Remove the deprecated function ExtensionService::extensions().

chrome/browser/extensions/extension_keybinding_registry.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/extension_keybinding_registry.h"
 
 #include "base/values.h"
 #include "chrome/browser/extensions/active_tab_permission_granter.h"
-#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/command.h"
 #include "content/public/browser/browser_context.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
-#include "extensions/browser/extension_system.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/manifest_constants.h"
 
 namespace {
 const char kOnCommandEventName[] = "commands.onCommand";
 }  // namespace
 
 namespace extensions {
 
@@ skipping 42 matching lines @@
 
       // If a specific command_name was requested, it has now been deleted so no
       // further work is required.
       if (!command_name.empty())
         break;
     }
   }
 }
 
 void ExtensionKeybindingRegistry::Init() {
-  ExtensionService* service =
-      ExtensionSystem::Get(browser_context_)->extension_service();
-  if (!service)
-    return;  // ExtensionService can be null during testing.
+  ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context_);
+  if (!registry)
+    return;  // ExtensionRegistry can be null during testing.
 
-  const ExtensionSet* extensions = service->extensions();
-  ExtensionSet::const_iterator iter = extensions->begin();
-  for (; iter != extensions->end(); ++iter)
-    if (ExtensionMatchesFilter(iter->get()))
-      AddExtensionKeybinding(iter->get(), std::string());
+  for (const scoped_refptr<const extensions::Extension>& extension :
+       registry->enabled_extensions())
+    if (ExtensionMatchesFilter(extension.get()))
+      AddExtensionKeybinding(extension.get(), std::string());
 }
 
 bool ExtensionKeybindingRegistry::ShouldIgnoreCommand(
     const std::string& command) const {
   return command == manifest_values::kPageActionCommandEvent ||
          command == manifest_values::kBrowserActionCommandEvent;
 }
 
 bool ExtensionKeybindingRegistry::NotifyEventTargets(
     const ui::Accelerator& accelerator) {
   return ExecuteCommands(accelerator, std::string());
 }
 
 void ExtensionKeybindingRegistry::CommandExecuted(
     const std::string& extension_id, const std::string& command) {
-  ExtensionService* service =
-      ExtensionSystem::Get(browser_context_)->extension_service();
-
-  const Extension* extension = service->extensions()->GetByID(extension_id);
+  const Extension* extension = ExtensionRegistry::Get(browser_context_)
+                                   ->enabled_extensions()
+                                   .GetByID(extension_id);
   if (!extension)
     return;
 
   // Grant before sending the event so that the permission is granted before
   // the extension acts on the command. NOTE: The Global Commands handler does
   // not set the delegate as it deals only with named commands (not page/browser
   // actions that are associated with the current page directly).
   ActiveTabPermissionGranter* granter =
       delegate_ ? delegate_->GetActiveTabPermissionGranter() : NULL;
   if (granter)
@@ skipping 70 matching lines @@
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case extensions::NOTIFICATION_EXTENSION_COMMAND_ADDED:
     case extensions::NOTIFICATION_EXTENSION_COMMAND_REMOVED: {
       std::pair<const std::string, const std::string>* payload =
           content::Details<std::pair<const std::string, const std::string> >(
               details).ptr();
 
-      const Extension* extension = ExtensionSystem::Get(browser_context_)
-                                       ->extension_service()
-                                       ->extensions()
-                                       ->GetByID(payload->first);
+      const Extension* extension = ExtensionRegistry::Get(browser_context_)
+                                       ->enabled_extensions()
+                                       .GetByID(payload->first);
       // During install and uninstall the extension won't be found. We'll catch
       // those events above, with the LOADED/UNLOADED, so we ignore this event.
       if (!extension)
         return;
 
       if (ExtensionMatchesFilter(extension)) {
         if (type == extensions::NOTIFICATION_EXTENSION_COMMAND_ADDED)
           AddExtensionKeybinding(extension, payload->second);
         else
           RemoveExtensionKeybinding(extension, payload->second);
@@ skipping 37 matching lines @@
     if (extension_id.empty() || it->first == extension_id) {
       CommandExecuted(it->first, it->second);
       executed = true;
     }
   }
 
   return executed;
 }
 
 }  // namespace extensions