DO NOT SUBMIT: what chrome/browser/resources/ could eventually look like with clang-format

chrome/browser/resources/options/inline_editable_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.
 
 cr.define('options', function() {
   /** @const */ var DeletableItem = options.DeletableItem;
   /** @const */ var DeletableItemList = options.DeletableItemList;
 
   /**
    * Creates a new list item with support for inline editing.
@@ skipping 304 matching lines @@
     },
 
     /**
      * Returns a div containing an <input>, as well as static text if
      * isPlaceholder is not true.
      * @param {string} text The text of the cell.
      * @return {HTMLElement} The HTML element for the cell.
      * @private
      */
     createEditableTextCell: function(text) {
-      var container = /** @type {HTMLElement} */(
-          this.ownerDocument.createElement('div'));
+      var container =
+          /** @type {HTMLElement} */ (this.ownerDocument.createElement('div'));
       var textEl = null;
       if (!this.isPlaceholder) {
         textEl = this.ownerDocument.createElement('div');
         textEl.className = 'static-text overruleable';
         textEl.textContent = text;
         textEl.setAttribute('displaymode', 'static');
         container.appendChild(textEl);
       }
 
       var inputEl = this.ownerDocument.createElement('input');
@@ skipping 26 matching lines @@
      */
     addEditField: function(control, staticElement) {
       control.staticVersion = staticElement;
       if (this.editable)
         control.tabIndex = -1;
 
       if (control.staticVersion) {
         if (this.editable)
           control.staticVersion.tabIndex = -1;
         control.staticVersion.editableVersion = control;
-        control.staticVersion.addEventListener('focus',
-                                               this.handleFocus.bind(this));
+        control.staticVersion.addEventListener(
+            'focus', this.handleFocus.bind(this));
       }
       this.editFields_.push(control);
     },
 
     /**
      * Set the column index for a child element of this InlineEditableItem.
      * Only elements with a column index will be keyboard focusable, e.g. by
      * pressing the tab key.
      * @param {Element} element Element whose column index to set. Method does
      *     nothing if element is null.
@@ skipping 17 matching lines @@
      */
     resetEditableValues_: function() {
       var editFields = this.editFields_;
       for (var i = 0; i < editFields.length; i++) {
         var staticLabel = editFields[i].staticVersion;
         if (!staticLabel && !this.isPlaceholder)
           continue;
 
         if (editFields[i].tagName == 'INPUT') {
           editFields[i].value =
-            this.isPlaceholder ? '' : staticLabel.textContent;
+              this.isPlaceholder ? '' : staticLabel.textContent;
         }
         // Add more tag types here as new createEditable* methods are added.
 
         editFields[i].setCustomValidity('');
       }
     },
 
     /**
      * Sets the static version of any controls created by createEditable*
      * to match the current value of the editable version. Called on commit so
@@ skipping 13 matching lines @@
       }
     },
 
     /**
      * Returns the index of the column that currently has focus, or -1 if no
      * column has focus.
      * @return {number}
      * @private
      */
     getFocusedColumnIndex_: function() {
-      var element = document.activeElement.editableVersion ||
-                    document.activeElement;
+      var element =
+          document.activeElement.editableVersion || document.activeElement;
 
       if (element.hasAttribute('inlineeditable-column'))
         return parseInt(element.getAttribute('inlineeditable-column'), 10);
       return -1;
     },
 
     /**
      * Returns the element from the column that has the largest index where:
      * where:
      *   + index <= startIndex, and
@@ skipping 83 matching lines @@
     /**
      * Called when this InlineEditableItem or any of its children are given
      * focus. Updates focusedColumnIndex with the index of the newly focused
      * column, or -1 if the focused element does not have a column index.
      * @param {Event} e The focusin event.
      * @private
      */
     handleFocusIn_: function(e) {
       var target = e.target.editableVersion || e.target;
       this.focusedColumnIndex = target.hasAttribute('inlineeditable-column') ?
-          parseInt(target.getAttribute('inlineeditable-column'), 10) : -1;
+          parseInt(target.getAttribute('inlineeditable-column'), 10) :
+          -1;
     },
   };
 
   /**
    * Takes care of committing changes to inline editable list items when the
    * window loses focus.
    */
   function handleWindowBlurs() {
     window.addEventListener('blur', function(e) {
       var itemAncestor = findAncestor(document.activeElement, function(node) {
@@ skipping 27 matching lines @@
      * Focuses the input element of the placeholder if true.
      * @type {boolean}
      * @private
      */
     needsToFocusPlaceholder_: false,
 
     /** @override */
     decorate: function() {
       DeletableItemList.prototype.decorate.call(this);
       this.setAttribute('inlineeditable', '');
-      this.addEventListener('hasElementFocusChange',
-                            this.handleListFocusChange_);
+      this.addEventListener(
+          'hasElementFocusChange', this.handleListFocusChange_);
       // <list> isn't focusable by default, but cr.ui.List defaults tabindex to
       // 0 if it's not set.
       this.tabIndex = -1;
     },
 
     /**
      * Called when the list hierarchy as a whole loses or gains focus; starts
      * or ends editing for the lead item if necessary.
      * @param {Event} e The change event.
      * @private
@@ skipping 78 matching lines @@
 
     /**
      * Set the selected index without changing the focused element on the page.
      * Used to change the selected index when the list doesn't have focus (and
      * doesn't want to take focus).
      * @param {number} index The index to select.
      */
     selectIndexWithoutFocusing: function(index) {
       // Remove focusability from old item.
       var oldItem = this.getListItemByIndex(this.selectionModel.leadIndex) ||
-                    this.getInitialFocusableItem();
+          this.getInitialFocusableItem();
       if (oldItem) {
         oldItem.setEditableValuesFocusable(false);
         oldItem.setStaticValuesFocusable(false);
         oldItem.setCloseButtonFocusable(false);
         oldItem.lead = false;
       }
 
       // Select the new item.
       this.ignoreChangeEvents(function() {
         this.selectionModel.selectedIndex = index;
@@ skipping 39 matching lines @@
      * May be overridden by subclasses to disable focusing the placeholder.
      * @return {boolean} True if the placeholder element should be focused on
      *     edit commit.
      * @protected
      */
     shouldFocusPlaceholderOnEditCommit: function() {
       return true;
     },
 
     /**
-    * Override to change which item is initially focusable.
-    * @return {options.InlineEditableItem} Initially focusable item or null.
-    * @protected
-    */
+     * Override to change which item is initially focusable.
+     * @return {options.InlineEditableItem} Initially focusable item or null.
+     * @protected
+     */
     getInitialFocusableItem: function() {
-      return /** @type {options.InlineEditableItem} */(
+      return /** @type {options.InlineEditableItem} */ (
           this.getListItemByIndex(0));
     },
   };
 
   // Export
   return {
     InlineEditableItem: InlineEditableItem,
     InlineEditableItemList: InlineEditableItemList,
   };
 });