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 53 matching lines @@
             ApplicationManager* manager,
             const GURL& requested_url,
             const GURL& url)
       : ShellImpl(manager, requested_url, url) {
     binding_.Bind(ptr);
   }
 
   ~ShellImpl() override {}
 
   void ConnectToClient(const GURL& requestor_url,
-                       ServiceProviderPtr service_provider) {
-    client()->AcceptConnection(String::From(requestor_url),
-                               service_provider.Pass());
+                       InterfaceRequest<ServiceProvider> services,
+                       ServiceProviderPtr exported_services) {
+    client()->AcceptConnection(String::From(requestor_url), services.Pass(),
+                               exported_services.Pass());
   }
 
   Application* client() { return binding_.client(); }
   const GURL& url() const { return url_; }
   const GURL& requested_url() const { return requested_url_; }
 
  private:
   ShellImpl(ApplicationManager* manager,
             const GURL& requested_url,
             const GURL& url)
       : manager_(manager),
         requested_url_(requested_url),
         url_(url),
         binding_(this) {
     binding_.set_error_handler(this);
   }
 
   // Shell implementation:
-  void ConnectToApplication(
-      const String& app_url,
-      InterfaceRequest<ServiceProvider> in_service_provider) override {
-    ServiceProviderPtr out_service_provider;
-    out_service_provider.Bind(in_service_provider.PassMessagePipe());
+  void ConnectToApplication(const String& app_url,
+                            InterfaceRequest<ServiceProvider> services,
+                            ServiceProviderPtr exported_services) override {
     GURL app_gurl(app_url);
     if (!app_gurl.is_valid()) {
       LOG(ERROR) << "Error: invalid URL: " << app_url;
       return;
     }
-    manager_->ConnectToApplication(app_gurl, url_, out_service_provider.Pass());
+    manager_->ConnectToApplication(app_gurl, url_, services.Pass(),
+                                   exported_services.Pass());
   }
 
   // ErrorHandler implementation:
   void OnConnectionError() override { manager_->OnShellImplError(this); }
 
   ApplicationManager* const manager_;
   const GURL requested_url_;
   const GURL url_;
   Binding<Shell> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ShellImpl);
 };
 
 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), ServiceProviderPtr());
+    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 exported_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(), exported_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(), exported_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 exported_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(),
+                  exported_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 exported_services) {
+  shell_impl->ConnectToClient(requestor_url, services.Pass(),
+                              exported_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),
+                       ServiceProviderPtr());
   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