Media Keys should not count towards the max of four shortcuts per extension.

chrome/browser/extensions/api/commands/command_service.cc

 // 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 "chrome/browser/extensions/api/commands/command_service.h"
 
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/prefs/scoped_user_pref_update.h"
@@ skipping 36 matching lines @@
 
 std::string GetPlatformKeybindingKeyForAccelerator(
     const ui::Accelerator& accelerator, const std::string extension_id) {
   std::string key = extensions::Command::CommandPlatform() + ":" +
                     extensions::Command::AcceleratorToString(accelerator);
 
   // Media keys have a 1-to-many relationship with targets, unlike regular
   // shortcut (1-to-1 relationship). That means two or more extensions can
   // register for the same media key so the extension ID needs to be added to
   // the key to make sure the key is unique.
-  if (extensions::CommandService::IsMediaKey(accelerator))
+  if (extensions::Command::IsMediaKey(accelerator))
     key += ":" + extension_id;
 
   return key;
 }
 
 bool IsForCurrentPlatform(const std::string& key) {
   return StartsWithASCII(
       key, extensions::Command::CommandPlatform() + ":", true);
 }
 
@@ skipping 15 matching lines @@
 }
 
 // Checks if |extension| is permitted to automatically assign the |accelerator|
 // key.
 bool CanAutoAssign(const ui::Accelerator& accelerator,
                    const Extension* extension,
                    Profile* profile,
                    bool is_named_command,
                    bool is_global) {
   // Media Keys are non-exclusive, so allow auto-assigning them.
-  if (extensions::CommandService::IsMediaKey(accelerator))
+  if (extensions::Command::IsMediaKey(accelerator))
     return true;
 
   if (is_global) {
     if (!is_named_command)
       return false;  // Browser and page actions are not global in nature.
 
     // Global shortcuts are restricted to (Ctrl|Command)+Shift+[0-9].
 #if defined OS_MACOSX
     if (!accelerator.IsCmdDown())
       return false;
@@ skipping 58 matching lines @@
 ProfileKeyedAPIFactory<CommandService>* CommandService::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 // static
 CommandService* CommandService::Get(content::BrowserContext* context) {
   return ProfileKeyedAPIFactory<CommandService>::GetForProfile(context);
 }
 
 // static
-bool CommandService::IsMediaKey(const ui::Accelerator& accelerator) {
-  if (accelerator.modifiers() != 0)
-    return false;
-
-  return (accelerator.key_code() == ui::VKEY_MEDIA_NEXT_TRACK ||
-          accelerator.key_code() == ui::VKEY_MEDIA_PREV_TRACK ||
-          accelerator.key_code() == ui::VKEY_MEDIA_PLAY_PAUSE ||
-          accelerator.key_code() == ui::VKEY_MEDIA_STOP);
-}
-
-// static
 bool CommandService::RemovesBookmarkShortcut(
     const extensions::Extension* extension) {
   using extensions::SettingsOverrides;
   const SettingsOverrides* settings_overrides =
       SettingsOverrides::Get(extension);
 
   return settings_overrides &&
       SettingsOverrides::RemovesBookmarkShortcut(*settings_overrides) &&
       (extensions::PermissionsData::HasAPIPermission(
           extension,
@@ skipping 61 matching lines @@
 bool CommandService::AddKeybindingPref(
     const ui::Accelerator& accelerator,
     std::string extension_id,
     std::string command_name,
     bool allow_overrides,
     bool global) {
   if (accelerator.key_code() == ui::VKEY_UNKNOWN)
     return false;
 
   // Media Keys are allowed to be used by named command only.
-  DCHECK(!IsMediaKey(accelerator) ||
+  DCHECK(!Command::IsMediaKey(accelerator) ||
          (command_name != manifest_values::kPageActionCommandEvent &&
           command_name != manifest_values::kBrowserActionCommandEvent));
 
   DictionaryPrefUpdate updater(profile_->GetPrefs(),
                                prefs::kExtensionCommands);
   base::DictionaryValue* bindings = updater.Get();
 
   std::string key = GetPlatformKeybindingKeyForAccelerator(accelerator,
                                                            extension_id);
 
@@ skipping 332 matching lines @@
 
   return true;
 }
 
 template <>
 void ProfileKeyedAPIFactory<CommandService>::DeclareFactoryDependencies() {
   DependsOn(ExtensionCommandsGlobalRegistry::GetFactoryInstance());
 }
 
 }  // namespace extensions