Clear Resource::m_loader in Resource::finish() and Resource::error()

third_party/WebKit/Source/core/fetch/ResourceLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2007 Graham Dennis (graham.dennis@gmail.com)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 60 matching lines @@
 {
     visitor->trace(m_fetcher);
     visitor->trace(m_resource);
 }
 
 void ResourceLoader::releaseResources()
 {
     ASSERT(m_state != ConnectionStateReleased);
     ASSERT(m_notifiedLoadComplete);
     m_fetcher->didLoadResource(m_resource.get());
-    if (m_state == ConnectionStateReleased)
-        return;
-    m_resource->clearLoader();
+    ASSERT(m_state != ConnectionStateReleased);
     m_resource = nullptr;
-
-    ASSERT(m_state != ConnectionStateReleased);
     m_state = ConnectionStateReleased;
     if (m_loader) {
         m_loader->cancel();
         m_loader.clear();
     }
     m_fetcher.clear();
 }
 
 void ResourceLoader::start(ResourceRequest& request)
 {
@@ skipping 25 matching lines @@
     RELEASE_ASSERT(m_state == ConnectionStateReceivedResponse);
     m_fetcher->didDownloadData(m_resource.get(), length, encodedDataLength);
     if (m_state == ConnectionStateReleased)
         return;
     m_resource->didDownloadData(length);
 }
 
 void ResourceLoader::didFinishLoadingOnePart(double finishTime, int64_t encodedDataLength)
 {
     ASSERT(m_state != ConnectionStateReleased);
-    if (isFinishing()) {
+    if (m_state == ConnectionStateFinishedLoading) {
         m_fetcher->removeResourceLoader(this);
     } else {
         // When loading a multipart resource, make the loader non-block when
         // finishing loading the first part.
         m_fetcher->moveResourceLoaderToNonBlocking(this);
 
         m_fetcher->didLoadResource(m_resource.get());
         if (m_state == ConnectionStateReleased)
             return;
     }
 
     if (m_notifiedLoadComplete)
         return;
     m_notifiedLoadComplete = true;
     m_fetcher->didFinishLoading(m_resource.get(), finishTime, encodedDataLength);
 }
 
 void ResourceLoader::didChangePriority(ResourceLoadPriority loadPriority, int intraPriorityValue)
 {
     ASSERT(m_state != ConnectionStateReleased);
     if (m_loader)
         m_loader->didChangePriority(static_cast<WebURLRequest::Priority>(loadPriority), intraPriorityValue);
 }
 
-void ResourceLoader::cancelIfNotFinishing()
-{
-    if (isFinishing())
-        return;
-    cancel();
-}
-
 void ResourceLoader::cancel()
 {
     cancel(ResourceError());
 }
 
 void ResourceLoader::cancel(const ResourceError& error)
 {
-    // If the load has already completed - succeeded, failed, or previously cancelled - do nothing.
-    if (m_state == ConnectionStateReleased)
-        return;
-    if (isFinishing()) {
-        releaseResources();
-        return;
-    }
-
-    ResourceError nonNullError = error.isNull() ? ResourceError::cancelledError(m_resource->lastResourceRequest().url()) : error;
-
-    WTF_LOG(ResourceLoading, "Cancelled load of '%s'.\n", m_resource->url().getString().latin1().data());
-    m_state = ConnectionStateCanceled;
+    ASSERT(m_state != ConnectionStateFinishedLoading);
+    ASSERT(m_state != ConnectionStateReleased);
 
     // If we don't immediately clear m_loader when cancelling, we might get
     // unexpected reentrancy. m_resource->error() can trigger JS events, which
     // could start a modal dialog. Normally, a modal dialog would defer loading
     // and prevent receiving messages for a cancelled ResourceLoader, but
     // m_fetcher->didFailLoading() severs the connection by which all of a
     // page's loads are deferred. A response can then arrive, see m_state
-    // is ConnectionStateCanceled, and ASSERT or break in other ways.
+    // is ConnectionStateFinishedLoading, and ASSERT or break in other ways.
     if (m_loader) {
         m_loader->cancel();
         m_loader.clear();
     }
-
-    if (!m_notifiedLoadComplete) {
-        m_notifiedLoadComplete = true;
-        m_fetcher->didFailLoading(m_resource.get(), nonNullError);
-    }
-
-    if (m_state != ConnectionStateReleased)
-        m_resource->error(nonNullError);
-    if (m_state != ConnectionStateReleased)
-        releaseResources();
+    didFail(nullptr, error.isNull() ? ResourceError::cancelledError(m_resource->lastResourceRequest().url()) : error);
 }
 
 void ResourceLoader::willFollowRedirect(WebURLLoader*, WebURLRequest& passedNewRequest, const WebURLResponse& passedRedirectResponse)
 {
     ASSERT(m_state != ConnectionStateReleased);
     ASSERT(!passedNewRequest.isNull());
     ASSERT(!passedRedirectResponse.isNull());
 
     ResourceRequest& newRequest(passedNewRequest.toMutableResourceRequest());
     const ResourceResponse& redirectResponse(passedRedirectResponse.toResourceResponse());
     newRequest.setFollowedRedirect(true);
 
     if (m_fetcher->willFollowRedirect(m_resource.get(), newRequest, redirectResponse)) {
         m_resource->willFollowRedirect(newRequest, redirectResponse);
     } else {
         m_resource->willNotFollowRedirect();
-        cancel(ResourceError::cancelledDueToAccessCheckError(newRequest.url()));
+        if (m_state != ConnectionStateReleased)
+            cancel(ResourceError::cancelledDueToAccessCheckError(newRequest.url()));
     }
 }
 
 void ResourceLoader::didReceiveCachedMetadata(WebURLLoader*, const char* data, int length)
 {
     RELEASE_ASSERT(m_state == ConnectionStateReceivedResponse || m_state == ConnectionStateReceivingData);
     m_resource->setSerializedCachedMetadata(data, length);
 }
 
 void ResourceLoader::didSendData(WebURLLoader*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
@@ skipping 77 matching lines @@
     // Could be an issue with a giant local file.
     m_fetcher->didReceiveData(m_resource.get(), data, length, encodedDataLength);
     if (m_state == ConnectionStateReleased)
         return;
     RELEASE_ASSERT(length >= 0);
     m_resource->appendData(data, length);
 }
 
 void ResourceLoader::didFinishLoading(WebURLLoader*, double finishTime, int64_t encodedDataLength)
 {
-
     RELEASE_ASSERT(m_state == ConnectionStateReceivedResponse || m_state == ConnectionStateReceivingData);
     m_state = ConnectionStateFinishedLoading;
-    WTF_LOG(ResourceLoading, "Received '%s'.", m_resource->url().getString().latin1().data());
     didFinishLoadingOnePart(finishTime, encodedDataLength);
-    if (m_state == ConnectionStateReleased)
-        return;
+    ASSERT(m_state != ConnectionStateReleased);
     m_resource->finish(finishTime);
-
-    // If the load has been cancelled by a delegate in response to didFinishLoad(), do not release
-    // the resources a second time, they have been released by cancel.
-    if (m_state == ConnectionStateReleased)
-        return;
     releaseResources();
 }
 
 void ResourceLoader::didFail(WebURLLoader*, const WebURLError& error)
 {
-
+    ASSERT(m_state != ConnectionStateFinishedLoading);
     ASSERT(m_state != ConnectionStateReleased);
-    m_state = ConnectionStateFailed;
-    WTF_LOG(ResourceLoading, "Failed to load '%s'.\n", m_resource->url().getString().latin1().data());
-    if (!m_notifiedLoadComplete) {
-        m_notifiedLoadComplete = true;
-        m_fetcher->didFailLoading(m_resource.get(), error);
-    }
-    if (m_state == ConnectionStateReleased)
-        return;
-
+    m_state = ConnectionStateFinishedLoading;
+    m_notifiedLoadComplete = true;
+    m_fetcher->didFailLoading(m_resource.get(), error);
+    ASSERT(m_state != ConnectionStateReleased);
     m_resource->error(error);
-
-    if (m_state == ConnectionStateReleased)
-        return;
-
     releaseResources();
 }
 
 void ResourceLoader::requestSynchronously(ResourceRequest& request)
 {
     // downloadToFile is not supported for synchronous requests.
     ASSERT(!request.downloadToFile());
     ASSERT(m_loader);
 
     // Synchronous requests should always be max priority, lest they hang the renderer.
@@ skipping 31 matching lines @@
     // empty buffer is a noop in most cases, but is destructive in the case of
     // a 304, where it will overwrite the cached data we should be reusing.
     if (dataOut.size()) {
         m_fetcher->didReceiveData(m_resource.get(), dataOut.data(), dataOut.size(), encodedDataLength);
         m_resource->setResourceBuffer(dataOut);
     }
     didFinishLoading(0, monotonicallyIncreasingTime(), encodedDataLength);
 }
 
 } // namespace blink