[Windows] Finish global and non-global media keys support on Windows.

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"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"

[Finnur, 2013/11/13 10:22:24]

Can either of this include be deleted now?

[zhchbin, 2013/11/13 16:05:11]

Done.

 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/commands/commands.h"
 #include "chrome/browser/extensions/extension_commands_global_registry.h"
 #include "chrome/browser/extensions/extension_function_registry.h"
 #include "chrome/browser/extensions/extension_keybinding_registry.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 84 matching lines @@
 // static
 ProfileKeyedAPIFactory<CommandService>* CommandService::GetFactoryInstance() {
   return &g_factory.Get();
 }
 
 // static
 CommandService* CommandService::Get(Profile* profile) {
   return ProfileKeyedAPIFactory<CommandService>::GetForProfile(profile);
 }
 
+// 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);
+}
+
 bool CommandService::GetBrowserActionCommand(
     const std::string& extension_id,
     QueryType type,
     extensions::Command* command,
     bool* active) {
   return GetExtensionActionCommand(
       extension_id, type, command, active, BROWSER_ACTION);
 }
 
 bool CommandService::GetPageActionCommand(
@@ skipping 63 matching lines @@
     bool allow_overrides,
     bool global) {
   if (accelerator.key_code() == ui::VKEY_UNKNOWN)
     return false;
 
   DictionaryPrefUpdate updater(profile_->GetPrefs(),
                                prefs::kExtensionCommands);
   base::DictionaryValue* bindings = updater.Get();
 
   std::string key = GetPlatformKeybindingKeyForAccelerator(accelerator);
+  if (IsMediaKey(accelerator))

[Finnur, 2013/11/13 10:22:24]

Please document why we do this. Perhaps something along the lines of:

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.

[zhchbin, 2013/11/13 16:05:11]

Done.

+    key += ":" + extension_id;
 
   if (!allow_overrides && bindings->HasKey(key))
     return false;  // Already taken.
 
   base::DictionaryValue* keybinding = new base::DictionaryValue();
   keybinding->SetString(kExtension, extension_id);
   keybinding->SetString(kCommandName, command_name);
   keybinding->SetBoolean(kGlobal, global);
 
   bindings->Set(key, keybinding);
@@ skipping 74 matching lines @@
       continue;
     std::string command_name;
     item->GetString(kCommandName, &command_name);
     if (command != command_name)
       continue;
     bool global = false;
     if (FeatureSwitch::global_commands()->IsEnabled())
       item->GetBoolean(kGlobal, &global);
 
     std::string shortcut = it.key();
-    if (StartsWithASCII(shortcut, Command::CommandPlatform() + ":", true))
-      shortcut = shortcut.substr(Command::CommandPlatform().length() + 1);
+    if (StartsWithASCII(shortcut, Command::CommandPlatform() + ":", true)) {
+      std::vector<std::string> tokens;
+      base::SplitString(shortcut, ':', &tokens);
+      CHECK(tokens.size() >= 2);
+      shortcut = tokens[1];  // The second token is the shortcut assigned.
+    }
 
     return Command(command_name, string16(), shortcut, global);
   }
 
   return Command();
 }
 
 void CommandService::AssignInitialKeybindings(const Extension* extension) {
   const extensions::CommandMap* commands =
       CommandsInfo::GetNamedCommands(extension);
   if (!commands)
     return;
 
   ExtensionService* extension_service =
       ExtensionSystem::Get(profile_)->extension_service();
   ExtensionPrefs* extension_prefs = extension_service->extension_prefs();
   if (InitialBindingsHaveBeenAssigned(extension_prefs, extension->id()))
     return;
   SetInitialBindingsHaveBeenAssigned(extension_prefs, extension->id());
 
   extensions::CommandMap::const_iterator iter = commands->begin();
   for (; iter != commands->end(); ++iter) {
-    if (!chrome::IsChromeAccelerator(
-            iter->second.accelerator(), profile_) &&
-        IsWhitelistedGlobalShortcut(iter->second)) {
+    if ((!chrome::IsChromeAccelerator(iter->second.accelerator(), profile_) &&
+        IsWhitelistedGlobalShortcut(iter->second)) ||
+        extensions::CommandService::IsMediaKey(iter->second.accelerator())) {
       AddKeybindingPref(iter->second.accelerator(),
                         extension->id(),
                         iter->second.command_name(),
                         false,  // Overwriting not allowed.
                         iter->second.global());
     }
   }
 
   const extensions::Command* browser_action_command =
       CommandsInfo::GetBrowserActionCommand(extension);
@@ skipping 130 matching lines @@
 
   return true;
 }
 
 template <>
 void ProfileKeyedAPIFactory<CommandService>::DeclareFactoryDependencies() {
   DependsOn(ExtensionCommandsGlobalRegistry::GetFactoryInstance());
 }
 
 }  // namespace extensions