Make Resource RefCountedWillBeGarbageCollectedFinalized, attempt #2

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

Index: third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp
diff --git a/third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp b/third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp
index a55cb447a5b1b691cfc5ebd51df897ed20ea5f10..237f7b107be8f5d7d34218c059adeaf2845588ac 100644
--- a/third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp
+++ b/third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp
@@ -303,7 +303,7 @@ static PassRefPtr<TracedValue> urlForTraceEvent(const KURL& url)
     return value.release();
 }
 
-ResourcePtr<Resource> ResourceFetcher::preCacheData(const FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
+void ResourceFetcher::preCacheData(const FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
 {
     const KURL& url = request.resourceRequest().url();
     ASSERT(url.protocolIsData() || substituteData.isValid());
@@ -313,13 +313,13 @@ ResourcePtr<Resource> ResourceFetcher::preCacheData(const FetchRequest& request,
     // layer where it isn't easy to mock out a network load. It uses data: urls to emulate the
     // behavior it wants to test, which would otherwise be reserved for network loads.
     if ((factory.type() == Resource::MainResource && !substituteData.isValid()) || factory.type() == Resource::Raw)
-        return nullptr;
+        return;
 
     const String cacheIdentifier = getCacheIdentifier();
     if (Resource* oldResource = memoryCache()->resourceForURL(url, cacheIdentifier)) {
         // There's no reason to re-parse if we saved the data from the previous parse.
         if (request.options().dataBufferingPolicy != DoNotBufferData)
-            return oldResource;
+            return;
         memoryCache()->remove(oldResource);
     }
 
@@ -333,13 +333,13 @@ ResourcePtr<Resource> ResourceFetcher::preCacheData(const FetchRequest& request,
     } else {
         data = PassRefPtr<SharedBuffer>(Platform::current()->parseDataURL(url, mimetype, charset));
         if (!data)
-            return nullptr;
+            return;
     }
     ResourceResponse response(url, mimetype, data->size(), charset, String());
     response.setHTTPStatusCode(200);
     response.setHTTPStatusText("OK");
 
-    ResourcePtr<Resource> resource = factory.create(request.resourceRequest(), request.charset());
+    RefPtrWillBeRawPtr<Resource> resource = factory.create(request.resourceRequest(), request.charset());
     resource->setNeedsSynchronousCacheHit(substituteData.forceSynchronousLoad());
     resource->setOptions(request.options());
     // FIXME: We should provide a body stream here.
@@ -351,7 +351,6 @@ ResourcePtr<Resource> ResourceFetcher::preCacheData(const FetchRequest& request,
     resource->setCacheIdentifier(cacheIdentifier);
     resource->finish();
     memoryCache()->add(resource.get());
-    return resource;
 }
 
 void ResourceFetcher::moveCachedNonBlockingResourceToBlocking(Resource* resource, const FetchRequest& request)
@@ -366,7 +365,7 @@ void ResourceFetcher::moveCachedNonBlockingResourceToBlocking(Resource* resource
     }
 }
 
-ResourcePtr<Resource> ResourceFetcher::requestResource(FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
+PassRefPtrWillBeRawPtr<Resource> ResourceFetcher::requestResource(FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
 {
     ASSERT(request.options().synchronousPolicy == RequestAsynchronously || factory.type() == Resource::Raw || factory.type() == Resource::XSLStyleSheet);
 
@@ -404,11 +403,9 @@ ResourcePtr<Resource> ResourceFetcher::requestResource(FetchRequest& request, co
     }
 
     bool isStaticData = request.resourceRequest().url().protocolIsData() || substituteData.isValid();
-    ResourcePtr<Resource> resource;
     if (isStaticData)
-        resource = preCacheData(request, factory, substituteData);
-    if (!resource)
-        resource = memoryCache()->resourceForURL(url, getCacheIdentifier());
+        preCacheData(request, factory, substituteData);
+    RefPtrWillBeRawPtr<Resource> resource = memoryCache()->resourceForURL(url, getCacheIdentifier());
 
     // See if we can use an existing resource from the cache. If so, we need to move it to be load blocking.
     moveCachedNonBlockingResourceToBlocking(resource.get(), request);
@@ -566,7 +563,7 @@ void ResourceFetcher::initializeRevalidation(const FetchRequest& request, Resour
     resource->setRevalidatingRequest(revalidatingRequest);
 }
 
-ResourcePtr<Resource> ResourceFetcher::createResourceForLoading(FetchRequest& request, const String& charset, const ResourceFactory& factory)
+PassRefPtrWillBeRawPtr<Resource> ResourceFetcher::createResourceForLoading(FetchRequest& request, const String& charset, const ResourceFactory& factory)
 {
     const String cacheIdentifier = getCacheIdentifier();
     ASSERT(!memoryCache()->resourceForURL(request.resourceRequest().url(), cacheIdentifier));
@@ -574,7 +571,7 @@ ResourcePtr<Resource> ResourceFetcher::createResourceForLoading(FetchRequest& re
     WTF_LOG(ResourceLoading, "Loading Resource for '%s'.", request.resourceRequest().url().elidedString().latin1().data());
 
     initializeResourceRequest(request.mutableResourceRequest(), factory.type());
-    ResourcePtr<Resource> resource = factory.create(request.resourceRequest(), charset);
+    RefPtrWillBeRawPtr<Resource> resource = factory.create(request.resourceRequest(), charset);
     resource->setLinkPreload(request.isLinkPreload());
     resource->setCacheIdentifier(cacheIdentifier);
 
@@ -844,7 +841,7 @@ void ResourceFetcher::preloadStarted(Resource* resource)
     resource->increasePreloadCount();
 
     if (!m_preloads)
-        m_preloads = adoptPtrWillBeNoop(new WillBeHeapListHashSet<RawPtrWillBeMember<Resource>>);
+        m_preloads = adoptPtrWillBeNoop(new WillBeHeapListHashSet<RefPtrWillBeMember<Resource>>);
     m_preloads->add(resource);
 
 #if PRELOAD_DEBUG
@@ -874,8 +871,7 @@ void ResourceFetcher::clearPreloads(ClearPreloadsPolicy policy)
 
     for (auto resource : *m_preloads) {
         resource->decreasePreloadCount();
-        bool deleted = resource->deleteIfPossible();
-        if (!deleted && resource->preloadResult() == Resource::PreloadNotReferenced && (policy == ClearAllPreloads || !resource->isLinkPreload()))
+        if (resource->preloadResult() == Resource::PreloadNotReferenced && (policy == ClearAllPreloads || !resource->isLinkPreload()))
             memoryCache()->remove(resource.get());
     }
     m_preloads.clear();