Clang format JS: Disallow single line functions, conditionals, loops, and switch statements

ui/webui/resources/js/cr/ui/list.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.
 
 // require: array_data_model.js
 // require: list_selection_model.js
 // require: list_selection_controller.js
 // require: list_item.js
 
 /**
@@ skipping 76 matching lines @@
      * Function used to create grid items.
      * @type {function(new:cr.ui.ListItem, *)}
      * @private
      */
     itemConstructor_: cr.ui.ListItem,
 
     /**
      * Function used to create grid items.
      * @return {function(new:cr.ui.ListItem, *)}
      */
-    get itemConstructor() { return this.itemConstructor_; },
+    get itemConstructor() {
+      return this.itemConstructor_;
+    },
     set itemConstructor(func) {
       if (func != this.itemConstructor_) {
         this.itemConstructor_ = func;
         this.cachedItems_ = {};
         this.redraw();
       }
     },
 
     dataModel_: null,
 
@@ skipping 31 matching lines @@
         this.dataModel_.addEventListener(
             'permuted', this.boundHandleDataModelPermuted_);
         this.dataModel_.addEventListener(
             'change', this.boundHandleDataModelChange_);
       }
 
       this.redraw();
       this.onSetDataModelComplete();
     },
 
-    get dataModel() { return this.dataModel_; },
+    get dataModel() {
+      return this.dataModel_;
+    },
 
     /**
      * Override to be notified when |this.dataModel| is set.
      * @protected
      */
     onSetDataModelComplete: function() {},
 
     /**
      * Cached item for measuring the default item size by measureItem().
      * @type {cr.ui.ListItem}
      */
     cachedMeasuredItem_: null,
 
     /**
      * The selection model to use.
      * @type {cr.ui.ListSelectionModel}
      */
-    get selectionModel() { return this.selectionModel_; },
+    get selectionModel() {
+      return this.selectionModel_;
+    },
     set selectionModel(sm) {
       var oldSm = this.selectionModel_;
       if (oldSm == sm)
         return;
 
       if (!this.boundHandleOnChange_) {
         this.boundHandleOnChange_ = this.handleOnChange_.bind(this);
         this.boundHandleLeadChange_ = this.handleLeadChange.bind(this);
       }
 
       if (oldSm) {
         oldSm.removeEventListener('change', this.boundHandleOnChange_);
         oldSm.removeEventListener(
             'leadIndexChange', this.boundHandleLeadChange_);
       }
 
       this.selectionModel_ = sm;
       this.selectionController_ = this.createSelectionController(sm);
 
       if (sm) {
         sm.addEventListener('change', this.boundHandleOnChange_);
         sm.addEventListener('leadIndexChange', this.boundHandleLeadChange_);
       }
     },
 
     /**
      * Whether or not the list auto-expands.
      * @type {boolean}
      */
-    get autoExpands() { return this.autoExpands_; },
+    get autoExpands() {
+      return this.autoExpands_;
+    },
     set autoExpands(autoExpands) {
       if (this.autoExpands_ == autoExpands)
         return;
       this.autoExpands_ = autoExpands;
       this.redraw();
     },
 
     /**
      * Whether or not the rows on list have various heights.
      * @type {boolean}
      */
-    get fixedHeight() { return this.fixedHeight_; },
+    get fixedHeight() {
+      return this.fixedHeight_;
+    },
     set fixedHeight(fixedHeight) {
       if (this.fixedHeight_ == fixedHeight)
         return;
       this.fixedHeight_ = fixedHeight;
       this.redraw();
     },
 
     /**
      * Convenience alias for selectionModel.selectedItem
      * @type {*}
@@ skipping 16 matching lines @@
     },
 
     /**
      * Convenience alias for selectionModel.selectedItems
      * @type {!Array<*>}
      */
     get selectedItems() {
       var indexes = this.selectionModel.selectedIndexes;
       var dataModel = this.dataModel;
       if (dataModel) {
-        return indexes.map(function(i) { return dataModel.item(i); });
+        return indexes.map(function(i) {
+          return dataModel.item(i);
+        });
       }
       return [];
     },
 
     /**
      * The HTML elements representing the items.
      * @type {HTMLCollection}
      */
     get items() {
       return Array.prototype.filter.call(this.children, this.isItem, this);
@@ skipping 11 matching lines @@
     },
 
     batchCount_: 0,
 
     /**
      * When making a lot of updates to the list, the code could be wrapped in
      * the startBatchUpdates and finishBatchUpdates to increase performance. Be
      * sure that the code will not return without calling endBatchUpdates or the
      * list will not be correctly updated.
      */
-    startBatchUpdates: function() { this.batchCount_++; },
+    startBatchUpdates: function() {
+      this.batchCount_++;
+    },
 
     /**
      * See startBatchUpdates.
      */
     endBatchUpdates: function() {
       this.batchCount_--;
       if (this.batchCount_ == 0)
         this.redraw();
     },
 
@@ skipping 388 matching lines @@
         }
         return top;
       }
     },
 
     /**
      * @param {number} index The index of the item.
      * @return {number} The row of the item. May vary in the case
      *     of multiple columns.
      */
-    getItemRow: function(index) { return index; },
+    getItemRow: function(index) {
+      return index;
+    },
 
     /**
      * @param {number} row The row.
      * @return {number} The index of the first item in the row.
      */
-    getFirstItemInRow: function(row) { return row; },
+    getFirstItemInRow: function(row) {
+      return row;
+    },
 
     /**
      * Ensures that a given index is inside the viewport.
      * @param {number} index The index of the item to scroll into view.
      */
     scrollIndexIntoView: function(index) {
       var dataModel = this.dataModel;
       if (!dataModel || index < 0 || index >= dataModel.length)
         return;
 
       var itemHeight = this.getItemHeightByIndex_(index);
       var scrollTop = this.scrollTop;
       var top = this.getItemTop(index);
       var clientHeight = this.clientHeight;
 
       var cs = getComputedStyle(this);
       var paddingY =
           parseInt(cs.paddingTop, 10) + parseInt(cs.paddingBottom, 10);
       var availableHeight = clientHeight - paddingY;
 
       var self = this;
       // Function to adjust the tops of viewport and row.
-      function scrollToAdjustTop() { self.scrollTop = top; }
+      function scrollToAdjustTop() {
+        self.scrollTop = top;
+      }
       // Function to adjust the bottoms of viewport and row.
       function scrollToAdjustBottom() {
         self.scrollTop = top + itemHeight - availableHeight;
       }
 
       // Check if the entire of given indexed row can be shown in the viewport.
       if (itemHeight <= availableHeight) {
         if (top < scrollTop)
           scrollToAdjustTop();
         else if (scrollTop + availableHeight < top + itemHeight)
@@ skipping 598 matching lines @@
     for (var element = start; element && element != root;
          element = element.parentElement) {
       if (element.tabIndex >= 0 && !element.disabled)
         return true;
     }
     return false;
   }
 
   return {List: List};
 });