Implement Keybinding for script badges.

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 "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_keybinding_registry.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 39 matching lines @@
 }
 
 CommandService::~CommandService() {
 }
 
 bool CommandService::GetBrowserActionCommand(
     const std::string& extension_id,
     QueryType type,
     extensions::Command* command,
     bool* active) {
-  return GetExtensionActionCommand(extension_id, type, command, active, true);
+  return GetExtensionActionCommand(
+      extension_id, type, command, active, BROWSER_ACTION);
 }
 
 bool CommandService::GetPageActionCommand(
     const std::string& extension_id,
     QueryType type,
     extensions::Command* command,
     bool* active) {
-  return GetExtensionActionCommand(extension_id, type, command, active, false);
+  return GetExtensionActionCommand(
+      extension_id, type, command, active, PAGE_ACTION);
+}
+
+bool CommandService::GetScriptBadgeCommand(
+    const std::string& extension_id,
+    QueryType type,
+    extensions::Command* command,
+    bool* active) {
+  return GetExtensionActionCommand(
+      extension_id, type, command, active, SCRIPT_BADGE);
 }
 
 bool CommandService::GetNamedCommands(const std::string& extension_id,
                                       QueryType type,
                                       extensions::CommandMap* command_map) {
   const ExtensionSet* extensions =
       ExtensionSystem::Get(profile_)->extension_service()->extensions();
   const Extension* extension = extensions->GetByID(extension_id);
   CHECK(extension);
 
@@ skipping 133 matching lines @@
   }
 
   const extensions::Command* page_action_command =
       extension->page_action_command();
   if (page_action_command) {
     AddKeybindingPref(page_action_command->accelerator(),
                       extension->id(),
                       page_action_command->command_name(),
                       false);  // Overwriting not allowed.
   }
+
+  const extensions::Command* script_badge_command =
+      extension->script_badge_command();
+  if (script_badge_command) {
+    AddKeybindingPref(script_badge_command->accelerator(),
+                      extension->id(),
+                      script_badge_command->command_name(),
+                      false);  // Overwriting not allowed.
+  }
 }
 
 void CommandService::RemoveKeybindingPrefs(const std::string& extension_id,
                                            const std::string& command_name) {
   DictionaryPrefUpdate updater(profile_->GetPrefs(),
                                prefs::kExtensionCommands);
   DictionaryValue* bindings = updater.Get();
 
   typedef std::vector<std::string> KeysToRemove;
   KeysToRemove keys_to_remove;
@@ skipping 28 matching lines @@
     std::pair<const std::string, const std::string> details =
         std::make_pair(extension_id, command_name);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_COMMAND_REMOVED,
         content::Source<Profile>(profile_),
         content::Details<
             std::pair<const std::string, const std::string> >(&details));
   }
 }
 
-bool CommandService::GetExtensionActionCommand(const std::string& extension_id,
-                                               QueryType type,
-                                               extensions::Command* command,
-                                               bool* active,
-                                               bool browser_action) {
+bool CommandService::GetExtensionActionCommand(
+    const std::string& extension_id,
+    QueryType query_type,
+    extensions::Command* command,
+    bool* active,
+    ExtensionActionType action_type) {
   const ExtensionSet* extensions =
       ExtensionSystem::Get(profile_)->extension_service()->extensions();
   const Extension* extension = extensions->GetByID(extension_id);
   CHECK(extension);
 
   if (active)
     *active = false;
 
-  const extensions::Command* requested_command =
-      browser_action ? extension->browser_action_command() :
-                       extension->page_action_command();
+  const extensions::Command* requested_command = NULL;
+  switch (action_type) {
+    case BROWSER_ACTION:
+      requested_command = extension->browser_action_command();
+      break;
+    case PAGE_ACTION:
+      requested_command = extension->page_action_command();
+      break;
+    case SCRIPT_BADGE:
+      requested_command = extension->script_badge_command();
+      break;
+  }
   if (!requested_command)
     return false;
 
   ui::Accelerator shortcut_assigned =
       FindShortcutForCommand(extension_id, requested_command->command_name());
 
   if (active)
     *active = (shortcut_assigned.key_code() != ui::VKEY_UNKNOWN);
 
-  if (type == ACTIVE_ONLY && shortcut_assigned.key_code() == ui::VKEY_UNKNOWN)
+  if (query_type == ACTIVE_ONLY &&
+      shortcut_assigned.key_code() == ui::VKEY_UNKNOWN)
     return false;
 
   *command = *requested_command;
   if (shortcut_assigned.key_code() != ui::VKEY_UNKNOWN)
     command->set_accelerator(shortcut_assigned);
 
   return true;
 }
 
 }  // namespace extensions