Enable user assign media keys in chrome://extensions page.

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.
 
 cr.define('options', function() {
   'use strict';
 
   /**
    * Creates a new list of extension commands.
    * @param {Object=} opt_propertyBag Optional properties.
    * @constructor
    * @extends {cr.ui.div}
    */
   var ExtensionCommandList = cr.ui.define('div');
 
   /** @const */ var keyComma = 188;
   /** @const */ var keyDel = 46;
   /** @const */ var keyDown = 40;
   /** @const */ var keyEnd = 35;
   /** @const */ var keyHome = 36;
   /** @const */ var keyIns = 45;
   /** @const */ var keyLeft = 37;
+  /** @const */ var keyMediaNextTrack = 176;
+  /** @const */ var keyMediaPlayPause = 179;
+  /** @const */ var keyMediaPrevTrack = 177;
+  /** @const */ var keyMediaStop = 178;
   /** @const */ var keyPageDown = 34;
   /** @const */ var keyPageUp = 33;
   /** @const */ var keyPeriod = 190;
   /** @const */ var keyRight = 39;
   /** @const */ var keyTab = 9;
   /** @const */ var keyUp = 38;
 
   /**
+   * Enum for whether we require modifiers of a keycode.
+   * @enum {number}
+   */
+  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.
    * @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 ||
+           keyCode == keyMediaNextTrack ||
+           keyCode == keyMediaPlayPause ||
+           keyCode == keyMediaPrevTrack ||
+           keyCode == keyMediaStop ||
            keyCode == keyPageDown ||
            keyCode == keyPageUp ||
            keyCode == keyPeriod ||
            keyCode == keyRight ||
            keyCode == keyTab ||
            keyCode == keyUp ||
            (keyCode >= 'A'.charCodeAt(0) && keyCode <= 'Z'.charCodeAt(0)) ||
            (keyCode >= '0'.charCodeAt(0) && keyCode <= '9'.charCodeAt(0));
   }
 
@@ skipping 28 matching lines @@
           case keyDown:
             output += 'Down'; break;
           case keyEnd:
             output += 'End'; break;
           case keyHome:
             output += 'Home'; break;
           case keyIns:
             output += 'Insert'; break;
           case keyLeft:
             output += 'Left'; break;
+          case keyMediaNextTrack:
+            output += 'MediaNextTrack'; break;
+          case keyMediaPlayPause:
+            output += 'MediaPlayPause'; break;
+          case keyMediaPrevTrack:
+            output += 'MediaPrevTrack'; break;
+          case keyMediaStop:
+            output += 'MediaStop'; break;
           case keyPageDown:
             output += 'PageDown'; break;
           case keyPageUp:
             output += 'PageUp'; break;
           case keyPeriod:
             output += 'Period'; break;
           case keyRight:
             output += 'Right'; break;
           case keyTab:
             output += 'Tab'; break;
           case keyUp:
             output += 'Up'; break;
         }
       }
     }
 
     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.
+   * @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:
+        return Modifiers.ARE_REQUIRED;
+    }
+  }
+
+  /**
+   * Return true if the specified keyboard event has any one of following
+   * modifiers: "Ctrl", "Alt", "Cmd" on Mac, and "Shift" when the
+   * countShiftAsModifier is true.
+   * @param {Event} event The keyboard event to consider.
+   * @param {boolean} countShiftAsModifier Whether the 'ShiftKey' should be
+   *     counted as modifier.
+   */
+  function hasModifier(event, countShiftAsModifier) {
+    return event.ctrlKey || event.altKey || (cr.isMac && event.metaKey) ||
+           (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}.
      * @private
      */
@@ skipping 194 matching lines @@
      * @param {Event} 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 (!event.ctrlKey && !event.altKey && (!cr.isMac || !event.metaKey))
-        return;  // Ctrl or Alt is a must (or Cmd on Mac).
+      if (modifiers(event.keyCode) == Modifiers.ARE_REQUIRED &&
+          !hasModifier(event, false)) {
+        // Ctrl or Alt (or Cmd on Mac) is a must for most shortcuts.
+        return;
+      }
+
+      if (modifiers(event.keyCode) == Modifiers.ARE_NOT_ALLOWED &&
+          hasModifier(event, true)) {
+        return;
+      }
 
       var shortcutNode = this.capturingElement_;
       var keystroke = keystrokeToString(event);
       shortcutNode.textContent = keystroke;
       event.target.classList.add('contains-chars');
 
       if (validChar(event.keyCode)) {
         var node = event.target;
         while (node && !node.id)
           node = node.parentElement;
@@ skipping 47 matching lines @@
                                   namespace.length + 1 + kExtensionIdLength),
         commandName: id.substring(namespace.length + 1 + kExtensionIdLength + 1)
       };
     },
   };
 
   return {
     ExtensionCommandList: ExtensionCommandList
   };
 });