Remove cancelWithError() from DocumentThreadableLoader

third_party/WebKit/Source/core/loader/DocumentThreadableLoader.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 304 matching lines @@
   DCHECK(!resource());
 
   // Cross-origin requests are only allowed certain registered schemes. We would
   // catch this when checking response headers later, but there is no reason to
   // send a request, preflighted or not, that's guaranteed to be denied.
   if (!SchemeRegistry::shouldTreatURLSchemeAsCORSEnabled(
           request.url().protocol())) {
     InspectorInstrumentation::
         documentThreadableLoaderFailedToStartLoadingForClient(m_document,
                                                               m_client);
-    ThreadableLoaderClient* client = m_client;
-    clear();
-    client->didFailAccessControlCheck(ResourceError(
+    dispatchDidFailAccessControlCheck(ResourceError(
         errorDomainBlinkInternal, 0, request.url().getString(),
         "Cross origin requests are only supported for protocol schemes: " +
             SchemeRegistry::listOfCORSEnabledURLSchemes() + "."));
     return;
   }
 
   // Non-secure origins may not make "external requests":
   // https://mikewest.github.io/cors-rfc1918/#integration-fetch
   if (!document().isSecureContext() && request.isExternalRequest()) {
-    ThreadableLoaderClient* client = m_client;
-    clear();
-    client->didFailAccessControlCheck(
+    dispatchDidFailAccessControlCheck(
         ResourceError(errorDomainBlinkInternal, 0, request.url().getString(),
                       "Requests to internal network resources are not allowed "
                       "from non-secure contexts (see https://goo.gl/Y0ZkNV). "
                       "This is an experimental restriction which is part of "
                       "'https://mikewest.github.io/cors-rfc1918/'."));
     return;
   }
 
   ResourceRequest crossOriginRequest(request);
   ResourceLoaderOptions crossOriginOptions(m_resourceLoaderOptions);
@@ skipping 82 matching lines @@
   if (timeoutMilliseconds) {
     double elapsedTime =
         monotonicallyIncreasingTime() - m_requestStartedSeconds;
     double nextFire = timeoutMilliseconds / 1000.0;
     double resolvedTime = std::max(nextFire - elapsedTime, 0.0);
     m_timeoutTimer.startOneShot(resolvedTime, BLINK_FROM_HERE);
   }
 }
 
 void DocumentThreadableLoader::cancel() {
-  cancelWithError(ResourceError());
-}
-
-void DocumentThreadableLoader::cancelWithError(const ResourceError& error) {
-  // Cancel can re-enter and m_resource might be null here as a result.
+  // Cancel can re-enter, and therefore |resource()| might be null here as a
+  // result.
   if (!m_client || !resource()) {
     clear();
     return;
   }
 
-  ResourceError errorForCallback = error;
-  if (errorForCallback.isNull()) {
-    // FIXME: This error is sent to the client in didFail(), so it should not be
-    // an internal one. Use FrameLoaderClient::cancelledError() instead.
-    errorForCallback =
-        ResourceError(errorDomainBlinkInternal, 0,
-                      resource()->url().getString(), "Load cancelled");
-    errorForCallback.setIsCancellation(true);
-  }
+  // FIXME: This error is sent to the client in didFail(), so it should not be
+  // an internal one. Use FrameLoaderClient::cancelledError() instead.
+  ResourceError error(errorDomainBlinkInternal, 0, resource()->url(),
+                      "Load cancelled");
+  error.setIsCancellation(true);
 
-  ThreadableLoaderClient* client = m_client;
-  clear();
-  client->didFail(errorForCallback);
+  dispatchDidFail(error);
 }
 
 void DocumentThreadableLoader::setDefersLoading(bool value) {
   if (resource())
     resource()->setDefersLoading(value);
 }
 
 void DocumentThreadableLoader::clear() {
   m_client = nullptr;
   m_timeoutTimer.stop();
@@ skipping 98 matching lines @@
     // request was not same-origin.
     accessControlErrorDescription =
         "Redirect from '" + redirectResponse.url().getString() + "' to '" +
         request.url().getString() + "' has been blocked by CORS policy: " +
         accessControlErrorDescription;
   } else {
     allowRedirect = true;
   }
 
   if (!allowRedirect) {
-    ThreadableLoaderClient* client = m_client;
-    clear();
-    client->didFailAccessControlCheck(ResourceError(
+    dispatchDidFailAccessControlCheck(ResourceError(
         errorDomainBlinkInternal, 0, redirectResponse.url().getString(),
         accessControlErrorDescription));
     return false;
   }
 
   m_client->didReceiveRedirectTo(request.url());
 
   // FIXME: consider combining this with CORS redirect handling performed by
   // CrossOriginAccessControl::handleRedirect().
   clearResource();
@@ skipping 206 matching lines @@
   m_fallbackRequestForServiceWorker = ResourceRequest();
 
   if (!m_sameOriginRequest &&
       m_options.crossOriginRequestPolicy == UseAccessControl) {
     String accessControlErrorDescription;
     if (!passesAccessControlCheck(
             response, effectiveAllowCredentials(), getSecurityOrigin(),
             accessControlErrorDescription, m_requestContext)) {
       reportResponseReceived(identifier, response);
 
-      ThreadableLoaderClient* client = m_client;
-      clear();
-      client->didFailAccessControlCheck(
+      dispatchDidFailAccessControlCheck(
           ResourceError(errorDomainBlinkInternal, 0, response.url().getString(),
                         accessControlErrorDescription));
       return;
     }
   }
 
   m_client->didReceiveResponse(identifier, response, std::move(handle));
 }
 
 void DocumentThreadableLoader::setSerializedCachedMetadata(Resource*,
@@ skipping 36 matching lines @@
 }
 
 void DocumentThreadableLoader::notifyFinished(Resource* resource) {
   DCHECK(m_client);
   DCHECK_EQ(resource, this->resource());
   DCHECK(m_async);
 
   m_checker.notifyFinished(resource);
 
   if (resource->errorOccurred()) {
-    handleError(resource->resourceError());
+    dispatchDidFail(resource->resourceError());
   } else {
     handleSuccessfulFinish(resource->identifier(), resource->loadFinishTime());
   }
 }
 
 void DocumentThreadableLoader::handleSuccessfulFinish(unsigned long identifier,
                                                       double finishTime) {
   DCHECK(m_fallbackRequestForServiceWorker.isNull());
 
   if (!m_actualRequest.isNull()) {
     // FIXME: Timeout should be applied to whole fetch, not for each of
     // preflight and actual request.
     m_timeoutTimer.stop();
     DCHECK(!m_sameOriginRequest);
     DCHECK_EQ(m_options.crossOriginRequestPolicy, UseAccessControl);
     loadActualRequest();
     return;
   }
 
   ThreadableLoaderClient* client = m_client;
   // Protect the resource in |didFinishLoading| in order not to release the
   // downloaded file.
   Persistent<Resource> protect = resource();
   clear();
   client->didFinishLoading(identifier, finishTime);
 }
 
 void DocumentThreadableLoader::didTimeout(TimerBase* timer) {
+  DCHECK(m_async);
   DCHECK_EQ(timer, &m_timeoutTimer);
+  // clearResource() may be called in clear() and some other places. clear()
+  // calls stop() on |m_timeoutTimer|. In the other places, the resource is set
+  // again. If the creation fails, clear() is called. So, here, resource() is
+  // always non-nullptr.
+  DCHECK(resource());
+  // When |m_client| is set to nullptr only in clear() where |m_timeoutTimer|
+  // is stopped. So, |m_client| is always non-nullptr here.
+  DCHECK(m_client);
 
   // Using values from net/base/net_error_list.h ERR_TIMED_OUT, Same as existing
   // FIXME above - this error should be coming from FrameLoaderClient to be
   // identifiable.
   static const int timeoutError = -7;
   ResourceError error("net", timeoutError, resource()->url(), String());
   error.setIsTimeout(true);
-  cancelWithError(error);
+
+  dispatchDidFail(error);
 }
 
 void DocumentThreadableLoader::loadFallbackRequestForServiceWorker() {
   clearResource();
   ResourceRequest fallbackRequest(m_fallbackRequestForServiceWorker);
   m_fallbackRequestForServiceWorker = ResourceRequest();
   dispatchInitialRequest(fallbackRequest);
 }
 
 void DocumentThreadableLoader::loadActualRequest() {
@@ skipping 15 matching lines @@
 }
 
 void DocumentThreadableLoader::handlePreflightFailure(
     const String& url,
     const String& errorDescription) {
   ResourceError error(errorDomainBlinkInternal, 0, url, errorDescription);
 
   // Prevent handleSuccessfulFinish() from bypassing access check.
   m_actualRequest = ResourceRequest();
 
+  dispatchDidFailAccessControlCheck(error);
+}
+
+void DocumentThreadableLoader::dispatchDidFailAccessControlCheck(
+    const ResourceError& error) {
   ThreadableLoaderClient* client = m_client;
   clear();
   client->didFailAccessControlCheck(error);
 }
 
-void DocumentThreadableLoader::handleError(const ResourceError& error) {
+void DocumentThreadableLoader::dispatchDidFail(const ResourceError& error) {
   ThreadableLoaderClient* client = m_client;
   clear();
   client->didFail(error);
 }
 
 void DocumentThreadableLoader::loadRequestAsync(
     const ResourceRequest& request,
     ResourceLoaderOptions resourceLoaderOptions) {
   if (!m_actualRequest.isNull())
     resourceLoaderOptions.dataBufferingPolicy = BufferData;
@@ skipping 156 matching lines @@
 }
 
 DEFINE_TRACE(DocumentThreadableLoader) {
   visitor->trace(m_resource);
   visitor->trace(m_document);
   ThreadableLoader::trace(visitor);
   RawResourceClient::trace(visitor);
 }
 
 }  // namespace blink