Moves BackgroundShellApplicationLoader to shell/android

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/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 345 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 147 matching lines @@
   TestAPtr a;
   application_manager_->ConnectToService(GURL(kTestAURLString), &a);
   a->CallCFromB();
   loop_.Run();
 
   EXPECT_EQ(1, tester_context_.num_b_calls());
   EXPECT_EQ(1, tester_context_.num_c_calls());
   EXPECT_TRUE(tester_context_.a_called_quit());
 }
 
-// Confirm that a service impl will be deleted if the app that connected to
-// it goes away.
-TEST_F(ApplicationManagerTest, BDeleted) {

[sky, 2014/12/16 19:22:19]

Contrary to the description this test was exercising a combination of
BackgroundShellApplicationLoader and the handle watcher code. The reason the
code worked before was resetting the loader on 646 (old) triggered shutting down
the background thread and background message loop. Shutting down the MessageLoop
closes the pipes. As A/B are InterfaceImpls they are destroyed when the pipe
closes.

Removing BackgroundShellApplicationLoader from here means resetting the app (646
old) no longer triggers closing pipes and this test fails.

[qsr, 2014/12/17 10:34:34]

 Can you still make this work by having Tester use WeakBindToPipe instead of
BindToPipe and close all implementation when going away?

 It seems we still want to be able to test this use case. 

-  AddLoaderForURL(GURL(kTestAURLString), std::string());
-  AddLoaderForURL(GURL(kTestBURLString), std::string());
-
-  TestAPtr a;
-  application_manager_->ConnectToService(GURL(kTestAURLString), &a);
-
-  a->CallB();
-  loop_.Run();
-
-  // Kills the a app.
-  application_manager_->SetLoaderForURL(scoped_ptr<ApplicationLoader>(),
-                                        GURL(kTestAURLString));
-  loop_.Run();
-
-  EXPECT_EQ(1, tester_context_.num_b_deletes());
-}
-
 // Confirm that the url of a service is correctly passed to another service that
 // it loads, and that it can be rejected.
 TEST_F(ApplicationManagerTest, ANoLoadB) {
   // Any url can load a.
   AddLoaderForURL(GURL(kTestAURLString), std::string());
 
   // Only c can load b, so this will fail.
   AddLoaderForURL(GURL(kTestBURLString), "test:TestC");
 
   TestAPtr a;
@@ skipping 48 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