extensions/browser/process_manager_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/process_manager.h"
   6
   7 #include "content/public/browser/content_browser_client.h"
   8 #include "content/public/browser/notification_service.h"
   9 #include "content/public/browser/site_instance.h"
  10 #include "content/public/common/content_client.h"
  11 #include "content/public/test/test_browser_context.h"
  12 #include "extensions/browser/extension_registry.h"
  13 #include "extensions/browser/extensions_test.h"
  14 #include "extensions/browser/notification_types.h"
  15 #include "extensions/browser/process_manager_delegate.h"
  16 #include "extensions/browser/test_extensions_browser_client.h"
  17
  18 using content::BrowserContext;
  19 using content::SiteInstance;
  20 using content::TestBrowserContext;
  21
  22 namespace extensions {
  23
  24 namespace {
  25
  26 // An incognito version of a TestBrowserContext.
  27 class TestBrowserContextIncognito : public TestBrowserContext {
  28  public:
  29   TestBrowserContextIncognito() {}
  30   virtual ~TestBrowserContextIncognito() {}
  31
  32   // TestBrowserContext implementation.
  33   virtual bool IsOffTheRecord() const OVERRIDE { return true; }
  34
  35  private:
  36   DISALLOW_COPY_AND_ASSIGN(TestBrowserContextIncognito);
  37 };
  38
  39 // A trivial ProcessManagerDelegate.
  40 class TestProcessManagerDelegate : public ProcessManagerDelegate {
  41  public:
  42   TestProcessManagerDelegate()
  43       : is_background_page_allowed_(true),
  44         defer_creating_startup_background_hosts_(false) {}
  45   virtual ~TestProcessManagerDelegate() {}
  46
  47   // ProcessManagerDelegate implementation.
  48   virtual bool IsBackgroundPageAllowed(BrowserContext* context) const OVERRIDE {
  49     return is_background_page_allowed_;
  50   }
  51   virtual bool DeferCreatingStartupBackgroundHosts(
  52       BrowserContext* context) const OVERRIDE {
  53     return defer_creating_startup_background_hosts_;
  54   }
  55
  56   bool is_background_page_allowed_;
  57   bool defer_creating_startup_background_hosts_;
  58 };
  59
  60 }  // namespace
  61
  62 class ProcessManagerTest : public ExtensionsTest {
  63  public:
  64   ProcessManagerTest()
  65       : notification_service_(content::NotificationService::Create()),
  66         extension_registry_(browser_context()) {
  67     extensions_browser_client()->SetIncognitoContext(&incognito_context_);
  68     extensions_browser_client()->set_process_manager_delegate(
  69         &process_manager_delegate_);
  70   }
  71
  72   virtual ~ProcessManagerTest() {}
  73
  74   // Use original_context() to make it clear it is a non-incognito context.
  75   BrowserContext* original_context() { return browser_context(); }
  76   BrowserContext* incognito_context() { return &incognito_context_; }
  77   ExtensionRegistry* extension_registry() { return &extension_registry_; }
  78   TestProcessManagerDelegate* process_manager_delegate() {
  79     return &process_manager_delegate_;
  80   }
  81
  82   // Returns true if the notification |type| is registered for |manager| with
  83   // source |context|. Pass NULL for |context| for all sources.
  84   static bool IsRegistered(ProcessManager* manager,
  85                            int type,
  86                            BrowserContext* context) {
  87     return manager->registrar_.IsRegistered(
  88         manager, type, content::Source<BrowserContext>(context));
  89   }
  90
  91  private:
  92   scoped_ptr<content::NotificationService> notification_service_;
  93   TestBrowserContextIncognito incognito_context_;
  94   ExtensionRegistry extension_registry_;  // Shared between BrowserContexts.
  95   TestProcessManagerDelegate process_manager_delegate_;
  96
  97   DISALLOW_COPY_AND_ASSIGN(ProcessManagerTest);
  98 };
  99
 100 // Test that notification registration works properly.
 101 TEST_F(ProcessManagerTest, ExtensionNotificationRegistration) {
 102   // Test for a normal context ProcessManager.
 103   scoped_ptr<ProcessManager> manager1(ProcessManager::CreateForTesting(
 104       original_context(), extension_registry()));
 105
 106   EXPECT_EQ(original_context(), manager1->GetBrowserContext());
 107   EXPECT_EQ(0u, manager1->background_hosts().size());
 108
 109   // It observes other notifications from this context.
 110   EXPECT_TRUE(IsRegistered(manager1.get(),
 111                            extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
 112                            original_context()));
 113   EXPECT_TRUE(IsRegistered(manager1.get(),
 114                            extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
 115                            original_context()));
 116   EXPECT_TRUE(
 117       IsRegistered(manager1.get(),
 118                    extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
 119                    original_context()));
 120   EXPECT_TRUE(IsRegistered(manager1.get(),
 121                            extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
 122                            original_context()));
 123
 124   // Test for an incognito context ProcessManager.
 125   scoped_ptr<ProcessManager> manager2(
 126       ProcessManager::CreateIncognitoForTesting(incognito_context(),
 127                                                 original_context(),
 128                                                 manager1.get(),
 129                                                 extension_registry()));
 130
 131   EXPECT_EQ(incognito_context(), manager2->GetBrowserContext());
 132   EXPECT_EQ(0u, manager2->background_hosts().size());
 133
 134   // Some notifications are observed for the original context.
 135   EXPECT_TRUE(IsRegistered(manager2.get(),
 136                            extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
 137                            original_context()));
 138
 139   // Some notifications are observed for the incognito context.
 140   EXPECT_TRUE(IsRegistered(manager2.get(),
 141                            extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
 142                            incognito_context()));
 143
 144   // Some are not observed at all.
 145   EXPECT_FALSE(
 146       IsRegistered(manager2.get(),
 147                    extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
 148                    original_context()));
 149 }
 150
 151 // Test that startup background hosts are created when the extension system
 152 // becomes ready.
 153 //
 154 // NOTE: This test and those that follow do not try to create ExtensionsHosts
 155 // because ExtensionHost is tightly coupled to WebContents and can't be
 156 // constructed in unit tests.
 157 TEST_F(ProcessManagerTest, CreateBackgroundHostsOnExtensionsReady) {
 158   scoped_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
 159       original_context(), extension_registry()));
 160   ASSERT_FALSE(manager->startup_background_hosts_created_for_test());
 161
 162   // Simulate the extension system becoming ready.
 163   content::NotificationService::current()->Notify(
 164       extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
 165       content::Source<BrowserContext>(original_context()),
 166       content::NotificationService::NoDetails());
 167   EXPECT_TRUE(manager->startup_background_hosts_created_for_test());
 168 }
 169
 170 // Test that startup background hosts can be created explicitly before the
 171 // extension system is ready (this is the normal pattern in Chrome).
 172 TEST_F(ProcessManagerTest, CreateBackgroundHostsExplicitly) {
 173   scoped_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
 174       original_context(), extension_registry()));
 175   ASSERT_FALSE(manager->startup_background_hosts_created_for_test());
 176
 177   // Embedder explicitly asks for hosts to be created. Chrome does this on
 178   // normal startup.
 179   manager->MaybeCreateStartupBackgroundHosts();
 180   EXPECT_TRUE(manager->startup_background_hosts_created_for_test());
 181 }
 182
 183 // Test that the embedder can defer background host creation. Chrome does this
 184 // when the profile is created asynchronously, which may take a while.
 185 TEST_F(ProcessManagerTest, CreateBackgroundHostsDeferred) {
 186   scoped_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
 187       original_context(), extension_registry()));
 188   ASSERT_FALSE(manager->startup_background_hosts_created_for_test());
 189
 190   // Don't create background hosts if the delegate says to defer them.
 191   process_manager_delegate()->defer_creating_startup_background_hosts_ = true;
 192   manager->MaybeCreateStartupBackgroundHosts();
 193   EXPECT_FALSE(manager->startup_background_hosts_created_for_test());
 194
 195   // The extension system becoming ready still doesn't create the hosts.
 196   content::NotificationService::current()->Notify(
 197       extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
 198       content::Source<BrowserContext>(original_context()),
 199       content::NotificationService::NoDetails());
 200   EXPECT_FALSE(manager->startup_background_hosts_created_for_test());
 201
 202   // Once the embedder is ready the background hosts can be created.
 203   process_manager_delegate()->defer_creating_startup_background_hosts_ = false;
 204   manager->MaybeCreateStartupBackgroundHosts();
 205   EXPECT_TRUE(manager->startup_background_hosts_created_for_test());
 206 }
 207
 208 // Test that the embedder can disallow background host creation.
 209 // Chrome OS does this in guest mode.
 210 TEST_F(ProcessManagerTest, IsBackgroundHostAllowed) {
 211   scoped_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
 212       original_context(), extension_registry()));
 213   ASSERT_FALSE(manager->startup_background_hosts_created_for_test());
 214
 215   // Don't create background hosts if the delegate disallows them.
 216   process_manager_delegate()->is_background_page_allowed_ = false;
 217   manager->MaybeCreateStartupBackgroundHosts();
 218   EXPECT_FALSE(manager->startup_background_hosts_created_for_test());
 219
 220   // The extension system becoming ready still doesn't create the hosts.
 221   content::NotificationService::current()->Notify(
 222       extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
 223       content::Source<BrowserContext>(original_context()),
 224       content::NotificationService::NoDetails());
 225   EXPECT_FALSE(manager->startup_background_hosts_created_for_test());
 226 }
 227
 228 // Test that extensions get grouped in the right SiteInstance (and therefore
 229 // process) based on their URLs.
 230 TEST_F(ProcessManagerTest, ProcessGrouping) {
 231   // Extensions in different browser contexts should always be different
 232   // SiteInstances.
 233   scoped_ptr<ProcessManager> manager1(ProcessManager::CreateForTesting(
 234       original_context(), extension_registry()));
 235   // NOTE: This context is not associated with the TestExtensionsBrowserClient.
 236   // That's OK because we're not testing regular vs. incognito behavior.
 237   TestBrowserContext another_context;
 238   ExtensionRegistry another_registry(&another_context);
 239   scoped_ptr<ProcessManager> manager2(
 240       ProcessManager::CreateForTesting(&another_context, &another_registry));
 241
 242   // Extensions with common origins ("scheme://id/") should be grouped in the
 243   // same SiteInstance.
 244   GURL ext1_url1("chrome-extension://ext1_id/index.html");
 245   GURL ext1_url2("chrome-extension://ext1_id/monkey/monkey.html");
 246   GURL ext2_url1("chrome-extension://ext2_id/index.html");
 247
 248   scoped_refptr<SiteInstance> site11 =
 249       manager1->GetSiteInstanceForURL(ext1_url1);
 250   scoped_refptr<SiteInstance> site12 =
 251       manager1->GetSiteInstanceForURL(ext1_url2);
 252   EXPECT_EQ(site11, site12);
 253
 254   scoped_refptr<SiteInstance> site21 =
 255       manager1->GetSiteInstanceForURL(ext2_url1);
 256   EXPECT_NE(site11, site21);
 257
 258   scoped_refptr<SiteInstance> other_profile_site =
 259       manager2->GetSiteInstanceForURL(ext1_url1);
 260   EXPECT_NE(site11, other_profile_site);
 261 }
 262
 263 }  // namespace extensions