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;
+}
+
+bool DoesRequireModifier(const std::string& accelerator) {
+  return accelerator != values::kKeyMediaNextTrack &&
+         accelerator != values::kKeyMediaPlayPause &&
+         accelerator != values::kKeyMediaPrevTrack &&
+         accelerator != values::kKeyMediaStop;
+}
+
 ui::Accelerator ParseImpl(const std::string& accelerator,
                           const std::string& platform_key,
                           int index,
+                          bool should_parse_media_keys,
                           string16* error) {
+  error->clear();
   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();
   }
 
   std::vector<std::string> tokens;
   base::SplitString(accelerator, '+', &tokens);
-  if (tokens.size() < 2 || tokens.size() > 3) {
+  if (tokens.size() == 0 ||
+      (tokens.size() == 1 && DoesRequireModifier(accelerator)) ||
+      tokens.size() > 3) {
     *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 31 matching lines @@
                tokens[i] == values::kKeyUp ||
                tokens[i] == values::kKeyDown ||
                tokens[i] == values::kKeyLeft ||
                tokens[i] == values::kKeyRight ||
                tokens[i] == values::kKeyIns ||
                tokens[i] == values::kKeyDel ||
                tokens[i] == values::kKeyHome ||
                tokens[i] == values::kKeyEnd ||
                tokens[i] == values::kKeyPgUp ||
                tokens[i] == values::kKeyPgDwn ||
-               tokens[i] == values::kKeyTab) {
+               tokens[i] == values::kKeyTab ||
+               tokens[i] == values::kKeyMediaNextTrack ||
+               tokens[i] == values::kKeyMediaPlayPause ||
+               tokens[i] == values::kKeyMediaPrevTrack ||
+               tokens[i] == values::kKeyMediaStop) {
       if (key != ui::VKEY_UNKNOWN) {
         // Multiple key assignments.
         key = ui::VKEY_UNKNOWN;
         break;
       }
 
       if (tokens[i] == values::kKeyComma) {
         key = ui::VKEY_OEM_COMMA;
       } else if (tokens[i] == values::kKeyPeriod) {
         key = ui::VKEY_OEM_PERIOD;
@@ skipping 12 matching lines @@
       } 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;
+      } else if (tokens[i] == values::kKeyMediaNextTrack &&
+                 should_parse_media_keys) {
+        key = ui::VKEY_MEDIA_NEXT_TRACK;
+      } else if (tokens[i] == values::kKeyMediaPlayPause &&
+                 should_parse_media_keys) {
+        key = ui::VKEY_MEDIA_PLAY_PAUSE;
+      } else if (tokens[i] == values::kKeyMediaPrevTrack &&
+                 should_parse_media_keys) {
+        key = ui::VKEY_MEDIA_PREV_TRACK;
+      } else if (tokens[i] == values::kKeyMediaStop &&
+                 should_parse_media_keys) {
+        key = ui::VKEY_MEDIA_STOP;
       } 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;
       }
     } else {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidKeyBinding,
           base::IntToString(index),
           platform_key,
           accelerator);
       return ui::Accelerator();
     }
   }
+
   bool command = (modifiers & ui::EF_COMMAND_DOWN) != 0;
   bool ctrl = (modifiers & ui::EF_CONTROL_DOWN) != 0;
   bool alt = (modifiers & ui::EF_ALT_DOWN) != 0;
   bool shift = (modifiers & ui::EF_SHIFT_DOWN) != 0;
 
   // We support Ctrl+foo, Alt+foo, Ctrl+Shift+foo, Alt+Shift+foo, but not
   // Ctrl+Alt+foo and not Shift+foo either. For a more detailed reason why we
   // don't support Ctrl+Alt+foo see this article:
   // http://blogs.msdn.com/b/oldnewthing/archive/2004/03/29/101121.aspx.
   // 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();
   }
 
+  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)) {
+    *error = ErrorUtils::FormatErrorMessageUTF16(
+        errors::kInvalidKeyBindingMediaKeyWithModifier,
+        base::IntToString(index),
+        platform_key,
+        accelerator);
+    return ui::Accelerator();
+  }
+
   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) {
     normalize = true;
@@ skipping 22 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);
+        if (error->empty()) {
+          *error = ErrorUtils::FormatErrorMessageUTF16(
+              errors::kInvalidKeyBinding,
+              base::IntToString(index),
+              iter->first,
+              iter->second);
+        }
         return false;
       }
     }
 
     if (iter->first == key) {
       // This platform is our platform, so grab this key.
       accelerator_ = accelerator;
       command_name_ = command_name;
       description_ = description;
     }
@@ skipping 17 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