Mac global keybindings

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/lazy_instance.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 137 matching lines @@
   const ExtensionSet* extensions = extension_service->extensions();
   const Extension* extension = extensions->GetByID(extension_id);
   CHECK(extension);
 
   command_map->clear();
   const extensions::CommandMap* commands =
       CommandsInfo::GetNamedCommands(extension);
   if (!commands)
     return false;
 
+  VLOG(0) << "Commands size: " << commands->size();
   extensions::CommandMap::const_iterator iter = commands->begin();
   for (; iter != commands->end(); ++iter) {
     // Look up to see if the user has overridden how the command should work.
     extensions::Command saved_command =
         FindCommandByName(extension_id, iter->second.command_name());
     ui::Accelerator shortcut_assigned = saved_command.accelerator();
 
-    if (type == ACTIVE_ONLY && shortcut_assigned.key_code() == ui::VKEY_UNKNOWN)
+    VLOG(0) << "Processing command: " << iter->second.command_name()
+      << ", shortcut assigned: " << shortcut_assigned.key_code()
+      << ", saved command global: " << saved_command.global();
+
+    if (type == ACTIVE_ONLY && shortcut_assigned.key_code() ==
+        ui::VKEY_UNKNOWN) {
+      VLOG(0) << "Discarded due to missing key code";
       continue;
+    }
 
     extensions::Command command = iter->second;
-    if (scope != ANY_SCOPE && ((scope == GLOBAL) != saved_command.global()))
+    if (scope != ANY_SCOPE &&
+        ((scope == GLOBAL) != saved_command.global())) {
+      VLOG(0) << "Discarded due to scope mismatch";
       continue;
+    }
+    VLOG(0) << "HERE";
 
     if (shortcut_assigned.key_code() != ui::VKEY_UNKNOWN)
       command.set_accelerator(shortcut_assigned);
     command.set_global(saved_command.global());
 
+    VLOG(0) << "Adding command " << iter->second.command_name()
+        << " to command map, scope is " << scope;
+
+    VLOG(0) << "Size before: " << (*command_map).size();
     (*command_map)[iter->second.command_name()] = command;
+    VLOG(0) << "Size after: " << (*command_map).size();
   }
 
   return true;
 }
 
 bool CommandService::AddKeybindingPref(
     const ui::Accelerator& accelerator,
     std::string extension_id,
     std::string command_name,
     bool allow_overrides,
     bool global) {
   if (accelerator.key_code() == ui::VKEY_UNKNOWN)
     return false;
 
+  VLOG(0) << "AddKeybindingPref, "
+      << "Global: " << global
+      << "Command name: " << command_name;
   DictionaryPrefUpdate updater(profile_->GetPrefs(),
                                prefs::kExtensionCommands);
   base::DictionaryValue* bindings = updater.Get();
 
   std::string key = GetPlatformKeybindingKeyForAccelerator(accelerator);
 
   if (!allow_overrides && bindings->HasKey(key))
     return false;  // Already taken.
 
   base::DictionaryValue* keybinding = new base::DictionaryValue();
@@ skipping 59 matching lines @@
   // Pre-existing shortcuts must be removed before proceeding because the
   // handlers for global and non-global extensions are not one and the same.
   RemoveKeybindingPrefs(extension_id, command_name);
   AddKeybindingPref(command.accelerator(), extension_id,
                     command_name, true, global);
   return true;
 }
 
 Command CommandService::FindCommandByName(
     const std::string& extension_id, const std::string& command) {
+  VLOG(0) << "FindCommandByName called.";
   const base::DictionaryValue* bindings =
       profile_->GetPrefs()->GetDictionary(prefs::kExtensionCommands);
   for (base::DictionaryValue::Iterator it(*bindings); !it.IsAtEnd();
        it.Advance()) {
     const base::DictionaryValue* item = NULL;
     it.value().GetAsDictionary(&item);
 
     std::string extension;
     item->GetString(kExtension, &extension);
+    VLOG(0) << "Extension: " << extension;
     if (extension != extension_id)
       continue;
     std::string command_name;
     item->GetString(kCommandName, &command_name);
+    VLOG(0) << "Command name: " << command_name;
     if (command != command_name)
       continue;
     bool global = false;
-    if (FeatureSwitch::global_commands()->IsEnabled())
+    VLOG(0) << "--global-commands: "
+        << FeatureSwitch::global_commands()->IsEnabled();
+    if (FeatureSwitch::global_commands()->IsEnabled()) {
       item->GetBoolean(kGlobal, &global);
+      VLOG(0) << "Global: " << global;
+    }
 
     std::string shortcut = it.key();
     if (StartsWithASCII(shortcut, Command::CommandPlatform() + ":", true))
       shortcut = shortcut.substr(Command::CommandPlatform().length() + 1);
 
     return Command(command_name, string16(), shortcut, global);
   }
 
   return Command();
 }
@@ skipping 14 matching lines @@
   extensions::CommandMap::const_iterator iter = commands->begin();
   for (; iter != commands->end(); ++iter) {
     if (!chrome::IsChromeAccelerator(
             iter->second.accelerator(), profile_) &&
         IsWhitelistedGlobalShortcut(iter->second)) {
       AddKeybindingPref(iter->second.accelerator(),
                         extension->id(),
                         iter->second.command_name(),
                         false,  // Overwriting not allowed.
                         iter->second.global());
+      LOG(ERROR) << "CommandService::AssignInitialKeybindings. "
+          << "global: " << iter->second.global();
     }
   }
 
   const extensions::Command* browser_action_command =
       CommandsInfo::GetBrowserActionCommand(extension);
   if (browser_action_command) {
     if (!chrome::IsChromeAccelerator(
         browser_action_command->accelerator(), profile_)) {
       AddKeybindingPref(browser_action_command->accelerator(),
                         extension->id(),
@@ skipping 125 matching lines @@
 
   return true;
 }
 
 template <>
 void ProfileKeyedAPIFactory<CommandService>::DeclareFactoryDependencies() {
   DependsOn(ExtensionCommandsGlobalRegistry::GetFactoryInstance());
 }
 
 }  // namespace extensions