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

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 33 matching lines @@
 const char kCapability_InstanceName[] = "service_manager:instance_name";
 const char kCapability_AllUsers[] = "service_manager:all_users";
 const char kCapability_InstancePerChild[] =
     "service_manager:instance_per_child";
 const char kCapability_ServiceManager[] = "service_manager:service_manager";
 
 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() {
   return Identity(service_manager::mojom::kServiceName, mojom::kRootUserID);
 }
 
 Identity CreateCatalogIdentity() {
   return Identity(catalog::mojom::kServiceName, mojom::kRootUserID);
 }
 
@@ skipping 57 matching lines @@
     } else {
       // Notify the ServiceManager that this Instance is really going away.
       service_manager_->OnInstanceStopped(identity_);
     }
   }
 
   ~Instance() override {
     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;
     }
 
     std::unique_ptr<ConnectParams> params(std::move(*in_params));
     InterfaceProviderSpecMap source_specs;
     InterfaceProviderSpec source_connection_spec;
     Instance* source =
         service_manager_->GetExistingInstance(params->source());
     if (source) {
       source_specs = source->interface_provider_specs_;
       source_connection_spec = source->GetConnectionSpec();
     }
 
     InterfaceSet exposed = GetInterfacesToExpose(source_connection_spec,
                                                  identity_,
                                                  GetConnectionSpec());
     bool allowed = (exposed.size() == 1 && exposed.count("*") == 1) ||
         exposed.count(params->interface_name()) > 0;
     if (!allowed) {
       std::stringstream ss;
       ss << "Connection InterfaceProviderSpec prevented service: "
          << 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(
         ServiceInfo(params->source(), source_specs),
         params->interface_name(),
         params->TakeInterfaceRequestPipe(),
         base::Bind(&Instance::OnConnectComplete, base::Unretained(this)));
     return true;
   }
 
@@ skipping 72 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 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;
+   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);
+     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());
+   }
 
-    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 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;
+     }
 
-  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_start_service_callback(callback);
+     service_manager_->Connect(std::move(params), weak_factory_.GetWeakPtr());
+   }
 
-    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 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;
+     }
 
-  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);
 
-    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());
+     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 {
     connectors_.AddBinding(this, std::move(request));
   }
 
   // mojom::PIDReceiver:
   void SetPID(uint32_t pid) override {
     PIDAvailable(pid);
   }
@@ skipping 147 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) {}
-  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
   // 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_;
   std::unique_ptr<ServiceProcessLauncher> runner_;
   mojom::ServicePtr service_;
   mojo::Binding<mojom::PIDReceiver> pid_receiver_binding_;
   mojo::BindingSet<mojom::Connector> connectors_;
   mojo::BindingSet<mojom::ServiceManager> service_manager_bindings_;
   mojo::AssociatedBinding<mojom::ServiceControl> control_binding_;
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(Instance);
 };
 
 class ServiceManager::ServiceImpl : public Service {
  public:
   explicit ServiceImpl(ServiceManager* service_manager)
@@ skipping 271 matching lines @@
 void ServiceManager::NotifyServiceFailedToStart(const Identity& identity) {
   listeners_.ForAllPtrs(
       [identity](mojom::ServiceManagerListener* listener) {
         listener->OnServiceFailedToStart(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(
     const Identity& source,
     const Identity& target,
     const InterfaceProviderSpecMap& specs) {
   CHECK(target.user_id() != mojom::kInheritUserID);
 
   auto instance = base::MakeUnique<Instance>(this, target, specs);
   Instance* raw_instance = instance.get();
@@ skipping 64 matching lines @@
                                        mojom::ResolveResultPtr result,
                                        mojom::ResolveResultPtr parent) {
   // If this request was originated by a specific Instance and that Instance is
   // no longer around, we ignore this response.
   if (has_source_instance && !source_instance)
     return;
 
   // 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;
   }
 
   std::string instance_name = params->target().instance();
 
   // |result->interface_provider_specs| can be empty when there is no manifest.
   InterfaceProviderSpec connection_spec = GetPermissiveInterfaceProviderSpec();
   auto it = result->interface_provider_specs.find(
       mojom::kServiceManager_ConnectorSpec);
   if (it != result->interface_provider_specs.end())
@@ skipping 46 matching lines @@
     mojom::ServiceRequest request(&service);
 
     // 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()) {
       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;
     }
 
     if (parent) {
       // This service is provided by another service via a ServiceFactory.
       std::string target_user_id = target.user_id();
       std::string factory_instance_name = instance_name;
 
       auto spec_iter = parent->interface_provider_specs.find(
           mojom::kServiceManager_ConnectorSpec);
@@ skipping 17 matching lines @@
     } else {
       base::FilePath package_path;
       if (!service_overrides_ || !service_overrides_->GetExecutablePathOverride(
             target.name(), &package_path)) {
         package_path = result->package_path;
       }
       DCHECK(!package_path.empty());
 
       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() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace service_manager