Removing callers of blink::Platform::CreateDefaultURLLoaderFactory (3).

This CL removes callers of
blink::Platform::CreateDefaultURLLoaderFactory to help with eventual
removal of this virtual method from blink::Platform.

This CL relies on an earlier https://crrev.com/c/2261419, which provides
a way to get the singleton WebURLLoaderMockFactory.  This CL uses the
singleton mock factory to construct WebURLLoaderFactoryWithMock (instead
of going via blink::Platform::CreateDefaultURLLoaderFactory) in the
following places:
- TestWebFrameClient::CreateURLLoaderFactory
- DummyLocalFrameClient::CreateURLLoaderFactory
- TestLoaderFactory's constructor

Additionally, this CL further tweaks PingLoaderTest, so that it doesn't
go through TestingPlatformSupport::CreateDefaultURLLoaderFactory, but
instead also directly constructs a WebURLLoaderFactoryWithMock.

Also, this CL has to tweak ResourceLoaderDefersLoadingTest which before
this CL depended on TestLoaderFactory going via
Platform::CreateDefaultURLLoaderFactory and ending up in
ResourceLoaderDefersLoadingTest::TestWebURLLoaderFactory::CreateDefault...
After this CL, the ResourceLoaderDefersLoadingTest::CreateFetcher method
directly constructs a ResourceLoader that wraps the test data (e.g.
|bool web_url_loader_defers_| and ProcessCodeCacheRequestCallback).
After this CL, ResourceLoaderDefersLoadingTest no longer needs to
override Platform methods.  Similar changes are needed in
ModuleScriptLoaderTest, WorkletModuleResponsesMapTest and
ResourceFetcherTest.

After this CL and after https://crrev.com/c/2250081, there should be no
more callers of blink::Platform::CreateDefaultURLLoaderFactory - this
method can be removed altogether in a follow-up CL:
https://crrev.com/c/2264503

Bug: 751425, 891872
Change-Id: I9190d4012ad8d1eb2ce554239265d46c2de52cf0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2260778
Commit-Queue: Łukasz Anforowicz <lukasza@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#783023}

third_party/blink/renderer/core/frame/frame_test_helpers.h

@@ -52,6 +52,7 @@
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/scheduler/test/web_fake_thread_scheduler.h"
 #include "third_party/blink/public/platform/web_string.h"
+#include "third_party/blink/public/platform/web_url_loader_mock_factory.h"
 #include "third_party/blink/public/platform/web_url_request.h"
 #include "third_party/blink/public/web/web_frame_owner_properties.h"
 #include "third_party/blink/public/web/web_history_item.h"
@@ -63,6 +64,7 @@
 #include "third_party/blink/renderer/core/frame/settings.h"
 #include "third_party/blink/renderer/core/scroll/scrollbar_theme.h"
 #include "third_party/blink/renderer/core/testing/scoped_mock_overlay_scrollbars.h"
+#include "third_party/blink/renderer/platform/loader/testing/web_url_loader_factory_with_mock.h"
 #include "third_party/blink/renderer/platform/runtime_enabled_features.h"
 #include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
 #include "third_party/blink/renderer/platform/wtf/vector.h"
@@ -431,9 +433,8 @@ class TestWebFrameClient : public WebLocalFrameClient {
   void DidStopLoading() override;
   std::unique_ptr<blink::WebURLLoaderFactory> CreateURLLoaderFactory()
       override {
-    // TODO(kinuko,toyoshim): Stop using Platform's URLLoaderFactory, but create
-    // its own WebURLLoaderFactoryWithMock. (crbug.com/751425)
-    return Platform::Current()->CreateDefaultURLLoaderFactory();
+    return std::make_unique<WebURLLoaderFactoryWithMock>(
+        WebURLLoaderMockFactory::GetSingletonInstance());
   }
   void BeginNavigation(std::unique_ptr<WebNavigationInfo> info) override;
   WebEffectiveConnectionType GetEffectiveConnectionType() override;

third_party/blink/renderer/core/loader/modulescript/module_script_loader_test.cc

@@ -190,7 +190,8 @@ void ModuleScriptLoaderTest::InitializeForDocument() {
   fetcher_ = MakeGarbageCollected<ResourceFetcher>(
       ResourceFetcherInit(properties->MakeDetachable(), fetch_context,
                           base::MakeRefCounted<scheduler::FakeTaskRunner>(),
-                          MakeGarbageCollected<TestLoaderFactory>()));
+                          MakeGarbageCollected<TestLoaderFactory>(
+                              platform_->GetURLLoaderMockFactory())));
   modulator_ = MakeGarbageCollected<ModuleScriptLoaderTestModulator>(
       ToScriptStateForMainWorld(&GetFrame()));
 }
@@ -202,7 +203,8 @@ void ModuleScriptLoaderTest::InitializeForWorklet() {
   fetcher_ = MakeGarbageCollected<ResourceFetcher>(
       ResourceFetcherInit(properties->MakeDetachable(), fetch_context,
                           base::MakeRefCounted<scheduler::FakeTaskRunner>(),
-                          MakeGarbageCollected<TestLoaderFactory>()));
+                          MakeGarbageCollected<TestLoaderFactory>(
+                              platform_->GetURLLoaderMockFactory())));
   reporting_proxy_ = std::make_unique<MockWorkerReportingProxy>();
   auto creation_params = std::make_unique<GlobalScopeCreationParams>(
       url_, mojom::blink::ScriptType::kModule, "GlobalScopeName", "UserAgent",

third_party/blink/renderer/core/loader/ping_loader_test.cc

@@ -5,13 +5,14 @@
 #include "third_party/blink/renderer/core/loader/ping_loader.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/public/platform/web_url_loader_factory.h"
 #include "third_party/blink/public/platform/web_url_loader_mock_factory.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/loader/empty_clients.h"
 #include "third_party/blink/renderer/core/loader/frame_loader.h"
 #include "third_party/blink/renderer/core/testing/page_test_base.h"
+#include "third_party/blink/renderer/platform/loader/testing/web_url_loader_factory_with_mock.h"
 #include "third_party/blink/renderer/platform/network/encoded_form_data.h"
-#include "third_party/blink/renderer/platform/testing/testing_platform_support.h"
 #include "third_party/blink/renderer/platform/testing/unit_test_helpers.h"
 #include "third_party/blink/renderer/platform/testing/url_test_helpers.h"
 #include "third_party/blink/renderer/platform/weborigin/kurl.h"
@@ -43,11 +44,11 @@ class PartialResourceRequest {
 
 class PingLocalFrameClient : public EmptyLocalFrameClient {
  public:
-  explicit PingLocalFrameClient(TestingPlatformSupport* platform)
-      : platform_(platform) {}
+  PingLocalFrameClient() = default;
 
   std::unique_ptr<WebURLLoaderFactory> CreateURLLoaderFactory() override {
-    return platform_->CreateDefaultURLLoaderFactory();
+    return std::make_unique<WebURLLoaderFactoryWithMock>(
+        WebURLLoaderMockFactory::GetSingletonInstance());
   }
 
   void DispatchWillSendRequest(ResourceRequest& request) override {
@@ -59,14 +60,12 @@ class PingLocalFrameClient : public EmptyLocalFrameClient {
 
  private:
   PartialResourceRequest ping_request_;
-  TestingPlatformSupport* platform_;
 };
 
 class PingLoaderTest : public PageTestBase {
  public:
   void SetUp() override {
-    client_ = MakeGarbageCollected<PingLocalFrameClient>(
-        platform_.GetTestingPlatformSupport());
+    client_ = MakeGarbageCollected<PingLocalFrameClient>();
     PageTestBase::SetupPageWithClients(nullptr, client_);
   }
 
@@ -101,7 +100,6 @@ class PingLoaderTest : public PageTestBase {
   }
 
  protected:
-  ScopedTestingPlatformSupport<TestingPlatformSupport> platform_;
   Persistent<PingLocalFrameClient> client_;
 };
 

third_party/blink/renderer/core/testing/dummy_page_holder.cc

@@ -33,6 +33,7 @@
 #include <memory>
 
 #include "base/memory/ptr_util.h"
+#include "third_party/blink/public/platform/web_url_loader_mock_factory.h"
 #include "third_party/blink/renderer/core/core_initializer.h"
 #include "third_party/blink/renderer/core/frame/local_dom_window.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
@@ -41,6 +42,7 @@
 #include "third_party/blink/renderer/core/frame/visual_viewport.h"
 #include "third_party/blink/renderer/core/loader/empty_clients.h"
 #include "third_party/blink/renderer/platform/heap/heap.h"
+#include "third_party/blink/renderer/platform/loader/testing/web_url_loader_factory_with_mock.h"
 #include "third_party/blink/renderer/platform/wtf/assertions.h"
 
 namespace blink {
@@ -53,7 +55,8 @@ class DummyLocalFrameClient : public EmptyLocalFrameClient {
 
  private:
   std::unique_ptr<WebURLLoaderFactory> CreateURLLoaderFactory() override {
-    return Platform::Current()->CreateDefaultURLLoaderFactory();
+    return std::make_unique<WebURLLoaderFactoryWithMock>(
+        WebURLLoaderMockFactory::GetSingletonInstance());
   }
 };
 

third_party/blink/renderer/core/workers/worklet_module_responses_map_test.cc

@@ -33,7 +33,8 @@ class WorkletModuleResponsesMapTest : public testing::Test {
     fetcher_ = MakeGarbageCollected<ResourceFetcher>(
         ResourceFetcherInit(properties->MakeDetachable(), context,
                             base::MakeRefCounted<scheduler::FakeTaskRunner>(),
-                            MakeGarbageCollected<TestLoaderFactory>()));
+                            MakeGarbageCollected<TestLoaderFactory>(
+                                platform_->GetURLLoaderMockFactory())));
     map_ = MakeGarbageCollected<WorkletModuleResponsesMap>();
   }
 

third_party/blink/renderer/platform/loader/fetch/resource_fetcher_test.cc

@@ -171,7 +171,8 @@ class ResourceFetcherTest : public testing::Test {
       FetchContext* context) {
     return MakeGarbageCollected<ResourceFetcher>(ResourceFetcherInit(
         properties.MakeDetachable(), context, CreateTaskRunner(),
-        MakeGarbageCollected<TestLoaderFactory>()));
+        MakeGarbageCollected<TestLoaderFactory>(
+            platform_->GetURLLoaderMockFactory())));
   }
 
   ResourceFetcher* CreateFetcher(
@@ -379,9 +380,11 @@ class RequestSameResourceOnComplete
   USING_GARBAGE_COLLECTED_MIXIN(RequestSameResourceOnComplete);
 
  public:
-  explicit RequestSameResourceOnComplete(FetchParameters& params,
-                                         ResourceFetcher* fetcher)
-      : notify_finished_called_(false),
+  RequestSameResourceOnComplete(WebURLLoaderMockFactory* mock_factory,
+                                FetchParameters& params,
+                                ResourceFetcher* fetcher)
+      : mock_factory_(mock_factory),
+        notify_finished_called_(false),
         source_origin_(fetcher->GetProperties()
                            .GetFetchClientSettingsObject()
                            .GetSecurityOrigin()) {
@@ -393,10 +396,10 @@ class RequestSameResourceOnComplete
     auto* properties =
         MakeGarbageCollected<TestResourceFetcherProperties>(source_origin_);
     MockFetchContext* context = MakeGarbageCollected<MockFetchContext>();
-    auto* fetcher2 = MakeGarbageCollected<ResourceFetcher>(
-        ResourceFetcherInit(properties->MakeDetachable(), context,
-                            base::MakeRefCounted<scheduler::FakeTaskRunner>(),
-                            MakeGarbageCollected<TestLoaderFactory>()));
+    auto* fetcher2 = MakeGarbageCollected<ResourceFetcher>(ResourceFetcherInit(
+        properties->MakeDetachable(), context,
+        base::MakeRefCounted<scheduler::FakeTaskRunner>(),
+        MakeGarbageCollected<TestLoaderFactory>(mock_factory_)));
     ResourceRequest resource_request2(GetResource()->Url());
     resource_request2.SetCacheMode(mojom::FetchCacheMode::kValidateCache);
     FetchParameters fetch_params2(std::move(resource_request2));
@@ -414,6 +417,7 @@ class RequestSameResourceOnComplete
   String DebugName() const override { return "RequestSameResourceOnComplete"; }
 
  private:
+  WebURLLoaderMockFactory* mock_factory_;
   bool notify_finished_called_;
   scoped_refptr<const SecurityOrigin> source_origin_;
 };
@@ -437,8 +441,8 @@ TEST_F(ResourceFetcherTest, RevalidateWhileFinishingLoading) {
   request1.SetHttpHeaderField(http_names::kCacheControl, "no-cache");
   FetchParameters fetch_params1(std::move(request1));
   Persistent<RequestSameResourceOnComplete> client =
-      MakeGarbageCollected<RequestSameResourceOnComplete>(fetch_params1,
-                                                          fetcher1);
+      MakeGarbageCollected<RequestSameResourceOnComplete>(
+          platform_->GetURLLoaderMockFactory(), fetch_params1, fetcher1);
   platform_->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
   EXPECT_TRUE(client->NotifyFinishedCalled());
 }
@@ -559,7 +563,7 @@ class ScopedMockRedirectRequester {
     auto* properties = MakeGarbageCollected<TestResourceFetcherProperties>();
     auto* fetcher = MakeGarbageCollected<ResourceFetcher>(ResourceFetcherInit(
         properties->MakeDetachable(), context_, task_runner_,
-        MakeGarbageCollected<TestLoaderFactory>()));
+        MakeGarbageCollected<TestLoaderFactory>(mock_factory_)));
     ResourceRequest resource_request(url);
     resource_request.SetRequestContext(mojom::RequestContextType::INTERNAL);
     FetchParameters fetch_params(std::move(resource_request));
@@ -1113,10 +1117,11 @@ TEST_F(ResourceFetcherTest, DeprioritizeSubframe) {
 TEST_F(ResourceFetcherTest, Detach) {
   DetachableResourceFetcherProperties& properties =
       MakeGarbageCollected<TestResourceFetcherProperties>()->MakeDetachable();
-  auto* const fetcher =
-      MakeGarbageCollected<ResourceFetcher>(ResourceFetcherInit(
-          properties, MakeGarbageCollected<MockFetchContext>(),
-          CreateTaskRunner(), MakeGarbageCollected<TestLoaderFactory>()));
+  auto* const fetcher = MakeGarbageCollected<ResourceFetcher>(
+      ResourceFetcherInit(properties, MakeGarbageCollected<MockFetchContext>(),
+                          CreateTaskRunner(),
+                          MakeGarbageCollected<TestLoaderFactory>(
+                              platform_->GetURLLoaderMockFactory())));
 
   EXPECT_EQ(&properties, &fetcher->GetProperties());
   EXPECT_FALSE(properties.IsDetached());

third_party/blink/renderer/platform/loader/fetch/resource_loader_defer_loading_test.cc

@@ -21,47 +21,14 @@
 
 namespace blink {
 
-class ResourceLoaderDefersLoadingTest : public testing::Test {
- public:
-  using ProcessCodeCacheRequestCallback =
-      base::RepeatingCallback<void(CodeCacheLoader::FetchCodeCacheCallback)>;
-  class TestingPlatformSupportWithMockCodeCacheLoader;
-  class TestCodeCacheLoader;
-  class TestWebURLLoaderFactory;
-  class TestWebURLLoader;
+namespace {
 
-  ResourceLoaderDefersLoadingTest();
-
-  void SaveCodeCacheCallback(CodeCacheLoader::FetchCodeCacheCallback callback) {
-    // Store the callback to send back a response.
-    code_cache_response_callback_ = std::move(callback);
-  }
-
-  ResourceFetcher* CreateFetcher() {
-    return MakeGarbageCollected<ResourceFetcher>(ResourceFetcherInit(
-        MakeGarbageCollected<TestResourceFetcherProperties>()->MakeDetachable(),
-        MakeGarbageCollected<MockFetchContext>(),
-        base::MakeRefCounted<scheduler::FakeTaskRunner>(),
-        MakeGarbageCollected<TestLoaderFactory>()));
-  }
-
-  CodeCacheLoader::FetchCodeCacheCallback code_cache_response_callback_;
-  // Passed to TestWebURLLoader (via |platform_|) and updated when its
-  // SetDefersLoading method is called.
-  bool web_url_loader_defers_ = false;
-  const KURL test_url_;
-
-  ScopedTestingPlatformSupport<
-      ResourceLoaderDefersLoadingTest::
-          TestingPlatformSupportWithMockCodeCacheLoader,
-      bool*>
-      platform_;
-};
+using ProcessCodeCacheRequestCallback =
+    base::RepeatingCallback<void(CodeCacheLoader::FetchCodeCacheCallback)>;
 
 // A mock code cache loader that calls the processing function whenever it
 // receives fetch requests.
-class ResourceLoaderDefersLoadingTest::TestCodeCacheLoader
-    : public CodeCacheLoader {
+class TestCodeCacheLoader : public CodeCacheLoader {
  public:
   explicit TestCodeCacheLoader(ProcessCodeCacheRequestCallback callback)
       : process_request_(callback) {}
@@ -84,8 +51,7 @@ class ResourceLoaderDefersLoadingTest::TestCodeCacheLoader
 };
 
 // A mock WebURLLoader to know the status of defers flag.
-class ResourceLoaderDefersLoadingTest::TestWebURLLoader final
-    : public WebURLLoader {
+class TestWebURLLoader final : public WebURLLoader {
  public:
   explicit TestWebURLLoader(bool* const defers_flag_ptr)
       : defers_flag_ptr_(defers_flag_ptr) {}
@@ -129,60 +95,73 @@ class ResourceLoaderDefersLoadingTest::TestWebURLLoader final
   bool* const defers_flag_ptr_;
 };
 
-// Mock WebURLLoaderFactory.
-class ResourceLoaderDefersLoadingTest::TestWebURLLoaderFactory final
-    : public WebURLLoaderFactory {
+class DeferTestLoaderFactory final : public ResourceFetcher::LoaderFactory {
  public:
-  explicit TestWebURLLoaderFactory(bool* const defers_flag)
-      : defers_flag_(defers_flag) {}
-
+  DeferTestLoaderFactory(
+      bool* const defers_flag,
+      ProcessCodeCacheRequestCallback process_code_cache_request_callback)
+      : defers_flag_(defers_flag),
+        process_code_cache_request_callback_(
+            process_code_cache_request_callback) {}
+
+  // LoaderFactory implementations
   std::unique_ptr<WebURLLoader> CreateURLLoader(
-      const WebURLRequest& request,
-      std::unique_ptr<scheduler::WebResourceLoadingTaskRunnerHandle>) override {
+      const ResourceRequest& request,
+      const ResourceLoaderOptions& options,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner) override {
     return std::make_unique<TestWebURLLoader>(defers_flag_);
   }
 
+  std::unique_ptr<CodeCacheLoader> CreateCodeCacheLoader() override {
+    return std::make_unique<TestCodeCacheLoader>(
+        process_code_cache_request_callback_);
+  }
+
  private:
   // Points to |ResourceLoaderDefersLoadingTest::web_url_loader_defers_|.
   bool* const defers_flag_;
+
+  ProcessCodeCacheRequestCallback process_code_cache_request_callback_;
 };
 
-// Mock TestPlatform to create the specific WebURLLoaderFactory and
-// CodeCacheLoader required for the tests.
-class ResourceLoaderDefersLoadingTest::
-    TestingPlatformSupportWithMockCodeCacheLoader
-    : public TestingPlatformSupportWithMockScheduler {
+}  // namespace
+
+class ResourceLoaderDefersLoadingTest : public testing::Test {
  public:
-  TestingPlatformSupportWithMockCodeCacheLoader(bool* const defers_flag)
-      : defers_flag_(defers_flag) {}
+  ResourceLoaderDefersLoadingTest() {
+    SetCodeCacheProcessFunction(base::BindRepeating(
+        &ResourceLoaderDefersLoadingTest::SaveCodeCacheCallback,
+        base::Unretained(this)));
+  }
 
-  std::unique_ptr<CodeCacheLoader> CreateCodeCacheLoader() override {
-    return std::make_unique<TestCodeCacheLoader>(process_code_cache_request_);
+  void SaveCodeCacheCallback(CodeCacheLoader::FetchCodeCacheCallback callback) {
+    // Store the callback to send back a response.
+    code_cache_response_callback_ = std::move(callback);
   }
 
-  std::unique_ptr<WebURLLoaderFactory> CreateDefaultURLLoaderFactory()
-      override {
-    return std::make_unique<TestWebURLLoaderFactory>(defers_flag_);
+  ResourceFetcher* CreateFetcher() {
+    return MakeGarbageCollected<ResourceFetcher>(ResourceFetcherInit(
+        MakeGarbageCollected<TestResourceFetcherProperties>()->MakeDetachable(),
+        MakeGarbageCollected<MockFetchContext>(),
+        base::MakeRefCounted<scheduler::FakeTaskRunner>(),
+        MakeGarbageCollected<DeferTestLoaderFactory>(
+            &web_url_loader_defers_, process_code_cache_request_callback_)));
   }
 
   void SetCodeCacheProcessFunction(ProcessCodeCacheRequestCallback callback) {
-    process_code_cache_request_ = callback;
+    process_code_cache_request_callback_ = callback;
   }
 
- private:
-  ProcessCodeCacheRequestCallback process_code_cache_request_;
-  // Points to |ResourceLoaderDefersLoadingTest::web_url_loader_defers_|.
-  bool* const defers_flag_;
-};
+  ProcessCodeCacheRequestCallback process_code_cache_request_callback_;
+  CodeCacheLoader::FetchCodeCacheCallback code_cache_response_callback_;
+  // Passed to TestWebURLLoader (via |platform_|) and updated when its
+  // SetDefersLoading method is called.
+  bool web_url_loader_defers_ = false;
+  const KURL test_url_ = KURL("http://example.com/");
 
-ResourceLoaderDefersLoadingTest::ResourceLoaderDefersLoadingTest()
-    : test_url_("http://example.com/"), platform_(&web_url_loader_defers_) {
-  // Saves the callback to control when the response is sent from
-  // the code cache loader.
-  platform_->SetCodeCacheProcessFunction(base::BindRepeating(
-      &ResourceLoaderDefersLoadingTest::SaveCodeCacheCallback,
-      base::Unretained(this)));
-}
+  ScopedTestingPlatformSupport<TestingPlatformSupportWithMockScheduler>
+      platform_;
+};
 
 TEST_F(ResourceLoaderDefersLoadingTest, CodeCacheFetchCheckDefers) {
   auto* fetcher = CreateFetcher();
@@ -203,7 +182,7 @@ TEST_F(ResourceLoaderDefersLoadingTest, CodeCacheFetchCheckDefers) {
 }
 
 TEST_F(ResourceLoaderDefersLoadingTest, CodeCacheFetchSyncReturn) {
-  platform_->SetCodeCacheProcessFunction(
+  SetCodeCacheProcessFunction(
       base::BindRepeating([](CodeCacheLoader::FetchCodeCacheCallback callback) {
         std::move(callback).Run(base::Time(), {});
       }));

third_party/blink/renderer/platform/loader/testing/test_loader_factory.h

@@ -10,8 +10,10 @@
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/scheduler/web_resource_loading_task_runner_handle.h"
 #include "third_party/blink/public/platform/web_url_loader_factory.h"
+#include "third_party/blink/public/platform/web_url_loader_mock_factory.h"
 #include "third_party/blink/renderer/platform/exported/wrapped_resource_request.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_fetcher.h"
+#include "third_party/blink/renderer/platform/loader/testing/web_url_loader_factory_with_mock.h"
 
 namespace blink {
 
@@ -19,8 +21,11 @@ namespace blink {
 class TestLoaderFactory : public ResourceFetcher::LoaderFactory {
  public:
   TestLoaderFactory()
+      : TestLoaderFactory(WebURLLoaderMockFactory::GetSingletonInstance()) {}
+
+  explicit TestLoaderFactory(WebURLLoaderMockFactory* mock_factory)
       : url_loader_factory_(
-            Platform::Current()->CreateDefaultURLLoaderFactory()) {}
+            std::make_unique<WebURLLoaderFactoryWithMock>(mock_factory)) {}
 
   // LoaderFactory implementations
   std::unique_ptr<WebURLLoader> CreateURLLoader(
@@ -33,6 +38,7 @@ class TestLoaderFactory : public ResourceFetcher::LoaderFactory {
         scheduler::WebResourceLoadingTaskRunnerHandle::CreateUnprioritized(
             std::move(task_runner)));
   }
+
   std::unique_ptr<CodeCacheLoader> CreateCodeCacheLoader() override {
     return Platform::Current()->CreateCodeCacheLoader();
   }