Run clang-format on ui/webui/resources

ui/webui/resources/js/cr/ui/array_data_model.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.
 
 /**
  * @fileoverview This is a data model representin
  */
 
 // The include directives are put into Javascript-style comments to prevent
 // parsing errors in non-flattened mode. The flattener still sees them.
@@ skipping 23 matching lines @@
     }
   }
 
   ArrayDataModel.prototype = {
     __proto__: EventTarget.prototype,
 
     /**
      * The length of the data model.
      * @type {number}
      */
-    get length() {
-      return this.array_.length;
-    },
+    get length() { return this.array_.length; },
 
     /**
      * Returns the item at the given index.
      * This implementation returns the item at the given index in the sorted
      * array.
      * @param {number} index The index of the element to get.
      * @return {*} The element at the given index.
      */
     item: function(index) {
       if (index >= 0 && index < this.length)
         return this.array_[this.indexes_[index]];
       return undefined;
     },
 
     /**
      * Returns compare function set for given field.
      * @param {string} field The field to get compare function for.
      * @return {function(*, *): number} Compare function set for given field.
      */
-    compareFunction: function(field) {
-      return this.compareFunctions_[field];
-    },
+    compareFunction: function(field) { return this.compareFunctions_[field]; },
 
     /**
      * Sets compare function for given field.
      * @param {string} field The field to set compare function.
      * @param {function(*, *): number} compareFunction Compare function to set
      *     for given field.
      */
     setCompareFunction: function(field, compareFunction) {
       if (!this.compareFunctions_) {
         this.compareFunctions_ = {};
@@ skipping 39 matching lines @@
     },
 
     /**
      * Returns an array of elements in a selected range.
      * @param {number=} opt_from The starting index of the selected range.
      * @param {number=} opt_to The ending index of selected range.
      * @return {Array} An array of elements in the selected range.
      */
     slice: function(opt_from, opt_to) {
       var arr = this.array_;
-      return this.indexes_.slice(opt_from, opt_to).map(
-          function(index) { return arr[index] });
+      return this.indexes_.slice(opt_from, opt_to).map(function(index) {
+        return arr[index]
+      });
     },
 
     /**
      * This removes and adds items to the model.
      * This dispatches a splice event.
      * This implementation runs sort after splice and creates permutation for
      * the whole change.
      * @param {number} index The index of the item to update.
      * @param {number} deleteCount The number of items to remove.
      * @param {...*} var_args The items to add.
@@ skipping 34 matching lines @@
 
       this.array_ = newArray;
 
       // TODO(arv): Maybe unify splice and change events?
       var spliceEvent = new Event('splice');
       spliceEvent.removed = deletedItems;
       spliceEvent.added = Array.prototype.slice.call(arguments, 2);
 
       var status = this.sortStatus;
       // if sortStatus.field is null, this restores original order.
-      var sortPermutation = this.doSort_(this.sortStatus.field,
-                                         this.sortStatus.direction);
+      var sortPermutation =
+          this.doSort_(this.sortStatus.field, this.sortStatus.direction);
       if (sortPermutation) {
         var splicePermutation = deletePermutation.map(function(element) {
           return element != -1 ? sortPermutation[element] : -1;
         });
         this.dispatchPermutedEvent_(splicePermutation);
         spliceEvent.index = sortPermutation[index];
       } else {
         this.dispatchPermutedEvent_(deletePermutation);
         spliceEvent.index = index;
       }
@@ skipping 43 matching lines @@
       this.updateIndex(index);
     },
 
     /**
      * Use this to update a given item in the array. This does not remove and
      * reinsert a new item.
      * This dispatches a change event.
      * This runs sort after updating.
      * @param {number} index The index of the item to update.
      */
-    updateIndex: function(index) {
-      this.updateIndexes([index]);
-    },
+    updateIndex: function(index) { this.updateIndexes([index]); },
 
     /**
      * Notifies of update of the items in the array. This does not remove and
      * reinsert new items.
      * This dispatches one or more change events.
      * This runs sort after updating.
      * @param {Array<number>} indexes The index list of items to update.
      */
     updateIndexes: function(indexes) {
       indexes.forEach(function(index) {
         assert(index >= 0 && index < this.length, 'Invalid index');
       }, this);
 
       for (var i = 0; i < indexes.length; i++) {
         var e = new Event('change');
         e.index = indexes[i];
         this.dispatchEvent(e);
       }
 
       if (this.sortStatus.field) {
         var status = this.sortStatus;
-        var sortPermutation = this.doSort_(this.sortStatus.field,
-                                           this.sortStatus.direction);
+        var sortPermutation =
+            this.doSort_(this.sortStatus.field, this.sortStatus.direction);
         if (sortPermutation)
           this.dispatchPermutedEvent_(sortPermutation);
         // We should first call prepareSort (data may change), and then sort.
         // Still need to finish the sorting above (including events), so
         // list will not go to inconsistent state.
         this.delayedSort_(status.field, status.direction);
       }
     },
 
     /**
      * Creates sort status with given field and direction.
      * @param {?string} field Sort field.
      * @param {?string} direction Sort direction.
      * @return {!Object} Created sort status.
      */
     createSortStatus: function(field, direction) {
-      return {
-        field: field,
-        direction: direction
-      };
+      return {field: field, direction: direction};
     },
 
     /**
      * Called before a sort happens so that you may fetch additional data
      * required for the sort.
      *
      * @param {string} field Sort field.
      * @param {function()} callback The function to invoke when preparation
      *     is complete.
      */
-    prepareSort: function(field, callback) {
-      callback();
-    },
+    prepareSort: function(field, callback) { callback(); },
 
     /**
      * Sorts data model according to given field and direction and dispathes
      * sorted event with delay. If no need to delay, use sort() instead.
      * @param {string} field Sort field.
      * @param {string} direction Sort direction.
      * @private
      */
     delayedSort_: function(field, direction) {
       var self = this;
@@ skipping 101 matching lines @@
 
       return function(index1, index2) {
         var item1 = this.array_[index1];
         var item2 = this.array_[index2];
 
         var compareResult = 0;
         if (typeof(compareFunction) === 'function')
           compareResult = compareFunction.call(null, item1, item2);
         if (compareResult != 0)
           return dirMultiplier * compareResult;
-        return dirMultiplier * this.defaultValuesCompareFunction(index1,
-                                                                 index2);
+        return dirMultiplier *
+            this.defaultValuesCompareFunction(index1, index2);
       }.bind(this);
     },
 
     /**
      * Default compare function.
      */
     defaultValuesCompareFunction: function(a, b) {
       // We could insert i18n comparisons here.
       if (a < b)
         return -1;
       if (a > b)
         return 1;
       return 0;
     }
   };
 
-  return {
-    ArrayDataModel: ArrayDataModel
-  };
+  return {ArrayDataModel: ArrayDataModel};
 });