Revert of Move fetching logic out of ApplicationManager, eliminate url mappings.

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 "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 
 const char kTestMimeType[] = "test/mime-type";
@@ skipping 246 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 TestApplicationFetcher : public ApplicationFetcher {
+class TestApplicationManagerDelegate : public ApplicationManager::Delegate {
  public:
-   TestApplicationFetcher() {}
-   ~TestApplicationFetcher() override {}
+   TestApplicationManagerDelegate() {}
+   ~TestApplicationManagerDelegate() override {}
 
    void set_use_test_fetcher(bool use_test_fetcher) {
      use_test_fetcher_ = use_test_fetcher;
    }
 
  private:
-  // Overridden from ApplicationFetcher:
-  void SetApplicationManager(ApplicationManager* manager) override {}
-  GURL ResolveURL(const GURL& url) override {
+  // Overridden from ApplicationManager::Delegate:
+  GURL ResolveMappings(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);
+  GURL ResolveMojoURL(const GURL& url) override {
+    return url;
+  }
+  bool CreateFetcher(const GURL& url,
+                     const Fetcher::FetchCallback& loader_callback) override {
+    if (use_test_fetcher_) {
+      new TestFetcher(url, loader_callback);
+      return true;
+    }
+    return false;
   }
 
   bool use_test_fetcher_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestApplicationFetcher);
+  DISALLOW_COPY_AND_ASSIGN(TestApplicationManagerDelegate);
 };
 
 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_application_fetcher_(nullptr),
-        validator_(nullptr) {}
+   CapabilityFilterTest() : 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.
     ServiceProviderPtr exposed_services;
@@ skipping 36 matching lines @@
     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_application_fetcher_->set_use_test_fetcher(true);
+    test_delegate_.set_use_test_fetcher(true);
   }
 
   // Overridden from testing::Test:
   void SetUp() override {
-    test_application_fetcher_ = new TestApplicationFetcher;
-    application_manager_.reset(
-        new ApplicationManager(make_scoped_ptr(test_application_fetcher_)));
+    application_manager_.reset(new ApplicationManager(&test_delegate_));
     CreateLoader<ServiceApplication>("test:service");
     CreateLoader<ServiceApplication>("test:service2");
   }
   void TearDown() override {
     application_manager_.reset();
-    test_application_fetcher_->set_use_test_fetcher(false);
+    test_delegate_.set_use_test_fetcher(false);
   }
 
  private:
   template<class T>
   scoped_ptr<ApplicationDelegate> CreateApplicationDelegate() {
     return scoped_ptr<ApplicationDelegate>(new T);
   }
 
-  TestApplicationFetcher* test_application_fetcher_;
   base::ShadowingAtExitManager at_exit_;
+  TestApplicationManagerDelegate test_delegate_;
   base::MessageLoop loop_;
   scoped_ptr<ApplicationManager> application_manager_;
   ConnectionValidator* validator_;
 
   DISALLOW_COPY_AND_ASSIGN(CapabilityFilterTest);
 };
 
 class CapabilityFilter_BlockingTest : public CapabilityFilterTest {
  public:
   CapabilityFilter_BlockingTest() {}
@@ skipping 119 matching lines @@
   RunTest();
 }
 
 TEST_F(CapabilityFilter_WildcardsTest, ContentHandler) {
   RunContentHandlerTest();
 }
 
 }  // namespace
 }  // namespace shell
 }  // namespace mojo