Revert of Extract some stuff into PackageManager

mojo/shell/capability_filter_unittest.cc

 // Copyright 2015 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/stl_util.h"
 #include "base/strings/stringprintf.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/connect.h"
 #include "mojo/application/public/cpp/interface_factory.h"
 #include "mojo/application/public/cpp/service_provider_impl.h"
 #include "mojo/application/public/interfaces/content_handler.mojom.h"
 #include "mojo/common/weak_binding_set.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/capability_filter_unittest.mojom.h"
-#include "mojo/shell/test_package_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 
 const char kTestMimeType[] = "test/mime-type";
 
 // Lives on the main thread of the test.
 // Listens for services exposed/blocked and for application connections being
@@ skipping 243 matching lines @@
       base::Callback<void(const base::FilePath&, bool)> callback) override {}
   std::string MimeType() override { return kTestMimeType; }
   bool HasMojoMagic() override { return false; }
   bool PeekFirstLine(std::string* line) override { return false; }
 
   const GURL url_;
 
   DISALLOW_COPY_AND_ASSIGN(TestFetcher);
 };
 
-class CFTestPackageManager : public TestPackageManager {
+class TestApplicationFetcher : public ApplicationFetcher {
  public:
-  CFTestPackageManager() {}
-  ~CFTestPackageManager() override {}
+   TestApplicationFetcher() {}
+   ~TestApplicationFetcher() override {}
 
    void set_use_test_fetcher(bool use_test_fetcher) {
      use_test_fetcher_ = use_test_fetcher;
    }
 
  private:
-  // Overridden from TestPackageManager:
+  // Overridden from ApplicationFetcher:
+  void SetApplicationManager(ApplicationManager* manager) override {}
+  GURL ResolveURL(const GURL& url) override {
+    return url;
+  }
   void FetchRequest(URLRequestPtr request,
                     const Fetcher::FetchCallback& loader_callback) override {
     if (use_test_fetcher_)
       new TestFetcher(GURL(request->url), loader_callback);
   }
 
   bool use_test_fetcher_;
 
-  DISALLOW_COPY_AND_ASSIGN(CFTestPackageManager);
+  DISALLOW_COPY_AND_ASSIGN(TestApplicationFetcher);
 };
 
 class TestLoader : public ApplicationLoader {
  public:
   explicit TestLoader(ApplicationDelegate* delegate) : delegate_(delegate) {}
   ~TestLoader() override {}
 
  private:
   // Overridden from ApplicationLoader:
   void Load(const GURL& url, InterfaceRequest<Application> request) override {
     app_.reset(new ApplicationImpl(delegate_.get(), request.Pass()));
   }
 
   scoped_ptr<ApplicationDelegate> delegate_;
   scoped_ptr<ApplicationImpl> app_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLoader);
 };
 
 class CapabilityFilterTest : public testing::Test {
  public:
    CapabilityFilterTest()
-      : test_package_manager_(nullptr),
+      : test_application_fetcher_(nullptr),
         validator_(nullptr) {}
    ~CapabilityFilterTest() override {}
 
  protected:
   void RunApplication(const std::string& url, const CapabilityFilter& filter) {
     ServiceProviderPtr services;
 
     // We expose Validator to the test application via ConnectToApplication
     // because we don't allow the test application to connect to test:validator.
     // Adding it to the CapabilityFilter would interfere with the test.
@@ skipping 24 matching lines @@
     loop()->Run();
     EXPECT_TRUE(validator_->expectations_met());
     if (!validator_->expectations_met())
       validator_->PrintUnmetExpectations();
   }
 
   void RunContentHandlerTest() {
     set_use_test_fetcher();
 
     GURL content_handler_url("test:content_handler");
-    test_package_manager_->RegisterContentHandler(kTestMimeType,
+    application_manager()->RegisterContentHandler(kTestMimeType,
                                                   content_handler_url);
 
     CreateLoader<TestContentHandler>(content_handler_url.spec());
     RunTest();
   }
 
   base::MessageLoop* loop() { return &loop_;  }
   ApplicationManager* application_manager() {
     return application_manager_.get();
   }
   ConnectionValidator* validator() { return validator_; }
   void set_use_test_fetcher() {
-    test_package_manager_->set_use_test_fetcher(true);
+    test_application_fetcher_->set_use_test_fetcher(true);
   }
 
   // Overridden from testing::Test:
   void SetUp() override {
-    test_package_manager_ = new CFTestPackageManager;
+    test_application_fetcher_ = new TestApplicationFetcher;
     application_manager_.reset(
-        new ApplicationManager(make_scoped_ptr(test_package_manager_)));
+        new ApplicationManager(make_scoped_ptr(test_application_fetcher_)));
     CreateLoader<ServiceApplication>("test:service");
     CreateLoader<ServiceApplication>("test:service2");
   }
   void TearDown() override {
     application_manager_.reset();
-    test_package_manager_->set_use_test_fetcher(false);
+    test_application_fetcher_->set_use_test_fetcher(false);
   }
 
  private:
   template<class T>
   scoped_ptr<ApplicationDelegate> CreateApplicationDelegate() {
     return scoped_ptr<ApplicationDelegate>(new T);
   }
 
-  CFTestPackageManager* test_package_manager_;
+  TestApplicationFetcher* test_application_fetcher_;
   base::ShadowingAtExitManager at_exit_;
   base::MessageLoop loop_;
   scoped_ptr<ApplicationManager> application_manager_;
   ConnectionValidator* validator_;
 
   DISALLOW_COPY_AND_ASSIGN(CapabilityFilterTest);
 };
 
 class CapabilityFilter_BlockingTest : public CapabilityFilterTest {
  public:
@@ skipping 120 matching lines @@
   RunTest();
 }
 
 TEST_F(CapabilityFilter_WildcardsTest, ContentHandler) {
   RunContentHandlerTest();
 }
 
 }  // namespace
 }  // namespace shell
 }  // namespace mojo