Reland: Refactor code that defers extension background page loading

extensions/browser/process_manager_unittest.cc

Index: extensions/browser/process_manager_unittest.cc
diff --git a/extensions/browser/process_manager_unittest.cc b/extensions/browser/process_manager_unittest.cc
index b72b1125a7f733302595108efb37833c8e9d3e64..e5fc807a905496959ad42656bfb2d9522c1d1b98 100644
--- a/extensions/browser/process_manager_unittest.cc
+++ b/extensions/browser/process_manager_unittest.cc
@@ -9,6 +9,8 @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/test/test_browser_context.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/browser/process_manager_delegate.h"
 #include "extensions/browser/test_extensions_browser_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -33,12 +35,37 @@ class TestBrowserContextIncognito : public TestBrowserContext {
   DISALLOW_COPY_AND_ASSIGN(TestBrowserContextIncognito);
 };
 
+// A trivial ProcessManagerDelegate.
+class TestProcessManagerDelegate : public ProcessManagerDelegate {
+ public:
+  TestProcessManagerDelegate()
+      : is_background_page_allowed_(true),
+        defer_creating_startup_background_hosts_(false) {}
+  virtual ~TestProcessManagerDelegate() {}
+
+  // ProcessManagerDelegate implementation.
+  virtual bool IsBackgroundPageAllowed(BrowserContext* context) const OVERRIDE {
+    return is_background_page_allowed_;
+  }
+  virtual bool DeferCreatingStartupBackgroundHosts(
+      BrowserContext* context) const OVERRIDE {
+    return defer_creating_startup_background_hosts_;
+  }
+
+  bool is_background_page_allowed_;
+  bool defer_creating_startup_background_hosts_;
+};
+
 }  // namespace
 
 class ProcessManagerTest : public testing::Test {
  public:
-  ProcessManagerTest() : extensions_browser_client_(&original_context_) {
+  ProcessManagerTest()
+      : extension_registry_(&original_context_),
+        extensions_browser_client_(&original_context_) {
     extensions_browser_client_.SetIncognitoContext(&incognito_context_);
+    extensions_browser_client_.set_process_manager_delegate(
+        &process_manager_delegate_);
     ExtensionsBrowserClient::Set(&extensions_browser_client_);
   }
 
@@ -48,6 +75,10 @@ class ProcessManagerTest : public testing::Test {
 
   BrowserContext* original_context() { return &original_context_; }
   BrowserContext* incognito_context() { return &incognito_context_; }
+  ExtensionRegistry* extension_registry() { return &extension_registry_; }
+  TestProcessManagerDelegate* process_manager_delegate() {
+    return &process_manager_delegate_;
+  }
 
   // Returns true if the notification |type| is registered for |manager| with
   // source |context|. Pass NULL for |context| for all sources.
@@ -61,6 +92,8 @@ class ProcessManagerTest : public testing::Test {
  private:
   TestBrowserContext original_context_;
   TestBrowserContextIncognito incognito_context_;
+  ExtensionRegistry extension_registry_;  // Shared between BrowserContexts.
+  TestProcessManagerDelegate process_manager_delegate_;
   TestExtensionsBrowserClient extensions_browser_client_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessManagerTest);
@@ -69,8 +102,8 @@ class ProcessManagerTest : public testing::Test {
 // Test that notification registration works properly.
 TEST_F(ProcessManagerTest, ExtensionNotificationRegistration) {
   // Test for a normal context ProcessManager.
-  scoped_ptr<ProcessManager> manager1(
-      ProcessManager::Create(original_context()));
+  scoped_ptr<ProcessManager> manager1(ProcessManager::CreateForTesting(
+      original_context(), extension_registry()));
 
   EXPECT_EQ(original_context(), manager1->GetBrowserContext());
   EXPECT_EQ(0u, manager1->background_hosts().size());
@@ -90,8 +123,11 @@ TEST_F(ProcessManagerTest, ExtensionNotificationRegistration) {
                            original_context()));
 
   // Test for an incognito context ProcessManager.
-  scoped_ptr<ProcessManager> manager2(ProcessManager::CreateIncognitoForTesting(
-      incognito_context(), original_context(), manager1.get()));
+  scoped_ptr<ProcessManager> manager2(
+      ProcessManager::CreateIncognitoForTesting(incognito_context(),
+                                                original_context(),
+                                                manager1.get(),
+                                                extension_registry()));
 
   EXPECT_EQ(incognito_context(), manager2->GetBrowserContext());
   EXPECT_EQ(0u, manager2->background_hosts().size());
@@ -125,6 +161,83 @@ TEST_F(ProcessManagerTest, ExtensionNotificationRegistration) {
                            incognito_context()));
 }
 
+// Test that startup background hosts are created when the extension system
+// becomes ready.
+//
+// NOTE: This test and those that follow do not try to create ExtensionsHosts
+// because ExtensionHost is tightly coupled to WebContents and can't be
+// constructed in unit tests.
+TEST_F(ProcessManagerTest, CreateBackgroundHostsOnExtensionsReady) {
+  scoped_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
+      original_context(), extension_registry()));
+  ASSERT_FALSE(manager->startup_background_hosts_created_for_test());
+
+  // Simulate the extension system becoming ready.
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_EXTENSIONS_READY,
+      content::Source<BrowserContext>(original_context()),
+      content::NotificationService::NoDetails());
+  EXPECT_TRUE(manager->startup_background_hosts_created_for_test());
+}
+
+// Test that startup background hosts can be created explicitly before the
+// extension system is ready (this is the normal pattern in Chrome).
+TEST_F(ProcessManagerTest, CreateBackgroundHostsExplicitly) {
+  scoped_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
+      original_context(), extension_registry()));
+  ASSERT_FALSE(manager->startup_background_hosts_created_for_test());
+
+  // Embedder explicitly asks for hosts to be created. Chrome does this on
+  // normal startup.
+  manager->MaybeCreateStartupBackgroundHosts();
+  EXPECT_TRUE(manager->startup_background_hosts_created_for_test());
+}
+
+// Test that the embedder can defer background host creation. Chrome does this
+// when the profile is created asynchronously, which may take a while.
+TEST_F(ProcessManagerTest, CreateBackgroundHostsDeferred) {
+  scoped_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
+      original_context(), extension_registry()));
+  ASSERT_FALSE(manager->startup_background_hosts_created_for_test());
+
+  // Don't create background hosts if the delegate says to defer them.
+  process_manager_delegate()->defer_creating_startup_background_hosts_ = true;
+  manager->MaybeCreateStartupBackgroundHosts();
+  EXPECT_FALSE(manager->startup_background_hosts_created_for_test());
+
+  // The extension system becoming ready still doesn't create the hosts.
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_EXTENSIONS_READY,
+      content::Source<BrowserContext>(original_context()),
+      content::NotificationService::NoDetails());
+  EXPECT_FALSE(manager->startup_background_hosts_created_for_test());
+
+  // Once the embedder is ready the background hosts can be created.
+  process_manager_delegate()->defer_creating_startup_background_hosts_ = false;
+  manager->MaybeCreateStartupBackgroundHosts();
+  EXPECT_TRUE(manager->startup_background_hosts_created_for_test());
+}
+
+// Test that the embedder can disallow background host creation.
+// Chrome OS does this in guest mode.
+TEST_F(ProcessManagerTest, IsBackgroundHostAllowed) {
+  scoped_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
+      original_context(), extension_registry()));
+  ASSERT_FALSE(manager->startup_background_hosts_created_for_test());
+
+  // Don't create background hosts if the delegate disallows them.
+  process_manager_delegate()->is_background_page_allowed_ = false;
+  manager->MaybeCreateStartupBackgroundHosts();
+  EXPECT_FALSE(manager->startup_background_hosts_created_for_test());
+
+  // The extension system becoming ready still doesn't create the hosts.
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_EXTENSIONS_READY,
+      content::Source<BrowserContext>(original_context()),
+      content::NotificationService::NoDetails());
+  EXPECT_FALSE(manager->startup_background_hosts_created_for_test());
+}
+
 // Test that extensions get grouped in the right SiteInstance (and therefore
 // process) based on their URLs.
 TEST_F(ProcessManagerTest, ProcessGrouping) {
@@ -133,12 +246,14 @@ TEST_F(ProcessManagerTest, ProcessGrouping) {
 
   // Extensions in different browser contexts should always be different
   // SiteInstances.
-  scoped_ptr<ProcessManager> manager1(
-      ProcessManager::Create(original_context()));
+  scoped_ptr<ProcessManager> manager1(ProcessManager::CreateForTesting(
+      original_context(), extension_registry()));
   // NOTE: This context is not associated with the TestExtensionsBrowserClient.
   // That's OK because we're not testing regular vs. incognito behavior.
   TestBrowserContext another_context;
-  scoped_ptr<ProcessManager> manager2(ProcessManager::Create(&another_context));
+  ExtensionRegistry another_registry(&another_context);
+  scoped_ptr<ProcessManager> manager2(
+      ProcessManager::CreateForTesting(&another_context, &another_registry));
 
   // Extensions with common origins ("scheme://id/") should be grouped in the
   // same SiteInstance.