Have ActiveProfilePrefService Use the Original Profile

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);
-    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;
-    }
+    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 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