Oilpan: Prepare to move ResourceLoader and ResourceLoaderSet 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 50 matching lines @@
     m_host->decrementRequestCount(m_resource);
 }
 
 ResourceLoader::RequestCountTracker::RequestCountTracker(const RequestCountTracker& other)
 {
     m_host = other.m_host;
     m_resource = other.m_resource;
     m_host->incrementRequestCount(m_resource);
 }
 
-PassRefPtr<ResourceLoader> ResourceLoader::create(ResourceLoaderHost* host, Resource* resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
+PassRefPtrWillBeRawPtr<ResourceLoader> ResourceLoader::create(ResourceLoaderHost* host, Resource* resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
 {
-    RefPtr<ResourceLoader> loader(adoptRef(new ResourceLoader(host, resource, options)));
+    RefPtrWillBeRawPtr<ResourceLoader> loader(adoptRefWillBeNoop(new ResourceLoader(host, resource, options)));
     loader->init(request);
     return loader.release();
 }
 
 ResourceLoader::ResourceLoader(ResourceLoaderHost* host, Resource* resource, const ResourceLoaderOptions& options)
     : m_host(host)
     , m_notifiedLoadComplete(false)
     , m_defersLoading(host->defersLoading())
     , m_options(options)
     , m_resource(resource)
     , m_state(Initialized)
     , m_connectionState(ConnectionStateNew)
     , m_requestCountTracker(adoptPtr(new RequestCountTracker(host, resource)))
 {
 }
 
 ResourceLoader::~ResourceLoader()
 {
     ASSERT(m_state == Terminated);
 }
 
+void ResourceLoader::trace(Visitor* visitor)
+{
+    visitor->trace(m_host);
+    visitor->trace(m_resource);
+}
+
 void ResourceLoader::releaseResources()
 {
     ASSERT(m_state != Terminated);
     ASSERT(m_notifiedLoadComplete);
     m_requestCountTracker.clear();
     m_host->didLoadResource(m_resource);
     if (m_state == Terminated)
         return;
     m_resource->clearLoader();
     m_host->willTerminateResourceLoader(this);
 
     ASSERT(m_state != Terminated);
 
     // It's possible that when we release the loader, it will be
     // deallocated and release the last reference to this object.
     // We need to retain to avoid accessing the object after it
     // has been deallocated and also to avoid reentering this method.
-    RefPtr<ResourceLoader> protector(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protector(this);
 
     m_host.clear();
     m_state = Terminated;
 
     if (m_loader) {
         m_loader->cancel();
         m_loader.clear();
     }
 
     m_deferredRequest = ResourceRequest();
@@ skipping 70 matching lines @@
         // threaded data receiver if it signals that it got successfully
         // attached.
         blink::WebThreadedDataReceiver* rawThreadedDataReceiver = threadedDataReceiver.leakPtr();
         if (!m_loader->attachThreadedDataReceiver(rawThreadedDataReceiver))
             delete rawThreadedDataReceiver;
     }
 }
 
 void ResourceLoader::didDownloadData(blink::WebURLLoader*, int length, int encodedDataLength)
 {
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     RELEASE_ASSERT(m_connectionState == ConnectionStateReceivedResponse);
     m_host->didDownloadData(m_resource, length, encodedDataLength);
     m_resource->didDownloadData(length);
 }
 
 void ResourceLoader::didFinishLoadingOnePart(double finishTime, int64 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)
@@ skipping 32 matching lines @@
         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.
-    RefPtr<ResourceLoader> protector(this);
+    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_host->didFailLoading(m_resource, nonNullError);
     }
 
     if (m_state == Finishing)
         m_resource->error(Resource::LoadError);
     if (m_state != Terminated)
         releaseResources();
 }
 
 void ResourceLoader::willSendRequest(blink::WebURLLoader*, blink::WebURLRequest& passedRequest, const blink::WebURLResponse& passedRedirectResponse)
 {
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
 
     ResourceRequest& request(applyOptions(passedRequest.toMutableResourceRequest()));
 
     // FIXME: We should have a real context for redirect requests. Currently, we don't: see WebURLLoaderImpl::Context::OnReceivedRedirect in content/.
     request.setRequestContext(blink::WebURLRequest::RequestContextInternal);
 
     ASSERT(!request.isNull());
     const ResourceResponse& redirectResponse(passedRedirectResponse.toResourceResponse());
     ASSERT(!redirectResponse.isNull());
     if (!m_host->canAccessRedirect(m_resource, request, redirectResponse, m_options)) {
@@ skipping 16 matching lines @@
 void ResourceLoader::didReceiveCachedMetadata(blink::WebURLLoader*, const char* data, int length)
 {
     RELEASE_ASSERT(m_connectionState == ConnectionStateReceivedResponse || m_connectionState == ConnectionStateReceivingData);
     ASSERT(m_state == Initialized);
     m_resource->setSerializedCachedMetadata(data, length);
 }
 
 void ResourceLoader::didSendData(blink::WebURLLoader*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 {
     ASSERT(m_state == Initialized);
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     m_resource->didSendData(bytesSent, totalBytesToBeSent);
 }
 
 bool ResourceLoader::responseNeedsAccessControlCheck() const
 {
     // If the fetch was (potentially) CORS enabled, an access control check of the response is required.
     return m_options.corsEnabled == IsCORSEnabled;
 }
 
 void ResourceLoader::didReceiveResponse(blink::WebURLLoader*, const blink::WebURLResponse& response)
@@ skipping 20 matching lines @@
             m_resource->setResponse(resourceResponse);
         if (!m_host->canAccessResource(resource, m_options.securityOrigin.get(), response.url())) {
             m_host->didReceiveResponse(m_resource, resourceResponse);
             cancel();
             return;
         }
     }
 
     // Reference the object in this method since the additional processing can do
     // anything including removing the last reference to this object.
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     m_resource->responseReceived(resourceResponse);
     if (m_state == Terminated)
         return;
 
     m_host->didReceiveResponse(m_resource, resourceResponse);
 
     if (response.toResourceResponse().isMultipart()) {
         // We don't count multiParts in a ResourceFetcher's request count
         m_requestCountTracker.clear();
         if (!m_resource->isImage()) {
@@ skipping 26 matching lines @@
     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.
-    RefPtr<ResourceLoader> protect(this);
+    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_host->didReceiveData(m_resource, data, length, encodedDataLength);
     m_resource->appendData(data, length);
 }
 
 void ResourceLoader::didFinishLoading(blink::WebURLLoader*, double finishTime, int64 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());
 
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     ResourcePtr<Resource> protectResource(m_resource);
     m_state = Finishing;
     didFinishLoadingOnePart(finishTime, encodedDataLength);
     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 == Terminated)
         return;
     releaseResources();
 }
 
 void ResourceLoader::didFail(blink::WebURLLoader*, const blink::WebURLError& error)
 {
     m_connectionState = ConnectionStateFailed;
     ASSERT(m_state != Terminated);
     WTF_LOG(ResourceLoading, "Failed to load '%s'.\n", m_resource->url().string().latin1().data());
 
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     RefPtrWillBeRawPtr<ResourceLoaderHost> protectHost(m_host.get());
     ResourcePtr<Resource> protectResource(m_resource);
     m_state = Finishing;
     m_resource->setResourceError(error);
 
     if (!m_notifiedLoadComplete) {
         m_notifiedLoadComplete = true;
         m_host->didFailLoading(m_resource, error);
     }
 
@@ skipping 11 matching lines @@
 }
 
 void ResourceLoader::requestSynchronously()
 {
     OwnPtr<blink::WebURLLoader> loader = adoptPtr(blink::Platform::current()->createURLLoader());
     ASSERT(loader);
 
     // downloadToFile is not supported for synchronous requests.
     ASSERT(!m_request.downloadToFile());
 
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     RefPtrWillBeRawPtr<ResourceLoaderHost> protectHost(m_host.get());
     ResourcePtr<Resource> protectResource(m_resource);
 
     RELEASE_ASSERT(m_connectionState == ConnectionStateNew);
     m_connectionState = ConnectionStateStarted;
 
     blink::WrappedResourceRequest requestIn(m_request);
     blink::WebURLResponse responseOut;
     responseOut.initialize();
     blink::WebURLError errorOut;
@@ skipping 13 matching lines @@
     didFinishLoading(0, monotonicallyIncreasingTime(), encodedDataLength);
 }
 
 ResourceRequest& ResourceLoader::applyOptions(ResourceRequest& request) const
 {
     request.setAllowStoredCredentials(m_options.allowCredentials == AllowStoredCredentials);
     return request;
 }
 
 }