Migrate GpuChildThread to use ConnectionFilter instead of the ChildThread's InterfaceRegistry to exp

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"
 #include "base/callback_helpers.h"
 #include "build/build_config.h"
 #include "content/child/child_process.h"
 #include "content/common/field_trial_recorder.mojom.h"
 #include "content/gpu/gpu_service_factory.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/service_manager_connection.h"
 #include "content/public/common/service_names.mojom.h"
+#include "content/public/common/simple_connection_filter.h"
 #include "content/public/gpu/content_gpu_client.h"
 #include "gpu/command_buffer/common/activity_flags.h"
 #include "gpu/ipc/service/gpu_watchdog_thread.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "media/gpu/ipc/service/media_gpu_channel_manager.h"
+#include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/connector.h"
-#include "services/service_manager/public/cpp/interface_registry.h"
 #include "services/ui/gpu/interfaces/gpu_service.mojom.h"
 
 #if defined(USE_OZONE)
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "media/base/android/media_drm_bridge_client.h"
 #endif
 
 namespace content {
 namespace {
 
 ChildThreadImpl::Options GetOptions() {
   ChildThreadImpl::Options::Builder builder;
 
 #if defined(USE_OZONE)
   IPC::MessageFilter* message_filter =
       ui::OzonePlatform::GetInstance()->GetGpuMessageFilter();
   if (message_filter)
     builder.AddStartupFilter(message_filter);
 #endif
 
+  builder.AutoStartServiceManagerConnection(false);
   builder.ConnectToBrowser(true);
 
   return builder.Build();
 }
 
 }  // namespace
 
 GpuChildThread::GpuChildThread(
     std::unique_ptr<gpu::GpuWatchdogThread> watchdog_thread,
     bool dead_on_arrival,
     const gpu::GPUInfo& gpu_info,
     const gpu::GpuFeatureInfo& gpu_feature_info,
     DeferredMessages deferred_messages)
     : GpuChildThread(GetOptions(),
                      std::move(watchdog_thread),
                      dead_on_arrival,
                      false /* in_browser_process */,
                      gpu_info,
                      gpu_feature_info) {
   deferred_messages_ = std::move(deferred_messages);
 }
 
 GpuChildThread::GpuChildThread(const InProcessChildThreadParams& params,
                                const gpu::GPUInfo& gpu_info,
                                const gpu::GpuFeatureInfo& gpu_feature_info)
     : GpuChildThread(ChildThreadImpl::Options::Builder()
                          .InBrowserProcess(params)

[Ken Rockot(use gerrit already), 2017/04/19 01:26:30]

Need to turn off autostart for this constructor as well

                          .ConnectToBrowser(true)
                          .Build(),
                      nullptr /* watchdog_thread */,
                      false /* dead_on_arrival */,
                      true /* in_browser_process */,
                      gpu_info,
                      gpu_feature_info) {}
 
 GpuChildThread::GpuChildThread(
     const ChildThreadImpl::Options& options,
@@ skipping 25 matching lines @@
 void GpuChildThread::Init(const base::Time& process_start_time) {
   gpu_service_->set_start_time(process_start_time);
 
 #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::SetMediaDrmBridgeClient(
         GetContentClient()->GetMediaDrmBridgeClient());
 #endif
-  // 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);
   AssociatedInterfaceRegistry* registry = &associated_interfaces_;
   registry->AddInterface(base::Bind(
       &GpuChildThread::CreateGpuMainService, base::Unretained(this)));
 }
 
 void GpuChildThread::OnFieldTrialGroupFinalized(const std::string& trial_name,
                                                 const std::string& group_name) {
   mojom::FieldTrialRecorderPtr field_trial_recorder;
@@ skipping 53 matching lines @@
   gpu_service_->InitializeWithHost(
       std::move(gpu_host),
       gpu::GpuProcessActivityFlags(std::move(activity_flags)),
       sync_point_manager, ChildProcess::current()->GetShutDownEvent());
   CHECK(gpu_service_->media_gpu_channel_manager());
 
   // Only set once per process instance.
   service_factory_.reset(new GpuServiceFactory(
       gpu_service_->media_gpu_channel_manager()->AsWeakPtr()));
 
-  GetInterfaceRegistry()->AddInterface(base::Bind(
-      &GpuChildThread::BindServiceFactoryRequest, base::Unretained(this)));
+  auto registry = base::MakeUnique<service_manager::BinderRegistry>();
+  registry->AddInterface(base::Bind(&GpuChildThread::BindServiceFactoryRequest,
+                                    base::Unretained(this)),
+                         base::ThreadTaskRunnerHandle::Get());
+  GetServiceManagerConnection()->AddConnectionFilter(
+      base::MakeUnique<SimpleConnectionFilter>(std::move(registry)));
 
-  if (GetContentClient()->gpu()) {  // NULL in tests.
-    GetContentClient()->gpu()->ExposeInterfacesToBrowser(GetInterfaceRegistry(),
-                                                         gpu_preferences);
-    GetContentClient()->gpu()->ConsumeInterfacesFromBrowser(GetConnector());
-  }
+  if (GetContentClient()->gpu())  // NULL in tests.
+    GetContentClient()->gpu()->GpuServiceInitialized(gpu_preferences);
 
-  GetInterfaceRegistry()->ResumeBinding();
+  StartServiceManagerConnection();
 }
 
 void GpuChildThread::CreateFrameSinkManager(
     cc::mojom::FrameSinkManagerRequest request,
     cc::mojom::FrameSinkManagerClientPtr client) {
   NOTREACHED();
 }
 
 void GpuChildThread::BindServiceFactoryRequest(
     service_manager::mojom::ServiceFactoryRequest request) {
   DVLOG(1) << "GPU: Binding service_manager::mojom::ServiceFactoryRequest";
   DCHECK(service_factory_);
   service_factory_bindings_.AddBinding(service_factory_.get(),
                                        std::move(request));
 }
 
 }  // namespace content