Make Resource RefCountedWillBeGarbageCollectedFinalized, attempt #2

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 14 matching lines @@
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/fetch/ResourceLoader.h"
 
 #include "core/fetch/CSSStyleSheetResource.h"
 #include "core/fetch/Resource.h"
 #include "core/fetch/ResourceFetcher.h"
-#include "core/fetch/ResourcePtr.h"
 #include "platform/Logging.h"
 #include "platform/SharedBuffer.h"
 #include "platform/ThreadedDataReceiver.h"
 #include "platform/exported/WrappedResourceRequest.h"
 #include "platform/exported/WrappedResourceResponse.h"
 #include "platform/network/ResourceError.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebData.h"
 #include "public/platform/WebThreadedDataReceiver.h"
 #include "public/platform/WebURLError.h"
@@ skipping 46 matching lines @@
 }
 
 void ResourceLoader::releaseResources()
 {
     ASSERT(m_state != Terminated);
     ASSERT(m_notifiedLoadComplete);
     m_fetcher->didLoadResource(m_resource.get());
     if (m_state == Terminated)
         return;
     m_resource->clearLoader();
-    m_resource->deleteIfPossible();
     m_resource = nullptr;
 
     ASSERT(m_state != Terminated);
 
     m_state = Terminated;
     if (m_loader) {
         m_loader->cancel();
         m_loader.clear();
     }
     m_deferredRequest = ResourceRequest();
@@ skipping 12 matching lines @@
     ASSERT(m_state != Terminated);
     m_fetcher->didInitializeResourceLoader(this);
 }
 
 void ResourceLoader::start()
 {
     ASSERT(!m_loader);
     ASSERT(!m_request.isNull());
     ASSERT(m_deferredRequest.isNull());
 
-    m_fetcher->willStartLoadingResource(m_resource, m_request);
+    m_fetcher->willStartLoadingResource(m_resource.get(), m_request);
 
     if (m_options.synchronousPolicy == RequestSynchronously) {
         requestSynchronously();
         return;
     }
 
     if (m_defersLoading) {
         m_deferredRequest = m_request;
         return;
     }
@@ skipping 43 matching lines @@
         WebThreadedDataReceiver* webDataReceiver = new WebThreadedDataReceiver(threadedDataReceiver);
         if (!m_loader->attachThreadedDataReceiver(webDataReceiver))
             delete webDataReceiver;
     }
 }
 
 void ResourceLoader::didDownloadData(WebURLLoader*, int length, int encodedDataLength)
 {
     ASSERT(m_state != Terminated);
     RELEASE_ASSERT(m_connectionState == ConnectionStateReceivedResponse);
-    m_fetcher->didDownloadData(m_resource, length, encodedDataLength);
+    m_fetcher->didDownloadData(m_resource.get(), length, encodedDataLength);
     if (m_state == Terminated)
         return;
     m_resource->didDownloadData(length);
 }
 
 void ResourceLoader::didFinishLoadingOnePart(double finishTime, int64_t encodedDataLength)
 {
     // If load has been cancelled after finishing (which could happen with a
     // JavaScript that changes the window location), do nothing.
     if (m_state == Terminated)
         return;
 
     if (m_notifiedLoadComplete)
         return;
     m_notifiedLoadComplete = true;
-    m_fetcher->didFinishLoading(m_resource, finishTime, encodedDataLength);
+    m_fetcher->didFinishLoading(m_resource.get(), finishTime, encodedDataLength);
 }
 
 void ResourceLoader::didChangePriority(ResourceLoadPriority loadPriority, int intraPriorityValue)
 {
     ASSERT(m_state != Terminated);
     if (m_loader)
         m_loader->didChangePriority(static_cast<WebURLRequest::Priority>(loadPriority), intraPriorityValue);
 }
 
 void ResourceLoader::cancelIfNotFinishing()
@@ skipping 26 matching lines @@
     m_resource->setResourceError(nonNullError);
 
     if (m_loader) {
         m_connectionState = ConnectionStateCanceled;
         m_loader->cancel();
         m_loader.clear();
     }
 
     if (!m_notifiedLoadComplete) {
         m_notifiedLoadComplete = true;
-        m_fetcher->didFailLoading(m_resource, nonNullError);
+        m_fetcher->didFailLoading(m_resource.get(), nonNullError);
     }
 
     if (m_state == Finishing)
         m_resource->error(Resource::LoadError);
     if (m_state != Terminated)
         releaseResources();
 }
 
 void ResourceLoader::willFollowRedirect(WebURLLoader*, WebURLRequest& passedNewRequest, const WebURLResponse& passedRedirectResponse)
 {
     ASSERT(m_state != Terminated);
 
     ResourceRequest& newRequest(applyOptions(passedNewRequest.toMutableResourceRequest()));
 
     ASSERT(!newRequest.isNull());
     const ResourceResponse& redirectResponse(passedRedirectResponse.toResourceResponse());
     ASSERT(!redirectResponse.isNull());
     newRequest.setFollowedRedirect(true);
-    if (!isManualRedirectFetchRequest(m_resource->resourceRequest()) && !m_fetcher->canAccessRedirect(m_resource, newRequest, redirectResponse, m_options)) {
+    if (!isManualRedirectFetchRequest(m_resource->resourceRequest()) && !m_fetcher->canAccessRedirect(m_resource.get(), newRequest, redirectResponse, m_options)) {
         cancel(ResourceError::cancelledDueToAccessCheckError(newRequest.url()));
         return;
     }
     ASSERT(m_state != Terminated);
 
     applyOptions(newRequest); // canAccessRedirect() can modify m_options so we should re-apply it.
-    m_fetcher->redirectReceived(m_resource, redirectResponse);
+    m_fetcher->redirectReceived(m_resource.get(), redirectResponse);
     ASSERT(m_state != Terminated);
     m_resource->willFollowRedirect(newRequest, redirectResponse);
     if (newRequest.isNull() || m_state == Terminated)
         return;
 
     m_fetcher->willSendRequest(m_resource->identifier(), newRequest, redirectResponse, m_options.initiatorInfo);
     ASSERT(m_state != Terminated);
     ASSERT(!newRequest.isNull());
     m_resource->updateRequest(newRequest);
     m_request = newRequest;
@@ skipping 41 matching lines @@
                 m_connectionState = ConnectionStateStarted;
                 m_loader = adoptPtr(Platform::current()->createURLLoader());
                 ASSERT(m_loader);
                 ASSERT(!m_request.skipServiceWorker());
                 m_request.setSkipServiceWorker(true);
                 WrappedResourceRequest wrappedRequest(m_request);
                 m_loader->loadAsynchronously(wrappedRequest, this);
                 return;
             }
         } else {
-            // If the response successfully validated a cached resource, perform
-            // the access control with respect to it. Need to do this right here
-            // before the resource switches clients over to that validated resource.
-            Resource* resource = m_resource;
-            if (!resource->isCacheValidator() || resourceResponse.httpStatusCode() != 304)
+            if (!m_resource->isCacheValidator() || resourceResponse.httpStatusCode() != 304)
                 m_resource->setResponse(resourceResponse);
-            if (!m_fetcher->canAccessResource(resource, m_options.securityOrigin.get(), response.url(), ResourceFetcher::ShouldLogAccessControlErrors)) {
-                m_fetcher->didReceiveResponse(m_resource, resourceResponse);
+            if (!m_fetcher->canAccessResource(m_resource.get(), m_options.securityOrigin.get(), response.url(), ResourceFetcher::ShouldLogAccessControlErrors)) {
+                m_fetcher->didReceiveResponse(m_resource.get(), resourceResponse);
                 cancel(ResourceError::cancelledDueToAccessCheckError(KURL(response.url())));
                 return;
             }
         }
     }
 
     m_resource->responseReceived(resourceResponse, handle.release());
     if (m_state == Terminated)
         return;
 
-    m_fetcher->didReceiveResponse(m_resource, resourceResponse);
+    m_fetcher->didReceiveResponse(m_resource.get(), resourceResponse);
     if (m_state == Terminated)
         return;
 
     if (response.toResourceResponse().isMultipart()) {
         // We only support multipart for images, though the image may be loaded
         // as a main resource that we end up displaying through an ImageDocument.
         if (!m_resource->isImage() && m_resource->type() != Resource::MainResource) {
             cancel();
             return;
         }
         m_loadingMultipartContent = true;
     } else if (isMultipartPayload) {
         // Since a subresource loader does not load multipart sections progressively, data was delivered to the loader all at once.
         // After the first multipart section is complete, signal to delegates that this load is "finished"
         m_fetcher->subresourceLoaderFinishedLoadingOnePart(this);
         didFinishLoadingOnePart(0, WebURLLoaderClient::kUnknownEncodedDataLength);
     }
     if (m_state == Terminated)
         return;
 
     if (m_resource->response().httpStatusCode() < 400 || m_resource->shouldIgnoreHTTPStatusCodeErrors())
         return;
     m_state = Finishing;
 
     if (!m_notifiedLoadComplete) {
         m_notifiedLoadComplete = true;
-        m_fetcher->didFailLoading(m_resource, ResourceError::cancelledError(m_request.url()));
+        m_fetcher->didFailLoading(m_resource.get(), ResourceError::cancelledError(m_request.url()));
     }
 
     ASSERT(m_state != Terminated);
     m_resource->error(Resource::LoadError);
     cancel();
 }
 
 void ResourceLoader::didReceiveResponse(WebURLLoader* loader, const WebURLResponse& response)
 {
     didReceiveResponse(loader, response, nullptr);
 }
 
 void ResourceLoader::didReceiveData(WebURLLoader*, const char* data, int length, int encodedDataLength)
 {
     ASSERT(m_state != Terminated);
     RELEASE_ASSERT(m_connectionState == ConnectionStateReceivedResponse || m_connectionState == ConnectionStateReceivingData);
     m_connectionState = ConnectionStateReceivingData;
 
     // It is possible to receive data on uninitialized resources if it had an error status code, and we are running a nested message
     // loop. When this occurs, ignoring the data is the correct action.
     if (m_resource->response().httpStatusCode() >= 400 && !m_resource->shouldIgnoreHTTPStatusCodeErrors())
         return;
     ASSERT(m_state == Initialized);
 
     // FIXME: If we get a resource with more than 2B bytes, this code won't do the right thing.
     // However, with today's computers and networking speeds, this won't happen in practice.
     // Could be an issue with a giant local file.
-    m_fetcher->didReceiveData(m_resource, data, length, encodedDataLength);
+    m_fetcher->didReceiveData(m_resource.get(), data, length, encodedDataLength);
     if (m_state == Terminated)
         return;
     RELEASE_ASSERT(length >= 0);
     m_resource->appendData(data, length);
 }
 
 void ResourceLoader::didFinishLoading(WebURLLoader*, double finishTime, int64_t encodedDataLength)
 {
     RELEASE_ASSERT(m_connectionState == ConnectionStateReceivedResponse || m_connectionState == ConnectionStateReceivingData);
     m_connectionState = ConnectionStateFinishedLoading;
     if (m_state != Initialized)
         return;
     ASSERT(m_state != Terminated);
     WTF_LOG(ResourceLoading, "Received '%s'.", m_resource->url().string().latin1().data());
 
-    ResourcePtr<Resource> protectResource(m_resource);
+    RefPtrWillBeRawPtr<Resource> protectResource(m_resource.get());
     m_state = Finishing;
     m_resource->setLoadFinishTime(finishTime);
     didFinishLoadingOnePart(finishTime, encodedDataLength);
     if (m_state == Terminated)
         return;
     m_resource->finish();
 
     // 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 == Terminated)
         return;
     releaseResources();
 }
 
 void ResourceLoader::didFail(WebURLLoader*, const WebURLError& error)
 {
     m_connectionState = ConnectionStateFailed;
     ASSERT(m_state != Terminated);
     WTF_LOG(ResourceLoading, "Failed to load '%s'.\n", m_resource->url().string().latin1().data());
 
-    ResourcePtr<Resource> protectResource(m_resource);
+    RefPtrWillBeRawPtr<Resource> protectResource(m_resource.get());
     m_state = Finishing;
     m_resource->setResourceError(error);
 
     if (!m_notifiedLoadComplete) {
         m_notifiedLoadComplete = true;
-        m_fetcher->didFailLoading(m_resource, error);
+        m_fetcher->didFailLoading(m_resource.get(), error);
     }
     if (m_state == Terminated)
         return;
 
     m_resource->error(Resource::LoadError);
 
     if (m_state == Terminated)
         return;
 
     releaseResources();
 }
 
 bool ResourceLoader::isLoadedBy(ResourceFetcher* loader) const
 {
     return m_fetcher->isLoadedBy(loader);
 }
 
 void ResourceLoader::requestSynchronously()
 {
     OwnPtr<WebURLLoader> loader = adoptPtr(Platform::current()->createURLLoader());
     ASSERT(loader);
 
     // downloadToFile is not supported for synchronous requests.
     ASSERT(!m_request.downloadToFile());
 
-    ResourcePtr<Resource> protectResource(m_resource);
+    RefPtrWillBeRawPtr<Resource> protectResource(m_resource.get());
 
     RELEASE_ASSERT(m_connectionState == ConnectionStateNew);
     m_connectionState = ConnectionStateStarted;
 
     WrappedResourceRequest requestIn(m_request);
     WebURLResponse responseOut;
     responseOut.initialize();
     WebURLError errorOut;
     WebData dataOut;
     loader->loadSynchronously(requestIn, responseOut, errorOut, dataOut);
@@ skipping 11 matching lines @@
     if (m_state == Terminated)
         return;
     RefPtr<ResourceLoadInfo> resourceLoadInfo = responseOut.toResourceResponse().resourceLoadInfo();
     int64_t encodedDataLength = resourceLoadInfo ? resourceLoadInfo->encodedDataLength : WebURLLoaderClient::kUnknownEncodedDataLength;
 
     // Follow the async case convention of not calling didReceiveData or
     // appending data to m_resource if the response body is empty. Copying the
     // 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, dataOut.data(), dataOut.size(), encodedDataLength);
+        m_fetcher->didReceiveData(m_resource.get(), dataOut.data(), dataOut.size(), encodedDataLength);
         m_resource->setResourceBuffer(dataOut);
     }
     didFinishLoading(0, monotonicallyIncreasingTime(), encodedDataLength);
 }
 
 ResourceRequest& ResourceLoader::applyOptions(ResourceRequest& request) const
 {
     request.setAllowStoredCredentials(m_options.allowCredentials == AllowStoredCredentials);
     return request;
 }
 
 } // namespace blink