Extract LazyBackgroundTaskQueue from ExtensionSystem.

This patch removes lazy_background_task_queue accessor from ExtensionSystem.
It can be its own browser context keyed service.
It can be built by its new factory.

Review URL: https://codereview.chromium.org/1129063011

Cr-Commit-Position: refs/heads/master@{#330815}

11 files changed, 120 insertions, 30 deletions

diff --git a/extensions/browser/api/runtime/runtime_api.cc b/extensions/browser/api/runtime/runtime_api.cc
index cc90d37..6e23721 100644
--- a/extensions/browser/api/runtime/runtime_api.cc
+++ b/extensions/browser/api/runtime/runtime_api.cc
@@ -95,13 +95,12 @@ void DispatchOnStartupEventImpl(BrowserContext* browser_context,
           extension_id);
   if (extension && BackgroundInfo::HasPersistentBackgroundPage(extension) &&
       first_call &&
-      system->lazy_background_task_queue()->ShouldEnqueueTask(browser_context,
-                                                              extension)) {
-    system->lazy_background_task_queue()->AddPendingTask(
-        browser_context,
-        extension_id,
-        base::Bind(
-            &DispatchOnStartupEventImpl, browser_context, extension_id, false));
+      LazyBackgroundTaskQueue::Get(browser_context)
+          ->ShouldEnqueueTask(browser_context, extension)) {
+    LazyBackgroundTaskQueue::Get(browser_context)
+        ->AddPendingTask(browser_context, extension_id,
+                         base::Bind(&DispatchOnStartupEventImpl,
+                                    browser_context, extension_id, false));
     return;
   }
 
@@ -404,15 +403,14 @@ void RuntimeEventRouter::OnExtensionUninstalled(
 }
 
 ExtensionFunction::ResponseAction RuntimeGetBackgroundPageFunction::Run() {
-  ExtensionSystem* system = ExtensionSystem::Get(browser_context());
   ExtensionHost* host = ProcessManager::Get(browser_context())
                             ->GetBackgroundHostForExtension(extension_id());
-  if (system->lazy_background_task_queue()->ShouldEnqueueTask(browser_context(),
-                                                              extension())) {
-    system->lazy_background_task_queue()->AddPendingTask(
-        browser_context(),
-        extension_id(),
-        base::Bind(&RuntimeGetBackgroundPageFunction::OnPageLoaded, this));
+  if (LazyBackgroundTaskQueue::Get(browser_context())
+          ->ShouldEnqueueTask(browser_context(), extension())) {
+    LazyBackgroundTaskQueue::Get(browser_context())
+        ->AddPendingTask(
+            browser_context(), extension_id(),
+            base::Bind(&RuntimeGetBackgroundPageFunction::OnPageLoaded, this));
   } else if (host) {
     OnPageLoaded(host);
   } else {
diff --git a/extensions/browser/event_router.cc b/extensions/browser/event_router.cc
index afd92d03..02df56a 100644
--- a/extensions/browser/event_router.cc
+++ b/extensions/browser/event_router.cc
@@ -638,8 +638,7 @@ bool EventRouter::MaybeLoadLazyBackgroundPageToDispatchEvent(
   if (!CanDispatchEventToBrowserContext(context, extension, event))
     return false;
 
-  LazyBackgroundTaskQueue* queue = ExtensionSystem::Get(
-      context)->lazy_background_task_queue();
+  LazyBackgroundTaskQueue* queue = LazyBackgroundTaskQueue::Get(context);
   if (queue->ShouldEnqueueTask(context, extension)) {
     linked_ptr<Event> dispatched_event(event);
 
@@ -752,8 +751,8 @@ void EventRouter::Observe(int type,
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
-        LazyBackgroundTaskQueue* queue = ExtensionSystem::Get(
-            browser_context_)->lazy_background_task_queue();
+        LazyBackgroundTaskQueue* queue =
+            LazyBackgroundTaskQueue::Get(browser_context_);
         queue->AddPendingTask(browser_context_, extension->id(),
                               base::Bind(&DoNothing));
       }
diff --git a/extensions/browser/extension_system.h b/extensions/browser/extension_system.h
index ec4c716..600ac3a 100644
--- a/extensions/browser/extension_system.h
+++ b/extensions/browser/extension_system.h
@@ -34,7 +34,6 @@ class EventRouter;
 class Extension;
 class ExtensionSet;
 class InfoMap;
-class LazyBackgroundTaskQueue;
 class ManagementPolicy;
 class OneShotEvent;
 class QuotaService;
@@ -83,9 +82,6 @@ class ExtensionSystem : public KeyedService {
   // Returns the IO-thread-accessible extension data.
   virtual InfoMap* info_map() = 0;
 
-  // The LazyBackgroundTaskQueue is created at startup.
-  virtual LazyBackgroundTaskQueue* lazy_background_task_queue() = 0;
-
   // The EventRouter is created at startup.
   virtual EventRouter* event_router() = 0;
 
diff --git a/extensions/browser/guest_view/app_view/app_view_guest.cc b/extensions/browser/guest_view/app_view/app_view_guest.cc
index 66aa593..705274d 100644
--- a/extensions/browser/guest_view/app_view/app_view_guest.cc
+++ b/extensions/browser/guest_view/app_view/app_view_guest.cc
@@ -207,7 +207,7 @@ void AppViewGuest::CreateWebContents(
                                         callback))));
 
   LazyBackgroundTaskQueue* queue =
-      ExtensionSystem::Get(browser_context())->lazy_background_task_queue();
+      LazyBackgroundTaskQueue::Get(browser_context());
   if (queue->ShouldEnqueueTask(browser_context(), guest_extension)) {
     queue->AddPendingTask(browser_context(),
                           guest_extension->id(),
diff --git a/extensions/browser/lazy_background_task_queue.cc b/extensions/browser/lazy_background_task_queue.cc
index b76b6d3..fcbde09 100644
--- a/extensions/browser/lazy_background_task_queue.cc
+++ b/extensions/browser/lazy_background_task_queue.cc
@@ -14,6 +14,7 @@
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extensions_browser_client.h"
+#include "extensions/browser/lazy_background_task_queue_factory.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_map.h"
@@ -39,6 +40,12 @@ LazyBackgroundTaskQueue::LazyBackgroundTaskQueue(
 LazyBackgroundTaskQueue::~LazyBackgroundTaskQueue() {
 }
 
+// static
+LazyBackgroundTaskQueue* LazyBackgroundTaskQueue::Get(
+    content::BrowserContext* browser_context) {
+  return LazyBackgroundTaskQueueFactory::GetForBrowserContext(browser_context);
+}
+
 bool LazyBackgroundTaskQueue::ShouldEnqueueTask(
     content::BrowserContext* browser_context,
     const Extension* extension) {
diff --git a/extensions/browser/lazy_background_task_queue.h b/extensions/browser/lazy_background_task_queue.h
index 96b3c89..52cbd91 100644
--- a/extensions/browser/lazy_background_task_queue.h
+++ b/extensions/browser/lazy_background_task_queue.h
@@ -13,6 +13,7 @@
 #include "base/gtest_prod_util.h"
 #include "base/memory/linked_ptr.h"
 #include "base/scoped_observer.h"
+#include "components/keyed_service/core/keyed_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "extensions/browser/extension_registry_observer.h"
@@ -32,7 +33,8 @@ class ExtensionRegistry;
 //
 // It is the consumer's responsibility to use this class when appropriate, i.e.
 // only with extensions that have not-yet-loaded lazy background pages.
-class LazyBackgroundTaskQueue : public content::NotificationObserver,
+class LazyBackgroundTaskQueue : public KeyedService,
+                                public content::NotificationObserver,
                                 public ExtensionRegistryObserver {
  public:
   typedef base::Callback<void(ExtensionHost*)> PendingTask;
@@ -40,6 +42,10 @@ class LazyBackgroundTaskQueue : public content::NotificationObserver,
   explicit LazyBackgroundTaskQueue(content::BrowserContext* browser_context);
   ~LazyBackgroundTaskQueue() override;
 
+  // Convenience method to return the LazyBackgroundTaskQueue for a given
+  // |context|.
+  static LazyBackgroundTaskQueue* Get(content::BrowserContext* context);
+
   // Returns the number of extensions having pending tasks.
   size_t extensions_with_pending_tasks() { return pending_tasks_.size(); }
 
diff --git a/extensions/browser/lazy_background_task_queue_factory.cc b/extensions/browser/lazy_background_task_queue_factory.cc
new file mode 100644
index 0000000..be9d8c7
--- /dev/null
+++ b/extensions/browser/lazy_background_task_queue_factory.cc
@@ -0,0 +1,50 @@
+// Copyright 2015 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/lazy_background_task_queue_factory.h"
+
+//#include "chrome/browser/profiles/profile.h"
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
+#include "extensions/browser/extension_registry_factory.h"
+#include "extensions/browser/extensions_browser_client.h"
+#include "extensions/browser/lazy_background_task_queue.h"
+
+using content::BrowserContext;
+
+namespace extensions {
+
+// static
+LazyBackgroundTaskQueue* LazyBackgroundTaskQueueFactory::GetForBrowserContext(
+    BrowserContext* context) {
+  return static_cast<LazyBackgroundTaskQueue*>(
+      GetInstance()->GetServiceForBrowserContext(context, true));
+}
+
+// static
+LazyBackgroundTaskQueueFactory* LazyBackgroundTaskQueueFactory::GetInstance() {
+  return Singleton<LazyBackgroundTaskQueueFactory>::get();
+}
+
+LazyBackgroundTaskQueueFactory::LazyBackgroundTaskQueueFactory()
+    : BrowserContextKeyedServiceFactory(
+          "LazyBackgroundTaskQueue",
+          BrowserContextDependencyManager::GetInstance()) {
+  DependsOn(ExtensionRegistryFactory::GetInstance());
+}
+
+LazyBackgroundTaskQueueFactory::~LazyBackgroundTaskQueueFactory() {
+}
+
+KeyedService* LazyBackgroundTaskQueueFactory::BuildServiceInstanceFor(
+    BrowserContext* context) const {
+  return new LazyBackgroundTaskQueue(context);
+}
+
+BrowserContext* LazyBackgroundTaskQueueFactory::GetBrowserContextToUse(
+    BrowserContext* context) const {
+  // Redirected in incognito.
+  return ExtensionsBrowserClient::Get()->GetOriginalContext(context);
+}
+
+}  // namespace extensions
diff --git a/extensions/browser/lazy_background_task_queue_factory.h b/extensions/browser/lazy_background_task_queue_factory.h
new file mode 100644
index 0000000..98917c9
--- /dev/null
+++ b/extensions/browser/lazy_background_task_queue_factory.h
@@ -0,0 +1,39 @@
+// Copyright 2015 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.
+
+#ifndef EXTENSIONS_BROWSER_LAZY_BACKGROUND_TASK_QUEUE_FACTORY_H_
+#define EXTENSIONS_BROWSER_LAZY_BACKGROUND_TASK_QUEUE_FACTORY_H_
+
+#include "base/memory/singleton.h"
+#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+
+namespace extensions {
+
+class LazyBackgroundTaskQueue;
+
+class LazyBackgroundTaskQueueFactory
+    : public BrowserContextKeyedServiceFactory {
+ public:
+  static LazyBackgroundTaskQueue* GetForBrowserContext(
+      content::BrowserContext* context);
+  static LazyBackgroundTaskQueueFactory* GetInstance();
+
+ private:
+  friend struct DefaultSingletonTraits<LazyBackgroundTaskQueueFactory>;
+
+  LazyBackgroundTaskQueueFactory();
+  ~LazyBackgroundTaskQueueFactory() override;
+
+  // BrowserContextKeyedServiceFactory implementation
+  KeyedService* BuildServiceInstanceFor(
+      content::BrowserContext* context) const override;
+  content::BrowserContext* GetBrowserContextToUse(
+      content::BrowserContext* context) const override;
+
+  DISALLOW_COPY_AND_ASSIGN(LazyBackgroundTaskQueueFactory);
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_BROWSER_LAZY_BACKGROUND_TASK_QUEUE_FACTORY_H_
diff --git a/extensions/browser/mock_extension_system.cc b/extensions/browser/mock_extension_system.cc
index 0bd01ff..8371c95 100644
--- a/extensions/browser/mock_extension_system.cc
+++ b/extensions/browser/mock_extension_system.cc
@@ -46,10 +46,6 @@ InfoMap* MockExtensionSystem::info_map() {
   return nullptr;
 }
 
-LazyBackgroundTaskQueue* MockExtensionSystem::lazy_background_task_queue() {
-  return nullptr;
-}
-
 EventRouter* MockExtensionSystem::event_router() {
   return event_router_;
 }
diff --git a/extensions/browser/mock_extension_system.h b/extensions/browser/mock_extension_system.h
index 7393f8c..c06b7bc 100644
--- a/extensions/browser/mock_extension_system.h
+++ b/extensions/browser/mock_extension_system.h
@@ -36,7 +36,6 @@ class MockExtensionSystem : public ExtensionSystem {
   StateStore* state_store() override;
   StateStore* rules_store() override;
   InfoMap* info_map() override;
-  LazyBackgroundTaskQueue* lazy_background_task_queue() override;
   EventRouter* event_router() override;
   QuotaService* quota_service() override;
   const OneShotEvent& ready() const override;
diff --git a/extensions/browser/process_manager.cc b/extensions/browser/process_manager.cc
index efe359d..7a28cad 100644
--- a/extensions/browser/process_manager.cc
+++ b/extensions/browser/process_manager.cc
@@ -436,7 +436,7 @@ bool ProcessManager::WakeEventPage(const std::string& extension_id,
     return false;
   }
   LazyBackgroundTaskQueue* queue =
-      ExtensionSystem::Get(browser_context_)->lazy_background_task_queue();
+      LazyBackgroundTaskQueue::Get(browser_context_);
   queue->AddPendingTask(browser_context_, extension_id,
                         base::Bind(&PropagateExtensionWakeResult, callback));
   return true;