Add a new BindInterface() method to Connector.

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 210 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 Start(
+  void StartService(
       const Identity& target,
       mojo::ScopedMessagePipeHandle service_handle,
       mojom::PIDReceiverRequest pid_receiver_request) override {
     mojom::ServicePtr service;
     service.Bind(mojom::ServicePtrInfo(std::move(service_handle), 0));
     ConnectImpl(
         target,
         mojom::InterfaceProviderRequest(),
         std::move(service),
         std::move(pid_receiver_request),
         base::Bind(
             &service_manager::ServiceManager::Instance::EmptyConnectCallback,
             weak_factory_.GetWeakPtr()));
   }
 
   void Connect(const service_manager::Identity& target,
                mojom::InterfaceProviderRequest remote_interfaces,
                const ConnectCallback& callback) override {
     ConnectImpl(target, std::move(remote_interfaces), mojom::ServicePtr(),
                 mojom::PIDReceiverRequest(), callback);
   }
 
+  void BindInterface(const service_manager::Identity& target,
+                     const std::string& interface_name,
+                     mojo::ScopedMessagePipeHandle interface_pipe,
+                     const BindInterfaceCallback& callback) override {
+    mojom::InterfaceProviderPtr remote_interfaces;
+    ConnectImpl(
+        target,
+        MakeRequest(&remote_interfaces),
+        mojom::ServicePtr(),
+        mojom::PIDReceiverRequest(),
+        base::Bind(
+            &service_manager::ServiceManager::Instance::BindCallbackWrapper,
+            weak_factory_.GetWeakPtr(),
+            callback));
+    remote_interfaces->GetInterface(interface_name, std::move(interface_pipe));
+    // TODO(beng): Rather than just forwarding thru to InterfaceProvider, do
+    //             manifest policy intersection here.
+  }
+
   void ConnectImpl(const service_manager::Identity& in_target,
                    mojom::InterfaceProviderRequest remote_interfaces,
                    mojom::ServicePtr service,
                    mojom::PIDReceiverRequest pid_receiver_request,
                    const ConnectCallback& callback) {
     Identity target = in_target;
     if (target.user_id() == mojom::kInheritUserID)
       target.set_user_id(identity_.user_id());
 
     if (!ValidateIdentity(target, callback))
@@ skipping 181 matching lines @@
 
   // 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_;
@@ skipping 164 matching lines @@
   singletons_.insert(catalog::mojom::kServiceName);
   instance->StartWithService(std::move(catalog));
 }
 
 mojom::Resolver* ServiceManager::GetResolver(const Identity& identity) {
   auto iter = identity_to_resolver_.find(identity);
   if (iter != identity_to_resolver_.end())
     return iter->second.get();
 
   mojom::ResolverPtr resolver_ptr;
-  ConnectToInterface(this, identity, CreateCatalogIdentity(), &resolver_ptr);
+  BindInterface(this, identity, CreateCatalogIdentity(), &resolver_ptr);
   mojom::Resolver* resolver = resolver_ptr.get();
   identity_to_resolver_[identity] = std::move(resolver_ptr);
   return resolver;
 }
 
 void ServiceManager::OnInstanceError(Instance* instance) {
   // We never clean up the ServiceManager's own instance.
   if (instance == service_manager_instance_)
     return;
 
@@ skipping 157 matching lines @@
 
 mojom::ServiceFactory* ServiceManager::GetServiceFactory(
     const Identity& service_factory_identity) {
   auto it = service_factories_.find(service_factory_identity);
   if (it != service_factories_.end())
     return it->second.get();
 
   Identity source_identity(service_manager::mojom::kServiceName,
                            mojom::kInheritUserID);
   mojom::ServiceFactoryPtr factory;
-  ConnectToInterface(this, source_identity, service_factory_identity,
-                     &factory);
+  BindInterface(this, source_identity, service_factory_identity, &factory);
   mojom::ServiceFactory* factory_interface = factory.get();
   factory.set_connection_error_handler(
       base::Bind(&service_manager::ServiceManager::OnServiceFactoryLost,
                  weak_ptr_factory_.GetWeakPtr(), service_factory_identity));
   service_factories_[service_factory_identity] = std::move(factory);
   return factory_interface;
 }
 
 void ServiceManager::OnServiceFactoryLost(const Identity& which) {
   // Remove the mapping.
@@ skipping 143 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