From f3900cdd2a118831f2d21627d5287525775c206b Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 29 Jan 2015 09:05:40 -0800
Subject: [PATCH 01/16] [Plot] Add PlotUpdater

Add PlotUpdater, which will track streaming data from within
the plot. Allows removal of the cache for WTD-751.
---
 .../features/plot/res/templates/plot.html     |  8 ++----
 platform/features/plot/src/PlotController.js  | 26 +++++++++++++++----
 2 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/platform/features/plot/res/templates/plot.html b/platform/features/plot/res/templates/plot.html
index 4d95150cab..5101438bd9 100644
--- a/platform/features/plot/res/templates/plot.html
+++ b/platform/features/plot/res/templates/plot.html
@@ -1,4 +1,3 @@
-<span ng-controller="TelemetryController as telemetry">
     <span ng-controller="PlotController as plot"
           ng-mouseleave="representation.showControls = false">
 
@@ -114,7 +113,7 @@
 
                 </div>
 
-                <span class="t-wait-spinner loading" ng-show="telemetry.isRequestPending()">
+                <span class="t-wait-spinner loading" ng-show="plot.isRequestPending">
                 </span>
             </div>
             <div ng-if="$last" class="gl-plot-axis-area gl-plot-x">
@@ -143,9 +142,6 @@
                 </div>
 
             </div>
-        </span>
-
-
+        </div>
     </span>
-</div>
 
diff --git a/platform/features/plot/src/PlotController.js b/platform/features/plot/src/PlotController.js
index 9b8c60b351..ceb04a8708 100644
--- a/platform/features/plot/src/PlotController.js
+++ b/platform/features/plot/src/PlotController.js
@@ -30,10 +30,11 @@ define(
          *
          * @constructor
          */
-        function PlotController($scope, telemetryFormatter) {
+        function PlotController($scope, telemetryFormatter, telemetrySubscriber) {
             var subPlotFactory = new SubPlotFactory(telemetryFormatter),
                 modeOptions = new PlotModeOptions([], subPlotFactory),
                 subplots = [],
+                subscription,
                 domainOffset;
 
             // Populate the scope with axis information (specifically, options
@@ -99,9 +100,18 @@ define(
                     .forEach(updateSubplot);
             }
 
-            $scope.$watch("telemetry.getTelemetryObjects()", setupModes);
-            $scope.$watch("telemetry.getMetadata()", setupAxes);
-            $scope.$on("telemetryUpdate", plotTelemetry);
+            function updateValues() {
+
+            }
+
+            // Create a new subscription; telemetrySubscriber gets
+            // to do the meaningful work here.
+            function subscribe(domainObject) {
+                subscription = domainObject && telemetrySubscriber.subscribe(
+                    domainObject,
+                    updateValues
+                );
+            }
 
             return {
                 /**
@@ -169,7 +179,13 @@ define(
                 /**
                  * Explicitly update all plots.
                  */
-                update: update
+                update: update,
+                /**
+                 * Check if a request is pending (to show the wait spinner)
+                 */
+                isRequestPending: function () {
+                    return false;
+                }
             };
         }
 

From b615a3c888f504b4f1fd3fcffe1a686f0f3092ba Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 29 Jan 2015 09:48:53 -0800
Subject: [PATCH 02/16] [Plot] Wire in updater

Wire in updater for use in plots (to cache values at
the plot level, allowing removal of a global cache to
reduce memory consumption for WTD-751.)
---
 platform/features/plot/src/PlotController.js  |  57 +++---
 .../features/plot/src/elements/PlotUpdater.js | 178 ++++++++++++++++++
 .../telemetry/src/TelemetrySubscription.js    |  25 +++
 3 files changed, 224 insertions(+), 36 deletions(-)
 create mode 100644 platform/features/plot/src/elements/PlotUpdater.js

diff --git a/platform/features/plot/src/PlotController.js b/platform/features/plot/src/PlotController.js
index ceb04a8708..05ba514a73 100644
--- a/platform/features/plot/src/PlotController.js
+++ b/platform/features/plot/src/PlotController.js
@@ -5,13 +5,13 @@
  */
 define(
     [
-        "./elements/PlotPreparer",
+        "./elements/PlotUpdater",
         "./elements/PlotPalette",
         "./elements/PlotAxis",
         "./modes/PlotModeOptions",
         "./SubPlotFactory"
     ],
-    function (PlotPreparer, PlotPalette, PlotAxis, PlotModeOptions, SubPlotFactory) {
+    function (PlotUpdater, PlotPalette, PlotAxis, PlotModeOptions, SubPlotFactory) {
         "use strict";
 
         var AXIS_DEFAULTS = [
@@ -34,6 +34,7 @@ define(
             var subPlotFactory = new SubPlotFactory(telemetryFormatter),
                 modeOptions = new PlotModeOptions([], subPlotFactory),
                 subplots = [],
+                updater,
                 subscription,
                 domainOffset;
 
@@ -46,38 +47,6 @@ define(
                 ];
             }
 
-            // Respond to newly-available telemetry data; update the
-            // drawing area accordingly.
-            function plotTelemetry() {
-                var prepared, datas, telemetry;
-
-                // Get a reference to the TelemetryController
-                telemetry = $scope.telemetry;
-
-                // Nothing to plot without TelemetryController
-                if (!telemetry) {
-                    return;
-                }
-
-                // Ensure axes have been initialized (we will want to
-                // get the active axis below)
-                if (!$scope.axes) {
-                    setupAxes(telemetry.getMetadata());
-                }
-
-                // Get data sets
-                datas = telemetry.getResponse();
-
-                // Prepare data sets for rendering
-                prepared = new PlotPreparer(
-                    datas,
-                    ($scope.axes[0].active || {}).key,
-                    ($scope.axes[1].active || {}).key
-                );
-
-                modeOptions.getModeHandler().plotTelemetry(prepared);
-            }
-
             // Trigger an update of a specific subplot;
             // used in a loop to update all subplots.
             function updateSubplot(subplot) {
@@ -100,19 +69,35 @@ define(
                     .forEach(updateSubplot);
             }
 
-            function updateValues() {
+            function recreateUpdater() {
+                updater = new PlotUpdater(
+                    subscription,
+                    ($scope.axes[0].active || {}).key,
+                    ($scope.axes[1].active || {}).key
+                );
+            }
 
+            function updateValues() {
+                modeOptions.getModeHandler().plotTelemetry(updater);
+                update();
             }
 
             // Create a new subscription; telemetrySubscriber gets
             // to do the meaningful work here.
             function subscribe(domainObject) {
+                if (subscription) {
+                    subscription.unsubscribe();
+                }
                 subscription = domainObject && telemetrySubscriber.subscribe(
                     domainObject,
                     updateValues
                 );
+                setupAxes(subscription.getMetadata());
+                recreateUpdater();
             }
 
+            $scope.$watch('domainObject', subscribe);
+
             return {
                 /**
                  * Get the color (as a style-friendly string) to use
@@ -166,7 +151,7 @@ define(
                  */
                 setMode: function (mode) {
                     modeOptions.setMode(mode);
-                    plotTelemetry();
+                    updateValues();
                 },
                 /**
                  * Get all individual plots contained within this Plot view.
diff --git a/platform/features/plot/src/elements/PlotUpdater.js b/platform/features/plot/src/elements/PlotUpdater.js
new file mode 100644
index 0000000000..1e60c4fe17
--- /dev/null
+++ b/platform/features/plot/src/elements/PlotUpdater.js
@@ -0,0 +1,178 @@
+/*global define,Float32Array*/
+
+/**
+ * Prepares data to be rendered in a GL Plot. Handles
+ * the conversion from data API to displayable buffers.
+ */
+define(
+    function () {
+        'use strict';
+
+        var MAX_POINTS = 86400,
+            INITIAL_SIZE = 675; // 1/128 of MAX_POINTS
+
+        function identity(x) { return x; }
+
+        /**
+         * The PlotPreparer is responsible for handling data sets and
+         * preparing them to be rendered. It creates a WebGL-plottable
+         * Float32Array for each trace, and tracks the boundaries of the
+         * data sets (since this is convenient to do during the same pass).
+         * @constructor
+         * @param {Telemetry[]} datas telemetry data objects
+         * @param {string} domain the key to use when looking up domain values
+         * @param {string} range the key to use when looking up range values
+         */
+        function PlotUpdater(subscription, domain, range) {
+            var max = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY],
+                min = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY],
+                x,
+                y,
+                domainOffset,
+                buffers = {},
+                lengths = {},
+                bufferArray;
+
+            function ensureBufferSize(buffer, id, index) {
+                // Check if we don't have enough room
+                if (index > buffer.length / 2) {
+                    // If we don't, can we expand?
+                    if (index < MAX_POINTS) {
+                        // Double the buffer size
+                        buffer = buffers[id] =
+                                new Float32Array(buffer, 0, buffer.length * 2);
+                    } else {
+                        // Just shift the existing buffer
+                        buffer.copyWithin(0, 2);
+                    }
+                }
+
+                return buffer;
+            }
+
+            function addData(obj) {
+                var id = obj.getId(),
+                    index = lengths[id],
+                    buffer = buffers[id],
+                    domainValue = subscription.getDomainValue(obj),
+                    rangeValue = subscription.getRangeValue(obj);
+
+                if (domainValue !== undefined && rangeValue !== undefined &&
+                        (index < 1 || domainValue !== buffer[index * 2 - 2])) {
+                    // Use the first observed domain value as a domainOffset
+                    domainOffset = domainOffset !== undefined ?
+                            domainOffset : domainValue;
+                    // Ensure there is space for the new buffer
+                    buffer = ensureBufferSize(buffer, id, index);
+                    // Account for shifting that may have occurred
+                    index = Math.min(index, MAX_POINTS - 2);
+                    // Update the buffer
+                    buffer[index * 2] = domainValue - domainOffset;
+                    buffer[index * 2 + 1] = rangeValue;
+                    // Update length
+                    lengths[id] = Math.min(index + 1, MAX_POINTS);
+                    // Observe max/min range values
+                    max[1] = Math.max(max[1], rangeValue);
+                    min[1] = Math.min(min[1], rangeValue);
+                }
+
+                return buffer;
+            }
+
+            function updateDomainExtrema(objects) {
+                max[0] = Number.NEGATIVE_INFINITY;
+                min[0] = Number.POSITIVE_INFINITY;
+                objects.forEach(function (obj) {
+                    var id = obj.getId(),
+                        buffer = buffers[id],
+                        length = lengths[id],
+                        value = buffer[length * 2 - 2] + domainOffset;
+                    max[0] = Math.max(value, max[0]);
+                    min[0] = Math.min(value, min[0]);
+                });
+            }
+
+            function padRange() {
+                // If range is empty, add some padding
+                if (max[1] === min[1]) {
+                    max[1] = max[1] + 1.0;
+                    min[1] = min[1] - 1.0;
+                }
+            }
+
+            function update() {
+                var objects = subscription.getTelemetryObjects();
+                bufferArray = objects.map(addData);
+                updateDomainExtrema(objects);
+                padRange();
+            }
+
+            function prepare(telemetryObject) {
+                var id = telemetryObject.getId();
+                lengths[id] = 0;
+                buffers[id] = new Float32Array(INITIAL_SIZE);
+            }
+
+            subscription.getTelemetryObjects().forEach(prepare);
+
+            return {
+                /**
+                 * Get the dimensions which bound all data in the provided
+                 * data sets. This is given as a two-element array where the
+                 * first element is domain, and second is range.
+                 * @returns {number[]} the dimensions which bound this data set
+                 */
+                getDimensions: function () {
+                    return [max[0] - min[0], max[1] - min[1]];
+                },
+                /**
+                 * Get the origin of this data set's boundary.
+                 * This is given as a two-element array where the
+                 * first element is domain, and second is range.
+                 * The domain value here is not adjusted by the domain offset.
+                 * @returns {number[]} the origin of this data set's boundary
+                 */
+                getOrigin: function () {
+                    return min;
+                },
+                /**
+                 * Get the domain offset; this offset will have been subtracted
+                 * from all domain values in all buffers returned by this
+                 * preparer, in order to minimize loss-of-precision due to
+                 * conversion to the 32-bit float format needed by WebGL.
+                 * @returns {number} the domain offset
+                 */
+                getDomainOffset: function () {
+                    return domainOffset;
+                },
+                /**
+                 * Get all renderable buffers for this data set. This will
+                 * be returned as an array which can be correlated back to
+                 * the provided telemetry data objects (from the constructor
+                 * call) by index.
+                 *
+                 * Internally, these are flattened; each buffer contains a
+                 * sequence of alternating domain and range values.
+                 *
+                 * All domain values in all buffers will have been adjusted
+                 * from their original values by subtraction of the domain
+                 * offset; this minimizes loss-of-precision resulting from
+                 * the conversion to 32-bit floats, which may otherwise
+                 * cause aliasing artifacts (particularly for timestamps)
+                 *
+                 * @returns {Float32Array[]} the buffers for these traces
+                 */
+                getBuffers: function () {
+                    return buffers;
+                },
+                /**
+                 * Update with latest data.
+                 */
+                update: update
+            };
+        }
+
+        return PlotUpdater;
+
+    }
+);
\ No newline at end of file
diff --git a/platform/telemetry/src/TelemetrySubscription.js b/platform/telemetry/src/TelemetrySubscription.js
index 5e929d8ee4..e0abaa2668 100644
--- a/platform/telemetry/src/TelemetrySubscription.js
+++ b/platform/telemetry/src/TelemetrySubscription.js
@@ -30,6 +30,7 @@ define(
             var unsubscribePromise,
                 latestValues = {},
                 telemetryObjects = [],
+                metadatas,
                 updatePending;
 
             // Look up domain objects which have telemetry capabilities.
@@ -96,6 +97,14 @@ define(
                 });
             }
 
+            // Look up metadata associated with an object's telemetry
+            function lookupMetadata(domainObject) {
+                var telemetryCapability =
+                    domainObject.getCapability("telemetry");
+                return telemetryCapability &&
+                        telemetryCapability.getMetadata();
+            }
+
             // Prepare subscriptions to all relevant telemetry-providing
             // domain objects.
             function subscribeAll(domainObjects) {
@@ -108,6 +117,7 @@ define(
             // to return a non-Promise to simplify usage elsewhere.
             function cacheObjectReferences(objects) {
                 telemetryObjects = objects;
+                metadatas = objects.map(lookupMetadata);
                 return objects;
             }
 
@@ -189,6 +199,21 @@ define(
                  */
                 getTelemetryObjects: function () {
                     return telemetryObjects;
+                },
+                /**
+                 * Get all telemetry metadata associated with
+                 * telemetry-providing domain objects managed by
+                 * this controller.
+                 *
+                 * This will ordered in the
+                 * same manner as `getTelemetryObjects()` or
+                 * `getResponse()`; that is, the metadata at a
+                 * given index will correspond to the telemetry-providing
+                 * domain object at the same index.
+                 * @returns {Array} an array of metadata objects
+                 */
+                getMetadata: function () {
+                    return metadatas;
                 }
             };
         }

From 57f20ba11045329678fea1c57da61f7aa737ae43 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 29 Jan 2015 11:19:22 -0800
Subject: [PATCH 03/16] [Plot] Amend plot updater

Amend plot updater to correctly expose information for real-time
plotting without history, allowing removal of cache to free
memory; WTD-751.
---
 .../features/plot/src/elements/PlotUpdater.js | 44 ++++++++++++-------
 1 file changed, 27 insertions(+), 17 deletions(-)

diff --git a/platform/features/plot/src/elements/PlotUpdater.js b/platform/features/plot/src/elements/PlotUpdater.js
index 1e60c4fe17..9da169f6b6 100644
--- a/platform/features/plot/src/elements/PlotUpdater.js
+++ b/platform/features/plot/src/elements/PlotUpdater.js
@@ -31,7 +31,8 @@ define(
                 domainOffset,
                 buffers = {},
                 lengths = {},
-                bufferArray;
+                lengthArray = [],
+                bufferArray = [];
 
             function ensureBufferSize(buffer, id, index) {
                 // Check if we don't have enough room
@@ -52,11 +53,16 @@ define(
 
             function addData(obj) {
                 var id = obj.getId(),
-                    index = lengths[id],
+                    index = lengths[id] || 0,
                     buffer = buffers[id],
                     domainValue = subscription.getDomainValue(obj),
                     rangeValue = subscription.getRangeValue(obj);
 
+                if (!buffer) {
+                    buffer = new Float32Array(INITIAL_SIZE);
+                    buffers[id] = buffer;
+                }
+
                 if (domainValue !== undefined && rangeValue !== undefined &&
                         (index < 1 || domainValue !== buffer[index * 2 - 2])) {
                     // Use the first observed domain value as a domainOffset
@@ -86,31 +92,28 @@ define(
                     var id = obj.getId(),
                         buffer = buffers[id],
                         length = lengths[id],
-                        value = buffer[length * 2 - 2] + domainOffset;
-                    max[0] = Math.max(value, max[0]);
-                    min[0] = Math.min(value, min[0]);
+                        low = buffer[0] + domainOffset,
+                        high = buffer[length * 2 - 2] + domainOffset;
+                    max[0] = Math.max(high, max[0]);
+                    min[0] = Math.min(low, min[0]);
                 });
             }
 
-            function padRange() {
-                // If range is empty, add some padding
-                if (max[1] === min[1]) {
-                    max[1] = max[1] + 1.0;
-                    min[1] = min[1] - 1.0;
-                }
-            }
-
             function update() {
                 var objects = subscription.getTelemetryObjects();
                 bufferArray = objects.map(addData);
+                lengthArray = objects.map(function (obj) {
+                    return lengths[obj.getId()];
+                });
                 updateDomainExtrema(objects);
-                padRange();
             }
 
             function prepare(telemetryObject) {
                 var id = telemetryObject.getId();
                 lengths[id] = 0;
                 buffers[id] = new Float32Array(INITIAL_SIZE);
+                lengthArray.push(lengths[id]);
+                bufferArray.push(buffers[id]);
             }
 
             subscription.getTelemetryObjects().forEach(prepare);
@@ -123,7 +126,10 @@ define(
                  * @returns {number[]} the dimensions which bound this data set
                  */
                 getDimensions: function () {
-                    return [max[0] - min[0], max[1] - min[1]];
+                    // Pad range if necessary
+                    return (max[1] === min[1]) ?
+                            [max[0] - min[0], 2.0 ] :
+                            [max[0] - min[0], max[1] - min[1]];
                 },
                 /**
                  * Get the origin of this data set's boundary.
@@ -133,7 +139,8 @@ define(
                  * @returns {number[]} the origin of this data set's boundary
                  */
                 getOrigin: function () {
-                    return min;
+                    // Pad range if necessary
+                    return (max[1] === min[1]) ? [ min[0], min[1] - 1.0 ] : min;
                 },
                 /**
                  * Get the domain offset; this offset will have been subtracted
@@ -163,7 +170,10 @@ define(
                  * @returns {Float32Array[]} the buffers for these traces
                  */
                 getBuffers: function () {
-                    return buffers;
+                    return bufferArray;
+                },
+                getLength: function (index) {
+                    return lengthArray;
                 },
                 /**
                  * Update with latest data.

From 5e2e0b4116632f8a615f6ad5e18572a79886c2f4 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 29 Jan 2015 11:22:31 -0800
Subject: [PATCH 04/16] [Plot] Fix wiring on plot updater

Fix usages of the plot updater, introduced to track real-time
telemetry to remove the need to cache values elsewhere. This
allows memory usage to be decreased for WTD-751.
---
 platform/features/plot/bundle.json                  |  2 +-
 platform/features/plot/res/templates/plot.html      |  2 +-
 platform/features/plot/src/PlotController.js        | 11 ++++++++---
 platform/features/plot/src/modes/PlotOverlayMode.js |  2 +-
 platform/features/plot/src/modes/PlotStackMode.js   |  2 +-
 5 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/platform/features/plot/bundle.json b/platform/features/plot/bundle.json
index b9d21894bb..b32a237d10 100644
--- a/platform/features/plot/bundle.json
+++ b/platform/features/plot/bundle.json
@@ -21,7 +21,7 @@
             {
                 "key": "PlotController",
                 "implementation": "PlotController.js",
-                "depends": [ "$scope", "telemetryFormatter" ]
+                "depends": [ "$scope", "telemetryFormatter", "telemetrySubscriber" ]
             }
         ]
     }
diff --git a/platform/features/plot/res/templates/plot.html b/platform/features/plot/res/templates/plot.html
index 5101438bd9..1f88ff9dd6 100644
--- a/platform/features/plot/res/templates/plot.html
+++ b/platform/features/plot/res/templates/plot.html
@@ -113,7 +113,7 @@
 
                 </div>
 
-                <span class="t-wait-spinner loading" ng-show="plot.isRequestPending">
+                <span class="t-wait-spinner loading" ng-show="plot.isRequestPending()">
                 </span>
             </div>
             <div ng-if="$last" class="gl-plot-axis-area gl-plot-x">
diff --git a/platform/features/plot/src/PlotController.js b/platform/features/plot/src/PlotController.js
index 05ba514a73..a812a6ce25 100644
--- a/platform/features/plot/src/PlotController.js
+++ b/platform/features/plot/src/PlotController.js
@@ -78,7 +78,10 @@ define(
             }
 
             function updateValues() {
-                modeOptions.getModeHandler().plotTelemetry(updater);
+                if (updater) {
+                    updater.update();
+                    modeOptions.getModeHandler().plotTelemetry(updater);
+                }
                 update();
             }
 
@@ -92,8 +95,10 @@ define(
                     domainObject,
                     updateValues
                 );
-                setupAxes(subscription.getMetadata());
-                recreateUpdater();
+                if (subscription) {
+                    setupAxes(subscription.getMetadata());
+                    recreateUpdater();
+                }
             }
 
             $scope.$watch('domainObject', subscribe);
diff --git a/platform/features/plot/src/modes/PlotOverlayMode.js b/platform/features/plot/src/modes/PlotOverlayMode.js
index de4445961e..342bbcc1c3 100644
--- a/platform/features/plot/src/modes/PlotOverlayMode.js
+++ b/platform/features/plot/src/modes/PlotOverlayMode.js
@@ -38,7 +38,7 @@ define(
                     return {
                         buffer: buf,
                         color: PlotPalette.getFloatColor(i),
-                        points: buf.length / 2
+                        points: prepared.getLength(i)
                     };
                 });
 
diff --git a/platform/features/plot/src/modes/PlotStackMode.js b/platform/features/plot/src/modes/PlotStackMode.js
index 25ad2e0304..5fe3895a61 100644
--- a/platform/features/plot/src/modes/PlotStackMode.js
+++ b/platform/features/plot/src/modes/PlotStackMode.js
@@ -35,7 +35,7 @@ define(
                 subplot.getDrawingObject().lines = [{
                     buffer: buffer,
                     color: PlotPalette.getFloatColor(0),
-                    points: buffer.length / 2
+                    points: prepared.getLength(index)
                 }];
 
                 subplot.update();

From 230ba3eb5c17b4c93a171e6f93be3eff1fccb4c3 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 29 Jan 2015 12:10:00 -0800
Subject: [PATCH 05/16] [Plot] Add comments

Add comments to plot code introduced to handle
subscribed telemetry only, to work around removal
of the cache to reduce memory usage, WTD-751.
---
 platform/features/plot/src/PlotController.js  |  3 ++
 .../features/plot/src/elements/PlotUpdater.js | 29 ++++++++++++++++---
 2 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/platform/features/plot/src/PlotController.js b/platform/features/plot/src/PlotController.js
index a812a6ce25..74de65d1aa 100644
--- a/platform/features/plot/src/PlotController.js
+++ b/platform/features/plot/src/PlotController.js
@@ -69,6 +69,8 @@ define(
                     .forEach(updateSubplot);
             }
 
+            // Reinstantiate the plot updater (e.g. because we have a
+            // new subscription.) This will clear the plot.
             function recreateUpdater() {
                 updater = new PlotUpdater(
                     subscription,
@@ -77,6 +79,7 @@ define(
                 );
             }
 
+            // Handle new telemetry data in this plot
             function updateValues() {
                 if (updater) {
                     updater.update();
diff --git a/platform/features/plot/src/elements/PlotUpdater.js b/platform/features/plot/src/elements/PlotUpdater.js
index 9da169f6b6..b074765bbd 100644
--- a/platform/features/plot/src/elements/PlotUpdater.js
+++ b/platform/features/plot/src/elements/PlotUpdater.js
@@ -11,8 +11,6 @@ define(
         var MAX_POINTS = 86400,
             INITIAL_SIZE = 675; // 1/128 of MAX_POINTS
 
-        function identity(x) { return x; }
-
         /**
          * The PlotPreparer is responsible for handling data sets and
          * preparing them to be rendered. It creates a WebGL-plottable
@@ -34,14 +32,20 @@ define(
                 lengthArray = [],
                 bufferArray = [];
 
+            // Make sure there is enough space in a buffer to accomodate a
+            // new point at the specified index. This will updates buffers[id]
+            // if necessary.
             function ensureBufferSize(buffer, id, index) {
                 // Check if we don't have enough room
                 if (index > buffer.length / 2) {
                     // If we don't, can we expand?
                     if (index < MAX_POINTS) {
                         // Double the buffer size
-                        buffer = buffers[id] =
-                                new Float32Array(buffer, 0, buffer.length * 2);
+                        buffer = buffers[id] = new Float32Array(
+                            buffer,
+                            0,
+                            buffer.length * 2
+                        );
                     } else {
                         // Just shift the existing buffer
                         buffer.copyWithin(0, 2);
@@ -51,6 +55,7 @@ define(
                 return buffer;
             }
 
+            // Add data to the plot.
             function addData(obj) {
                 var id = obj.getId(),
                     index = lengths[id] || 0,
@@ -58,11 +63,14 @@ define(
                     domainValue = subscription.getDomainValue(obj),
                     rangeValue = subscription.getRangeValue(obj);
 
+                // If we don't already have a data buffer for that ID,
+                // make one.
                 if (!buffer) {
                     buffer = new Float32Array(INITIAL_SIZE);
                     buffers[id] = buffer;
                 }
 
+                // Make sure there's data to add, and then add it
                 if (domainValue !== undefined && rangeValue !== undefined &&
                         (index < 1 || domainValue !== buffer[index * 2 - 2])) {
                     // Use the first observed domain value as a domainOffset
@@ -85,6 +93,7 @@ define(
                 return buffer;
             }
 
+            // Update min/max domain values for these objects
             function updateDomainExtrema(objects) {
                 max[0] = Number.NEGATIVE_INFINITY;
                 min[0] = Number.POSITIVE_INFINITY;
@@ -99,6 +108,7 @@ define(
                 });
             }
 
+            // Handle new telemetry data
             function update() {
                 var objects = subscription.getTelemetryObjects();
                 bufferArray = objects.map(addData);
@@ -108,6 +118,7 @@ define(
                 updateDomainExtrema(objects);
             }
 
+            // Prepare buffers and related state for this object
             function prepare(telemetryObject) {
                 var id = telemetryObject.getId();
                 lengths[id] = 0;
@@ -116,6 +127,9 @@ define(
                 bufferArray.push(buffers[id]);
             }
 
+            // Initially prepare state for these objects.
+            // Note that this may be an empty array at this time,
+            // so we also need to check during update cycles.
             subscription.getTelemetryObjects().forEach(prepare);
 
             return {
@@ -172,6 +186,13 @@ define(
                 getBuffers: function () {
                     return bufferArray;
                 },
+                /**
+                 * Get the number of points in the buffer with the specified
+                 * index. Buffers are padded to minimize memory allocations,
+                 * so user code will need this information to know how much
+                 * data to plot.
+                 * @returns {number} the number of points in this buffer
+                 */
                 getLength: function (index) {
                     return lengthArray;
                 },

From a0137b341eac8e0093f274f6b141557535dfdc6e Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 29 Jan 2015 12:27:04 -0800
Subject: [PATCH 06/16] [Plot] Fix bug for panels

Fix bug wherein number of points-to-plot is misreported
with multiple traces in a plot; clean up on modifications
to plot to self-cache streaming telemetry, to remove
other cache, WTD-751.
---
 platform/features/plot/src/PlotController.js       | 13 +++++++++----
 platform/features/plot/src/elements/PlotUpdater.js |  2 +-
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/platform/features/plot/src/PlotController.js b/platform/features/plot/src/PlotController.js
index 74de65d1aa..0050a5a22e 100644
--- a/platform/features/plot/src/PlotController.js
+++ b/platform/features/plot/src/PlotController.js
@@ -34,6 +34,7 @@ define(
             var subPlotFactory = new SubPlotFactory(telemetryFormatter),
                 modeOptions = new PlotModeOptions([], subPlotFactory),
                 subplots = [],
+                cachedObjects = [],
                 updater,
                 subscription,
                 domainOffset;
@@ -56,10 +57,13 @@ define(
             // Set up available modes (stacked/overlaid), based on the
             // set of telemetry objects in this plot view.
             function setupModes(telemetryObjects) {
-                modeOptions = new PlotModeOptions(
-                    telemetryObjects || [],
-                    subPlotFactory
-                );
+                if (cachedObjects !== telemetryObjects) {
+                    cachedObjects = telemetryObjects;
+                    modeOptions = new PlotModeOptions(
+                        telemetryObjects || [],
+                        subPlotFactory
+                    );
+                }
             }
 
             // Update all sub-plots
@@ -81,6 +85,7 @@ define(
 
             // Handle new telemetry data in this plot
             function updateValues() {
+                setupModes(subscription.getTelemetryObjects());
                 if (updater) {
                     updater.update();
                     modeOptions.getModeHandler().plotTelemetry(updater);
diff --git a/platform/features/plot/src/elements/PlotUpdater.js b/platform/features/plot/src/elements/PlotUpdater.js
index b074765bbd..f59fda4e52 100644
--- a/platform/features/plot/src/elements/PlotUpdater.js
+++ b/platform/features/plot/src/elements/PlotUpdater.js
@@ -194,7 +194,7 @@ define(
                  * @returns {number} the number of points in this buffer
                  */
                 getLength: function (index) {
-                    return lengthArray;
+                    return lengthArray[index] || 0;
                 },
                 /**
                  * Update with latest data.

From 4fb750c0e01d7f335653ee48f0f4fc7bef749ad1 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 29 Jan 2015 12:34:58 -0800
Subject: [PATCH 07/16] [Plot] Update/suppress specs

Update specs and suppress failures; intermediate commit
for updates to plot for WTD-751.
---
 .../features/plot/test/PlotControllerSpec.js  | 38 +++++--------------
 .../plot/test/modes/PlotOverlayModeSpec.js    |  3 +-
 .../plot/test/modes/PlotStackModeSpec.js      |  3 +-
 .../test/TelemetrySubscriptionSpec.js         |  2 +-
 4 files changed, 15 insertions(+), 31 deletions(-)

diff --git a/platform/features/plot/test/PlotControllerSpec.js b/platform/features/plot/test/PlotControllerSpec.js
index c5c7d45005..dd73231e62 100644
--- a/platform/features/plot/test/PlotControllerSpec.js
+++ b/platform/features/plot/test/PlotControllerSpec.js
@@ -1,4 +1,4 @@
-/*global define,Promise,describe,it,expect,beforeEach,waitsFor,jasmine*/
+/*global define,Promise,describe,it,expect,xit,beforeEach,waitsFor,jasmine*/
 
 /**
  * MergeModelsSpec. Created by vwoeltje on 11/6/14.
@@ -11,7 +11,7 @@ define(
         describe("The plot controller", function () {
             var mockScope,
                 mockFormatter,
-                mockTelemetry, // mock telemetry controller
+                mockSubscriber,
                 mockData,
                 mockDomainObject,
                 controller;
@@ -27,10 +27,6 @@ define(
                     "formatter",
                     [ "formatDomainValue", "formatRangeValue" ]
                 );
-                mockTelemetry = jasmine.createSpyObj(
-                    "telemetry",
-                    [ "getResponse", "getMetadata" ]
-                );
                 mockData = jasmine.createSpyObj(
                     "data",
                     [ "getPointCount", "getDomainValue", "getRangeValue" ]
@@ -39,21 +35,16 @@ define(
                     "domainObject",
                     [ "getId", "getModel", "getCapability" ]
                 );
+                mockSubscriber = jasmine.createSpyObj(
+                    "telemetrySubscriber",
+                    ["subscribe"]
+                );
 
-                mockScope.telemetry = mockTelemetry;
-                mockTelemetry.getResponse.andReturn([mockData]);
                 mockData.getPointCount.andReturn(2);
                 mockData.getDomainValue.andCallFake(echo);
                 mockData.getRangeValue.andCallFake(echo);
 
-                controller = new PlotController(mockScope, mockFormatter);
-            });
-
-            it("listens for telemetry updates", function () {
-                expect(mockScope.$on).toHaveBeenCalledWith(
-                    "telemetryUpdate",
-                    jasmine.any(Function)
-                );
+                controller = new PlotController(mockScope, mockFormatter, mockSubscriber);
             });
 
             it("provides plot colors", function () {
@@ -66,16 +57,7 @@ define(
                     .not.toEqual(controller.getColor(1));
             });
 
-            it("does not fail if telemetry controller is not in scope", function () {
-                mockScope.telemetry = undefined;
-
-                // Broadcast data
-                mockScope.$on.mostRecentCall.args[1]();
-
-                // Just want to not have an exception
-            });
-
-            it("draws lines when data becomes available", function () {
+            xit("draws lines when data becomes available", function () {
                 // Verify precondition
                 controller.getSubPlots().forEach(function (subplot) {
                     expect(subplot.getDrawingObject().lines)
@@ -96,7 +78,7 @@ define(
             });
 
 
-            it("changes modes depending on number of objects", function () {
+            xit("changes modes depending on number of objects", function () {
                 var expectedWatch = "telemetry.getTelemetryObjects()",
                     watchFunction;
 
@@ -131,7 +113,7 @@ define(
                     .toEqual(jasmine.any(String));
             });
 
-            it("allows plot mode to be changed", function () {
+            xit("allows plot mode to be changed", function () {
                 expect(function () {
                     controller.setMode(controller.getMode());
                 }).not.toThrow();
diff --git a/platform/features/plot/test/modes/PlotOverlayModeSpec.js b/platform/features/plot/test/modes/PlotOverlayModeSpec.js
index 30a29ab1e3..8c2922cf22 100644
--- a/platform/features/plot/test/modes/PlotOverlayModeSpec.js
+++ b/platform/features/plot/test/modes/PlotOverlayModeSpec.js
@@ -57,7 +57,7 @@ define(
                 // Prepared telemetry data
                 mockPrepared = jasmine.createSpyObj(
                     "prepared",
-                    [ "getDomainOffset", "getOrigin", "getDimensions", "getBuffers" ]
+                    [ "getDomainOffset", "getOrigin", "getDimensions", "getBuffers", "getLength" ]
                 );
 
                 mockSubPlotFactory.createSubPlot.andCallFake(createMockSubPlot);
@@ -68,6 +68,7 @@ define(
                 mockPrepared.getDomainOffset.andReturn(1234);
                 mockPrepared.getOrigin.andReturn([10, 10]);
                 mockPrepared.getDimensions.andReturn([500, 500]);
+                mockPrepared.getLength.andReturn(3);
 
                 // Clear out drawing objects
                 testDrawingObjects = [];
diff --git a/platform/features/plot/test/modes/PlotStackModeSpec.js b/platform/features/plot/test/modes/PlotStackModeSpec.js
index c44cd8c8a3..4c2c11a308 100644
--- a/platform/features/plot/test/modes/PlotStackModeSpec.js
+++ b/platform/features/plot/test/modes/PlotStackModeSpec.js
@@ -57,7 +57,7 @@ define(
                 // Prepared telemetry data
                 mockPrepared = jasmine.createSpyObj(
                     "prepared",
-                    [ "getDomainOffset", "getOrigin", "getDimensions", "getBuffers" ]
+                    [ "getDomainOffset", "getOrigin", "getDimensions", "getBuffers", "getLength" ]
                 );
 
                 mockSubPlotFactory.createSubPlot.andCallFake(createMockSubPlot);
@@ -68,6 +68,7 @@ define(
                 mockPrepared.getDomainOffset.andReturn(1234);
                 mockPrepared.getOrigin.andReturn([10, 10]);
                 mockPrepared.getDimensions.andReturn([500, 500]);
+                mockPrepared.getLength.andReturn(3);
 
                 // Objects that will be drawn to in sub-plots
                 testDrawingObjects = [];
diff --git a/platform/telemetry/test/TelemetrySubscriptionSpec.js b/platform/telemetry/test/TelemetrySubscriptionSpec.js
index 44bd6c4d20..3a02632e47 100644
--- a/platform/telemetry/test/TelemetrySubscriptionSpec.js
+++ b/platform/telemetry/test/TelemetrySubscriptionSpec.js
@@ -33,7 +33,7 @@ define(
                 mockCallback = jasmine.createSpy("callback");
                 mockTelemetry = jasmine.createSpyObj(
                     "telemetry",
-                    ["subscribe"]
+                    ["subscribe", "getMetadata"]
                 );
                 mockUnsubscribe = jasmine.createSpy("unsubscribe");
                 mockSeries = jasmine.createSpyObj(

From b1485e716c9bee7a2519c51f31a102ebd716a400 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Fri, 30 Jan 2015 12:26:42 -0800
Subject: [PATCH 08/16] [Plot] Fix disappearing plot bug

Fix buffer resize operation as plots fill, WTD-782.
---
 .../features/plot/src/elements/PlotUpdater.js     | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/platform/features/plot/src/elements/PlotUpdater.js b/platform/features/plot/src/elements/PlotUpdater.js
index f59fda4e52..312f625963 100644
--- a/platform/features/plot/src/elements/PlotUpdater.js
+++ b/platform/features/plot/src/elements/PlotUpdater.js
@@ -32,20 +32,23 @@ define(
                 lengthArray = [],
                 bufferArray = [];
 
+            // Double the size of a Float32Array
+            function doubleSize(buffer) {
+                var doubled = new Float32Array(buffer.length * 2);
+                doubled.set(buffer); // Copy contents of original
+                return doubled;
+            }
+
             // Make sure there is enough space in a buffer to accomodate a
             // new point at the specified index. This will updates buffers[id]
             // if necessary.
             function ensureBufferSize(buffer, id, index) {
                 // Check if we don't have enough room
-                if (index > buffer.length / 2) {
+                if (index > (buffer.length / 2 - 1)) {
                     // If we don't, can we expand?
                     if (index < MAX_POINTS) {
                         // Double the buffer size
-                        buffer = buffers[id] = new Float32Array(
-                            buffer,
-                            0,
-                            buffer.length * 2
-                        );
+                        buffer = buffers[id] = doubleSize(buffer);
                     } else {
                         // Just shift the existing buffer
                         buffer.copyWithin(0, 2);

From 01d66bbf93d09323dcd55aec9534dbd7b3117d8b Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Fri, 30 Jan 2015 14:40:01 -0800
Subject: [PATCH 09/16] [Telemetry] Add test case for lossless subscription

Add a test case for subscriptions which should be handled
losslessly (that is, which should notify subscribers once
per data event, not once per execution cycle.) This
test case reflects the underlying cause for WTD-784.
---
 .../test/TelemetrySubscriptionSpec.js         | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/platform/telemetry/test/TelemetrySubscriptionSpec.js b/platform/telemetry/test/TelemetrySubscriptionSpec.js
index 3a02632e47..8aca781f40 100644
--- a/platform/telemetry/test/TelemetrySubscriptionSpec.js
+++ b/platform/telemetry/test/TelemetrySubscriptionSpec.js
@@ -120,6 +120,47 @@ define(
                 // Should have no objects
                 expect(subscription.getTelemetryObjects()).toEqual([]);
             });
+
+            // This test case corresponds to plot usage of
+            // telemetrySubscription, where failure to callback
+            // once-per-update results in loss of data, WTD-784
+            it("fires one event per update if requested", function () {
+                var i, domains = [], ranges = [], lastCall;
+
+                // Clear out the subscription from beforeEach
+                subscription.unsubscribe();
+                // Create a subscription which does not drop events
+                subscription = new TelemetrySubscription(
+                    mockQ,
+                    mockTimeout,
+                    mockDomainObject,
+                    mockCallback,
+                    true // Don't drop updates!
+                );
+
+                // Snapshot getDomainValue, getRangeValue at time of callback
+                mockCallback.andCallFake(function () {
+                    domains.push(subscription.getDomainValue(mockDomainObject));
+                    ranges.push(subscription.getRangeValue(mockDomainObject));
+                });
+
+                // Send 100 updates
+                for (i = 0; i < 100; i += 1) {
+                    // Return different values to verify later
+                    mockSeries.getDomainValue.andReturn(i);
+                    mockSeries.getRangeValue.andReturn(i * 2);
+                    mockTelemetry.subscribe.mostRecentCall.args[0](mockSeries);
+                }
+
+                // Fire all timeouts that get scheduled
+                while (mockTimeout.mostRecentCall !== lastCall) {
+                    lastCall = mockTimeout.mostRecentCall;
+                    lastCall.args[0]();
+                }
+
+                // Should have only triggered the
+                expect(mockCallback.calls.length).toEqual(100);
+            });
         });
     }
 );
\ No newline at end of file

From acf4261a0848f56931ddbb2fac232d50d5d4c101 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Fri, 30 Jan 2015 15:16:36 -0800
Subject: [PATCH 10/16] [Telemetry] Add data structure specs

Add specs for data structures which will support resolution
of WTD-784 by retaining all data not yet received by callbacks
(instead of just the very latest) such that plots can ensure
they do not miss streaming data.
---
 platform/telemetry/src/TelemetryQueue.js      |  0
 .../telemetry/src/TelemetrySubscription.js    | 29 ++++++++--
 platform/telemetry/src/TelemetryTable.js      |  0
 platform/telemetry/test/TelemetryQueueSpec.js | 55 +++++++++++++++++++
 platform/telemetry/test/TelemetryTableSpec.js | 53 ++++++++++++++++++
 platform/telemetry/test/suite.json            |  4 +-
 6 files changed, 134 insertions(+), 7 deletions(-)
 create mode 100644 platform/telemetry/src/TelemetryQueue.js
 create mode 100644 platform/telemetry/src/TelemetryTable.js
 create mode 100644 platform/telemetry/test/TelemetryQueueSpec.js
 create mode 100644 platform/telemetry/test/TelemetryTableSpec.js

diff --git a/platform/telemetry/src/TelemetryQueue.js b/platform/telemetry/src/TelemetryQueue.js
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/platform/telemetry/src/TelemetrySubscription.js b/platform/telemetry/src/TelemetrySubscription.js
index e0abaa2668..046d00dc80 100644
--- a/platform/telemetry/src/TelemetrySubscription.js
+++ b/platform/telemetry/src/TelemetrySubscription.js
@@ -1,8 +1,8 @@
 /*global define*/
 
 define(
-    [],
-    function () {
+    ['./TelemetryQueue', './TelemetryTable'],
+    function (TelemetryQueue, TelemetryTable) {
         "use strict";
 
 
@@ -25,11 +25,16 @@ define(
          *        associated telemetry data is of interest
          * @param {Function} callback a function to invoke
          *        when new data has become available.
+         * @param {boolean} lossless true if callback should be invoked
+         *        once with every data point available; otherwise, multiple
+         *        data events in a short period of time will only invoke
+         *        the callback once, with access to the latest data
          */
-        function TelemetrySubscription($q, $timeout, domainObject, callback) {
+        function TelemetrySubscription($q, $timeout, domainObject, callback, lossless) {
             var unsubscribePromise,
                 latestValues = {},
                 telemetryObjects = [],
+                pool = lossless ? new TelemetryQueue() : new TelemetryTable(),
                 metadatas,
                 updatePending;
 
@@ -56,10 +61,22 @@ define(
                 });
             }
 
+            function updateValuesFromPool() {
+                var values = pool.poll();
+                Object.keys(values).forEach(function (k) {
+                    latestValues[k] = values[k];
+                });
+            }
+
             // Invoke the observer callback to notify that new streaming
             // data has become available.
             function fireCallback() {
-                callback();
+                // Play back from queue if we are lossless
+                while (!pool.isEmpty()) {
+                    updateValuesFromPool();
+                    callback();
+                }
+
                 // Clear the pending flag so that future updates will
                 // schedule this callback.
                 updatePending = false;
@@ -80,10 +97,10 @@ define(
 
                 // Update the latest-value table
                 if (count > 0) {
-                    latestValues[domainObject.getId()] = {
+                    pool.put(domainObject.getId(), {
                         domain: telemetry.getDomainValue(count - 1),
                         range: telemetry.getRangeValue(count - 1)
-                    };
+                    });
                 }
             }
 
diff --git a/platform/telemetry/src/TelemetryTable.js b/platform/telemetry/src/TelemetryTable.js
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/platform/telemetry/test/TelemetryQueueSpec.js b/platform/telemetry/test/TelemetryQueueSpec.js
new file mode 100644
index 0000000000..ecdf9c376f
--- /dev/null
+++ b/platform/telemetry/test/TelemetryQueueSpec.js
@@ -0,0 +1,55 @@
+/*global define,Promise,describe,it,expect,beforeEach,waitsFor,jasmine*/
+
+define(
+    ["../src/TelemetryQueue"],
+    function (TelemetryQueue) {
+        "use strict";
+
+        describe("The telemetry queue", function () {
+            var queue;
+
+            beforeEach(function () {
+                // put, isEmpty, dequeue
+                queue = new TelemetryQueue();
+            });
+
+            it("stores elements by key", function () {
+                queue.put("a", { someKey: "some value" });
+                expect(queue.poll())
+                    .toEqual({ a: { someKey: "some value" }});
+            });
+
+            it("merges non-overlapping keys", function () {
+                queue.put("a", { someKey: "some value" });
+                queue.put("b", 42);
+                expect(queue.poll())
+                    .toEqual({ a: { someKey: "some value" }, b: 42 });
+            });
+
+            it("adds new objects for repeated keys", function () {
+                queue.put("a", { someKey: "some value" });
+                queue.put("a", { someKey: "some other value" });
+                queue.put("b", 42);
+                expect(queue.poll())
+                    .toEqual({ a: { someKey: "some value" }, b: 42 });
+                expect(queue.poll())
+                    .toEqual({ a: { someKey: "some other value" }  });
+            });
+
+            it("reports emptiness", function () {
+                expect(queue.isEmpty()).toBeTruthy();
+                queue.put("a", { someKey: "some value" });
+                queue.put("a", { someKey: "some other value" });
+                queue.put("b", 42);
+                expect(queue.isEmpty()).toBeFalsy();
+                queue.poll();
+                expect(queue.isEmpty()).toBeFalsy();
+                queue.poll();
+                expect(queue.isEmpty()).toBeTruthy();
+            });
+
+
+        });
+
+    }
+);
\ No newline at end of file
diff --git a/platform/telemetry/test/TelemetryTableSpec.js b/platform/telemetry/test/TelemetryTableSpec.js
new file mode 100644
index 0000000000..53da765aaa
--- /dev/null
+++ b/platform/telemetry/test/TelemetryTableSpec.js
@@ -0,0 +1,53 @@
+/*global define,Promise,describe,it,expect,beforeEach,waitsFor,jasmine*/
+
+define(
+    ["../src/TelemetryTable"],
+    function (TelemetryTable) {
+        "use strict";
+
+        describe("The telemetry table", function () {
+            var queue;
+
+            beforeEach(function () {
+                // put, isEmpty, dequeue
+                queue = new TelemetryTable();
+            });
+
+            it("stores elements by key", function () {
+                queue.put("a", { someKey: "some value" });
+                expect(queue.poll())
+                    .toEqual({ a: { someKey: "some value" }});
+            });
+
+            it("merges non-overlapping keys", function () {
+                queue.put("a", { someKey: "some value" });
+                queue.put("b", 42);
+                expect(queue.poll())
+                    .toEqual({ a: { someKey: "some value" }, b: 42 });
+            });
+
+            it("overwrites repeated keys", function () {
+                queue.put("a", { someKey: "some value" });
+                queue.put("a", { someKey: "some other value" });
+                queue.put("b", 42);
+                expect(queue.poll())
+                    .toEqual({ a: { someKey: "some other value" }, b: 42 });
+                expect(queue.poll())
+                    .toBeUndefined();
+            });
+
+            it("reports emptiness", function () {
+                expect(queue.isEmpty()).toBeTruthy();
+                queue.put("a", { someKey: "some value" });
+                queue.put("a", { someKey: "some other value" });
+                queue.put("b", 42);
+                expect(queue.isEmpty()).toBeFalsy();
+                queue.poll();
+                expect(queue.isEmpty()).toBeTruthy();
+            });
+
+
+        });
+
+    }
+);
\ No newline at end of file
diff --git a/platform/telemetry/test/suite.json b/platform/telemetry/test/suite.json
index 68110d0a6e..0ed5887ac5 100644
--- a/platform/telemetry/test/suite.json
+++ b/platform/telemetry/test/suite.json
@@ -3,6 +3,8 @@
     "TelemetryCapability",
     "TelemetryController",
     "TelemetryFormatter",
+    "TelemetryQueue",
     "TelemetrySubscriber",
-    "TelemetrySubscription"
+    "TelemetrySubscription",
+    "TelemetryTable"
 ]
\ No newline at end of file

From 590f4caa9761a1873aca5e9ff6a14e3fab5a6922 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Fri, 30 Jan 2015 15:34:18 -0800
Subject: [PATCH 11/16] [Telemetry] Implement subscription pools

Implement data structures which support lossless/lossy
behaviors for telemetry subscriptions (that is, allow
users of the telemetrySubscriber to decide whether or not
they are willing to drop updates in favor of only being
notified with the latest available values.) WTD-784.
---
 platform/telemetry/src/TelemetryQueue.js      | 71 +++++++++++++++++++
 platform/telemetry/src/TelemetrySubscriber.js |  9 ++-
 platform/telemetry/src/TelemetryTable.js      | 53 ++++++++++++++
 3 files changed, 131 insertions(+), 2 deletions(-)

diff --git a/platform/telemetry/src/TelemetryQueue.js b/platform/telemetry/src/TelemetryQueue.js
index e69de29bb2..e255e01206 100644
--- a/platform/telemetry/src/TelemetryQueue.js
+++ b/platform/telemetry/src/TelemetryQueue.js
@@ -0,0 +1,71 @@
+/*global define*/
+
+define(
+    [],
+    function () {
+        "use strict";
+
+        /**
+         * Supports TelemetrySubscription. Provides a simple data structure
+         * (with a pool-like interface) that aggregates key-value pairs into
+         * a queued series of large objects, ensuring that no value is
+         * overwritten (but consolidated non-overlapping keys into single
+         * objects.)
+         * @constructor
+         */
+        function TelemetryQueue() {
+            var queue = [];
+
+            // Look up an object in the queue that does not have a value
+            // assigned to this key (or, add a new one)
+            function getFreeObject(key) {
+                var index = 0, object;
+
+                // Look for an existing queue position where we can store
+                // a value to this key without overwriting an existing value.
+                for (index = 0; index < queue.length; index += 1) {
+                    if (queue[index][key] === undefined) {
+                        return queue[index];
+                    }
+                }
+
+                // If we made it through the loop, values have been assigned
+                // to that key in all queued containers, so we need to queue
+                // up a new  container for key-value pairs.
+                object = {};
+                queue.push(object);
+                return object;
+            }
+
+            return {
+                /**
+                 * Check if any value groups remain in this pool.
+                 * @return {boolean} true if value groups remain
+                 */
+                isEmpty: function () {
+                    return queue.length < 1;
+                },
+                /**
+                 * Retrieve the next value group from this pool.
+                 * This gives an object containing key-value pairs,
+                 * where keys and values correspond to the arguments
+                 * given to previous put functions.
+                 * @return {object} key-value pairs
+                 */
+                poll: function () {
+                    return queue.shift();
+                },
+                /**
+                 * Put a key-value pair into the pool.
+                 * @param {string} key the key to store the value under
+                 * @param {*} value the value to store
+                 */
+                put: function (key, value) {
+                    getFreeObject(key)[key] = value;
+                }
+            };
+        }
+
+        return TelemetryQueue;
+    }
+);
\ No newline at end of file
diff --git a/platform/telemetry/src/TelemetrySubscriber.js b/platform/telemetry/src/TelemetrySubscriber.js
index d422a3af31..3881b1f84a 100644
--- a/platform/telemetry/src/TelemetrySubscriber.js
+++ b/platform/telemetry/src/TelemetrySubscriber.js
@@ -32,18 +32,23 @@ define(
                  *        associated telemetry data is of interest
                  * @param {Function} callback a function to invoke
                  *        when new data has become available.
+                 * @param {boolean} lossless flag to indicate whether the
+                 *        callback should be notified for all values
+                 *        (otherwise, multiple values in quick succession
+                 *        will call back with only the latest value.)
                  * @returns {TelemetrySubscription} the subscription,
                  *        which will provide access to latest values.
                  *
                  * @method
                  * @memberof TelemetrySubscriber
                  */
-                subscribe: function (domainObject, callback) {
+                subscribe: function (domainObject, callback, lossless) {
                     return new TelemetrySubscription(
                         $q,
                         $timeout,
                         domainObject,
-                        callback
+                        callback,
+                        lossless
                     );
                 }
             };
diff --git a/platform/telemetry/src/TelemetryTable.js b/platform/telemetry/src/TelemetryTable.js
index e69de29bb2..1b02887a86 100644
--- a/platform/telemetry/src/TelemetryTable.js
+++ b/platform/telemetry/src/TelemetryTable.js
@@ -0,0 +1,53 @@
+/*global define*/
+
+define(
+    [],
+    function () {
+        "use strict";
+
+        /**
+         * Supports TelemetrySubscription. Provides a simple data structure
+         * (with a pool-like interface) that aggregates key-value pairs into
+         * one large object, overwriting new values as necessary. Stands
+         * in contrast to the TelemetryQueue, which will avoid overwriting
+         * values.
+         * @constructor
+         */
+        function TelemetryTable() {
+            var table;
+
+            return {
+                /**
+                 * Check if any value groups remain in this pool.
+                 * @return {boolean} true if value groups remain
+                 */
+                isEmpty: function () {
+                    return !table;
+                },
+                /**
+                 * Retrieve the next value group from this pool.
+                 * This gives an object containing key-value pairs,
+                 * where keys and values correspond to the arguments
+                 * given to previous put functions.
+                 * @return {object} key-value pairs
+                 */
+                poll: function () {
+                    var t = table;
+                    table = undefined;
+                    return t;
+                },
+                /**
+                 * Put a key-value pair into the pool.
+                 * @param {string} key the key to store the value under
+                 * @param {*} value the value to store
+                 */
+                put: function (key, value) {
+                    table = table || {};
+                    table[key] = value;
+                }
+            };
+        }
+
+        return TelemetryTable;
+    }
+);
\ No newline at end of file

From 757665683e40c55023e99acd116bf4826149ea13 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Fri, 30 Jan 2015 15:35:36 -0800
Subject: [PATCH 12/16] [Plot] Use a lossless subscription

Utilize lossless subscription to ensure that points are not
overwritten before being plotted from live telemetry.
WTD-784.
---
 platform/features/plot/src/PlotController.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/platform/features/plot/src/PlotController.js b/platform/features/plot/src/PlotController.js
index 0050a5a22e..ff013092e8 100644
--- a/platform/features/plot/src/PlotController.js
+++ b/platform/features/plot/src/PlotController.js
@@ -101,7 +101,8 @@ define(
                 }
                 subscription = domainObject && telemetrySubscriber.subscribe(
                     domainObject,
-                    updateValues
+                    updateValues,
+                    true // Lossless
                 );
                 if (subscription) {
                     setupAxes(subscription.getMetadata());

From e6f1328d9d00b115fb45671d4b7b06d8d0fe4b90 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Mon, 2 Feb 2015 15:44:24 -0800
Subject: [PATCH 13/16] [Plot] Update specs

Update specs with minor changes related to using
telemetrySubscriber to populate plot with streaming
data, WTD-751 and WTD-784.
---
 platform/features/plot/test/SubPlotSpec.js       | 16 ++++++++++++++++
 .../plot/test/elements/PlotPreparerSpec.js       |  9 ++++++++-
 .../telemetry/test/TelemetrySubscriptionSpec.js  |  9 +++++++++
 3 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/platform/features/plot/test/SubPlotSpec.js b/platform/features/plot/test/SubPlotSpec.js
index 0cd81681c0..4eb9b6342b 100644
--- a/platform/features/plot/test/SubPlotSpec.js
+++ b/platform/features/plot/test/SubPlotSpec.js
@@ -135,6 +135,22 @@ define(
                     ]
                 );
             });
+
+            it("provides access to a drawable object", function () {
+                expect(typeof subplot.getDrawingObject()).toEqual('object');
+            });
+
+            it("allows a domain offset to be provided", function () {
+                // Domain object is needed to adjust canvas coordinates
+                // to avoid loss-of-precision associated with converting
+                // to 32 bit floats.
+                subplot.setDomainOffset(3);
+                subplot.update();
+                // Should have adjusted the origin accordingly
+                expect(subplot.getDrawingObject().origin[0])
+                    .toEqual(2);
+            });
+
         });
     }
 );
\ No newline at end of file
diff --git a/platform/features/plot/test/elements/PlotPreparerSpec.js b/platform/features/plot/test/elements/PlotPreparerSpec.js
index eb3d999397..8f72349312 100644
--- a/platform/features/plot/test/elements/PlotPreparerSpec.js
+++ b/platform/features/plot/test/elements/PlotPreparerSpec.js
@@ -1,4 +1,4 @@
-/*global define,Promise,describe,it,expect,beforeEach,waitsFor,jasmine*/
+/*global define,Promise,describe,it,expect,beforeEach,waitsFor,jasmine,Float32Array*/
 
 /**
  * MergeModelsSpec. Created by vwoeltje on 11/6/14.
@@ -60,6 +60,13 @@ define(
                 expect(preparer.getDimensions[1]).not.toEqual(0);
             });
 
+            it("provides buffers", function () {
+                var datas = [makeMockData(0)],
+                    preparer = new PlotPreparer(datas);
+                expect(preparer.getBuffers()[0] instanceof Float32Array)
+                    .toBeTruthy();
+            });
+
         });
     }
 );
\ No newline at end of file
diff --git a/platform/telemetry/test/TelemetrySubscriptionSpec.js b/platform/telemetry/test/TelemetrySubscriptionSpec.js
index 8aca781f40..469015ee93 100644
--- a/platform/telemetry/test/TelemetrySubscriptionSpec.js
+++ b/platform/telemetry/test/TelemetrySubscriptionSpec.js
@@ -13,6 +13,7 @@ define(
                 mockTelemetry,
                 mockUnsubscribe,
                 mockSeries,
+                testMetadata,
                 subscription;
 
             function mockPromise(value) {
@@ -24,6 +25,8 @@ define(
             }
 
             beforeEach(function () {
+                testMetadata = { someKey: "some value" };
+
                 mockQ = jasmine.createSpyObj("$q", ["when", "all"]);
                 mockTimeout = jasmine.createSpy("$timeout");
                 mockDomainObject = jasmine.createSpyObj(
@@ -48,6 +51,7 @@ define(
                 mockDomainObject.getId.andReturn('test-id');
 
                 mockTelemetry.subscribe.andReturn(mockUnsubscribe);
+                mockTelemetry.getMetadata.andReturn(testMetadata);
 
                 mockSeries.getPointCount.andReturn(42);
                 mockSeries.getDomainValue.andReturn(123456);
@@ -161,6 +165,11 @@ define(
                 // Should have only triggered the
                 expect(mockCallback.calls.length).toEqual(100);
             });
+
+            it("provides domain object metadata", function () {
+                expect(subscription.getMetadata()[0])
+                    .toEqual(testMetadata);
+            });
         });
     }
 );
\ No newline at end of file

From 2ea4e7a47a790a9598d48267cefce150091f8026 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Mon, 2 Feb 2015 16:17:17 -0800
Subject: [PATCH 14/16] [Plot] Update plot controller spec

Update plot controller spec to reflect changes introduced
for WTD-751 and WTD-784.
---
 platform/features/plot/src/PlotController.js  |  7 +-
 .../features/plot/test/PlotControllerSpec.js  | 92 +++++++++++++------
 2 files changed, 72 insertions(+), 27 deletions(-)

diff --git a/platform/features/plot/src/PlotController.js b/platform/features/plot/src/PlotController.js
index ff013092e8..ef53efd87f 100644
--- a/platform/features/plot/src/PlotController.js
+++ b/platform/features/plot/src/PlotController.js
@@ -85,7 +85,9 @@ define(
 
             // Handle new telemetry data in this plot
             function updateValues() {
-                setupModes(subscription.getTelemetryObjects());
+                if (subscription) {
+                    setupModes(subscription.getTelemetryObjects());
+                }
                 if (updater) {
                     updater.update();
                     modeOptions.getModeHandler().plotTelemetry(updater);
@@ -105,6 +107,7 @@ define(
                     true // Lossless
                 );
                 if (subscription) {
+                    setupModes(subscription.getTelemetryObjects());
                     setupAxes(subscription.getMetadata());
                     recreateUpdater();
                 }
@@ -183,6 +186,8 @@ define(
                  * Check if a request is pending (to show the wait spinner)
                  */
                 isRequestPending: function () {
+                    // Placeholder; this should reflect request state
+                    // when requesting historical telemetry
                     return false;
                 }
             };
diff --git a/platform/features/plot/test/PlotControllerSpec.js b/platform/features/plot/test/PlotControllerSpec.js
index dd73231e62..a8523502ee 100644
--- a/platform/features/plot/test/PlotControllerSpec.js
+++ b/platform/features/plot/test/PlotControllerSpec.js
@@ -12,11 +12,10 @@ define(
             var mockScope,
                 mockFormatter,
                 mockSubscriber,
-                mockData,
+                mockSubscription,
                 mockDomainObject,
                 controller;
 
-            function echo(i) { return i; }
 
             beforeEach(function () {
                 mockScope = jasmine.createSpyObj(
@@ -27,10 +26,6 @@ define(
                     "formatter",
                     [ "formatDomainValue", "formatRangeValue" ]
                 );
-                mockData = jasmine.createSpyObj(
-                    "data",
-                    [ "getPointCount", "getDomainValue", "getRangeValue" ]
-                );
                 mockDomainObject = jasmine.createSpyObj(
                     "domainObject",
                     [ "getId", "getModel", "getCapability" ]
@@ -39,10 +34,22 @@ define(
                     "telemetrySubscriber",
                     ["subscribe"]
                 );
+                mockSubscription = jasmine.createSpyObj(
+                    "subscription",
+                    [
+                        "unsubscribe",
+                        "getTelemetryObjects",
+                        "getMetadata",
+                        "getDomainValue",
+                        "getRangeValue"
+                    ]
+                );
 
-                mockData.getPointCount.andReturn(2);
-                mockData.getDomainValue.andCallFake(echo);
-                mockData.getRangeValue.andCallFake(echo);
+                mockSubscriber.subscribe.andReturn(mockSubscription);
+                mockSubscription.getTelemetryObjects.andReturn([mockDomainObject]);
+                mockSubscription.getMetadata.andReturn([{}]);
+                mockSubscription.getDomainValue.andReturn(123);
+                mockSubscription.getRangeValue.andReturn(42);
 
                 controller = new PlotController(mockScope, mockFormatter, mockSubscriber);
             });
@@ -57,7 +64,24 @@ define(
                     .not.toEqual(controller.getColor(1));
             });
 
-            xit("draws lines when data becomes available", function () {
+            it("subscribes to telemetry when a domain object appears in scope", function () {
+                // Make sure we're using the right watch here
+                expect(mockScope.$watch.mostRecentCall.args[0])
+                    .toEqual("domainObject");
+                // Make an object available
+                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+                // Should have subscribed
+                expect(mockSubscriber.subscribe).toHaveBeenCalledWith(
+                    mockDomainObject,
+                    jasmine.any(Function),
+                    true // Lossless
+                );
+            });
+
+            it("draws lines when data becomes available", function () {
+                // Make an object available
+                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+
                 // Verify precondition
                 controller.getSubPlots().forEach(function (subplot) {
                     expect(subplot.getDrawingObject().lines)
@@ -65,11 +89,10 @@ define(
                 });
 
                 // Make sure there actually are subplots being verified
-                expect(controller.getSubPlots().length > 0)
-                    .toBeTruthy();
+                expect(controller.getSubPlots().length > 0).toBeTruthy();
 
                 // Broadcast data
-                mockScope.$on.mostRecentCall.args[1]();
+                mockSubscriber.subscribe.mostRecentCall.args[1]();
 
                 controller.getSubPlots().forEach(function (subplot) {
                     expect(subplot.getDrawingObject().lines)
@@ -77,27 +100,39 @@ define(
                 });
             });
 
+            it("unsubscribes when domain object changes", function () {
+                // Make an object available
+                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+                // Verify precondition - shouldn't unsubscribe yet
+                expect(mockSubscription.unsubscribe).not.toHaveBeenCalled();
+                // Remove the domain object
+                mockScope.$watch.mostRecentCall.args[1](undefined);
+                // Should have unsubscribed
+                expect(mockSubscription.unsubscribe).toHaveBeenCalled();
+            });
 
-            xit("changes modes depending on number of objects", function () {
-                var expectedWatch = "telemetry.getTelemetryObjects()",
-                    watchFunction;
 
-                // Find the watch for telemetry objects, which
-                // should change plot mode options
-                mockScope.$watch.calls.forEach(function (call) {
-                    if (call.args[0] === expectedWatch) {
-                        watchFunction = call.args[1];
-                    }
-                });
+            it("changes modes depending on number of objects", function () {
+                // Act like one object is available
+                mockSubscription.getTelemetryObjects.andReturn([
+                    mockDomainObject
+                ]);
+
+                // Make an object available
+                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
 
-                watchFunction([mockDomainObject]);
                 expect(controller.getModeOptions().length).toEqual(1);
 
-                watchFunction([
+                // Act like one object is available
+                mockSubscription.getTelemetryObjects.andReturn([
                     mockDomainObject,
                     mockDomainObject,
                     mockDomainObject
                 ]);
+
+                // Make an object available
+                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+
                 expect(controller.getModeOptions().length).toEqual(2);
             });
 
@@ -113,7 +148,7 @@ define(
                     .toEqual(jasmine.any(String));
             });
 
-            xit("allows plot mode to be changed", function () {
+            it("allows plot mode to be changed", function () {
                 expect(function () {
                     controller.setMode(controller.getMode());
                 }).not.toThrow();
@@ -133,6 +168,11 @@ define(
                 expect(controller.stepBackPanZoom).not.toThrow();
                 expect(controller.unzoom).not.toThrow();
             });
+
+            it("indicates if a request is pending", function () {
+                // Placeholder; need to support requesting telemetry
+                expect(controller.isRequestPending()).toBeFalsy();
+            });
         });
     }
 );
\ No newline at end of file

From ed0e0709c599b00429d19093e1d7fdacf908b13c Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Mon, 2 Feb 2015 18:14:08 -0800
Subject: [PATCH 15/16] [Plot] Spec for plot updater

Spec for plot updater, added for WTD-751.
---
 .../features/plot/src/elements/PlotUpdater.js |   4 +-
 .../plot/test/elements/PlotUpdaterSpec.js     | 112 ++++++++++++++++++
 platform/features/plot/test/suite.json        |   1 +
 3 files changed, 115 insertions(+), 2 deletions(-)
 create mode 100644 platform/features/plot/test/elements/PlotUpdaterSpec.js

diff --git a/platform/features/plot/src/elements/PlotUpdater.js b/platform/features/plot/src/elements/PlotUpdater.js
index 312f625963..dd7a690989 100644
--- a/platform/features/plot/src/elements/PlotUpdater.js
+++ b/platform/features/plot/src/elements/PlotUpdater.js
@@ -63,8 +63,8 @@ define(
                 var id = obj.getId(),
                     index = lengths[id] || 0,
                     buffer = buffers[id],
-                    domainValue = subscription.getDomainValue(obj),
-                    rangeValue = subscription.getRangeValue(obj);
+                    domainValue = subscription.getDomainValue(obj, domain),
+                    rangeValue = subscription.getRangeValue(obj, range);
 
                 // If we don't already have a data buffer for that ID,
                 // make one.
diff --git a/platform/features/plot/test/elements/PlotUpdaterSpec.js b/platform/features/plot/test/elements/PlotUpdaterSpec.js
new file mode 100644
index 0000000000..a8e10049a0
--- /dev/null
+++ b/platform/features/plot/test/elements/PlotUpdaterSpec.js
@@ -0,0 +1,112 @@
+/*global define,Promise,describe,it,expect,beforeEach,waitsFor,jasmine,Float32Array*/
+
+/**
+ * MergeModelsSpec. Created by vwoeltje on 11/6/14.
+ */
+define(
+    ["../../src/elements/PlotUpdater"],
+    function (PlotUpdater) {
+        "use strict";
+
+        describe("A plot updater", function () {
+            var mockSubscription,
+                testDomain,
+                testRange,
+                testDomainValues,
+                testRangeValues,
+                updater;
+
+            function makeMockDomainObject(id) {
+                var mockDomainObject = jasmine.createSpyObj(
+                    "object-" + id,
+                    [ "getId", "getCapability", "getModel" ]
+                );
+                mockDomainObject.getId.andReturn(id);
+                return mockDomainObject;
+            }
+
+            beforeEach(function () {
+                var ids = [ 'a', 'b', 'c' ],
+                    mockObjects = ids.map(makeMockDomainObject);
+
+                mockSubscription = jasmine.createSpyObj(
+                    "subscription",
+                    [ "getDomainValue", "getRangeValue", "getTelemetryObjects" ]
+                );
+                testDomain = "testDomain";
+                testRange = "testRange";
+                testDomainValues = { a: 3, b: 7, c: 13 };
+                testRangeValues = { a: 123, b: 456, c: 789 };
+
+                mockSubscription.getTelemetryObjects.andReturn(mockObjects);
+                mockSubscription.getDomainValue.andCallFake(function (mockObject) {
+                    return testDomainValues[mockObject.getId()];
+                });
+                mockSubscription.getRangeValue.andCallFake(function (mockObject) {
+                    return testRangeValues[mockObject.getId()];
+                });
+
+                updater = new PlotUpdater(
+                    mockSubscription,
+                    testDomain,
+                    testRange
+                );
+            });
+
+            it("provides one buffer per telemetry object", function () {
+                expect(updater.getBuffers().length).toEqual(3);
+            });
+
+            it("changes buffer count if telemetry object counts change", function () {
+                mockSubscription.getTelemetryObjects
+                    .andReturn([makeMockDomainObject('a')]);
+                updater.update();
+                expect(updater.getBuffers().length).toEqual(1);
+            });
+
+            it("maintains a buffer of received telemetry", function () {
+                // Count should be large enough to trigger a buffer resize
+                var count = 1000,
+                    i;
+
+                // Increment values exposed by subscription
+                function increment() {
+                    Object.keys(testDomainValues).forEach(function (k) {
+                        testDomainValues[k] += 1;
+                        testRangeValues[k] += 1;
+                    });
+                }
+
+                // Simulate a lot of telemetry updates
+                for (i = 0; i < count; i += 1) {
+                    updater.update();
+                    expect(updater.getLength(0)).toEqual(i + 1);
+                    expect(updater.getLength(1)).toEqual(i + 1);
+                    expect(updater.getLength(2)).toEqual(i + 1);
+                    increment();
+                }
+
+                // Domain offset should be lowest domain value
+                expect(updater.getDomainOffset()).toEqual(3);
+
+                // Test against initial values, offset by count,
+                // as was the case during each update
+                for (i = 0; i < count; i += 1) {
+                    expect(updater.getBuffers()[0][i * 2])
+                        .toEqual(3 + i - 3);
+                    expect(updater.getBuffers()[0][i * 2 + 1])
+                        .toEqual(123 + i);
+                    expect(updater.getBuffers()[1][i * 2])
+                        .toEqual(7 + i - 3);
+                    expect(updater.getBuffers()[1][i * 2 + 1])
+                        .toEqual(456 + i);
+                    expect(updater.getBuffers()[2][i * 2])
+                        .toEqual(13 + i - 3);
+                    expect(updater.getBuffers()[2][i * 2 + 1])
+                        .toEqual(789 + i);
+                }
+            });
+
+        });
+    }
+);
\ No newline at end of file
diff --git a/platform/features/plot/test/suite.json b/platform/features/plot/test/suite.json
index 7528ce7869..2df3badfef 100644
--- a/platform/features/plot/test/suite.json
+++ b/platform/features/plot/test/suite.json
@@ -11,6 +11,7 @@
     "elements/PlotPosition",
     "elements/PlotPreparer",
     "elements/PlotTickGenerator",
+    "elements/PlotUpdater",
     "modes/PlotModeOptions",
     "modes/PlotOverlayMode",
     "modes/PlotStackMode"

From 494cce9b2feea49f49bf5a939e8b03c537f64b65 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Tue, 3 Feb 2015 10:35:03 -0800
Subject: [PATCH 16/16] [Plot] Complete specs for plot updater

Complete specs for plot updater; particularly, address
case (and fix bug in case) where maximum buffer size
has been hit. WTD-751.
---
 .../features/plot/src/elements/PlotUpdater.js | 13 +++--
 .../plot/test/elements/PlotUpdaterSpec.js     | 53 ++++++++++++++++++-
 2 files changed, 59 insertions(+), 7 deletions(-)

diff --git a/platform/features/plot/src/elements/PlotUpdater.js b/platform/features/plot/src/elements/PlotUpdater.js
index dd7a690989..ed81035b6b 100644
--- a/platform/features/plot/src/elements/PlotUpdater.js
+++ b/platform/features/plot/src/elements/PlotUpdater.js
@@ -21,7 +21,7 @@ define(
          * @param {string} domain the key to use when looking up domain values
          * @param {string} range the key to use when looking up range values
          */
-        function PlotUpdater(subscription, domain, range) {
+        function PlotUpdater(subscription, domain, range, maxPoints) {
             var max = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY],
                 min = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY],
                 x,
@@ -46,12 +46,12 @@ define(
                 // Check if we don't have enough room
                 if (index > (buffer.length / 2 - 1)) {
                     // If we don't, can we expand?
-                    if (index < MAX_POINTS) {
+                    if (index < maxPoints) {
                         // Double the buffer size
                         buffer = buffers[id] = doubleSize(buffer);
                     } else {
                         // Just shift the existing buffer
-                        buffer.copyWithin(0, 2);
+                        buffer.set(buffer.subarray(2));
                     }
                 }
 
@@ -82,12 +82,12 @@ define(
                     // Ensure there is space for the new buffer
                     buffer = ensureBufferSize(buffer, id, index);
                     // Account for shifting that may have occurred
-                    index = Math.min(index, MAX_POINTS - 2);
+                    index = Math.min(index, maxPoints - 1);
                     // Update the buffer
                     buffer[index * 2] = domainValue - domainOffset;
                     buffer[index * 2 + 1] = rangeValue;
                     // Update length
-                    lengths[id] = Math.min(index + 1, MAX_POINTS);
+                    lengths[id] = Math.min(index + 1, maxPoints);
                     // Observe max/min range values
                     max[1] = Math.max(max[1], rangeValue);
                     min[1] = Math.min(min[1], rangeValue);
@@ -130,6 +130,9 @@ define(
                 bufferArray.push(buffers[id]);
             }
 
+            // Use a default MAX_POINTS if none is provided
+            maxPoints = maxPoints || MAX_POINTS;
+
             // Initially prepare state for these objects.
             // Note that this may be an empty array at this time,
             // so we also need to check during update cycles.
diff --git a/platform/features/plot/test/elements/PlotUpdaterSpec.js b/platform/features/plot/test/elements/PlotUpdaterSpec.js
index a8e10049a0..41be699578 100644
--- a/platform/features/plot/test/elements/PlotUpdaterSpec.js
+++ b/platform/features/plot/test/elements/PlotUpdaterSpec.js
@@ -49,7 +49,8 @@ define(
                 updater = new PlotUpdater(
                     mockSubscription,
                     testDomain,
-                    testRange
+                    testRange,
+                    1350 // Smaller max size for easier testing
                 );
             });
 
@@ -66,7 +67,7 @@ define(
 
             it("maintains a buffer of received telemetry", function () {
                 // Count should be large enough to trigger a buffer resize
-                var count = 1000,
+                var count = 750,
                     i;
 
                 // Increment values exposed by subscription
@@ -107,6 +108,54 @@ define(
                 }
             });
 
+            it("can handle delayed telemetry object availability", function () {
+                // The case can occur where getTelemetryObjects() returns an
+                // empty array - specifically, while objects are still being
+                // loaded. The updater needs to be able to cope with that
+                // case.
+                var tmp = mockSubscription.getTelemetryObjects();
+                mockSubscription.getTelemetryObjects.andReturn([]);
+
+                // Reinstantiate with the empty subscription
+                updater = new PlotUpdater(
+                    mockSubscription,
+                    testDomain,
+                    testRange
+                );
+
+                // Should have 0 buffers for 0 objects
+                expect(updater.getBuffers().length).toEqual(0);
+
+                // Restore the three objects the test subscription would
+                // normally have.
+                mockSubscription.getTelemetryObjects.andReturn(tmp);
+                updater.update();
+
+                // Should have 3 buffers for 3 objects
+                expect(updater.getBuffers().length).toEqual(3);
+            });
+
+
+            it("shifts buffer upon expansion", function () {
+                // Count should be large enough to hit buffer's max size
+                var count = 1400,
+                    i;
+
+                // Initial update; should have 3 in first position
+                // (a's initial domain value)
+                updater.update();
+                expect(updater.getBuffers()[0][1]).toEqual(123);
+
+                // Simulate a lot of telemetry updates
+                for (i = 0; i < count; i += 1) {
+                    testDomainValues.a += 1;
+                    testRangeValues.a += 1;
+                    updater.update();
+                }
+
+                // Value at front of the buffer should have been pushed out
+                expect(updater.getBuffers()[0][1]).not.toEqual(123);
+            });
         });
     }
 );
\ No newline at end of file