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

extensions/browser/renderer_startup_helper_unittest.cc

 // Copyright 2017 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/renderer_startup_helper.h"
 
 #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"
 
 namespace extensions {
 
 class RendererStartupHelperTest : public ExtensionsTest {
  public:
   RendererStartupHelperTest() {}
   ~RendererStartupHelperTest() override {}
 
   void SetUp() override {
     ExtensionsTest::SetUp();
     helper_ = base::MakeUnique<RendererStartupHelper>(browser_context());
     registry_ =
         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();
   }
 
  protected:
   void SimulateRenderProcessCreated(content::RenderProcessHost* rph) {
     content::NotificationService::current()->Notify(
         content::NOTIFICATION_RENDERER_PROCESS_CREATED,
         content::Source<content::RenderProcessHost>(rph),
         content::NotificationService::NoDetails());
   }
 
   void SimulateRenderProcessTerminated(content::RenderProcessHost* rph) {
     content::NotificationService::current()->Notify(
         content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
         content::Source<content::RenderProcessHost>(rph),
         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")
             .Set("description", "an extension")
             .Set("manifest_version", 2)
             .Set("version", "0.1")
             .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")
             .Set("description", "a theme")
             .Set("theme", DictionaryBuilder().Build())
             .Set("manifest_version", 2)
             .Set("version", "0.1")
             .Build();
     return ExtensionBuilder()
         .SetManifest(std::move(manifest))
-        .SetID(extension_id)
+        .SetID(crx_file::id_util::GenerateId(id_input))
         .Build();
   }
 
   void AddExtensionToRegistry(scoped_refptr<Extension> extension) {
     registry_->AddEnabled(extension);
   }
 
   void RemoveExtensionFromRegistry(scoped_refptr<Extension> extension) {
     registry_->RemoveEnabled(extension->id());
   }
@@ skipping 16 matching lines @@
   bool IsExtensionPendingActivationInProcess(const Extension& extension,
                                              content::RenderProcessHost* rph) {
     return base::ContainsKey(helper_->pending_active_extensions_, rph) &&
            base::ContainsKey(helper_->pending_active_extensions_[rph],
                              extension.id());
   }
 
   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:
   DISALLOW_COPY_AND_ASSIGN(RendererStartupHelperTest);
 };
 
 // Tests extension loading, unloading and activation and render process creation
 // and termination.
 TEST_F(RendererStartupHelperTest, NormalExtensionLifecycle) {
   // Initialize render process.
@@ skipping 108 matching lines @@
   helper_->ActivateExtensionInProcess(*extension, render_process_host_.get());
   EXPECT_EQ(0u, sink.message_count());
   EXPECT_FALSE(IsExtensionPendingActivationInProcess(
       *extension, render_process_host_.get()));
 
   helper_->OnExtensionUnloaded(*extension);
   EXPECT_EQ(0u, sink.message_count());
   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