Make WebURLLoaderMockFactoryImpl::createURLLoader accept nullptr

third_party/WebKit/Source/platform/testing/WebURLLoaderMock.cpp

 // 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/WebURLLoaderMock.h"
 
 #include "platform/testing/WebURLLoaderMockFactoryImpl.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 IsFallbackLoaderAvailable(const WebURL& url,

[kinuko, 2017/01/25 12:42:13]

I'd name this 'assertFallbackLoaderAvailability()'

[Takashi Toyoshima, 2017/01/26 11:54:24]

Done.

+                               const WebURLLoader* defaultLoader) {
+  DCHECK(KURL(url).protocolIsData()) << "shouldn't be falling back: "
+                                     << url.string().utf8();
+  DCHECK(defaultLoader) << "defaultLoader wasn't set: " << url.string().utf8();
+}
+
+}  // namespace
+
 WebURLLoaderMock::WebURLLoaderMock(WebURLLoaderMockFactoryImpl* factory,
                                    WebURLLoader* defaultLoader)
     : m_factory(factory),
       m_defaultLoader(WTF::wrapUnique(defaultLoader)),
       m_weakFactory(this) {}
 
 WebURLLoaderMock::~WebURLLoaderMock() {
   cancel();
 }
 
@@ skipping 72 matching lines @@
                                          WebURLResponse& response,
                                          WebURLError& error,
                                          WebData& data,
                                          int64_t& encodedDataLength,
                                          int64_t& encodedBodyLength) {
   if (m_factory->IsMockedURL(request.url())) {
     m_factory->LoadSynchronously(request, &response, &error, &data,
                                  &encodedDataLength);
     return;
   }
-  DCHECK(KURL(request.url()).protocolIsData())
-      << "loadSynchronously shouldn't be falling back: "
-      << request.url().string().utf8();
+  IsFallbackLoaderAvailable(request.url(), m_defaultLoader.get());
   m_usingDefaultLoader = true;
   m_defaultLoader->loadSynchronously(request, response, error, data,
                                      encodedDataLength, encodedBodyLength);
 }
 
 void WebURLLoaderMock::loadAsynchronously(const WebURLRequest& request,
                                           WebURLLoaderClient* client) {
   DCHECK(client);
   if (m_factory->IsMockedURL(request.url())) {
     m_client = client;
     m_factory->LoadAsynchronouly(request, this);
     return;
   }
-  DCHECK(KURL(request.url()).protocolIsData())
-      << "loadAsynchronously shouldn't be falling back: "
-      << request.url().string().utf8();
+  IsFallbackLoaderAvailable(request.url(), m_defaultLoader.get());
   m_usingDefaultLoader = true;
   m_defaultLoader->loadAsynchronously(request, client);
 }
 
 void WebURLLoaderMock::cancel() {
   if (m_usingDefaultLoader) {
     m_defaultLoader->cancel();
     return;
   }
   m_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 m_weakFactory.createWeakPtr();
 }
 
 }  // namespace blink