Add name to services

mojo/service_manager/service_manager.cc

 // Copyright 2013 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 <stdio.h>
 
 #include "mojo/service_manager/service_manager.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 11 matching lines @@
 class ServiceManager::ServiceFactory : public InterfaceImpl<ServiceProvider> {
  public:
   ServiceFactory(ServiceManager* manager, const GURL& url)
       : manager_(manager),
         url_(url) {
   }
 
   virtual ~ServiceFactory() {
   }
 
-  void ConnectToClient(ScopedMessagePipeHandle handle) {
+  void ConnectToClient(const std::string& name,
+                       ScopedMessagePipeHandle handle) {
     if (handle.is_valid())
-      client()->ConnectToService(url_.spec(), handle.Pass());
+      client()->ConnectToService(url_.spec(), name, handle.Pass());
   }
 
   // ServiceProvider implementation:
   virtual void ConnectToService(const String& url,
+                                const String& name,
                                 ScopedMessagePipeHandle client_pipe) OVERRIDE {
-    manager_->ConnectToService(GURL(url), client_pipe.Pass());
+    manager_->ConnectToService(GURL(url), name, client_pipe.Pass());
   }
 
   const GURL& url() const { return url_; }
 
  private:
   virtual void OnConnectionError() OVERRIDE {
     manager_->OnServiceFactoryError(this);
   }
 
   ServiceManager* const manager_;
   const GURL url_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceFactory);
 };
 
 class ServiceManager::TestAPI::TestServiceProviderConnection
     : public InterfaceImpl<ServiceProvider> {
  public:
   explicit TestServiceProviderConnection(ServiceManager* manager)
       : manager_(manager) {}
   virtual ~TestServiceProviderConnection() {}
 
   virtual void OnConnectionError() OVERRIDE {
     // TODO(darin): How should we handle this error?
   }
 
   // ServiceProvider:
   virtual void ConnectToService(const String& url,
+                                const String& name,
                                 ScopedMessagePipeHandle client_pipe) OVERRIDE {
-    manager_->ConnectToService(GURL(url), client_pipe.Pass());
+    manager_->ConnectToService(GURL(url), name, client_pipe.Pass());
   }
 
  private:
   ServiceManager* manager_;
 
   DISALLOW_COPY_AND_ASSIGN(TestServiceProviderConnection);
 };
 
 // static
 ServiceManager::TestAPI::TestAPI(ServiceManager* manager) : manager_(manager) {
@@ skipping 31 matching lines @@
 
 // static
 ServiceManager* ServiceManager::GetInstance() {
   static base::LazyInstance<ServiceManager> instance =
       LAZY_INSTANCE_INITIALIZER;
   has_created_instance = true;
   return &instance.Get();
 }
 
 void ServiceManager::ConnectToService(const GURL& url,
+                                      const std::string& name,
                                       ScopedMessagePipeHandle client_handle) {
   URLToServiceFactoryMap::const_iterator service_it =
       url_to_service_factory_.find(url);
   ServiceFactory* service_factory;
   if (service_it != url_to_service_factory_.end()) {
     service_factory = service_it->second;
   } else {
     MessagePipe pipe;
     GetLoaderForURL(url)->LoadService(this, url, pipe.handle0.Pass());
 
     service_factory =
         BindToPipe(new ServiceFactory(this, url), pipe.handle1.Pass());
 
     url_to_service_factory_[url] = service_factory;
   }
   if (interceptor_) {
     service_factory->ConnectToClient(
-        interceptor_->OnConnectToClient(url, client_handle.Pass()));
+        name, interceptor_->OnConnectToClient(url, client_handle.Pass()));
   } else {
-    service_factory->ConnectToClient(client_handle.Pass());
+    service_factory->ConnectToClient(name, client_handle.Pass());
   }
 }
 
 void ServiceManager::SetLoaderForURL(scoped_ptr<ServiceLoader> loader,
                                      const GURL& url) {
   URLToLoaderMap::iterator it = url_to_loader_.find(url);
   if (it != url_to_loader_.end())
     delete it->second;
   url_to_loader_[url] = loader.release();
 }
@@ skipping 26 matching lines @@
   // Called from ~ServiceFactory, so we do not need to call Destroy here.
   const GURL url = service_factory->url();
   URLToServiceFactoryMap::iterator it = url_to_service_factory_.find(url);
   DCHECK(it != url_to_service_factory_.end());
   delete it->second;
   url_to_service_factory_.erase(it);
   GetLoaderForURL(url)->OnServiceError(this, url);
 }
 
 }  // namespace mojo