Eliminate OnConnect usage

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 89 matching lines @@
     return false;
   return it->second.find(capability) != it->second.end();
 }
 
 // Encapsulates a connection to an instance of a service, tracked by the
 // Service Manager.
 class ServiceManager::Instance
     : public mojom::Connector,
       public mojom::PIDReceiver,
       public Service,
-      public InterfaceFactory<mojom::ServiceManager>,
       public mojom::ServiceManager,
       public mojom::ServiceControl {
  public:
   Instance(service_manager::ServiceManager* service_manager,
            const Identity& identity,
            const InterfaceProviderSpecMap& interface_provider_specs)
       : service_manager_(service_manager),
         id_(GenerateUniqueID()),
         identity_(identity),
         interface_provider_specs_(interface_provider_specs),
@@ skipping 151 matching lines @@
   const InterfaceProviderSpec& GetConnectionSpec() const {
     auto it = interface_provider_specs_.find(
         mojom::kServiceManager_ConnectorSpec);
     return it != interface_provider_specs_.end() ? it->second : empty_spec_;
   }
   const Identity& identity() const { return identity_; }
   void set_identity(const Identity& identity) { identity_ = identity; }
   uint32_t id() const { return id_; }
 
   // Service:
-  bool OnConnect(const ServiceInfo& remote_info,
-                 InterfaceRegistry* registry) override {
+  void OnBindInterface(const ServiceInfo& source_info,
+                       const std::string& interface_name,
+                       mojo::ScopedMessagePipeHandle interface_pipe) override {
     Instance* source =
-        service_manager_->GetExistingInstance(remote_info.identity);
+        service_manager_->GetExistingInstance(source_info.identity);
     DCHECK(source);
-    if (HasCapability(source->GetConnectionSpec(),
+    if (interface_name == mojom::ServiceManager::Name_ &&
+        HasCapability(source->GetConnectionSpec(),
                       kCapability_ServiceManager)) {
-      registry->AddInterface<mojom::ServiceManager>(this);
-      return true;
+      mojom::ServiceManagerRequest request =
+          mojo::MakeRequest<mojom::ServiceManager>(std::move(interface_pipe));
+      service_manager_bindings_.AddBinding(this, std::move(request));
     }
-    return false;
   }
 
  private:
    enum class State {
     // The service was not started yet.
     IDLE,
 
     // The service was started but the service manager hasn't received the
     // initial response from it yet.
     STARTING,
@@ skipping 66 matching lines @@
 
   void Clone(mojom::ConnectorRequest request) override {
     connectors_.AddBinding(this, std::move(request));
   }
 
   // mojom::PIDReceiver:
   void SetPID(uint32_t pid) override {
     PIDAvailable(pid);
   }
 
-  // InterfaceFactory<mojom::ServiceManager>:
-  void Create(const Identity& remote_identity,
-              mojom::ServiceManagerRequest request) override {
-    service_manager_bindings_.AddBinding(this, std::move(request));
-  }
-
   // mojom::ServiceManager implementation:
   void AddListener(mojom::ServiceManagerListenerPtr listener) override {
     // TODO(beng): this should only track the instances matching this user, and
     // root.
     service_manager_->AddListener(std::move(listener));
   }
 
   mojom::ConnectResult ValidateConnectParams(
       Identity* target,
       mojom::ServicePtr* service,
@@ skipping 178 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Instance);
 };
 
 class ServiceManager::ServiceImpl : public Service {
  public:
   explicit ServiceImpl(ServiceManager* service_manager)
       : service_manager_(service_manager) {}
   ~ServiceImpl() override {}
 
   // Service:
-  bool OnConnect(const ServiceInfo& remote_info,
-                 InterfaceRegistry* registry) override {
+  void OnBindInterface(const ServiceInfo& source_info,
+                       const std::string& interface_name,
+                       mojo::ScopedMessagePipeHandle interface_pipe) override {
     // The only interface ServiceManager exposes is mojom::ServiceManager, and
     // access to this interface is brokered by a policy specific to each caller,
     // managed by the caller's instance. Here we look to see who's calling,
     // and forward to the caller's instance to continue.
     Instance* instance = nullptr;
     for (const auto& entry : service_manager_->identity_to_instance_) {
-      if (entry.first == remote_info.identity) {
+      if (entry.first == source_info.identity) {
         instance = entry.second;
         break;
       }
     }
 
     DCHECK(instance);
-    return instance->OnConnect(remote_info, registry);
+    instance->OnBindInterface(source_info, interface_name,
+                              std::move(interface_pipe));
   }
 
  private:
   ServiceManager* const service_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceImpl);
 };
 
 // static
 ServiceManager::TestAPI::TestAPI(ServiceManager* service_manager)
@@ skipping 456 matching lines @@
     bool connected = instance->CallOnConnect(&params);
     DCHECK(connected);
   }
 }
 
 base::WeakPtr<ServiceManager> ServiceManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace service_manager