Adds associated interface support between RenderFrameHost and RenderFrame.

Introduces a new content::AssociatedInterfaceRegistry and
content::AssociatedInterfaceProvider to serve as Channel-associated
interface counterparts to their shell namesakes.

RenderFrameHost and RenderFrame each have both of these things on them,
and they're routed to the other side using a new RouteProvider interface
buried in RenderProcessHostImpl / ChildThreadImpl on either end.

Also adds a WebContentsInterfaceRegistry to every WebContents,
and a helper WebContentsFrameBindingSet<T> to allow consumers to
very easily manage the lifetime of associated interface bindings
for each frame in a WebContents.

See the follow-up patch for example usage.

Part a series of CLs to enable and demonstrate WebContents associated
interfaces:

  1. https://codereview.chromium.org/2309513002
  2. https://codereview.chromium.org/2316963005
  3. This CL
  4. https://codereview.chromium.org/2310583002

BUG=612500
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_site_isolation

Review-Url: https://codereview.chromium.org/2310563002
Cr-Commit-Position: refs/heads/master@{#418717}

Author: krockot

content/browser/frame_host/render_frame_host_delegate.h

@@ -7,6 +7,7 @@
 
 #include <stdint.h>
 
+#include <string>
 #include <vector>
 
 #include "base/i18n/rtl.h"
@@ -17,6 +18,7 @@
 #include "content/public/browser/site_instance.h"
 #include "content/public/common/javascript_message_type.h"
 #include "content/public/common/media_stream_request.h"
+#include "mojo/public/cpp/bindings/scoped_interface_endpoint_handle.h"
 #include "net/http/http_response_headers.h"
 
 #if defined(OS_WIN)
@@ -54,6 +56,12 @@ class CONTENT_EXPORT RenderFrameHostDelegate {
   virtual bool OnMessageReceived(RenderFrameHost* render_frame_host,
                                  const IPC::Message& message);
 
+  // Allows the delegate to filter incoming associated inteface requests.
+  virtual void OnAssociatedInterfaceRequest(
+      RenderFrameHost* render_frame_host,
+      const std::string& interface_name,
+      mojo::ScopedInterfaceEndpointHandle handle) {}
+
   // Gets the last committed URL. See WebContents::GetLastCommittedURL for a
   // description of the semantics.
   virtual const GURL& GetMainFrameLastCommittedURL() const;

content/browser/frame_host/render_frame_host_impl.cc

@@ -53,6 +53,8 @@
 #include "content/browser/websockets/websocket_manager.h"
 #include "content/browser/webui/web_ui_controller_factory_registry.h"
 #include "content/common/accessibility_messages.h"
+#include "content/common/associated_interface_provider_impl.h"
+#include "content/common/associated_interfaces.mojom.h"
 #include "content/common/frame_messages.h"
 #include "content/common/frame_owner_properties.h"
 #include "content/common/input_messages.h"
@@ -87,6 +89,7 @@
 #include "device/vibration/vibration_manager_impl.h"
 #include "media/mojo/interfaces/media_service.mojom.h"
 #include "media/mojo/interfaces/service_factory.mojom.h"
+#include "mojo/public/cpp/bindings/associated_interface_ptr.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "ui/accessibility/ax_tree.h"
@@ -500,6 +503,28 @@ shell::InterfaceProvider* RenderFrameHostImpl::GetRemoteInterfaces() {
   return remote_interfaces_.get();
 }
 
+AssociatedInterfaceProvider*
+RenderFrameHostImpl::GetRemoteAssociatedInterfaces() {
+  if (!remote_associated_interfaces_) {
+    mojom::AssociatedInterfaceProviderAssociatedPtr remote_interfaces;
+    IPC::ChannelProxy* channel = GetProcess()->GetChannel();
+    if (channel) {
+      RenderProcessHostImpl* process =
+          static_cast<RenderProcessHostImpl*>(GetProcess());
+      process->GetRemoteRouteProvider()->GetRoute(
+          GetRoutingID(),
+          mojo::GetProxy(&remote_interfaces, channel->GetAssociatedGroup()));
+    } else {
+      // The channel may not be initialized in some tests environments. In this
+      // case we set up a dummy interface provider.
+      mojo::GetDummyProxyForTesting(&remote_interfaces);
+    }
+    remote_associated_interfaces_.reset(new AssociatedInterfaceProviderImpl(
+        std::move(remote_interfaces)));
+  }
+  return remote_associated_interfaces_.get();
+}
+
 blink::WebPageVisibilityState RenderFrameHostImpl::GetVisibilityState() {
   // Works around the crashes seen in https://crbug.com/501863, where the
   // active WebContents from a browser iterator may contain a render frame
@@ -643,6 +668,13 @@ bool RenderFrameHostImpl::OnMessageReceived(const IPC::Message &msg) {
   return handled;
 }
 
+void RenderFrameHostImpl::OnAssociatedInterfaceRequest(
+    const std::string& interface_name,
+    mojo::ScopedInterfaceEndpointHandle handle) {
+  delegate_->OnAssociatedInterfaceRequest(
+      this, interface_name, std::move(handle));
+}
+
 void RenderFrameHostImpl::AccessibilitySetFocus(int object_id) {
   Send(new AccessibilityMsg_SetFocus(routing_id_, object_id));
 }
@@ -1463,6 +1495,10 @@ void RenderFrameHostImpl::OnRenderProcessGone(int status, int exit_code) {
     iter.second.Run(ui::AXTreeUpdate());
   ax_tree_snapshot_callbacks_.clear();
 
+  // Ensure that future remote interface requests are associated with the new
+  // process's channel.
+  remote_associated_interfaces_.reset();
+
   if (!is_active()) {
     // If the process has died, we don't need to wait for the swap out ack from
     // this RenderFrame if it is pending deletion.  Complete the swap out to

content/browser/frame_host/render_frame_host_impl.h

@@ -74,6 +74,7 @@ class WebBluetoothService;
 
 namespace content {
 
+class AssociatedInterfaceProviderImpl;
 class CrossProcessFrameConnector;
 class CrossSiteTransferringRequest;
 class FrameTree;
@@ -159,6 +160,7 @@ class CONTENT_EXPORT RenderFrameHostImpl
   RenderViewHost* GetRenderViewHost() override;
   shell::InterfaceRegistry* GetInterfaceRegistry() override;
   shell::InterfaceProvider* GetRemoteInterfaces() override;
+  AssociatedInterfaceProvider* GetRemoteAssociatedInterfaces() override;
   blink::WebPageVisibilityState GetVisibilityState() override;
   bool IsRenderFrameLive() override;
   int GetProxyCount() override;
@@ -177,6 +179,9 @@ class CONTENT_EXPORT RenderFrameHostImpl
 
   // IPC::Listener
   bool OnMessageReceived(const IPC::Message& msg) override;
+  void OnAssociatedInterfaceRequest(
+      const std::string& interface_name,
+      mojo::ScopedInterfaceEndpointHandle handle) override;
 
   // BrowserAccessibilityDelegate
   void AccessibilitySetFocus(int acc_obj_id) override;
@@ -1055,6 +1060,9 @@ class CONTENT_EXPORT RenderFrameHostImpl
 
   std::vector<std::unique_ptr<shell::InterfaceRegistry>> media_registries_;
 
+  std::unique_ptr<AssociatedInterfaceProviderImpl>
+      remote_associated_interfaces_;
+
   // NOTE: This must be the last member.
   base::WeakPtrFactory<RenderFrameHostImpl> weak_ptr_factory_;
 

content/browser/renderer_host/render_process_host_impl.cc

@@ -675,6 +675,9 @@ RenderProcessHostImpl::RenderProcessHostImpl(
       child_token_(mojo::edk::GenerateRandomToken()),
       service_worker_ref_count_(0),
       shared_worker_ref_count_(0),
+      route_provider_binding_(this),
+      associated_interface_provider_bindings_(
+          mojo::BindingSetDispatchMode::WITH_CONTEXT),
       visible_widgets_(0),
       is_process_backgrounded_(false),
       is_initialized_(false),
@@ -815,10 +818,7 @@ RenderProcessHostImpl::~RenderProcessHostImpl() {
 #endif
   // We may have some unsent messages at this point, but that's OK.
   channel_.reset();
-  while (!queued_messages_.empty()) {
-    delete queued_messages_.front();
-    queued_messages_.pop();
-  }
+  queued_messages_ = MessageQueue{};
 
   UnregisterHost(GetID());
 
@@ -941,10 +941,19 @@ bool RenderProcessHostImpl::Init() {
         base::Bind(&RenderProcessHostImpl::OnMojoError,
                    weak_factory_.GetWeakPtr(),
                    base::ThreadTaskRunnerHandle::Get())));
+    channel_->Pause();
 
     fast_shutdown_started_ = false;
   }
 
+  // Push any pending messages to the channel now. Note that if the child
+  // process is still launching, the channel will be paused and outgoing
+  // messages will be queued internally by the channel.
+  while (!queued_messages_.empty()) {
+    channel_->Send(queued_messages_.front().release());
+    queued_messages_.pop();
+  }
+
   if (!gpu_observer_registered_) {
     gpu_observer_registered_ = true;
     ui::GpuSwitchingManager::GetInstance()->AddObserver(this);
@@ -967,24 +976,23 @@ std::unique_ptr<IPC::ChannelProxy> RenderProcessHostImpl::CreateChannelProxy(
       IPC::ChannelMojo::CreateServerFactory(
           bootstrap.PassInterface().PassHandle(), runner);
 
+  std::unique_ptr<IPC::ChannelProxy> channel;
   // Do NOT expand ifdef or run time condition checks here! Synchronous
   // IPCs from browser process are banned. It is only narrowly allowed
   // for Android WebView to maintain backward compatibility.
   // See crbug.com/526842 for details.
 #if defined(OS_ANDROID)
-  if (GetContentClient()->UsingSynchronousCompositing()) {
-    return IPC::SyncChannel::Create(
-        std::move(channel_factory), this, runner.get(), true, &never_signaled_);
-  }
+  if (GetContentClient()->UsingSynchronousCompositing())
+    channel = IPC::SyncChannel::Create(this, runner.get(), &never_signaled_);
 #endif  // OS_ANDROID
-
-  std::unique_ptr<IPC::ChannelProxy> channel(
-      new IPC::ChannelProxy(this, runner.get()));
+  if (!channel)
+    channel.reset(new IPC::ChannelProxy(this, runner.get()));
 #if USE_ATTACHMENT_BROKER
   IPC::AttachmentBroker::GetGlobal()->RegisterCommunicationChannel(
       channel.get(), runner);
 #endif
-  channel->Init(std::move(channel_factory), true);
+  channel->Init(std::move(channel_factory), true /* create_pipe_now */);
+
   return channel;
 }
 
@@ -1186,6 +1194,10 @@ void RenderProcessHostImpl::RegisterMojoInterfaces() {
       interface_registry_android_.get());
 #endif
 
+  channel_->AddAssociatedInterface(
+      base::Bind(&RenderProcessHostImpl::OnRouteProviderRequest,
+                 base::Unretained(this)));
+
 #if !defined(OS_ANDROID)
   AddUIThreadInterface(
       registry.get(), base::Bind(&device::BatteryMonitorImpl::Create));
@@ -1261,6 +1273,25 @@ void RenderProcessHostImpl::RegisterMojoInterfaces() {
       mojo_shell_connection->AddConnectionFilter(std::move(connection_filter));
 }
 
+void RenderProcessHostImpl::GetRoute(
+    int32_t routing_id,
+    mojom::AssociatedInterfaceProviderAssociatedRequest request) {
+  DCHECK(request.is_pending());
+  associated_interface_provider_bindings_.AddBinding(
+      this, std::move(request),
+      reinterpret_cast<void*>(static_cast<uintptr_t>(routing_id)));
+}
+
+void RenderProcessHostImpl::GetAssociatedInterface(
+    const std::string& name,
+    mojom::AssociatedInterfaceAssociatedRequest request) {
+  int32_t routing_id = static_cast<int32_t>(reinterpret_cast<uintptr_t>(
+      associated_interface_provider_bindings_.dispatch_context()));
+  IPC::Listener* listener = listeners_.Lookup(routing_id);
+  if (listener)
+    listener->OnAssociatedInterfaceRequest(name, request.PassHandle());
+}
+
 void RenderProcessHostImpl::CreateStoragePartitionService(
     mojo::InterfaceRequest<mojom::StoragePartitionService> request) {
   // DO NOT REMOVE THIS COMMAND LINE CHECK WITHOUT SECURITY REVIEW!
@@ -1347,6 +1378,14 @@ void RenderProcessHostImpl::PurgeAndSuspend() {
   Send(new ChildProcessMsg_PurgeAndSuspend());
 }
 
+mojom::RouteProvider* RenderProcessHostImpl::GetRemoteRouteProvider() {
+  if (!remote_route_provider_) {
+    DCHECK(channel_);
+    channel_->GetRemoteAssociatedInterface(&remote_route_provider_);
+  }
+  return remote_route_provider_.get();
+}
+
 void RenderProcessHostImpl::AddRoute(int32_t routing_id,
                                      IPC::Listener* listener) {
   CHECK(!listeners_.Lookup(routing_id)) << "Found Routing ID Conflict: "
@@ -1355,7 +1394,7 @@ void RenderProcessHostImpl::AddRoute(int32_t routing_id,
 }
 
 void RenderProcessHostImpl::RemoveRoute(int32_t routing_id) {
-  DCHECK(listeners_.Lookup(routing_id) != NULL);
+  DCHECK(listeners_.Lookup(routing_id) != nullptr);
   listeners_.Remove(routing_id);
   Cleanup();
 }
@@ -1861,38 +1900,33 @@ bool RenderProcessHostImpl::FastShutdownIfPossible() {
 
 bool RenderProcessHostImpl::Send(IPC::Message* msg) {
   TRACE_EVENT0("renderer_host", "RenderProcessHostImpl::Send");
+
+  std::unique_ptr<IPC::Message> message(msg);
+
 #if !defined(OS_ANDROID)
-  DCHECK(!msg->is_sync());
+  DCHECK(!message->is_sync());
 #endif
 
   if (!channel_) {
 #if defined(OS_ANDROID)
-    if (msg->is_sync()) {
-      delete msg;
+    if (message->is_sync())
       return false;
-    }
 #endif
     if (!is_initialized_) {
-      queued_messages_.push(msg);
+      queued_messages_.emplace(std::move(message));
       return true;
-    } else {
-      delete msg;
-      return false;
     }
+    return false;
   }
 
-  if (child_process_launcher_.get() && child_process_launcher_->IsStarting()) {
 #if defined(OS_ANDROID)
-    if (msg->is_sync()) {
-      delete msg;
-      return false;
-    }
-#endif
-    queued_messages_.push(msg);
-    return true;
+  if (child_process_launcher_.get() && child_process_launcher_->IsStarting() &&
+      message->is_sync()) {
+    return false;
   }
+#endif
 
-  return channel_->Send(msg);
+  return channel_->Send(message.release());
 }
 
 bool RenderProcessHostImpl::OnMessageReceived(const IPC::Message& msg) {
@@ -2548,6 +2582,13 @@ void RenderProcessHostImpl::CreateSharedRendererHistogramAllocator() {
       shm_handle, metrics_allocator_->shared_memory()->mapped_size()));
 }
 
+void RenderProcessHostImpl::OnRouteProviderRequest(
+    mojom::RouteProviderAssociatedRequest request) {
+  if (route_provider_binding_.is_bound())
+    return;
+  route_provider_binding_.Bind(std::move(request));
+}
+
 void RenderProcessHostImpl::ProcessDied(bool already_dead,
                                         RendererClosedDetails* known_details) {
   // Our child process has died.  If we didn't expect it, it's a crash.
@@ -2592,10 +2633,8 @@ void RenderProcessHostImpl::ProcessDied(bool already_dead,
       channel_.get());
 #endif
   channel_.reset();
-  while (!queued_messages_.empty()) {
-    delete queued_messages_.front();
-    queued_messages_.pop();
-  }
+  queued_messages_ = MessageQueue{};
+
   UpdateProcessPriority();
   DCHECK(!is_process_backgrounded_);
 
@@ -2746,6 +2785,12 @@ void RenderProcessHostImpl::OnProcessLaunched() {
     DCHECK(child_process_launcher_->GetProcess().IsValid());
     DCHECK(!is_process_backgrounded_);
 
+    // Unpause the channel now that the process is launched. We don't flush it
+    // yet to ensure that any initialization messages sent here (e.g., things
+    // done in response to NOTIFICATION_RENDER_PROCESS_CREATED; see below)
+    // preempt already queued messages.
+    channel_->Unpause(false /* flush */);
+
     if (mojo_child_connection_) {
       mojo_child_connection_->SetProcessHandle(
           child_process_launcher_->GetProcess().Handle());
@@ -2770,7 +2815,7 @@ void RenderProcessHostImpl::OnProcessLaunched() {
     CreateSharedRendererHistogramAllocator();
   }
 
-  // NOTE: This needs to be before sending queued messages because
+  // NOTE: This needs to be before flushing queued messages, because
   // ExtensionService uses this notification to initialize the renderer process
   // with state that must be there before any JavaScript executes.
   //
@@ -2781,10 +2826,8 @@ void RenderProcessHostImpl::OnProcessLaunched() {
                                          Source<RenderProcessHost>(this),
                                          NotificationService::NoDetails());
 
-  while (!queued_messages_.empty()) {
-    Send(queued_messages_.front());
-    queued_messages_.pop();
-  }
+  if (child_process_launcher_)
+    channel_->Flush();
 
   if (IsReady()) {
     DCHECK(!sent_render_process_ready_);