Makes ServiceManagerConnectionImpl queue requests

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 121 matching lines @@
                                 const ServiceRequestHandler& handler) {
     io_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ServiceManagerConnectionImpl::IOThreadContext::
                                   AddServiceRequestHandlerOnIoThread,
                               this, name, handler));
   }
 
  private:
   friend class base::RefCountedThreadSafe<IOThreadContext>;
 
+  struct PendingRequest {
+    std::string service_name;
+    service_manager::mojom::ServiceRequest request;
+  };
+
   class MessageLoopObserver : public base::MessageLoop::DestructionObserver {
    public:
     explicit MessageLoopObserver(base::WeakPtr<IOThreadContext> context)
         : context_(context) {
       base::MessageLoop::current()->AddDestructionObserver(this);
     }
 
     ~MessageLoopObserver() override {
       base::MessageLoop::current()->RemoveDestructionObserver(this);
     }
@@ skipping 97 matching lines @@
         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);
+    auto iter = pending_requests_.begin();
+    while (iter != pending_requests_.end()) {
+      if ((*iter)->service_name == name) {
+        std::unique_ptr<PendingRequest> pending_request = std::move(*iter);
+        iter = pending_requests_.erase(iter);
+        handler.Run(std::move(pending_request->request));
+      } else {
+        ++iter;
+      }
+    }
   }
 
   /////////////////////////////////////////////////////////////////////////////
   // service_manager::Service implementation
 
   void OnStart() override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     DCHECK(!local_info_available_callback_.is_null());
     local_info_ = context()->local_info();
 
@@ skipping 53 matching lines @@
     return true;
   }
 
   /////////////////////////////////////////////////////////////////////////////
   // 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.";
+    if (it == request_handlers_.end()) {
+      std::unique_ptr<PendingRequest> pending_request =
+          base::MakeUnique<PendingRequest>();
+      pending_request->service_name = name;
+      pending_request->request = std::move(request);
+      pending_requests_.push_back(std::move(pending_request));
+      return;
+    }
     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 41 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_;
 
+  // Requests before the service have been registered are added here. Typically
+  // there are very few elements, so we use a vector.
+  std::vector<std::unique_ptr<PendingRequest>> pending_requests_;
+
   mojo::Binding<mojom::Child> child_binding_;
 
   base::WeakPtrFactory<IOThreadContext> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(IOThreadContext);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceManagerConnection, public:
 
@@ skipping 149 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