Add RegisterService, split out of Connect().

services/service_manager/service_manager.cc

 // Copyright 2014 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 "services/service_manager/service_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 216 matching lines @@
 
     // The service was started but the service manager hasn't received the
     // initial response from it yet.
     STARTING,
 
     // The service was started successfully.
     STARTED
   };
 
   // mojom::Connector implementation:
+  void RegisterService(
+      const Identity& target,
+      mojom::ClientProcessConnectionPtr client_process_connection) override {
+    Connect(
+        target,
+        mojom::InterfaceProviderRequest(),
+        std::move(client_process_connection),
+        base::Bind(
+            &service_manager::ServiceManager::Instance::EmptyConnectCallback,
+            weak_factory_.GetWeakPtr()));
+  }
+
   void Connect(const service_manager::Identity& in_target,
                mojom::InterfaceProviderRequest remote_interfaces,
                mojom::ClientProcessConnectionPtr client_process_connection,
                const ConnectCallback& callback) override {
     Identity target = in_target;
     if (target.user_id() == mojom::kInheritUserID)
       target.set_user_id(identity_.user_id());
 
     if (!ValidateIdentity(target, callback))
       return;
@@ skipping 178 matching lines @@
     service_manager_->NotifyServiceStarted(identity_, pid_);
   }
 
   // mojom::ServiceControl:
   void RequestQuit() override {
     // If quit is requested, oblige when there are no pending OnConnects.
     if (!pending_service_connections_)
       OnServiceLost(service_manager_->GetWeakPtr());
   }
 
+  void EmptyConnectCallback(mojom::ConnectResult result,
+                            const std::string& user_id) {}
+
   service_manager::ServiceManager* const service_manager_;
 
   // An id that identifies this instance. Distinct from pid, as a single process
   // may vend multiple application instances, and this object may exist before a
   // process is launched.
   const uint32_t id_;
   Identity identity_;
   const InterfaceProviderSpecMap interface_provider_specs_;
   const InterfaceProviderSpec empty_spec_;
   const bool allow_any_application_;
@@ skipping 432 matching lines @@
   Instance* instance = CreateInstance(source_identity_for_creation,
                                       target, result->interface_provider_specs);
 
   // Below are various paths through which a new Instance can be bound to a
   // Service proxy.
   if (service.is_bound()) {
     // If a ServicePtr was provided, there's no more work to do: someone
     // is already holding a corresponding ServiceRequest.
     instance->StartWithService(std::move(service));
   } else if (!client_process_connection.is_null()) {
-    // Likewise if a ClientProcessConnection was given via Connect(), it
-    // provides the Service proxy to use.
+    // This branch should be reachable only via a call to RegisterService(). We
+    // start the instance but return early before we connect to it. Clients will
+    // call Connect() with the target identity subsequently.
     instance->StartWithClientProcessConnection(
         std::move(client_process_connection));
+    return;
   } else {
     // Otherwise we create a new Service pipe.
     mojom::ServiceRequest request(&service);
     CHECK(!result->package_path.empty());
 
     // The catalog was unable to read a manifest for this service. We can't do
     // anything more.
     // TODO(beng): There may be some cases where it's valid to have an empty
     // spec, so we should probably include a return value in |result|.
     if (result->interface_provider_specs.empty()) {
@@ skipping 50 matching lines @@
   // Now that the instance has a Service, we can connect to it.
   bool connected = instance->ConnectToService(&params);
   DCHECK(connected);
 }
 
 base::WeakPtr<ServiceManager> ServiceManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace service_manager