Convert content ConnectionFilter to OnBindInterface

content/common/service_manager/service_manager_connection_impl.cc

 // Copyright 2016 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/common/service_manager/service_manager_connection_impl.h"
 
 #include <queue>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "content/common/child.mojom.h"
 #include "content/common/service_manager/embedded_service_runner.h"
 #include "content/public/common/connection_filter.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "services/service_manager/public/cpp/interface_registry.h"
 #include "services/service_manager/public/cpp/service.h"
 #include "services/service_manager/public/cpp/service_context.h"
 #include "services/service_manager/public/interfaces/constants.mojom.h"
 #include "services/service_manager/public/interfaces/service_factory.mojom.h"
 #include "services/service_manager/runner/common/client_util.h"
 
 namespace content {
 namespace {
 
 base::LazyInstance<std::unique_ptr<ServiceManagerConnection>>::Leaky
     g_connection_for_process = LAZY_INSTANCE_INITIALIZER;
 
 ServiceManagerConnection::Factory* service_manager_connection_factory = nullptr;
 
 }  // namespace
 
 // A ref-counted object which owns the IO thread state of a
 // ServiceManagerConnectionImpl. This includes Service and ServiceFactory
 // bindings.
 class ServiceManagerConnectionImpl::IOThreadContext
     : public base::RefCountedThreadSafe<IOThreadContext>,
       public service_manager::Service,
-      public service_manager::InterfaceFactory<
-          service_manager::mojom::ServiceFactory>,
-      public service_manager::mojom::ServiceFactory {
+      public service_manager::mojom::ServiceFactory,
+      public mojom::Child {
  public:
   using InitializeCallback =
-      base::Callback<void(const service_manager::Identity&)>;
+      base::Callback<void(const service_manager::ServiceInfo&)>;
 
   IOThreadContext(
       service_manager::mojom::ServiceRequest service_request,
       scoped_refptr<base::SequencedTaskRunner> io_task_runner,
       std::unique_ptr<service_manager::Connector> io_thread_connector,
       service_manager::mojom::ConnectorRequest connector_request)
       : pending_service_request_(std::move(service_request)),
         io_task_runner_(io_task_runner),
         io_thread_connector_(std::move(io_thread_connector)),
         pending_connector_request_(std::move(connector_request)),
+        child_binding_(this),
         weak_factory_(this) {
     // This will be reattached by any of the IO thread functions on first call.
     io_thread_checker_.DetachFromThread();
   }
 
   // Safe to call from any thread.
-  void Start(
-      const InitializeCallback& initialize_callback,
-      const ServiceManagerConnection::OnConnectHandler& on_connect_callback,
-      const base::Closure& stop_callback) {
+  void Start(const InitializeCallback& local_info_available_callback,
+             const InitializeCallback& browser_info_available_callback,
+             const base::Closure& stop_callback) {
     DCHECK(!started_);
 
     started_ = true;
     callback_task_runner_ = base::ThreadTaskRunnerHandle::Get();
-    initialize_handler_ = initialize_callback;
-    on_connect_callback_ = on_connect_callback;
+    local_info_available_callback_ = local_info_available_callback;
+    browser_info_available_callback_ = browser_info_available_callback;
     stop_callback_ = stop_callback;
     io_task_runner_->PostTask(
         FROM_HERE, base::Bind(&IOThreadContext::StartOnIOThread, this));
   }
 
   // Safe to call from whichever thread called Start() (or may have called
   // Start()). Must be called before IO thread shutdown.
   void ShutDown() {
     if (!started_)
       return;
@@ skipping 168 matching lines @@
     DCHECK(io_thread_checker_.CalledOnValidThread());
     auto result = request_handlers_.insert(std::make_pair(name, handler));
     DCHECK(result.second);
   }
 
   /////////////////////////////////////////////////////////////////////////////
   // service_manager::Service implementation
 
   void OnStart() override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
-    DCHECK(!initialize_handler_.is_null());
+    DCHECK(!local_info_available_callback_.is_null());
     local_info_ = context()->local_info();
 
-    InitializeCallback handler = base::ResetAndReturn(&initialize_handler_);
+    InitializeCallback handler =
+        base::ResetAndReturn(&local_info_available_callback_);
     callback_task_runner_->PostTask(FROM_HERE,
-                                    base::Bind(handler, local_info_.identity));
+                                    base::Bind(handler, local_info_));
   }
 
-  bool OnConnect(const service_manager::ServiceInfo& remote_info,
-                 service_manager::InterfaceRegistry* registry) override {
+  void OnBindInterface(const service_manager::ServiceInfo& source_info,
+                       const std::string& interface_name,
+                       mojo::ScopedMessagePipeHandle interface_pipe) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
 
-    callback_task_runner_->PostTask(
-        FROM_HERE, base::Bind(on_connect_callback_, local_info_, remote_info));
-
-    std::string remote_service = remote_info.identity.name();
-    if (remote_service == service_manager::mojom::kServiceName) {
-      // Only expose the ServiceFactory interface to the Service Manager.
-      registry->AddInterface<service_manager::mojom::ServiceFactory>(this);
-      return true;
+    std::string remote_service = source_info.identity.name();
+    // Only expose the ServiceFactory interface to the Service Manager.
+    if (remote_service == service_manager::mojom::kServiceName &&
+        interface_name == service_manager::mojom::ServiceFactory::Name_) {
+      factory_bindings_.AddBinding(
+          this, mojo::MakeRequest<service_manager::mojom::ServiceFactory>(
+                    std::move(interface_pipe)));
+      return;
     }
 
-    bool accept = false;
     {
       base::AutoLock lock(lock_);
       for (auto& entry : connection_filters_) {
-        accept |= entry.second->OnConnect(remote_info.identity, registry,
-                                          service_context_->connector());
+        entry.second->OnBindInterface(source_info, interface_name,
+                                      &interface_pipe,
+                                      service_context_->connector());
+        // A filter may have bound the interface, claiming the pipe.
+        if (!interface_pipe.is_valid())
+          return;
       }
     }
 
-    if (remote_service == "content_browser" &&
-        !has_browser_connection_) {
-      has_browser_connection_ = true;
-      registry->set_default_binder(default_browser_binder_);
-      registry->AddConnectionLostClosure(
-          base::Bind(&IOThreadContext::OnBrowserConnectionLost, this));
-      return true;
+    if (remote_service == "content_browser") {
+      if (interface_name == mojom::Child::Name_ && !has_browser_connection_) {
+        has_browser_connection_ = true;
+        InitializeCallback handler =
+            base::ResetAndReturn(&browser_info_available_callback_);
+        callback_task_runner_->PostTask(FROM_HERE,
+                                        base::Bind(handler, source_info));
+
+        child_binding_.Bind(std::move(interface_pipe));
+        child_binding_.set_connection_error_handler(
+            base::Bind(&IOThreadContext::OnBrowserConnectionLost, this));
+      } else {
+        default_browser_binder_.Run(interface_name, std::move(interface_pipe));
+      }
     }
-
-    // If no filters were interested, reject the connection.
-    return accept;
   }
 
   bool OnServiceManagerConnectionLost() override {
     ClearConnectionFiltersOnIOThread();
     callback_task_runner_->PostTask(FROM_HERE, stop_callback_);
     return true;
   }
 
   /////////////////////////////////////////////////////////////////////////////
-  // service_manager::InterfaceFactory<service_manager::mojom::ServiceFactory>
-  // implementation
-
-  void Create(const service_manager::Identity& remote_identity,
-              service_manager::mojom::ServiceFactoryRequest request) override {
-    DCHECK(io_thread_checker_.CalledOnValidThread());
-    factory_bindings_.AddBinding(this, std::move(request));
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
   // service_manager::mojom::ServiceFactory implementation
 
   void CreateService(service_manager::mojom::ServiceRequest request,
                      const std::string& name) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     auto it = request_handlers_.find(name);
     DCHECK(it != request_handlers_.end())
         << "Can't create service " << name << ". No handler found.";
     it->second.Run(std::move(request));
   }
@@ skipping 15 matching lines @@
   service_manager::mojom::ServiceRequest pending_service_request_;
   scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
   std::unique_ptr<service_manager::Connector> io_thread_connector_;
   service_manager::mojom::ConnectorRequest pending_connector_request_;
 
   // TaskRunner on which to run our owner's callbacks, i.e. the ones passed to
   // Start().
   scoped_refptr<base::SequencedTaskRunner> callback_task_runner_;
 
   // Callback to run once Service::OnStart is invoked.
-  InitializeCallback initialize_handler_;
-
-  // Callback to run when a connection request is received.
-  ServiceManagerConnection::OnConnectHandler on_connect_callback_;
+  InitializeCallback local_info_available_callback_;
+  InitializeCallback browser_info_available_callback_;
 
   // Callback to run if the service is stopped by the service manager.
   base::Closure stop_callback_;
 
   // Called once a connection has been received from the browser process & the
   // default binder (below) has been set up.
   bool has_browser_connection_ = false;
 
   service_manager::ServiceInfo local_info_;
 
@@ skipping 12 matching lines @@
   MessageLoopObserver* message_loop_observer_ = nullptr;
 
   // Guards |connection_filters_|.
   base::Lock lock_;
   std::map<int, std::unique_ptr<ConnectionFilter>> connection_filters_;
 
   std::unordered_map<std::string, std::unique_ptr<EmbeddedServiceRunner>>
       embedded_services_;
   std::unordered_map<std::string, ServiceRequestHandler> request_handlers_;
 
+  mojo::Binding<mojom::Child> child_binding_;
+
   base::WeakPtrFactory<IOThreadContext> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(IOThreadContext);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceManagerConnection, public:
 
 // static
 void ServiceManagerConnection::SetForProcess(
@@ skipping 50 matching lines @@
 
 ServiceManagerConnectionImpl::~ServiceManagerConnectionImpl() {
   context_->ShutDown();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceManagerConnectionImpl, ServiceManagerConnection implementation:
 
 void ServiceManagerConnectionImpl::Start() {
   context_->Start(
-      base::Bind(&ServiceManagerConnectionImpl::OnContextInitialized,
+      base::Bind(&ServiceManagerConnectionImpl::OnLocalServiceInfoAvailable,
                  weak_factory_.GetWeakPtr()),
-      base::Bind(&ServiceManagerConnectionImpl::OnConnect,
+      base::Bind(&ServiceManagerConnectionImpl::OnBrowserServiceInfoAvailable,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&ServiceManagerConnectionImpl::OnConnectionLost,
                  weak_factory_.GetWeakPtr()));
 }
 
 service_manager::Connector* ServiceManagerConnectionImpl::GetConnector() {
   return connector_.get();
 }
 
-const service_manager::Identity& ServiceManagerConnectionImpl::GetIdentity()
+const service_manager::ServiceInfo& ServiceManagerConnectionImpl::GetLocalInfo()
     const {
-  return identity_;
+  return local_info_;
+}
+
+const service_manager::ServiceInfo&
+ServiceManagerConnectionImpl::GetBrowserInfo() const {
+  return browser_info_;
 }
 
 void ServiceManagerConnectionImpl::SetConnectionLostClosure(
     const base::Closure& closure) {
   connection_lost_handler_ = closure;
 }
 
 void ServiceManagerConnectionImpl::SetupInterfaceRequestProxies(
     service_manager::InterfaceRegistry* registry,
     service_manager::InterfaceProvider* provider) {
@@ skipping 32 matching lines @@
   on_connect_handlers_[id] = handler;
   return id;
 }
 
 void ServiceManagerConnectionImpl::RemoveOnConnectHandler(int id) {
   auto it = on_connect_handlers_.find(id);
   DCHECK(it != on_connect_handlers_.end());
   on_connect_handlers_.erase(it);
 }
 
-void ServiceManagerConnectionImpl::OnContextInitialized(
-    const service_manager::Identity& identity) {
-  identity_ = identity;
+void ServiceManagerConnectionImpl::OnLocalServiceInfoAvailable(
+    const service_manager::ServiceInfo& local_info) {
+  local_info_ = local_info;
+}
+
+void ServiceManagerConnectionImpl::OnBrowserServiceInfoAvailable(
+    const service_manager::ServiceInfo& browser_info) {
+  browser_info_ = browser_info;
+  for (auto& handler : on_connect_handlers_)
+    handler.second.Run(local_info_, browser_info_);
 }
 
 void ServiceManagerConnectionImpl::OnConnectionLost() {
   if (!connection_lost_handler_.is_null())
     connection_lost_handler_.Run();
 }
 
-void ServiceManagerConnectionImpl::OnConnect(
-    const service_manager::ServiceInfo& local_info,
-    const service_manager::ServiceInfo& remote_info) {
-  local_info_ = local_info;
-  for (auto& handler : on_connect_handlers_)
-    handler.second.Run(local_info, remote_info);
-}
-
 void ServiceManagerConnectionImpl::GetInterface(
     service_manager::mojom::InterfaceProvider* provider,
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle request_handle) {
   provider->GetInterface(interface_name, std::move(request_handle));
 }
 
 }  // namespace content