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 TestApplicationManagerDelegate : public ApplicationManager::Delegate {
+class TestApplicationFetcher : public ApplicationFetcher {
  public:
-   TestApplicationManagerDelegate() {}
-   ~TestApplicationManagerDelegate() override {}
+   TestApplicationFetcher() {}
+   ~TestApplicationFetcher() override {}
 
    void set_use_test_fetcher(bool use_test_fetcher) {
      use_test_fetcher_ = use_test_fetcher;
    }
 
  private:
-  // Overridden from ApplicationManager::Delegate:
-  GURL ResolveMappings(const GURL& url) override {
+  // Overridden from ApplicationFetcher:
+  void SetApplicationManager(ApplicationManager* manager) override {}
+  GURL ResolveURL(const GURL& url) override {
     return url;
   }
-  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;
+  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(TestApplicationManagerDelegate);
+  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() : validator_(nullptr) {}
+   CapabilityFilterTest()
+      : 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.
     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_delegate_.set_use_test_fetcher(true);
+    test_application_fetcher_->set_use_test_fetcher(true);
   }
 
   // Overridden from testing::Test:
   void SetUp() override {
-    application_manager_.reset(new ApplicationManager(&test_delegate_));
+    test_application_fetcher_ = new TestApplicationFetcher;
+    application_manager_.reset(
+        new ApplicationManager(make_scoped_ptr(test_application_fetcher_)));
     CreateLoader<ServiceApplication>("test:service");
     CreateLoader<ServiceApplication>("test:service2");
   }
   void TearDown() override {
     application_manager_.reset();
-    test_delegate_.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);
   }
 
+  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