Make WebURLLoaderMockFactoryImpl::createURLLoader accept nullptr

third_party/WebKit/Source/platform/testing/weburl_loader_mock.cc

 // Copyright 2016 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 "platform/testing/weburl_loader_mock.h"
 
 #include "platform/testing/weburl_loader_mock_factory_impl.h"
 #include "public/platform/URLConversion.h"
 #include "public/platform/WebData.h"
 #include "public/platform/WebURLError.h"
 #include "public/platform/WebURLLoaderClient.h"
 
 namespace blink {
 
+namespace {
+
+void assertFallbackLoaderAvailability(const WebURL& url,
+                                      const WebURLLoader* default_loader) {
+  DCHECK(KURL(url).protocolIsData()) << "shouldn't be falling back: "
+                                     << url.string().utf8();
+  DCHECK(default_loader) << "default_loader wasn't set: "
+                         << url.string().utf8();
+}
+
+}  // namespace
+
 WebURLLoaderMock::WebURLLoaderMock(WebURLLoaderMockFactoryImpl* factory,
                                    WebURLLoader* default_loader)
     : factory_(factory),
       default_loader_(WTF::wrapUnique(default_loader)),
       weak_factory_(this) {}
 
 WebURLLoaderMock::~WebURLLoaderMock() {
   cancel();
 }
 
@@ skipping 72 matching lines @@
                                          WebURLResponse& response,
                                          WebURLError& error,
                                          WebData& data,
                                          int64_t& encoded_data_length,
                                          int64_t& encoded_body_length) {
   if (factory_->IsMockedURL(request.url())) {
       factory_->LoadSynchronously(request, &response, &error, &data,
                                   &encoded_data_length);
     return;
   }
-  DCHECK(KURL(request.url()).protocolIsData())
-      << "loadSynchronously shouldn't be falling back: "
-      << request.url().string().utf8();
+  assertFallbackLoaderAvailability(request.url(), default_loader_.get());
   using_default_loader_ = true;
   default_loader_->loadSynchronously(request, response, error, data,
                                      encoded_data_length, encoded_body_length);
 }
 
 void WebURLLoaderMock::loadAsynchronously(const WebURLRequest& request,
                                           WebURLLoaderClient* client) {
   DCHECK(client);
   if (factory_->IsMockedURL(request.url())) {
     client_ = client;
     factory_->LoadAsynchronouly(request, this);
     return;
   }
-  DCHECK(KURL(request.url()).protocolIsData())
-      << "loadAsynchronously shouldn't be falling back: "
-      << request.url().string().utf8();
+  assertFallbackLoaderAvailability(request.url(), default_loader_.get());
   using_default_loader_ = true;
   default_loader_->loadAsynchronously(request, client);
 }
 
 void WebURLLoaderMock::cancel() {
   if (using_default_loader_) {
     default_loader_->cancel();
     return;
   }
   client_ = nullptr;
@@ skipping 20 matching lines @@
   // In principle this is NOTIMPLEMENTED(), but if we put that here it floods
   // the console during webkit unit tests, so we leave the function empty.
   DCHECK(runner);
 }
 
 WeakPtr<WebURLLoaderMock> WebURLLoaderMock::GetWeakPtr() {
   return weak_factory_.createWeakPtr();
 }
 
 } // namespace blink