[Service Manager] Get rid of dynamic service discovery

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 304 matching lines @@
       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), nullptr, weak_factory_.GetWeakPtr());
+    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), nullptr, weak_factory_.GetWeakPtr());
+    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), nullptr, weak_factory_.GetWeakPtr());
+    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 299 matching lines @@
     std::unique_ptr<ServiceOverrides> overrides) {
   service_overrides_ = std::move(overrides);
 }
 
 void ServiceManager::SetInstanceQuitCallback(
     base::Callback<void(const Identity&)> callback) {
   instance_quit_callback_ = callback;
 }
 
 void ServiceManager::Connect(std::unique_ptr<ConnectParams> params) {
-  Connect(std::move(params), nullptr, nullptr);
+  Connect(std::move(params), nullptr);
 }
 
-mojom::ServiceRequest ServiceManager::StartEmbedderService(
-    const std::string& name) {
-  std::unique_ptr<ConnectParams> params(new ConnectParams);
+void ServiceManager::RegisterService(
+    const Identity& identity,
+    mojom::ServicePtr service,
+    mojom::PIDReceiverRequest pid_receiver_request) {
+  auto params = base::MakeUnique<ConnectParams>();
 
-  Identity embedder_identity(name, mojom::kRootUserID);
-  params->set_source(embedder_identity);
-  params->set_target(embedder_identity);
+  if (!pid_receiver_request.is_pending()) {
+    mojom::PIDReceiverPtr pid_receiver;
+    pid_receiver_request = mojom::PIDReceiverRequest(&pid_receiver);
+    pid_receiver->SetPID(base::Process::Current().Pid());
+  }
 
-  mojom::ServicePtr service;
-  mojom::ServiceRequest request(&service);
-  Connect(std::move(params), std::move(service), nullptr);
-
-  return request;
+  params->set_source(identity);
+  params->set_target(identity);
+  params->set_client_process_info(
+      std::move(service), std::move(pid_receiver_request));
+  Connect(std::move(params), nullptr);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceManager, private:
 
 void ServiceManager::InitCatalog(mojom::ServicePtr catalog) {
   // TODO(beng): It'd be great to build this from the manifest, however there's
   //             a bit of a chicken-and-egg problem.
   InterfaceProviderSpec spec;
   spec.provides["app"].insert("filesystem::mojom::Directory");
@@ skipping 44 matching lines @@
 
 void ServiceManager::OnInstanceStopped(const Identity& identity) {
   listeners_.ForAllPtrs([identity](mojom::ServiceManagerListener* listener) {
     listener->OnServiceStopped(identity);
   });
   if (!instance_quit_callback_.is_null())
     instance_quit_callback_.Run(identity);
 }
 
 void ServiceManager::Connect(std::unique_ptr<ConnectParams> params,
-                             mojom::ServicePtr service,
                              base::WeakPtr<Instance> source_instance) {
   TRACE_EVENT_INSTANT1("service_manager", "ServiceManager::Connect",
                        TRACE_EVENT_SCOPE_THREAD, "original_name",
                        params->target().name());
   DCHECK(!params->target().name().empty());
   DCHECK(base::IsValidGUID(params->target().user_id()));
   DCHECK_NE(mojom::kInheritUserID, params->target().user_id());
-  DCHECK(!service.is_bound() || !identity_to_instance_.count(params->target()));
+  DCHECK(!params->HasClientProcessInfo() ||
+         !identity_to_instance_.count(params->target()));
 
   // Connect to an existing matching instance, if possible.
-  if (!service.is_bound() && ConnectToExistingInstance(&params))
+  if (!params->HasClientProcessInfo() && ConnectToExistingInstance(&params))
     return;
 
   // The catalog needs to see the source identity as that of the originating
   // app so it loads the correct store. Since the catalog is itself run as root
   // when this re-enters Connect() it'll be handled by
   // ConnectToExistingInstance().
   mojom::Resolver* resolver = GetResolver(Identity(
       service_manager::mojom::kServiceName, params->target().user_id()));
 
   std::string name = params->target().name();
   resolver->ResolveServiceName(
       name,
       base::Bind(&service_manager::ServiceManager::OnGotResolvedName,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&params),
-                 base::Passed(&service), !!source_instance, source_instance));
+                 !!source_instance, source_instance));
 }
 
 ServiceManager::Instance* ServiceManager::GetExistingInstance(
     const Identity& identity) const {
   const auto& it = identity_to_instance_.find(identity);
   Instance* instance = it != identity_to_instance_.end() ? it->second : nullptr;
   if (instance)
     return instance;
 
   if (singletons_.find(identity.name()) != singletons_.end()) {
@@ skipping 120 matching lines @@
 }
 
 void ServiceManager::OnServiceFactoryLost(const Identity& which) {
   // Remove the mapping.
   auto it = service_factories_.find(which);
   DCHECK(it != service_factories_.end());
   service_factories_.erase(it);
 }
 
 void ServiceManager::OnGotResolvedName(std::unique_ptr<ConnectParams> params,
-                                       mojom::ServicePtr service,
                                        bool has_source_instance,
                                        base::WeakPtr<Instance> source_instance,
                                        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.
@@ skipping 39 matching lines @@
     source_identity_for_creation = CreateServiceManagerIdentity();
   } else {
     source_identity_for_creation = params->source();
   }
 
   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 (params->HasClientProcessInfo()) {
-    // This branch should be reachable only via a call to RegisterService(). We
+  if (params->HasClientProcessInfo()) {
+    // 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->BindPIDReceiver(params->TakePIDReceiverRequest());
     instance->StartWithService(params->TakeService());
     return;
   } else {
     // Otherwise we create a new Service pipe.
+    mojom::ServicePtr service;
     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 << "\".";
@@ skipping 48 matching lines @@
     bool connected = instance->CallOnConnect(&params);
     DCHECK(connected);
   }
 }
 
 base::WeakPtr<ServiceManager> ServiceManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace service_manager