Pass ServiceProvider and ServiceProvider& params in Connect

shell/external_application_listener_unittest.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 "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread.h"
@@ skipping 56 matching lines @@
 
   base::ScopedTempDir temp_dir_;
   base::FilePath socket_path_;
   scoped_ptr<ExternalApplicationListener> listener_;
 };
 
 namespace {
 
 class StubShellImpl : public InterfaceImpl<Shell> {
  private:
-  void ConnectToApplication(
-      const String& requestor_url,
-      InterfaceRequest<ServiceProvider> in_service_provider) override {
-    ServiceProviderPtr out_service_provider;
-    out_service_provider.Bind(in_service_provider.PassMessagePipe());
-    client()->AcceptConnection(requestor_url, out_service_provider.Pass());
+  void ConnectToApplication(const String& requestor_url,
+                            InterfaceRequest<ServiceProvider> services,
+                            ServiceProviderPtr exported_services) override {
+    client()->AcceptConnection(requestor_url, services.Pass(),
+                               exported_services.Pass());
   }
 };
 
 void DoLocalRegister(const GURL& app_url, ScopedMessagePipeHandle shell) {
   BindToPipe(new StubShellImpl, shell.Pass());
 }
 
 void QuitLoopOnConnect(scoped_refptr<base::TaskRunner> loop,
                        base::Closure quit_callback,
                        int rv) {
@@ skipping 25 matching lines @@
  public:
   QuitLoopOnConnectApplicationImpl(const std::string& url,
                                    scoped_refptr<base::TaskRunner> loop,
                                    base::Closure quit_callback)
       : url_(url), to_quit_(loop), quit_callback_(quit_callback) {}
 
  private:
   void Initialize(Array<String> args) override {}
 
   void AcceptConnection(const String& requestor_url,
-                        ServiceProviderPtr p) override {
+                        InterfaceRequest<ServiceProvider> services,
+                        ServiceProviderPtr exported_services) override {
     DVLOG(1) << url_ << " accepting connection from " << requestor_url;
     to_quit_->PostTask(FROM_HERE, quit_callback_);
   }
 
   const std::string url_;
   scoped_refptr<base::TaskRunner> to_quit_;
   base::Closure quit_callback_;
 };
 
 class FakeExternalApplication {
@@ skipping 12 matching lines @@
                 base::Closure register_complete_callback) {
     connection_->Register(
         GURL(url_),
         base::Bind(&FakeExternalApplication::OnRegister, base::Unretained(this),
                    register_complete_callback));
     application_impl_ = application_impl.Pass();
   }
 
   void ConnectToAppByUrl(std::string app_url) {
     ServiceProviderPtr sp;
-    ptr_->ConnectToApplication(app_url, GetProxy(&sp));
+    ptr_->ConnectToApplication(app_url, GetProxy(&sp), ServiceProviderPtr());
   }
 
   const std::string& url() { return url_; }
 
  private:
   void OnRegister(base::Closure complete_callback, ShellPtr shell) {
     ptr_ = shell.Pass();
     ptr_.set_client(application_impl_.get());
     complete_callback.Run();
   }
@@ skipping 74 matching lines @@
   run_loop_.Run();
 
   // The apps need to be destroyed on the thread where they did socket stuff.
   io_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&DestroyOnIOThread, base::Passed(&supersweet_app),
                             base::Passed(&awesome_app)));
 }
 
 }  // namespace shell
 }  // namespace mojo