Move Command class out of the Extension class and into its own location (under chrome/common/exten…

chrome/common/extensions/extension.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/extension.h"
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ skipping 232 matching lines @@
 Extension::OAuth2Info::OAuth2Info() {}
 Extension::OAuth2Info::~OAuth2Info() {}
 
 ExtensionOAuth2Scopes Extension::OAuth2Info::GetScopesAsSet() {
   ExtensionOAuth2Scopes result;
   std::copy(scopes.begin(), scopes.end(),
             std::inserter(result, result.begin()));
   return result;
 }
 
-Extension::Command::Command() {}
-Extension::Command::~Command() {}
-
-ui::Accelerator Extension::Command::ParseImpl(
-    const std::string& shortcut,
-    const std::string& platform_key,
-    int index,
-    string16* error) {
-  if (platform_key != values::kKeybindingPlatformWin &&
-      platform_key != values::kKeybindingPlatformMac &&
-      platform_key != values::kKeybindingPlatformChromeOs &&
-      platform_key != values::kKeybindingPlatformLinux &&
-      platform_key != values::kKeybindingPlatformDefault) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-        errors::kInvalidKeyBindingUnknownPlatform,
-        base::IntToString(index),
-        platform_key);
-    return ui::Accelerator();
-  }
-
-  std::vector<std::string> tokens;
-  base::SplitString(shortcut, '+', &tokens);
-  if (tokens.size() < 2 || tokens.size() > 3) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-        errors::kInvalidKeyBinding,
-        base::IntToString(index),
-        platform_key,
-        shortcut);
-    return ui::Accelerator();
-  }
-
-  // Now, parse it into an accelerator.
-  bool ctrl = false;
-  bool alt = false;
-  bool shift = false;
-  ui::KeyboardCode key = ui::VKEY_UNKNOWN;
-  for (size_t i = 0; i < tokens.size(); i++) {
-    if (tokens[i] == "Ctrl") {
-      ctrl = true;
-    } else if (tokens[i] == "Alt") {
-      alt = true;
-    } else if (tokens[i] == "Shift") {
-      shift = true;
-    } else if (tokens[i] == "Command" && platform_key == "mac") {
-      // TODO(finnur): Implement for Mac.
-    } else if (tokens[i] == "Option" && platform_key == "mac") {
-      // TODO(finnur): Implement for Mac.
-    } else if (tokens[i].size() == 1 &&
-               tokens[i][0] >= 'A' && tokens[i][0] <= 'Z') {
-      if (key != ui::VKEY_UNKNOWN) {
-        // Multiple key assignments.
-        key = ui::VKEY_UNKNOWN;
-        break;
-      }
-
-      key = static_cast<ui::KeyboardCode>(ui::VKEY_A + (tokens[i][0] - 'A'));
-    } else {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidKeyBinding,
-          base::IntToString(index),
-          platform_key,
-          shortcut);
-      return ui::Accelerator();
-    }
-  }
-
-  // We support Ctrl+foo, Alt+foo, Ctrl+Shift+foo, Alt+Shift+foo, but not
-  // Ctrl+Alt+foo. For a more detailed reason why we don't support Ctrl+Alt+foo:
-  // http://blogs.msdn.com/b/oldnewthing/archive/2004/03/29/101121.aspx.
-  if (key == ui::VKEY_UNKNOWN || (ctrl && alt)) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-        errors::kInvalidKeyBinding,
-        base::IntToString(index),
-        platform_key,
-        shortcut);
-    return ui::Accelerator();
-  }
-
-  return ui::Accelerator(key, shift, ctrl, alt);
-}
-
-// static
-std::string Extension::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
-}
-
-bool Extension::Command::Parse(DictionaryValue* command,
-                               const std::string& command_name,
-                               int index,
-                               string16* error) {
-  DCHECK(!command_name.empty());
-
-  // We'll build up a map of platform-to-shortcut suggestions.
-  std::map<const std::string, std::string> suggestions;
-
-  // First try to parse the |suggested_key| as a dictionary.
-  DictionaryValue* suggested_key_dict;
-  if (command->GetDictionary(keys::kSuggestedKey, &suggested_key_dict)) {
-    DictionaryValue::key_iterator iter = suggested_key_dict->begin_keys();
-    for ( ; iter != suggested_key_dict->end_keys(); ++iter) {
-      // For each item in the dictionary, extract the platforms specified.
-      std::string suggested_key_string;
-      if (suggested_key_dict->GetString(*iter, &suggested_key_string) &&
-          !suggested_key_string.empty()) {
-        // Found a platform, add it to the suggestions list.
-        suggestions[*iter] = suggested_key_string;
-      } else {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-            errors::kInvalidKeyBinding,
-            base::IntToString(index),
-            keys::kSuggestedKey,
-            "Missing");
-        return false;
-      }
-    }
-  } else {
-    // No dictionary was found, fall back to using just a string, so developers
-    // don't have to specify a dictionary if they just want to use one default
-    // for all platforms.
-    std::string suggested_key_string;
-    if (command->GetString(keys::kSuggestedKey, &suggested_key_string) &&
-        !suggested_key_string.empty()) {
-      // If only a signle string is provided, it must be default for all.
-      suggestions["default"] = suggested_key_string;
-    } else {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidKeyBinding,
-          base::IntToString(index),
-          keys::kSuggestedKey,
-          "Missing");
-       return false;
-    }
-  }
-
-  std::string platform = CommandPlatform();
-  std::string key = platform;
-  if (suggestions.find(key) == suggestions.end())
-    key = values::kKeybindingPlatformDefault;
-  if (suggestions.find(key) == suggestions.end()) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-        errors::kInvalidKeyBindingMissingPlatform,
-        base::IntToString(index),
-        keys::kSuggestedKey,
-        platform);
-    return false;  // No platform specified and no fallback. Bail.
-  }
-
-  // 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) {
-    // Note that we pass iter->first to pretend we are on a platform we're not
-    // on.
-    ui::Accelerator accelerator =
-        ParseImpl(iter->second, iter->first, index, error);
-    if (accelerator.key_code() == ui::VKEY_UNKNOWN) {
-      *error = ExtensionErrorUtils::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;
-
-      if (command_name !=
-              extension_manifest_values::kPageActionKeybindingEvent &&
-          command_name !=
-              extension_manifest_values::kBrowserActionKeybindingEvent) {
-        if (!command->GetString(keys::kDescription, &description_) ||
-            description_.empty()) {
-          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-              errors::kInvalidKeyBindingDescription,
-              base::IntToString(index));
-          return false;
-        }
-      }
-    }
-  }
-  return true;
-}
-
 //
 // Extension
 //
 
 // static
 scoped_refptr<Extension> Extension::Create(const FilePath& path,
                                            Location location,
                                            const DictionaryValue& value,
                                            int flags,
                                            std::string* utf8_error) {
@@ skipping 1127 matching lines @@
       ++command_index;
 
       DictionaryValue* command = NULL;
       if (!commands->GetDictionary(*iter, &command)) {
         *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidKeyBindingDictionary,
             base::IntToString(command_index));
         return false;
       }
 
-      scoped_ptr<Extension::Command> binding(new Command());
+      scoped_ptr<extensions::Command> binding(new extensions::Command());
       if (!binding->Parse(command, *iter, command_index, error))
         return false;  // |error| already set.
 
       std::string command_name = binding->command_name();
       if (command_name == values::kPageActionKeybindingEvent) {
         page_action_command_.reset(binding.release());
       } else if (command_name == values::kBrowserActionKeybindingEvent) {
         browser_action_command_.reset(binding.release());
       } else {
         if (command_name[0] != '_')  // All commands w/underscore are reserved.
@@ skipping 2120 matching lines @@
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}