Revert of Eliminate ChildThread InterfaceRegistry.

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 "content/public/common/service_names.mojom.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
@@ skipping 70 matching lines @@
     return id;
   }
 
   void RemoveConnectionFilter(int filter_id) {
     io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&IOThreadContext::RemoveConnectionFilterOnIOThread, this,
                    filter_id));
   }
 
+  // Safe to call any time before Start() is called.
+  void SetDefaultBinderForBrowserConnection(
+      const service_manager::InterfaceRegistry::Binder& binder) {
+    DCHECK(!started_);
+    default_browser_binder_ = base::Bind(
+        &IOThreadContext::CallBinderOnTaskRunner,
+        base::ThreadTaskRunnerHandle::Get(), binder);
+  }
+
   void AddEmbeddedService(const std::string& name, const ServiceInfo& info) {
     io_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ServiceManagerConnectionImpl::IOThreadContext::
                                   AddEmbeddedServiceRequestHandlerOnIoThread,
                               this, name, info));
   }
 
   void AddServiceRequestHandler(const std::string& name,
                                 const ServiceRequestHandler& handler) {
     io_task_runner_->PostTask(
@@ skipping 91 matching lines @@
 
   void RemoveConnectionFilterOnIOThread(int filter_id) {
     base::AutoLock lock(lock_);
     auto it = connection_filters_.find(filter_id);
     // During shutdown the connection filters might have been cleared already
     // by ClearConnectionFiltersOnIOThread() above, so this id might not exist.
     if (it != connection_filters_.end())
       connection_filters_.erase(it);
   }
 
+  void OnBrowserConnectionLost() {
+    DCHECK(io_thread_checker_.CalledOnValidThread());
+    has_browser_connection_ = false;
+  }
+
   void AddEmbeddedServiceRequestHandlerOnIoThread(const std::string& name,
                                                   const ServiceInfo& info) {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     std::unique_ptr<EmbeddedServiceRunner> service(
         new EmbeddedServiceRunner(name, info));
     AddServiceRequestHandlerOnIoThread(
         name, base::Bind(&EmbeddedServiceRunner::BindServiceRequest,
                          base::Unretained(service.get())));
     auto result =
         embedded_services_.insert(std::make_pair(name, std::move(service)));
@@ skipping 19 matching lines @@
     InitializeCallback handler =
         base::ResetAndReturn(&local_info_available_callback_);
     callback_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(handler, local_info_));
   }
 
   void OnBindInterface(const service_manager::ServiceInfo& source_info,
                        const std::string& interface_name,
                        mojo::ScopedMessagePipeHandle interface_pipe) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
-    if (source_info.identity.name() == service_manager::mojom::kServiceName &&
+
+    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)));
-    } else if (source_info.identity.name() == mojom::kBrowserServiceName &&
-               interface_name == mojom::Child::Name_) {
-      DCHECK(!child_binding_.is_bound());
-      child_binding_.Bind(
-          mojo::MakeRequest<mojom::Child>(std::move(interface_pipe)));
+      return;
+    }
 
-      InitializeCallback handler =
-          base::ResetAndReturn(&browser_info_available_callback_);
-      callback_task_runner_->PostTask(FROM_HERE,
-                                      base::Bind(handler, source_info));
-    } else {
+    {
       base::AutoLock lock(lock_);
       for (auto& entry : connection_filters_) {
         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") {
+      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));
+      }
+    }
   }
 
+  bool OnServiceManagerConnectionLost() override {
+    ClearConnectionFiltersOnIOThread();
+    callback_task_runner_->PostTask(FROM_HERE, stop_callback_);
+    return true;
+  }
+
   /////////////////////////////////////////////////////////////////////////////
-  // service_manager::mojom::ServiceFactory:
+  // 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));
   }
 
+  static void CallBinderOnTaskRunner(
+      scoped_refptr<base::SequencedTaskRunner> task_runner,
+      const service_manager::InterfaceRegistry::Binder& binder,
+      const std::string& interface_name,
+      mojo::ScopedMessagePipeHandle request_handle) {
+    task_runner->PostTask(FROM_HERE, base::Bind(binder, interface_name,
+                                                base::Passed(&request_handle)));
+  }
+
   base::ThreadChecker io_thread_checker_;
   bool started_ = false;
 
   // Temporary state established on construction and consumed on the IO thread
   // once the connection is started.
   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 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_;
 
+  // Default binder callback used for the browser connection's
+  // InterfaceRegistry.
+  //
+  // TODO(rockot): Remove this once all interfaces exposed to the browser are
+  // exposed via a ConnectionFilter.
+  service_manager::InterfaceRegistry::Binder default_browser_binder_;
+
   std::unique_ptr<service_manager::ServiceContext> service_context_;
   mojo::BindingSet<service_manager::mojom::ServiceFactory> factory_bindings_;
   int next_filter_id_ = kInvalidConnectionFilterId;
 
   // Not owned.
   MessageLoopObserver* message_loop_observer_ = nullptr;
 
   // Guards |connection_filters_|.
   base::Lock lock_;
   std::map<int, std::unique_ptr<ConnectionFilter>> connection_filters_;
@@ skipping 94 matching lines @@
 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) {
+  // It's safe to bind |registry| as a raw pointer because the caller must
+  // guarantee that it outlives |this|, and |this| is bound as a weak ptr here.
+  context_->SetDefaultBinderForBrowserConnection(
+      base::Bind(&ServiceManagerConnectionImpl::GetInterface,
+                 weak_factory_.GetWeakPtr(), registry));
+
+  // TODO(beng): remove provider parameter.
+}
+
 int ServiceManagerConnectionImpl::AddConnectionFilter(
     std::unique_ptr<ConnectionFilter> filter) {
   return context_->AddConnectionFilter(std::move(filter));
 }
 
 void ServiceManagerConnectionImpl::RemoveConnectionFilter(int filter_id) {
   context_->RemoveConnectionFilter(filter_id);
 }
 
 void ServiceManagerConnectionImpl::AddEmbeddedService(const std::string& name,
@@ skipping 38 matching lines @@
 }
 
 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