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) {
     connection->ConnectToApplication(kTestBURLString)->ConnectToService(&b_);
   }
   ~TestAImpl() override {
     test_context_->IncrementNumADeletes();
     if (base::MessageLoop::current()->is_running())
       Quit();
   }
@@ skipping 65 matching lines @@
                public ApplicationLoader,
                public InterfaceFactory<TestA>,
                public InterfaceFactory<TestB>,
                public InterfaceFactory<TestC> {
  public:
   Tester(TesterContext* context, const std::string& requestor_url)
       : context_(context), requestor_url_(requestor_url) {}
   ~Tester() override {}
 
  private:
+  struct TestABinding {

[qsr, 2014/12/18 08:58:34]

I'm perfectly fine with this, but you could have obtained the same result
without using this class by having a scoped_vector of TestAImpl and either:
- use InterfaceImpl and use WeakBindToRequest so that you kept ownership of the
implementation.
- Have TestAImpl owns the Binding and takes an InterfaceRequest in its
constructor.

[sky, 2014/12/18 16:46:55]

Good point. I went with your second suggestion.

+    scoped_ptr<TestAImpl> a;
+    scoped_ptr<Binding<TestA>> binding;
+  };
+
   void Load(ApplicationManager* manager,
             const GURL& url,
             ScopedMessagePipeHandle shell_handle,
             LoadCallback callback) override {
     app_.reset(new ApplicationImpl(this, shell_handle.Pass()));
   }
 
   void OnApplicationError(ApplicationManager* manager,
                           const GURL& url) override {}
 
@@ skipping 15 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);
+    scoped_ptr<TestABinding> binding(new TestABinding);
+    binding->a.reset(new TestAImpl(connection, context_));
+    binding->binding.reset(new Binding<TestA>(binding->a.get(),
+                                              request.Pass()));
+    a_bindings_.push_back(binding.release());
   }
 
   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<TestABinding> 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