Change ServiceManagerConnectionImpl to run service request handlers on the IO thread.

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>
 
@@ skipping 31 matching lines @@
 // 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:
   using InitializeCallback =
       base::Callback<void(const service_manager::Identity&)>;
-  using ServiceFactoryCallback =
-      base::Callback<void(service_manager::mojom::ServiceRequest,
-                          const std::string&)>;
 
   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)),
         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 ServiceFactoryCallback& create_service_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;
-    create_service_callback_ = create_service_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 26 matching lines @@
 
   // 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(
+        FROM_HERE, base::Bind(&ServiceManagerConnectionImpl::IOThreadContext::
+                                  AddServiceRequestHandlerOnIoThread,
+                              this, name, handler));
+  }
+
  private:
   friend class base::RefCountedThreadSafe<IOThreadContext>;
 
   class MessageLoopObserver : public base::MessageLoop::DestructionObserver {
    public:
     explicit MessageLoopObserver(base::WeakPtr<IOThreadContext> context)
         : context_(context) {
       base::MessageLoop::current()->AddDestructionObserver(this);
     }
 
@@ skipping 57 matching lines @@
 
     // Resetting the ServiceContext below may otherwise release the last
     // reference to this IOThreadContext. We keep it alive until the stack
     // unwinds.
     scoped_refptr<IOThreadContext> keepalive(this);
 
     factory_bindings_.CloseAllBindings();
     service_context_.reset();
 
     ClearConnectionFiltersOnIOThread();
+
+    request_handlers_.clear();
+    embedded_services_.clear();
   }
 
   void ClearConnectionFiltersOnIOThread() {
     base::AutoLock lock(lock_);
     connection_filters_.clear();
   }
 
   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)));
+    DCHECK(result.second);
+  }
+
+  void AddServiceRequestHandlerOnIoThread(
+      const std::string& name,
+      const ServiceRequestHandler& handler) {
+    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());
     local_info_ = context()->local_info();
 
     InitializeCallback handler = base::ResetAndReturn(&initialize_handler_);
     callback_task_runner_->PostTask(FROM_HERE,
@@ skipping 51 matching lines @@
     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());
-    callback_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(create_service_callback_, base::Passed(&request), name));
+    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)));
   }
@@ skipping 11 matching lines @@
   // 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_;
 
-  // Callback to run when a new Service request is received.
-  ServiceFactoryCallback create_service_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_;
 
+  std::unordered_map<std::string, std::unique_ptr<EmbeddedServiceRunner>>
+      embedded_services_;
+  std::unordered_map<std::string, ServiceRequestHandler> request_handlers_;
+
   base::WeakPtrFactory<IOThreadContext> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(IOThreadContext);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceManagerConnection, public:
 
 // static
 void ServiceManagerConnection::SetForProcess(
@@ skipping 54 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceManagerConnectionImpl, ServiceManagerConnection implementation:
 
 void ServiceManagerConnectionImpl::Start() {
   context_->Start(
       base::Bind(&ServiceManagerConnectionImpl::OnContextInitialized,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&ServiceManagerConnectionImpl::OnConnect,
                  weak_factory_.GetWeakPtr()),
-      base::Bind(&ServiceManagerConnectionImpl::CreateService,
-                 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 {
@@ skipping 21 matching lines @@
     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,
                                                       const ServiceInfo& info) {
-  std::unique_ptr<EmbeddedServiceRunner> service(
-      new EmbeddedServiceRunner(name, info));
-  AddServiceRequestHandler(
-      name, base::Bind(&EmbeddedServiceRunner::BindServiceRequest,
-                       base::Unretained(service.get())));
-  auto result =
-      embedded_services_.insert(std::make_pair(name, std::move(service)));
-  DCHECK(result.second);
+  context_->AddEmbeddedService(name, info);
 }
 
 void ServiceManagerConnectionImpl::AddServiceRequestHandler(
     const std::string& name,
     const ServiceRequestHandler& handler) {
-  auto result = request_handlers_.insert(std::make_pair(name, handler));
-  DCHECK(result.second);
+  context_->AddServiceRequestHandler(name, handler);
 }
 
 int ServiceManagerConnectionImpl::AddOnConnectHandler(
     const OnConnectHandler& handler) {
   int id = ++next_on_connect_handler_id_;
   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::CreateService(
-    service_manager::mojom::ServiceRequest request,
-    const std::string& name) {
-  auto it = request_handlers_.find(name);
-  DCHECK(it != request_handlers_.end())
-      << "Can't create service " << name << ". No handler found.";
-  if (it != request_handlers_.end())
-    it->second.Run(std::move(request));
-}
-
 void ServiceManagerConnectionImpl::OnContextInitialized(
     const service_manager::Identity& identity) {
   identity_ = identity;
 }
 
 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