Observe OnExtensionLoaded to trigger update of chrome.commands keybindings for component extensions.

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 <vector>
 
 #include "base/lazy_instance.h"
 #include "base/prefs/scoped_user_pref_update.h"
@@ skipping 276 matching lines @@
       std::make_pair(extension_id, command_name);
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_EXTENSION_COMMAND_ADDED,
       content::Source<Profile>(profile_),
       content::Details<std::pair<const std::string, const std::string> >(
           &details));
 
   return true;
 }
 
-void CommandService::OnExtensionWillBeInstalled(
-    content::BrowserContext* browser_context,
-    const Extension* extension,
-    bool is_update,
-    bool from_ephemeral,
-    const std::string& old_name) {
+void CommandService::OnExtensionLoaded(content::BrowserContext* browser_context,
+                                       const Extension* extension) {
   UpdateKeybindings(extension);
 }
 
-void CommandService::OnExtensionUninstalled(
+void CommandService::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
-    extensions::UninstallReason reason) {
+    UnloadedExtensionInfo::Reason reason) {
   RemoveKeybindingPrefs(extension->id(), std::string());

[Finnur, 2014/12/10 12:25:38]

If I temporarily disable an extension/it crashes, won't that 
unregister the keybinding? What if a new extension is then installed, which
overlaps in keybindings. Who wins if the initial extension gets re-enabled?

What happens if I install extension A and B, which request the same keybinding
and start toggling them enabled/disabled. Will keybindings change as a result?

Should we perhaps listen to both sets of series (Load-Unload vs.
Install-Uninstall) and act on Load/Unload only for Component Extensions, because
those won't be "toggle-able"?

[David Tseng, 2014/12/10 17:27:51]

Done.
Yup; that's the right way to do this; had only tested with component extensions.
Install does get called when the component extension gets loaded into a new
profile, so we need to qualify on Manifest::COMPONENT. in all OnExtension*.

 }
 
 void CommandService::UpdateKeybindingPrefs(const std::string& extension_id,
                                            const std::string& command_name,
                                            const std::string& keystroke) {
   Command command = FindCommandByName(extension_id, command_name);
 
   // The extension command might be assigned another shortcut. Remove that
   // shortcut before proceeding.
   RemoveKeybindingPrefs(extension_id, command_name);
@@ skipping 542 matching lines @@
   return true;
 }
 
 template <>
 void
 BrowserContextKeyedAPIFactory<CommandService>::DeclareFactoryDependencies() {
   DependsOn(ExtensionCommandsGlobalRegistry::GetFactoryInstance());
 }
 
 }  // namespace extensions