Extensions: Only load incognito-enabled extensions in an incognito renderer.

extensions/browser/renderer_startup_helper_unittest.cc

Index: extensions/browser/renderer_startup_helper_unittest.cc
diff --git a/extensions/browser/renderer_startup_helper_unittest.cc b/extensions/browser/renderer_startup_helper_unittest.cc
index 56ff5bb1d3828da22ae64b87a40cb7786371463a..8cbcb458d7dd61dae05d41f695ea58c12b945c36 100644
--- a/extensions/browser/renderer_startup_helper_unittest.cc
+++ b/extensions/browser/renderer_startup_helper_unittest.cc
@@ -6,12 +6,16 @@
 
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
+#include "components/crx_file/id_util.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/test/mock_render_process_host.h"
+#include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_registry_factory.h"
+#include "extensions/browser/extension_util.h"
 #include "extensions/browser/extensions_test.h"
+#include "extensions/browser/test_extensions_browser_client.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/extension_messages.h"
 
@@ -29,11 +33,14 @@ class RendererStartupHelperTest : public ExtensionsTest {
         ExtensionRegistryFactory::GetForBrowserContext(browser_context());
     render_process_host_ =
         base::MakeUnique<content::MockRenderProcessHost>(browser_context());
+    incognito_render_process_host_ =
+        base::MakeUnique<content::MockRenderProcessHost>(incognito_context());
     extension_ = CreateExtension("ext_1");
   }
 
   void TearDown() override {
     render_process_host_.reset();
+    incognito_render_process_host_.reset();
     helper_.reset();
     ExtensionsTest::TearDown();
   }
@@ -53,7 +60,7 @@ class RendererStartupHelperTest : public ExtensionsTest {
         content::NotificationService::NoDetails());
   }
 
-  scoped_refptr<Extension> CreateExtension(const std::string& extension_id) {
+  scoped_refptr<Extension> CreateExtension(const std::string& id_input) {
     std::unique_ptr<base::DictionaryValue> manifest =
         DictionaryBuilder()
             .Set("name", "extension")
@@ -63,11 +70,11 @@ class RendererStartupHelperTest : public ExtensionsTest {
             .Build();
     return ExtensionBuilder()
         .SetManifest(std::move(manifest))
-        .SetID(extension_id)
+        .SetID(crx_file::id_util::GenerateId(id_input))
         .Build();
   }
 
-  scoped_refptr<Extension> CreateTheme(const std::string& extension_id) {
+  scoped_refptr<Extension> CreateTheme(const std::string& id_input) {
     std::unique_ptr<base::DictionaryValue> manifest =
         DictionaryBuilder()
             .Set("name", "theme")
@@ -78,7 +85,7 @@ class RendererStartupHelperTest : public ExtensionsTest {
             .Build();
     return ExtensionBuilder()
         .SetManifest(std::move(manifest))
-        .SetID(extension_id)
+        .SetID(crx_file::id_util::GenerateId(id_input))
         .Build();
   }
 
@@ -115,6 +122,8 @@ class RendererStartupHelperTest : public ExtensionsTest {
   std::unique_ptr<RendererStartupHelper> helper_;
   ExtensionRegistry* registry_;  // Weak.
   std::unique_ptr<content::MockRenderProcessHost> render_process_host_;
+  std::unique_ptr<content::MockRenderProcessHost>
+      incognito_render_process_host_;
   scoped_refptr<Extension> extension_;
 
  private:
@@ -243,4 +252,65 @@ TEST_F(RendererStartupHelperTest, LoadTheme) {
   EXPECT_FALSE(IsExtensionLoaded(*extension));
 }
 
+// Tests that only incognito-enabled extensions are loaded in an incognito
+// context.
+TEST_F(RendererStartupHelperTest, ExtensionInIncognitoRenderer) {
+  // Initialize the incognito renderer.
+  EXPECT_FALSE(IsProcessInitialized(incognito_render_process_host_.get()));
+  SimulateRenderProcessCreated(incognito_render_process_host_.get());
+  EXPECT_TRUE(IsProcessInitialized(incognito_render_process_host_.get()));
+
+  IPC::TestSink& sink = render_process_host_->sink();
+  IPC::TestSink& incognito_sink = incognito_render_process_host_->sink();
+
+  // Enable the extension. It should not be loaded in the incognito renderer.
+  sink.ClearMessages();
+  incognito_sink.ClearMessages();
+  EXPECT_FALSE(util::IsIncognitoEnabled(extension_->id(), browser_context()));
+  EXPECT_FALSE(IsExtensionLoaded(*extension_));
+  AddExtensionToRegistry(extension_);
+  helper_->OnExtensionLoaded(*extension_);
+  EXPECT_EQ(0u, sink.message_count());
+  EXPECT_EQ(0u, incognito_sink.message_count());
+  EXPECT_TRUE(IsExtensionLoaded(*extension_));
+  EXPECT_FALSE(IsExtensionLoadedInProcess(
+      *extension_, incognito_render_process_host_.get()));
+  EXPECT_FALSE(
+      IsExtensionLoadedInProcess(*extension_, render_process_host_.get()));
+
+  // Initialize the normal renderer. The extension should get loaded in it.
+  sink.ClearMessages();
+  incognito_sink.ClearMessages();
+  EXPECT_FALSE(IsProcessInitialized(render_process_host_.get()));
+  SimulateRenderProcessCreated(render_process_host_.get());
+  EXPECT_TRUE(IsProcessInitialized(render_process_host_.get()));
+  EXPECT_TRUE(
+      IsExtensionLoadedInProcess(*extension_, render_process_host_.get()));
+  EXPECT_LE(1u, sink.message_count());
+  EXPECT_EQ(0u, incognito_sink.message_count());
+
+  // Enable incognito mode for extension. This will reload the extension.
+  sink.ClearMessages();
+  incognito_sink.ClearMessages();
+  ExtensionPrefs::Get(browser_context())
+      ->SetIsIncognitoEnabled(extension_->id(), true);
+  helper_->OnExtensionUnloaded(*extension_);
+  helper_->OnExtensionLoaded(*extension_);
+  EXPECT_TRUE(IsExtensionLoadedInProcess(*extension_,
+                                         incognito_render_process_host_.get()));
+  EXPECT_TRUE(
+      IsExtensionLoadedInProcess(*extension_, render_process_host_.get()));
+  // The extension would not have been unloaded from the incognito renderer
+  // since it wasn't loaded.
+  ASSERT_EQ(1u, incognito_sink.message_count());
+  EXPECT_EQ(ExtensionMsg_Loaded::ID, incognito_sink.GetMessageAt(0)->type());
+  // The extension would be first unloaded and then loaded from the normal
+  // renderer.
+  ASSERT_EQ(2u, sink.message_count());
+  EXPECT_EQ(ExtensionMsg_Unloaded::ID, sink.GetMessageAt(0)->type());
+  EXPECT_EQ(ExtensionMsg_Loaded::ID, sink.GetMessageAt(1)->type());
+}
+
+TEST_F(RendererStartupHelperTest, PlatformAppInIncognitoRenderer) {}
+
 }  // namespace extensions