Removes BackgroundShellApplicationLoader from application_manager tests

mojo/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 "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/application_manager/application_loader.h"
 #include "mojo/application_manager/application_manager.h"
-#include "mojo/application_manager/background_shell_application_loader.h"
 #include "mojo/application_manager/test.mojom.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/interface_factory.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace {
@@ skipping 55 matching lines @@
     service_.set_client(this);
   }
 
   ~TestClientImpl() override { service_.reset(); }
 
   void AckTest() override {
     if (quit_after_ack_)
       base::MessageLoop::current()->Quit();
   }
 
-  void Test(std::string test_string) {
+  void Test(const std::string& test_string) {
     quit_after_ack_ = true;
     service_->Test(test_string);
   }
 
  private:
   TestServicePtr service_;
   bool quit_after_ack_;
   DISALLOW_COPY_AND_ASSIGN(TestClientImpl);
 };
 
@@ skipping 133 matching lines @@
   int num_a_deletes_;
   int num_b_deletes_;
   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 InterfaceImpl<TestA> {
+class TestAImpl : public TestA {
  public:
-  TestAImpl(ApplicationConnection* connection, TesterContext* test_context)
-      : test_context_(test_context) {
+  TestAImpl(ApplicationConnection* connection,
+            TesterContext* test_context,
+            InterfaceRequest<TestA> request)
+      : test_context_(test_context),
+        binding_(this, request.Pass()) {
     connection->ConnectToApplication(kTestBURLString)->ConnectToService(&b_);
   }
   ~TestAImpl() override {
     test_context_->IncrementNumADeletes();
     if (base::MessageLoop::current()->is_running())
       Quit();
   }
 
  private:
   void CallB() override {
     b_->B(base::Bind(&TestAImpl::Quit, base::Unretained(this)));
   }
 
   void CallCFromB() override {
     b_->CallC(base::Bind(&TestAImpl::Quit, base::Unretained(this)));
   }
 
   void Quit() {
     base::MessageLoop::current()->Quit();
     test_context_->set_a_called_quit();
     test_context_->QuitSoon();
   }
 
   TesterContext* test_context_;
   TestBPtr b_;
+  Binding<TestA> binding_;
 };
 
 class TestBImpl : public InterfaceImpl<TestB> {
  public:
   TestBImpl(ApplicationConnection* connection, TesterContext* test_context)
       : test_context_(test_context) {
     connection->ConnectToService(&c_);
   }
 
   ~TestBImpl() override {
@@ skipping 72 matching lines @@
 
   bool ConfigureOutgoingConnection(ApplicationConnection* connection) override {
     // If we're connecting to B, then add C.
     if (connection->GetRemoteApplicationURL() == kTestBURLString)
       connection->AddService<TestC>(this);
     return true;
   }
 
   void Create(ApplicationConnection* connection,
               InterfaceRequest<TestA> request) override {
-    BindToRequest(new TestAImpl(connection, context_), &request);
+    a_bindings_.push_back(new TestAImpl(connection, context_, request.Pass()));
   }
 
   void Create(ApplicationConnection* connection,
               InterfaceRequest<TestB> request) override {
     BindToRequest(new TestBImpl(connection, context_), &request);
   }
 
   void Create(ApplicationConnection* connection,
               InterfaceRequest<TestC> request) override {
     BindToRequest(new TestCImpl(connection, context_), &request);
   }
 
   TesterContext* context_;
   scoped_ptr<ApplicationImpl> app_;
   std::string requestor_url_;
+  ScopedVector<TestAImpl> a_bindings_;
 };
 
 class TestServiceInterceptor : public ApplicationManager::Interceptor {
  public:
   TestServiceInterceptor() : call_count_(0) {}
 
   ServiceProviderPtr OnConnectToClient(
       const GURL& url,
       ServiceProviderPtr service_provider) override {
     ++call_count_;
@@ skipping 55 matching lines @@
     application_manager_->ConnectToService(GURL(kTestURLString),
                                            &service_proxy);
     test_client_.reset(new TestClientImpl(service_proxy.Pass()));
   }
 
   void TearDown() override {
     test_client_.reset(NULL);
     application_manager_.reset(NULL);
   }
 
-  scoped_ptr<BackgroundShellApplicationLoader> MakeLoader(
-      const std::string& requestor_url) {
-    scoped_ptr<ApplicationLoader> real_loader(
-        new Tester(&tester_context_, requestor_url));
-    scoped_ptr<BackgroundShellApplicationLoader> loader(
-        new BackgroundShellApplicationLoader(real_loader.Pass(),
-                                             std::string(),
-                                             base::MessageLoop::TYPE_DEFAULT));
-    return loader.Pass();
-  }
-
   void AddLoaderForURL(const GURL& url, const std::string& requestor_url) {
-    application_manager_->SetLoaderForURL(MakeLoader(requestor_url), url);
+    application_manager_->SetLoaderForURL(
+        make_scoped_ptr(new Tester(&tester_context_, requestor_url)), url);
   }
 
   bool HasFactoryForTestURL() {
     ApplicationManager::TestAPI manager_test_api(application_manager_.get());
     return manager_test_api.HasFactoryForURL(GURL(kTestURLString));
   }
 
  protected:
   base::ShadowingAtExitManager at_exit_;
   TestDelegate test_delegate_;
@@ skipping 235 matching lines @@
   TestServicePtr test_service2;
   application_manager_->ConnectToService(GURL("foo:foo2"), &test_service2);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   TestServicePtr test_service3;
   application_manager_->ConnectToService(GURL("bar:bar"), &test_service2);
   EXPECT_EQ(3, test_loader_->num_loads());
 }
 
 }  // namespace mojo