Revert of Revert "Typecheck JS files for chrome://extensions"

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.
 
+/** @typedef {{active: boolean,
+ *             command_name: string,
+ *             description: string,
+ *             extension_action: boolean,
+ *             extension_id: string,
+ *             global: boolean,
+ *             keybinding: string}}
+ */
+var ExtensionCommand;
+
 cr.define('options', function() {
   'use strict';
 
   /**
    * Creates a new list of extension commands.
    * @param {Object=} opt_propertyBag Optional properties.
    * @constructor
-   * @extends {cr.ui.div}
+   * @extends {HTMLDivElement}
    */
   var ExtensionCommandList = cr.ui.define('div');
 
   /** @const */ var keyComma = 188;
   /** @const */ var keyDel = 46;
   /** @const */ var keyDown = 40;
   /** @const */ var keyEnd = 35;
   /** @const */ var keyEscape = 27;
   /** @const */ var keyHome = 36;
   /** @const */ var keyIns = 45;
@@ skipping 15 matching lines @@
    */
   var Modifiers = {
     ARE_NOT_ALLOWED: 0,
     ARE_REQUIRED: 1
   };
 
   /**
    * Returns whether the passed in |keyCode| is a valid extension command
    * char or not. This is restricted to A-Z and 0-9 (ignoring modifiers) at
    * the moment.
-   * @param {int} keyCode The keycode to consider.
+   * @param {number} keyCode The keycode to consider.
    * @return {boolean} Returns whether the char is valid.
    */
   function validChar(keyCode) {
     return keyCode == keyComma ||
            keyCode == keyDel ||
            keyCode == keyDown ||
            keyCode == keyEnd ||
            keyCode == keyHome ||
            keyCode == keyIns ||
            keyCode == keyLeft ||
@@ skipping 73 matching lines @@
       }
     }
 
     return output;
   }
 
   /**
    * Returns whether the passed in |keyCode| require modifiers. Currently only
    * "MediaNextTrack", "MediaPrevTrack", "MediaStop", "MediaPlayPause" are
    * required to be used without any modifier.
-   * @param {int} keyCode The keycode to consider.
+   * @param {number} keyCode The keycode to consider.
    * @return {Modifiers} Returns whether the keycode require modifiers.
    */
   function modifiers(keyCode) {
     switch (keyCode) {
       case keyMediaNextTrack:
       case keyMediaPlayPause:
       case keyMediaPrevTrack:
       case keyMediaStop:
         return Modifiers.ARE_NOT_ALLOWED;
       default:
@@ skipping 14 matching lines @@
            (countShiftAsModifier && event.shiftKey);
   }
 
   ExtensionCommandList.prototype = {
     __proto__: HTMLDivElement.prototype,
 
     /**
      * While capturing, this records the current (last) keyboard event generated
      * by the user. Will be |null| after capture and during capture when no
      * keyboard event has been generated.
-     * @type: {keyboard event}.
+     * @type {KeyboardEvent}.
      * @private
      */
     currentKeyEvent_: null,
 
     /**
      * While capturing, this keeps track of the previous selection so we can
      * revert back to if no valid assignment is made during capture.
-     * @type: {string}.
+     * @type {string}.
      * @private
      */
     oldValue_: '',
 
     /**
      * While capturing, this keeps track of which element the user asked to
      * change.
-     * @type: {HTMLElement}.
+     * @type {HTMLElement}.
      * @private
      */
     capturingElement_: null,
 
     /** @override */
     decorate: function() {
       this.textContent = '';
 
       // Iterate over the extension data and add each item to the list.
       this.data_.commands.forEach(this.createNodeForExtension_.bind(this));
@@ skipping 16 matching lines @@
       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));
     },
 
     /**
      * Synthesizes and initializes an HTML element for the extension command
      * metadata given in |command|.
-     * @param {Object} command A dictionary of extension command metadata.
+     * @param {ExtensionCommand} command A dictionary of extension command
+     *     metadata.
      * @private
      */
     createNodeForCommand_: function(command) {
       var template = $('template-collection-extension-commands').querySelector(
           '.extension-command-list-command-item-wrapper');
       var node = template.cloneNode(true);
       node.id = this.createElementId_(
           'command', command.extension_id, command.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('focus', this.handleFocus_.bind(this));
       shortcutNode.addEventListener('blur', this.handleBlur_.bind(this));
-      shortcutNode.addEventListener('keydown',
-                                    this.handleKeyDown_.bind(this));
+      shortcutNode.addEventListener('keydown', this.handleKeyDown_.bind(this));
       shortcutNode.addEventListener('keyup', this.handleKeyUp_.bind(this));
       if (!command.active) {
         shortcutNode.textContent =
             loadTimeData.getString('extensionCommandsInactive');
 
         var commandShortcut = node.querySelector('.command-shortcut');
         commandShortcut.classList.add('inactive-keybinding');
       } else {
         shortcutNode.textContent = command.keybinding;
       }
@@ skipping 45 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_ = 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 51 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);
       if (event.keyCode == keyEscape) {
         // Escape cancels capturing.
         this.endCapture_(event);
         var parsed = this.parseElementId_('clear',
             event.target.parentElement.querySelector('.command-clear').id);
         chrome.send('setExtensionCommandShortcut',
             [parsed.extensionId, parsed.commandName, '']);
         event.preventDefault();
         event.stopPropagation();
         return;
       }
       if (event.keyCode == keyTab) {
         // 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);
       if (event.keyCode == keyTab) {
         // Allow tab propagation for keyboard navigation.
         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
       // as fast as the other two keys. Therefore, we process KeyUp until you
       // have a valid combination and then stop processing it (meaning that once
       // you have a valid combination, we won't change it until the next
       // KeyDown message arrives).
       if (!this.currentKeyEvent_ || !validChar(this.currentKeyEvent_.keyCode)) {
         if (!event.ctrlKey && !event.altKey) {
           // If neither Ctrl nor Alt is pressed then it is not a valid shortcut.
           // That means we're back at the starting point so we should restart
           // capture.
           this.endCapture_(event);
           this.startCapture_(event);
         } else {
           this.handleKey_(event);
         }
       }
     },
 
     /**
      * A general key handler (used for both KeyDown and KeyUp).
-     * @param {Event} event The keyboard event to consider.
+     * @param {KeyboardEvent} event The keyboard event to consider.
      * @private
      */
     handleKey_: function(event) {
       // While capturing, we prevent all events from bubbling, to prevent
       // shortcuts lacking the right modifier (F3 for example) from activating
       // and ending capture prematurely.
       event.preventDefault();
       event.stopPropagation();
 
       if (modifiers(event.keyCode) == Modifiers.ARE_REQUIRED &&
@@ skipping 63 matching lines @@
      */
     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 {object} The parsed id, as an object with two members:
-     *                  extensionID and commandName.
+     * @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),
         commandName: id.substring(namespace.length + 1 + kExtensionIdLength + 1)
       };
     },
   };
 
   return {
     ExtensionCommandList: ExtensionCommandList
   };
 });