Eliminate Connector::Connect(), Connection, etc.

services/service_manager/service_manager.cc

Index: services/service_manager/service_manager.cc
diff --git a/services/service_manager/service_manager.cc b/services/service_manager/service_manager.cc
index 2a0150437eb4d2e4575991f0e6dd78b22f2b58f0..d29b0c9ad960ddaa0ecf2844270e479d7cef74a5 100644
--- a/services/service_manager/service_manager.cc
+++ b/services/service_manager/service_manager.cc
@@ -51,30 +51,6 @@ bool Succeeded(mojom::ConnectResult result) {
   return result == mojom::ConnectResult::SUCCEEDED;
 }
 
-bool RunConnectCallback(ConnectParams* params,
-                        mojom::ConnectResult result,
-                        const std::string& user_id) {
-  if (!params->connect_callback().is_null()) {
-    params->connect_callback().Run(result, user_id);
-    return true;
-  }
-  return false;
-}
-
-void RunBindInterfaceCallback(ConnectParams* params,
-                              mojom::ConnectResult result,
-                              const std::string& user_id) {
-  if (!params->bind_interface_callback().is_null())
-    params->bind_interface_callback().Run(result, user_id);
-}
-
-void RunCallback(ConnectParams* params,
-                 mojom::ConnectResult result,
-                 const std::string& user_id) {
-  if (!RunConnectCallback(params, result, user_id))
-    RunBindInterfaceCallback(params, result, user_id);
-}
-
 }  // namespace
 
 Identity CreateServiceManagerIdentity() {
@@ -152,36 +128,10 @@ class ServiceManager::Instance
     Stop();
   }
 
-  bool CallOnConnect(std::unique_ptr<ConnectParams>* in_params) {
-    if (!service_.is_bound()) {
-      RunConnectCallback(in_params->get(), mojom::ConnectResult::ACCESS_DENIED,
-                         identity_.user_id());
-      return false;
-    }
-
-    std::unique_ptr<ConnectParams> params(std::move(*in_params));
-    RunConnectCallback(params.get(), mojom::ConnectResult::SUCCEEDED,
-                       identity_.user_id());
-
-    InterfaceProviderSpecMap specs;
-    Instance* source =
-        service_manager_->GetExistingInstance(params->source());
-    if (source)
-      specs = source->interface_provider_specs_;
-
-    pending_service_connections_++;
-    service_->OnConnect(ServiceInfo(params->source(), specs),
-                        params->TakeRemoteInterfaces(),
-                        base::Bind(&Instance::OnConnectComplete,
-                                   base::Unretained(this)));
-    return true;
-  }
-
   bool CallOnBindInterface(std::unique_ptr<ConnectParams>* in_params) {
     if (!service_.is_bound()) {
-      RunBindInterfaceCallback(in_params->get(),
-                               mojom::ConnectResult::ACCESS_DENIED,
-                               identity_.user_id());
+      (*in_params)
+          ->set_response_data(mojom::ConnectResult::ACCESS_DENIED, identity_);
       return false;
     }
 
@@ -206,15 +156,11 @@ class ServiceManager::Instance
          << params->source().name() << " from binding interface: "
          << params->interface_name() << " exposed by: " << identity_.name();
       LOG(ERROR) << ss.str();
-      params->bind_interface_callback().Run(mojom::ConnectResult::ACCESS_DENIED,
-                                            identity_.user_id());
+      params->set_response_data(mojom::ConnectResult::ACCESS_DENIED, identity_);
       return false;
     }
 
-    if (!params->bind_interface_callback().is_null()) {
-      params->bind_interface_callback().Run(mojom::ConnectResult::SUCCEEDED,
-                                            identity_.user_id());
-    }
+    params->set_response_data(mojom::ConnectResult::SUCCEEDED, identity_);
 
     pending_service_connections_++;
     service_->OnBindInterface(
@@ -307,65 +253,67 @@ class ServiceManager::Instance
   };
 
   // mojom::Connector implementation:
-  void StartService(
-      const Identity& in_target,
-      mojo::ScopedMessagePipeHandle service_handle,
-      mojom::PIDReceiverRequest pid_receiver_request) override {
-    Identity target = in_target;
-    mojom::ConnectResult result =
-        ValidateConnectParams(&target, nullptr, nullptr);
-    if (!Succeeded(result))
-      return;
-
-    std::unique_ptr<ConnectParams> params(new ConnectParams);
-    params->set_source(identity_);
-    params->set_target(target);
-
-    mojom::ServicePtr service;
-    service.Bind(mojom::ServicePtrInfo(std::move(service_handle), 0));
-    params->set_client_process_info(std::move(service),
-                                    std::move(pid_receiver_request));
-    service_manager_->Connect(std::move(params), weak_factory_.GetWeakPtr());
-  }
-
-  void Connect(const service_manager::Identity& in_target,
-               mojom::InterfaceProviderRequest remote_interfaces,
-               const ConnectCallback& callback) override {
-    Identity target = in_target;
-    mojom::ConnectResult result =
-        ValidateConnectParams(&target, nullptr, nullptr);
-    if (!Succeeded(result)) {
-      callback.Run(result, mojom::kInheritUserID);
-      return;
-    }
-
-    std::unique_ptr<ConnectParams> params(new ConnectParams);
-    params->set_source(identity_);
-    params->set_target(target);
-    params->set_remote_interfaces(std::move(remote_interfaces));
-    params->set_connect_callback(callback);
-    service_manager_->Connect(std::move(params), weak_factory_.GetWeakPtr());
-  }
-
-  void BindInterface(const service_manager::Identity& in_target,
-                     const std::string& interface_name,
-                     mojo::ScopedMessagePipeHandle interface_pipe,
-                     const BindInterfaceCallback& callback) override {
-    Identity target = in_target;
-    mojom::ConnectResult result =
-        ValidateConnectParams(&target, nullptr, nullptr);
-    if (!Succeeded(result)) {
-      callback.Run(result, mojom::kInheritUserID);
-      return;
-    }
-
-    std::unique_ptr<ConnectParams> params(new ConnectParams);
-    params->set_source(identity_);
-    params->set_target(target);
-    params->set_interface_request_info(interface_name,
-                                       std::move(interface_pipe));
-    params->set_bind_interface_callback(callback);
-    service_manager_->Connect(std::move(params), weak_factory_.GetWeakPtr());
+   void BindInterface(const service_manager::Identity& in_target,
+                      const std::string& interface_name,
+                      mojo::ScopedMessagePipeHandle interface_pipe,
+                      const BindInterfaceCallback& callback) override {
+     Identity target = in_target;
+     mojom::ConnectResult result =
+         ValidateConnectParams(&target, nullptr, nullptr);
+     if (!Succeeded(result)) {
+       callback.Run(result, Identity());
+       return;
+     }
+
+     std::unique_ptr<ConnectParams> params(new ConnectParams);
+     params->set_source(identity_);
+     params->set_target(target);
+     params->set_interface_request_info(interface_name,
+                                        std::move(interface_pipe));
+     params->set_start_service_callback(callback);
+     service_manager_->Connect(std::move(params), weak_factory_.GetWeakPtr());
+   }
+
+   void StartService(const Identity& in_target,
+                     const StartServiceCallback& callback) override {
+     Identity target = in_target;
+     mojom::ConnectResult result =
+         ValidateConnectParams(&target, nullptr, nullptr);
+     if (!Succeeded(result)) {
+       callback.Run(result, Identity());
+       return;
+     }
+
+     std::unique_ptr<ConnectParams> params(new ConnectParams);
+     params->set_source(identity_);
+     params->set_target(target);
+     params->set_start_service_callback(callback);
+     service_manager_->Connect(std::move(params), weak_factory_.GetWeakPtr());
+   }
+
+   void StartServiceWithProcess(
+       const Identity& in_target,
+       mojo::ScopedMessagePipeHandle service_handle,
+       mojom::PIDReceiverRequest pid_receiver_request,
+       const StartServiceWithProcessCallback& callback) override {
+     Identity target = in_target;
+     mojom::ConnectResult result =
+         ValidateConnectParams(&target, nullptr, nullptr);
+     if (!Succeeded(result)) {
+       callback.Run(result, Identity());
+       return;
+     }
+
+     std::unique_ptr<ConnectParams> params(new ConnectParams);
+     params->set_source(identity_);
+     params->set_target(target);
+
+     mojom::ServicePtr service;
+     service.Bind(mojom::ServicePtrInfo(std::move(service_handle), 0));
+     params->set_client_process_info(std::move(service),
+                                     std::move(pid_receiver_request));
+     params->set_start_service_callback(callback);
+     service_manager_->Connect(std::move(params), weak_factory_.GetWeakPtr());
   }
 
   void Clone(mojom::ConnectorRequest request) override {
@@ -533,14 +481,6 @@ class ServiceManager::Instance
       OnServiceLost(service_manager_->GetWeakPtr());
   }
 
-  void EmptyConnectCallback(mojom::ConnectResult result,
-                            const std::string& user_id) {}
-  void BindCallbackWrapper(const BindInterfaceCallback& wrapped,
-                           mojom::ConnectResult result,
-                           const std::string& user_id) {
-    wrapped.Run(result, user_id);
-  }
-
   service_manager::ServiceManager* const service_manager_;
 
   // An id that identifies this instance. Distinct from pid, as a single process
@@ -560,7 +500,7 @@ class ServiceManager::Instance
   base::ProcessId pid_ = base::kNullProcessId;
   State state_;
 
-  // The number of outstanding OnConnect requests which are in flight.
+  // The number of outstanding OnBindInterface requests which are in flight.
   int pending_service_connections_ = 0;
 
   base::WeakPtrFactory<Instance> weak_factory_;
@@ -852,14 +792,12 @@ void ServiceManager::NotifyServiceFailedToStart(const Identity& identity) {
 bool ServiceManager::ConnectToExistingInstance(
     std::unique_ptr<ConnectParams>* params) {
   Instance* instance = GetExistingInstance((*params)->target());
-  if (instance) {
-    if ((*params)->HasInterfaceRequestInfo()) {
-      instance->CallOnBindInterface(params);
-      return true;
-    }
-    return instance->CallOnConnect(params);
-  }
-  return false;
+  if (!instance)
+    return false;
+
+  if ((*params)->HasInterfaceRequestInfo())
+    instance->CallOnBindInterface(params);
+  return true;
 }
 
 ServiceManager::Instance* ServiceManager::CreateInstance(
@@ -944,7 +882,8 @@ void ServiceManager::OnGotResolvedName(std::unique_ptr<ConnectParams> params,
   // If name resolution failed, we drop the connection.
   if (!result) {
     LOG(ERROR) << "Failed to resolve service name: " << params->target().name();
-    RunCallback(params.get(), mojom::ConnectResult::INVALID_ARGUMENT, "");
+    params->set_response_data(mojom::ConnectResult::INVALID_ARGUMENT,
+                              Identity());
     return;
   }
 
@@ -1011,7 +950,8 @@ void ServiceManager::OnGotResolvedName(std::unique_ptr<ConnectParams> params,
       LOG(ERROR)
           << "Error: The catalog was unable to read a manifest for service \""
           << result->name << "\".";
-      RunCallback(params.get(), mojom::ConnectResult::ACCESS_DENIED, "");
+      params->set_response_data(mojom::ConnectResult::ACCESS_DENIED,
+                                Identity());
       return;
     }
 
@@ -1049,19 +989,17 @@ void ServiceManager::OnGotResolvedName(std::unique_ptr<ConnectParams> params,
 
       if (!instance->StartWithFilePath(package_path)) {
         OnInstanceError(instance);
-        RunCallback(params.get(), mojom::ConnectResult::INVALID_ARGUMENT, "");
+        params->set_response_data(mojom::ConnectResult::INVALID_ARGUMENT,
+                                  Identity());
         return;
       }
     }
   }
 
-  // Now that the instance has a Service, we can connect to it.
-  if (params->HasInterfaceRequestInfo()) {
+  params->set_response_data(mojom::ConnectResult::SUCCEEDED,
+                            instance->identity());
+  if (params->HasInterfaceRequestInfo())
     instance->CallOnBindInterface(&params);
-  } else {
-    bool connected = instance->CallOnConnect(&params);
-    DCHECK(connected);
-  }
 }
 
 base::WeakPtr<ServiceManager> ServiceManager::GetWeakPtr() {