Add the Polymer object observe library and add a test that it works.

perf/server/res/js/logic.js

 /**
  * Copyright (c) 2014 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file */
 /** Provides the logic behind the performance visualization webpage. */
 
-function assert(cond, msg) {
+function assert_(cond, msg) {
   if(!cond) {
     throw msg || "Assertion failed";
   }
 }
 
 
 function last(ary) {
   return ary[ary.length - 1];
 }
 
@@ skipping 137 matching lines @@
 /* Unordered data structure with O(1) add, remove, and index.*/
 // Benchmarked remarkably well against vector.splice()/push()
 function Vector() {
   var data = [];
   var firstEmpty = 0;
   if(arguments) {
     data = Array.prototype.map.call(arguments, id);
     firstEmpty = data.length;
   }
   this.get = function(idx) {
-    assert(idx < firstEmpty);
+    assert_(idx < firstEmpty);
     return data[idx];
   },
   this.push = function(elem) {
     data[firstEmpty] = elem;
     firstEmpty++;
   };
   this.pop = function(idx) {
-    assert(idx < firstEmpty && firstEmpty > 0);
+    assert_(idx < firstEmpty && firstEmpty > 0);
     var result = data[idx];
     data[idx] = data[firstEmpty - 1];
     data[firstEmpty - 1] = null;
     firstEmpty--;
     return result;
   };
   this.all = function() {
     return data.slice(0, firstEmpty);
   };
   this.remove = function(elem) {
@@ skipping 72 matching lines @@
 var legend = (function() {
   var internalLegend = [];
   var externalLegend = [];
   // Each legend marker has two values, a key and a color
   // The external legend also has a pointer to its DOM element called elem.
   var legendBody = null;
 
   function addToDOM(e) {
     console.log('addToDOM called');
     // console.log(e);
-    assert(e.key && e.color);
-    assert(legendBody);
+    assert_(e.key && e.color);
+    assert_(legendBody);
     var container = document.createElement('tr');
     var checkContainer = document.createElement('td');
     var checkbox = document.createElement('input');
     checkbox.type = 'checkbox';
     checkbox.checked = true;
     checkbox.id = e.key;
     var outerColor = document.createElement('div');
     outerColor.classList.add('legend-box-outer');
     var innerColor = document.createElement('div');
     innerColor.classList.add('legend-box-inner');
@@ skipping 13 matching lines @@
     checkContainer.appendChild(text);
 
     linkContainer.appendChild(link);
     outerColor.appendChild(innerColor);
 
     legendBody.appendChild(container);
     return {key: e.key, color: e.color, elem: container};
   }
 
   function rawAdd(key, color) {
-    assert(getComponent(internalLegend, 'key').indexOf(key) == -1);
+    assert_(getComponent(internalLegend, 'key').indexOf(key) == -1);
 
     var newPair = {key:key, color:color};
     internalLegend.push(newPair);
     externalLegend.push(addToDOM(newPair));
   }
   return {
     /** Updates the colors for the elements.*/
     updateColors: function(plotRef) {
       var dataRef = plotRef.getData();
       internalLegend.forEach(function(legendMarker) {
@@ skipping 23 matching lines @@
           }
         }
       });
       if(synced && color_synced) {
         console.log('legend.refresh: legends synced');
         return;
       } else if(synced && !color_synced) {
         console.log('legend.refresh: fixing colors');
         // Fix the colors
         $$('tr', legendBody).forEach(function(e, idx) {
-          assert($$$('input', e).id == internalLegend[idx].key);
+          assert_($$$('input', e).id == internalLegend[idx].key);
 
           $$$('.legend-box-inner', e).style.
             border = '5px solid ' + internalLegend[idx].color;
         });
       } else {
         killChildren($$$('#legend table tbody'));
         externalLegend = [];
         // Regenerate a new legend
         var _this = this;
         internalLegend.forEach(function(e) {
           externalLegend.push(addToDOM(e, _this));
         });
       }
     },
     remove: function(key) {
       var children = [];
       externalLegend.forEach(function(e, idx) {
         if(e.key == key) {
           children.push(e.elem);
         }
       });
       children.forEach(function(c) {
-        assert(c.parentNode);
+        assert_(c.parentNode);
         c.parentNode.removeChild(c);
       });
       internalLegend = internalLegend.filter(function(e) {
         return e.key != key;
       });
       externalLegend = externalLegend.filter(function(e) {
         return e.key != key;
       });
     },
     /* Sets up the private variables, and a few of the relevant UI controls.*/
     init: function(showHandler, hideHandler, drawHandler) {
       console.log('Initializing legend');
-      assert(showHandler && hideHandler);
+      assert_(showHandler && hideHandler);
       legendBody = $$$('#legend table tbody');
       var _this = this;
       $$$('#nuke-plot').addEventListener('click', function(e) {
         internalLegend.forEach(function(keypair) {
           plotData.hide(keypair.key);
         });
         killChildren($$$('#legend table tbody'));
         internalLegend = [];
         externalLegend = [];
         drawHandler();
@@ skipping 48 matching lines @@
 var jsonRequest = (function() {
   var waitingHandlers = [];
   var freshFiles = [];
 
   function makeRequest(uri, callback) {
     var ref = {uri: uri, callbacks: [callback]};
     waitingHandlers.push(ref);
 
     var removeSelf = function() {
       var idx = waitingHandlers.indexOf(ref);
-      assert(idx != -1);
+      assert_(idx != -1);
       waitingHandlers.splice(idx, 1);
     };
 
     loadJSON(ref.uri, function(data) {
       console.log('jsonRequest: ' + ref.uri + ' received');
       var freshIdx = getComponent(freshFiles, 'uri').indexOf(uri);
       if(freshIdx == -1) {
         freshFiles.push({uri: uri, time: Date.now(), data: data});
       } else {
         freshFiles[freshIdx].data = data;
         freshFiles[freshIdx].time = Date.now();
       }
       ref.callbacks.forEach(function(callback) {
-        assert(callback);
+        assert_(callback);
         callback(data, true);
       });
       removeSelf();
     }, function() {
       ref.callbacks.forEach(function(callback) {
-        assert(callback);
+        assert_(callback);
         callback(data, false);
       });
       removeSelf();
     });
   }
   return {
     askFor: function(uri, callback) {
       var idx = getComponent(waitingHandlers, 'uri').indexOf(uri);
       var freshIdx = getComponent(freshFiles, 'uri').indexOf(uri);
       if(idx != -1) {
@@ skipping 65 matching lines @@
     for(var key in data[scale]) {
       if(data[scale].hasOwnProperty(key)) {
         result.push(parseInt(key));
       }
     }
     return result;
   }
 
   /* Adds a set of data to the trace.*/
   this.add = function(newData, tileId, scale) {
-    assert(newData.length > 0);
+    assert_(newData.length > 0);
     if(!data[scale]) {
       data[scale] = [];
     }
     if(!data[scale][tileId] || (newData.length >= data[scale][tileId].length)) {
       data[scale][tileId] = newData.slice();  // FUTURE: If too slow, replace with
                                               // shallow copy
     }
   };
 
   this.get = function(tileId, scale) {
     return (data[scale] && data[scale][tileId]) || [];
   };
 
   this.getRange = function(start, end, scale) {
     // FUTURE: Add support for downsampling on scale mismatch
-    assert(start <= end);
+    assert_(start <= end);
     var results = [];
     var tiles = data[scale];
     getTiles(scale).forEach(function(tileIdx) {
       if(tiles[tileIdx][0][0] <= end && last(tiles[tileIdx])[0] >= start) {
         var result = [];
         var i = 0;
         while(tiles[tileIdx][i][0] < start) {
-          assert(i < tiles[tileIdx].length);
+          assert_(i < tiles[tileIdx].length);
           i++;
         }
         if(i > 0) {
           // Add one just before the range if possible
           i--;
         }
         while(i < tiles[tileIdx].length && tiles[tileIdx][i][0] <= end) {
           result.push(tiles[tileIdx][i]);
           i++;
         }
@@ skipping 20 matching lines @@
 
 var traceDict = (function() {
   var cache = new PagedDictionary();
   // A dictionary of keys to Trace objects
 
   function loadData(data, tileId, dataset, scale) {
     console.log('traceDict: loadData called. tileId = ' + tileId + 
         ', scale = ' + scale);
     // Look for the key in the data, and store that. If no key specified, store
     // as much data as possible.
-    assert(data['traces'] && data['commits']);
+    assert_(data['traces'] && data['commits']);
 
     var commitAry = getComponent(data['commits'], 'commit_time');
     data['traces'].forEach(function(trace) {
       var newKey = schema.makeLegendKey(trace);
       var processedData = [];
       for(var i = 0; i < trace['values'].length; i++) {
         if(trace['values'][i] < 1e+99) {
           processedData.push([commitAry[i], trace['values'][i]]);
         }
       }
@@ skipping 115 matching lines @@
       if(dataDict.has(scale) && dataDict.get(scale).has(timestamp)) {
         return dataDict.get(scale).get(timestamp);
       } else if(callback) {
         callbacks.push({lookup: timestamp, scale: scale, callback: callback});
         return null;
       }
     },
     /* Call the callback with the hash for the given timestamp.*/
     timestampToHash: function(timestamp, scale, callback) {
       var res = this.getAssociatedData(timestamp, scale, function(res) {
-        assert(res && res.hash);
+        assert_(res && res.hash);
         callback(res.hash);
       });
       return res && res.hash;
     },
     /* Updates the dictionaries with the JSON data.*/
     update: function(data, isManifest) {
       console.log('commitDict.update called: isManifest=' + isManifest);
       console.log(data);
       // Load new data, then see if any of the callbacks are now valid
       if(isManifest) {
         // it's a manifest JSON
         // FUTURE
-        assert(false, "Unimplemented");
+        assert_(false, "Unimplemented");
       } else {
         // it's a tile JSON
         // FUTURE: Remove hack when the JSON has the right format
         data['scale'] = data['scale'] || 0;
 
-        assert(data && data['commits']); // FUTURE: add: && data['scale']);
+        assert_(data && data['commits']); // FUTURE: add: && data['scale']);
         var commits = data['commits'];
         var scale = 0; // FUTURE: Replace with: parseInt(data['scale']);
         commits.forEach(function(commit) {
-          assert(commit['commit_time']);
+          assert_(commit['commit_time']);
           if(!dataDict.has(scale)) {
             dataDict.add(scale, new PagedDictionary());
           }
           if(!dataDict.get(scale).has(commit['commit_time'])) {
             dataDict.get(scale).add(parseInt(commit['commit_time']), commit);
           }
         });
       }
       iterateAndPopCallback(function(entry) {
-        assert(entry.callback);
+        assert_(entry.callback);
         if(callbackObject.hasOwnProperty('lookup')) { // Then it's a timestamp look up
           var res = getAssociatedData(entry.timestamp, entry.scale, null);
           if(res != null) {
             entry.callback(res);
           }
           return res != null; // Remove the entry if the get was successful
         }
         return false;
       });
     },
@@ skipping 71 matching lines @@
         obj[fieldName] = value;
       }
     }
     var checkSetAttr = function(node, fieldName, value) {
       if(node.getAttribute(fieldName) != value) {
         node.setAttribute(fieldName, value);
       }
     }
     var specialCases = ['children', 'text', 'attributes', 'style'];
     for(var i = 0; i < model.length; i++) {
-      assert(model[i].nodeType);
+      assert_(model[i].nodeType);
       if(i >= root.children.length || 
           root.children[i].nodeName != model[i].nodeType.toUpperCase()) {
         root.appendChild(document.createElement(model[i].nodeType));
       }
       var curChild = root.children[i];
       for(var name in model[i]) {
         if(model[i].hasOwnProperty(name) && specialCases.indexOf(name) == -1) {
           checkSet(curChild, name, model[i][name]);
         }
       }
@@ skipping 28 matching lines @@
         options[partName].push(selectedOption.value);
       });
     });
     options['dataset'] = currentDataset;
     return options;
   }
 
   return {
     /* Returns a string given the key elements in trace.*/
     makeLegendKey: function(trace, dataset) {
-      assert(trace['params']);
+      assert_(trace['params']);
       if(!dataset) {
-        assert(trace['params']['dataset']);
+        assert_(trace['params']['dataset']);
         dataset = trace['params']['dataset'];
       } else if(!trace['params']['dataset']) {
         trace['params']['dataset'] = dataset;
       }
-      assert(validKeyParts[dataset]);
+      assert_(validKeyParts[dataset]);
       return validKeyParts[dataset].map(function(part) {
         return trace['params'][part] || '';
       }).join(KEY_DELIMITER);
     },
     /* Updates the schema given data in the JSON input.*/
     update: function(data, datasetName) {
       console.log('schema.update called: datasetName=' + datasetName);
       console.log(data);
-      assert(data['param_set']);
+      assert_(data['param_set']);
       // Update internal structure
       if(!schemaDict.has(datasetName)) {
         schemaDict.add(datasetName, new PagedDictionary());
       }
       var keys = [];
       for(var key in data['param_set']) {
         if(data['param_set'].hasOwnProperty(key) && 
             validKeyParts[datasetName].indexOf(key) != -1) {
           keys.push(key);
         }
@@ skipping 19 matching lines @@
         }, this);
       }
       this.updateDOM();
     },
     /* Given the input options, returns the ones that define real traces and
      * their number.
      * options is a dictionary keyed with the key part name and has the
      * selected values as its value.*/
     getValidOptions: function(options, dataset) {
       // FUTURE: Replace with tree if not performing well enough
-      assert(validKeyParts[dataset]);
+      assert_(validKeyParts[dataset]);
       var mapOptions = function(key) {
         // Return the split string if it's valid, false otherwise.
         var parts = key.split(KEY_DELIMITER);
         return key.split(KEY_DELIMITER).every(function(part, idx) {
           return !options[validKeyParts[dataset][idx]] ||
               options[validKeyParts[dataset][idx]].indexOf(part) != -1;
         }) && parts;
       };
       var validLines = lineList.map(mapOptions);
       var optionDicts = {};
@@ skipping 15 matching lines @@
             tmpOptions.push(k);
           }
         }
         optionDicts[validKeyParts[i]] = tmpOptions;
       }
       return [optionDicts, count];
     },
     /* Returns a list of valid lines given the selected options.*/
     getValidLines: function(options, dataset) {
       // FUTURE: Replace with tree if not performing well enough
-      assert(validKeyParts[dataset]);
+      assert_(validKeyParts[dataset]);
       var mapOptions = function(key) {
         // Return the split string if it's valid, false otherwise.
         var parts = key.split(KEY_DELIMITER);
         return parts.every(function(part, idx) {
           return !options[validKeyParts[dataset][idx]] ||
               options[validKeyParts[dataset][idx]].indexOf(part) != -1;
         }) && key;
       };
       var validLines = lineList.map(mapOptions);
       // console.log(validLines);
       return validLines.filter(id);
     },
     /* Updates the selection boxes to match the ones currently in the schema.*/
     updateDOM: function() {
-      assert(currentDataset);
+      assert_(currentDataset);
       console.log('schema.updateDOM: start');
       if(!schemaDict.has(currentDataset)) {
         console.log('schema.updateDOM: Schema for selected dataset not ' +
             'currently loaded; sending request.');
         var _this = this;
         jsonRequest.askForTile(0, -1, currentDataset, {'get_params_data': true},
             function(data, success) {
               if(success) {
                 console.log('schema.updateDOM: received data.');
                 _this.update(data, currentDataset);
               }
             });
         return;
       }
-      assert($$$('#line-table'));
+      assert_($$$('#line-table'));
       var inputRoot;
       if($$$('#' + currentDataset + '-set')) {
         inputRoot = $$$('#' + currentDataset + '-set');
-        assert(inputRoot.parentElement == $$$('#line-table'));
+        assert_(inputRoot.parentElement == $$$('#line-table'));
       } else {
         inputRoot = document.createElement('tr');
         inputRoot.id = currentDataset + '-set';
       }
       var curDict = schemaDict.get(currentDataset);
       curDict.index().forEach(function(part) {
         curDict.get(part).sort();
       });
       var getWidth = function(part) {
         var longestLine = Math.max.apply(null, 
@@ skipping 114 matching lines @@
         // console.log(e);
         var inputId = e.target.id.slice(0,-'-input'.length);
         console.log('called for ' + e.target.id);
         if(e.target.nodeName == 'INPUT') {
           if(!currentDataset) {
             console.log('line-table.input: no schema currently loaded. Ignoring.');
             return;
           }
           var query = e.target.value;
           var dataset = schemaDict.get(currentDataset).get(inputId);
-          assert(dataset != null);
+          assert_(dataset != null);
           var results = dataset.filter(function(candidate) {
             return candidate.indexOf(query) != -1;
           });  // FUTURE: If this is too slow, swap with binary search
           if (results.length < 1) {
             matchLengths = dataset.map(function(candidate) {
               var maxMatch = 0;
               for(var start = 0; start < candidate.length; start++) {
                 var i = 0;
                 for (; start + i < candidate.length && i < query.length; i++) {
                   if (candidate[start + i] != query[i]) {
@@ skipping 416 matching lines @@
   document.body.addEventListener('click', function(e) {
     if(!$(e.target).parents().is('#note,#chart')) {
       $('#note').hide();
     }
   });
 
 
   $('#note').hide();
   $('#notification').hide();
 });