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 keyPageDown = 34;
   /** @const */ var keyPageUp = 33;
   /** @const */ var keyPeriod = 190;
   /** @const */ var keyRight = 39;
   /** @const */ var keyTab = 9;
   /** @const */ var keyUp = 38;
+  /** @const */ var keyMediaNextTrack = 176;
+  /** @const */ var keyMediaPrevTrack = 177;
+  /** @const */ var keyMediaStop = 178;
+  /** @const */ var keyMediaPlayPause = 179;

[Finnur, 2013/09/04 11:28:12]

The list is alphabetical so this should not be at the bottom.

[zhchbin, 2013/09/04 12:50:03]

Done.

 
   /**
    * 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 == keyPageDown ||
            keyCode == keyPageUp ||
            keyCode == keyPeriod ||
            keyCode == keyRight ||
            keyCode == keyTab ||
            keyCode == keyUp ||
+           keyCode == keyMediaNextTrack ||
+           keyCode == keyMediaPrevTrack ||
+           keyCode == keyMediaStop ||
+           keyCode == keyMediaPlayPause ||

[Finnur, 2013/09/04 11:28:12]

Same here.

[zhchbin, 2013/09/04 12:50:03]

Done.

            (keyCode >= 'A'.charCodeAt(0) && keyCode <= 'Z'.charCodeAt(0)) ||
            (keyCode >= '0'.charCodeAt(0) && keyCode <= '9'.charCodeAt(0));
   }
 
   /**
    * Convert a keystroke event to string form, while taking into account
    * (ignoring) invalid extension commands.
    * @param {Event} event The keyboard event to convert.
    * @return {string} The keystroke as a string.
    */
@@ skipping 34 matching lines @@
           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;
+          case keyMediaNextTrack:
+            output += 'MediaNextTrack'; break;
+          case keyMediaPrevTrack:
+            output += 'MediaPrevTrack'; break;
+          case keyMediaStop:
+            output += 'MediaStop'; break;
+          case keyMediaPlayPause:
+            output += 'MediaPlayPause'; break;

[Finnur, 2013/09/04 11:28:12]

Same here.

[zhchbin, 2013/09/04 12:50:03]

Done.

         }
       }
     }
 
     return output;
   }
 
+  /**
+   * Returns whether the passed in |keyCode| is a keycode of media key. This is
+   * restricted to 'MediaNextTrack', 'MediaPrevTrack', 'MediaStop',
+   * 'MediaPlayPause' at the moment.
+   * @param {int} keyCode The keycode to consider.
+   * @return {boolean} Returns whether the keycode is media key.
+   */
+  function isMediaKey(keyCode) {

[Finnur, 2013/09/04 11:28:12]

I'd like to make this function a bit more general, so that if we add more keys
it is easy to just add to this matrix. It also helps make the code below a bit
more general and readable. So, I would do this:

function modifiers(keyCode) {
  switch (keycode) {
   case keyMediaNextTrack:
   case keyMediaPrevTrack:
   case keyMediaStop:
   case keyMediaPlayPause:
     return areNotAllowed;
   default:
     return areRequired;
  }
}

areAllowed and areRequired can be enums (consts) at the top.

Remember to fix the comment for this function too.

[zhchbin, 2013/09/04 12:50:03]

Done with using a enum:

  /**
   * Enum for whether we require modifiers of a keycode.
   * @enum {number}
   */
  var Modifiers = {
    ARE_NOT_REQUIRED: 0,
    ARE_REQUIRED: 1
  };

+    return keyCode == keyMediaNextTrack ||
+           keyCode == keyMediaPrevTrack ||
+           keyCode == keyMediaStop ||
+           keyCode == keyMediaPlayPause;
+  }
+
   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 (!event.ctrlKey && !event.altKey && (!cr.isMac || !event.metaKey) &&
+          !isMediaKey(event.keyCode)) {
+        // Ctrl or Alt is a must (or Cmd on Mac), except for Media Keys.
+        return;
+      }
+
+      // Modifiers can not be used in combination with the Media Keys.
+      if (isMediaKey(event.keyCode)) {
+        if (event.ctrlKey || event.altKey || (cr.isMac && event.metaKey) ||
+            event.shiftKey)
+          return;
+      }

[Finnur, 2013/09/04 11:28:12]

I think this is a bit more readable:

function hasModifier(event, countShiftAsModifier) {
  return event.ctrlKey || event.altKey || (cr.isMac && event.metaKey) ||
         (countShiftAsModifier && event.shiftKey);
}

if (modifiers(event.keyCode) == areRequired && !hasModifier(event, false)) {
  // Ctrl or Alt (or Cmd on Mac) is a must for most shortcuts.
  return;
}

if (modifiers(event.keyCode) == areNotAllowed && hasModifier(event, true))
  return;

You can even (for extra readability) create an enum for "ignoreShift" and "all"
instead of using a bool for countShiftAsModifier.

[zhchbin, 2013/09/04 12:50:03]

Done with still using a boolean for countShiftAsModifier.

 
       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
   };
 });