Parse media keys for named command in the manifest.

chrome/common/extensions/command.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/common/extensions/command.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ skipping 11 matching lines @@
 using extensions::ErrorUtils;
 using extensions::Command;
 
 namespace {
 
 static const char kMissing[] = "Missing";
 
 static const char kCommandKeyNotSupported[] =
     "Command key is not supported. Note: Ctrl means Command on Mac";
 
+bool IsNamedCommand(const std::string& command_name) {
+  return command_name != values::kPageActionCommandEvent &&
+         command_name != values::kBrowserActionCommandEvent &&
+         command_name != values::kScriptBadgeCommandEvent;
+}
+
 ui::Accelerator ParseImpl(const std::string& accelerator,
                           const std::string& platform_key,
                           int index,
+                          bool should_parse_media_keys,
                           string16* error) {
   if (platform_key != values::kKeybindingPlatformWin &&
       platform_key != values::kKeybindingPlatformMac &&
       platform_key != values::kKeybindingPlatformChromeOs &&
       platform_key != values::kKeybindingPlatformLinux &&
       platform_key != values::kKeybindingPlatformDefault) {
     *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidKeyBindingUnknownPlatform,
         base::IntToString(index),
         platform_key);
     return ui::Accelerator();
   }
 
+  if (should_parse_media_keys) {
+    if (accelerator == values::kKeyMediaNextTrack)
+      return ui::Accelerator(ui::VKEY_MEDIA_NEXT_TRACK, ui::EF_NONE);
+    if (accelerator == values::kKeyMediaPlayPause)
+      return ui::Accelerator(ui::VKEY_MEDIA_PLAY_PAUSE, ui::EF_NONE);
+    if (accelerator == values::kKeyMediaPrevTrack)
+      return ui::Accelerator(ui::VKEY_MEDIA_PREV_TRACK, ui::EF_NONE);
+    if (accelerator == values::kKeyMediaStop)
+      return ui::Accelerator(ui::VKEY_MEDIA_STOP, ui::EF_NONE);

[Finnur, 2013/08/28 14:15:16]

This seems a bit ad-hoc. Also, I think we need to make sure modifiers don't work
(such as Ctrl+Shift+MediaKeys). I would delete this code block and implement it
below.

+  }
+
   std::vector<std::string> tokens;
   base::SplitString(accelerator, '+', &tokens);
   if (tokens.size() < 2 || tokens.size() > 3) {

[zhchbin, 2013/08/29 06:20:14]

Note: if the size of tokens is 1, it will fail and return. Our case:
"MediaNextTrack", there is no '+' in the accelerator and the size of tokens is
1.

[Finnur, 2013/08/29 11:20:52]

Yes, change this if statement to become:

if (tokens.size() == 0 ||
    (tokens.size() == 1 && DoesRequireModifier(accelerator)) ||
    tokens.size() > 3) {
  ... do what it does now (show error) ...
}

Then implement DoesRequireModifier to return true for all accelerators but the
Media Keys.

[zhchbin, 2013/08/29 14:27:11]

Done.

     *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidKeyBinding,
         base::IntToString(index),
         platform_key,
         accelerator);
     return ui::Accelerator();
   }
 
   // Now, parse it into an accelerator.
   int modifiers = ui::EF_NONE;
@@ skipping 63 matching lines @@
         key = ui::VKEY_DELETE;
       } else if (tokens[i] == values::kKeyHome) {
         key = ui::VKEY_HOME;
       } else if (tokens[i] == values::kKeyEnd) {
         key = ui::VKEY_END;
       } else if (tokens[i] == values::kKeyPgUp) {
         key = ui::VKEY_PRIOR;
       } else if (tokens[i] == values::kKeyPgDwn) {
         key = ui::VKEY_NEXT;
       } else if (tokens[i] == values::kKeyTab) {
         key = ui::VKEY_TAB;

[Finnur, 2013/08/28 14:15:16]

Add values::kKeyMediaNextTrack (and the other media keys) after the vKeyTab
clause and assign ui::VKEY_MEDIA_NEXT_TRACK (etc) to |key|. Remember to include
should_parse_media_keys in the if clause for *each* key.

[zhchbin, 2013/08/29 14:27:11]

Done.

       } else if (tokens[i].size() == 1 &&
                  tokens[i][0] >= 'A' && tokens[i][0] <= 'Z') {
         key = static_cast<ui::KeyboardCode>(ui::VKEY_A + (tokens[i][0] - 'A'));
       } else if (tokens[i].size() == 1 &&
                  tokens[i][0] >= '0' && tokens[i][0] <= '9') {
         key = static_cast<ui::KeyboardCode>(ui::VKEY_0 + (tokens[i][0] - '0'));
       } else {
         key = ui::VKEY_UNKNOWN;
         break;
       }
@@ skipping 18 matching lines @@
   // On Mac Command can also be used in combination with Shift or on its own,
   // as a modifier.
   if (key == ui::VKEY_UNKNOWN || (ctrl && alt) || (command && alt) ||
       (shift && !ctrl && !alt && !command)) {
     *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidKeyBinding,
         base::IntToString(index),
         platform_key,
         accelerator);
     return ui::Accelerator();
   }

[Finnur, 2013/08/28 14:15:16]

Add an if clause:

if ((key == ui::VKEY_MEDIA_NEXT_TRACK ||
    key == ui::VKEY_MEDIA_PREV_TRACK ||
    key == ui::VKEY_MEDIA_PLAY_PAUSE ||
    key == ui::VKEY_MEDIA_STOP) &&
    (shift || ctrl || alt || command)) {
  // Set *error to a message saying Media Keys cannot have a modifier.
  return ui::Accelerator();
}

[zhchbin, 2013/08/29 14:27:11]

Done.

 
   return ui::Accelerator(key, modifiers);
 }
 
 // For Mac, we convert "Ctrl" to "Command" and "MacCtrl" to "Ctrl". Other
 // platforms leave the shortcut untouched.
 std::string NormalizeShortcutSuggestion(const std::string& suggestion,
                                         const std::string& platform) {
   bool normalize = false;
   if (platform == values::kKeybindingPlatformMac) {
@@ skipping 23 matching lines @@
 namespace extensions {
 
 Command::Command() {}
 
 Command::Command(const std::string& command_name,
                  const string16& description,
                  const std::string& accelerator)
     : command_name_(command_name),
       description_(description) {
   string16 error;
-  accelerator_ = ParseImpl(accelerator, CommandPlatform(), 0, &error);
+  accelerator_ = ParseImpl(accelerator, CommandPlatform(), 0,
+                           IsNamedCommand(command_name), &error);
 }
 
 Command::~Command() {}
 
 // static
 std::string Command::CommandPlatform() {
 #if defined(OS_WIN)
   return values::kKeybindingPlatformWin;
 #elif defined(OS_MACOSX)
   return values::kKeybindingPlatformMac;
 #elif defined(OS_CHROMEOS)
   return values::kKeybindingPlatformChromeOs;
 #elif defined(OS_LINUX)
   return values::kKeybindingPlatformLinux;
 #else
   return "";
 #endif
 }
 
 // static
-ui::Accelerator Command::StringToAccelerator(const std::string& accelerator) {
+ui::Accelerator Command::StringToAccelerator(const std::string& accelerator,
+                                             const std::string& command_name) {
   string16 error;
-  Command command;
   ui::Accelerator parsed =
-      ParseImpl(accelerator, Command::CommandPlatform(), 0, &error);
+      ParseImpl(accelerator, Command::CommandPlatform(), 0,
+                IsNamedCommand(command_name), &error);
   return parsed;
 }
 
 // static
 std::string Command::AcceleratorToString(const ui::Accelerator& accelerator) {
   std::string shortcut;
 
   // Ctrl and Alt are mutually exclusive.
   if (accelerator.IsCtrlDown())
     shortcut += values::kKeyCtrl;
@@ skipping 52 matching lines @@
         break;
       case ui::VKEY_PRIOR:
         shortcut += values::kKeyPgUp;
         break;
       case ui::VKEY_NEXT:
         shortcut += values::kKeyPgDwn;
         break;
       case ui::VKEY_TAB:
         shortcut += values::kKeyTab;
         break;
+      case ui::VKEY_MEDIA_NEXT_TRACK:
+        shortcut += values::kKeyMediaNextTrack;
+        break;
+      case ui::VKEY_MEDIA_PLAY_PAUSE:
+        shortcut += values::kKeyMediaPlayPause;
+        break;
+      case ui::VKEY_MEDIA_PREV_TRACK:
+        shortcut += values::kKeyMediaPrevTrack;
+        break;
+      case ui::VKEY_MEDIA_STOP:
+        shortcut += values::kKeyMediaStop;
+        break;
       default:
         return "";
     }
   }
   return shortcut;
 }
 
 bool Command::Parse(const base::DictionaryValue* command,
                     const std::string& command_name,
                     int index,
                     string16* error) {
   DCHECK(!command_name.empty());
 
   string16 description;
-  if (command_name != values::kPageActionCommandEvent &&
-      command_name != values::kBrowserActionCommandEvent &&
-      command_name != values::kScriptBadgeCommandEvent) {
+  if (IsNamedCommand(command_name)) {
     if (!command->GetString(keys::kDescription, &description) ||
         description.empty()) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidKeyBindingDescription,
           base::IntToString(index));
       return false;
     }
   }
 
   // We'll build up a map of platform-to-shortcut suggestions.
@@ skipping 70 matching lines @@
 
   // For developer convenience, we parse all the suggestions (and complain about
   // errors for platforms other than the current one) but use only what we need.
   std::map<const std::string, std::string>::const_iterator iter =
       suggestions.begin();
   for ( ; iter != suggestions.end(); ++iter) {
     ui::Accelerator accelerator;
     if (!iter->second.empty()) {
       // Note that we pass iter->first to pretend we are on a platform we're not
       // on.
-      accelerator = ParseImpl(iter->second, iter->first, index, error);
+      accelerator = ParseImpl(iter->second, iter->first, index,
+                              IsNamedCommand(command_name), error);
       if (accelerator.key_code() == ui::VKEY_UNKNOWN) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidKeyBinding,
             base::IntToString(index),
             iter->first,
             iter->second);
         return false;
       }
     }
 
@@ skipping 23 matching lines @@
   extension_data->SetString("description", command_description);
   extension_data->SetBoolean("active", active);
   extension_data->SetString("keybinding", accelerator().GetShortcutText());
   extension_data->SetString("command_name", command_name());
   extension_data->SetString("extension_id", extension->id());
 
   return extension_data;
 }
 
 }  // namespace extensions