Extract some stuff into PackageManager

mojo/shell/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 "base/run_loop.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_delegate.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/interface_factory.h"
 #include "mojo/application/public/interfaces/content_handler.mojom.h"
 #include "mojo/application/public/interfaces/service_provider.mojom.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
-#include "mojo/shell/application_fetcher.h"
 #include "mojo/shell/application_loader.h"
 #include "mojo/shell/application_manager.h"
 #include "mojo/shell/fetcher.h"
 #include "mojo/shell/test.mojom.h"
+#include "mojo/shell/test_package_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 
 const char kTestURLString[] = "test:testService";
 const char kTestAURLString[] = "test:TestA";
 const char kTestBURLString[] = "test:TestB";
 
@@ skipping 416 matching lines @@
               InterfaceRequest<TestC> request) override {
     new TestCImpl(connection, context_, request.Pass());
   }
 
   TesterContext* context_;
   scoped_ptr<ApplicationImpl> app_;
   std::string requestor_url_;
   ScopedVector<TestAImpl> a_bindings_;
 };
 
-class TestApplicationFetcher : public ApplicationFetcher {
+class AMTestPackageManager : public TestPackageManager {
  public:
-  TestApplicationFetcher()
+   AMTestPackageManager()
       : create_test_fetcher_(false),
         fetcher_url_("xxx"),
         mime_type_(kTestMimeType) {}
-  ~TestApplicationFetcher() override {}
+   ~AMTestPackageManager() override {}
 
   void set_create_test_fetcher(bool create_test_fetcher) {
     create_test_fetcher_ = create_test_fetcher;
   }
 
   void set_fetcher_url(const GURL& url) { fetcher_url_ = url; }
 
   void set_mime_type(const std::string& mime_type) { mime_type_ = mime_type; }
 
-  // ApplicationManager::Delegate
-  void SetApplicationManager(ApplicationManager* manager) override {}
+  // TestPackageManager:
   GURL ResolveURL(const GURL& url) override {
     GURL resolved_url = url;
     // The shell automatically map mojo URLs.
     if (resolved_url.scheme() == "mojo") {
       url::Replacements<char> replacements;
       replacements.SetScheme("file", url::Component(0, 4));
       resolved_url = resolved_url.ReplaceComponents(replacements);
     }
     return resolved_url;
   }
   void FetchRequest(URLRequestPtr request,
                     const Fetcher::FetchCallback& loader_callback) override {
     if (create_test_fetcher_)
       new TestMimeTypeFetcher(loader_callback, fetcher_url_, mime_type_);
   }
 
  private:
   bool create_test_fetcher_;
   GURL fetcher_url_;
   std::string mime_type_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestApplicationFetcher);
+  DISALLOW_COPY_AND_ASSIGN(AMTestPackageManager);
 };
 
 class ApplicationManagerTest : public testing::Test {
  public:
   ApplicationManagerTest() : tester_context_(&loop_) {}
 
   ~ApplicationManagerTest() override {}
 
   void SetUp() override {
     application_manager_.reset(new ApplicationManager(
-        make_scoped_ptr(new TestApplicationFetcher)));
+        make_scoped_ptr(new AMTestPackageManager)));
     test_loader_ = new TestApplicationLoader;
     test_loader_->set_context(&context_);
     application_manager_->set_default_loader(
         scoped_ptr<ApplicationLoader>(test_loader_));
 
     TestServicePtr service_proxy;
     application_manager_->ConnectToService(GURL(kTestURLString),
                                            &service_proxy);
     test_client_.reset(new TestClient(service_proxy.Pass()));
   }
@@ skipping 36 matching lines @@
   loop_.Run();
   EXPECT_EQ(1, context_.num_impls);
   test_client_.reset();
   loop_.Run();
   EXPECT_EQ(0, context_.num_impls);
   EXPECT_TRUE(HasRunningInstanceForURL(GURL(kTestURLString)));
 }
 
 TEST_F(ApplicationManagerTest, Deletes) {
   {
-    ApplicationManager am(make_scoped_ptr(new TestApplicationFetcher));
+    ApplicationManager am(make_scoped_ptr(new AMTestPackageManager));
     TestApplicationLoader* default_loader = new TestApplicationLoader;
     default_loader->set_context(&context_);
     TestApplicationLoader* url_loader1 = new TestApplicationLoader;
     TestApplicationLoader* url_loader2 = new TestApplicationLoader;
     url_loader1->set_context(&context_);
     url_loader2->set_context(&context_);
     am.set_default_loader(scoped_ptr<ApplicationLoader>(default_loader));
     am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(url_loader1),
                        GURL("test:test1"));
     am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(url_loader2),
@@ skipping 125 matching lines @@
   application_manager_->ConnectToApplication(params.Pass());
   loop_.Run();
   EXPECT_TRUE(called);
 }
 
 TEST(ApplicationManagerTest2, ContentHandlerConnectionGetsRequestorURL) {
   const GURL content_handler_url("http://test.content.handler");
   const GURL requestor_url("http://requestor.url");
   TestContext test_context;
   base::MessageLoop loop;
-  scoped_ptr<TestApplicationFetcher> test_application_fetcher(
-      new TestApplicationFetcher);
-  test_application_fetcher->set_create_test_fetcher(true);
-  ApplicationManager application_manager(test_application_fetcher.Pass());
+  scoped_ptr<AMTestPackageManager> test_package_manager(
+      new AMTestPackageManager);
+  test_package_manager->set_create_test_fetcher(true);
+  test_package_manager->RegisterContentHandler(kTestMimeType,
+                                               content_handler_url);
+  ApplicationManager application_manager(test_package_manager.Pass());
   application_manager.set_default_loader(nullptr);
-  application_manager.RegisterContentHandler(kTestMimeType,
-                                             content_handler_url);
 
   TestApplicationLoader* loader = new TestApplicationLoader;
   loader->set_context(&test_context);
   application_manager.SetLoaderForURL(scoped_ptr<ApplicationLoader>(loader),
                                       content_handler_url);
 
   bool called = false;
   scoped_ptr<ConnectToApplicationParams> params(new ConnectToApplicationParams);
   params->set_originator_identity(Identity(requestor_url));
   params->set_originator_filter(GetPermissiveCapabilityFilter());
@@ skipping 39 matching lines @@
       GURL("http://www.another_domain.org/abc"), &test_service);
   EXPECT_EQ(4, test_loader_->num_loads());
 }
 
 TEST(ApplicationManagerTest2,
      MultipleConnectionsToContentHandlerGetSameContentHandlerId) {
   base::MessageLoop loop;
   const GURL content_handler_url("http://test.content.handler");
   const GURL requestor_url("http://requestor.url");
   TestContext test_context;
-  scoped_ptr<TestApplicationFetcher> test_application_fetcher(
-      new TestApplicationFetcher);
-  test_application_fetcher->set_fetcher_url(GURL("test:test"));
-  test_application_fetcher->set_create_test_fetcher(true);
-  ApplicationManager application_manager(test_application_fetcher.Pass());
+  scoped_ptr<AMTestPackageManager> test_package_manager(
+      new AMTestPackageManager);
+  test_package_manager->set_fetcher_url(GURL("test:test"));
+  test_package_manager->set_create_test_fetcher(true);
+  test_package_manager->RegisterContentHandler(kTestMimeType,
+                                               content_handler_url);
+  ApplicationManager application_manager(test_package_manager.Pass());
   application_manager.set_default_loader(nullptr);
-  application_manager.RegisterContentHandler(kTestMimeType,
-                                             content_handler_url);
 
   TestApplicationLoader* content_handler_loader = new TestApplicationLoader;
   content_handler_loader->set_create_content_handler(true);
   content_handler_loader->set_context(&test_context);
   application_manager.SetLoaderForURL(
       scoped_ptr<ApplicationLoader>(content_handler_loader),
       content_handler_url);
 
   uint32_t content_handler_id;
   {
@@ skipping 31 matching lines @@
     EXPECT_NE(Shell::kInvalidContentHandlerID, content_handler_id2);
   }
   EXPECT_EQ(content_handler_id, content_handler_id2);
 }
 
 TEST(ApplicationManagerTest2, DifferedContentHandlersGetDifferentIDs) {
   base::MessageLoop loop;
   const GURL content_handler_url("http://test.content.handler");
   const GURL requestor_url("http://requestor.url");
   TestContext test_context;
-  TestApplicationFetcher* test_application_fetcher = new TestApplicationFetcher;
-  test_application_fetcher->set_fetcher_url(GURL("test:test"));
-  test_application_fetcher->set_create_test_fetcher(true);
-  ApplicationManager application_manager(
-      make_scoped_ptr(test_application_fetcher));
+  AMTestPackageManager* test_package_manager = new AMTestPackageManager;
+  test_package_manager->set_fetcher_url(GURL("test:test"));
+  test_package_manager->set_create_test_fetcher(true);
+  test_package_manager->RegisterContentHandler(kTestMimeType,
+                                               content_handler_url);
+  ApplicationManager application_manager(make_scoped_ptr(test_package_manager));
   application_manager.set_default_loader(nullptr);
-  application_manager.RegisterContentHandler(kTestMimeType,
-                                             content_handler_url);
 
   TestApplicationLoader* content_handler_loader = new TestApplicationLoader;
   content_handler_loader->set_create_content_handler(true);
   content_handler_loader->set_context(&test_context);
   application_manager.SetLoaderForURL(
       scoped_ptr<ApplicationLoader>(content_handler_loader),
       content_handler_url);
 
   uint32_t content_handler_id;
   {
     base::RunLoop run_loop;
     scoped_ptr<ConnectToApplicationParams> params(
         new ConnectToApplicationParams);
     params->set_originator_identity(Identity(requestor_url));
     params->set_originator_filter(GetPermissiveCapabilityFilter());
     params->SetURLInfo(GURL("test:test"));
     params->set_filter(GetPermissiveCapabilityFilter());
     params->set_connect_callback([&content_handler_id, &run_loop](uint32_t t) {
       content_handler_id = t;
       run_loop.Quit();
     });
     application_manager.ConnectToApplication(params.Pass());
     run_loop.Run();
     EXPECT_NE(Shell::kInvalidContentHandlerID, content_handler_id);
   }
 
   const std::string mime_type2("test/mime-type2");
   const GURL content_handler_url2("http://test.content2.handler");
-  test_application_fetcher->set_fetcher_url(GURL("test2:test2"));
-  test_application_fetcher->set_mime_type(mime_type2);
-  application_manager.RegisterContentHandler(mime_type2, content_handler_url2);
+  test_package_manager->set_fetcher_url(GURL("test2:test2"));
+  test_package_manager->set_mime_type(mime_type2);
+  test_package_manager->RegisterContentHandler(mime_type2,
+                                               content_handler_url2);
 
   TestApplicationLoader* content_handler_loader2 = new TestApplicationLoader;
   content_handler_loader->set_create_content_handler(true);
   content_handler_loader->set_context(&test_context);
   application_manager.SetLoaderForURL(
       scoped_ptr<ApplicationLoader>(content_handler_loader2),
       content_handler_url2);
 
   uint32_t content_handler_id2;
   {
@@ skipping 27 matching lines @@
   params->set_filter(GetPermissiveCapabilityFilter());
   params->set_connect_callback(
       [&content_handler_id](uint32_t t) { content_handler_id = t; });
   application_manager_->ConnectToApplication(params.Pass());
   EXPECT_EQ(0u, content_handler_id);
 }
 
 }  // namespace
 }  // namespace shell
 }  // namespace mojo