WIP: run clang-format-js on lots of things

chrome/browser/resources/profiler/profiler.js

 // Copyright (c) 2012 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.
 
 var g_browserBridge;
 var g_mainView;
 
 // TODO(eroman): The handling of "max" across snapshots is not correct.
 // For starters the browser needs to be aware to generate new maximums.
 // Secondly, we need to take into account the "max" of intermediary snapshots,
@@ skipping 12 matching lines @@
 /**
  * This class provides a "bridge" for communicating between the javascript and
  * the browser. Used as a singleton.
  */
 var BrowserBridge = (function() {
   'use strict';
 
   /**
    * @constructor
    */
-  function BrowserBridge() {
-  }
+  function BrowserBridge() {}
 
   BrowserBridge.prototype = {
     //--------------------------------------------------------------------------
     // Messages sent to the browser
     //--------------------------------------------------------------------------
 
     sendGetData: function() {
       chrome.send('getData');
     },
 
@@ skipping 130 matching lines @@
       consume: function(e) {
         this.valuesSet_[e[this.key_]] = true;
       },
 
       getValueAsText: function() {
         return getDictionaryKeys(this.valuesSet_).length + ' unique';
       },
     };
 
     return {
-      create: function(key) { return new Aggregator(key); }
+      create: function(key) {
+        return new Aggregator(key);
+      }
     };
   })();
 
   /**
    * This aggregator sums a numeric field.
    */
   var SumAggregator = (function() {
     function Aggregator(key) {
       this.key_ = key;
       this.sum_ = 0;
     }
 
     Aggregator.prototype = {
       consume: function(e) {
         this.sum_ += e[this.key_];
       },
 
       getValue: function() {
         return this.sum_;
       },
 
       getValueAsText: function() {
         return formatNumberAsText(this.getValue());
       },
     };
 
     return {
-      create: function(key) { return new Aggregator(key); }
+      create: function(key) {
+        return new Aggregator(key);
+      }
     };
   })();
 
   /**
    * This aggregator computes an average by summing two
    * numeric fields, and then dividing the totals.
    */
   var AvgAggregator = (function() {
     function Aggregator(numeratorKey, divisorKey) {
       this.numeratorKey_ = numeratorKey;
@@ skipping 87 matching lines @@
       getValue: function() {
         return this.max_;
       },
 
       getValueAsText: function() {
         return formatNumberAsText(this.getValue());
       },
     };
 
     return {
-      create: function(key) { return new Aggregator(key); }
+      create: function(key) {
+        return new Aggregator(key);
+      }
     };
   })();
 
   // --------------------------------------------------------------------------
   // Key properties
   // --------------------------------------------------------------------------
 
   // Custom comparator for thread names (sorts main thread and IO thread
   // higher than would happen lexicographically.)
-  var threadNameComparator =
-      createLexicographicComparatorWithExceptions([
-          'CrBrowserMain',
-          'Chrome_IOThread',
-          'Chrome_FileThread',
-          'Chrome_HistoryThread',
-          'Chrome_DBThread',
-          'Still_Alive',
-      ]);
+  var threadNameComparator = createLexicographicComparatorWithExceptions([
+    'CrBrowserMain',
+    'Chrome_IOThread',
+    'Chrome_FileThread',
+    'Chrome_HistoryThread',
+    'Chrome_DBThread',
+    'Still_Alive',
+  ]);
 
   function diffFuncForCount(a, b) {
     return b - a;
   }
 
   function diffFuncForMax(a, b) {
     return b;
   }
 
   /**
@@ skipping 135 matching lines @@
       sortDescending: true,
       textPrinter: formatNumberAsText,
       aggregator: AvgAggregator.create(KEY_MEMORY_FREE_OPS, KEY_COUNT),
     };
 
     KEY_PROPERTIES[KEY_MEMORY_AVG_NET_BYTES] = {
       name: 'Avg Net Bytes',
       cellAlignment: 'right',
       sortDescending: true,
       textPrinter: formatNumberAsText,
-      aggregator: AvgDiffAggregator.create(KEY_MEMORY_ALLOCATED_BYTES,
-                                           KEY_MEMORY_FREED_BYTES, KEY_COUNT),
+      aggregator: AvgDiffAggregator.create(
+          KEY_MEMORY_ALLOCATED_BYTES, KEY_MEMORY_FREED_BYTES, KEY_COUNT),
     };
 
     KEY_PROPERTIES[KEY_MEMORY_ALLOC_OPS] = {
       name: 'Allocation count',
       cellAlignment: 'right',
       sortDescending: true,
       textPrinter: formatNumberAsText,
       inputJsonKey: 'death_data.alloc_ops',
       aggregator: SumAggregator,
       diff: diffFuncForCount,
@@ skipping 244 matching lines @@
   }
 
   /**
    * Formats the number |x| as a decimal integer. Strips off any decimal parts,
    * and comma separates the number every 3 characters.
    */
   function formatNumberAsText(x) {
     var orig = x.toFixed(0);
 
     var parts = [];
-    for (var end = orig.length; end > 0; ) {
+    for (var end = orig.length; end > 0;) {
       var chunk = Math.min(end, 3);
       parts.push(orig.substr(end - chunk, chunk));
       end -= chunk;
     }
     return parts.reverse().join(',');
   }
 
   /**
    * Simple comparator function which works for both strings and numbers.
    */
@@ skipping 71 matching lines @@
     var textNode = parent.ownerDocument.createTextNode(text);
     parent.appendChild(textNode);
     return textNode;
   }
 
   /**
    * Deletes all the strings in |array| which appear in |valuesToDelete|.
    */
   function deleteValuesFromArray(array, valuesToDelete) {
     var valueSet = arrayToSet(valuesToDelete);
-    for (var i = 0; i < array.length; ) {
+    for (var i = 0; i < array.length;) {
       if (valueSet[array[i]]) {
         array.splice(i, 1);
       } else {
         i++;
       }
     }
   }
 
   /**
    * Deletes all the repeated ocurrences of strings in |array|.
    */
   function deleteDuplicateStringsFromArray(array) {
     // Build up set of each entry in array.
     var seenSoFar = {};
 
-    for (var i = 0; i < array.length; ) {
+    for (var i = 0; i < array.length;) {
       var value = array[i];
       if (seenSoFar[value]) {
         array.splice(i, 1);
       } else {
         seenSoFar[value] = true;
         i++;
       }
     }
   }
 
@@ skipping 35 matching lines @@
     checkbox.type = 'checkbox';
     addText(labelNode, label);
     return checkbox;
   }
 
   /**
    * Return the last component in a path which is separated by either forward
    * slashes or backslashes.
    */
   function getFilenameFromPath(path) {
-    var lastSlash = Math.max(path.lastIndexOf('/'),
-                             path.lastIndexOf('\\'));
+    var lastSlash = Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\'));
     if (lastSlash == -1)
       return path;
 
     return path.substr(lastSlash + 1);
   }
 
   /**
    * Returns the current time in milliseconds since unix epoch.
    */
   function getTimeMillis() {
@@ skipping 36 matching lines @@
 
   function computeDataRowAverages(e) {
     e[KEY_AVG_QUEUE_TIME] = e[KEY_QUEUE_TIME] / e[KEY_COUNT];
     e[KEY_AVG_RUN_TIME] = e[KEY_RUN_TIME] / e[KEY_COUNT];
 
     if (loadTimeData.getBoolean('enableMemoryTaskProfiler')) {
       e[KEY_MEMORY_AVG_ALLOC_OPS] = e[KEY_MEMORY_ALLOC_OPS] / e[KEY_COUNT];
       e[KEY_MEMORY_AVG_FREE_OPS] = e[KEY_MEMORY_FREE_OPS] / e[KEY_COUNT];
       e[KEY_MEMORY_AVG_NET_BYTES] =
           (e[KEY_MEMORY_ALLOCATED_BYTES] - e[KEY_MEMORY_FREED_BYTES]) /
-              e[KEY_COUNT];
+          e[KEY_COUNT];
     }
   }
 
   /**
    * Creates and initializes an aggregator object for each key in |columns|.
    * Returns an array whose keys are values from |columns|, and whose
    * values are Aggregator instances.
    */
   function initializeAggregates(columns) {
     var aggregates = [];
@@ skipping 38 matching lines @@
    * order).
    *
    * If |mergeSimilarThreads| is true, then threads with a similar name will be
    * considered equivalent. For instance, "WorkerThread-1" and "WorkerThread-2"
    * will be remapped to "WorkerThread-*".
    *
    * If |outputAsDictionary| is false then the merged rows will be returned as a
    * flat list. Otherwise the result will be a dictionary, where each row
    * has a unique key.
    */
-  function mergeRows(origRows, mergeKeys, mergeSimilarThreads,
-                     outputAsDictionary) {
+  function mergeRows(
+      origRows, mergeKeys, mergeSimilarThreads, outputAsDictionary) {
     // Define a translation function for each property. Normally we copy over
     // properties as-is, but if we have been asked to "merge similar threads" we
     // we will remap the thread names that end in a numeric suffix.
     var propertyGetterFunc;
 
     if (mergeSimilarThreads) {
       propertyGetterFunc = function(row, key) {
         var value = row[key];
         // If the property is a thread name, try to remap it.
         if (key == KEY_BIRTH_THREAD || key == KEY_DEATH_THREAD) {
           var m = /^(.*[^\d])(\d+)$/.exec(value);
           if (m)
             value = m[1] + '*';
         }
         return value;
       };
     } else {
-      propertyGetterFunc = function(row, key) { return row[key]; };
+      propertyGetterFunc = function(row, key) {
+        return row[key];
+      };
     }
 
     // Determine which sets of properties a row needs to match on to be
     // considered identical to another row.
     var identityKeys = IDENTITY_KEYS.slice(0);
     deleteValuesFromArray(identityKeys, mergeKeys);
 
     // Set |aggregateKeys| to everything else, since we will be aggregating
     // their value as part of the merge.
     var aggregateKeys = ALL_KEYS.slice(0);
@@ skipping 47 matching lines @@
    *
    * Rows in data1 and data2 are expected to use the same scheme for the keys.
    * In other words, data1[k] is considered the analagous row to data2[k].
    */
   function subtractSnapshots(data1, data2, columnsToExclude) {
     // These columns are computed from the other columns. We won't bother
     // diffing/aggregating these, but rather will derive them again from the
     // final row.
     var COMPUTED_AGGREGATE_KEYS = [KEY_AVG_QUEUE_TIME, KEY_AVG_RUN_TIME];
     if (loadTimeData.getBoolean('enableMemoryTaskProfiler')) {
-       COMPUTED_AGGREGATE_KEYS = COMPUTED_AGGREGATE_KEYS.concat([
-          KEY_MEMORY_AVG_ALLOC_OPS,
-          KEY_MEMORY_AVG_FREE_OPS,
-          KEY_MEMORY_AVG_NET_BYTES]);
+      COMPUTED_AGGREGATE_KEYS = COMPUTED_AGGREGATE_KEYS.concat([
+        KEY_MEMORY_AVG_ALLOC_OPS, KEY_MEMORY_AVG_FREE_OPS,
+        KEY_MEMORY_AVG_NET_BYTES
+      ]);
     }
 
     // These are the keys which determine row equality. Since we are not doing
     // any merging yet at this point, it is simply the list of all identity
     // columns.
     var identityKeys = IDENTITY_KEYS.slice(0);
     deleteValuesFromArray(identityKeys, columnsToExclude);
 
     // The columns to compute via aggregation is everything else.
     var aggregateKeys = ALL_KEYS.slice(0);
@@ skipping 85 matching lines @@
       // builds.
       var m = /^(.*) \[(\d+)\]$/.exec(text);
       if (m) {
         var filepath = m[1];
         var filename = getFilenameFromPath(filepath);
         var linenumber = m[2];
 
         var link = addNode(td, 'a', filename + ' [' + linenumber + ']');
 
         link.href = 'https://code.google.com/p/chromium/codesearch#search/&q=' +
-                    encodeURIComponent(filename) + ':' + linenumber +
-                    '&sq=package:chromium&type=cs';
+            encodeURIComponent(filename) + ':' + linenumber +
+            '&sq=package:chromium&type=cs';
         link.target = '_blank';
         return;
       }
     }
 
     // String values can get pretty long. If the string contains no spaces, then
     // CSS fails to wrap it, and it overflows the cell causing the table to get
     // really big. We solve this using a hack: insert a <wbr> element after
     // every single character. This will allow the rendering engine to wrap the
     // value, and hence avoid it overflowing!
@@ skipping 252 matching lines @@
         // Otherwise if two snapshots were chosen, show the difference between
         // them.
         var snapshot1 = this.snapshots_[selectedSnapshots[0]];
         var snapshot2 = this.snapshots_[selectedSnapshots[1]];
 
         var timeDeltaInSeconds =
             ((snapshot2.time - snapshot1.time) / 1000).toFixed(0);
 
         // Explain that what is being shown is the difference between two
         // snapshots.
-        summaryDiv.innerText =
-            'Showing the difference between snapshots #' +
-            selectedSnapshots[0] + ' and #' +
-            selectedSnapshots[1] + ' (' + timeDeltaInSeconds +
-            ' seconds worth of data)';
+        summaryDiv.innerText = 'Showing the difference between snapshots #' +
+            selectedSnapshots[0] + ' and #' + selectedSnapshots[1] + ' (' +
+            timeDeltaInSeconds + ' seconds worth of data)';
       } else {
         // This shouldn't be possible...
         throw 'Unexpected number of selected snapshots';
       }
     },
 
     updateMergedData_: function() {
       // Retrieve the merge options.
       var mergeColumns = this.getMergeColumns_();
       var shouldMergeSimilarThreads = this.shouldMergeSimilarThreads_();
 
       var selectedSnapshots = this.getSelectedSnapshotIndexes_();
 
       // We do merges a bit differently depending if we are displaying the diffs
       // between two snapshots, or just displaying a single snapshot.
       if (selectedSnapshots.length == 1) {
         var snapshot = this.snapshots_[selectedSnapshots[0]];
-        this.mergedData_ = mergeRows(snapshot.flatData,
-                                     mergeColumns,
-                                     shouldMergeSimilarThreads,
-                                     false);
+        this.mergedData_ = mergeRows(
+            snapshot.flatData, mergeColumns, shouldMergeSimilarThreads, false);
 
       } else if (selectedSnapshots.length == 2) {
         var snapshot1 = this.snapshots_[selectedSnapshots[0]];
         var snapshot2 = this.snapshots_[selectedSnapshots[1]];
 
         // Merge the data for snapshot1.
-        var mergedRows1 = mergeRows(snapshot1.flatData,
-                                    mergeColumns,
-                                    shouldMergeSimilarThreads,
-                                    true);
+        var mergedRows1 = mergeRows(
+            snapshot1.flatData, mergeColumns, shouldMergeSimilarThreads, true);
 
         // Merge the data for snapshot2.
-        var mergedRows2 = mergeRows(snapshot2.flatData,
-                                    mergeColumns,
-                                    shouldMergeSimilarThreads,
-                                    true);
+        var mergedRows2 = mergeRows(
+            snapshot2.flatData, mergeColumns, shouldMergeSimilarThreads, true);
 
         // Do a diff between the two snapshots.
-        this.mergedData_ = subtractSnapshots(mergedRows1,
-                                             mergedRows2,
-                                             mergeColumns);
+        this.mergedData_ =
+            subtractSnapshots(mergedRows1, mergedRows2, mergeColumns);
       } else {
         throw 'Unexpected number of selected snapshots';
       }
 
       // Recompute filteredData_ (since it is derived from mergedData_)
       this.updateFilteredData_();
     },
 
     updateFilteredData_: function() {
       // Recompute filteredData_.
@@ skipping 147 matching lines @@
       table.className = 'results-table';
       var thead = addNode(table, 'thead');
       var tbody = addNode(table, 'tbody');
 
       var displaySettings = this.getGroupDisplaySettings_(groupKey);
       var limit = displaySettings.limit;
 
       this.drawAggregateRow_(thead, data.aggregates, columns);
       this.drawTableHeader_(thead, columns);
       this.drawTableBody_(tbody, data.rows, columns, limit);
-      this.drawTruncationRow_(tbody, data.rows.length, limit, columns.length,
-                              groupKey);
+      this.drawTruncationRow_(
+          tbody, data.rows.length, limit, columns.length, groupKey);
     },
 
     drawTableHeader_: function(thead, columns) {
       var tr = addNode(thead, 'tr');
       for (var i = 0; i < columns.length; ++i) {
         var key = columns[i];
         var th = addNode(tr, 'th', getNameForKey(key));
         th.onclick = this.onClickColumn_.bind(this, key);
 
         // Draw an indicator if we are currently sorted on this column.
@@ skipping 194 matching lines @@
       this.addSnapshotToList_(this.snapshots_.length - 1);
 
       // Ask the browser for the profiling data. We will receive the data
       // later through a callback to addDataToSnapshot_().
       g_browserBridge.sendGetData();
     },
 
     saveSnapshots_: function() {
       var snapshots = [];
       for (var i = 0; i < this.snapshots_.length; ++i) {
-        snapshots.push({ data: this.snapshots_[i].origData,
-                         timestamp: Math.floor(
-                                 this.snapshots_[i].time / 1000) });
+        snapshots.push({
+          data: this.snapshots_[i].origData,
+          timestamp: Math.floor(this.snapshots_[i].time / 1000)
+        });
       }
 
       var dump = {
         'userAgent': navigator.userAgent,
         'version': 1,
         'snapshots': snapshots
       };
 
       var dumpText = JSON.stringify(dump, null, ' ');
-      var textBlob = new Blob([dumpText],
-                              { type: 'octet/stream', endings: 'native' });
+      var textBlob =
+          new Blob([dumpText], {type: 'octet/stream', endings: 'native'});
       var blobUrl = window.URL.createObjectURL(textBlob);
       $(DOWNLOAD_ANCHOR_ID).href = blobUrl;
       $(DOWNLOAD_ANCHOR_ID).click();
     },
 
     loadFileChanged_: function() {
       this.loadSnapshots_($(SNAPSHOT_FILE_LOADER_ID).files[0]);
     },
 
     loadSnapshots_: function(file) {
@@ skipping 38 matching lines @@
       this.clearExistingSnapshots_();
       $(TAKE_SNAPSHOT_BUTTON_ID).disabled = true;
       $(SAVE_SNAPSHOTS_BUTTON_ID).disabled = true;
 
       if (content.snapshots.length > 1) {
         setNodeDisplay($(SNAPSHOTS_ROW), true);
       }
 
       for (var i = 0; i < content.snapshots.length; ++i) {
         var snapshot = content.snapshots[i];
-        this.snapshots_.push({flatData: [], origData: [],
-                              time: snapshot.timestamp * 1000});
+        this.snapshots_.push(
+            {flatData: [], origData: [], time: snapshot.timestamp * 1000});
         this.addSnapshotToList_(this.snapshots_.length - 1);
         var snapshotData = snapshot.data;
         for (var j = 0; j < snapshotData.length; ++j) {
           this.addDataToSnapshot(snapshotData[j]);
         }
       }
       this.redrawData_();
     },
 
     onLoadSnapshotsFileError_: function(file, filedata) {
@@ skipping 59 matching lines @@
 
     onSnapshotCheckboxChanged_: function(event) {
       // Keep track of when we clicked this box (for when we need to uncheck
       // older boxes).
       event.target.__time = getTimeMillis();
 
       // Find all the checked boxes. Either 1 or 2 can be checked. If a third
       // was just checked, then uncheck one of the earlier ones so we only have
       // 2.
       var checked = this.getSelectedSnapshotBoxes_();
-      checked.sort(function(a, b) { return b.__time - a.__time; });
+      checked.sort(function(a, b) {
+        return b.__time - a.__time;
+      });
       if (checked.length > 2) {
         for (var i = 2; i < checked.length; ++i)
           checked[i].checked = false;
         checked.length = 2;
       }
 
       // We should always have at least 1 selection. Prevent the user from
       // unselecting the final box.
       if (checked.length == 0)
         event.target.checked = true;
@@ skipping 197 matching lines @@
       };
     },
 
     getGroupSortingFunction_: function() {
       return function(a, b) {
         var groupKey1 = JSON.parse(a);
         var groupKey2 = JSON.parse(b);
 
         for (var i = 0; i < groupKey1.length; ++i) {
           var comparison = compareValuesForKey(
-              groupKey1[i].key,
-              groupKey1[i].value,
-              groupKey2[i].value);
+              groupKey1[i].key, groupKey1[i].value, groupKey2[i].value);
 
           if (comparison != 0)
             return comparison;
         }
 
         // Tie breaker.
         return simpleCompare(a, b);
       };
     },
 
@@ skipping 28 matching lines @@
       deleteValuesFromArray(groupings, ['']);
 
       // Eliminate duplicate primary/secondary group by directives, since they
       // are redundant.
       deleteDuplicateStringsFromArray(groupings);
 
       return function(e) {
         var groupKey = [];
 
         for (var i = 0; i < groupings.length; ++i) {
-          var entry = {key: groupings[i],
-                       value: e[groupings[i]]};
+          var entry = {key: groupings[i], value: e[groupings[i]]};
           groupKey.push(entry);
         }
 
         return JSON.stringify(groupKey);
       };
     },
   };
 
   return MainView;
 })();