Extract ProcessManager from ExtensionSystem.

extensions/browser/lazy_background_task_queue_unittest.cc

 // Copyright 2013 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.h"
 
 #include "base/bind.h"
+#include "base/prefs/testing_pref_service.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
+#include "components/user_prefs/user_prefs.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/test_browser_context.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_registry_factory.h"
-#include "extensions/browser/extension_system.h"
-#include "extensions/browser/extension_system_provider.h"
 #include "extensions/browser/extensions_test.h"
-#include "extensions/browser/mock_extension_system.h"
 #include "extensions/browser/process_manager.h"
+#include "extensions/browser/process_manager_factory.h"
 #include "extensions/browser/test_extensions_browser_client.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserContext;
 
 namespace extensions {
 namespace {
 
@@ skipping 17 matching lines @@
     create_count_++;
     return false;
   }
 
  private:
   int create_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestProcessManager);
 };
 
-// A simple ExtensionSystem that returns a TestProcessManager.
-class MockExtensionSystemWithProcessManager : public MockExtensionSystem {
- public:
-  explicit MockExtensionSystemWithProcessManager(BrowserContext* context)
-      : MockExtensionSystem(context), test_process_manager_(context) {}
-  ~MockExtensionSystemWithProcessManager() override {}
-
-  ProcessManager* process_manager() override { return &test_process_manager_; }
-
- private:
-  TestProcessManager test_process_manager_;
-};
+KeyedService* CreateTestProcessManager(BrowserContext* context) {
+  return new TestProcessManager(context);
+}
 
 }  // namespace
 
 // Derives from ExtensionsTest to provide content module and keyed service
 // initialization.
 class LazyBackgroundTaskQueueTest : public ExtensionsTest {
  public:
   LazyBackgroundTaskQueueTest()
       : notification_service_(content::NotificationService::Create()),
         task_run_count_(0) {
-    extensions_browser_client()->set_extension_system_factory(
-        &extension_system_factory_);
   }
   virtual ~LazyBackgroundTaskQueueTest() {}
 
   int task_run_count() { return task_run_count_; }
 
   // A simple callback for AddPendingTask.
   void RunPendingTask(ExtensionHost* host) {
     task_run_count_++;
   }
 
@@ skipping 20 matching lines @@
             .Set("background",
                   DictionaryBuilder()
                   .Set("page", "background.html")
                   .SetBoolean("persistent", false)))
         .SetID("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
         .Build();
     ExtensionRegistry::Get(browser_context())->AddEnabled(extension);
     return extension;
   }
 
+ protected:
+  virtual void SetUp() override {
+    user_prefs::UserPrefs::Set(browser_context(), &testing_pref_service_);
+  }
+
  private:
   scoped_ptr<content::NotificationService> notification_service_;
-  MockExtensionSystemFactory<MockExtensionSystemWithProcessManager>
-      extension_system_factory_;
+
+  TestingPrefServiceSimple testing_pref_service_;
 
   // The total number of pending tasks that have been executed.
   int task_run_count_;
 
   DISALLOW_COPY_AND_ASSIGN(LazyBackgroundTaskQueueTest);
 };
 
 // Tests that only extensions with background pages should have tasks queued.
 TEST_F(LazyBackgroundTaskQueueTest, ShouldEnqueueTask) {
   LazyBackgroundTaskQueue queue(browser_context());
 
   // Build a simple extension with no background page.
   scoped_refptr<Extension> no_background = CreateSimpleExtension();
   EXPECT_FALSE(queue.ShouldEnqueueTask(browser_context(), no_background.get()));
 
   // Build another extension with a background page.
   scoped_refptr<Extension> with_background = CreateLazyBackgroundExtension();
   EXPECT_TRUE(
       queue.ShouldEnqueueTask(browser_context(), with_background.get()));
 }
 
 // Tests that adding tasks actually increases the pending task count, and that
 // multiple extensions can have pending tasks.
 TEST_F(LazyBackgroundTaskQueueTest, AddPendingTask) {
   // Get our TestProcessManager.
-  MockExtensionSystem* extension_system = static_cast<MockExtensionSystem*>(
-      ExtensionSystem::Get(browser_context()));
-  TestProcessManager* process_manager =
-      static_cast<TestProcessManager*>(extension_system->process_manager());
+  TestProcessManager* process_manager = static_cast<TestProcessManager*>(
+      ProcessManagerFactory::GetInstance()->SetTestingFactoryAndUse(
+          browser_context(), CreateTestProcessManager));
 
   LazyBackgroundTaskQueue queue(browser_context());
 
   // Build a simple extension with no background page.
   scoped_refptr<Extension> no_background = CreateSimpleExtension();
 
   // Adding a pending task increases the number of extensions with tasks, but
   // doesn't run the task.
   queue.AddPendingTask(browser_context(),
                        no_background->id(),
@@ skipping 49 matching lines @@
   EXPECT_EQ(1u, queue.extensions_with_pending_tasks());
 
   // Processing tasks when there is one pending runs the task and removes the
   // extension from the list of extensions with pending tasks.
   queue.ProcessPendingTasks(NULL, browser_context(), extension.get());
   EXPECT_EQ(1, task_run_count());
   EXPECT_EQ(0u, queue.extensions_with_pending_tasks());
 }
 
 }  // namespace extensions