ConnectToApplicationDeprecated() conversion/removal, part 3.

shell/application_manager/application_manager_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 "shell/application_manager/application_manager.h"
+
+#include <utility>
+
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
+#include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/cpp/application/interface_factory.h"
+#include "mojo/public/cpp/application/service_provider_impl.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
 #include "shell/application_manager/application_loader.h"
-#include "shell/application_manager/application_manager.h"
 #include "shell/application_manager/test.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using mojo::Application;
 using mojo::ApplicationConnection;
 using mojo::ApplicationDelegate;
 using mojo::ApplicationImpl;
 using mojo::Callback;
 using mojo::InterfaceFactory;
 using mojo::InterfaceRequest;
@@ skipping 206 matching lines @@
   int num_c_deletes_;
   bool tester_called_quit_;
   bool a_called_quit_;
 
   base::MessageLoop* loop_;
 };
 
 // Used to test that the requestor url will be correctly passed.
 class TestAImpl : public TestA {
  public:
-  TestAImpl(ApplicationConnection* b_connection,
+  TestAImpl(mojo::InterfaceHandle<mojo::ServiceProvider> b_sp_handle,
             TesterContext* test_context,
             InterfaceRequest<TestA> request)
       : test_context_(test_context), binding_(this, request.Pass()) {
-    b_connection->ConnectToService(&b_);
+    auto b_sp = mojo::ServiceProviderPtr::Create(b_sp_handle.Pass());
+    mojo::ConnectToService(b_sp.get(), GetProxy(&b_));
   }
 
   ~TestAImpl() override {
     test_context_->IncrementNumADeletes();
     if (base::MessageLoop::current()->is_running())
       Quit();
   }
 
  private:
   void CallB() override {
@@ skipping 93 matching lines @@
     // If we're coming from A, then add B, otherwise A.
     if (connection->GetRemoteApplicationURL() == kTestAURLString)
       connection->AddService<TestB>(this);
     else
       connection->AddService<TestA>(this);
     return true;
   }
 
   void Create(ApplicationConnection* connection,
               InterfaceRequest<TestA> request) override {
-    ApplicationConnection* b_connection =
-        app_->ConnectToApplicationDeprecated(kTestBURLString);
-    b_connection->AddService<TestC>(this);
+    mojo::InterfaceHandle<mojo::ServiceProvider> incoming_sp_handle;
+    mojo::InterfaceHandle<mojo::ServiceProvider> outgoing_sp_handle;
+    mojo::InterfaceRequest<mojo::ServiceProvider> outgoing_sp_request =
+        GetProxy(&outgoing_sp_handle);
+    app_->shell()->ConnectToApplication(kTestBURLString,
+                                        GetProxy(&incoming_sp_handle),
+                                        outgoing_sp_handle.Pass());
+    std::unique_ptr<mojo::ServiceProviderImpl> outgoing_sp_impl(
+        new mojo::ServiceProviderImpl(outgoing_sp_request.Pass()));
+    outgoing_sp_impl->AddService<TestC>(this);
+    outgoing_sp_impls_for_b_.push_back(std::move(outgoing_sp_impl));
     a_bindings_.push_back(
-        new TestAImpl(b_connection, context_, request.Pass()));
+        new TestAImpl(incoming_sp_handle.Pass(), context_, request.Pass()));
   }
 
   void Create(ApplicationConnection* connection,
               InterfaceRequest<TestB> request) override {
     new TestBImpl(connection, context_, request.Pass());
   }
 
   void Create(ApplicationConnection* connection,
               InterfaceRequest<TestC> request) override {
     new TestCImpl(connection, context_, request.Pass());
   }
 
   TesterContext* context_;
   scoped_ptr<ApplicationImpl> app_;
   std::string requestor_url_;
+  std::vector<std::unique_ptr<mojo::ServiceProviderImpl>>
+      outgoing_sp_impls_for_b_;
   ScopedVector<TestAImpl> a_bindings_;
 };
 
 class TestDelegate : public ApplicationManager::Delegate {
  public:
   void AddMapping(const GURL& from, const GURL& to) { mappings_[from] = to; }
 
   // ApplicationManager::Delegate
   GURL ResolveMappings(const GURL& url) override {
     auto it = mappings_.find(url);
@@ skipping 448 matching lines @@
   bool called = false;
   application_manager_->ConnectToApplication(
       GURL("test:test"), GURL(), nullptr, nullptr,
       base::Bind(&QuitClosure, base::Unretained(&called)));
   loop_.Run();
   EXPECT_TRUE(called);
 }
 
 }  // namespace
 }  // namespace shell