Adds routed interface support between RenderFrameHost and RenderFrame

content/renderer/render_thread_impl.cc

 // Copyright (c) 2012 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 "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 570 matching lines @@
     const InProcessChildThreadParams& params,
     std::unique_ptr<blink::scheduler::RendererScheduler> scheduler,
     scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue)
     : ChildThreadImpl(Options::Builder()
                           .InBrowserProcess(params)
                           .UseMojoChannel(true)
                           .AutoStartMojoShellConnection(false)
                           .ConnectToBrowser(true)
                           .Build()),
       renderer_scheduler_(std::move(scheduler)),
-      categorized_worker_pool_(new CategorizedWorkerPool()) {
+      categorized_worker_pool_(new CategorizedWorkerPool()),
+      route_provider_binding_(this) {
   Init(resource_task_queue);
 }
 
 // When we run plugins in process, we actually run them on the render thread,
 // which means that we need to make the render thread pump UI events.
 RenderThreadImpl::RenderThreadImpl(
     std::unique_ptr<base::MessageLoop> main_message_loop,
     std::unique_ptr<blink::scheduler::RendererScheduler> scheduler)
     : ChildThreadImpl(Options::Builder()
                           .UseMojoChannel(true)
                           .AutoStartMojoShellConnection(false)
                           .ConnectToBrowser(true)
                           .Build()),
       renderer_scheduler_(std::move(scheduler)),
       main_message_loop_(std::move(main_message_loop)),
-      categorized_worker_pool_(new CategorizedWorkerPool()) {
+      categorized_worker_pool_(new CategorizedWorkerPool()),
+      route_provider_binding_(this) {
   scoped_refptr<base::SingleThreadTaskRunner> test_task_counter;
   Init(test_task_counter);
 }
 
 void RenderThreadImpl::Init(
     scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue) {
   TRACE_EVENT0("startup", "RenderThreadImpl::Init");
 
   base::trace_event::TraceLog::GetInstance()->SetThreadSortIndex(
       base::PlatformThread::CurrentId(),
@@ skipping 88 matching lines @@
 
   AddFilter((new ServiceWorkerContextMessageFilter())->GetFilter());
 
 #if defined(USE_AURA)
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseMusInRenderer)) {
     CreateRenderWidgetWindowTreeClientFactory(GetMojoShellConnection());
   }
 #endif
 
+  GetChannel()->AddAssociatedInterface(base::Bind(
+      &RenderThreadImpl::OnRouteProviderRequest, base::Unretained(this)));
+
   // Must be called before RenderThreadStarted() below.
   StartMojoShellConnection();
 
   GetContentClient()->renderer()->RenderThreadStarted();
 
   InitSkiaEventTracer();
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       skia::SkiaMemoryDumpProvider::GetInstance(), "Skia", nullptr);
 
   const base::CommandLine& command_line =
@@ skipping 307 matching lines @@
   if (!frame)
     return;
 
   scoped_refptr<PendingFrameCreate> create(it->second);
   frame->Bind(it->second->TakeFrameRequest(), it->second->TakeFrameHost());
   pending_frame_creates_.erase(it);
 }
 
 void RenderThreadImpl::RemoveRoute(int32_t routing_id) {
   ChildThreadImpl::GetRouter()->RemoveRoute(routing_id);
+  routed_interface_providers_.erase(routing_id);
 }
 
 void RenderThreadImpl::AddEmbeddedWorkerRoute(int32_t routing_id,
                                               IPC::Listener* listener) {
   AddRoute(routing_id, listener);
   if (devtools_agent_message_filter_.get()) {
     devtools_agent_message_filter_->AddEmbeddedWorkerRouteOnMainThread(
         routing_id);
   }
 }
@@ skipping 21 matching lines @@
 mojom::StoragePartitionService* RenderThreadImpl::GetStoragePartitionService() {
   return storage_partition_service_.get();
 }
 
 int RenderThreadImpl::GenerateRoutingID() {
   int routing_id = MSG_ROUTING_NONE;
   Send(new ViewHostMsg_GenerateRoutingID(&routing_id));
   return routing_id;
 }
 
+void RenderThreadImpl::AddRoutedInterfaces(
+    int32_t routing_id,
+    mojom::RoutedInterfaceProvider* provider) {
+  auto result =
+      routed_interface_providers_.insert(std::make_pair(routing_id, provider));
+  DCHECK(result.second);
+}
+
+mojom::RouteProvider* RenderThreadImpl::GetRemoteRouteProvider() {
+  if (!remote_route_provider_)
+    channel()->GetRemoteAssociatedInterface(&remote_route_provider_);
+  return remote_route_provider_.get();
+}
+
 void RenderThreadImpl::AddFilter(IPC::MessageFilter* filter) {
   channel()->AddFilter(filter);
 }
 
 void RenderThreadImpl::RemoveFilter(IPC::MessageFilter* filter) {
   channel()->RemoveFilter(filter);
 }
 
 void RenderThreadImpl::AddObserver(RenderThreadObserver* observer) {
   observers_.AddObserver(observer);
@@ skipping 1131 matching lines @@
 // OnSyncMemoryPressure() is never called in that case.
 void RenderThreadImpl::OnTrimMemoryImmediately() {
   if (blink::mainThreadIsolate()) {
     blink::mainThreadIsolate()->MemoryPressureNotification(
         v8::MemoryPressureLevel::kCritical);
     blink::MemoryPressureNotificationToWorkerThreadIsolates(
         v8::MemoryPressureLevel::kCritical);
   }
 }
 
+void RenderThreadImpl::OnRouteProviderRequest(
+    mojom::RouteProviderAssociatedRequest request) {
+  DCHECK(!route_provider_binding_.is_bound());
+  route_provider_binding_.Bind(std::move(request));
+}
+
+void RenderThreadImpl::GetRoutedInterfaces(
+    int32_t routing_id,
+    mojom::RoutedInterfaceProviderAssociatedRequest request) {
+  auto it = routed_interface_providers_.find(routing_id);
+  if (it == routed_interface_providers_.end())
+    return;
+  routed_interface_provider_bindings_.AddBinding(it->second,
+                                                 std::move(request));
+}
 
 }  // namespace content