Introduce Extensions Renderer interface.

This API mirrors the content mojom Renderer interface for similar
messages that the extension system needs to implement.

It is an associated interface to support moving the messages without
breaking the rest of the system. Move ExtensionMsg_ActivateExtension as
the first message, others will be done in other commits.

BUG=692120

Change-Id: Ib42d16abc864440303df1e87631937f7dfde08ae
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2514724
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: Devlin <rdevlin.cronin@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#824500}

chrome/renderer/extensions/renderer_permissions_policy_delegate_unittest.cc

@@ -77,7 +77,7 @@ TEST_F(RendererPermissionsPolicyDelegateTest, CannotScriptWebstore) {
   scoped_refptr<const Extension> webstore_extension(
       CreateTestExtension(extensions::kWebStoreAppId));
   RendererExtensionRegistry::Get()->Insert(webstore_extension.get());
-  extension_dispatcher_->OnActivateExtension(extensions::kWebStoreAppId);
+  extension_dispatcher_->ActivateExtension(extensions::kWebStoreAppId);
   EXPECT_FALSE(
       extension->permissions_data()->CanAccessPage(kAnyUrl, -1, &error))
       << error;

extensions/browser/renderer_startup_helper.cc

@@ -79,8 +79,8 @@ RendererStartupHelper::RendererStartupHelper(BrowserContext* browser_context)
 }
 
 RendererStartupHelper::~RendererStartupHelper() {
-  for (auto* process : initialized_processes_)
-    process->RemoveObserver(this);
+  for (auto& process_entry : process_mojo_map_)
+    process_entry.first->RemoveObserver(this);
 }
 
 void RendererStartupHelper::OnRenderProcessHostCreated(
@@ -105,6 +105,11 @@ void RendererStartupHelper::InitializeProcess(
   if (!client->IsSameContext(browser_context_, process->GetBrowserContext()))
     return;
 
+  mojom::Renderer* renderer =
+      process_mojo_map_.emplace(process, BindNewRendererRemote(process))
+          .first->second.get();
+  process->AddObserver(this);
+
   bool activity_logging_enabled =
       client->IsActivityLoggingEnabled(process->GetBrowserContext());
   // We only send the ActivityLoggingEnabled message if it is enabled; otherwise
@@ -185,13 +190,11 @@ void RendererStartupHelper::InitializeProcess(
       DCHECK(extensions.Contains(id));
       DCHECK(base::Contains(extension_process_map_, id));
       DCHECK(base::Contains(extension_process_map_[id], process));
-      process->Send(new ExtensionMsg_ActivateExtension(id));
+      renderer->ActivateExtension(id);
     }
   }
 
-  initialized_processes_.insert(process);
   pending_active_extensions_.erase(process);
-  process->AddObserver(this);
 }
 
 void RendererStartupHelper::UntrackProcess(
@@ -202,7 +205,7 @@ void RendererStartupHelper::UntrackProcess(
   }
 
   process->RemoveObserver(this);
-  initialized_processes_.erase(process);
+  process_mojo_map_.erase(process);
   pending_active_extensions_.erase(process);
   for (auto& extension_process_pair : extension_process_map_)
     extension_process_pair.second.erase(process);
@@ -226,9 +229,10 @@ void RendererStartupHelper::ActivateExtensionInProcess(
   if (!IsExtensionVisibleToContext(extension, process->GetBrowserContext()))
     return;
 
-  if (base::Contains(initialized_processes_, process)) {
+  auto remote = process_mojo_map_.find(process);
+  if (remote != process_mojo_map_.end()) {
     DCHECK(base::Contains(extension_process_map_[extension.id()], process));
-    process->Send(new ExtensionMsg_ActivateExtension(extension.id()));
+    remote->second->ActivateExtension(extension.id());
   } else {
     pending_active_extensions_[process].insert(extension.id());
   }
@@ -269,7 +273,8 @@ void RendererStartupHelper::OnExtensionLoaded(const Extension& extension) {
   params.emplace_back(&extension, false /* no tab permissions */,
                       GetWorkerActivationSequence(browser_context_, extension));
 
-  for (content::RenderProcessHost* process : initialized_processes_) {
+  for (auto& process_entry : process_mojo_map_) {
+    content::RenderProcessHost* process = process_entry.first;
     if (!IsExtensionVisibleToContext(extension, process->GetBrowserContext()))
       continue;
     process->Send(new ExtensionMsg_Loaded(params));
@@ -287,7 +292,7 @@ void RendererStartupHelper::OnExtensionUnloaded(const Extension& extension) {
   const std::set<content::RenderProcessHost*>& loaded_process_set =
       extension_process_map_[extension.id()];
   for (content::RenderProcessHost* process : loaded_process_set) {
-    DCHECK(base::Contains(initialized_processes_, process));
+    DCHECK(base::Contains(process_mojo_map_, process));
     process->Send(new ExtensionMsg_Unloaded(extension.id()));
   }
 
@@ -305,6 +310,14 @@ void RendererStartupHelper::OnExtensionUnloaded(const Extension& extension) {
   extension_process_map_.erase(extension.id());
 }
 
+mojo::PendingAssociatedRemote<mojom::Renderer>
+RendererStartupHelper::BindNewRendererRemote(
+    content::RenderProcessHost* process) {
+  mojo::AssociatedRemote<mojom::Renderer> renderer_interface;
+  process->GetChannel()->GetRemoteAssociatedInterface(&renderer_interface);
+  return renderer_interface.Unbind();
+}
+
 //////////////////////////////////////////////////////////////////////////////
 
 // static

extensions/browser/renderer_startup_helper.h

@@ -16,6 +16,9 @@
 #include "content/public/browser/render_process_host_creation_observer.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "extensions/common/extension_id.h"
+#include "extensions/common/mojom/renderer.mojom.h"
+#include "mojo/public/cpp/bindings/associated_remote.h"
+#include "mojo/public/cpp/bindings/pending_associated_remote.h"
 
 namespace content {
 class BrowserContext;
@@ -65,6 +68,11 @@ class RendererStartupHelper : public KeyedService,
   void OnExtensionUnloaded(const Extension& extension);
   void OnExtensionLoaded(const Extension& extension);
 
+ protected:
+  // Provide ability for tests to override.
+  virtual mojo::PendingAssociatedRemote<mojom::Renderer> BindNewRendererRemote(
+      content::RenderProcessHost* process);
+
  private:
   friend class RendererStartupHelperTest;
 
@@ -81,18 +89,20 @@ class RendererStartupHelper : public KeyedService,
   std::map<ExtensionId, std::set<content::RenderProcessHost*>>
       extension_process_map_;
 
-  // The set of render processes that have had the initial batch of IPC messages
-  // sent, including the set of loaded extensions. Further messages that
-  // activate, load, or unload extensions should not be sent until after this
-  // happens.
-  std::set<content::RenderProcessHost*> initialized_processes_;
-
   // The set of ids for extensions that are active in a process that has not
   // been initialized. The activation message will be sent the process is
   // initialized.
   std::map<content::RenderProcessHost*, std::set<ExtensionId>>
       pending_active_extensions_;
 
+  // A map of render processes to mojo remotes. Being in this
+  // map means that have had the initial batch of IPC messages
+  // sent, including the set of loaded extensions. Further messages that
+  // activate, load, or unload extensions should not be sent until after this
+  // happens.
+  std::map<content::RenderProcessHost*, mojo::AssociatedRemote<mojom::Renderer>>
+      process_mojo_map_;
+
   DISALLOW_COPY_AND_ASSIGN(RendererStartupHelper);
 };
 

extensions/browser/renderer_startup_helper_unittest.cc

@@ -15,9 +15,39 @@
 #include "extensions/browser/test_extensions_browser_client.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/extension_messages.h"
+#include "mojo/public/cpp/bindings/associated_receiver_set.h"
 
 namespace extensions {
 
+// Class that implements the binding of a new Renderer mojom interface and
+// can receive callbacks on it for testing validation.
+class InterceptingRendererStartupHelper : public RendererStartupHelper,
+                                          public mojom::Renderer {
+ public:
+  explicit InterceptingRendererStartupHelper(
+      content::BrowserContext* browser_context)
+      : RendererStartupHelper(browser_context) {}
+
+  size_t num_activated_extensions() { return activated_extensions_.size(); }
+
+ protected:
+  mojo::PendingAssociatedRemote<mojom::Renderer> BindNewRendererRemote(
+      content::RenderProcessHost* process) override {
+    mojo::AssociatedRemote<mojom::Renderer> remote;
+    receivers_.Add(this, remote.BindNewEndpointAndPassDedicatedReceiver());
+    return remote.Unbind();
+  }
+
+ private:
+  // mojom::Renderer implementation:
+  void ActivateExtension(const std::string& extension_id) override {
+    activated_extensions_.push_back(extension_id);
+  }
+
+  std::vector<std::string> activated_extensions_;
+  mojo::AssociatedReceiverSet<mojom::Renderer> receivers_;
+};
+
 class RendererStartupHelperTest : public ExtensionsTest {
  public:
   RendererStartupHelperTest() {}
@@ -25,7 +55,8 @@ class RendererStartupHelperTest : public ExtensionsTest {
 
   void SetUp() override {
     ExtensionsTest::SetUp();
-    helper_ = std::make_unique<RendererStartupHelper>(browser_context());
+    helper_ =
+        std::make_unique<InterceptingRendererStartupHelper>(browser_context());
     registry_ =
         ExtensionRegistryFactory::GetForBrowserContext(browser_context());
     render_process_host_ =
@@ -102,7 +133,7 @@ class RendererStartupHelperTest : public ExtensionsTest {
   }
 
   bool IsProcessInitialized(content::RenderProcessHost* rph) {
-    return base::Contains(helper_->initialized_processes_, rph);
+    return base::Contains(helper_->process_mojo_map_, rph);
   }
 
   bool IsExtensionLoaded(const Extension& extension) {
@@ -122,7 +153,7 @@ class RendererStartupHelperTest : public ExtensionsTest {
                           extension.id());
   }
 
-  std::unique_ptr<RendererStartupHelper> helper_;
+  std::unique_ptr<InterceptingRendererStartupHelper> helper_;
   ExtensionRegistry* registry_;  // Weak.
   std::unique_ptr<content::MockRenderProcessHost> render_process_host_;
   std::unique_ptr<content::MockRenderProcessHost>
@@ -170,9 +201,8 @@ TEST_F(RendererStartupHelperTest, NormalExtensionLifecycle) {
   helper_->ActivateExtensionInProcess(*extension_, render_process_host_.get());
   EXPECT_FALSE(IsExtensionPendingActivationInProcess(
       *extension_, render_process_host_.get()));
-  ASSERT_EQ(1u, sink.message_count());
-  EXPECT_EQ(static_cast<uint32_t>(ExtensionMsg_ActivateExtension::ID),
-            sink.GetMessageAt(0)->type());
+  base::RunLoop().RunUntilIdle();
+  ASSERT_EQ(1u, helper_->num_activated_extensions());
 
   // Disable extension.
   sink.ClearMessages();

extensions/common/BUILD.gn

@@ -40,6 +40,7 @@ if (enable_extensions) {
       "mojom/app_window.mojom",
       "mojom/guest_view.mojom",
       "mojom/keep_alive.mojom",
+      "mojom/renderer.mojom",
     ]
 
     if (proprietary_codecs && enable_wifi_display) {

extensions/common/extension_messages.h

@@ -572,12 +572,6 @@ IPC_MESSAGE_CONTROL2(ExtensionMsg_SetSystemFont,
                      std::string /* font_family */,
                      std::string /* font_size */)
 
-// Marks an extension as 'active' in an extension process. 'Active' extensions
-// have more privileges than other extension content that might end up running
-// in the process (e.g. because of iframes or content scripts).
-IPC_MESSAGE_CONTROL1(ExtensionMsg_ActivateExtension,
-                     std::string /* extension_id */)
-
 // Notifies the renderer that extensions were loaded in the browser.
 IPC_MESSAGE_CONTROL1(ExtensionMsg_Loaded,
                      std::vector<ExtensionMsg_Loaded_Params>)

extensions/common/mojom/renderer.mojom

+// Copyright 2020 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.
+
+module extensions.mojom;
+
+// This should be used for implementing browser-to-renderer control messages
+// which need to retain FIFO with respect to other mojo interfaces like
+// content.mojom.Renderer.
+interface Renderer {
+  // Marks an extension as 'active' in an extension process. 'Active' extensions
+  // have more privileges than other extension content that might end up running
+  // in the process (e.g. because of iframes or content scripts).
+  ActivateExtension(string extension_id);
+};

extensions/renderer/DEPS

@@ -9,6 +9,7 @@ include_rules = [
   "+third_party/skia/include/core",
   "+third_party/cld_3",
 
+  "+third_party/blink/public/common/associated_interfaces/associated_interface_registry.h",
   "+third_party/blink/public/mojom/devtools/console_message.mojom.h",
   "+third_party/blink/public/mojom/loader/transferrable_url_loader.mojom.h",
   "+third_party/blink/public/mojom/frame/user_activation_notification_type.mojom.h",

extensions/renderer/dispatcher.cc

@@ -99,6 +99,7 @@
 #include "gin/converter.h"
 #include "mojo/public/js/grit/mojo_bindings_resources.h"
 #include "services/network/public/mojom/cors.mojom.h"
+#include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
 #include "third_party/blink/public/mojom/frame/user_activation_notification_type.mojom.h"
 #include "third_party/blink/public/platform/web_string.h"
 #include "third_party/blink/public/platform/web_url_request.h"
@@ -226,7 +227,8 @@ Dispatcher::Dispatcher(std::unique_ptr<DispatcherDelegate> delegate)
       source_map_(&ui::ResourceBundle::GetSharedInstance()),
       v8_schema_registry_(new V8SchemaRegistry),
       user_script_set_manager_observer_(this),
-      activity_logging_enabled_(false) {
+      activity_logging_enabled_(false),
+      receiver_(this) {
   bindings_system_ = CreateBindingsSystem(
       IPCMessageSender::CreateMainThreadIPCMessageSender());
 
@@ -306,7 +308,7 @@ void Dispatcher::DidCreateScriptContext(
       script_context_set_->Register(frame, v8_context, world_id);
 
   // Initialize origin permissions for content scripts, which can't be
-  // initialized in |OnActivateExtension|.
+  // initialized in |ActivateExtension|.
   if (context->context_type() == Feature::CONTENT_SCRIPT_CONTEXT)
     InitOriginPermissions(context->extension());
 
@@ -862,7 +864,6 @@ bool Dispatcher::OnControlMessageReceived(const IPC::Message& message) {
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(Dispatcher, message)
-  IPC_MESSAGE_HANDLER(ExtensionMsg_ActivateExtension, OnActivateExtension)
   IPC_MESSAGE_HANDLER(ExtensionMsg_CancelSuspend, OnCancelSuspend)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DeliverMessage, OnDeliverMessage)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnConnect, OnDispatchOnConnect)
@@ -898,7 +899,29 @@ bool Dispatcher::OnControlMessageReceived(const IPC::Message& message) {
   return handled;
 }
 
-void Dispatcher::OnActivateExtension(const std::string& extension_id) {
+void Dispatcher::RegisterMojoInterfaces(
+    blink::AssociatedInterfaceRegistry* associated_interfaces) {
+  // This base::Unretained() is safe, because:
+  // 1) the Dispatcher is a RenderThreadObserver and outlives the RenderThread.
+  // 2) |asscoiated_interfaces| is owned by the RenderThread.
+  // As well the Dispatcher is owned by the
+  // ExtensionsRendererClient, which in turn is a leaky LazyInstance (and thus
+  // never deleted).
+  associated_interfaces->AddInterface(base::BindRepeating(
+      &Dispatcher::OnRendererAssociatedRequest, base::Unretained(this)));
+}
+
+void Dispatcher::UnregisterMojoInterfaces(
+    blink::AssociatedInterfaceRegistry* associated_interfaces) {
+  associated_interfaces->RemoveInterface(mojom::Renderer::Name_);
+}
+
+void Dispatcher::OnRendererAssociatedRequest(
+    mojo::PendingAssociatedReceiver<mojom::Renderer> receiver) {
+  receiver_.Bind(std::move(receiver));
+}
+
+void Dispatcher::ActivateExtension(const std::string& extension_id) {
   const Extension* extension =
       RendererExtensionRegistry::Get()->GetByID(extension_id);
   if (!extension) {

extensions/renderer/dispatcher.h

@@ -25,11 +25,13 @@
 #include "extensions/common/extensions_client.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/common/features/feature_session_type.h"
+#include "extensions/common/mojom/renderer.mojom.h"
 #include "extensions/renderer/resource_bundle_source_map.h"
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/script_context_set.h"
 #include "extensions/renderer/user_script_set_manager.h"
 #include "extensions/renderer/v8_schema_registry.h"
+#include "mojo/public/cpp/bindings/associated_receiver.h"
 #include "third_party/blink/public/platform/web_string.h"
 #include "v8/include/v8.h"
 
@@ -74,7 +76,8 @@ struct PortId;
 // Dispatches extension control messages sent to the renderer and stores
 // renderer extension related state.
 class Dispatcher : public content::RenderThreadObserver,
-                   public UserScriptSetManager::Observer {
+                   public UserScriptSetManager::Observer,
+                   public mojom::Renderer {
  public:
   explicit Dispatcher(std::unique_ptr<DispatcherDelegate> delegate);
   ~Dispatcher() override;
@@ -198,15 +201,23 @@ class Dispatcher : public content::RenderThreadObserver,
 
  private:
   // The RendererPermissionsPolicyDelegateTest.CannotScriptWebstore test needs
-  // to call the OnActivateExtension IPCs.
+  // to call the ActivateExtension IPCs.
   friend class ::ChromeRenderViewTest;
   FRIEND_TEST_ALL_PREFIXES(RendererPermissionsPolicyDelegateTest,
                            CannotScriptWebstore);
 
   // RenderThreadObserver implementation:
   bool OnControlMessageReceived(const IPC::Message& message) override;
+  void RegisterMojoInterfaces(
+      blink::AssociatedInterfaceRegistry* associated_interfaces) override;
+  void UnregisterMojoInterfaces(
+      blink::AssociatedInterfaceRegistry* associated_interfaces) override;
 
-  void OnActivateExtension(const std::string& extension_id);
+  // mojom::Renderer implementation:
+  void ActivateExtension(const std::string& extension_id) override;
+
+  void OnRendererAssociatedRequest(
+      mojo::PendingAssociatedReceiver<mojom::Renderer> receiver);
   void OnCancelSuspend(const std::string& extension_id);
   void OnDeliverMessage(int worker_thread_id,
                         const PortId& target_port_id,
@@ -344,6 +355,10 @@ class Dispatcher : public content::RenderThreadObserver,
   // empty.
   std::string webview_partition_id_;
 
+  // Extensions renderer receiver. This is an associated receiver because
+  // it is dependent on other messages sent on other associated channels.
+  mojo::AssociatedReceiver<mojom::Renderer> receiver_;
+
   // Used to hold a service worker information which is ready to execute but the
   // onloaded message haven't been received yet. We need to defer service worker
   // execution until the ExtensionMsg_Loaded message is received because we can