Implement first part of supporting global extension commands.

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 232 matching lines @@
     if (tokens[i] == values::kKeyCtrl)
       tokens[i] = values::kKeyCommand;
     else if (tokens[i] == values::kKeyMacCtrl)
       tokens[i] = values::kKeyCtrl;
   }
   return JoinString(tokens, '+');
 }
 
 }  // namespace
 
-Command::Command() {}
+Command::Command() : global_(false) {}
 
 Command::Command(const std::string& command_name,
                  const string16& description,
-                 const std::string& accelerator)
+                 const std::string& accelerator,
+                 bool global)
     : command_name_(command_name),
-      description_(description) {
+      description_(description),
+      global_(global) {
   string16 error;
   accelerator_ = ParseImpl(accelerator, CommandPlatform(), 0,
                            IsNamedCommand(command_name), &error);
 }
 
 Command::~Command() {}
 
 // static
 std::string Command::CommandPlatform() {
 #if defined(OS_WIN)
@@ skipping 155 matching lines @@
     std::string suggested_key_string;
     if (command->GetString(keys::kSuggestedKey, &suggested_key_string) &&
         !suggested_key_string.empty()) {
       // If only a single string is provided, it must be default for all.
       suggestions[values::kKeybindingPlatformDefault] = suggested_key_string;
     } else {
       suggestions[values::kKeybindingPlatformDefault] = "";
     }
   }
 
+  // Check if this is a global or a regular shortcut.
+  bool global = false;
+  command->GetBoolean(keys::kGlobal, &global);
+
   // Normalize the suggestions.
   for (SuggestionMap::iterator iter = suggestions.begin();
        iter != suggestions.end(); ++iter) {
     // Before we normalize Ctrl to Command we must detect when the developer
     // specified Command in the Default section, which will work on Mac after
     // normalization but only fail on other platforms when they try it out on
     // other platforms, which is not what we want.
     if (iter->first == values::kKeybindingPlatformDefault &&
         iter->second.find("Command+") != std::string::npos) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
@@ skipping 42 matching lines @@
         }
         return false;
       }
     }
 
     if (iter->first == key) {
       // This platform is our platform, so grab this key.
       accelerator_ = accelerator;
       command_name_ = command_name;
       description_ = description;
+      global_ = global;
     }
   }
   return true;
 }
 
 base::DictionaryValue* Command::ToValue(const Extension* extension,
                                         bool active) const {
   base::DictionaryValue* extension_data = new base::DictionaryValue();
 
   string16 command_description;
   if (command_name() == values::kBrowserActionCommandEvent ||
       command_name() == values::kPageActionCommandEvent ||
       command_name() == values::kScriptBadgeCommandEvent) {
     command_description =
         l10n_util::GetStringUTF16(IDS_EXTENSION_COMMANDS_GENERIC_ACTIVATE);
   } else {
     command_description = description();
   }
   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