Split ExtensionSystem interface from ExtensionSystemImpl implementation, part 1.

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_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_prefs.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_system.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 41 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&NotifyExtensionDispatchObserverOnUIThread,
                    browser_context_id, base::Passed(&details)));
   } else {
     BrowserContext* context =
         reinterpret_cast<BrowserContext*>(browser_context_id);
     if (!ExtensionsBrowserClient::Get()->IsValidContext(context))
       return;
-    ExtensionSystem* extension_system =
-        ExtensionSystem::GetForBrowserContext(context);
+    ExtensionSystem* extension_system = ExtensionSystem::Get(context);
     EventRouter* event_router = extension_system->event_router();
     if (!event_router)
       return;
     if (event_router->event_dispatch_observer_) {
       event_router->event_dispatch_observer_->OnWillDispatchEvent(
           details.Pass());
     }
   }
 }
 
@@ skipping 470 matching lines @@
   return util::CanCrossIncognito(extension, context);
 }
 
 bool EventRouter::MaybeLoadLazyBackgroundPageToDispatchEvent(
     BrowserContext* context,
     const Extension* extension,
     const linked_ptr<Event>& event) {
   if (extension->is_ephemeral() && !event->can_load_ephemeral_apps) {
     // Most events can only be dispatched to ephemeral apps that are already
     // running.
-    ProcessManager* pm =
-        ExtensionSystem::GetForBrowserContext(context)->process_manager();
+    ProcessManager* pm = ExtensionSystem::Get(context)->process_manager();
     if (!pm->GetBackgroundHostForExtension(extension->id()))
       return false;
   }
 
   if (!CanDispatchEventToBrowserContext(context, extension, event))
     return false;
 
-  LazyBackgroundTaskQueue* queue = ExtensionSystem::GetForBrowserContext(
+  LazyBackgroundTaskQueue* queue = ExtensionSystem::Get(
       context)->lazy_background_task_queue();
   if (queue->ShouldEnqueueTask(context, extension)) {
     linked_ptr<Event> dispatched_event(event);
 
     // If there's a dispatch callback, call it now (rather than dispatch time)
     // to avoid lifetime issues. Use a separate copy of the event args, so they
     // last until the event is dispatched.
     if (!event->will_dispatch_callback.is_null()) {
       dispatched_event.reset(event->DeepCopy());
       dispatched_event->will_dispatch_callback.Run(
@@ skipping 13 matching lines @@
 
 // static
 void EventRouter::IncrementInFlightEventsOnUI(
     void* browser_context_id,
     const std::string& extension_id) {
   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);
+  ExtensionSystem* extension_system = ExtensionSystem::Get(browser_context);
   EventRouter* event_router = extension_system->event_router();
   if (!event_router)
     return;
   const Extension* extension =
       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)) {
-    ProcessManager* pm =
-        ExtensionSystem::GetForBrowserContext(context)->process_manager();
+    ProcessManager* pm = ExtensionSystem::Get(context)->process_manager();
     ExtensionHost* host = pm->GetBackgroundHostForExtension(extension->id());
     if (host)
       pm->IncrementLazyKeepaliveCount(extension);
   }
 }
 
 void EventRouter::OnEventAck(BrowserContext* context,
                              const std::string& extension_id) {
-  ProcessManager* pm =
-      ExtensionSystem::GetForBrowserContext(context)->process_manager();
+  ProcessManager* pm = ExtensionSystem::Get(context)->process_manager();
   ExtensionHost* host = pm->GetBackgroundHostForExtension(extension_id);
   // The event ACK is routed to the background host, so this should never be
   // NULL.
   CHECK(host);
   // TODO(mpcomplete): We should never get this message unless
   // HasLazyBackgroundPage is true. Find out why we're getting it anyway.
   if (host->extension() &&
       BackgroundInfo::HasLazyBackgroundPage(host->extension()))
     pm->DecrementLazyKeepaliveCount(host->extension());
 }
@@ skipping 21 matching lines @@
       // Remove all event listeners associated with this renderer.
       listeners_.RemoveListenersForProcess(renderer);
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_ENABLED: {
       // If the extension has a lazy background page, make sure it gets loaded
       // to register the events the extension is interested in.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
-        LazyBackgroundTaskQueue* queue = ExtensionSystem::GetForBrowserContext(
+        LazyBackgroundTaskQueue* queue = ExtensionSystem::Get(
             browser_context_)->lazy_background_task_queue();
         queue->AddPendingTask(browser_context_, extension->id(),
                               base::Bind(&DoNothing));
       }
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       // Add all registered lazy listeners to our cache.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
@@ skipping 80 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