Move content's shell connections to the IO thread

content/gpu/gpu_child_thread.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/gpu/gpu_child_thread.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 18 matching lines @@
 #include "gpu/config/gpu_switches.h"
 #include "gpu/config/gpu_util.h"
 #include "gpu/ipc/common/memory_stats.h"
 #include "gpu/ipc/service/gpu_memory_buffer_factory.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "media/gpu/ipc/service/gpu_jpeg_decode_accelerator.h"
 #include "media/gpu/ipc/service/gpu_video_decode_accelerator.h"
 #include "media/gpu/ipc/service/gpu_video_encode_accelerator.h"
 #include "media/gpu/ipc/service/media_service.h"
+#include "services/shell/public/cpp/interface_registry.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/gpu_switching_manager.h"
 #include "ui/gl/init/gl_factory.h"
 #include "url/gurl.h"
 
 #if defined(USE_OZONE)
 #include "ui/ozone/public/gpu_platform_support.h"
 #include "ui/ozone/public/ozone_platform.h"
 #endif
@@ skipping 165 matching lines @@
 #if defined(OS_ANDROID)
   // When running in in-process mode, this has been set in the browser at
   // ChromeBrowserMainPartsAndroid::PreMainMessageLoopRun().
   if (!in_browser_process_)
     media::SetMediaClientAndroid(GetContentClient()->GetMediaClientAndroid());
 #endif
 
   // Only set once per process instance.
   process_control_.reset(new GpuProcessControlImpl());
 
+  // Use of base::Unretained(this) is safe here because |service_registry()|

[Ben Goodger (Google), 2016/07/03 03:29:27]

This seems worse than before - given that you don't have the ability to inspect
the incoming connection before you expose interfaces?

[Ken Rockot(use gerrit already), 2016/07/04 18:22:58]

Right, so it's not really worse in practice since these interfaces weren't
filtered based on any property of the incoming connection. This isn't what
interface registration should look like, but currently all interface
registration is expected to happen on the main thread, and this CL has to move
the relevant shell::Connections to the IO thread. AcceptConnection can't do its
work asynchronously or it would race with incoming connections. Also this part
of the CL wasn't complete when I sent it out.

Now I've changed ProcessControl exposure to be done via a ConnectionFilter which
lives on the IO thread.

It's necessary to have ConnectionFilters live on the IO thread, but it's also
super awkward when they want to register interfaces that should be bound on the
main thread. I would like to devise some reusable helpers for this, but since
there are only a handful of cases that exist today, I've opted to roll one-off
solutions for this CL (see ChromeInterfaceRegistry and
RenderWidgetWindowTreeClientWhateverRidiculousName for examples.)

+  // will be destroyed before GpuChildThread is destructed.
+  GetInterfaceRegistry()->AddInterface(base::Bind(
+      &GpuChildThread::BindProcessControlRequest, base::Unretained(this)));
+
+  if (GetContentClient()->gpu()) {  // NULL in tests.
+    GetContentClient()->gpu()->ExposeInterfacesToBrowser(
+        GetInterfaceRegistry());
+  }
+
+  // We don't want to process any incoming interface requests until
+  // OnInitialize() is invoked.
+  GetInterfaceRegistry()->PauseBinding();
+
   if (GetContentClient()->gpu())  // NULL in tests.
     GetContentClient()->gpu()->Initialize(this);
 }
 
 void GpuChildThread::OnFieldTrialGroupFinalized(const std::string& trial_name,
                                                 const std::string& group_name) {
   Send(new GpuHostMsg_FieldTrialActivated(trial_name));
 }
 
 bool GpuChildThread::Send(IPC::Message* msg) {
@@ skipping 49 matching lines @@
                         OnDestroyingVideoSurface);
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   if (handled)
     return true;
 
   return false;
 }
 
-bool GpuChildThread::AcceptConnection(shell::Connection* connection) {
-  // Use of base::Unretained(this) is safe here because |service_registry()|
-  // will be destroyed before GpuChildThread is destructed.
-  connection->GetInterfaceRegistry()->AddInterface(base::Bind(
-      &GpuChildThread::BindProcessControlRequest, base::Unretained(this)));
-
-  if (GetContentClient()->gpu()) {  // NULL in tests.
-    GetContentClient()->gpu()->ExposeInterfacesToBrowser(
-        connection->GetInterfaceRegistry());
-  }
-
-  // We don't want to process any incoming interface requests until
-  // OnInitialize().
-  if (!gpu_channel_manager_) {
-    connection->GetInterfaceRegistry()->PauseBinding();
-    resume_interface_bindings_callback_ = base::Bind(
-        &shell::InterfaceRegistry::ResumeBinding,
-        connection->GetInterfaceRegistry()->GetWeakPtr());
-  }
-
-  return true;
-}
-
-shell::InterfaceRegistry* GpuChildThread::GetInterfaceRegistryForConnection() {
-  return nullptr;
-}
-
-shell::InterfaceProvider* GpuChildThread::GetInterfaceProviderForConnection() {
-  return nullptr;
-}
-
 void GpuChildThread::SetActiveURL(const GURL& url) {
   GetContentClient()->SetActiveURL(url);
 }
 
 void GpuChildThread::DidCreateOffscreenContext(const GURL& active_url) {
   Send(new GpuHostMsg_DidCreateOffscreenContext(active_url));
 }
 
 void GpuChildThread::DidDestroyChannel(int client_id) {
   media_service_->RemoveChannel(client_id);
@@ skipping 23 matching lines @@
 }
 #endif
 
 void GpuChildThread::StoreShaderToDisk(int32_t client_id,
                                        const std::string& key,
                                        const std::string& shader) {
   Send(new GpuHostMsg_CacheShader(client_id, key, shader));
 }
 
 void GpuChildThread::OnInitialize(const gpu::GpuPreferences& gpu_preferences) {
-  if (!resume_interface_bindings_callback_.is_null())
-    base::ResetAndReturn(&resume_interface_bindings_callback_).Run();
+  GetInterfaceRegistry()->ResumeBinding();
 
   gpu_preferences_ = gpu_preferences;
 
   gpu_info_.video_decode_accelerator_capabilities =
       media::GpuVideoDecodeAccelerator::GetCapabilities(gpu_preferences_);
   gpu_info_.video_encode_accelerator_supported_profiles =
       media::GpuVideoEncodeAccelerator::GetSupportedProfiles(
           gpu_preferences_);
   gpu_info_.jpeg_decode_accelerator_supported =
       media::GpuJpegDecodeAccelerator::IsSupported();
@@ skipping 206 matching lines @@
 
 void GpuChildThread::BindProcessControlRequest(
     mojo::InterfaceRequest<mojom::ProcessControl> request) {
   DVLOG(1) << "GPU: Binding ProcessControl request";
   DCHECK(process_control_);
   process_control_bindings_.AddBinding(process_control_.get(),
                                        std::move(request));
 }
 
 }  // namespace content