Pass ServiceProvider and ServiceProvider& params in Connect

mojo/application_manager/application_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 "mojo/application_manager/application_manager.h"
 
 #include <stdio.h>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 34 matching lines @@
 
 GURL ApplicationManager::Delegate::ResolveURL(const GURL& url) {
   return url;
 }
 
 class ApplicationManager::ContentHandlerConnection : public ErrorHandler {
  public:
   ContentHandlerConnection(ApplicationManager* manager,
                            const GURL& content_handler_url)
       : manager_(manager), content_handler_url_(content_handler_url) {
-    ServiceProviderPtr service_provider;
-    StubServiceProvider* service_provider_impl =
-        BindToProxy(new StubServiceProvider, &service_provider);
-    manager->ConnectToApplication(
-        content_handler_url, GURL(), service_provider.Pass());
-    mojo::ConnectToService(service_provider_impl->client(), &content_handler_);
+    ServiceProviderPtr services;
+    manager->ConnectToApplication(content_handler_url, GURL(),
+                                  GetProxy(&services), nullptr);
+    mojo::ConnectToService(services.get(), &content_handler_);
     content_handler_.set_error_handler(this);
   }
 
   ContentHandler* content_handler() { return content_handler_.get(); }
 
   GURL content_handler_url() { return content_handler_url_; }
 
  private:
   // ErrorHandler implementation:
   void OnConnectionError() override { manager_->OnContentHandlerError(this); }
@@ skipping 34 matching lines @@
   STLDeleteValues(&scheme_to_loader_);
 }
 
 void ApplicationManager::TerminateShellConnections() {
   STLDeleteValues(&url_to_shell_impl_);
 }
 
 void ApplicationManager::ConnectToApplication(
     const GURL& requested_url,
     const GURL& requestor_url,
-    ServiceProviderPtr service_provider) {
+    InterfaceRequest<ServiceProvider> services,
+    ServiceProviderPtr exposed_services) {
   DCHECK(requested_url.is_valid());
   ApplicationLoader* loader = GetLoaderForURL(requested_url,
                                               DONT_INCLUDE_DEFAULT_LOADER);
   if (loader) {
     ConnectToApplicationImpl(requested_url, requested_url, requestor_url,
-                             service_provider.Pass(), loader);
+                             services.Pass(), exposed_services.Pass(), loader);
     return;
   }
 
   GURL resolved_url = delegate_->ResolveURL(requested_url);
   loader = GetLoaderForURL(resolved_url, INCLUDE_DEFAULT_LOADER);
   if (loader) {
     ConnectToApplicationImpl(requested_url, resolved_url, requestor_url,
-                             service_provider.Pass(), loader);
+                             services.Pass(), exposed_services.Pass(), loader);
     return;
   }
 
   LOG(WARNING) << "Could not find loader to load application: "
                << requested_url.spec();
 }
 
 void ApplicationManager::ConnectToApplicationImpl(
     const GURL& requested_url,
     const GURL& resolved_url,
     const GURL& requestor_url,
-    ServiceProviderPtr service_provider,
+    InterfaceRequest<ServiceProvider> services,
+    ServiceProviderPtr exposed_services,
     ApplicationLoader* loader) {
   ShellImpl* shell = nullptr;
   URLToShellImplMap::const_iterator shell_it =
       url_to_shell_impl_.find(resolved_url);
   if (shell_it != url_to_shell_impl_.end()) {
     shell = shell_it->second;
   } else {
     MessagePipe pipe;
     shell =
         new ShellImpl(pipe.handle0.Pass(), this, requested_url, resolved_url);
     url_to_shell_impl_[resolved_url] = shell;
     shell->client()->Initialize(GetArgsForURL(requested_url));
 
     loader->Load(this, resolved_url, pipe.handle1.Pass(),
                  base::Bind(&ApplicationManager::LoadWithContentHandler,
                             weak_ptr_factory_.GetWeakPtr()));
   }
-  ConnectToClient(shell, resolved_url, requestor_url, service_provider.Pass());
+  ConnectToClient(shell, resolved_url, requestor_url, services.Pass(),
+                  exposed_services.Pass());
 }
 
-void ApplicationManager::ConnectToClient(ShellImpl* shell_impl,
-                                         const GURL& url,
-                                         const GURL& requestor_url,
-                                         ServiceProviderPtr service_provider) {
-  shell_impl->ConnectToClient(requestor_url, service_provider.Pass());
+void ApplicationManager::ConnectToClient(
+    ShellImpl* shell_impl,
+    const GURL& url,
+    const GURL& requestor_url,
+    InterfaceRequest<ServiceProvider> services,
+    ServiceProviderPtr exposed_services) {
+  shell_impl->ConnectToClient(requestor_url, services.Pass(),
+                              exposed_services.Pass());
 }
 
 void ApplicationManager::RegisterExternalApplication(
     const GURL& url,
     ScopedMessagePipeHandle shell_handle) {
   ShellImpl* shell_impl = new ShellImpl(shell_handle.Pass(), this, url, url);
   url_to_shell_impl_[url] = shell_impl;
   shell_impl->client()->Initialize(GetArgsForURL(url));
 }
 
@@ skipping 72 matching lines @@
   auto it =
       url_to_content_handler_.find(content_handler->content_handler_url());
   DCHECK(it != url_to_content_handler_.end());
   delete it->second;
   url_to_content_handler_.erase(it);
 }
 
 ScopedMessagePipeHandle ApplicationManager::ConnectToServiceByName(
     const GURL& application_url,
     const std::string& interface_name) {
-  StubServiceProvider* stub_sp = new StubServiceProvider;
-  ServiceProviderPtr spp;
-  BindToProxy(stub_sp, &spp);
-  ConnectToApplication(application_url, GURL(), spp.Pass());
+  ServiceProviderPtr services;
+  ConnectToApplication(application_url, GURL(), GetProxy(&services), nullptr);
   MessagePipe pipe;
-  stub_sp->GetRemoteServiceProvider()->ConnectToService(interface_name,
-                                                        pipe.handle1.Pass());
+  services->ConnectToService(interface_name, pipe.handle1.Pass());
   return pipe.handle0.Pass();
 }
 
 Array<String> ApplicationManager::GetArgsForURL(const GURL& url) {
   URLToArgsMap::const_iterator args_it = url_to_args_.find(url);
   if (args_it != url_to_args_.end())
     return Array<String>::From(args_it->second);
   return Array<String>();
 }
 }  // namespace mojo