process_manager_unittest.cc 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181
  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. #include "extensions/browser/process_manager.h"
  5. #include "content/public/browser/content_browser_client.h"
  6. #include "content/public/browser/notification_service.h"
  7. #include "content/public/browser/site_instance.h"
  8. #include "content/public/common/content_client.h"
  9. #include "content/public/test/test_browser_context.h"
  10. #include "extensions/browser/extension_registry.h"
  11. #include "extensions/browser/extensions_test.h"
  12. #include "extensions/browser/notification_types.h"
  13. #include "extensions/browser/process_manager_delegate.h"
  14. #include "extensions/browser/test_extensions_browser_client.h"
  15. using content::BrowserContext;
  16. using content::SiteInstance;
  17. using content::TestBrowserContext;
  18. namespace extensions {
  19. namespace {
  20. // A trivial ProcessManagerDelegate.
  21. class TestProcessManagerDelegate : public ProcessManagerDelegate {
  22. public:
  23. TestProcessManagerDelegate()
  24. : is_background_page_allowed_(true),
  25. defer_creating_startup_background_hosts_(false) {}
  26. ~TestProcessManagerDelegate() override {}
  27. // ProcessManagerDelegate implementation.
  28. bool AreBackgroundPagesAllowedForContext(
  29. BrowserContext* context) const override {
  30. return is_background_page_allowed_;
  31. }
  32. bool IsExtensionBackgroundPageAllowed(
  33. BrowserContext* context,
  34. const Extension& extension) const override {
  35. return is_background_page_allowed_;
  36. }
  37. bool DeferCreatingStartupBackgroundHosts(
  38. BrowserContext* context) const override {
  39. return defer_creating_startup_background_hosts_;
  40. }
  41. bool is_background_page_allowed_;
  42. bool defer_creating_startup_background_hosts_;
  43. };
  44. } // namespace
  45. class ProcessManagerTest : public ExtensionsTest {
  46. public:
  47. ProcessManagerTest() {}
  48. ProcessManagerTest(const ProcessManagerTest&) = delete;
  49. ProcessManagerTest& operator=(const ProcessManagerTest&) = delete;
  50. ~ProcessManagerTest() override {}
  51. void SetUp() override {
  52. ExtensionsTest::SetUp();
  53. extension_registry_ =
  54. std::make_unique<ExtensionRegistry>(browser_context());
  55. extensions_browser_client()->set_process_manager_delegate(
  56. &process_manager_delegate_);
  57. }
  58. // Use original_context() to make it clear it is a non-incognito context.
  59. BrowserContext* original_context() { return browser_context(); }
  60. ExtensionRegistry* extension_registry() { return extension_registry_.get(); }
  61. TestProcessManagerDelegate* process_manager_delegate() {
  62. return &process_manager_delegate_;
  63. }
  64. private:
  65. std::unique_ptr<ExtensionRegistry>
  66. extension_registry_; // Shared between BrowserContexts.
  67. TestProcessManagerDelegate process_manager_delegate_;
  68. };
  69. // Test that startup background hosts are created when the extension system
  70. // becomes ready.
  71. //
  72. // NOTE: This test and those that follow do not try to create ExtensionsHosts
  73. // because ExtensionHost is tightly coupled to WebContents and can't be
  74. // constructed in unit tests.
  75. TEST_F(ProcessManagerTest, CreateBackgroundHostsOnExtensionsReady) {
  76. std::unique_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
  77. original_context(), extension_registry()));
  78. ASSERT_FALSE(manager->startup_background_hosts_created_for_test());
  79. // Simulate the extension system becoming ready.
  80. extension_system()->SetReady();
  81. base::RunLoop().RunUntilIdle();
  82. EXPECT_TRUE(manager->startup_background_hosts_created_for_test());
  83. }
  84. // Test that the embedder can defer background host creation. Chrome does this
  85. // when the profile is created asynchronously, which may take a while.
  86. TEST_F(ProcessManagerTest, CreateBackgroundHostsDeferred) {
  87. std::unique_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
  88. original_context(), extension_registry()));
  89. ASSERT_FALSE(manager->startup_background_hosts_created_for_test());
  90. // Don't create background hosts if the delegate says to defer them.
  91. process_manager_delegate()->defer_creating_startup_background_hosts_ = true;
  92. manager->MaybeCreateStartupBackgroundHosts();
  93. EXPECT_FALSE(manager->startup_background_hosts_created_for_test());
  94. // The extension system becoming ready still doesn't create the hosts.
  95. extension_system()->SetReady();
  96. base::RunLoop().RunUntilIdle();
  97. EXPECT_FALSE(manager->startup_background_hosts_created_for_test());
  98. // Once the embedder is ready the background hosts can be created.
  99. process_manager_delegate()->defer_creating_startup_background_hosts_ = false;
  100. manager->MaybeCreateStartupBackgroundHosts();
  101. EXPECT_TRUE(manager->startup_background_hosts_created_for_test());
  102. }
  103. // Test that the embedder can disallow background host creation.
  104. // Chrome OS does this in guest mode.
  105. TEST_F(ProcessManagerTest, IsBackgroundHostAllowed) {
  106. std::unique_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
  107. original_context(), extension_registry()));
  108. ASSERT_FALSE(manager->startup_background_hosts_created_for_test());
  109. // Don't create background hosts if the delegate disallows them.
  110. process_manager_delegate()->is_background_page_allowed_ = false;
  111. manager->MaybeCreateStartupBackgroundHosts();
  112. EXPECT_FALSE(manager->startup_background_hosts_created_for_test());
  113. // The extension system becoming ready still doesn't create the hosts.
  114. extension_system()->SetReady();
  115. base::RunLoop().RunUntilIdle();
  116. EXPECT_FALSE(manager->startup_background_hosts_created_for_test());
  117. }
  118. // Test that extensions get grouped in the right SiteInstance (and therefore
  119. // process) based on their URLs.
  120. TEST_F(ProcessManagerTest, ProcessGrouping) {
  121. // Extensions in different browser contexts should always be different
  122. // SiteInstances.
  123. std::unique_ptr<ProcessManager> manager1(ProcessManager::CreateForTesting(
  124. original_context(), extension_registry()));
  125. // NOTE: This context is not associated with the TestExtensionsBrowserClient.
  126. // That's OK because we're not testing regular vs. incognito behavior.
  127. TestBrowserContext another_context;
  128. ExtensionRegistry another_registry(&another_context);
  129. std::unique_ptr<ProcessManager> manager2(
  130. ProcessManager::CreateForTesting(&another_context, &another_registry));
  131. // Extensions with common origins ("scheme://id/") should be grouped in the
  132. // same SiteInstance.
  133. GURL ext1_url1("chrome-extension://ext1_id/index.html");
  134. GURL ext1_url2("chrome-extension://ext1_id/monkey/monkey.html");
  135. GURL ext2_url1("chrome-extension://ext2_id/index.html");
  136. scoped_refptr<SiteInstance> site11 =
  137. manager1->GetSiteInstanceForURL(ext1_url1);
  138. scoped_refptr<SiteInstance> site12 =
  139. manager1->GetSiteInstanceForURL(ext1_url2);
  140. EXPECT_EQ(site11, site12);
  141. scoped_refptr<SiteInstance> site21 =
  142. manager1->GetSiteInstanceForURL(ext2_url1);
  143. EXPECT_NE(site11, site21);
  144. scoped_refptr<SiteInstance> other_profile_site =
  145. manager2->GetSiteInstanceForURL(ext1_url1);
  146. EXPECT_NE(site11, other_profile_site);
  147. BrowserContextDependencyManager::GetInstance()->DestroyBrowserContextServices(
  148. &another_context);
  149. }
  150. } // namespace extensions