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 "base/threading/thread_checker.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/connection_filter.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/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
 
+// This ConnectionFilter queues all incoming bind interface requests until
+// Release() is called.
+class GpuChildThread::QueueingConnectionFilter : public ConnectionFilter {
+ public:
+  QueueingConnectionFilter(
+      scoped_refptr<base::SequencedTaskRunner> io_task_runner,
+      std::unique_ptr<service_manager::BinderRegistry> registry)
+      : io_task_runner_(io_task_runner),
+        registry_(std::move(registry)),
+        weak_factory_(this) {
+    // This will be reattached by any of the IO thread functions on first call.
+    io_thread_checker_.DetachFromThread();
+  }
+  ~QueueingConnectionFilter() override {
+    DCHECK(io_thread_checker_.CalledOnValidThread());
+  }
+
+  void Release() {
+    base::AutoLock lock(lock_);
+    released_ = true;
+    io_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&QueueingConnectionFilter::ReleaseOnIOThread,
+                              base::Unretained(this)));
+  }
+
+  base::WeakPtr<QueueingConnectionFilter> GetWeakPtr() {

[Ken Rockot(use gerrit already), 2017/04/20 15:30:22]

WeakPtr must be dereferenced and invalidated from the same thread - you're
expecting to use a WeakPtr on one thread while invalidating it on another.
Instead of doing that, how about binding a callback to Release on the IO thread
which uses a WeakPtr, and just having GpuChildThread hold and invoke the
callback.

Then you don't have to expose a public GetWeakPtr method, and the WeakPtr will
always be dereferenced only on the IO thread where it's also invalidated.

It's a little ugly:

base::Closure GetReleaseCallback() {
  return base::Bind(base::IgnoreResult(&base::TaskRunner::PostTask),
                    io_task_runner_, FROM_HERE,
                    base::Bind(&QueueingConnectionFilter::Release,
                               weak_factory_.GetWeakPtr()));
}

but I think safe.

+    return weak_factory_.GetWeakPtr();
+  }
+
+ private:
+  struct PendingRequest {
+    service_manager::Identity source_identity;
+    std::string interface_name;
+    mojo::ScopedMessagePipeHandle interface_pipe;
+  };
+
+  // ConnectionFilter:
+  void OnBindInterface(const service_manager::ServiceInfo& source_info,
+                       const std::string& interface_name,
+                       mojo::ScopedMessagePipeHandle* interface_pipe,
+                       service_manager::Connector* connector) override {
+    DCHECK(io_thread_checker_.CalledOnValidThread());
+    if (registry_->CanBindInterface(interface_name)) {
+      base::AutoLock lock(lock_);
+      if (released_) {
+        registry_->BindInterface(source_info.identity, interface_name,
+                                 std::move(*interface_pipe));
+      } else {
+        std::unique_ptr<PendingRequest> request =
+            base::MakeUnique<PendingRequest>();
+        request->source_identity = source_info.identity;
+        request->interface_name = interface_name;
+        request->interface_pipe = std::move(*interface_pipe);
+        pending_requests_.push_back(std::move(request));
+      }
+    }
+  }
+
+  void ReleaseOnIOThread() {
+    DCHECK(io_thread_checker_.CalledOnValidThread());
+    for (auto& request : pending_requests_) {
+      registry_->BindInterface(request->source_identity,
+                               request->interface_name,
+                               std::move(request->interface_pipe));
+    }
+  }
+
+  base::ThreadChecker io_thread_checker_;
+  scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
+  // Guards |released_|.
+  base::Lock lock_;
+  bool released_ = false;
+  std::vector<std::unique_ptr<PendingRequest>> pending_requests_;
+  std::unique_ptr<service_manager::BinderRegistry> registry_;
+
+  base::WeakPtrFactory<QueueingConnectionFilter> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(QueueingConnectionFilter);
+};
+
 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)
+                         .AutoStartServiceManagerConnection(false)
                          .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();
+  AssociatedInterfaceRegistry* associated_registry = &associated_interfaces_;
+  associated_registry->AddInterface(base::Bind(
+      &GpuChildThread::CreateGpuMainService, base::Unretained(this)));
 
+  auto registry = base::MakeUnique<service_manager::BinderRegistry>();
+  registry->AddInterface(base::Bind(&GpuChildThread::BindServiceFactoryRequest,
+                                    base::Unretained(this)),
+                         base::ThreadTaskRunnerHandle::Get());
   if (GetContentClient()->gpu())  // NULL in tests.
-    GetContentClient()->gpu()->Initialize(this);
-  AssociatedInterfaceRegistry* registry = &associated_interfaces_;
-  registry->AddInterface(base::Bind(
-      &GpuChildThread::CreateGpuMainService, base::Unretained(this)));
+    GetContentClient()->gpu()->Initialize(this, registry.get());
+
+  std::unique_ptr<QueueingConnectionFilter> filter =
+      base::MakeUnique<QueueingConnectionFilter>(GetIOTaskRunner(),
+                                                 std::move(registry));
+  queueing_filter_ = filter->GetWeakPtr();
+  GetServiceManagerConnection()->AddConnectionFilter(std::move(filter));
+
+  StartServiceManagerConnection();
 }
 
 void GpuChildThread::OnFieldTrialGroupFinalized(const std::string& trial_name,
                                                 const std::string& group_name) {
   mojom::FieldTrialRecorderPtr field_trial_recorder;
   GetConnector()->BindInterface(mojom::kBrowserServiceName,
                                 &field_trial_recorder);
   field_trial_recorder->FieldTrialActivated(trial_name);
 }
 
@@ skipping 48 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)));
+  if (GetContentClient()->gpu())  // NULL in tests.
+    GetContentClient()->gpu()->GpuServiceInitialized(gpu_preferences);
 
-  if (GetContentClient()->gpu()) {  // NULL in tests.
-    GetContentClient()->gpu()->ExposeInterfacesToBrowser(GetInterfaceRegistry(),
-                                                         gpu_preferences);
-    GetContentClient()->gpu()->ConsumeInterfacesFromBrowser(GetConnector());
-  }
-
-  GetInterfaceRegistry()->ResumeBinding();
+  if (queueing_filter_)
+    queueing_filter_->Release();
 }
 
 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