Convert ExtensionRegistry to a BrowserContextKeyedService

extensions/browser/event_router.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 "extensions/browser/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_map.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_api.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
 
@@ skipping 442 matching lines @@
         }
       }
     }
   }
 }
 
 void EventRouter::DispatchLazyEvent(
     const std::string& extension_id,
     const linked_ptr<Event>& event,
     std::set<EventDispatchIdentifier>* already_dispatched) {
-  ExtensionService* service = ExtensionSystem::GetForBrowserContext(
-      browser_context_)->extension_service();
   // Check both the original and the incognito browser context to see if we
   // should load a lazy bg page to handle the event. The latter case
   // occurs in the case of split-mode extensions.
-  const Extension* extension = service->extensions()->GetByID(extension_id);
+  const Extension* extension =
+      ExtensionRegistry::Get(browser_context_)->enabled_extensions().GetByID(
+          extension_id);
   if (!extension)
     return;
 
   if (MaybeLoadLazyBackgroundPageToDispatchEvent(
           browser_context_, extension, event)) {
     already_dispatched->insert(std::make_pair(browser_context_, extension_id));
   }
 
   ExtensionsBrowserClient* browser_client = ExtensionsBrowserClient::Get();
   if (browser_client->HasOffTheRecordContext(browser_context_) &&
       IncognitoInfo::IsSplitMode(extension)) {
     BrowserContext* incognito_context =
         browser_client->GetOffTheRecordContext(browser_context_);
     if (MaybeLoadLazyBackgroundPageToDispatchEvent(
             incognito_context, extension, event)) {
       already_dispatched->insert(
           std::make_pair(incognito_context, extension_id));
     }
   }
 }
 
 void EventRouter::DispatchEventToProcess(const std::string& extension_id,
                                          content::RenderProcessHost* process,
                                          const linked_ptr<Event>& event) {
-  ExtensionService* service = ExtensionSystem::GetForBrowserContext(
-      browser_context_)->extension_service();
-  const Extension* extension = service->extensions()->GetByID(extension_id);
+  const Extension* extension =
+      ExtensionRegistry::Get(browser_context_)->enabled_extensions().GetByID(
+          extension_id);
 
   // The extension could have been removed, but we do not unregister it until
   // the extension process is unloaded.
   if (!extension)
     return;
 
   BrowserContext* listener_context = process->GetBrowserContext();
   ProcessMap* process_map =
       ExtensionSystem::GetForBrowserContext(listener_context)
           ->extension_service()
@@ skipping 82 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserContext* browser_context =
       reinterpret_cast<BrowserContext*>(browser_context_id);
   if (!ExtensionsBrowserClient::Get()->IsValidContext(browser_context))
     return;
   ExtensionSystem* extension_system =
       ExtensionSystem::GetForBrowserContext(browser_context);
   EventRouter* event_router = extension_system->event_router();
   if (!event_router)
     return;
-  ExtensionService* extension_service = extension_system->extension_service();
   const Extension* extension =
-      extension_service->extensions()->GetByID(extension_id);
+      ExtensionRegistry::Get(browser_context)->enabled_extensions().GetByID(
+          extension_id);
   if (!extension)
     return;
   event_router->IncrementInFlightEvents(browser_context, extension);
 }
 
 void EventRouter::IncrementInFlightEvents(BrowserContext* context,
                                           const Extension* extension) {
   // Only increment in-flight events if the lazy background page is active,
   // because that's the only time we'll get an ACK.
   if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
@@ skipping 141 matching lines @@
 EventDispatchInfo::EventDispatchInfo(const std::string& extension_id,
                                      const std::string& event_name,
                                      scoped_ptr<ListValue> event_args)
     : extension_id(extension_id),
       event_name(event_name),
       event_args(event_args.Pass()) {}
 
 EventDispatchInfo::~EventDispatchInfo() {}
 
 }  // namespace extensions