Move ExtensionProcessManager to src/extensions, part 4

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/command_line.h"
-#include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service_unittest.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "extensions/browser/process_manager.h"
 #include "extensions/common/extension_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
-// An ExtensionProcessManager that doesn't create background host pages.
-class TestExtensionProcessManager : public ExtensionProcessManager {
+// A ProcessManager that doesn't create background host pages.
+class TestProcessManager : public ProcessManager {
  public:
-  explicit TestExtensionProcessManager(Profile* profile)
-      : ExtensionProcessManager(profile, profile->GetOriginalProfile()),
+  explicit TestProcessManager(Profile* profile)
+      : ProcessManager(profile, profile->GetOriginalProfile()),
         create_count_(0) {}
-  virtual ~TestExtensionProcessManager() {}
+  virtual ~TestProcessManager() {}
 
   int create_count() { return create_count_; }
 
-  // ExtensionProcessManager overrides:
-  virtual extensions::ExtensionHost* CreateBackgroundHost(
-      const extensions::Extension* extension,
-      const GURL& url) OVERRIDE {
+  // ProcessManager overrides:
+  virtual ExtensionHost* CreateBackgroundHost(const Extension* extension,
+                                              const GURL& url) OVERRIDE {
     // Don't actually try to create a web contents.
     create_count_++;
     return NULL;
   }
 
  private:
   int create_count_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestExtensionProcessManager);
+  DISALLOW_COPY_AND_ASSIGN(TestProcessManager);
 };
 
 // Derives from ExtensionServiceTestBase because ExtensionService is difficult
 // to initialize alone.
 class LazyBackgroundTaskQueueTest : public ExtensionServiceTestBase {
  public:
   LazyBackgroundTaskQueueTest() : task_run_count_(0) {}
   virtual ~LazyBackgroundTaskQueueTest() {}
 
   int task_run_count() { return task_run_count_; }
@@ skipping 36 matching lines @@
  private:
   // 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) {
   InitializeEmptyExtensionService();
-  InitializeExtensionProcessManager();
+  InitializeProcessManager();
 
   LazyBackgroundTaskQueue queue(profile_.get());
 
   // Build a simple extension with no background page.
   scoped_refptr<Extension> no_background = CreateSimpleExtension();
   EXPECT_FALSE(queue.ShouldEnqueueTask(profile_.get(), no_background.get()));
 
   // Build another extension with a background page.
   scoped_refptr<Extension> with_background = CreateLazyBackgroundExtension();
   EXPECT_TRUE(queue.ShouldEnqueueTask(profile_.get(), 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) {
   InitializeEmptyExtensionService();
 
-  // Swap in our stub TestExtensionProcessManager.
+  // Swap in our stub TestProcessManager.
   TestExtensionSystem* extension_system =
       static_cast<extensions::TestExtensionSystem*>(
           ExtensionSystem::Get(profile_.get()));
   // Owned by |extension_system|.
-  TestExtensionProcessManager* process_manager =
-      new TestExtensionProcessManager(profile_.get());
-  extension_system->SetExtensionProcessManager(process_manager);
+  TestProcessManager* process_manager = new TestProcessManager(profile_.get());
+  extension_system->SetProcessManager(process_manager);
 
   LazyBackgroundTaskQueue queue(profile_.get());
 
   // 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(profile_.get(),
                        no_background->id(),
@@ skipping 51 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, profile_.get(), extension);
   EXPECT_EQ(1, task_run_count());
   EXPECT_EQ(0u, queue.extensions_with_pending_tasks());
 }
 
 }  // namespace extensions