Move interface registration to OnConnect in RPH

content/browser/renderer_host/render_process_host_impl.cc

 // Copyright 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 130 matching lines @@
 #include "content/public/browser/owned_interface.h"
 #include "content/public/browser/render_process_host_factory.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/worker_service.h"
 #include "content/public/common/child_process_host.h"
+#include "content/public/common/connection_filter.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/mojo_channel_switches.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/resource_type.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #include "content/public/common/url_constants.h"
 #include "device/battery/battery_monitor_impl.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gpu_switches.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "ipc/attachment_broker.h"
 #include "ipc/attachment_broker_privileged.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_mojo.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_switches.h"
 #include "media/base/media_switches.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ppapi/shared_impl/ppapi_switches.h"
+#include "services/shell/public/cpp/connection.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "services/shell/public/cpp/interface_registry.h"
 #include "services/shell/runner/common/switches.h"
 #include "storage/browser/fileapi/sandbox_file_system_backend.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/display/display_switches.h"
 #include "ui/events/event_switches.h"
 #include "ui/gfx/switches.h"
 #include "ui/gl/gl_switches.h"
@@ skipping 262 matching lines @@
 std::string UintVectorToString(const std::vector<unsigned>& vector) {
   std::string str;
   for (auto it : vector) {
     if (!str.empty())
       str += ",";
     str += base::UintToString(it);
   }
   return str;
 }
 
-void CreateMemoryCoordinatorHandle(
-    int render_process_id,
-    memory_coordinator::mojom::MemoryCoordinatorHandleRequest request) {
-  BrowserMainLoop::GetInstance()->memory_coordinator()->CreateHandle(
-      render_process_id, std::move(request));
-}
-
 }  // namespace
 
 RendererMainThreadFactoryFunction g_renderer_main_thread_factory = NULL;
 
 base::MessageLoop* g_in_process_thread;
 
 base::MessageLoop*
 RenderProcessHostImpl::GetInProcessRendererThreadForTesting() {
   return g_in_process_thread;
 }
 
 // Stores the maximum number of renderer processes the content module can
 // create.
 static size_t g_max_renderer_count_override = 0;
 
+class RenderProcessHostImpl::ConnectionFilterImpl : public ConnectionFilter {
+ public:
+  explicit ConnectionFilterImpl(
+      base::WeakPtr<RenderProcessHostImpl> render_process_host)
+      : render_process_host_(render_process_host) {}
+  ~ConnectionFilterImpl() override {}
+
+ private:
+  // ConnectionFilter implementation:
+  bool OnConnect(shell::Connection* connection,
+                 shell::Connector* connector) override {
+    shell::InterfaceRegistry* reg = connection->GetInterfaceRegistry();
+
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner =
+        BrowserThread::GetTaskRunnerForThread(BrowserThread::UI);
+#if !defined(OS_ANDROID)
+    reg->AddInterface(base::Bind(&device::BatteryMonitorImpl::Create),
+                      ui_task_runner);
+#endif
+    reg->AddInterface(base::Bind(&ConnectionFilterImpl::BindPermissionService,
+                                 base::Unretained(this)),
+                      ui_task_runner);
+    reg->AddInterface(base::Bind(&ImageCaptureImpl::Create), ui_task_runner);
+    reg->AddInterface(base::Bind(&OffscreenCanvasSurfaceImpl::Create),
+                      ui_task_runner);
+    reg->AddInterface(
+        base::Bind(&ConnectionFilterImpl::BindBackgroundSyncService,
+                   base::Unretained(this)),
+        ui_task_runner);
+    reg->AddInterface(
+        base::Bind(&ConnectionFilterImpl::BindNotificationService,
+                   base::Unretained(this)),
+        ui_task_runner);
+    reg->AddInterface(
+        base::Bind(&ConnectionFilterImpl::BindStoragePartitionService,
+                   base::Unretained(this)),
+        ui_task_runner);
+    reg->AddInterface(
+        base::Bind(&ConnectionFilterImpl::BindBroadcastChannelProvider,
+                   base::Unretained(this)),
+        ui_task_runner);
+    if (memory_coordinator::IsEnabled()) {
+      reg->AddInterface(
+          base::Bind(&ConnectionFilterImpl::BindMemoryCoordinatorHandle,
+                     base::Unretained(this)),
+          ui_task_runner);
+    }
+
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
+        BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE);
+    reg->AddInterface(base::Bind(&MimeRegistryImpl::Create), file_task_runner);
+#if defined(USE_MINIKIN_HYPHENATION)
+    reg->AddInterface(base::Bind(&hyphenation::HyphenationImpl::Create),
+                      file_task_runner);
+#endif
+
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner =
+        BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
+    reg->AddInterface(base::Bind(&DeviceLightHost::Create), io_task_runner);
+    reg->AddInterface(base::Bind(&DeviceMotionHost::Create), io_task_runner);
+    reg->AddInterface(base::Bind(&DeviceOrientationHost::Create),
+                      io_task_runner);
+    reg->AddInterface(base::Bind(&DeviceOrientationAbsoluteHost::Create),
+                      io_task_runner);
+
+    GetContentClient()->browser()->ExposeInterfacesToRenderer(connection);
+    return true;
+  }
+
+  void BindPermissionService(blink::mojom::PermissionServiceRequest request) {
+    if (!render_process_host_)
+      return;
+    PermissionServiceContext* permission_service_context =
+        render_process_host_->permission_service_context_.get();
+    permission_service_context->CreateService(std::move(request));
+  }
+
+  void BindBackgroundSyncService(
+      blink::mojom::BackgroundSyncServiceRequest request) {
+    if (!render_process_host_)
+      return;
+    render_process_host_->storage_partition_impl_->GetBackgroundSyncContext()->
+        CreateService(std::move(request));
+  }
+
+  void BindNotificationService(
+      blink::mojom::NotificationServiceRequest request) {
+    if (!render_process_host_)
+      return;
+    render_process_host_->storage_partition_impl_->
+        GetPlatformNotificationContext()->CreateService(
+            render_process_host_->GetID(), std::move(request));
+  }
+
+  void BindStoragePartitionService(
+      mojom::StoragePartitionServiceRequest request) {
+    if (!render_process_host_)
+      return;
+    // DO NOT REMOVE THIS COMMAND LINE CHECK WITHOUT SECURITY REVIEW!
+    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kMojoLocalStorage)) {
+      render_process_host_->storage_partition_impl_->Bind(std::move(request));
+    }
+  }
+
+  void BindBroadcastChannelProvider(
+      blink::mojom::BroadcastChannelProviderRequest request) {
+    if (!render_process_host_)
+      return;
+    render_process_host_->storage_partition_impl_->
+        GetBroadcastChannelProvider()->Connect(std::move(request));
+  }
+
+  void BindMemoryCoordinatorHandle(
+      memory_coordinator::mojom::MemoryCoordinatorHandleRequest request) {
+    if (!render_process_host_)
+      return;
+    BrowserMainLoop::GetInstance()->memory_coordinator()->CreateHandle(
+        render_process_host_->GetID(), std::move(request));
+  }
+
+  base::WeakPtr<RenderProcessHostImpl> render_process_host_;
+
+  DISALLOW_COPY_AND_ASSIGN(ConnectionFilterImpl);
+};
+
 // static
 size_t RenderProcessHost::GetMaxRendererProcessCount() {
   if (g_max_renderer_count_override)
     return g_max_renderer_count_override;
 
 #if defined(OS_ANDROID)
   // On Android we don't maintain a limit of renderer process hosts - we are
   // happy with keeping a lot of these, as long as the number of live renderer
   // processes remains reasonable, and on Android the OS takes care of that.
   return std::numeric_limits<size_t>::max();
@@ skipping 268 matching lines @@
 
 #if defined(OS_ANDROID)
   // Initialize the java audio manager so that media session tests will pass.
   // See internal b/29872494.
   static_cast<media::AudioManagerAndroid*>(media::AudioManager::Get())->
       InitializeIfNeeded();
 #endif  // defined(OS_ANDROID)
 
   CreateMessageFilters();
   RegisterMojoInterfaces();
+  MojoShellConnection* connection =
+      BrowserContext::GetMojoShellConnectionFor(browser_context_);
+  BrowserThread::PostTask(BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&MojoShellConnection::AddConnectionFilter,
+                 base::Unretained(connection),
+                 base::Passed(base::WrapUnique(
+                     new ConnectionFilterImpl(weak_factory_.GetWeakPtr())))));
 
   if (run_renderer_in_process()) {
     DCHECK(g_renderer_main_thread_factory);
     // Crank up a thread and run the initialization there.  With the way that
     // messages flow between the browser and renderer, this thread is required
     // to prevent a deadlock in single-process mode.  Since the primordial
     // thread in the renderer process runs the WebKit code and can sometimes
     // make blocking calls to the UI thread (i.e. this thread), they need to run
     // on separate threads.
     in_process_renderer_.reset(
@@ skipping 275 matching lines @@
   AddFilter(new HistogramMessageFilter());
   AddFilter(new MemoryMessageFilter(this));
   AddFilter(new PushMessagingMessageFilter(
       GetID(), storage_partition_impl_->GetServiceWorkerContext()));
 #if defined(OS_ANDROID)
   AddFilter(new ScreenOrientationMessageFilterAndroid());
 #endif
 }
 
 void RenderProcessHostImpl::RegisterMojoInterfaces() {
-#if !defined(OS_ANDROID)
-  GetInterfaceRegistry()->AddInterface(
-      base::Bind(&device::BatteryMonitorImpl::Create));
-#endif
-
-  GetInterfaceRegistry()->AddInterface(
-      base::Bind(&PermissionServiceContext::CreateService,
-                 base::Unretained(permission_service_context_.get())));
-
-  // TODO(mcasas): finalize arguments.
-  GetInterfaceRegistry()->AddInterface(
-      base::Bind(&ImageCaptureImpl::Create));
-
-  GetInterfaceRegistry()->AddInterface(
-      base::Bind(&OffscreenCanvasSurfaceImpl::Create));
-
-  GetInterfaceRegistry()->AddInterface(base::Bind(
-      &BackgroundSyncContext::CreateService,
-      base::Unretained(storage_partition_impl_->GetBackgroundSyncContext())));
-
-  GetInterfaceRegistry()->AddInterface(base::Bind(
-      &PlatformNotificationContextImpl::CreateService,
-      base::Unretained(
-          storage_partition_impl_->GetPlatformNotificationContext()), GetID()));
-
-  GetInterfaceRegistry()->AddInterface(
-      base::Bind(&RenderProcessHostImpl::CreateStoragePartitionService,
-                 base::Unretained(this)));
-
-  GetInterfaceRegistry()->AddInterface(
-      base::Bind(&BroadcastChannelProvider::Connect,
-                 base::Unretained(
-                     storage_partition_impl_->GetBroadcastChannelProvider())));
-
-  scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
-      BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE);
-  GetInterfaceRegistry()->AddInterface(
-      base::Bind(&MimeRegistryImpl::Create), file_task_runner);
-
-#if defined(USE_MINIKIN_HYPHENATION)
-  GetInterfaceRegistry()->AddInterface(
-      base::Bind(&hyphenation::HyphenationImpl::Create), file_task_runner);
-#endif
-
-  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner =
-      BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
-  GetInterfaceRegistry()->AddInterface(base::Bind(&DeviceLightHost::Create),
-                                       io_task_runner);
-  GetInterfaceRegistry()->AddInterface(base::Bind(&DeviceMotionHost::Create),
-                                       io_task_runner);
-  GetInterfaceRegistry()->AddInterface(
-      base::Bind(&DeviceOrientationHost::Create), io_task_runner);
-  GetInterfaceRegistry()->AddInterface(
-      base::Bind(&DeviceOrientationAbsoluteHost::Create), io_task_runner);
-
-  if (memory_coordinator::IsEnabled()) {
-    GetInterfaceRegistry()->AddInterface(
-        base::Bind(&CreateMemoryCoordinatorHandle, GetID()));
-  }
-
 #if defined(OS_ANDROID)
   ServiceRegistrarAndroid::RegisterProcessHostServices(
       mojo_child_connection_->service_registry_android());
 #endif
-
-  GetContentClient()->browser()->ExposeInterfacesToRenderer(
-      GetInterfaceRegistry(), this);
-}
-
-void RenderProcessHostImpl::CreateStoragePartitionService(
-    mojo::InterfaceRequest<mojom::StoragePartitionService> request) {
-  // DO NOT REMOVE THIS COMMAND LINE CHECK WITHOUT SECURITY REVIEW!
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kMojoLocalStorage)) {
-    storage_partition_impl_->Bind(std::move(request));
-  }
 }
 
 int RenderProcessHostImpl::GetNextRoutingID() {
   return widget_helper_->GetNextRoutingID();
 }
 
 void RenderProcessHostImpl::ResumeDeferredNavigation(
     const GlobalRequestID& request_id) {
   widget_helper_->ResumeDeferredNavigation(request_id);
 }
@@ skipping 1645 matching lines @@
   LOG(ERROR) << "Terminating render process for bad Mojo message: " << error;
 
   // The ReceivedBadMessage call below will trigger a DumpWithoutCrashing. Alias
   // enough information here so that we can determine what the bad message was.
   base::debug::Alias(&error);
   bad_message::ReceivedBadMessage(process.get(),
                                   bad_message::RPH_MOJO_PROCESS_ERROR);
 }
 
 }  // namespace content