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

content/common/service_manager/service_manager_connection_impl.cc

Index: content/common/service_manager/service_manager_connection_impl.cc
diff --git a/content/common/service_manager/service_manager_connection_impl.cc b/content/common/service_manager/service_manager_connection_impl.cc
index 212ec813940655443904302f87647e01d9e0680e..5549c63b8a726986bbd7161e11b17666f3e5b31b 100644
--- a/content/common/service_manager/service_manager_connection_impl.cc
+++ b/content/common/service_manager/service_manager_connection_impl.cc
@@ -49,9 +49,6 @@ class ServiceManagerConnectionImpl::IOThreadContext
  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,
@@ -71,7 +68,6 @@ class ServiceManagerConnectionImpl::IOThreadContext
   void Start(
       const InitializeCallback& initialize_callback,
       const ServiceManagerConnection::OnConnectHandler& on_connect_callback,
-      const ServiceFactoryCallback& create_service_callback,
       const base::Closure& stop_callback) {
     DCHECK(!started_);
 
@@ -79,7 +75,6 @@ class ServiceManagerConnectionImpl::IOThreadContext
     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));
@@ -126,6 +121,21 @@ class ServiceManagerConnectionImpl::IOThreadContext
         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>;
 
@@ -203,6 +213,9 @@ class ServiceManagerConnectionImpl::IOThreadContext
     service_context_.reset();
 
     ClearConnectionFiltersOnIOThread();
+
+    request_handlers_.clear();
+    embedded_services_.clear();
   }
 
   void ClearConnectionFiltersOnIOThread() {
@@ -224,6 +237,27 @@ class ServiceManagerConnectionImpl::IOThreadContext
     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
 
@@ -295,9 +329,10 @@ class ServiceManagerConnectionImpl::IOThreadContext
   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(
@@ -329,9 +364,6 @@ class ServiceManagerConnectionImpl::IOThreadContext
   // 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_;
 
@@ -359,6 +391,10 @@ class ServiceManagerConnectionImpl::IOThreadContext
   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);
@@ -433,8 +469,6 @@ void ServiceManagerConnectionImpl::Start() {
                  weak_factory_.GetWeakPtr()),
       base::Bind(&ServiceManagerConnectionImpl::OnConnect,
                  weak_factory_.GetWeakPtr()),
-      base::Bind(&ServiceManagerConnectionImpl::CreateService,
-                 weak_factory_.GetWeakPtr()),
       base::Bind(&ServiceManagerConnectionImpl::OnConnectionLost,
                  weak_factory_.GetWeakPtr()));
 }
@@ -476,21 +510,13 @@ void ServiceManagerConnectionImpl::RemoveConnectionFilter(int 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(
@@ -506,16 +532,6 @@ void ServiceManagerConnectionImpl::RemoveOnConnectHandler(int id) {
   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;