[Oilpan] [Reland] Migrate classes under core/fetch to Oilpan heap

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 33 matching lines @@
 #include "public/platform/WebData.h"
 #include "public/platform/WebThreadedDataReceiver.h"
 #include "public/platform/WebURLError.h"
 #include "public/platform/WebURLRequest.h"
 #include "public/platform/WebURLResponse.h"
 #include "wtf/Assertions.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
-PassRefPtrWillBeRawPtr<ResourceLoader> ResourceLoader::create(ResourceFetcher* fetcher, Resource* resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
+ResourceLoader* ResourceLoader::create(ResourceFetcher* fetcher, Resource* resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
 {
-    RefPtrWillBeRawPtr<ResourceLoader> loader(adoptRefWillBeNoop(new ResourceLoader(fetcher, resource, options)));
+    ResourceLoader* loader = new ResourceLoader(fetcher, resource, options);
     loader->init(request);
-    return loader.release();
+    return loader;
 }
 
 ResourceLoader::ResourceLoader(ResourceFetcher* fetcher, Resource* resource, const ResourceLoaderOptions& options)
     : m_fetcher(fetcher)
     , m_notifiedLoadComplete(false)
     , m_defersLoading(fetcher->defersLoading())
     , m_loadingMultipartContent(false)
     , m_options(options)
     , m_resource(resource)
     , m_state(Initialized)
@@ skipping 113 matching lines @@
         // attached.
         WebThreadedDataReceiver* webDataReceiver = new WebThreadedDataReceiver(threadedDataReceiver);
         if (!m_loader->attachThreadedDataReceiver(webDataReceiver))
             delete webDataReceiver;
     }
 }
 
 void ResourceLoader::didDownloadData(WebURLLoader*, int length, int encodedDataLength)
 {
     ASSERT(m_state != Terminated);
-    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     RELEASE_ASSERT(m_connectionState == ConnectionStateReceivedResponse);
     m_fetcher->didDownloadData(m_resource, 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
@@ skipping 33 matching lines @@
     // If the load has already completed - succeeded, failed, or previously cancelled - do nothing.
     if (m_state == Terminated)
         return;
     if (m_state == Finishing) {
         releaseResources();
         return;
     }
 
     ResourceError nonNullError = error.isNull() ? ResourceError::cancelledError(m_request.url()) : error;
 
-    // This function calls out to clients at several points that might do
-    // something that causes the last reference to this object to go away.
-    RefPtrWillBeRawPtr<ResourceLoader> protector(this);
-
     WTF_LOG(ResourceLoading, "Cancelled load of '%s'.\n", m_resource->url().string().latin1().data());
     if (m_state == Initialized)
         m_state = Finishing;
     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);
     }
 
     if (m_state == Finishing)
         m_resource->error(Resource::LoadError);
     if (m_state != Terminated)
         releaseResources();
 }
 
 void ResourceLoader::willSendRequest(WebURLLoader*, WebURLRequest& passedNewRequest, const WebURLResponse& passedRedirectResponse)
 {
     ASSERT(m_state != Terminated);
-    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
 
     ResourceRequest& newRequest(applyOptions(passedNewRequest.toMutableResourceRequest()));
 
     ASSERT(!newRequest.isNull());
     const ResourceResponse& redirectResponse(passedRedirectResponse.toResourceResponse());
     ASSERT(!redirectResponse.isNull());
     newRequest.setFollowedRedirect(true);
     if (!m_fetcher->canAccessRedirect(m_resource, newRequest, redirectResponse, m_options)) {
         cancel(ResourceError::cancelledDueToAccessCheckError(newRequest.url()));
         return;
@@ skipping 72 matching lines @@
             else
                 m_resource->setResponse(resourceResponse);
             if (!m_fetcher->canAccessResource(resource, m_options.securityOrigin.get(), response.url(), ResourceFetcher::ShouldLogAccessControlErrors)) {
                 m_fetcher->didReceiveResponse(m_resource, resourceResponse);
                 cancel(ResourceError::cancelledDueToAccessCheckError(KURL(response.url())));
                 return;
             }
         }
     }
 
-    // Reference the object in this method since the additional processing can do
-    // anything including removing the last reference to this object.
-    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     m_resource->responseReceived(resourceResponse, handle.release());
     if (m_state == Terminated)
         return;
 
     m_fetcher->didReceiveResponse(m_resource, resourceResponse);
     if (m_state == Terminated)
         return;
 
     if (response.toResourceResponse().isMultipart()) {
         // We only support multipart for images, though the image may be loaded
@@ skipping 36 matching lines @@
     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);
 
-    // Reference the object in this method since the additional processing can do
-    // anything including removing the last reference to this object.
-    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
-
     // 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);
     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());
 
-    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     ResourcePtr<Resource> protectResource(m_resource);
     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());
 
-    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
-    RefPtrWillBeRawPtr<ResourceFetcher> protectFetcher(m_fetcher.get());
     ResourcePtr<Resource> protectResource(m_resource);
     m_state = Finishing;
     m_resource->setResourceError(error);
 
     if (!m_notifiedLoadComplete) {
         m_notifiedLoadComplete = true;
         m_fetcher->didFailLoading(m_resource, error);
     }
     if (m_state == Terminated)
         return;
@@ skipping 12 matching lines @@
 }
 
 void ResourceLoader::requestSynchronously()
 {
     OwnPtr<WebURLLoader> loader = adoptPtr(Platform::current()->createURLLoader());
     ASSERT(loader);
 
     // downloadToFile is not supported for synchronous requests.
     ASSERT(!m_request.downloadToFile());
 
-    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
-    RefPtrWillBeRawPtr<ResourceFetcher> protectFetcher(m_fetcher.get());
     ResourcePtr<Resource> protectResource(m_resource);
 
     RELEASE_ASSERT(m_connectionState == ConnectionStateNew);
     m_connectionState = ConnectionStateStarted;
 
     WrappedResourceRequest requestIn(m_request);
     WebURLResponse responseOut;
     responseOut.initialize();
     WebURLError errorOut;
     WebData dataOut;
@@ skipping 18 matching lines @@
     didFinishLoading(0, monotonicallyIncreasingTime(), encodedDataLength);
 }
 
 ResourceRequest& ResourceLoader::applyOptions(ResourceRequest& request) const
 {
     request.setAllowStoredCredentials(m_options.allowCredentials == AllowStoredCredentials);
     return request;
 }
 
 }