Remove unused test-only code from WebURLLoaderImpl

data URLs are now handled in blink, so we don't need to use
WebURLLoaderImpl for data URL handling in tests. Remove
|default_loader| param from WebURLLoaderMockFactory::CreateURLLoader.

That allows us to expect non-null |resource_dispatcher_| and
|loader_factory_| in WebURLLoaderImpl. Remove the redundant code.

Bug: 751425
Change-Id: Iddcc5178b641c37aa563dce65b0626472d710d02
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1704717Reviewed-by: Takashi Toyoshima <toyoshim@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Makoto Shimazu <shimazu@chromium.org>
Commit-Queue: Yutaka Hirano <yhirano@chromium.org>
Cr-Commit-Position: refs/heads/master@{#684273}

content/renderer/loader/web_url_loader_impl.cc

@@ -348,29 +348,16 @@ WebURLLoaderFactoryImpl::WebURLLoaderFactoryImpl(
     base::WeakPtr<ResourceDispatcher> resource_dispatcher,
     scoped_refptr<network::SharedURLLoaderFactory> loader_factory)
     : resource_dispatcher_(std::move(resource_dispatcher)),
-      loader_factory_(std::move(loader_factory)) {}
+      loader_factory_(std::move(loader_factory)) {
+  DCHECK(resource_dispatcher_);
+  DCHECK(loader_factory_);
+}
 
 WebURLLoaderFactoryImpl::~WebURLLoaderFactoryImpl() = default;
 
 std::unique_ptr<blink::WebURLLoader> WebURLLoaderFactoryImpl::CreateURLLoader(
     const blink::WebURLRequest& request,
     std::unique_ptr<WebResourceLoadingTaskRunnerHandle> task_runner_handle) {
-  if (!loader_factory_) {
-    // In some tests like RenderViewTests loader_factory_ is not available.
-    // These tests can still use data URLs to bypass the ResourceDispatcher.
-    if (!task_runner_handle) {
-      // TODO(altimin): base::ThreadTaskRunnerHandle::Get is deprecated in
-      // the renderer. Fix this for frame and non-frame clients.
-      task_runner_handle =
-          WebResourceLoadingTaskRunnerHandle::CreateUnprioritized(
-              base::ThreadTaskRunnerHandle::Get());
-    }
-
-    return std::make_unique<WebURLLoaderImpl>(resource_dispatcher_.get(),
-                                              std::move(task_runner_handle),
-                                              nullptr /* factory */);
-  }
-
   DCHECK(task_runner_handle);
   DCHECK(resource_dispatcher_);
   return std::make_unique<WebURLLoaderImpl>(resource_dispatcher_.get(),
@@ -583,14 +570,14 @@ WebURLLoaderImpl::Context::Context(
       defers_loading_(NOT_DEFERRING),
       request_id_(-1),
       url_loader_factory_(std::move(url_loader_factory)) {
-  DCHECK(url_loader_factory_ || !resource_dispatcher);
+  DCHECK(resource_dispatcher_);
+  DCHECK(url_loader_factory_);
 }
 
 void WebURLLoaderImpl::Context::Cancel() {
   TRACE_EVENT_WITH_FLOW0("loading", "WebURLLoaderImpl::Context::Cancel", this,
                          TRACE_EVENT_FLAG_FLOW_IN);
-  if (resource_dispatcher_ && // NULL in unittest.
-      request_id_ != -1) {
+  if (request_id_ != -1) {
     resource_dispatcher_->Cancel(request_id_, task_runner_);
     request_id_ = -1;
   }

content/test/test_blink_web_unit_test_support.cc

@@ -24,7 +24,6 @@
 #include "content/app/mojo/mojo_init.h"
 #include "content/child/child_process.h"
 #include "content/public/common/service_names.mojom.h"
-#include "content/renderer/loader/web_url_loader_impl.h"
 #include "content/renderer/mojo/blink_interface_provider_impl.h"
 #include "content/test/mock_clipboard_host.h"
 #include "media/base/media.h"
@@ -103,12 +102,7 @@ class WebURLLoaderFactoryWithMock : public blink::WebURLLoaderFactory {
       std::unique_ptr<blink::scheduler::WebResourceLoadingTaskRunnerHandle>
           task_runner_handle) override {
     DCHECK(platform_);
-    // This loader should be used only for process-local resources such as
-    // data URLs.
-    auto default_loader = std::make_unique<content::WebURLLoaderImpl>(
-        nullptr, std::move(task_runner_handle), nullptr);
-    return platform_->GetURLLoaderMockFactory()->CreateURLLoader(
-        std::move(default_loader));
+    return platform_->GetURLLoaderMockFactory()->CreateURLLoader();
   }
 
  private:

third_party/blink/public/platform/web_url_loader_mock_factory.h

@@ -27,10 +27,7 @@ class WebURLLoaderMockFactory {
   virtual ~WebURLLoaderMockFactory() = default;
 
   // Create a WebURLLoader that takes care of mocked requests.
-  // Non-mocked request are forwarded to given loader which should not
-  // be nullptr.
-  virtual std::unique_ptr<WebURLLoader> CreateURLLoader(
-      std::unique_ptr<WebURLLoader>) = 0;
+  virtual std::unique_ptr<WebURLLoader> CreateURLLoader() = 0;
 
   // Registers a response and the file to be served when the specified URL
   // is loaded. If no file is specified then the response content will be empty.

third_party/blink/renderer/modules/service_worker/web_embedded_worker_impl_test.cc

@@ -55,8 +55,7 @@ class FakeServiceWorkerNetworkProvider final
   std::unique_ptr<WebURLLoader> CreateURLLoader(
       const WebURLRequest& request,
       std::unique_ptr<scheduler::WebResourceLoadingTaskRunnerHandle>) override {
-    return Platform::Current()->GetURLLoaderMockFactory()->CreateURLLoader(
-        nullptr);
+    return Platform::Current()->GetURLLoaderMockFactory()->CreateURLLoader();
   }
 
   blink::mojom::ControllerServiceWorkerMode GetControllerServiceWorkerMode()

third_party/blink/renderer/platform/loader/testing/web_url_loader_factory_with_mock.cc

@@ -18,7 +18,7 @@ WebURLLoaderFactoryWithMock::~WebURLLoaderFactoryWithMock() = default;
 std::unique_ptr<WebURLLoader> WebURLLoaderFactoryWithMock::CreateURLLoader(
     const WebURLRequest& request,
     std::unique_ptr<blink::scheduler::WebResourceLoadingTaskRunnerHandle>) {
-  return mock_factory_->CreateURLLoader(nullptr);
+  return mock_factory_->CreateURLLoader();
 }
 
 }  // namespace blink

third_party/blink/renderer/platform/testing/weburl_loader_mock.cc

@@ -17,21 +17,8 @@
 
 namespace blink {
 
-namespace {
-
-void AssertFallbackLoaderAvailability(const WebURL& url,
-                                      const WebURLLoader* default_loader) {
-  DCHECK(KURL(url).ProtocolIsData())
-      << "shouldn't be falling back: " << url.GetString().Utf8();
-  DCHECK(default_loader) << "default_loader wasn't set: "
-                         << url.GetString().Utf8();
-}
-
-}  // namespace
-
-WebURLLoaderMock::WebURLLoaderMock(WebURLLoaderMockFactoryImpl* factory,
-                                   std::unique_ptr<WebURLLoader> default_loader)
-    : factory_(factory), default_loader_(std::move(default_loader)) {}
+WebURLLoaderMock::WebURLLoaderMock(WebURLLoaderMockFactoryImpl* factory)
+    : factory_(factory) {}
 
 WebURLLoaderMock::~WebURLLoaderMock() {
   Cancel();
@@ -42,7 +29,6 @@ void WebURLLoaderMock::ServeAsynchronousRequest(
     const WebURLResponse& response,
     const WebData& data,
     const base::Optional<WebURLError>& error) {
-  DCHECK(!using_default_loader_);
   if (!client_)
     return;
 
@@ -115,47 +101,26 @@ void WebURLLoaderMock::LoadSynchronously(
     int64_t& encoded_data_length,
     int64_t& encoded_body_length,
     blink::WebBlobInfo& downloaded_blob) {
-  if (factory_->IsMockedURL(request.Url())) {
-    factory_->LoadSynchronously(request, &response, &error, &data,
-                                &encoded_data_length);
-    return;
-  }
-  AssertFallbackLoaderAvailability(request.Url(), default_loader_.get());
-  using_default_loader_ = true;
-  default_loader_->LoadSynchronously(request, client, response, error, data,
-                                     encoded_data_length, encoded_body_length,
-                                     downloaded_blob);
+  DCHECK(factory_->IsMockedURL(request.Url()));
+  factory_->LoadSynchronously(request, &response, &error, &data,
+                              &encoded_data_length);
 }
 
 void WebURLLoaderMock::LoadAsynchronously(const WebURLRequest& request,
                                           WebURLLoaderClient* client) {
   DCHECK(client);
-  if (factory_->IsMockedURL(request.Url())) {
-    client_ = client;
-    factory_->LoadAsynchronouly(request, this);
-    return;
-  }
-  AssertFallbackLoaderAvailability(request.Url(), default_loader_.get());
-  using_default_loader_ = true;
-  default_loader_->LoadAsynchronously(request, client);
+  DCHECK(factory_->IsMockedURL(request.Url()));
+  client_ = client;
+  factory_->LoadAsynchronouly(request, this);
 }
 
 void WebURLLoaderMock::Cancel() {
-  if (using_default_loader_ && default_loader_) {
-    default_loader_.reset();
-    return;
-  }
   client_ = nullptr;
   factory_->CancelLoad(this);
 }
 
 void WebURLLoaderMock::SetDefersLoading(bool deferred) {
   is_deferred_ = deferred;
-  if (using_default_loader_) {
-    default_loader_->SetDefersLoading(deferred);
-    return;
-  }
-
   // Ignores setDefersLoading(false) safely.
   if (!deferred)
     return;

third_party/blink/renderer/platform/testing/weburl_loader_mock.h

@@ -29,9 +29,7 @@ const uint32_t kRedirectResponseOverheadBytes = 300;
 // forwards it to the default loader.
 class WebURLLoaderMock : public WebURLLoader {
  public:
-  // This object becomes the owner of |default_loader|.
-  WebURLLoaderMock(WebURLLoaderMockFactoryImpl* factory,
-                   std::unique_ptr<WebURLLoader> default_loader);
+  explicit WebURLLoaderMock(WebURLLoaderMockFactoryImpl* factory);
   ~WebURLLoaderMock() override;
 
   // Simulates the asynchronous request being served.
@@ -70,8 +68,6 @@ class WebURLLoaderMock : public WebURLLoader {
 
   WebURLLoaderMockFactoryImpl* factory_ = nullptr;
   WebURLLoaderClient* client_ = nullptr;
-  std::unique_ptr<WebURLLoader> default_loader_;
-  bool using_default_loader_ = false;
   bool is_deferred_ = false;
 
   base::WeakPtrFactory<WebURLLoaderMock> weak_factory_{this};

third_party/blink/renderer/platform/testing/weburl_loader_mock_factory_impl.cc

@@ -39,9 +39,8 @@ WebURLLoaderMockFactoryImpl::WebURLLoaderMockFactoryImpl(
 
 WebURLLoaderMockFactoryImpl::~WebURLLoaderMockFactoryImpl() = default;
 
-std::unique_ptr<WebURLLoader> WebURLLoaderMockFactoryImpl::CreateURLLoader(
-    std::unique_ptr<WebURLLoader> default_loader) {
-  return std::make_unique<WebURLLoaderMock>(this, std::move(default_loader));
+std::unique_ptr<WebURLLoader> WebURLLoaderMockFactoryImpl::CreateURLLoader() {
+  return std::make_unique<WebURLLoaderMock>(this);
 }
 
 void WebURLLoaderMockFactoryImpl::RegisterURL(const WebURL& url,

third_party/blink/renderer/platform/testing/weburl_loader_mock_factory_impl.h

@@ -35,8 +35,7 @@ class WebURLLoaderMockFactoryImpl : public WebURLLoaderMockFactory {
   ~WebURLLoaderMockFactoryImpl() override;
 
   // WebURLLoaderMockFactory:
-  std::unique_ptr<WebURLLoader> CreateURLLoader(
-      std::unique_ptr<WebURLLoader> default_loader) override;
+  std::unique_ptr<WebURLLoader> CreateURLLoader() override;
   void RegisterURL(const WebURL& url,
                    const WebURLResponse& response,
                    const WebString& file_path = WebString()) override;