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

chrome/browser/resources/extensions/extension_command_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.
 
 // <include src="shortcut_util.js">
 
 cr.define('extensions', function() {
   'use strict';
 
   /**
@@ skipping 55 matching lines @@
      * metadata given in |extension|.
      * @param {chrome.developerPrivate.ExtensionInfo} extension A dictionary of
      *     extension metadata.
      * @private
      */
     createNodeForExtension_: function(extension) {
       if (extension.commands.length == 0 ||
           extension.state == chrome.developerPrivate.ExtensionState.DISABLED)
         return;
 
-      var template = $('template-collection-extension-commands').querySelector(
-          '.extension-command-list-extension-item-wrapper');
+      var template =
+          $('template-collection-extension-commands')
+              .querySelector('.extension-command-list-extension-item-wrapper');
       var node = template.cloneNode(true);
 
       var title = node.querySelector('.extension-title');
       title.textContent = extension.name;
 
       this.appendChild(node);
 
       // Iterate over the commands data within the extension and add each item
       // to the list.
       extension.commands.forEach(
           this.createNodeForCommand_.bind(this, extension.id));
     },
 
     /**
      * Synthesizes and initializes an HTML element for the extension command
      * metadata given in |command|.
      * @param {string} extensionId The associated extension's id.
      * @param {chrome.developerPrivate.Command} command A dictionary of
      *     extension command metadata.
      * @private
      */
     createNodeForCommand_: function(extensionId, command) {
-      var template = $('template-collection-extension-commands').querySelector(
-          '.extension-command-list-command-item-wrapper');
+      var template =
+          $('template-collection-extension-commands')
+              .querySelector('.extension-command-list-command-item-wrapper');
       var node = template.cloneNode(true);
       node.id = this.createElementId_('command', extensionId, command.name);
 
       var description = node.querySelector('.command-description');
       description.textContent = command.description;
 
       var shortcutNode = node.querySelector('.command-shortcut-text');
-      shortcutNode.addEventListener('mouseup',
-                                    this.startCapture_.bind(this));
+      shortcutNode.addEventListener('mouseup', this.startCapture_.bind(this));
       shortcutNode.addEventListener('focus', this.handleFocus_.bind(this));
       shortcutNode.addEventListener('blur', this.handleBlur_.bind(this));
       shortcutNode.addEventListener('keydown', this.handleKeyDown_.bind(this));
       shortcutNode.addEventListener('keyup', this.handleKeyUp_.bind(this));
       if (!command.isActive) {
         shortcutNode.textContent =
             loadTimeData.getString('extensionCommandsInactive');
 
         var commandShortcut = node.querySelector('.command-shortcut');
         commandShortcut.classList.add('inactive-keybinding');
       } else {
         shortcutNode.textContent = command.keybinding;
       }
 
       var commandClear = node.querySelector('.command-clear');
-      commandClear.id = this.createElementId_(
-          'clear', extensionId, command.name);
+      commandClear.id =
+          this.createElementId_('clear', extensionId, command.name);
       commandClear.title = loadTimeData.getString('extensionCommandsDelete');
       commandClear.addEventListener('click', this.handleClear_.bind(this));
 
       var select = node.querySelector('.command-scope');
-      select.id = this.createElementId_(
-          'setCommandScope', extensionId, command.name);
+      select.id =
+          this.createElementId_('setCommandScope', extensionId, command.name);
       select.hidden = false;
       // Add the 'In Chrome' option.
       var option = document.createElement('option');
       option.textContent = loadTimeData.getString('extensionCommandsRegular');
       select.appendChild(option);
       if (command.isExtensionAction || !command.isActive) {
         // Extension actions cannot be global, so we might as well disable the
         // combo box, to signify that, and if the command is inactive, it
         // doesn't make sense to allow the user to adjust the scope.
         select.disabled = true;
       } else {
         // Add the 'Global' option.
         option = document.createElement('option');
         option.textContent = loadTimeData.getString('extensionCommandsGlobal');
         select.appendChild(option);
         select.selectedIndex =
-            command.scope == chrome.developerPrivate.CommandScope.GLOBAL ?
-                1 : 0;
+            command.scope == chrome.developerPrivate.CommandScope.GLOBAL ? 1 :
+                                                                           0;
 
         select.addEventListener(
             'change', this.handleSetCommandScope_.bind(this));
       }
 
       this.appendChild(node);
     },
 
     /**
      * Starts keystroke capture to determine which key to use for a particular
@@ skipping 10 matching lines @@
       var shortcutNode = event.target;
       this.oldValue_ = shortcutNode.textContent;
       shortcutNode.textContent =
           loadTimeData.getString('extensionCommandsStartTyping');
       shortcutNode.parentElement.classList.add('capturing');
 
       var commandClear =
           shortcutNode.parentElement.querySelector('.command-clear');
       commandClear.hidden = true;
 
-      this.capturingElement_ = /** @type {HTMLElement} */(event.target);
+      this.capturingElement_ = /** @type {HTMLElement} */ (event.target);
     },
 
     /**
      * Ends keystroke capture and either restores the old value or (if valid
      * value) sets the new value as active..
      * @param {Event} event The keyboard event to consider.
      * @private
      */
     endCapture_: function(event) {
       if (!this.capturingElement_)
@@ skipping 52 matching lines @@
       var commandShortcut = event.target.parentElement;
       commandShortcut.classList.remove('focused');
     },
 
     /**
      * The KeyDown handler.
      * @param {Event} event The keyboard event to consider.
      * @private
      */
     handleKeyDown_: function(event) {
-      event = /** @type {KeyboardEvent} */(event);
+      event = /** @type {KeyboardEvent} */ (event);
       if (event.keyCode == extensions.Key.Escape) {
         if (!this.capturingElement_) {
           // If we're not currently capturing, allow escape to propagate (so it
           // can close the overflow).
           return;
         }
         // Otherwise, escape cancels capturing.
         this.endCapture_(event);
-        var parsed = this.parseElementId_('clear',
+        var parsed = this.parseElementId_(
+            'clear',
             event.target.parentElement.querySelector('.command-clear').id);
         chrome.developerPrivate.updateExtensionCommand({
           extensionId: parsed.extensionId,
           commandName: parsed.commandName,
           keybinding: ''
         });
         event.preventDefault();
         event.stopPropagation();
         return;
       }
       if (event.keyCode == extensions.Key.Tab) {
         // Allow tab propagation for keyboard navigation.
         return;
       }
 
       if (!this.capturingElement_)
         this.startCapture_(event);
 
       this.handleKey_(event);
     },
 
     /**
      * The KeyUp handler.
      * @param {Event} event The keyboard event to consider.
      * @private
      */
     handleKeyUp_: function(event) {
-      event = /** @type {KeyboardEvent} */(event);
+      event = /** @type {KeyboardEvent} */ (event);
       if (event.keyCode == extensions.Key.Tab ||
           event.keyCode == extensions.Key.Escape) {
         // We need to allow tab propagation for keyboard navigation, and escapes
         // are fully handled in handleKeyDown.
         return;
       }
 
       // We want to make it easy to change from Ctrl+Shift+ to just Ctrl+ by
       // releasing Shift, but we also don't want it to be easy to lose for
       // example Ctrl+Shift+F to Ctrl+ just because you didn't release Ctrl
@@ skipping 41 matching lines @@
         var node = event.target;
         while (node && !node.id)
           node = node.parentElement;
 
         this.oldValue_ = keystroke;  // Forget what the old value was.
         var parsed = this.parseElementId_('command', node.id);
 
         // Ending the capture must occur before calling
         // setExtensionCommandShortcut to ensure the shortcut is set.
         this.endCapture_(event);
-        chrome.developerPrivate.updateExtensionCommand(
-            {extensionId: parsed.extensionId,
-             commandName: parsed.commandName,
-             keybinding: keystroke});
+        chrome.developerPrivate.updateExtensionCommand({
+          extensionId: parsed.extensionId,
+          commandName: parsed.commandName,
+          keybinding: keystroke
+        });
       }
     },
 
     /**
      * A handler for the delete command button.
      * @param {Event} event The mouse event to consider.
      * @private
      */
     handleClear_: function(event) {
       var parsed = this.parseElementId_('clear', event.target.id);
-      chrome.developerPrivate.updateExtensionCommand(
-          {extensionId: parsed.extensionId,
-           commandName: parsed.commandName,
-           keybinding: ''});
+      chrome.developerPrivate.updateExtensionCommand({
+        extensionId: parsed.extensionId,
+        commandName: parsed.commandName,
+        keybinding: ''
+      });
     },
 
     /**
      * A handler for the setting the scope of the command.
      * @param {Event} event The mouse event to consider.
      * @private
      */
     handleSetCommandScope_: function(event) {
       var parsed = this.parseElementId_('setCommandScope', event.target.id);
       var element = document.getElementById(
           'setCommandScope-' + parsed.extensionId + '-' + parsed.commandName);
       var scope = element.selectedIndex == 1 ?
           chrome.developerPrivate.CommandScope.GLOBAL :
           chrome.developerPrivate.CommandScope.CHROME;
-      chrome.developerPrivate.updateExtensionCommand(
-          {extensionId: parsed.extensionId,
-           commandName: parsed.commandName,
-           scope: scope});
+      chrome.developerPrivate.updateExtensionCommand({
+        extensionId: parsed.extensionId,
+        commandName: parsed.commandName,
+        scope: scope
+      });
     },
 
     /**
      * A utility function to create a unique element id based on a namespace,
      * extension id and a command name.
      * @param {string} namespace   The namespace to prepend the id with.
      * @param {string} extensionId The extension ID to use in the id.
      * @param {string} commandName The command name to append the id with.
      * @private
      */
     createElementId_: function(namespace, extensionId, commandName) {
       return namespace + '-' + extensionId + '-' + commandName;
     },
 
     /**
      * A utility function to parse a unique element id based on a namespace,
      * extension id and a command name.
      * @param {string} namespace   The namespace to prepend the id with.
      * @param {string} id          The id to parse.
      * @return {{extensionId: string, commandName: string}} The parsed id.
      * @private
      */
     parseElementId_: function(namespace, id) {
       var kExtensionIdLength = 32;
       return {
-        extensionId: id.substring(namespace.length + 1,
-                                  namespace.length + 1 + kExtensionIdLength),
+        extensionId: id.substring(
+            namespace.length + 1, namespace.length + 1 + kExtensionIdLength),
         commandName: id.substring(namespace.length + 1 + kExtensionIdLength + 1)
       };
     },
   };
 
-  return {
-    ExtensionCommandList: ExtensionCommandList
-  };
+  return {ExtensionCommandList: ExtensionCommandList};
 });