[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_split.h"
 #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"
 #include "chrome/browser/ui/accelerator_utils.h"
 #include "chrome/common/extensions/api/commands/commands_handler.h"
 #include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "extensions/common/feature_switch.h"
+#include "extensions/common/manifest_constants.h"
 
 using extensions::Extension;
 using extensions::ExtensionPrefs;
 
 namespace {
 
 const char kExtension[] = "extension";
 const char kCommandName[] = "command_name";
 const char kGlobal[] = "global";
 
 // A preference that indicates that the initial keybindings for the given
 // extension have been set.
 const char kInitialBindingsHaveBeenAssigned[] = "initial_keybindings_set";
 
 std::string GetPlatformKeybindingKeyForAccelerator(
-    const ui::Accelerator& accelerator) {
-  return extensions::Command::CommandPlatform() + ":" +
-         extensions::Command::AcceleratorToString(accelerator);
+    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))
+    key += ":" + extension_id;
+
+  return key;
 }
 
 void SetInitialBindingsHaveBeenAssigned(
     ExtensionPrefs* prefs, const std::string& extension_id) {
   prefs->UpdateExtensionPref(extension_id, kInitialBindingsHaveBeenAssigned,
                              new base::FundamentalValue(true));
 }
 
 bool InitialBindingsHaveBeenAssigned(
     const ExtensionPrefs* prefs, const std::string& extension_id) {
@@ skipping 49 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 58 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.
+  if (IsMediaKey(accelerator)) {
+    DCHECK(command_name != manifest_values::kPageActionCommandEvent &&
+           command_name != manifest_values::kBrowserActionCommandEvent &&
+           command_name != manifest_values::kScriptBadgeCommandEvent);

[Finnur, 2013/11/19 15:29:47]

nit: Probably preferable to do
DCHECK(!IsMediaKey(...) || (...what the DCHECK does now...))
Then the if statement around it isn't needed.

[zhchbin, 2013/11/19 15:49:11]

Done.

+  }
+
   DictionaryPrefUpdate updater(profile_->GetPrefs(),
                                prefs::kExtensionCommands);
   base::DictionaryValue* bindings = updater.Get();
 
-  std::string key = GetPlatformKeybindingKeyForAccelerator(accelerator);
+  std::string key = GetPlatformKeybindingKeyForAccelerator(accelerator,
+                                                           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 73 matching lines @@
     if (extension != extension_id)
       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);
 
+    // Format stored in Preferences is: "Platform:Shortcut[:ExtensionId]".
     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];
+    }
 
     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)) {
+    // Make sure registered Chrome shortcuts cannot be automatically assigned
+    // (overwritten) by extension developers. Media keys are an exception here.
+    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