Simplifying finishing a load on Resource

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 162 matching lines @@
         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;
-    m_resource->setResourceError(nonNullError);
 
     // 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.
     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(Resource::LoadError);
+        m_resource->error(nonNullError);
     if (m_state != ConnectionStateReleased)
         releaseResources();
 }
 
 void ResourceLoader::willFollowRedirect(WebURLLoader*, WebURLRequest& passedNewRequest, const WebURLResponse& passedRedirectResponse)
 {
     ASSERT(m_state != ConnectionStateReleased);
     ASSERT(!passedNewRequest.isNull());
     ASSERT(!passedRedirectResponse.isNull());
 
@@ skipping 66 matching lines @@
     m_resource->responseReceived(resourceResponse, handle.release());
     if (m_state == ConnectionStateReleased)
         return;
 
     m_fetcher->didReceiveResponse(m_resource.get(), resourceResponse);
     if (m_state == ConnectionStateReleased)
         return;
 
     if (m_resource->response().httpStatusCode() < 400 || m_resource->shouldIgnoreHTTPStatusCodeErrors())
         return;
-
-    if (!m_notifiedLoadComplete) {

[Nate Chapin, 2016/04/28 18:10:27]

This block is redundant with cancel()

-        m_notifiedLoadComplete = true;
-        m_fetcher->didFailLoading(m_resource.get(), ResourceError::cancelledError(resourceResponse.url()));
-    }
-
-    ASSERT(m_state != ConnectionStateReleased);
-    m_resource->error(Resource::LoadError);
     cancel(ResourceError::cancelledError(resourceResponse.url()));
 }
 
 void ResourceLoader::didReceiveResponse(WebURLLoader* loader, const WebURLResponse& response)
 {
     didReceiveResponse(loader, response, nullptr);
 }
 
 void ResourceLoader::didReceiveData(WebURLLoader*, const char* data, int length, int encodedDataLength)
 {
@@ skipping 14 matching lines @@
     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());
-
-    m_resource->setLoadFinishTime(finishTime);
     didFinishLoadingOnePart(finishTime, encodedDataLength);
     if (m_state == ConnectionStateReleased)
         return;
-    m_resource->finish();
+    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 != ConnectionStateReleased);
     m_state = ConnectionStateFailed;
     WTF_LOG(ResourceLoading, "Failed to load '%s'.\n", m_resource->url().getString().latin1().data());
-
-    m_resource->setResourceError(error);
-
     if (!m_notifiedLoadComplete) {
         m_notifiedLoadComplete = true;
         m_fetcher->didFailLoading(m_resource.get(), error);
     }
     if (m_state == ConnectionStateReleased)
         return;
 
-    m_resource->error(Resource::LoadError);
+    m_resource->error(error);
 
     if (m_state == ConnectionStateReleased)
         return;
 
     releaseResources();
 }
 
 void ResourceLoader::requestSynchronously(ResourceRequest& request)
 {
     // downloadToFile is not supported for synchronous requests.
@@ skipping 35 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