Revert of Make Resource RefCountedWillBeGarbageCollectedFinalized (patchset #28 id:520001 of https://codereview.chromium.org/1423033012/ )

Reason for revert: Perf sheriffing. This CL looks like it causes multiple failures during sign in to Facebook. Original issue's description: > Make Resource RefCountedWillBeGarbageCollectedFinalized > > Resource's lifetime is currently managed by an unholy mix of > factors that would ideally be represented in a more canonical > way. Historically, some of this was necessary, and it was > glossed over because of ResourcePtr which, in addition to > keeping the Resource alive, performed a key part of > revalidation handling in the case of a 304. Now that > ResourcePtr's revalidation behavior has been removed, > standardize Resource's lifetime management. > > BUG=571190 > > Committed: https://crrev.com/078b8da5052922b9d4ab7b7f9294a8050bdc3286 > Cr-Commit-Position: refs/heads/master@{#373046} TBR=mkwst@chromium.org,sigbjornf@opera.com,haraken@chromium.org,peria@chromium.org,dgozman@chromium.org,yhirano@chromium.org,keishi@chromium.org,japhet@chromium.org # Skipping CQ checks because original CL landed less than 1 days ago. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true BUG=571190 Review URL: https://codereview.chromium.org/1661823003 Cr-Commit-Position: refs/heads/master@{#373227}
author: picksi <picksi@google.com> 2016-02-03 05:50:23 -0800
committer: Commit bot <commit-bot@chromium.org> 2016-02-03 13:51:22 +0000
commit: 783c4ec025ab4ed46d0cf2f8a1acde990928e39d (patch)
tree: 4e24e077badc63fb6037cfabd6d1582ca5314b37
parent: 36b4e445347aab5b32b5f7fa39b2199ddb85968c (diff)
download: chromium_src-783c4ec025ab4ed46d0cf2f8a1acde990928e39d.zip
chromium_src-783c4ec025ab4ed46d0cf2f8a1acde990928e39d.tar.gz
chromium_src-783c4ec025ab4ed46d0cf2f8a1acde990928e39d.tar.bz2
107 files changed, 892 insertions, 613 deletions
diff --git a/third_party/WebKit/Source/bindings/core/v8/ScriptSourceCode.cpp b/third_party/WebKit/Source/bindings/core/v8/ScriptSourceCode.cpp
index bc41b08..dfb6423 100644
--- a/third_party/WebKit/Source/bindings/core/v8/ScriptSourceCode.cpp
+++ b/third_party/WebKit/Source/bindings/core/v8/ScriptSourceCode.cpp
@@ -7,7 +7,8 @@
 namespace blink {
 
 ScriptSourceCode::ScriptSourceCode()
-    : m_startPosition(TextPosition::minimumPosition())
+    : m_resource(0)
+    , m_startPosition(TextPosition::minimumPosition())
 {
 }
 
@@ -18,6 +19,7 @@ ScriptSourceCode::ScriptSourceCode(const String& source, const KURL& url, const
 
 ScriptSourceCode::ScriptSourceCode(const CompressibleString& source, const KURL& url, const TextPosition& startPosition)
     : m_source(source)
+    , m_resource(0)
     , m_url(url)
     , m_startPosition(startPosition)
 {
@@ -49,7 +51,6 @@ ScriptSourceCode::~ScriptSourceCode()
 
 DEFINE_TRACE(ScriptSourceCode)
 {
-    visitor->trace(m_resource);
     visitor->trace(m_streamer);
 }
 
diff --git a/third_party/WebKit/Source/bindings/core/v8/ScriptSourceCode.h b/third_party/WebKit/Source/bindings/core/v8/ScriptSourceCode.h
index 0cc57e4..0d4056e 100644
--- a/third_party/WebKit/Source/bindings/core/v8/ScriptSourceCode.h
+++ b/third_party/WebKit/Source/bindings/core/v8/ScriptSourceCode.h
@@ -33,6 +33,7 @@
 
 #include "bindings/core/v8/ScriptStreamer.h"
 #include "core/CoreExport.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/fetch/ScriptResource.h"
 #include "platform/heap/Handle.h"
 #include "platform/weborigin/KURL.h"
@@ -41,6 +42,9 @@
 
 namespace blink {
 
+template <class R> class ResourcePtr;
+class ScriptResource;
+
 class CORE_EXPORT ScriptSourceCode final {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
@@ -74,7 +78,7 @@ private:
     void treatNullSourceAsEmpty();
 
     CompressibleString m_source;
-    RefPtrWillBeMember<ScriptResource> m_resource;
+    ResourcePtr<ScriptResource> m_resource;
     RefPtrWillBeMember<ScriptStreamer> m_streamer;
     mutable KURL m_url;
     TextPosition m_startPosition;
diff --git a/third_party/WebKit/Source/bindings/core/v8/ScriptStreamerTest.cpp b/third_party/WebKit/Source/bindings/core/v8/ScriptStreamerTest.cpp
index 7317c68..4056578 100644
--- a/third_party/WebKit/Source/bindings/core/v8/ScriptStreamerTest.cpp
+++ b/third_party/WebKit/Source/bindings/core/v8/ScriptStreamerTest.cpp
@@ -32,7 +32,7 @@ public:
         , m_scope(v8::Isolate::GetCurrent())
         , m_settings(Settings::create())
         , m_resourceRequest("http://www.streaming-test.com/")
-        , m_resource(ScriptResource::create(m_resourceRequest, "UTF-8"))
+        , m_resource(new ScriptResource(m_resourceRequest, "UTF-8"))
         , m_pendingScript(PendingScript::create(0, m_resource.get()))
     {
         m_resource->setLoading(true);
@@ -89,7 +89,7 @@ protected:
     // fetch any data outside the test; the test controls the data by calling
     // ScriptResource::appendData.
     ResourceRequest m_resourceRequest;
-    RefPtrWillBePersistent<ScriptResource> m_resource;
+    ResourcePtr<ScriptResource> m_resource;
     OwnPtrWillBePersistent<PendingScript> m_pendingScript;
 };
 
@@ -194,7 +194,7 @@ TEST_F(ScriptStreamingTest, CancellingStreaming)
     pendingScript()->stopWatchingForLoad(&client);
     pendingScript()->releaseElementAndClear();
     m_pendingScript = nullptr; // This will destroy m_resource.
-    m_resource = nullptr;
+    m_resource = 0;
 
     // The V8 side will complete too. This should not crash. We don't receive
     // any results from the streaming and the client doesn't get notified.
diff --git a/third_party/WebKit/Source/bindings/core/v8/V8ScriptRunnerTest.cpp b/third_party/WebKit/Source/bindings/core/v8/V8ScriptRunnerTest.cpp
index a974e8b..1cf157a 100644
--- a/third_party/WebKit/Source/bindings/core/v8/V8ScriptRunnerTest.cpp
+++ b/third_party/WebKit/Source/bindings/core/v8/V8ScriptRunnerTest.cpp
@@ -73,13 +73,13 @@ public:
     void setEmptyResource()
     {
         m_resourceRequest = ResourceRequest();
-        m_resource = ScriptResource::create(m_resourceRequest, "UTF-8");
+        m_resource = new ScriptResource(m_resourceRequest, "UTF-8");
     }
 
     void setResource()
     {
         m_resourceRequest = ResourceRequest(url());
-        m_resource = ScriptResource::create(m_resourceRequest, "UTF-8");
+        m_resource = new ScriptResource(m_resourceRequest, "UTF-8");
     }
 
     CachedMetadataHandler* cacheHandler()
@@ -89,7 +89,7 @@ public:
 
 protected:
     ResourceRequest m_resourceRequest;
-    RefPtrWillBePersistent<ScriptResource> m_resource;
+    ResourcePtr<ScriptResource> m_resource;
     V8TestingScope m_scope;
 
     static int counter;
@@ -118,7 +118,7 @@ TEST_F(V8ScriptRunnerTest, parseOption)
     EXPECT_FALSE(cacheHandler()->cachedMetadata(tagForCodeCache(cacheHandler())));
     // The cached data is associated with the encoding.
     ResourceRequest request(url());
-    RefPtrWillBeRawPtr<ScriptResource> anotherResource = ScriptResource::create(request, "UTF-16");
+    ResourcePtr<ScriptResource> anotherResource = new ScriptResource(request, "UTF-16");
     EXPECT_FALSE(cacheHandler()->cachedMetadata(tagForParserCache(anotherResource->cacheHandler())));
 }
 
@@ -134,7 +134,7 @@ TEST_F(V8ScriptRunnerTest, codeOption)
     EXPECT_TRUE(cacheHandler()->cachedMetadata(tagForCodeCache(cacheHandler())));
     // The cached data is associated with the encoding.
     ResourceRequest request(url());
-    RefPtrWillBeRawPtr<ScriptResource> anotherResource = ScriptResource::create(request, "UTF-16");
+    ResourcePtr<ScriptResource> anotherResource = new ScriptResource(request, "UTF-16");
     EXPECT_FALSE(cacheHandler()->cachedMetadata(tagForCodeCache(anotherResource->cacheHandler())));
 }
 
diff --git a/third_party/WebKit/Source/core/clipboard/DataTransfer.cpp b/third_party/WebKit/Source/core/clipboard/DataTransfer.cpp
index 3b01ec0..8e1e9c1 100644
--- a/third_party/WebKit/Source/core/clipboard/DataTransfer.cpp
+++ b/third_party/WebKit/Source/core/clipboard/DataTransfer.cpp
@@ -230,7 +230,7 @@ void DataTransfer::clearDragImage()
     if (!canSetDragImage())
         return;
 
-    m_dragImage = nullptr;
+    m_dragImage = 0;
     m_dragLoc = IntPoint();
     m_dragImageElement = nullptr;
 }
@@ -513,7 +513,6 @@ String convertDragOperationToDropZoneOperation(DragOperation operation)
 DEFINE_TRACE(DataTransfer)
 {
     visitor->trace(m_dataObject);
-    visitor->trace(m_dragImage);
 #if ENABLE(OILPAN)
     visitor->trace(m_dragImageElement);
 #endif
diff --git a/third_party/WebKit/Source/core/clipboard/DataTransfer.h b/third_party/WebKit/Source/core/clipboard/DataTransfer.h
index c36b790..ff489c30 100644
--- a/third_party/WebKit/Source/core/clipboard/DataTransfer.h
+++ b/third_party/WebKit/Source/core/clipboard/DataTransfer.h
@@ -28,6 +28,7 @@
 #include "core/CoreExport.h"
 #include "core/clipboard/DataTransferAccessPolicy.h"
 #include "core/fetch/ImageResource.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/page/DragActions.h"
 #include "platform/geometry/IntPoint.h"
 #include "platform/heap/Handle.h"
@@ -130,7 +131,7 @@ private:
     Member<DataObject> m_dataObject;
 
     IntPoint m_dragLoc;
-    RefPtrWillBeMember<ImageResource> m_dragImage;
+    ResourcePtr<ImageResource> m_dragImage;
     RefPtrWillBeMember<Node> m_dragImageElement;
 };
 
diff --git a/third_party/WebKit/Source/core/core.gypi b/third_party/WebKit/Source/core/core.gypi
index 0e51588..a3600e9 100644
--- a/third_party/WebKit/Source/core/core.gypi
+++ b/third_party/WebKit/Source/core/core.gypi
@@ -1581,6 +1581,8 @@
             'fetch/ResourceLoaderOptions.h',
             'fetch/ResourceLoaderSet.cpp',
             'fetch/ResourceLoaderSet.h',
+            'fetch/ResourcePtr.cpp',
+            'fetch/ResourcePtr.h',
             'fetch/ScriptResource.cpp',
             'fetch/ScriptResource.h',
             'fetch/SubstituteData.h',
diff --git a/third_party/WebKit/Source/core/css/CSSCrossfadeValue.cpp b/third_party/WebKit/Source/core/css/CSSCrossfadeValue.cpp
index f852653..ec59447 100644
--- a/third_party/WebKit/Source/core/css/CSSCrossfadeValue.cpp
+++ b/third_party/WebKit/Source/core/css/CSSCrossfadeValue.cpp
@@ -125,14 +125,10 @@ CSSCrossfadeValue::~CSSCrossfadeValue()
 
 void CSSCrossfadeValue::dispose()
 {
-    if (m_cachedFromImage) {
+    if (m_cachedFromImage)
         m_cachedFromImage->removeClient(&m_crossfadeSubimageObserver);
-        m_cachedFromImage = nullptr;
-    }
-    if (m_cachedToImage) {
+    if (m_cachedToImage)
         m_cachedToImage->removeClient(&m_crossfadeSubimageObserver);
-        m_cachedToImage = nullptr;
-    }
 }
 
 String CSSCrossfadeValue::customCSSText() const
@@ -194,8 +190,8 @@ bool CSSCrossfadeValue::knownToBeOpaque(const LayoutObject* layoutObject) const
 
 void CSSCrossfadeValue::loadSubimages(Document* document)
 {
-    RefPtrWillBeRawPtr<ImageResource> oldCachedFromImage = m_cachedFromImage;
-    RefPtrWillBeRawPtr<ImageResource> oldCachedToImage = m_cachedToImage;
+    ResourcePtr<ImageResource> oldCachedFromImage = m_cachedFromImage;
+    ResourcePtr<ImageResource> oldCachedToImage = m_cachedToImage;
 
     m_cachedFromImage = cachedImageForCSSValue(m_fromValue.get(), document);
     m_cachedToImage = cachedImageForCSSValue(m_toValue.get(), document);
@@ -277,8 +273,6 @@ DEFINE_TRACE_AFTER_DISPATCH(CSSCrossfadeValue)
     visitor->trace(m_fromValue);
     visitor->trace(m_toValue);
     visitor->trace(m_percentageValue);
-    visitor->trace(m_cachedFromImage);
-    visitor->trace(m_cachedToImage);
     visitor->trace(m_crossfadeSubimageObserver);
     CSSImageGeneratorValue::traceAfterDispatch(visitor);
 }
diff --git a/third_party/WebKit/Source/core/css/CSSCrossfadeValue.h b/third_party/WebKit/Source/core/css/CSSCrossfadeValue.h
index 0a3a9d6..8f93a01 100644
--- a/third_party/WebKit/Source/core/css/CSSCrossfadeValue.h
+++ b/third_party/WebKit/Source/core/css/CSSCrossfadeValue.h
@@ -31,6 +31,7 @@
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/fetch/ImageResource.h"
 #include "core/fetch/ImageResourceClient.h"
+#include "core/fetch/ResourcePtr.h"
 #include "platform/graphics/Image.h"
 
 namespace blink {
@@ -101,8 +102,8 @@ private:
     RefPtrWillBeMember<CSSValue> m_toValue;
     RefPtrWillBeMember<CSSPrimitiveValue> m_percentageValue;
 
-    RefPtrWillBeMember<ImageResource> m_cachedFromImage;
-    RefPtrWillBeMember<ImageResource> m_cachedToImage;
+    ResourcePtr<ImageResource> m_cachedFromImage;
+    ResourcePtr<ImageResource> m_cachedToImage;
 
     RefPtr<Image> m_generatedImage;
 
diff --git a/third_party/WebKit/Source/core/css/CSSFontFaceSrcValue.cpp b/third_party/WebKit/Source/core/css/CSSFontFaceSrcValue.cpp
index 3b5e056..2244957 100644
--- a/third_party/WebKit/Source/core/css/CSSFontFaceSrcValue.cpp
+++ b/third_party/WebKit/Source/core/css/CSSFontFaceSrcValue.cpp
@@ -72,7 +72,7 @@ String CSSFontFaceSrcValue::customCSSText() const
 
 bool CSSFontFaceSrcValue::hasFailedOrCanceledSubresources() const
 {
-    return m_fetched && m_fetched->resource()->loadFailedOrCanceled();
+    return m_fetched && m_fetched->loadFailedOrCanceled();
 }
 
 static void setCrossOriginAccessControl(FetchRequest& request, SecurityOrigin* securityOrigin)
@@ -93,13 +93,13 @@ FontResource* CSSFontFaceSrcValue::fetch(Document* document)
         SecurityOrigin* securityOrigin = document->securityOrigin();
         setCrossOriginAccessControl(request, securityOrigin);
         request.mutableResourceRequest().setHTTPReferrer(SecurityPolicy::generateReferrer(m_referrer.referrerPolicy, request.url(), m_referrer.referrer));
-        m_fetched = FontResourceHelper::create(FontResource::fetch(request, document->fetcher()));
+        m_fetched = FontResource::fetch(request, document->fetcher());
     } else {
         // FIXME: CSSFontFaceSrcValue::fetch is invoked when @font-face rule
         // is processed by StyleResolver / StyleEngine.
         restoreCachedResourceIfNeeded(document);
     }
-    return m_fetched->resource();
+    return m_fetched.get();
 }
 
 void CSSFontFaceSrcValue::restoreCachedResourceIfNeeded(Document* document)
@@ -113,9 +113,9 @@ void CSSFontFaceSrcValue::restoreCachedResourceIfNeeded(Document* document)
 
     FetchRequest request(ResourceRequest(resourceURL), FetchInitiatorTypeNames::css);
     request.setContentSecurityCheck(m_shouldCheckContentSecurityPolicy);
-    MixedContentChecker::shouldBlockFetch(document->frame(), m_fetched->resource()->lastResourceRequest(),
-        m_fetched->resource()->lastResourceRequest().url(), MixedContentChecker::SendReport);
-    document->fetcher()->requestLoadStarted(m_fetched->resource(), request, ResourceFetcher::ResourceLoadingFromCache);
+    MixedContentChecker::shouldBlockFetch(document->frame(), m_fetched->lastResourceRequest(),
+        m_fetched->lastResourceRequest().url(), MixedContentChecker::SendReport);
+    document->fetcher()->requestLoadStarted(m_fetched.get(), request, ResourceFetcher::ResourceLoadingFromCache);
 }
 
 bool CSSFontFaceSrcValue::equals(const CSSFontFaceSrcValue& other) const
diff --git a/third_party/WebKit/Source/core/css/CSSFontFaceSrcValue.h b/third_party/WebKit/Source/core/css/CSSFontFaceSrcValue.h
index eea8f3e..ab53370 100644
--- a/third_party/WebKit/Source/core/css/CSSFontFaceSrcValue.h
+++ b/third_party/WebKit/Source/core/css/CSSFontFaceSrcValue.h
@@ -27,14 +27,14 @@
 #define CSSFontFaceSrcValue_h
 
 #include "core/css/CSSValue.h"
-#include "core/fetch/FontResource.h"
-#include "core/fetch/ResourceOwner.h"
+#include "core/fetch/ResourcePtr.h"
 #include "platform/weborigin/Referrer.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
+class FontResource;
 class Document;
 
 class CSSFontFaceSrcValue : public CSSValue {
@@ -65,11 +65,7 @@ public:
 
     bool equals(const CSSFontFaceSrcValue&) const;
 
-    DEFINE_INLINE_TRACE_AFTER_DISPATCH()
-    {
-        visitor->trace(m_fetched);
-        CSSValue::traceAfterDispatch(visitor);
-    }
+    DEFINE_INLINE_TRACE_AFTER_DISPATCH() { CSSValue::traceAfterDispatch(visitor); }
 
 private:
     CSSFontFaceSrcValue(const String& resource, bool local, ContentSecurityPolicyDisposition shouldCheckContentSecurityPolicy)
@@ -88,26 +84,7 @@ private:
     bool m_isLocal;
     ContentSecurityPolicyDisposition m_shouldCheckContentSecurityPolicy;
 
-
-    class FontResourceHelper : public NoBaseWillBeGarbageCollectedFinalized<FontResourceHelper>, public ResourceOwner<FontResource> {
-        WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(FontResourceHelper);
-    public:
-        static PassOwnPtrWillBeRawPtr<FontResourceHelper> create(PassRefPtrWillBeRawPtr<FontResource> resource)
-        {
-            return adoptPtrWillBeNoop(new FontResourceHelper(resource));
-        }
-
-        DEFINE_INLINE_VIRTUAL_TRACE() { ResourceOwner<FontResource>::trace(visitor); }
-
-    private:
-        FontResourceHelper(PassRefPtrWillBeRawPtr<FontResource> resource)
-        {
-            setResource(resource);
-        }
-
-        String debugName() const override { return "CSSFontFaceSrcValue::FontResourceHelper"; }
-    };
-    OwnPtrWillBeMember<FontResourceHelper> m_fetched;
+    ResourcePtr<FontResource> m_fetched;
 };
 
 DEFINE_CSS_VALUE_TYPE_CASTS(CSSFontFaceSrcValue, isFontFaceSrcValue());
diff --git a/third_party/WebKit/Source/core/css/CSSImageSetValue.cpp b/third_party/WebKit/Source/core/css/CSSImageSetValue.cpp
index aaf2bb0..b68a44a 100644
--- a/third_party/WebKit/Source/core/css/CSSImageSetValue.cpp
+++ b/third_party/WebKit/Source/core/css/CSSImageSetValue.cpp
@@ -122,7 +122,7 @@ StyleImage* CSSImageSetValue::cacheImage(Document* document, float deviceScaleFa
         if (crossOrigin != CrossOriginAttributeNotSet)
             request.setCrossOriginAccessControl(document->securityOrigin(), crossOrigin);
 
-        if (RefPtrWillBeRawPtr<ImageResource> cachedImage = ImageResource::fetch(request, document->fetcher()))
+        if (ResourcePtr<ImageResource> cachedImage = ImageResource::fetch(request, document->fetcher()))
             m_cachedImage = StyleFetchedImageSet::create(cachedImage.get(), image.scaleFactor, this, request.url());
         else
             m_cachedImage = StyleInvalidImage::create(image.imageURL);
diff --git a/third_party/WebKit/Source/core/css/CSSImageValue.cpp b/third_party/WebKit/Source/core/css/CSSImageValue.cpp
index fcbe961..25a5250 100644
--- a/third_party/WebKit/Source/core/css/CSSImageValue.cpp
+++ b/third_party/WebKit/Source/core/css/CSSImageValue.cpp
@@ -68,7 +68,7 @@ StyleFetchedImage* CSSImageValue::cacheImage(Document* document, CrossOriginAttr
         if (crossOrigin != CrossOriginAttributeNotSet)
             request.setCrossOriginAccessControl(document->securityOrigin(), crossOrigin);
 
-        if (RefPtrWillBeRawPtr<ImageResource> cachedImage = ImageResource::fetch(request, document->fetcher()))
+        if (ResourcePtr<ImageResource> cachedImage = ImageResource::fetch(request, document->fetcher()))
             m_cachedImage = StyleFetchedImage::create(cachedImage.get(), document, request.url());
     }
 
diff --git a/third_party/WebKit/Source/core/css/CSSSVGDocumentValue.h b/third_party/WebKit/Source/core/css/CSSSVGDocumentValue.h
index 11dd452..edd2357 100644
--- a/third_party/WebKit/Source/core/css/CSSSVGDocumentValue.h
+++ b/third_party/WebKit/Source/core/css/CSSSVGDocumentValue.h
@@ -27,6 +27,7 @@
 
 #include "core/css/CSSValue.h"
 #include "core/fetch/DocumentResource.h"
+#include "core/fetch/ResourcePtr.h"
 
 namespace blink {
 
@@ -48,17 +49,13 @@ public:
     bool loadRequested() const { return m_loadRequested; }
     bool equals(const CSSSVGDocumentValue&) const;
 
-    DEFINE_INLINE_TRACE_AFTER_DISPATCH()
-    {
-        visitor->trace(m_document);
-        CSSValue::traceAfterDispatch(visitor);
-    }
+    DEFINE_INLINE_TRACE_AFTER_DISPATCH() { CSSValue::traceAfterDispatch(visitor); }
 
 private:
     CSSSVGDocumentValue(const String& url);
 
     String m_url;
-    RefPtrWillBeMember<DocumentResource> m_document;
+    ResourcePtr<DocumentResource> m_document;
     bool m_loadRequested;
 };
 
diff --git a/third_party/WebKit/Source/core/css/CSSStyleSheetResourceTest.cpp b/third_party/WebKit/Source/core/css/CSSStyleSheetResourceTest.cpp
index 5080f8e..4c16737 100644
--- a/third_party/WebKit/Source/core/css/CSSStyleSheetResourceTest.cpp
+++ b/third_party/WebKit/Source/core/css/CSSStyleSheetResourceTest.cpp
@@ -71,7 +71,7 @@ TEST_F(CSSStyleSheetResourceTest, PruneCanCauseEviction)
         // the image resource.
         document()->fetcher()->setAutoLoadImages(false);
 
-        RefPtrWillBeRawPtr<CSSStyleSheetResource> cssResource = CSSStyleSheetResource::createForTest(ResourceRequest(cssURL), "utf-8");
+        ResourcePtr<CSSStyleSheetResource> cssResource = CSSStyleSheetResource::createForTest(ResourceRequest(cssURL), "utf-8");
         memoryCache()->add(cssResource.get());
         cssResource->responseReceived(ResourceResponse(cssURL, "style/css", 0, nullAtom, String()), nullptr);
         cssResource->finish();
@@ -92,7 +92,7 @@ TEST_F(CSSStyleSheetResourceTest, PruneCanCauseEviction)
             StyleRule::create(CSSSelectorList::adoptSelectorVector(selectors), ImmutableStylePropertySet::create(&property, 1, HTMLStandardMode)));
 
         crossfade->loadSubimages(document());
-        RefPtrWillBeRawPtr<Resource> imageResource = memoryCache()->resourceForURL(imageURL, MemoryCache::defaultCacheIdentifier());
+        ResourcePtr<Resource> imageResource = memoryCache()->resourceForURL(imageURL, MemoryCache::defaultCacheIdentifier());
         ASSERT_TRUE(imageResource);
         ResourceResponse imageResponse;
         imageResponse.setURL(imageURL);
diff --git a/third_party/WebKit/Source/core/css/FontFace.cpp b/third_party/WebKit/Source/core/css/FontFace.cpp
index 710f527..2f4661d 100644
--- a/third_party/WebKit/Source/core/css/FontFace.cpp
+++ b/third_party/WebKit/Source/core/css/FontFace.cpp
@@ -588,10 +588,10 @@ void FontFace::initCSSFontFace(Document* document, PassRefPtrWillBeRawPtr<CSSVal
             const Settings* settings = document ? document->settings() : nullptr;
             bool allowDownloading = settings && settings->downloadableBinaryFontsEnabled();
             if (allowDownloading && item->isSupportedFormat() && document) {
-                RefPtrWillBeRawPtr<FontResource> fetched = item->fetch(document);
+                FontResource* fetched = item->fetch(document);
                 if (fetched) {
                     FontLoader* fontLoader = document->styleEngine().fontSelector()->fontLoader();
-                    source = adoptPtrWillBeNoop(new RemoteFontFaceSource(fetched.release(), fontLoader, CSSValueToFontDisplay(m_display.get())));
+                    source = adoptPtrWillBeNoop(new RemoteFontFaceSource(fetched, fontLoader, CSSValueToFontDisplay(m_display.get())));
                 }
             }
         } else {
diff --git a/third_party/WebKit/Source/core/css/FontLoader.cpp b/third_party/WebKit/Source/core/css/FontLoader.cpp
index 5495890..fda44d7 100644
--- a/third_party/WebKit/Source/core/css/FontLoader.cpp
+++ b/third_party/WebKit/Source/core/css/FontLoader.cpp
@@ -12,29 +12,16 @@
 
 namespace blink {
 
-struct FontLoader::FontToLoad : public NoBaseWillBeGarbageCollectedFinalized<FontLoader::FontToLoad> {
+struct FontLoader::FontToLoad {
 public:
-    static PassOwnPtrWillBeRawPtr<FontToLoad> create(FontResource* fontResource, Document& document)
+    static PassOwnPtr<FontToLoad> create(FontResource* fontResource, Document& document)
     {
-        return adoptPtrWillBeNoop(new FontToLoad(fontResource, document));
+        return adoptPtr(new FontToLoad(fontResource, document));
     }
 
-    virtual ~FontToLoad()
-    {
-        ASSERT(!fontResource);
-    }
-
-    RefPtrWillBeMember<FontResource> fontResource;
+    ResourcePtr<FontResource> fontResource;
     OwnPtr<IncrementLoadEventDelayCount> delay;
 
-    void dispose()
-    {
-        fontResource = nullptr;
-        delay.clear();
-    }
-
-    DEFINE_INLINE_TRACE() { visitor->trace(fontResource); }
-
 private:
     FontToLoad(FontResource* resource, Document& document)
         : fontResource(resource)
@@ -91,7 +78,6 @@ void FontLoader::loadPendingFonts()
             fontToLoad->fontResource->beginLoadIfNeeded(m_document->fetcher());
         else
             fontToLoad->fontResource->error(Resource::LoadError);
-        fontToLoad->dispose();
     }
 
     // When the local fontsToBeginLoading vector goes out of scope it will
@@ -133,16 +119,13 @@ void FontLoader::clearDocumentAndFontSelector()
 
 void FontLoader::clearPendingFonts()
 {
-    for (const auto& fontToLoad : m_fontsToBeginLoading) {
+    for (const auto& fontToLoad : m_fontsToBeginLoading)
         fontToLoad->fontResource->didUnscheduleLoad();
-        fontToLoad->dispose();
-    }
     m_fontsToBeginLoading.clear();
 }
 
 DEFINE_TRACE(FontLoader)
 {
-    visitor->trace(m_fontsToBeginLoading);
     visitor->trace(m_document);
     visitor->trace(m_fontSelector);
 }
diff --git a/third_party/WebKit/Source/core/css/FontLoader.h b/third_party/WebKit/Source/core/css/FontLoader.h
index 9221b4f..a7e7634 100644
--- a/third_party/WebKit/Source/core/css/FontLoader.h
+++ b/third_party/WebKit/Source/core/css/FontLoader.h
@@ -6,6 +6,7 @@
 #define FontLoader_h
 
 #include "core/fetch/ResourceLoader.h"
+#include "core/fetch/ResourcePtr.h"
 #include "platform/Timer.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Vector.h"
@@ -43,7 +44,7 @@ private:
     Timer<FontLoader> m_beginLoadingTimer;
 
     struct FontToLoad;
-    using FontsToLoadVector = WillBeHeapVector<OwnPtrWillBeMember<FontToLoad>>;
+    using FontsToLoadVector = Vector<OwnPtr<FontToLoad>>;
     FontsToLoadVector m_fontsToBeginLoading;
     RawPtrWillBeMember<CSSFontSelector> m_fontSelector;
     RawPtrWillBeWeakMember<Document> m_document;
diff --git a/third_party/WebKit/Source/core/css/RemoteFontFaceSource.cpp b/third_party/WebKit/Source/core/css/RemoteFontFaceSource.cpp
index 069122b..d86c598 100644
--- a/third_party/WebKit/Source/core/css/RemoteFontFaceSource.cpp
+++ b/third_party/WebKit/Source/core/css/RemoteFontFaceSource.cpp
@@ -17,7 +17,7 @@
 
 namespace blink {
 
-RemoteFontFaceSource::RemoteFontFaceSource(PassRefPtrWillBeRawPtr<FontResource> font, PassRefPtrWillBeRawPtr<FontLoader> fontLoader, FontDisplay display)
+RemoteFontFaceSource::RemoteFontFaceSource(FontResource* font, PassRefPtrWillBeRawPtr<FontLoader> fontLoader, FontDisplay display)
     : m_font(font)
     , m_fontLoader(fontLoader)
     , m_display(display)
@@ -49,7 +49,6 @@ RemoteFontFaceSource::~RemoteFontFaceSource()
 void RemoteFontFaceSource::dispose()
 {
     m_font->removeClient(this);
-    m_font = nullptr;
     pruneTable();
 }
 
@@ -187,7 +186,6 @@ void RemoteFontFaceSource::beginLoadIfNeeded()
 
 DEFINE_TRACE(RemoteFontFaceSource)
 {
-    visitor->trace(m_font);
     visitor->trace(m_fontLoader);
     CSSFontFaceSource::trace(visitor);
 }
diff --git a/third_party/WebKit/Source/core/css/RemoteFontFaceSource.h b/third_party/WebKit/Source/core/css/RemoteFontFaceSource.h
index a346a5d..9d58bcb 100644
--- a/third_party/WebKit/Source/core/css/RemoteFontFaceSource.h
+++ b/third_party/WebKit/Source/core/css/RemoteFontFaceSource.h
@@ -7,6 +7,7 @@
 
 #include "core/css/CSSFontFaceSource.h"
 #include "core/fetch/FontResource.h"
+#include "core/fetch/ResourcePtr.h"
 #include "wtf/Allocator.h"
 
 namespace blink {
@@ -27,7 +28,7 @@ class RemoteFontFaceSource final : public CSSFontFaceSource, public FontResource
 public:
     enum DisplayPeriod { BlockPeriod, SwapPeriod, FailurePeriod };
 
-    explicit RemoteFontFaceSource(PassRefPtrWillBeRawPtr<FontResource>, PassRefPtrWillBeRawPtr<FontLoader>, FontDisplay);
+    explicit RemoteFontFaceSource(FontResource*, PassRefPtrWillBeRawPtr<FontLoader>, FontDisplay);
     ~RemoteFontFaceSource() override;
     void dispose();
 
@@ -79,7 +80,7 @@ private:
     void switchToSwapPeriod();
     void switchToFailurePeriod();
 
-    RefPtrWillBeMember<FontResource> m_font;
+    ResourcePtr<FontResource> m_font;
     RefPtrWillBeMember<FontLoader> m_fontLoader;
     const FontDisplay m_display;
     DisplayPeriod m_period;
diff --git a/third_party/WebKit/Source/core/css/StyleRuleImport.cpp b/third_party/WebKit/Source/core/css/StyleRuleImport.cpp
index b252d3f..cc09ce7 100644
--- a/third_party/WebKit/Source/core/css/StyleRuleImport.cpp
+++ b/third_party/WebKit/Source/core/css/StyleRuleImport.cpp
@@ -41,14 +41,11 @@ StyleRuleImport::StyleRuleImport(const String& href, PassRefPtrWillBeRawPtr<Medi
     , m_styleSheetClient(this)
     , m_strHref(href)
     , m_mediaQueries(media)
+    , m_resource(nullptr)
     , m_loading(false)
 {
     if (!m_mediaQueries)
         m_mediaQueries = MediaQuerySet::create(String());
-
-#if ENABLE(OILPAN)
-    ThreadState::current()->registerPreFinalizer(this);
-#endif
 }
 
 StyleRuleImport::~StyleRuleImport()
@@ -56,15 +53,9 @@ StyleRuleImport::~StyleRuleImport()
 #if !ENABLE(OILPAN)
     if (m_styleSheet)
         m_styleSheet->clearOwnerRule();
-    dispose();
 #endif
-}
-
-void StyleRuleImport::dispose()
-{
     if (m_resource)
         m_resource->removeClient(&m_styleSheetClient);
-    m_resource = nullptr;
 }
 
 DEFINE_TRACE_AFTER_DISPATCH(StyleRuleImport)
@@ -73,7 +64,6 @@ DEFINE_TRACE_AFTER_DISPATCH(StyleRuleImport)
     visitor->trace(m_parentStyleSheet);
     visitor->trace(m_mediaQueries);
     visitor->trace(m_styleSheet);
-    visitor->trace(m_resource);
     StyleRuleBase::traceAfterDispatch(visitor);
 }
 
diff --git a/third_party/WebKit/Source/core/css/StyleRuleImport.h b/third_party/WebKit/Source/core/css/StyleRuleImport.h
index d7cb9d1..2c795e1 100644
--- a/third_party/WebKit/Source/core/css/StyleRuleImport.h
+++ b/third_party/WebKit/Source/core/css/StyleRuleImport.h
@@ -23,6 +23,7 @@
 #define StyleRuleImport_h
 
 #include "core/css/StyleRule.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/fetch/StyleSheetResourceClient.h"
 #include "platform/heap/Handle.h"
 
@@ -34,7 +35,6 @@ class StyleSheetContents;
 
 class StyleRuleImport : public StyleRuleBase {
     USING_FAST_MALLOC_WILL_BE_REMOVED(StyleRuleImport);
-    WILL_BE_USING_PRE_FINALIZER(StyleRuleImport, dispose);
 public:
     static PassRefPtrWillBeRawPtr<StyleRuleImport> create(const String& href, PassRefPtrWillBeRawPtr<MediaQuerySet>);
 
@@ -83,15 +83,13 @@ private:
 
     StyleRuleImport(const String& href, PassRefPtrWillBeRawPtr<MediaQuerySet>);
 
-    void dispose();
-
     RawPtrWillBeMember<StyleSheetContents> m_parentStyleSheet;
 
     ImportedStyleSheetClient m_styleSheetClient;
     String m_strHref;
     RefPtrWillBeMember<MediaQuerySet> m_mediaQueries;
     RefPtrWillBeMember<StyleSheetContents> m_styleSheet;
-    RefPtrWillBeMember<CSSStyleSheetResource> m_resource;
+    ResourcePtr<CSSStyleSheetResource> m_resource;
     bool m_loading;
 };
 
diff --git a/third_party/WebKit/Source/core/dom/PendingScript.h b/third_party/WebKit/Source/core/dom/PendingScript.h
index e4269a3..1fdf269 100644
--- a/third_party/WebKit/Source/core/dom/PendingScript.h
+++ b/third_party/WebKit/Source/core/dom/PendingScript.h
@@ -42,7 +42,7 @@ class ScriptSourceCode;
 
 // A container for an external script which may be loaded and executed.
 //
-// A RefPtr alone does not prevent the underlying Resource
+// A ResourcePtr alone does not prevent the underlying Resource
 // from purging its data buffer. This class holds a dummy client open for its
 // lifetime in order to guarantee that the data buffer will not be purged.
 class CORE_EXPORT PendingScript final : public NoBaseWillBeGarbageCollectedFinalized<PendingScript>, public ResourceOwner<ScriptResource> {
diff --git a/third_party/WebKit/Source/core/dom/ProcessingInstruction.cpp b/third_party/WebKit/Source/core/dom/ProcessingInstruction.cpp
index c41eaf7..fd53c61 100644
--- a/third_party/WebKit/Source/core/dom/ProcessingInstruction.cpp
+++ b/third_party/WebKit/Source/core/dom/ProcessingInstruction.cpp
@@ -165,7 +165,7 @@ void ProcessingInstruction::process(const String& href, const String& charset)
 
     String url = document().completeURL(href).string();
 
-    RefPtrWillBeRawPtr<StyleSheetResource> resource = nullptr;
+    ResourcePtr<StyleSheetResource> resource;
     FetchRequest request(ResourceRequest(document().completeURL(href)), FetchInitiatorTypeNames::processinginstruction);
     if (m_isXSL) {
         if (RuntimeEnabledFeatures::xsltEnabled())
diff --git a/third_party/WebKit/Source/core/dom/ScriptLoader.cpp b/third_party/WebKit/Source/core/dom/ScriptLoader.cpp
index f861af8..1e990c2 100644
--- a/third_party/WebKit/Source/core/dom/ScriptLoader.cpp
+++ b/third_party/WebKit/Source/core/dom/ScriptLoader.cpp
@@ -59,6 +59,7 @@ namespace blink {
 
 ScriptLoader::ScriptLoader(Element* element, bool parserInserted, bool alreadyStarted)
     : m_element(element)
+    , m_resource(0)
     , m_startLineNumber(WTF::OrdinalNumber::beforeFirst())
     , m_parserInserted(parserInserted)
     , m_isExternalScript(false)
@@ -88,7 +89,6 @@ ScriptLoader::~ScriptLoader()
 DEFINE_TRACE(ScriptLoader)
 {
     visitor->trace(m_element);
-    visitor->trace(m_resource);
     visitor->trace(m_pendingScript);
 }
 
@@ -454,7 +454,7 @@ void ScriptLoader::execute()
         else
             dispatchErrorEvent();
     }
-    m_resource = nullptr;
+    m_resource = 0;
 }
 
 void ScriptLoader::notifyFinished(Resource* resource)
diff --git a/third_party/WebKit/Source/core/dom/ScriptLoader.h b/third_party/WebKit/Source/core/dom/ScriptLoader.h
index ae027ad..7b71d0c 100644
--- a/third_party/WebKit/Source/core/dom/ScriptLoader.h
+++ b/third_party/WebKit/Source/core/dom/ScriptLoader.h
@@ -25,6 +25,7 @@
 #include "core/dom/PendingScript.h"
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/ResourceClient.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/fetch/ScriptResource.h"
 #include "wtf/text/TextPosition.h"
 #include "wtf/text/WTFString.h"
@@ -68,7 +69,7 @@ public:
     bool willBeParserExecuted() const { return m_willBeParserExecuted; }
     bool readyToBeParserExecuted() const { return m_readyToBeParserExecuted; }
     bool willExecuteWhenDocumentFinishedParsing() const { return m_willExecuteWhenDocumentFinishedParsing; }
-    ScriptResource* resource() { return m_resource.get(); }
+    ResourcePtr<ScriptResource> resource() { return m_resource; }
 
     void setHaveFiredLoadEvent(bool haveFiredLoad) { m_haveFiredLoad = haveFiredLoad; }
     bool isParserInserted() const { return m_parserInserted; }
@@ -103,7 +104,7 @@ private:
     String debugName() const override { return "ScriptLoader"; }
 
     RawPtrWillBeMember<Element> m_element;
-    RefPtrWillBeMember<ScriptResource> m_resource;
+    ResourcePtr<ScriptResource> m_resource;
     WTF::OrdinalNumber m_startLineNumber;
     String m_characterEncoding;
     String m_fallbackCharacterEncoding;
diff --git a/third_party/WebKit/Source/core/dom/ScriptRunner.h b/third_party/WebKit/Source/core/dom/ScriptRunner.h
index 0303b62..a553e51 100644
--- a/third_party/WebKit/Source/core/dom/ScriptRunner.h
+++ b/third_party/WebKit/Source/core/dom/ScriptRunner.h
@@ -27,6 +27,7 @@
 #define ScriptRunner_h
 
 #include "core/CoreExport.h"
+#include "core/fetch/ResourcePtr.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Deque.h"
 #include "wtf/HashMap.h"
diff --git a/third_party/WebKit/Source/core/fetch/CSSStyleSheetResource.cpp b/third_party/WebKit/Source/core/fetch/CSSStyleSheetResource.cpp
index 29a0bfc..2151f9e 100644
--- a/third_party/WebKit/Source/core/fetch/CSSStyleSheetResource.cpp
+++ b/third_party/WebKit/Source/core/fetch/CSSStyleSheetResource.cpp
@@ -37,16 +37,16 @@
 
 namespace blink {
 
-PassRefPtrWillBeRawPtr<CSSStyleSheetResource> CSSStyleSheetResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<CSSStyleSheetResource> CSSStyleSheetResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
 {
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
     request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextStyle);
     return toCSSStyleSheetResource(fetcher->requestResource(request, CSSStyleSheetResourceFactory()));
 }
 
-PassRefPtrWillBeRawPtr<CSSStyleSheetResource> CSSStyleSheetResource::createForTest(const ResourceRequest& request, const String& charset)
+ResourcePtr<CSSStyleSheetResource> CSSStyleSheetResource::createForTest(const ResourceRequest& request, const String& charset)
 {
-    return adoptRefWillBeNoop(new CSSStyleSheetResource(request, charset));
+    return new CSSStyleSheetResource(request, charset);
 }
 
 CSSStyleSheetResource::CSSStyleSheetResource(const ResourceRequest& resourceRequest, const String& charset)
@@ -65,12 +65,11 @@ CSSStyleSheetResource::~CSSStyleSheetResource()
     ASSERT(!m_parsedStyleSheetCache);
 }
 
-void CSSStyleSheetResource::removedFromMemoryCache()
+void CSSStyleSheetResource::dispose()
 {
     if (m_parsedStyleSheetCache)
         m_parsedStyleSheetCache->removedFromMemoryCache();
     m_parsedStyleSheetCache.clear();
-    Resource::removedFromMemoryCache();
 }
 
 DEFINE_TRACE(CSSStyleSheetResource)
diff --git a/third_party/WebKit/Source/core/fetch/CSSStyleSheetResource.h b/third_party/WebKit/Source/core/fetch/CSSStyleSheetResource.h
index 8f6d75e..b462afd 100644
--- a/third_party/WebKit/Source/core/fetch/CSSStyleSheetResource.h
+++ b/third_party/WebKit/Source/core/fetch/CSSStyleSheetResource.h
@@ -27,6 +27,7 @@
 #define CSSStyleSheetResource_h
 
 #include "core/CoreExport.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/fetch/StyleSheetResource.h"
 #include "platform/heap/Handle.h"
 
@@ -42,8 +43,8 @@ class CORE_EXPORT CSSStyleSheetResource final : public StyleSheetResource {
 public:
     enum class MIMETypeCheck { Strict, Lax };
 
-    static PassRefPtrWillBeRawPtr<CSSStyleSheetResource> fetch(FetchRequest&, ResourceFetcher*);
-    static PassRefPtrWillBeRawPtr<CSSStyleSheetResource> createForTest(const ResourceRequest&, const String& charset);
+    static ResourcePtr<CSSStyleSheetResource> fetch(FetchRequest&, ResourceFetcher*);
+    static ResourcePtr<CSSStyleSheetResource> createForTest(const ResourceRequest&, const String& charset);
 
     ~CSSStyleSheetResource() override;
     DECLARE_VIRTUAL_TRACE();
@@ -68,15 +69,15 @@ private:
         CSSStyleSheetResourceFactory()
             : ResourceFactory(Resource::CSSStyleSheet) { }
 
-        PassRefPtrWillBeRawPtr<Resource> create(const ResourceRequest& request, const String& charset) const override
+        Resource* create(const ResourceRequest& request, const String& charset) const override
         {
-            return adoptRefWillBeNoop(new CSSStyleSheetResource(request, charset));
+            return new CSSStyleSheetResource(request, charset);
         }
     };
     CSSStyleSheetResource(const ResourceRequest&, const String& charset);
 
     bool canUseSheet(MIMETypeCheck) const;
-    void removedFromMemoryCache() override;
+    void dispose() override;
     void checkNotify() override;
 
     String m_decodedSheetText;
diff --git a/third_party/WebKit/Source/core/fetch/CachingCorrectnessTest.cpp b/third_party/WebKit/Source/core/fetch/CachingCorrectnessTest.cpp
index 5cdd739..d90176e 100644
--- a/third_party/WebKit/Source/core/fetch/CachingCorrectnessTest.cpp
+++ b/third_party/WebKit/Source/core/fetch/CachingCorrectnessTest.cpp
@@ -34,6 +34,7 @@
 #include "core/fetch/RawResource.h"
 #include "core/fetch/Resource.h"
 #include "core/fetch/ResourceFetcher.h"
+#include "core/fetch/ResourcePtr.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/testing/TestingPlatformSupport.h"
 #include "public/platform/Platform.h"
@@ -76,17 +77,17 @@ protected:
         m_proxyPlatform.advanceClock(seconds);
     }
 
-    PassRefPtrWillBeRawPtr<Resource> resourceFromResourceResponse(ResourceResponse response, Resource::Type type = Resource::Raw)
+    ResourcePtr<Resource> resourceFromResourceResponse(ResourceResponse response, Resource::Type type = Resource::Raw)
     {
         if (response.url().isNull())
             response.setURL(KURL(ParsedURLString, kResourceURL));
-        RefPtrWillBeRawPtr<Resource> resource = nullptr;
+        ResourcePtr<Resource> resource;
         switch (type) {
         case Resource::Raw:
-            resource = Resource::create(ResourceRequest(response.url()), type);
+            resource = new Resource(ResourceRequest(response.url()), type);
             break;
         case Resource::Image:
-            resource = ImageResource::create(ResourceRequest(response.url()), nullptr);
+            resource = new ImageResource(ResourceRequest(response.url()), nullptr);
             break;
         default:
             EXPECT_TRUE(false) << "'Unreachable' code was reached";
@@ -98,25 +99,25 @@ protected:
         return resource;
     }
 
-    PassRefPtrWillBeRawPtr<Resource> resourceFromResourceRequest(ResourceRequest request, Resource::Type type = Resource::Raw)
+    ResourcePtr<Resource> resourceFromResourceRequest(ResourceRequest request, Resource::Type type = Resource::Raw)
     {
         if (request.url().isNull())
             request.setURL(KURL(ParsedURLString, kResourceURL));
-        RefPtrWillBeRawPtr<Resource> resource =
-            Resource::create(request, type);
+        ResourcePtr<Resource> resource =
+            new Resource(request, type);
         resource->setResponse(ResourceResponse(KURL(ParsedURLString, kResourceURL), "text/html", 0, nullAtom, String()));
         memoryCache()->add(resource.get());
 
         return resource;
     }
 
-    PassRefPtrWillBeRawPtr<Resource> fetch()
+    ResourcePtr<Resource> fetch()
     {
         FetchRequest fetchRequest(ResourceRequest(KURL(ParsedURLString, kResourceURL)), FetchInitiatorInfo());
         return RawResource::fetchSynchronously(fetchRequest, fetcher());
     }
 
-    PassRefPtrWillBeRawPtr<Resource> fetchImage()
+    ResourcePtr<Resource> fetchImage()
     {
         FetchRequest fetchRequest(ResourceRequest(KURL(ParsedURLString, kResourceURL)), FetchInitiatorInfo());
         return ImageResource::fetch(fetchRequest, fetcher());
@@ -174,12 +175,12 @@ TEST_F(CachingCorrectnessTest, FreshFromLastModified)
     fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
     fresh200Response.setHTTPHeaderField("Last-Modified", kOneDayBeforeOriginalRequest);
 
-    RefPtrWillBeRawPtr<Resource> fresh200 = resourceFromResourceResponse(fresh200Response);
+    ResourcePtr<Resource> fresh200 = resourceFromResourceResponse(fresh200Response);
 
     // Advance the clock within the implicit freshness period of this resource before we make a request.
     advanceClock(600.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_EQ(fresh200, fetched);
 }
 
@@ -190,12 +191,12 @@ TEST_F(CachingCorrectnessTest, FreshFromExpires)
     fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
     fresh200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest);
 
-    RefPtrWillBeRawPtr<Resource> fresh200 = resourceFromResourceResponse(fresh200Response);
+    ResourcePtr<Resource> fresh200 = resourceFromResourceResponse(fresh200Response);
 
     // Advance the clock within the freshness period of this resource before we make a request.
     advanceClock(24. * 60. * 60. - 15.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_EQ(fresh200, fetched);
 }
 
@@ -206,12 +207,12 @@ TEST_F(CachingCorrectnessTest, FreshFromMaxAge)
     fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
     fresh200Response.setHTTPHeaderField("Cache-Control", "max-age=600");
 
-    RefPtrWillBeRawPtr<Resource> fresh200 = resourceFromResourceResponse(fresh200Response);
+    ResourcePtr<Resource> fresh200 = resourceFromResourceResponse(fresh200Response);
 
     // Advance the clock within the freshness period of this resource before we make a request.
     advanceClock(500.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_EQ(fresh200, fetched);
 }
 
@@ -223,12 +224,12 @@ TEST_F(CachingCorrectnessTest, DISABLED_ExpiredFromLastModified)
     expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
     expired200Response.setHTTPHeaderField("Last-Modified", kOneDayBeforeOriginalRequest);
 
-    RefPtrWillBeRawPtr<Resource> expired200 = resourceFromResourceResponse(expired200Response);
+    ResourcePtr<Resource> expired200 = resourceFromResourceResponse(expired200Response);
 
     // Advance the clock beyond the implicit freshness period.
     advanceClock(24. * 60. * 60. * 0.2);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_NE(expired200, fetched);
 }
 
@@ -239,12 +240,12 @@ TEST_F(CachingCorrectnessTest, ExpiredFromExpires)
     expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
     expired200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest);
 
-    RefPtrWillBeRawPtr<Resource> expired200 = resourceFromResourceResponse(expired200Response);
+    ResourcePtr<Resource> expired200 = resourceFromResourceResponse(expired200Response);
 
     // Advance the clock within the expiredness period of this resource before we make a request.
     advanceClock(24. * 60. * 60. + 15.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_NE(expired200, fetched);
 }
 
@@ -256,12 +257,12 @@ TEST_F(CachingCorrectnessTest, NewImageExpiredFromExpires)
     expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
     expired200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest);
 
-    RefPtrWillBeRawPtr<Resource> expired200 = resourceFromResourceResponse(expired200Response, Resource::Image);
+    ResourcePtr<Resource> expired200 = resourceFromResourceResponse(expired200Response, Resource::Image);
 
     // Advance the clock within the expiredness period of this resource before we make a request.
     advanceClock(24. * 60. * 60. + 15.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetchImage();
+    ResourcePtr<Resource> fetched = fetchImage();
     EXPECT_NE(expired200, fetched);
 }
 
@@ -274,17 +275,17 @@ TEST_F(CachingCorrectnessTest, ReuseImageExpiredFromExpires)
     expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
     expired200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest);
 
-    RefPtrWillBeRawPtr<Resource> expired200 = resourceFromResourceResponse(expired200Response, Resource::Image);
+    ResourcePtr<Resource> expired200 = resourceFromResourceResponse(expired200Response, Resource::Image);
 
     // Advance the clock within the freshness period, and make a request to add this image to the document resources.
     advanceClock(15.);
-    RefPtrWillBeRawPtr<Resource> firstFetched = fetchImage();
+    ResourcePtr<Resource> firstFetched = fetchImage();
     EXPECT_EQ(expired200, firstFetched);
 
     // Advance the clock within the expiredness period of this resource before we make a request.
     advanceClock(24. * 60. * 60. + 15.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetchImage();
+    ResourcePtr<Resource> fetched = fetchImage();
     EXPECT_EQ(expired200, fetched);
 }
 
@@ -295,12 +296,12 @@ TEST_F(CachingCorrectnessTest, ExpiredFromMaxAge)
     expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
     expired200Response.setHTTPHeaderField("Cache-Control", "max-age=600");
 
-    RefPtrWillBeRawPtr<Resource> expired200 = resourceFromResourceResponse(expired200Response);
+    ResourcePtr<Resource> expired200 = resourceFromResourceResponse(expired200Response);
 
     // Advance the clock within the expiredness period of this resource before we make a request.
     advanceClock(700.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_NE(expired200, fetched);
 }
 
@@ -312,12 +313,12 @@ TEST_F(CachingCorrectnessTest, FreshButNoCache)
     fresh200NocacheResponse.setHTTPHeaderField(HTTPNames::Expires, kOneDayAfterOriginalRequest);
     fresh200NocacheResponse.setHTTPHeaderField(HTTPNames::Cache_Control, "no-cache");
 
-    RefPtrWillBeRawPtr<Resource> fresh200Nocache = resourceFromResourceResponse(fresh200NocacheResponse);
+    ResourcePtr<Resource> fresh200Nocache = resourceFromResourceResponse(fresh200NocacheResponse);
 
     // Advance the clock within the freshness period of this resource before we make a request.
     advanceClock(24. * 60. * 60. - 15.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_NE(fresh200Nocache, fetched);
 }
 
@@ -325,8 +326,8 @@ TEST_F(CachingCorrectnessTest, RequestWithNoCahe)
 {
     ResourceRequest noCacheRequest;
     noCacheRequest.setHTTPHeaderField(HTTPNames::Cache_Control, "no-cache");
-    RefPtrWillBeRawPtr<Resource> noCacheResource = resourceFromResourceRequest(noCacheRequest);
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> noCacheResource = resourceFromResourceRequest(noCacheRequest);
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_NE(noCacheResource, fetched);
 }
 
@@ -338,12 +339,12 @@ TEST_F(CachingCorrectnessTest, FreshButNoStore)
     fresh200NostoreResponse.setHTTPHeaderField(HTTPNames::Expires, kOneDayAfterOriginalRequest);
     fresh200NostoreResponse.setHTTPHeaderField(HTTPNames::Cache_Control, "no-store");
 
-    RefPtrWillBeRawPtr<Resource> fresh200Nostore = resourceFromResourceResponse(fresh200NostoreResponse);
+    ResourcePtr<Resource> fresh200Nostore = resourceFromResourceResponse(fresh200NostoreResponse);
 
     // Advance the clock within the freshness period of this resource before we make a request.
     advanceClock(24. * 60. * 60. - 15.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_NE(fresh200Nostore, fetched);
 }
 
@@ -351,8 +352,8 @@ TEST_F(CachingCorrectnessTest, RequestWithNoStore)
 {
     ResourceRequest noStoreRequest;
     noStoreRequest.setHTTPHeaderField(HTTPNames::Cache_Control, "no-store");
-    RefPtrWillBeRawPtr<Resource> noStoreResource = resourceFromResourceRequest(noStoreRequest);
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> noStoreResource = resourceFromResourceRequest(noStoreRequest);
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_NE(noStoreResource, fetched);
 }
 
@@ -366,12 +367,12 @@ TEST_F(CachingCorrectnessTest, DISABLED_FreshButMustRevalidate)
     fresh200MustRevalidateResponse.setHTTPHeaderField(HTTPNames::Expires, kOneDayAfterOriginalRequest);
     fresh200MustRevalidateResponse.setHTTPHeaderField(HTTPNames::Cache_Control, "must-revalidate");
 
-    RefPtrWillBeRawPtr<Resource> fresh200MustRevalidate = resourceFromResourceResponse(fresh200MustRevalidateResponse);
+    ResourcePtr<Resource> fresh200MustRevalidate = resourceFromResourceResponse(fresh200MustRevalidateResponse);
 
     // Advance the clock within the freshness period of this resource before we make a request.
     advanceClock(24. * 60. * 60. - 15.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_NE(fresh200MustRevalidate, fetched);
 }
 
@@ -381,7 +382,7 @@ TEST_F(CachingCorrectnessTest, FreshWithFreshRedirect)
     const char redirectTargetUrlString[] = "http://redirect-target.com";
     KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString);
 
-    RefPtrWillBeRawPtr<Resource> firstResource = Resource::create(ResourceRequest(redirectUrl), Resource::Raw);
+    ResourcePtr<Resource> firstResource = new Resource(ResourceRequest(redirectUrl), Resource::Raw);
 
     ResourceResponse fresh301Response;
     fresh301Response.setURL(redirectUrl);
@@ -406,7 +407,7 @@ TEST_F(CachingCorrectnessTest, FreshWithFreshRedirect)
 
     advanceClock(500.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_EQ(firstResource, fetched);
 }
 
@@ -416,7 +417,7 @@ TEST_F(CachingCorrectnessTest, FreshWithStaleRedirect)
     const char redirectTargetUrlString[] = "http://redirect-target.com";
     KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString);
 
-    RefPtrWillBeRawPtr<Resource> firstResource = Resource::create(ResourceRequest(redirectUrl), Resource::Raw);
+    ResourcePtr<Resource> firstResource = new Resource(ResourceRequest(redirectUrl), Resource::Raw);
 
     ResourceResponse stale301Response;
     stale301Response.setURL(redirectUrl);
@@ -440,7 +441,7 @@ TEST_F(CachingCorrectnessTest, FreshWithStaleRedirect)
 
     advanceClock(500.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_NE(firstResource, fetched);
 }
 
@@ -448,14 +449,14 @@ TEST_F(CachingCorrectnessTest, PostToSameURLTwice)
 {
     ResourceRequest request1(KURL(ParsedURLString, kResourceURL));
     request1.setHTTPMethod(HTTPNames::POST);
-    RefPtrWillBeRawPtr<Resource> resource1 = Resource::create(ResourceRequest(request1.url()), Resource::Raw);
+    ResourcePtr<Resource> resource1 = new Resource(ResourceRequest(request1.url()), Resource::Raw);
     resource1->setLoading(true);
     memoryCache()->add(resource1.get());
 
     ResourceRequest request2(KURL(ParsedURLString, kResourceURL));
     request2.setHTTPMethod(HTTPNames::POST);
     FetchRequest fetch2(request2, FetchInitiatorInfo());
-    RefPtrWillBeRawPtr<Resource> resource2 = RawResource::fetchSynchronously(fetch2, fetcher());
+    ResourcePtr<Resource> resource2 = RawResource::fetchSynchronously(fetch2, fetcher());
 
     EXPECT_EQ(resource2, memoryCache()->resourceForURL(request2.url()));
     EXPECT_NE(resource1, resource2);
@@ -467,7 +468,7 @@ TEST_F(CachingCorrectnessTest, 302RedirectNotImplicitlyFresh)
     const char redirectTargetUrlString[] = "http://redirect-target.com";
     KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString);
 
-    RefPtrWillBeRawPtr<Resource> firstResource = Resource::create(ResourceRequest(redirectUrl), Resource::Raw);
+    ResourcePtr<Resource> firstResource = new Resource(ResourceRequest(redirectUrl), Resource::Raw);
 
     ResourceResponse fresh302Response;
     fresh302Response.setURL(redirectUrl);
@@ -492,7 +493,7 @@ TEST_F(CachingCorrectnessTest, 302RedirectNotImplicitlyFresh)
 
     advanceClock(500.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_NE(firstResource, fetched);
 }
 
@@ -502,7 +503,7 @@ TEST_F(CachingCorrectnessTest, 302RedirectExplicitlyFreshMaxAge)
     const char redirectTargetUrlString[] = "http://redirect-target.com";
     KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString);
 
-    RefPtrWillBeRawPtr<Resource> firstResource = Resource::create(ResourceRequest(redirectUrl), Resource::Raw);
+    ResourcePtr<Resource> firstResource = new Resource(ResourceRequest(redirectUrl), Resource::Raw);
 
     ResourceResponse fresh302Response;
     fresh302Response.setURL(redirectUrl);
@@ -527,7 +528,7 @@ TEST_F(CachingCorrectnessTest, 302RedirectExplicitlyFreshMaxAge)
 
     advanceClock(500.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_EQ(firstResource, fetched);
 }
 
@@ -537,7 +538,7 @@ TEST_F(CachingCorrectnessTest, 302RedirectExplicitlyFreshExpires)
     const char redirectTargetUrlString[] = "http://redirect-target.com";
     KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString);
 
-    RefPtrWillBeRawPtr<Resource> firstResource = Resource::create(ResourceRequest(redirectUrl), Resource::Raw);
+    ResourcePtr<Resource> firstResource = new Resource(ResourceRequest(redirectUrl), Resource::Raw);
 
     ResourceResponse fresh302Response;
     fresh302Response.setURL(redirectUrl);
@@ -562,7 +563,7 @@ TEST_F(CachingCorrectnessTest, 302RedirectExplicitlyFreshExpires)
 
     advanceClock(500.);
 
-    RefPtrWillBeRawPtr<Resource> fetched = fetch();
+    ResourcePtr<Resource> fetched = fetch();
     EXPECT_EQ(firstResource, fetched);
 }
 
diff --git a/third_party/WebKit/Source/core/fetch/DocumentResource.cpp b/third_party/WebKit/Source/core/fetch/DocumentResource.cpp
index aab75f7..5396803 100644
--- a/third_party/WebKit/Source/core/fetch/DocumentResource.cpp
+++ b/third_party/WebKit/Source/core/fetch/DocumentResource.cpp
@@ -30,7 +30,7 @@
 
 namespace blink {
 
-PassRefPtrWillBeRawPtr<DocumentResource> DocumentResource::fetchSVGDocument(FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<DocumentResource> DocumentResource::fetchSVGDocument(FetchRequest& request, ResourceFetcher* fetcher)
 {
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
     request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextImage);
diff --git a/third_party/WebKit/Source/core/fetch/DocumentResource.h b/third_party/WebKit/Source/core/fetch/DocumentResource.h
index fbbf7e5..326e2a5 100644
--- a/third_party/WebKit/Source/core/fetch/DocumentResource.h
+++ b/third_party/WebKit/Source/core/fetch/DocumentResource.h
@@ -25,6 +25,7 @@
 
 #include "core/fetch/Resource.h"
 #include "core/fetch/ResourceClient.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/html/parser/TextResourceDecoder.h"
 
 namespace blink {
@@ -37,7 +38,7 @@ class DocumentResource final : public Resource {
 public:
     using ClientType = ResourceClient;
 
-    static PassRefPtrWillBeRawPtr<DocumentResource> fetchSVGDocument(FetchRequest&, ResourceFetcher*);
+    static ResourcePtr<DocumentResource> fetchSVGDocument(FetchRequest&, ResourceFetcher*);
     ~DocumentResource() override;
     DECLARE_VIRTUAL_TRACE();
 
@@ -53,9 +54,9 @@ private:
         SVGDocumentResourceFactory()
             : ResourceFactory(Resource::SVGDocument) { }
 
-        PassRefPtrWillBeRawPtr<Resource> create(const ResourceRequest& request, const String& charset) const override
+        Resource* create(const ResourceRequest& request, const String& charset) const override
         {
-            return adoptRefWillBeNoop(new DocumentResource(request, Resource::SVGDocument));
+            return new DocumentResource(request, Resource::SVGDocument);
         }
     };
     DocumentResource(const ResourceRequest&, Type);
@@ -67,7 +68,7 @@ private:
 };
 
 DEFINE_TYPE_CASTS(DocumentResource, Resource, resource, resource->type() == Resource::SVGDocument, resource.type() == Resource::SVGDocument); \
-inline DocumentResource* toDocumentResource(const RefPtrWillBeRawPtr<Resource>& ptr) { return toDocumentResource(ptr.get()); }
+inline DocumentResource* toDocumentResource(const ResourcePtr<Resource>& ptr) { return toDocumentResource(ptr.get()); }
 
 class DocumentResourceClient : public ResourceClient {
 public:
diff --git a/third_party/WebKit/Source/core/fetch/DocumentResourceReference.h b/third_party/WebKit/Source/core/fetch/DocumentResourceReference.h
index fff7f74..56f7280 100644
--- a/third_party/WebKit/Source/core/fetch/DocumentResourceReference.h
+++ b/third_party/WebKit/Source/core/fetch/DocumentResourceReference.h
@@ -27,6 +27,7 @@
 #define DocumentResourceReference_h
 
 #include "core/fetch/DocumentResource.h"
+#include "core/fetch/ResourcePtr.h"
 
 namespace blink {
 
@@ -38,7 +39,7 @@ public:
     DocumentResource* document() { return m_document.get(); }
 private:
     String debugName() const override { return "DocumentResourceReference"; }
-    RefPtrWillBePersistent<DocumentResource> m_document;
+    ResourcePtr<DocumentResource> m_document;
 };
 
 } // namespace blink
diff --git a/third_party/WebKit/Source/core/fetch/FontResource.cpp b/third_party/WebKit/Source/core/fetch/FontResource.cpp
index 10cb041..48b48ae 100644
--- a/third_party/WebKit/Source/core/fetch/FontResource.cpp
+++ b/third_party/WebKit/Source/core/fetch/FontResource.cpp
@@ -69,7 +69,7 @@ static void recordPackageFormatHistogram(FontPackageFormat format)
     Platform::current()->histogramEnumeration("WebFont.PackageFormat", format, PackageFormatEnumMax);
 }
 
-PassRefPtrWillBeRawPtr<FontResource> FontResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<FontResource> FontResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
 {
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
     request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextFont);
diff --git a/third_party/WebKit/Source/core/fetch/FontResource.h b/third_party/WebKit/Source/core/fetch/FontResource.h
index 3bda896..7586499 100644
--- a/third_party/WebKit/Source/core/fetch/FontResource.h
+++ b/third_party/WebKit/Source/core/fetch/FontResource.h
@@ -26,8 +26,8 @@
 #ifndef FontResource_h
 #define FontResource_h
 
-#include "core/fetch/Resource.h"
 #include "core/fetch/ResourceClient.h"
+#include "core/fetch/ResourcePtr.h"
 #include "platform/Timer.h"
 #include "platform/fonts/FontOrientation.h"
 #include "wtf/OwnPtr.h"
@@ -38,13 +38,12 @@ class FetchRequest;
 class ResourceFetcher;
 class FontPlatformData;
 class FontCustomPlatformData;
-class FontResourceClient;
 
 class FontResource final : public Resource {
 public:
-    using ClientType = FontResourceClient;
+    using ClientType = ResourceClient;
 
-    static PassRefPtrWillBeRawPtr<FontResource> fetch(FetchRequest&, ResourceFetcher*);
+    static ResourcePtr<FontResource> fetch(FetchRequest&, ResourceFetcher*);
     ~FontResource() override;
 
     void load(ResourceFetcher*, const ResourceLoaderOptions&) override;
@@ -75,9 +74,9 @@ private:
         FontResourceFactory()
             : ResourceFactory(Resource::Font) { }
 
-        PassRefPtrWillBeRawPtr<Resource> create(const ResourceRequest& request, const String& charset) const override
+        Resource* create(const ResourceRequest& request, const String& charset) const override
         {
-            return adoptRefWillBeNoop(new FontResource(request));
+            return new FontResource(request);
         }
     };
     FontResource(const ResourceRequest&);
diff --git a/third_party/WebKit/Source/core/fetch/ImageResource.cpp b/third_party/WebKit/Source/core/fetch/ImageResource.cpp
index 8a61421..6395714 100644
--- a/third_party/WebKit/Source/core/fetch/ImageResource.cpp
+++ b/third_party/WebKit/Source/core/fetch/ImageResource.cpp
@@ -41,7 +41,7 @@
 
 namespace blink {
 
-PassRefPtrWillBeRawPtr<ImageResource> ImageResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<ImageResource> ImageResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
 {
     if (request.resourceRequest().requestContext() == WebURLRequest::RequestContextUnspecified)
         request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextImage);
@@ -49,7 +49,7 @@ PassRefPtrWillBeRawPtr<ImageResource> ImageResource::fetch(FetchRequest& request
         KURL requestURL = request.resourceRequest().url();
         if (requestURL.isValid() && fetcher->context().canRequest(Resource::Image, request.resourceRequest(), requestURL, request.options(), request.forPreload(), request.originRestriction()))
             fetcher->context().sendImagePing(requestURL);
-        return nullptr;
+        return 0;
     }
 
     if (fetcher->clientDefersImage(request.resourceRequest().url()))
diff --git a/third_party/WebKit/Source/core/fetch/ImageResource.h b/third_party/WebKit/Source/core/fetch/ImageResource.h
index 31ac208..5776aaf 100644
--- a/third_party/WebKit/Source/core/fetch/ImageResource.h
+++ b/third_party/WebKit/Source/core/fetch/ImageResource.h
@@ -24,7 +24,7 @@
 #define ImageResource_h
 
 #include "core/CoreExport.h"
-#include "core/fetch/Resource.h"
+#include "core/fetch/ResourcePtr.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/geometry/IntSizeHash.h"
 #include "platform/geometry/LayoutSize.h"
@@ -48,20 +48,11 @@ class CORE_EXPORT ImageResource final : public Resource, public ImageObserver {
 public:
     using ClientType = ImageResourceClient;
 
-    static PassRefPtrWillBeRawPtr<ImageResource> fetch(FetchRequest&, ResourceFetcher*);
-
-    static PassRefPtrWillBeRawPtr<ImageResource> create(blink::Image* image)
-    {
-        return adoptRefWillBeNoop(new ImageResource(image));
-    }
+    static ResourcePtr<ImageResource> fetch(FetchRequest&, ResourceFetcher*);
 
+    ImageResource(blink::Image*);
     // Exposed for testing
-    static PassRefPtrWillBeRawPtr<ImageResource> create(const ResourceRequest& request, blink::Image* image)
-    {
-        return adoptRefWillBeNoop(new ImageResource(request, image));
-    }
-
-
+    ImageResource(const ResourceRequest&, blink::Image*);
     ~ImageResource() override;
 
     void load(ResourceFetcher*, const ResourceLoaderOptions&) override;
@@ -125,17 +116,14 @@ protected:
 private:
     friend class PaintLayerTest;
 
-    explicit ImageResource(blink::Image*);
-    ImageResource(const ResourceRequest&, blink::Image*);
-
     class ImageResourceFactory : public ResourceFactory {
     public:
         ImageResourceFactory()
             : ResourceFactory(Resource::Image) { }
 
-        PassRefPtrWillBeRawPtr<Resource> create(const ResourceRequest& request, const String&) const override
+        Resource* create(const ResourceRequest& request, const String&) const override
         {
-            return adoptRefWillBeNoop(new ImageResource(request));
+            return new ImageResource(request);
         }
     };
     ImageResource(const ResourceRequest&);
diff --git a/third_party/WebKit/Source/core/fetch/ImageResourceTest.cpp b/third_party/WebKit/Source/core/fetch/ImageResourceTest.cpp
index 6631f9e..9f13c66 100644
--- a/third_party/WebKit/Source/core/fetch/ImageResourceTest.cpp
+++ b/third_party/WebKit/Source/core/fetch/ImageResourceTest.cpp
@@ -35,6 +35,7 @@
 #include "core/fetch/MockImageResourceClient.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/fetch/ResourceLoader.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/fetch/UniqueIdentifier.h"
 #include "platform/SharedBuffer.h"
 #include "platform/exported/WrappedResourceResponse.h"
@@ -88,7 +89,7 @@ TEST(ImageResourceTest, MultipartImage)
     URLTestHelpers::registerMockedURLLoad(testURL, "cancelTest.html", "text/html");
 
     // Emulate starting a real load, but don't expect any "real" WebURLLoaderClient callbacks.
-    RefPtrWillBeRawPtr<ImageResource> cachedImage = ImageResource::create(ResourceRequest(testURL), nullptr);
+    ResourcePtr<ImageResource> cachedImage = new ImageResource(ResourceRequest(testURL), nullptr);
     cachedImage->setIdentifier(createUniqueIdentifier());
     cachedImage->load(fetcher, ResourceLoaderOptions());
     Platform::current()->unitTestSupport()->unregisterMockedURL(testURL);
@@ -144,7 +145,7 @@ TEST(ImageResourceTest, CancelOnDetach)
     ResourceFetcher* fetcher = ResourceFetcher::create(nullptr);
 
     // Emulate starting a real load.
-    RefPtrWillBeRawPtr<ImageResource> cachedImage = ImageResource::create(ResourceRequest(testURL), nullptr);
+    ResourcePtr<ImageResource> cachedImage = new ImageResource(ResourceRequest(testURL), nullptr);
     cachedImage->setIdentifier(createUniqueIdentifier());
 
     cachedImage->load(fetcher, ResourceLoaderOptions());
@@ -168,7 +169,7 @@ TEST(ImageResourceTest, CancelOnDetach)
 
 TEST(ImageResourceTest, DecodedDataRemainsWhileHasClients)
 {
-    RefPtrWillBeRawPtr<ImageResource> cachedImage = ImageResource::create(ResourceRequest(), nullptr);
+    ResourcePtr<ImageResource> cachedImage = new ImageResource(ResourceRequest(), nullptr);
     cachedImage->setLoading(true);
 
     MockImageResourceClient client(cachedImage);
@@ -201,7 +202,7 @@ TEST(ImageResourceTest, DecodedDataRemainsWhileHasClients)
 
 TEST(ImageResourceTest, UpdateBitmapImages)
 {
-    RefPtrWillBeRawPtr<ImageResource> cachedImage = ImageResource::create(ResourceRequest(), nullptr);
+    ResourcePtr<ImageResource> cachedImage = new ImageResource(ResourceRequest(), nullptr);
     cachedImage->setLoading(true);
 
     MockImageResourceClient client(cachedImage);
diff --git a/third_party/WebKit/Source/core/fetch/LinkFetchResource.cpp b/third_party/WebKit/Source/core/fetch/LinkFetchResource.cpp
index 2c92ed8..65653f1 100644
--- a/third_party/WebKit/Source/core/fetch/LinkFetchResource.cpp
+++ b/third_party/WebKit/Source/core/fetch/LinkFetchResource.cpp
@@ -10,7 +10,7 @@
 
 namespace blink {
 
-PassRefPtrWillBeRawPtr<Resource> LinkFetchResource::fetch(Resource::Type type, FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<Resource> LinkFetchResource::fetch(Resource::Type type, FetchRequest& request, ResourceFetcher* fetcher)
 {
     ASSERT(type == LinkPrefetch);
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
diff --git a/third_party/WebKit/Source/core/fetch/LinkFetchResource.h b/third_party/WebKit/Source/core/fetch/LinkFetchResource.h
index 62d7131..654716d 100644
--- a/third_party/WebKit/Source/core/fetch/LinkFetchResource.h
+++ b/third_party/WebKit/Source/core/fetch/LinkFetchResource.h
@@ -8,6 +8,7 @@
 
 #include "core/fetch/Resource.h"
 #include "core/fetch/ResourceClient.h"
+#include "core/fetch/ResourcePtr.h"
 
 namespace blink {
 
@@ -18,7 +19,7 @@ class LinkFetchResource final : public Resource {
 public:
     using ClientType = ResourceClient;
 
-    static PassRefPtrWillBeRawPtr<Resource> fetch(Resource::Type, FetchRequest&, ResourceFetcher*);
+    static ResourcePtr<Resource> fetch(Resource::Type, FetchRequest&, ResourceFetcher*);
     ~LinkFetchResource() override;
 
 private:
@@ -27,9 +28,9 @@ private:
         LinkResourceFactory(Resource::Type type)
             : ResourceFactory(type) { }
 
-        PassRefPtrWillBeRawPtr<Resource> create(const ResourceRequest& request, const String& charset) const override
+        Resource* create(const ResourceRequest& request, const String& charset) const override
         {
-            return adoptRefWillBeNoop(new LinkFetchResource(request, type()));
+            return new LinkFetchResource(request, type());
         }
     };
     LinkFetchResource(const ResourceRequest&, Type);
diff --git a/third_party/WebKit/Source/core/fetch/MemoryCache.cpp b/third_party/WebKit/Source/core/fetch/MemoryCache.cpp
index 6edb7ce..cefaf93 100644
--- a/third_party/WebKit/Source/core/fetch/MemoryCache.cpp
+++ b/third_party/WebKit/Source/core/fetch/MemoryCache.cpp
@@ -22,6 +22,7 @@
 
 #include "core/fetch/MemoryCache.h"
 
+#include "core/fetch/ResourcePtr.h"
 #include "core/fetch/WebCacheMemoryDumpProvider.h"
 #include "platform/Logging.h"
 #include "platform/TraceEvent.h"
@@ -55,6 +56,12 @@ MemoryCache* memoryCache()
 
 MemoryCache* replaceMemoryCacheForTesting(MemoryCache* cache)
 {
+#if ENABLE(OILPAN)
+    // Move m_liveResources content to keep Resource objects alive.
+    for (const auto& resource : memoryCache()->m_liveResources)
+        cache->m_liveResources.add(resource);
+    memoryCache()->m_liveResources.clear();
+#endif
     memoryCache();
     MemoryCache* oldCache = gMemoryCache->release();
     *gMemoryCache = cache;
@@ -64,7 +71,6 @@ MemoryCache* replaceMemoryCacheForTesting(MemoryCache* cache)
 
 DEFINE_TRACE(MemoryCacheEntry)
 {
-    visitor->trace(m_resource);
     visitor->trace(m_previousInLiveResourcesList);
     visitor->trace(m_nextInLiveResourcesList);
     visitor->trace(m_previousInAllResourcesList);
@@ -73,7 +79,6 @@ DEFINE_TRACE(MemoryCacheEntry)
 
 void MemoryCacheEntry::dispose()
 {
-    m_resource->removedFromMemoryCache();
     m_resource.clear();
 }
 
@@ -125,6 +130,9 @@ DEFINE_TRACE(MemoryCache)
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(m_liveDecodedResources); ++i)
         visitor->trace(m_liveDecodedResources[i]);
     visitor->trace(m_resourceMaps);
+#if ENABLE(OILPAN)
+    visitor->trace(m_liveResources);
+#endif
 }
 
 KURL MemoryCache::removeFragmentIdentifierIfNeeded(const KURL& originalURL)
@@ -199,8 +207,12 @@ Resource* MemoryCache::resourceForURL(const KURL& resourceURL, const String& cac
     if (!entry)
         return nullptr;
     Resource* resource = entry->m_resource.get();
-    if (resource && !resource->lock())
+    if (resource && !resource->lock()) {
+        ASSERT(!resource->hasClients());
+        bool didEvict = evict(entry);
+        ASSERT_UNUSED(didEvict, didEvict);
         return nullptr;
+    }
     return resource;
 }
 
@@ -288,6 +300,24 @@ void MemoryCache::pruneDeadResources(PruneStrategy strategy)
     size_t targetSize = static_cast<size_t>(capacity * cTargetPrunePercentage); // Cut by a percentage to avoid immediately pruning again.
 
     int size = m_allResources.size();
+
+    // See if we have any purged resources we can evict.
+    for (int i = 0; i < size; i++) {
+        MemoryCacheEntry* current = m_allResources[i].m_tail;
+        while (current) {
+            MemoryCacheEntry* previous = current->m_previousInAllResourcesList;
+            // Main Resources in the cache are only substitue data that was
+            // precached and should not be evicted.
+            if (current->m_resource->wasPurged() && current->m_resource->canDelete()
+                && current->m_resource->type() != Resource::MainResource) {
+                ASSERT(!current->m_resource->hasClients());
+                ASSERT(!current->m_resource->isPreloaded());
+                bool wasEvicted = evict(current);
+                ASSERT_UNUSED(wasEvicted, wasEvicted);
+            }
+            current = previous;
+        }
+    }
     if (targetSize && m_deadSize <= targetSize)
         return;
 
@@ -327,8 +357,13 @@ void MemoryCache::pruneDeadResources(PruneStrategy strategy)
                 ASSERT(previous->m_resource);
                 ASSERT(contains(previous->m_resource.get()));
             }
-            if (!current->m_resource->hasClients() && !current->m_resource->isPreloaded()) {
-                evict(current);
+            if (!current->m_resource->hasClients() && !current->m_resource->isPreloaded()
+                && !current->m_resource->isCacheValidator() && current->m_resource->canDelete()
+                && current->m_resource->type() != Resource::MainResource) {
+                // Main Resources in the cache are only substitue data that was
+                // precached and should not be evicted.
+                bool wasEvicted = evict(current);
+                ASSERT_UNUSED(wasEvicted, wasEvicted);
                 if (targetSize && m_deadSize <= targetSize)
                     return;
             }
@@ -357,11 +392,12 @@ void MemoryCache::setCapacities(size_t minDeadBytes, size_t maxDeadBytes, size_t
     prune();
 }
 
-void MemoryCache::evict(MemoryCacheEntry* entry)
+bool MemoryCache::evict(MemoryCacheEntry* entry)
 {
     ASSERT(WTF::isMainThread());
 
     Resource* resource = entry->m_resource.get();
+    bool canDelete = resource->canDelete();
     WTF_LOG(ResourceLoading, "Evicting resource %p for '%s' from cache", resource, resource->url().string().latin1().data());
     // The resource may have already been removed by someone other than our caller,
     // who needed a fresh copy for a reload. See <http://bugs.webkit.org/show_bug.cgi?id=12479#c6>.
@@ -377,6 +413,8 @@ void MemoryCache::evict(MemoryCacheEntry* entry)
     resources->remove(it);
     if (entryPtr)
         entryPtr->dispose();
+
+    return canDelete;
 }
 
 MemoryCacheEntry* MemoryCache::getEntryForResource(const Resource* resource) const
@@ -590,15 +628,17 @@ void MemoryCache::removeURLFromCache(const KURL& url)
 
 void MemoryCache::TypeStatistic::addResource(Resource* o)
 {
-    bool purgeable = o->isPurgeable();
+    bool purged = o->wasPurged();
+    bool purgeable = o->isPurgeable() && !purged;
     size_t pageSize = (o->encodedSize() + o->overheadSize() + 4095) & ~4095;
     count++;
-    size += o->size();
+    size += purged ? 0 : o->size();
     liveSize += o->hasClients() ? o->size() : 0;
     decodedSize += o->decodedSize();
     encodedSize += o->encodedSize();
     encodedSizeDuplicatedInDataURLs += o->url().protocolIsData() ? o->encodedSize() : 0;
     purgeableSize += purgeable ? pageSize : 0;
+    purgedSize += purged ? pageSize : 0;
 }
 
 MemoryCache::Statistics MemoryCache::getStatistics()
@@ -755,6 +795,22 @@ bool MemoryCache::isInSameLRUListForTest(const Resource* x, const Resource* y)
     return lruListFor(ex->m_accessCount, x->size()) == lruListFor(ey->m_accessCount, y->size());
 }
 
+void MemoryCache::registerLiveResource(Resource& resource)
+{
+#if ENABLE(OILPAN)
+    ASSERT(!m_liveResources.contains(&resource));
+    m_liveResources.add(&resource);
+#endif
+}
+
+void MemoryCache::unregisterLiveResource(Resource& resource)
+{
+#if ENABLE(OILPAN)
+    ASSERT(m_liveResources.contains(&resource));
+    m_liveResources.remove(&resource);
+#endif
+}
+
 #ifdef MEMORY_CACHE_STATS
 
 void MemoryCache::dumpStats(Timer<MemoryCache>*)
@@ -781,16 +837,16 @@ void MemoryCache::dumpStats(Timer<MemoryCache>*)
 
 void MemoryCache::dumpLRULists(bool includeLive) const
 {
-    printf("LRU-SP lists in eviction order (Kilobytes decoded, Kilobytes encoded, Access count, Referenced, isPurgeable):\n");
+    printf("LRU-SP lists in eviction order (Kilobytes decoded, Kilobytes encoded, Access count, Referenced, isPurgeable, wasPurged):\n");
 
     int size = m_allResources.size();
     for (int i = size - 1; i >= 0; i--) {
         printf("\n\nList %d: ", i);
         MemoryCacheEntry* current = m_allResources[i].m_tail;
         while (current) {
-            RefPtrWillBeRawPtr<Resource> currentResource = current->m_resource;
+            ResourcePtr<Resource> currentResource = current->m_resource;
             if (includeLive || !currentResource->hasClients())
-                printf("(%.1fK, %.1fK, %uA, %dR, %d); ", currentResource->decodedSize() / 1024.0f, (currentResource->encodedSize() + currentResource->overheadSize()) / 1024.0f, current->m_accessCount, currentResource->hasClients(), currentResource->isPurgeable());
+                printf("(%.1fK, %.1fK, %uA, %dR, %d, %d); ", currentResource->decodedSize() / 1024.0f, (currentResource->encodedSize() + currentResource->overheadSize()) / 1024.0f, current->m_accessCount, currentResource->hasClients(), currentResource->isPurgeable(), currentResource->wasPurged());
 
             current = current->m_previousInAllResourcesList;
         }
diff --git a/third_party/WebKit/Source/core/fetch/MemoryCache.h b/third_party/WebKit/Source/core/fetch/MemoryCache.h
index 987666f..43739bb 100644
--- a/third_party/WebKit/Source/core/fetch/MemoryCache.h
+++ b/third_party/WebKit/Source/core/fetch/MemoryCache.h
@@ -27,6 +27,7 @@
 
 #include "core/CoreExport.h"
 #include "core/fetch/Resource.h"
+#include "core/fetch/ResourcePtr.h"
 #include "public/platform/WebMemoryDumpProvider.h"
 #include "public/platform/WebThread.h"
 #include "wtf/Allocator.h"
@@ -83,7 +84,7 @@ public:
     DECLARE_TRACE();
     void dispose();
 
-    RefPtrWillBeMember<Resource> m_resource;
+    ResourcePtr<Resource> m_resource;
     bool m_inLiveDecodedResourcesList;
     unsigned m_accessCount;
     MemoryCacheLiveResourcePriority m_liveResourcePriority;
@@ -272,7 +273,7 @@ private:
     void pruneLiveResources(PruneStrategy);
     void pruneNow(double currentTime, PruneStrategy);
 
-    void evict(MemoryCacheEntry*);
+    bool evict(MemoryCacheEntry*);
 
     MemoryCacheEntry* getEntryForResource(const Resource*) const;
 
@@ -310,6 +311,15 @@ private:
     ResourceMap* ensureResourceMap(const String& cacheIdentifier);
     ResourceMapIndex m_resourceMaps;
 
+#if ENABLE(OILPAN)
+    // Unlike m_allResources, m_liveResources is a set of Resource objects which
+    // should not be deleted. m_allResources only contains on-cache Resource
+    // objects.
+    // FIXME: Can we remove manual lifetime management of Resource and this?
+    HeapHashSet<Member<Resource>> m_liveResources;
+    friend CORE_EXPORT MemoryCache* replaceMemoryCacheForTesting(MemoryCache*);
+#endif
+
     friend class MemoryCacheTest;
 #ifdef MEMORY_CACHE_STATS
     Timer<MemoryCache> m_statsTimer;
diff --git a/third_party/WebKit/Source/core/fetch/MemoryCacheTest.cpp b/third_party/WebKit/Source/core/fetch/MemoryCacheTest.cpp
index 4facb09..a2430bb 100644
--- a/third_party/WebKit/Source/core/fetch/MemoryCacheTest.cpp
+++ b/third_party/WebKit/Source/core/fetch/MemoryCacheTest.cpp
@@ -32,6 +32,7 @@
 
 #include "core/fetch/MockImageResourceClient.h"
 #include "core/fetch/RawResource.h"
+#include "core/fetch/ResourcePtr.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/Platform.h"
@@ -44,9 +45,9 @@ class MemoryCacheTest : public ::testing::Test {
 public:
     class FakeDecodedResource : public Resource {
     public:
-        static RefPtrWillBeRawPtr<FakeDecodedResource> create(const ResourceRequest& request, Type type)
+        FakeDecodedResource(const ResourceRequest& request, Type type)
+            : Resource(request, type)
         {
-            return adoptRefWillBeNoop(new FakeDecodedResource(request, type));
         }
 
         virtual void appendData(const char* data, size_t len)
@@ -56,11 +57,6 @@ public:
         }
 
     protected:
-        FakeDecodedResource(const ResourceRequest& request, Type type)
-            : Resource(request, type)
-        {
-        }
-
         void destroyDecodedDataIfPossible() override
         {
             setDecodedSize(0);
@@ -69,21 +65,15 @@ public:
 
     class FakeResource : public Resource {
     public:
-        static RefPtrWillBeRawPtr<FakeResource> create(const ResourceRequest& request, Type type)
+        FakeResource(const ResourceRequest& request, Type type)
+            : Resource(request, type)
         {
-            return adoptRefWillBeNoop(new FakeResource(request, type));
         }
 
         void fakeEncodedSize(size_t size)
         {
             setEncodedSize(size);
         }
-
-    private:
-        FakeResource(const ResourceRequest& request, Type type)
-            : Resource(request, type)
-        {
-        }
     };
 
 protected:
@@ -123,8 +113,8 @@ TEST_F(MemoryCacheTest, VeryLargeResourceAccounting)
     const size_t resourceSize1 = sizeMax / 16;
     const size_t resourceSize2 = sizeMax / 20;
     memoryCache()->setCapacities(minDeadCapacity, maxDeadCapacity, totalCapacity);
-    RefPtrWillBeRawPtr<FakeResource> cachedResource =
-        FakeResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+    ResourcePtr<FakeResource> cachedResource =
+        new FakeResource(ResourceRequest("http://test/resource"), Resource::Raw);
     cachedResource->fakeEncodedSize(resourceSize1);
 
     ASSERT_EQ(0u, memoryCache()->deadSize());
@@ -180,24 +170,24 @@ static void TestDeadResourceEviction(Resource* resource1, Resource* resource2)
 
 TEST_F(MemoryCacheTest, DeadResourceEviction_Basic)
 {
-    RefPtrWillBeRawPtr<Resource> resource1 =
-        Resource::create(ResourceRequest("http://test/resource1"), Resource::Raw);
-    RefPtrWillBeRawPtr<Resource> resource2 =
-        Resource::create(ResourceRequest("http://test/resource2"), Resource::Raw);
-    TestDeadResourceEviction(resource1.get(), resource2.get());
+    Resource* resource1 =
+        new Resource(ResourceRequest("http://test/resource1"), Resource::Raw);
+    Resource* resource2 =
+        new Resource(ResourceRequest("http://test/resource2"), Resource::Raw);
+    TestDeadResourceEviction(resource1, resource2);
 }
 
 TEST_F(MemoryCacheTest, DeadResourceEviction_MultipleResourceMaps)
 {
-    RefPtrWillBeRawPtr<Resource> resource1 =
-        Resource::create(ResourceRequest("http://test/resource1"), Resource::Raw);
-    RefPtrWillBeRawPtr<Resource> resource2 =
-        Resource::create(ResourceRequest("http://test/resource2"), Resource::Raw);
+    Resource* resource1 =
+        new Resource(ResourceRequest("http://test/resource1"), Resource::Raw);
+    Resource* resource2 =
+        new Resource(ResourceRequest("http://test/resource2"), Resource::Raw);
     resource2->setCacheIdentifier("foo");
-    TestDeadResourceEviction(resource1.get(), resource2.get());
+    TestDeadResourceEviction(resource1, resource2);
 }
 
-static void TestLiveResourceEvictionAtEndOfTask(Resource* cachedDeadResource, Resource* cachedLiveResource)
+static void TestLiveResourceEvictionAtEndOfTask(Resource* cachedDeadResource, const ResourcePtr<Resource>& cachedLiveResource)
 {
     memoryCache()->setDelayBeforeLiveDecodedPrune(0);
     const unsigned totalCapacity = 1;
@@ -211,7 +201,7 @@ static void TestLiveResourceEvictionAtEndOfTask(Resource* cachedDeadResource, Re
 
     class Task1 : public WebTaskRunner::Task {
     public:
-        Task1(Resource* live, Resource* dead)
+        Task1(const ResourcePtr<Resource>& live, Resource* dead)
             : m_live(live)
             , m_dead(dead)
         { }
@@ -226,7 +216,7 @@ static void TestLiveResourceEvictionAtEndOfTask(Resource* cachedDeadResource, Re
             ASSERT_EQ(0u, memoryCache()->deadSize());
             ASSERT_EQ(0u, memoryCache()->liveSize());
 
-            memoryCache()->add(m_dead.get());
+            memoryCache()->add(m_dead);
             memoryCache()->add(m_live.get());
             memoryCache()->updateDecodedResource(m_live.get(), UpdateForPropertyChange);
             ASSERT_EQ(m_dead->size(), memoryCache()->deadSize());
@@ -240,8 +230,8 @@ static void TestLiveResourceEvictionAtEndOfTask(Resource* cachedDeadResource, Re
         }
 
     private:
-        RefPtrWillBePersistent<Resource> m_live;
-        RefPtrWillBePersistent<Resource> m_dead;
+        ResourcePtr<Resource> m_live;
+        RawPtrWillBePersistent<Resource> m_dead;
     };
 
     class Task2 : public WebTaskRunner::Task {
@@ -270,48 +260,48 @@ static void TestLiveResourceEvictionAtEndOfTask(Resource* cachedDeadResource, Re
 // is deferred to the end of the task.
 TEST_F(MemoryCacheTest, LiveResourceEvictionAtEndOfTask_Basic)
 {
-    RefPtrWillBeRawPtr<Resource> cachedDeadResource =
-        Resource::create(ResourceRequest("hhtp://foo"), Resource::Raw);
-    RefPtrWillBeRawPtr<Resource> cachedLiveResource =
-        FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
-    TestLiveResourceEvictionAtEndOfTask(cachedDeadResource.get(), cachedLiveResource.get());
+    Resource* cachedDeadResource =
+        new Resource(ResourceRequest("hhtp://foo"), Resource::Raw);
+    ResourcePtr<Resource> cachedLiveResource =
+        new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
+    TestLiveResourceEvictionAtEndOfTask(cachedDeadResource, cachedLiveResource);
 }
 
 TEST_F(MemoryCacheTest, LiveResourceEvictionAtEndOfTask_MultipleResourceMaps)
 {
     {
-        RefPtrWillBeRawPtr<Resource> cachedDeadResource =
-            Resource::create(ResourceRequest("hhtp://foo"), Resource::Raw);
+        Resource* cachedDeadResource =
+            new Resource(ResourceRequest("hhtp://foo"), Resource::Raw);
         cachedDeadResource->setCacheIdentifier("foo");
-        RefPtrWillBeRawPtr<Resource> cachedLiveResource =
-            FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
-        TestLiveResourceEvictionAtEndOfTask(cachedDeadResource.get(), cachedLiveResource.get());
+        ResourcePtr<Resource> cachedLiveResource =
+            new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
+        TestLiveResourceEvictionAtEndOfTask(cachedDeadResource, cachedLiveResource);
         memoryCache()->evictResources();
     }
     {
-        RefPtrWillBeRawPtr<Resource> cachedDeadResource =
-            Resource::create(ResourceRequest("hhtp://foo"), Resource::Raw);
-        RefPtrWillBeRawPtr<Resource> cachedLiveResource =
-            FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+        Resource* cachedDeadResource =
+            new Resource(ResourceRequest("hhtp://foo"), Resource::Raw);
+        ResourcePtr<Resource> cachedLiveResource =
+            new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
         cachedLiveResource->setCacheIdentifier("foo");
-        TestLiveResourceEvictionAtEndOfTask(cachedDeadResource.get(), cachedLiveResource.get());
+        TestLiveResourceEvictionAtEndOfTask(cachedDeadResource, cachedLiveResource);
         memoryCache()->evictResources();
     }
     {
-        RefPtrWillBeRawPtr<Resource> cachedDeadResource =
-            Resource::create(ResourceRequest("hhtp://test/resource"), Resource::Raw);
+        Resource* cachedDeadResource =
+            new Resource(ResourceRequest("hhtp://test/resource"), Resource::Raw);
         cachedDeadResource->setCacheIdentifier("foo");
-        RefPtrWillBeRawPtr<Resource> cachedLiveResource =
-            FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+        ResourcePtr<Resource> cachedLiveResource =
+            new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
         cachedLiveResource->setCacheIdentifier("bar");
-        TestLiveResourceEvictionAtEndOfTask(cachedDeadResource.get(), cachedLiveResource.get());
+        TestLiveResourceEvictionAtEndOfTask(cachedDeadResource, cachedLiveResource);
         memoryCache()->evictResources();
     }
 }
 
 // Verifies that cached resources are evicted immediately after release when
 // the total dead resource size is more than double the dead resource capacity.
-static void TestClientRemoval(Resource* resource1, Resource* resource2)
+static void TestClientRemoval(const ResourcePtr<Resource>& resource1, const ResourcePtr<Resource>& resource2)
 {
     const char data[6] = "abcde";
     MockImageResourceClient client1(resource1);
@@ -323,8 +313,8 @@ static void TestClientRemoval(Resource* resource1, Resource* resource2)
     const unsigned maxDeadCapacity = ((resource1->size() + resource2->size()) / 2) - 1;
     const unsigned totalCapacity = maxDeadCapacity;
     memoryCache()->setCapacities(minDeadCapacity, maxDeadCapacity, totalCapacity);
-    memoryCache()->add(resource1);
-    memoryCache()->add(resource2);
+    memoryCache()->add(resource1.get());
+    memoryCache()->add(resource2.get());
     // Call prune. There is nothing to prune, but this will initialize
     // the prune timestamp, allowing future prunes to be deferred.
     memoryCache()->prune();
@@ -340,8 +330,8 @@ static void TestClientRemoval(Resource* resource1, Resource* resource2)
     ASSERT_GT(resource2->decodedSize(), 0u);
     ASSERT_EQ(memoryCache()->deadSize(), resource1->size());
     ASSERT_EQ(memoryCache()->liveSize(), resource2->size());
-    ASSERT_TRUE(memoryCache()->contains(resource1));
-    ASSERT_TRUE(memoryCache()->contains(resource2));
+    ASSERT_TRUE(memoryCache()->contains(resource1.get()));
+    ASSERT_TRUE(memoryCache()->contains(resource2.get()));
 
     // Removing the client from resource2 should result in immediate
     // eviction of resource2 because we are over the prune deferral limit.
@@ -350,54 +340,54 @@ static void TestClientRemoval(Resource* resource1, Resource* resource2)
     ASSERT_GT(resource2->decodedSize(), 0u);
     ASSERT_EQ(memoryCache()->deadSize(), resource1->size());
     ASSERT_EQ(memoryCache()->liveSize(), 0u);
-    ASSERT_TRUE(memoryCache()->contains(resource1));
-    ASSERT_FALSE(memoryCache()->contains(resource2));
+    ASSERT_TRUE(memoryCache()->contains(resource1.get()));
+    ASSERT_FALSE(memoryCache()->contains(resource2.get()));
 }
 
 TEST_F(MemoryCacheTest, ClientRemoval_Basic)
 {
-    RefPtrWillBeRawPtr<Resource> resource1 =
-        FakeDecodedResource::create(ResourceRequest("http://foo.com"), Resource::Raw);
-    RefPtrWillBeRawPtr<Resource> resource2 =
-        FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
-    TestClientRemoval(resource1.get(), resource2.get());
+    ResourcePtr<Resource> resource1 =
+        new FakeDecodedResource(ResourceRequest("http://foo.com"), Resource::Raw);
+    ResourcePtr<Resource> resource2 =
+        new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
+    TestClientRemoval(resource1, resource2);
 }
 
 TEST_F(MemoryCacheTest, ClientRemoval_MultipleResourceMaps)
 {
     {
-        RefPtrWillBeRawPtr<Resource> resource1 =
-            FakeDecodedResource::create(ResourceRequest("http://foo.com"), Resource::Raw);
+        ResourcePtr<Resource> resource1 =
+            new FakeDecodedResource(ResourceRequest("http://foo.com"), Resource::Raw);
         resource1->setCacheIdentifier("foo");
-        RefPtrWillBeRawPtr<Resource> resource2 =
-            FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
-        TestClientRemoval(resource1.get(), resource2.get());
+        ResourcePtr<Resource> resource2 =
+            new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
+        TestClientRemoval(resource1, resource2);
         memoryCache()->evictResources();
     }
     {
-        RefPtrWillBeRawPtr<Resource> resource1 =
-            FakeDecodedResource::create(ResourceRequest("http://foo.com"), Resource::Raw);
-        RefPtrWillBeRawPtr<Resource> resource2 =
-            FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+        ResourcePtr<Resource> resource1 =
+            new FakeDecodedResource(ResourceRequest("http://foo.com"), Resource::Raw);
+        ResourcePtr<Resource> resource2 =
+            new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
         resource2->setCacheIdentifier("foo");
-        TestClientRemoval(resource1.get(), resource2.get());
+        TestClientRemoval(resource1, resource2);
         memoryCache()->evictResources();
     }
     {
-        RefPtrWillBeRawPtr<Resource> resource1 =
-            FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+        ResourcePtr<Resource> resource1 =
+            new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
         resource1->setCacheIdentifier("foo");
-        RefPtrWillBeRawPtr<Resource> resource2 =
-            FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+        ResourcePtr<Resource> resource2 =
+            new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
         resource2->setCacheIdentifier("bar");
-        TestClientRemoval(resource1.get(), resource2.get());
+        TestClientRemoval(resource1, resource2);
         memoryCache()->evictResources();
     }
 }
 
 // Verifies that CachedResources are evicted from the decode cache
 // according to their DecodeCachePriority.
-static void TestDecodeCacheOrder(Resource* cachedImageLowPriority, Resource* cachedImageHighPriority)
+static void TestDecodeCacheOrder(const ResourcePtr<Resource>& cachedImageLowPriority, const ResourcePtr<Resource>& cachedImageHighPriority)
 {
     memoryCache()->setDelayBeforeLiveDecodedPrune(0);
     memoryCache()->setMaxPruneDeferralDelay(0);
@@ -424,23 +414,23 @@ static void TestDecodeCacheOrder(Resource* cachedImageLowPriority, Resource* cac
     ASSERT_EQ(memoryCache()->liveSize(), 0u);
 
     // Add the items. The item added first would normally be evicted first.
-    memoryCache()->add(cachedImageHighPriority);
+    memoryCache()->add(cachedImageHighPriority.get());
     ASSERT_EQ(memoryCache()->deadSize(), 0u);
     ASSERT_EQ(memoryCache()->liveSize(), highPrioritySize);
 
-    memoryCache()->add(cachedImageLowPriority);
+    memoryCache()->add(cachedImageLowPriority.get());
     ASSERT_EQ(memoryCache()->deadSize(), 0u);
     ASSERT_EQ(memoryCache()->liveSize(), highPrioritySize + lowPrioritySize);
 
     // Insert all items in the decoded items list with the same priority
-    memoryCache()->updateDecodedResource(cachedImageHighPriority, UpdateForPropertyChange);
-    memoryCache()->updateDecodedResource(cachedImageLowPriority, UpdateForPropertyChange);
+    memoryCache()->updateDecodedResource(cachedImageHighPriority.get(), UpdateForPropertyChange);
+    memoryCache()->updateDecodedResource(cachedImageLowPriority.get(), UpdateForPropertyChange);
     ASSERT_EQ(memoryCache()->deadSize(), 0u);
     ASSERT_EQ(memoryCache()->liveSize(), totalSize);
 
     // Now we will assign their priority and make sure they are moved to the correct buckets.
-    memoryCache()->updateDecodedResource(cachedImageLowPriority, UpdateForPropertyChange, MemoryCacheLiveResourcePriorityLow);
-    memoryCache()->updateDecodedResource(cachedImageHighPriority, UpdateForPropertyChange, MemoryCacheLiveResourcePriorityHigh);
+    memoryCache()->updateDecodedResource(cachedImageLowPriority.get(), UpdateForPropertyChange, MemoryCacheLiveResourcePriorityLow);
+    memoryCache()->updateDecodedResource(cachedImageHighPriority.get(), UpdateForPropertyChange, MemoryCacheLiveResourcePriorityHigh);
 
     // Should first prune the LowPriority item.
     memoryCache()->setCapacities(memoryCache()->minDeadCapacity(), memoryCache()->liveSize() - 10, memoryCache()->liveSize() - 10);
@@ -457,57 +447,57 @@ static void TestDecodeCacheOrder(Resource* cachedImageLowPriority, Resource* cac
 
 TEST_F(MemoryCacheTest, DecodeCacheOrder_Basic)
 {
-    RefPtrWillBeRawPtr<FakeDecodedResource> cachedImageLowPriority =
-        FakeDecodedResource::create(ResourceRequest("http://foo.com"), Resource::Raw);
-    RefPtrWillBeRawPtr<FakeDecodedResource> cachedImageHighPriority =
-        FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
-    TestDecodeCacheOrder(cachedImageLowPriority.get(), cachedImageHighPriority.get());
+    ResourcePtr<FakeDecodedResource> cachedImageLowPriority =
+        new FakeDecodedResource(ResourceRequest("http://foo.com"), Resource::Raw);
+    ResourcePtr<FakeDecodedResource> cachedImageHighPriority =
+        new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
+    TestDecodeCacheOrder(cachedImageLowPriority, cachedImageHighPriority);
 }
 
 TEST_F(MemoryCacheTest, DecodeCacheOrder_MultipleResourceMaps)
 {
     {
-        RefPtrWillBeRawPtr<FakeDecodedResource> cachedImageLowPriority =
-            FakeDecodedResource::create(ResourceRequest("http://foo.com"), Resource::Raw);
-        RefPtrWillBeRawPtr<FakeDecodedResource> cachedImageHighPriority =
-            FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+        ResourcePtr<FakeDecodedResource> cachedImageLowPriority =
+            new FakeDecodedResource(ResourceRequest("http://foo.com"), Resource::Raw);
+        ResourcePtr<FakeDecodedResource> cachedImageHighPriority =
+            new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
         cachedImageLowPriority->setCacheIdentifier("foo");
-        TestDecodeCacheOrder(cachedImageLowPriority.get(), cachedImageHighPriority.get());
+        TestDecodeCacheOrder(cachedImageLowPriority, cachedImageHighPriority);
         memoryCache()->evictResources();
     }
     {
-        RefPtrWillBeRawPtr<FakeDecodedResource> cachedImageLowPriority =
-            FakeDecodedResource::create(ResourceRequest("http://foo.com"), Resource::Raw);
-        RefPtrWillBeRawPtr<FakeDecodedResource> cachedImageHighPriority =
-            FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+        ResourcePtr<FakeDecodedResource> cachedImageLowPriority =
+            new FakeDecodedResource(ResourceRequest("http://foo.com"), Resource::Raw);
+        ResourcePtr<FakeDecodedResource> cachedImageHighPriority =
+            new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
         cachedImageHighPriority->setCacheIdentifier("foo");
-        TestDecodeCacheOrder(cachedImageLowPriority.get(), cachedImageHighPriority.get());
+        TestDecodeCacheOrder(cachedImageLowPriority, cachedImageHighPriority);
         memoryCache()->evictResources();
     }
     {
-        RefPtrWillBeRawPtr<FakeDecodedResource> cachedImageLowPriority =
-            FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+        ResourcePtr<FakeDecodedResource> cachedImageLowPriority =
+            new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
         cachedImageLowPriority->setCacheIdentifier("foo");
-        RefPtrWillBeRawPtr<FakeDecodedResource> cachedImageHighPriority =
-            FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+        ResourcePtr<FakeDecodedResource> cachedImageHighPriority =
+            new FakeDecodedResource(ResourceRequest("http://test/resource"), Resource::Raw);
         cachedImageHighPriority->setCacheIdentifier("bar");
-        TestDecodeCacheOrder(cachedImageLowPriority.get(), cachedImageHighPriority.get());
+        TestDecodeCacheOrder(cachedImageLowPriority, cachedImageHighPriority);
         memoryCache()->evictResources();
     }
 }
 
 TEST_F(MemoryCacheTest, RemoveDuringRevalidation)
 {
-    RefPtrWillBeRawPtr<FakeResource> resource1 = FakeResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+    ResourcePtr<FakeResource> resource1 = new FakeResource(ResourceRequest("http://test/resource"), Resource::Raw);
     memoryCache()->add(resource1.get());
 
-    RefPtrWillBeRawPtr<FakeResource> resource2 = FakeResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+    ResourcePtr<FakeResource> resource2 = new FakeResource(ResourceRequest("http://test/resource"), Resource::Raw);
     memoryCache()->remove(resource1.get());
     memoryCache()->add(resource2.get());
     EXPECT_TRUE(memoryCache()->contains(resource2.get()));
     EXPECT_FALSE(memoryCache()->contains(resource1.get()));
 
-    RefPtrWillBeRawPtr<FakeResource> resource3 = FakeResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+    ResourcePtr<FakeResource> resource3 = new FakeResource(ResourceRequest("http://test/resource"), Resource::Raw);
     memoryCache()->remove(resource2.get());
     memoryCache()->add(resource3.get());
     EXPECT_TRUE(memoryCache()->contains(resource3.get()));
@@ -516,10 +506,10 @@ TEST_F(MemoryCacheTest, RemoveDuringRevalidation)
 
 TEST_F(MemoryCacheTest, ResourceMapIsolation)
 {
-    RefPtrWillBeRawPtr<FakeResource> resource1 = FakeResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+    ResourcePtr<FakeResource> resource1 = new FakeResource(ResourceRequest("http://test/resource"), Resource::Raw);
     memoryCache()->add(resource1.get());
 
-    RefPtrWillBeRawPtr<FakeResource> resource2 = FakeResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+    ResourcePtr<FakeResource> resource2 = new FakeResource(ResourceRequest("http://test/resource"), Resource::Raw);
     resource2->setCacheIdentifier("foo");
     memoryCache()->add(resource2.get());
     EXPECT_TRUE(memoryCache()->contains(resource1.get()));
@@ -531,7 +521,7 @@ TEST_F(MemoryCacheTest, ResourceMapIsolation)
     EXPECT_EQ(resource2.get(), memoryCache()->resourceForURL(url, "foo"));
     EXPECT_EQ(0, memoryCache()->resourceForURL(KURL()));
 
-    RefPtrWillBeRawPtr<FakeResource> resource3 = FakeResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
+    ResourcePtr<FakeResource> resource3 = new FakeResource(ResourceRequest("http://test/resource"), Resource::Raw);
     resource3->setCacheIdentifier("foo");
     memoryCache()->remove(resource2.get());
     memoryCache()->add(resource3.get());
diff --git a/third_party/WebKit/Source/core/fetch/MockImageResourceClient.cpp b/third_party/WebKit/Source/core/fetch/MockImageResourceClient.cpp
index b3d9d15..4b41e4e 100644
--- a/third_party/WebKit/Source/core/fetch/MockImageResourceClient.cpp
+++ b/third_party/WebKit/Source/core/fetch/MockImageResourceClient.cpp
@@ -5,11 +5,12 @@
 #include "core/fetch/MockImageResourceClient.h"
 
 #include "core/fetch/ImageResource.h"
+#include "core/fetch/ResourcePtr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
-MockImageResourceClient::MockImageResourceClient(PassRefPtrWillBeRawPtr<Resource> resource)
+MockImageResourceClient::MockImageResourceClient(const ResourcePtr<Resource>& resource)
     : m_resource(resource.get())
     , m_imageChangedCount(0)
     , m_notifyFinishedCalled(false)
diff --git a/third_party/WebKit/Source/core/fetch/MockImageResourceClient.h b/third_party/WebKit/Source/core/fetch/MockImageResourceClient.h
index b877a92..914e126 100644
--- a/third_party/WebKit/Source/core/fetch/MockImageResourceClient.h
+++ b/third_party/WebKit/Source/core/fetch/MockImageResourceClient.h
@@ -32,14 +32,17 @@
 #define MockImageResourceClient_h
 
 #include "core/fetch/ImageResourceClient.h"
-#include "core/fetch/Resource.h"
 #include "platform/heap/Handle.h"
 
 namespace blink {
 
+template<typename T> class ResourcePtr;
+
+class Resource;
+
 class MockImageResourceClient final : public ImageResourceClient {
 public:
-    explicit MockImageResourceClient(const PassRefPtrWillBeRawPtr<Resource>);
+    explicit MockImageResourceClient(const ResourcePtr<Resource>&);
     ~MockImageResourceClient() override;
 
     void imageChanged(ImageResource*, const IntRect*) override
diff --git a/third_party/WebKit/Source/core/fetch/RawResource.cpp b/third_party/WebKit/Source/core/fetch/RawResource.cpp
index 1a8eaa6..9bc2cd4 100644
--- a/third_party/WebKit/Source/core/fetch/RawResource.cpp
+++ b/third_party/WebKit/Source/core/fetch/RawResource.cpp
@@ -33,7 +33,7 @@
 
 namespace blink {
 
-PassRefPtrWillBeRawPtr<Resource> RawResource::fetchSynchronously(FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<Resource> RawResource::fetchSynchronously(FetchRequest& request, ResourceFetcher* fetcher)
 {
     request.mutableResourceRequest().setTimeoutInterval(10);
     ResourceLoaderOptions options(request.options());
@@ -42,7 +42,7 @@ PassRefPtrWillBeRawPtr<Resource> RawResource::fetchSynchronously(FetchRequest& r
     return fetcher->requestResource(request, RawResourceFactory(Resource::Raw));
 }
 
-PassRefPtrWillBeRawPtr<RawResource> RawResource::fetchImport(FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<RawResource> RawResource::fetchImport(FetchRequest& request, ResourceFetcher* fetcher)
 {
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
     request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextImport);
@@ -50,14 +50,14 @@ PassRefPtrWillBeRawPtr<RawResource> RawResource::fetchImport(FetchRequest& reque
     return toRawResource(fetcher->requestResource(request, RawResourceFactory(Resource::ImportResource)));
 }
 
-PassRefPtrWillBeRawPtr<RawResource> RawResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<RawResource> RawResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
 {
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
     ASSERT(request.resourceRequest().requestContext() != WebURLRequest::RequestContextUnspecified);
     return toRawResource(fetcher->requestResource(request, RawResourceFactory(Resource::Raw)));
 }
 
-PassRefPtrWillBeRawPtr<RawResource> RawResource::fetchMainResource(FetchRequest& request, ResourceFetcher* fetcher, const SubstituteData& substituteData)
+ResourcePtr<RawResource> RawResource::fetchMainResource(FetchRequest& request, ResourceFetcher* fetcher, const SubstituteData& substituteData)
 {
     ASSERT(request.resourceRequest().frameType() != WebURLRequest::FrameTypeNone);
     ASSERT(request.resourceRequest().requestContext() == WebURLRequest::RequestContextForm || request.resourceRequest().requestContext() == WebURLRequest::RequestContextFrame || request.resourceRequest().requestContext() == WebURLRequest::RequestContextHyperlink || request.resourceRequest().requestContext() == WebURLRequest::RequestContextIframe || request.resourceRequest().requestContext() == WebURLRequest::RequestContextInternal || request.resourceRequest().requestContext() == WebURLRequest::RequestContextLocation);
@@ -65,21 +65,21 @@ PassRefPtrWillBeRawPtr<RawResource> RawResource::fetchMainResource(FetchRequest&
     return toRawResource(fetcher->requestResource(request, RawResourceFactory(Resource::MainResource), substituteData));
 }
 
-PassRefPtrWillBeRawPtr<RawResource> RawResource::fetchMedia(FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<RawResource> RawResource::fetchMedia(FetchRequest& request, ResourceFetcher* fetcher)
 {
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
     ASSERT(request.resourceRequest().requestContext() == WebURLRequest::RequestContextAudio || request.resourceRequest().requestContext() == WebURLRequest::RequestContextVideo);
     return toRawResource(fetcher->requestResource(request, RawResourceFactory(Resource::Media)));
 }
 
-PassRefPtrWillBeRawPtr<RawResource> RawResource::fetchTextTrack(FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<RawResource> RawResource::fetchTextTrack(FetchRequest& request, ResourceFetcher* fetcher)
 {
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
     request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextTrack);
     return toRawResource(fetcher->requestResource(request, RawResourceFactory(Resource::TextTrack)));
 }
 
-PassRefPtrWillBeRawPtr<RawResource> RawResource::fetchManifest(FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<RawResource> RawResource::fetchManifest(FetchRequest& request, ResourceFetcher* fetcher)
 {
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
     ASSERT(request.resourceRequest().requestContext() == WebURLRequest::RequestContextManifest);
@@ -95,7 +95,7 @@ void RawResource::appendData(const char* data, size_t length)
 {
     Resource::appendData(data, length);
 
-    RefPtrWillBeRawPtr<RawResource> protect(this);
+    ResourcePtr<RawResource> protect(this);
     ResourceClientWalker<RawResourceClient> w(m_clients);
     while (RawResourceClient* c = w.next())
         c->dataReceived(this, data, length);
@@ -108,7 +108,7 @@ void RawResource::didAddClient(ResourceClient* c)
     // The calls to the client can result in events running, potentially causing
     // this resource to be evicted from the cache and all clients to be removed,
     // so a protector is necessary.
-    RefPtrWillBeRawPtr<RawResource> protect(this);
+    ResourcePtr<RawResource> protect(this);
     ASSERT(c->resourceClientType() == RawResourceClient::expectedType());
     RawResourceClient* client = static_cast<RawResourceClient*>(c);
     for (const auto& redirect : redirectChain()) {
@@ -131,7 +131,7 @@ void RawResource::didAddClient(ResourceClient* c)
 
 void RawResource::willFollowRedirect(ResourceRequest& newRequest, const ResourceResponse& redirectResponse)
 {
-    RefPtrWillBeRawPtr<RawResource> protect(this);
+    ResourcePtr<RawResource> protect(this);
     ASSERT(!redirectResponse.isNull());
     ResourceClientWalker<RawResourceClient> w(m_clients);
     while (RawResourceClient* c = w.next())
@@ -141,7 +141,7 @@ void RawResource::willFollowRedirect(ResourceRequest& newRequest, const Resource
 
 void RawResource::updateRequest(const ResourceRequest& request)
 {
-    RefPtrWillBeRawPtr<RawResource> protect(this);
+    ResourcePtr<RawResource> protect(this);
     ResourceClientWalker<RawResourceClient> w(m_clients);
     while (RawResourceClient* c = w.next())
         c->updateRequest(this, request);
@@ -149,7 +149,7 @@ void RawResource::updateRequest(const ResourceRequest& request)
 
 void RawResource::responseReceived(const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle)
 {
-    RefPtrWillBeRawPtr<RawResource> protect(this);
+    InternalResourcePtr protect(this);
 
     bool isSuccessfulRevalidation = isCacheValidator() && response.httpStatusCode() == 304;
     Resource::responseReceived(response, nullptr);
@@ -175,7 +175,7 @@ void RawResource::responseReceived(const ResourceResponse& response, PassOwnPtr<
 
 void RawResource::setSerializedCachedMetadata(const char* data, size_t size)
 {
-    RefPtrWillBeRawPtr<RawResource> protect(this);
+    ResourcePtr<RawResource> protect(this);
     Resource::setSerializedCachedMetadata(data, size);
     ResourceClientWalker<RawResourceClient> w(m_clients);
     while (RawResourceClient* c = w.next())
@@ -184,7 +184,7 @@ void RawResource::setSerializedCachedMetadata(const char* data, size_t size)
 
 void RawResource::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 {
-    RefPtrWillBeRawPtr<RawResource> protect(this);
+    ResourcePtr<RawResource> protect(this);
     ResourceClientWalker<RawResourceClient> w(m_clients);
     while (RawResourceClient* c = w.next())
         c->dataSent(this, bytesSent, totalBytesToBeSent);
@@ -192,7 +192,7 @@ void RawResource::didSendData(unsigned long long bytesSent, unsigned long long t
 
 void RawResource::didDownloadData(int dataLength)
 {
-    RefPtrWillBeRawPtr<RawResource> protect(this);
+    ResourcePtr<RawResource> protect(this);
     ResourceClientWalker<RawResourceClient> w(m_clients);
     while (RawResourceClient* c = w.next())
         c->dataDownloaded(this, dataLength);
diff --git a/third_party/WebKit/Source/core/fetch/RawResource.h b/third_party/WebKit/Source/core/fetch/RawResource.h
index d7061f0..0bab880 100644
--- a/third_party/WebKit/Source/core/fetch/RawResource.h
+++ b/third_party/WebKit/Source/core/fetch/RawResource.h
@@ -24,8 +24,8 @@
 #define RawResource_h
 
 #include "core/CoreExport.h"
-#include "core/fetch/Resource.h"
 #include "core/fetch/ResourceClient.h"
+#include "core/fetch/ResourcePtr.h"
 #include "public/platform/WebDataConsumerHandle.h"
 #include "wtf/PassOwnPtr.h"
 
@@ -39,19 +39,16 @@ class CORE_EXPORT RawResource final : public Resource {
 public:
     using ClientType = RawResourceClient;
 
-    static PassRefPtrWillBeRawPtr<Resource> fetchSynchronously(FetchRequest&, ResourceFetcher*);
-    static PassRefPtrWillBeRawPtr<RawResource> fetch(FetchRequest&, ResourceFetcher*);
-    static PassRefPtrWillBeRawPtr<RawResource> fetchMainResource(FetchRequest&, ResourceFetcher*, const SubstituteData&);
-    static PassRefPtrWillBeRawPtr<RawResource> fetchImport(FetchRequest&, ResourceFetcher*);
-    static PassRefPtrWillBeRawPtr<RawResource> fetchMedia(FetchRequest&, ResourceFetcher*);
-    static PassRefPtrWillBeRawPtr<RawResource> fetchTextTrack(FetchRequest&, ResourceFetcher*);
-    static PassRefPtrWillBeRawPtr<RawResource> fetchManifest(FetchRequest&, ResourceFetcher*);
+    static ResourcePtr<Resource> fetchSynchronously(FetchRequest&, ResourceFetcher*);
+    static ResourcePtr<RawResource> fetch(FetchRequest&, ResourceFetcher*);
+    static ResourcePtr<RawResource> fetchMainResource(FetchRequest&, ResourceFetcher*, const SubstituteData&);
+    static ResourcePtr<RawResource> fetchImport(FetchRequest&, ResourceFetcher*);
+    static ResourcePtr<RawResource> fetchMedia(FetchRequest&, ResourceFetcher*);
+    static ResourcePtr<RawResource> fetchTextTrack(FetchRequest&, ResourceFetcher*);
+    static ResourcePtr<RawResource> fetchManifest(FetchRequest&, ResourceFetcher*);
 
     // Exposed for testing
-    static RefPtrWillBeRawPtr<RawResource> create(const ResourceRequest& request, Type type)
-    {
-        return adoptRefWillBeNoop(new RawResource(request, type));
-    }
+    RawResource(const ResourceRequest&, Type);
 
     // FIXME: AssociatedURLLoader shouldn't be a DocumentThreadableLoader and therefore shouldn't
     // use RawResource. However, it is, and it needs to be able to defer loading.
@@ -66,14 +63,12 @@ private:
         RawResourceFactory(Resource::Type type)
             : ResourceFactory(type) { }
 
-        PassRefPtrWillBeRawPtr<Resource> create(const ResourceRequest& request, const String& charset) const override
+        Resource* create(const ResourceRequest& request, const String& charset) const override
         {
-            return adoptRefWillBeNoop(new RawResource(request, m_type));
+            return new RawResource(request, m_type);
         }
     };
 
-    RawResource(const ResourceRequest&, Type);
-
     void didAddClient(ResourceClient*) override;
     void appendData(const char*, size_t) override;
 
@@ -95,7 +90,7 @@ inline bool isRawResource(const Resource& resource)
     return type == Resource::MainResource || type == Resource::Raw || type == Resource::TextTrack || type == Resource::Media || type == Resource::Manifest || type == Resource::ImportResource;
 }
 #endif
-inline PassRefPtrWillBeRawPtr<RawResource> toRawResource(const PassRefPtrWillBeRawPtr<Resource>& resource)
+inline RawResource* toRawResource(const ResourcePtr<Resource>& resource)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(!resource || isRawResource(*resource.get()));
     return static_cast<RawResource*>(resource.get());
diff --git a/third_party/WebKit/Source/core/fetch/RawResourceTest.cpp b/third_party/WebKit/Source/core/fetch/RawResourceTest.cpp
index ef41529..ed4b988 100644
--- a/third_party/WebKit/Source/core/fetch/RawResourceTest.cpp
+++ b/third_party/WebKit/Source/core/fetch/RawResourceTest.cpp
@@ -34,6 +34,7 @@
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/MockImageResourceClient.h"
 #include "core/fetch/ResourceFetcher.h"
+#include "core/fetch/ResourcePtr.h"
 #include "platform/SharedBuffer.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/Platform.h"
@@ -49,7 +50,7 @@ TEST(RawResourceTest, DontIgnoreAcceptForCacheReuse)
     ResourceRequest jpegRequest;
     jpegRequest.setHTTPAccept("image/jpeg");
 
-    RefPtrWillBeRawPtr<RawResource> jpegResource(RawResource::create(jpegRequest, Resource::Raw));
+    ResourcePtr<RawResource> jpegResource(new RawResource(jpegRequest, Resource::Raw));
 
     ResourceRequest pngRequest;
     pngRequest.setHTTPAccept("image/png");
@@ -107,13 +108,13 @@ public:
     }
 private:
     DummyClient* m_dummyClient;
-    RefPtrWillBePersistent<Resource> m_resource;
+    ResourcePtr<Resource> m_resource;
     Timer<AddingClient> m_removeClientTimer;
 };
 
 TEST(RawResourceTest, RevalidationSucceeded)
 {
-    RefPtrWillBeRawPtr<Resource> resource = RawResource::create(ResourceRequest("data:text/html,"), Resource::Raw);
+    ResourcePtr<Resource> resource = new RawResource(ResourceRequest("data:text/html,"), Resource::Raw);
     ResourceResponse response;
     response.setHTTPStatusCode(200);
     resource->responseReceived(response, nullptr);
@@ -145,7 +146,7 @@ TEST(RawResourceTest, RevalidationSucceeded)
 
 TEST(RawResourceTest, RevalidationSucceededForResourceWithoutBody)
 {
-    RefPtrWillBeRawPtr<Resource> resource = RawResource::create(ResourceRequest("data:text/html,"), Resource::Raw);
+    ResourcePtr<Resource> resource = new RawResource(ResourceRequest("data:text/html,"), Resource::Raw);
     ResourceResponse response;
     response.setHTTPStatusCode(200);
     resource->responseReceived(response, nullptr);
@@ -175,7 +176,7 @@ TEST(RawResourceTest, RevalidationSucceededForResourceWithoutBody)
 
 TEST(RawResourceTest, AddClientDuringCallback)
 {
-    RefPtrWillBeRawPtr<Resource> raw = RawResource::create(ResourceRequest("data:text/html,"), Resource::Raw);
+    ResourcePtr<Resource> raw = new RawResource(ResourceRequest("data:text/html,"), Resource::Raw);
     raw->setLoading(false);
 
     // Create a non-null response.
@@ -214,7 +215,7 @@ private:
 
 TEST(RawResourceTest, RemoveClientDuringCallback)
 {
-    RefPtrWillBeRawPtr<Resource> raw = RawResource::create(ResourceRequest("data:text/html,"), Resource::Raw);
+    ResourcePtr<Resource> raw = new RawResource(ResourceRequest("data:text/html,"), Resource::Raw);
     raw->setLoading(false);
 
     // Create a non-null response.
diff --git a/third_party/WebKit/Source/core/fetch/Resource.cpp b/third_party/WebKit/Source/core/fetch/Resource.cpp
index 1bcc9d1..586b2d2 100644
--- a/third_party/WebKit/Source/core/fetch/Resource.cpp
+++ b/third_party/WebKit/Source/core/fetch/Resource.cpp
@@ -31,6 +31,7 @@
 #include "core/fetch/ResourceClientWalker.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/fetch/ResourceLoader.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "platform/Logging.h"
 #include "platform/SharedBuffer.h"
@@ -154,13 +155,17 @@ Resource::Resource(const ResourceRequest& request, Type type)
     , m_identifier(0)
     , m_encodedSize(0)
     , m_decodedSize(0)
+    , m_handleCount(0)
     , m_preloadCount(0)
+    , m_protectorCount(0)
     , m_cacheIdentifier(MemoryCache::defaultCacheIdentifier())
     , m_preloadResult(PreloadNotReferenced)
     , m_requestedFromNetworkingLayer(false)
     , m_loading(false)
+    , m_switchingClientsToRevalidatedResource(false)
     , m_type(type)
     , m_status(Pending)
+    , m_wasPurged(false)
     , m_needsSynchronousCacheHit(false)
     , m_avoidBlockingOnLoad(false)
 #ifdef ENABLE_RESOURCE_IS_DELETED_CHECK
@@ -169,6 +174,7 @@ Resource::Resource(const ResourceRequest& request, Type type)
 {
     ASSERT(m_type == unsigned(type)); // m_type is a bitfield, so this tests careless updates of the enum.
     InstanceCounters::incrementCounter(InstanceCounters::ResourceCounter);
+    memoryCache()->registerLiveResource(*this);
 
     // Currently we support the metadata caching only for HTTP family.
     if (m_resourceRequest.url().protocolIsInHTTPFamily())
@@ -185,18 +191,19 @@ Resource::Resource(const ResourceRequest& request, Type type)
 
 Resource::~Resource()
 {
+    ASSERT(canDelete());
+    RELEASE_ASSERT(!memoryCache()->contains(this));
+    RELEASE_ASSERT(!ResourceCallback::callbackHandler()->isScheduled(this));
     assertAlive();
 
 #ifdef ENABLE_RESOURCE_IS_DELETED_CHECK
     m_deleted = true;
 #endif
-
     InstanceCounters::decrementCounter(InstanceCounters::ResourceCounter);
 }
 
-void Resource::removedFromMemoryCache()
+void Resource::dispose()
 {
-    InspectorInstrumentation::removedResourceFromMemoryCache(this);
 }
 
 DEFINE_TRACE(Resource)
@@ -439,13 +446,18 @@ bool Resource::unlock()
     if (!m_data->isLocked())
         return true;
 
-    if (!memoryCache()->contains(this) || hasClients() || !m_revalidatingRequest.isNull() || !m_loadFinishTime || !isSafeToUnlock())
+    if (!memoryCache()->contains(this) || hasClients() || m_handleCount > 1 || !m_revalidatingRequest.isNull() || !m_loadFinishTime || !isSafeToUnlock())
         return false;
 
     m_data->unlock();
     return true;
 }
 
+bool Resource::hasRightHandleCountApartFromCache(unsigned targetCount) const
+{
+    return m_handleCount == targetCount + (memoryCache()->contains(this) ? 1 : 0);
+}
+
 void Resource::responseReceived(const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle>)
 {
     m_responseTimestamp = currentTime();
@@ -517,6 +529,12 @@ WeakPtrWillBeRawPtr<Resource> Resource::asWeakPtr()
 #endif
 }
 
+bool Resource::canDelete() const
+{
+    return !hasClients() && !m_loader && !m_preloadCount && hasRightHandleCountApartFromCache(0)
+        && !m_protectorCount;
+}
+
 String Resource::reasonNotDeletable() const
 {
     StringBuilder builder;
@@ -545,6 +563,20 @@ String Resource::reasonNotDeletable() const
         builder.appendNumber(m_preloadCount);
         builder.append(")");
     }
+    if (!hasRightHandleCountApartFromCache(0)) {
+        if (!builder.isEmpty())
+            builder.append(' ');
+        builder.append("m_handleCount(");
+        builder.appendNumber(m_handleCount);
+        builder.append(")");
+    }
+    if (m_protectorCount) {
+        if (!builder.isEmpty())
+            builder.append(' ');
+        builder.append("m_protectorCount(");
+        builder.appendNumber(m_protectorCount);
+        builder.append(")");
+    }
     if (memoryCache()->contains(this)) {
         if (!builder.isEmpty())
             builder.append(' ');
@@ -553,6 +585,11 @@ String Resource::reasonNotDeletable() const
     return builder.toString();
 }
 
+bool Resource::hasOneHandle() const
+{
+    return hasRightHandleCountApartFromCache(1);
+}
+
 CachedMetadata* Resource::cachedMetadata(unsigned dataTypeID) const
 {
     if (!m_cachedMetadata || m_cachedMetadata->dataTypeID() != dataTypeID)
@@ -642,10 +679,11 @@ void Resource::removeClient(ResourceClient* client)
     if (m_clientsAwaitingCallback.isEmpty())
         ResourceCallback::callbackHandler()->cancel(this);
 
-    if (!hasClients()) {
-        RefPtrWillBeRawPtr<Resource> protect(this);
+    bool deleted = deleteIfPossible();
+    if (!deleted && !hasClients()) {
         memoryCache()->makeDead(this);
-        allClientsRemoved();
+        if (!m_switchingClientsToRevalidatedResource)
+            allClientsRemoved();
 
         // RFC2616 14.9.2:
         // "no-store: ... MUST make a best-effort attempt to remove the information from volatile storage as promptly as possible"
@@ -665,7 +703,7 @@ void Resource::allClientsRemoved()
 {
     if (!m_loader)
         return;
-    if (m_type == MainResource || m_type == Raw || !memoryCache()->contains(this))
+    if (m_type == MainResource || m_type == Raw)
         cancelTimerFired(&m_cancelTimer);
     else if (!m_cancelTimer.isActive())
         m_cancelTimer.startOneShot(0, BLINK_FROM_HERE);
@@ -678,12 +716,26 @@ void Resource::cancelTimerFired(Timer<Resource>* timer)
     ASSERT_UNUSED(timer, timer == &m_cancelTimer);
     if (hasClients() || !m_loader)
         return;
-    RefPtrWillBeRawPtr<Resource> protect(this);
+    ResourcePtr<Resource> protect(this);
     m_loader->cancelIfNotFinishing();
     if (m_status != Cached)
         memoryCache()->remove(this);
 }
 
+bool Resource::deleteIfPossible()
+{
+    if (canDelete() && !memoryCache()->contains(this)) {
+        InspectorInstrumentation::willDestroyResource(this);
+        dispose();
+        memoryCache()->unregisterLiveResource(*this);
+#if !ENABLE(OILPAN)
+        delete this;
+#endif
+        return true;
+    }
+    return false;
+}
+
 void Resource::setDecodedSize(size_t decodedSize)
 {
     if (decodedSize == m_decodedSize)
@@ -755,13 +807,14 @@ void Resource::onMemoryDump(WebMemoryDumpLevelOfDetail levelOfDetail, WebProcess
     const String dumpName = getMemoryDumpName();
     WebMemoryAllocatorDump* dump = memoryDump->createMemoryAllocatorDump(dumpName);
     dump->addScalar("encoded_size", "bytes", m_encodedSize);
-    if (m_data && m_data->isLocked())
-        dump->addScalar("live_size", "bytes", m_encodedSize);
-    else
+    if (canDelete()) {
         dump->addScalar("dead_size", "bytes", m_encodedSize);
+    } else {
+        dump->addScalar("live_size", "bytes", m_encodedSize);
+    }
 
     if (m_data) {
-        dump->addScalar("purgeable_size", "bytes", isPurgeable() ? encodedSize() + overheadSize() : 0);
+        dump->addScalar("purgeable_size", "bytes", isPurgeable() && !wasPurged() ? encodedSize() + overheadSize() : 0);
         m_data->onMemoryDump(dumpName, memoryDump);
     }
 
@@ -843,6 +896,29 @@ void Resource::revalidationFailed()
     destroyDecodedDataForFailedRevalidation();
 }
 
+void Resource::registerHandle(ResourcePtrBase* h)
+{
+    assertAlive();
+    ++m_handleCount;
+}
+
+void Resource::unregisterHandle(ResourcePtrBase* h)
+{
+    assertAlive();
+    ASSERT(m_handleCount > 0);
+    --m_handleCount;
+
+    if (!m_handleCount) {
+        if (deleteIfPossible())
+            return;
+        unlock();
+    } else if (m_handleCount == 1 && memoryCache()->contains(this)) {
+        unlock();
+        if (!hasClients())
+            memoryCache()->prune(this);
+    }
+}
+
 bool Resource::canReuseRedirectChain()
 {
     for (auto& redirect : m_redirectChain) {
@@ -884,6 +960,11 @@ bool Resource::isPurgeable() const
     return m_data && !m_data->isLocked();
 }
 
+bool Resource::wasPurged() const
+{
+    return m_wasPurged;
+}
+
 bool Resource::lock()
 {
     if (!m_data)
@@ -893,10 +974,8 @@ bool Resource::lock()
 
     ASSERT(!hasClients());
 
-    // If locking fails, our buffer has been purged. There's no point
-    // in leaving a purged resource in MemoryCache.
     if (!m_data->lock()) {
-        memoryCache()->remove(this);
+        m_wasPurged = true;
         return false;
     }
     return true;
@@ -976,8 +1055,8 @@ bool Resource::ResourceCallback::isScheduled(Resource* resource) const
 
 void Resource::ResourceCallback::runTask()
 {
-    WillBeHeapVector<RefPtrWillBeMember<Resource>> resources;
-    for (const RefPtrWillBeMember<Resource>& resource : m_resourcesWithPendingClients)
+    Vector<ResourcePtr<Resource>> resources;
+    for (const RawPtrWillBeMember<Resource>& resource : m_resourcesWithPendingClients)
         resources.append(resource.get());
     m_resourcesWithPendingClients.clear();
 
diff --git a/third_party/WebKit/Source/core/fetch/Resource.h b/third_party/WebKit/Source/core/fetch/Resource.h
index 7689b3e..eae6e25 100644
--- a/third_party/WebKit/Source/core/fetch/Resource.h
+++ b/third_party/WebKit/Source/core/fetch/Resource.h
@@ -49,6 +49,7 @@ struct FetchInitiatorInfo;
 class CachedMetadata;
 class FetchRequest;
 class ResourceClient;
+class ResourcePtrBase;
 class ResourceFetcher;
 class ResourceTimingInfo;
 class InspectorResource;
@@ -59,7 +60,7 @@ class SharedBuffer;
 // A resource that is held in the cache. Classes who want to use this object should derive
 // from ResourceClient, to get the function calls in case the requested data has arrived.
 // This class also does the actual communication with the loader to obtain the resource from the network.
-class CORE_EXPORT Resource : public RefCountedWillBeGarbageCollectedFinalized<Resource> {
+class CORE_EXPORT Resource : public NoBaseWillBeGarbageCollectedFinalized<Resource> {
     WTF_MAKE_NONCOPYABLE(Resource);
     USING_FAST_MALLOC_WITH_TYPE_NAME_WILL_BE_REMOVED(blink::Resource);
     friend class InspectorResource;
@@ -91,13 +92,16 @@ public:
     };
 
     // Exposed for testing.
-    static PassRefPtrWillBeRawPtr<Resource> create(const ResourceRequest& request, Type type)
-    {
-        return adoptRefWillBeNoop(new Resource(request, type));
-    }
+    Resource(const ResourceRequest&, Type);
+#if ENABLE(OILPAN)
     virtual ~Resource();
-
-    virtual void removedFromMemoryCache();
+#else
+protected:
+    // Only deleteIfPossible should delete this.
+    virtual ~Resource();
+public:
+#endif
+    virtual void dispose();
     DECLARE_VIRTUAL_TRACE();
 
     virtual void load(ResourceFetcher*, const ResourceLoaderOptions&);
@@ -137,6 +141,7 @@ public:
     void addClient(ResourceClient*);
     void removeClient(ResourceClient*);
     bool hasClients() const { return !m_clients.isEmpty() || !m_clientsAwaitingCallback.isEmpty() || !m_finishedClients.isEmpty(); }
+    bool deleteIfPossible();
 
     enum PreloadResult {
         PreloadNotReferenced,
@@ -203,6 +208,8 @@ public:
     // This may return nullptr when the resource isn't cacheable.
     CachedMetadataHandler* cacheHandler();
 
+    bool hasOneHandle() const;
+    bool canDelete() const;
     String reasonNotDeletable() const;
 
     // List of acceptable MIME types separated by ",".
@@ -222,6 +229,9 @@ public:
     void increasePreloadCount() { ++m_preloadCount; }
     void decreasePreloadCount() { ASSERT(m_preloadCount); --m_preloadCount; }
 
+    void registerHandle(ResourcePtrBase* h);
+    void unregisterHandle(ResourcePtrBase* h);
+
     bool canReuseRedirectChain();
     bool mustRevalidateDueToCacheHeaders();
     bool canUseCacheValidator();
@@ -235,6 +245,7 @@ public:
     double stalenessLifetime();
 
     bool isPurgeable() const;
+    bool wasPurged() const;
     bool lock();
 
     void setCacheIdentifier(const String& cacheIdentifier) { m_cacheIdentifier = cacheIdentifier; }
@@ -265,13 +276,38 @@ public:
 #endif
 
 protected:
-    Resource(const ResourceRequest&, Type);
-
     virtual void checkNotify();
     virtual void finishOnePart();
 
     virtual void destroyDecodedDataForFailedRevalidation() { }
 
+    // Normal resource pointers will silently switch what Resource* they reference when we
+    // successfully revalidated the resource. We need a way to guarantee that the Resource
+    // that received the 304 response survives long enough to switch everything over to the
+    // revalidatedresource. The normal mechanisms for keeping a Resource alive externally
+    // (ResourcePtrs and ResourceClients registering themselves) don't work in this case, so
+    // have a separate internal protector).
+    class InternalResourcePtr {
+        STACK_ALLOCATED();
+    public:
+        explicit InternalResourcePtr(Resource* resource)
+            : m_resource(resource)
+        {
+            m_resource->incrementProtectorCount();
+        }
+
+        ~InternalResourcePtr()
+        {
+            m_resource->decrementProtectorCount();
+            m_resource->deleteIfPossible();
+        }
+    private:
+        RawPtrWillBeMember<Resource> m_resource;
+    };
+
+    void incrementProtectorCount() { m_protectorCount++; }
+    void decrementProtectorCount() { m_protectorCount--; }
+
     void setEncodedSize(size_t);
     void setDecodedSize(size_t);
     void didAccessDecodedData();
@@ -293,7 +329,7 @@ protected:
         ResourceCallback();
         void runTask();
         OwnPtr<CancellableTaskFactory> m_callbackTaskFactory;
-        WillBeHeapHashSet<RefPtrWillBeMember<Resource>> m_resourcesWithPendingClients;
+        WillBeHeapHashSet<RawPtrWillBeMember<Resource>> m_resourcesWithPendingClients;
     };
 
     bool hasClient(ResourceClient* client) { return m_clients.contains(client) || m_clientsAwaitingCallback.contains(client) || m_finishedClients.contains(client); }
@@ -342,6 +378,8 @@ private:
 
     bool unlock();
 
+    bool hasRightHandleCountApartFromCache(unsigned targetCount) const;
+
     void setCachedMetadata(unsigned dataTypeID, const char*, size_t, CachedMetadataHandler::CacheType);
     void clearCachedMetadata(CachedMetadataHandler::CacheType);
     CachedMetadata* cachedMetadata(unsigned dataTypeID) const;
@@ -363,7 +401,9 @@ private:
 
     size_t m_encodedSize;
     size_t m_decodedSize;
+    unsigned m_handleCount;
     unsigned m_preloadCount;
+    unsigned m_protectorCount;
 
     String m_cacheIdentifier;
 
@@ -372,9 +412,13 @@ private:
 
     unsigned m_loading : 1;
 
+    unsigned m_switchingClientsToRevalidatedResource : 1;
+
     unsigned m_type : 4; // Type
     unsigned m_status : 3; // Status
 
+    unsigned m_wasPurged : 1;
+
     unsigned m_needsSynchronousCacheHit : 1;
     unsigned m_avoidBlockingOnLoad : 1;
 
@@ -389,7 +433,7 @@ private:
 class ResourceFactory {
     STACK_ALLOCATED();
 public:
-    virtual PassRefPtrWillBeRawPtr<Resource> create(const ResourceRequest&, const String&) const = 0;
+    virtual Resource* create(const ResourceRequest&, const String&) const = 0;
     Resource::Type type() const { return m_type; }
 
 protected:
@@ -400,7 +444,7 @@ protected:
 
 #define DEFINE_RESOURCE_TYPE_CASTS(typeName) \
     DEFINE_TYPE_CASTS(typeName##Resource, Resource, resource, resource->type() == Resource::typeName, resource.type() == Resource::typeName); \
-    inline typeName##Resource* to##typeName##Resource(const RefPtrWillBeRawPtr<Resource>& ptr) { return to##typeName##Resource(ptr.get()); }
+    inline typeName##Resource* to##typeName##Resource(const ResourcePtr<Resource>& ptr) { return to##typeName##Resource(ptr.get()); }
 
 } // namespace blink
 
diff --git a/third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp b/third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp
index c269dc2..5d39309 100644
--- a/third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp
+++ b/third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp
@@ -275,7 +275,7 @@ static PassRefPtr<TracedValue> urlForTraceEvent(const KURL& url)
     return value.release();
 }
 
-void ResourceFetcher::preCacheData(const FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
+ResourcePtr<Resource> ResourceFetcher::preCacheData(const FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
 {
     const KURL& url = request.resourceRequest().url();
     ASSERT(url.protocolIsData() || substituteData.isValid());
@@ -285,13 +285,13 @@ void ResourceFetcher::preCacheData(const FetchRequest& request, const ResourceFa
     // 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;
+        return nullptr;
 
     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;
+            return oldResource;
         memoryCache()->remove(oldResource);
     }
 
@@ -305,13 +305,13 @@ void ResourceFetcher::preCacheData(const FetchRequest& request, const ResourceFa
     } else {
         data = PassRefPtr<SharedBuffer>(Platform::current()->parseDataURL(url, mimetype, charset));
         if (!data)
-            return;
+            return nullptr;
     }
     ResourceResponse response(url, mimetype, data->size(), charset, String());
     response.setHTTPStatusCode(200);
     response.setHTTPStatusText("OK");
 
-    RefPtrWillBeRawPtr<Resource> resource = factory.create(request.resourceRequest(), request.charset());
+    ResourcePtr<Resource> resource = factory.create(request.resourceRequest(), request.charset());
     resource->setNeedsSynchronousCacheHit(substituteData.forceSynchronousLoad());
     resource->setOptions(request.options());
     // FIXME: We should provide a body stream here.
@@ -323,6 +323,7 @@ void ResourceFetcher::preCacheData(const FetchRequest& request, const ResourceFa
     resource->setCacheIdentifier(cacheIdentifier);
     resource->finish();
     memoryCache()->add(resource.get());
+    return resource;
 }
 
 void ResourceFetcher::moveCachedNonBlockingResourceToBlocking(Resource* resource, const FetchRequest& request)
@@ -337,7 +338,7 @@ void ResourceFetcher::moveCachedNonBlockingResourceToBlocking(Resource* resource
     }
 }
 
-PassRefPtrWillBeRawPtr<Resource> ResourceFetcher::requestResource(FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
+ResourcePtr<Resource> ResourceFetcher::requestResource(FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
 {
     ASSERT(request.options().synchronousPolicy == RequestAsynchronously || factory.type() == Resource::Raw || factory.type() == Resource::XSLStyleSheet);
 
@@ -375,9 +376,11 @@ PassRefPtrWillBeRawPtr<Resource> ResourceFetcher::requestResource(FetchRequest&
     }
 
     bool isStaticData = request.resourceRequest().url().protocolIsData() || substituteData.isValid();
+    ResourcePtr<Resource> resource;
     if (isStaticData)
-        preCacheData(request, factory, substituteData);
-    RefPtrWillBeRawPtr<Resource> resource = memoryCache()->resourceForURL(url, getCacheIdentifier());
+        resource = preCacheData(request, factory, substituteData);
+    if (!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);
@@ -535,7 +538,7 @@ void ResourceFetcher::initializeRevalidation(const FetchRequest& request, Resour
     resource->setRevalidatingRequest(revalidatingRequest);
 }
 
-PassRefPtrWillBeRawPtr<Resource> ResourceFetcher::createResourceForLoading(FetchRequest& request, const String& charset, const ResourceFactory& factory)
+ResourcePtr<Resource> ResourceFetcher::createResourceForLoading(FetchRequest& request, const String& charset, const ResourceFactory& factory)
 {
     const String cacheIdentifier = getCacheIdentifier();
     ASSERT(!memoryCache()->resourceForURL(request.resourceRequest().url(), cacheIdentifier));
@@ -543,7 +546,7 @@ PassRefPtrWillBeRawPtr<Resource> ResourceFetcher::createResourceForLoading(Fetch
     WTF_LOG(ResourceLoading, "Loading Resource for '%s'.", request.resourceRequest().url().elidedString().latin1().data());
 
     initializeResourceRequest(request.mutableResourceRequest(), factory.type());
-    RefPtrWillBeRawPtr<Resource> resource = factory.create(request.resourceRequest(), charset);
+    ResourcePtr<Resource> resource = factory.create(request.resourceRequest(), charset);
     resource->setAvoidBlockingOnLoad(request.avoidBlockingOnLoad());
     resource->setCacheIdentifier(cacheIdentifier);
 
@@ -813,7 +816,7 @@ void ResourceFetcher::preloadStarted(Resource* resource)
     resource->increasePreloadCount();
 
     if (!m_preloads)
-        m_preloads = adoptPtrWillBeNoop(new WillBeHeapListHashSet<RefPtrWillBeMember<Resource>>);
+        m_preloads = adoptPtrWillBeNoop(new WillBeHeapListHashSet<RawPtrWillBeMember<Resource>>);
     m_preloads->add(resource);
 
 #if PRELOAD_DEBUG
@@ -843,8 +846,9 @@ void ResourceFetcher::clearPreloads(ClearPreloadsPolicy policy)
 
     for (auto resource : *m_preloads) {
         resource->decreasePreloadCount();
+        bool deleted = resource->deleteIfPossible();
         // avoidBlockingOnLoad is only set on non speculative preloads (i.e. <link rel=preload> triggered preloads)
-        if (resource->preloadResult() == Resource::PreloadNotReferenced && (policy == ClearAllPreloads || !resource->avoidBlockingOnLoad()))
+        if (!deleted && resource->preloadResult() == Resource::PreloadNotReferenced && (policy == ClearAllPreloads || !resource->avoidBlockingOnLoad()))
             memoryCache()->remove(resource.get());
     }
     m_preloads.clear();
diff --git a/third_party/WebKit/Source/core/fetch/ResourceFetcher.h b/third_party/WebKit/Source/core/fetch/ResourceFetcher.h
index 828382b..b12db11 100644
--- a/third_party/WebKit/Source/core/fetch/ResourceFetcher.h
+++ b/third_party/WebKit/Source/core/fetch/ResourceFetcher.h
@@ -33,6 +33,7 @@
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/Resource.h"
 #include "core/fetch/ResourceLoaderOptions.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/fetch/SubstituteData.h"
 #include "platform/Timer.h"
 #include "platform/network/ResourceError.h"
@@ -73,7 +74,7 @@ public:
     virtual ~ResourceFetcher();
     DECLARE_VIRTUAL_TRACE();
 
-    PassRefPtrWillBeRawPtr<Resource> requestResource(FetchRequest&, const ResourceFactory&, const SubstituteData& = SubstituteData());
+    ResourcePtr<Resource> requestResource(FetchRequest&, const ResourceFactory&, const SubstituteData& = SubstituteData());
 
     Resource* cachedResource(const KURL&) const;
 
@@ -151,7 +152,7 @@ public:
     void updateAllImageResourcePriorities();
 
     // This is only exposed for testing purposes.
-    WillBeHeapListHashSet<RefPtrWillBeMember<Resource>>* preloads() { return m_preloads.get(); }
+    WillBeHeapListHashSet<RawPtrWillBeMember<Resource>>* preloads() { return m_preloads.get(); }
 
 private:
     friend class ResourceCacheValidationSuppressor;
@@ -159,10 +160,10 @@ private:
     explicit ResourceFetcher(FetchContext*);
 
     void initializeRevalidation(const FetchRequest&, Resource*);
-    PassRefPtrWillBeRawPtr<Resource> createResourceForLoading(FetchRequest&, const String& charset, const ResourceFactory&);
+    ResourcePtr<Resource> createResourceForLoading(FetchRequest&, const String& charset, const ResourceFactory&);
     void storeResourceTimingInitiatorInformation(Resource*);
     bool scheduleArchiveLoad(Resource*, const ResourceRequest&);
-    void preCacheData(const FetchRequest&, const ResourceFactory&, const SubstituteData&);
+    ResourcePtr<Resource> preCacheData(const FetchRequest&, const ResourceFactory&, const SubstituteData&);
 
     // RevalidationPolicy enum values are used in UMAs https://crbug.com/579496.
     enum RevalidationPolicy { Use, Revalidate, Reload, Load };
@@ -187,11 +188,18 @@ private:
     HashSet<String> m_validatedURLs;
     mutable DocumentResourceMap m_documentResources;
 
-    OwnPtrWillBeMember<WillBeHeapListHashSet<RefPtrWillBeMember<Resource>>> m_preloads;
+    // We intentionally use a Member instead of a ResourcePtr.
+    // Using a ResourcePtrs can lead to a wrong behavior because
+    // the underlying Resource of the ResourcePtr is updated when the Resource
+    // is revalidated. What we really want to hold here is not the ResourcePtr
+    // but the underlying Resource.
+    OwnPtrWillBeMember<WillBeHeapListHashSet<RawPtrWillBeMember<Resource>>> m_preloads;
     RefPtrWillBeMember<MHTMLArchive> m_archive;
 
     Timer<ResourceFetcher> m_resourceTimingReportTimer;
 
+    // We intentionally use a Member instead of a ResourcePtr.
+    // See the comment on m_preloads.
     using ResourceTimingInfoMap = WillBeHeapHashMap<RawPtrWillBeMember<Resource>, OwnPtr<ResourceTimingInfo>>;
     ResourceTimingInfoMap m_resourceTimingInfoMap;
 
diff --git a/third_party/WebKit/Source/core/fetch/ResourceFetcherTest.cpp b/third_party/WebKit/Source/core/fetch/ResourceFetcherTest.cpp
index ffc0a0c..784cc6f 100644
--- a/third_party/WebKit/Source/core/fetch/ResourceFetcherTest.cpp
+++ b/third_party/WebKit/Source/core/fetch/ResourceFetcherTest.cpp
@@ -35,6 +35,7 @@
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceLoader.h"
+#include "core/fetch/ResourcePtr.h"
 #include "platform/exported/WrappedResourceResponse.h"
 #include "platform/heap/Handle.h"
 #include "platform/network/ResourceRequest.h"
@@ -79,9 +80,9 @@ public:
     TestResourceFactory(Resource::Type type = Resource::Raw)
         : ResourceFactory(type) { }
 
-    PassRefPtrWillBeRawPtr<Resource> create(const ResourceRequest& request, const String& charset) const override
+    Resource* create(const ResourceRequest& request, const String& charset) const override
     {
-        return Resource::create(request, type());
+        return new Resource(request, type());
     }
 };
 
@@ -92,7 +93,7 @@ TEST_F(ResourceFetcherTest, StartLoadAfterFrameDetach)
     // and no resource should be present in the cache.
     ResourceFetcher* fetcher = ResourceFetcher::create(nullptr);
     FetchRequest fetchRequest = FetchRequest(ResourceRequest(secureURL), FetchInitiatorInfo());
-    RefPtrWillBeRawPtr<Resource> resource = fetcher->requestResource(fetchRequest, TestResourceFactory());
+    ResourcePtr<Resource> resource = fetcher->requestResource(fetchRequest, TestResourceFactory());
     EXPECT_EQ(resource.get(), static_cast<Resource*>(nullptr));
     EXPECT_EQ(memoryCache()->resourceForURL(secureURL), static_cast<Resource*>(nullptr));
 }
@@ -102,7 +103,7 @@ TEST_F(ResourceFetcherTest, UseExistingResource)
     ResourceFetcher* fetcher = ResourceFetcher::create(ResourceFetcherTestMockFetchContext::create());
 
     KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html");
-    RefPtrWillBeRawPtr<Resource> resource = Resource::create(url, Resource::Image);
+    ResourcePtr<Resource> resource = new Resource(url, Resource::Image);
     memoryCache()->add(resource.get());
     ResourceResponse response;
     response.setURL(url);
@@ -112,7 +113,7 @@ TEST_F(ResourceFetcherTest, UseExistingResource)
     resource->finish();
 
     FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo());
-    RefPtrWillBeRawPtr<Resource> newResource = fetcher->requestResource(fetchRequest, TestResourceFactory(Resource::Image));
+    ResourcePtr<Resource> newResource = fetcher->requestResource(fetchRequest, TestResourceFactory(Resource::Image));
     EXPECT_EQ(resource, newResource);
     memoryCache()->remove(resource.get());
 }
@@ -120,7 +121,7 @@ TEST_F(ResourceFetcherTest, UseExistingResource)
 TEST_F(ResourceFetcherTest, Vary)
 {
     KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html");
-    RefPtrWillBeRawPtr<Resource> resource = Resource::create(url, Resource::Raw);
+    ResourcePtr<Resource> resource = new Resource(url, Resource::Raw);
     memoryCache()->add(resource.get());
     ResourceResponse response;
     response.setURL(url);
@@ -134,7 +135,7 @@ TEST_F(ResourceFetcherTest, Vary)
     ResourceFetcher* fetcher = ResourceFetcher::create(ResourceFetcherTestMockFetchContext::create());
     FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo());
     Platform::current()->unitTestSupport()->registerMockedURL(url, WebURLResponse(), "");
-    RefPtrWillBeRawPtr<Resource> newResource = fetcher->requestResource(fetchRequest, TestResourceFactory());
+    ResourcePtr<Resource> newResource = fetcher->requestResource(fetchRequest, TestResourceFactory());
     EXPECT_NE(resource, newResource);
     newResource->loader()->cancel();
     memoryCache()->remove(newResource.get());
@@ -150,7 +151,7 @@ TEST_F(ResourceFetcherTest, VaryOnBack)
     ResourceFetcher* fetcher = ResourceFetcher::create(context);
 
     KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html");
-    RefPtrWillBeRawPtr<Resource> resource = Resource::create(url, Resource::Raw);
+    ResourcePtr<Resource> resource = new Resource(url, Resource::Raw);
     memoryCache()->add(resource.get());
     ResourceResponse response;
     response.setURL(url);
@@ -162,7 +163,7 @@ TEST_F(ResourceFetcherTest, VaryOnBack)
     ASSERT_TRUE(resource->hasVaryHeader());
 
     FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo());
-    RefPtrWillBeRawPtr<Resource> newResource = fetcher->requestResource(fetchRequest, TestResourceFactory());
+    ResourcePtr<Resource> newResource = fetcher->requestResource(fetchRequest, TestResourceFactory());
     EXPECT_EQ(resource, newResource);
 
     memoryCache()->remove(newResource.get());
@@ -181,13 +182,13 @@ TEST_F(ResourceFetcherTest, VaryImage)
     URLTestHelpers::registerMockedURLLoadWithCustomResponse(url, "white-1x1.png", WebString::fromUTF8(""), WrappedResourceResponse(response));
 
     FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo());
-    RefPtrWillBeRawPtr<Resource> resource = fetcher->requestResource(fetchRequestOriginal, TestResourceFactory(Resource::Image));
+    ResourcePtr<Resource> resource = fetcher->requestResource(fetchRequestOriginal, TestResourceFactory(Resource::Image));
     ASSERT_TRUE(resource.get());
     Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     ASSERT_TRUE(resource->hasVaryHeader());
 
     FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo());
-    RefPtrWillBeRawPtr<Resource> newResource = fetcher->requestResource(fetchRequest, TestResourceFactory(Resource::Image));
+    ResourcePtr<Resource> newResource = fetcher->requestResource(fetchRequest, TestResourceFactory(Resource::Image));
     EXPECT_EQ(resource, newResource);
 
     memoryCache()->remove(newResource.get());
@@ -203,7 +204,7 @@ TEST_F(ResourceFetcherTest, RevalidateWhileLoading)
     ResourceRequest request1(url);
     request1.setHTTPHeaderField(HTTPNames::Cache_Control, "no-cache");
     FetchRequest fetchRequest1 = FetchRequest(request1, FetchInitiatorInfo());
-    RefPtrWillBeRawPtr<Resource> resource1 = fetcher1->requestResource(fetchRequest1, TestResourceFactory(Resource::Image));
+    ResourcePtr<Resource> resource1 = fetcher1->requestResource(fetchRequest1, TestResourceFactory(Resource::Image));
     ResourceResponse response;
     response.setURL(url);
     response.setHTTPStatusCode(200);
@@ -216,7 +217,7 @@ TEST_F(ResourceFetcherTest, RevalidateWhileLoading)
     context->setCachePolicy(CachePolicyRevalidate);
     ResourceFetcher* fetcher2 = ResourceFetcher::create(context);
     FetchRequest fetchRequest2(url, FetchInitiatorInfo());
-    RefPtrWillBeRawPtr<Resource> resource2 = fetcher2->requestResource(fetchRequest2, TestResourceFactory(Resource::Image));
+    ResourcePtr<Resource> resource2 = fetcher2->requestResource(fetchRequest2, TestResourceFactory(Resource::Image));
     EXPECT_EQ(resource1, resource2);
 
     // Tidily(?) shut down the ResourceLoader.
@@ -231,8 +232,8 @@ TEST_F(ResourceFetcherTest, DontReuseMediaDataUrl)
     ResourceLoaderOptions options;
     options.dataBufferingPolicy = DoNotBufferData;
     FetchRequest fetchRequest = FetchRequest(request, FetchInitiatorTypeNames::internal, options);
-    RefPtrWillBeRawPtr<Resource> resource1 = fetcher->requestResource(fetchRequest, TestResourceFactory(Resource::Media));
-    RefPtrWillBeRawPtr<Resource> resource2 = fetcher->requestResource(fetchRequest, TestResourceFactory(Resource::Media));
+    ResourcePtr<Resource> resource1 = fetcher->requestResource(fetchRequest, TestResourceFactory(Resource::Media));
+    ResourcePtr<Resource> resource2 = fetcher->requestResource(fetchRequest, TestResourceFactory(Resource::Media));
     EXPECT_NE(resource1.get(), resource2.get());
     memoryCache()->remove(resource2.get());
 }
diff --git a/third_party/WebKit/Source/core/fetch/ResourceLoader.cpp b/third_party/WebKit/Source/core/fetch/ResourceLoader.cpp
index d53920a..153d175 100644
--- a/third_party/WebKit/Source/core/fetch/ResourceLoader.cpp
+++ b/third_party/WebKit/Source/core/fetch/ResourceLoader.cpp
@@ -32,6 +32,7 @@
 #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"
@@ -98,6 +99,7 @@ void ResourceLoader::releaseResources()
     if (m_state == Terminated)
         return;
     m_resource->clearLoader();
+    m_resource->deleteIfPossible();
     m_resource = nullptr;
 
     ASSERT(m_state != Terminated);
@@ -130,7 +132,7 @@ void ResourceLoader::start()
     ASSERT(!m_request.isNull());
     ASSERT(m_deferredRequest.isNull());
 
-    m_fetcher->willStartLoadingResource(m_resource.get(), m_request);
+    m_fetcher->willStartLoadingResource(m_resource, m_request);
 
     if (m_options.synchronousPolicy == RequestSynchronously) {
         requestSynchronously();
@@ -194,7 +196,7 @@ void ResourceLoader::didDownloadData(WebURLLoader*, int length, int encodedDataL
 {
     ASSERT(m_state != Terminated);
     RELEASE_ASSERT(m_connectionState == ConnectionStateReceivedResponse);
-    m_fetcher->didDownloadData(m_resource.get(), length, encodedDataLength);
+    m_fetcher->didDownloadData(m_resource, length, encodedDataLength);
     if (m_state == Terminated)
         return;
     m_resource->didDownloadData(length);
@@ -210,7 +212,7 @@ void ResourceLoader::didFinishLoadingOnePart(double finishTime, int64_t encodedD
     if (m_notifiedLoadComplete)
         return;
     m_notifiedLoadComplete = true;
-    m_fetcher->didFinishLoading(m_resource.get(), finishTime, encodedDataLength);
+    m_fetcher->didFinishLoading(m_resource, finishTime, encodedDataLength);
 }
 
 void ResourceLoader::didChangePriority(ResourceLoadPriority loadPriority, int intraPriorityValue)
@@ -257,7 +259,7 @@ void ResourceLoader::cancel(const ResourceError& error)
 
     if (!m_notifiedLoadComplete) {
         m_notifiedLoadComplete = true;
-        m_fetcher->didFailLoading(m_resource.get(), nonNullError);
+        m_fetcher->didFailLoading(m_resource, nonNullError);
     }
 
     if (m_state == Finishing)
@@ -276,14 +278,14 @@ void ResourceLoader::willFollowRedirect(WebURLLoader*, WebURLRequest& passedNewR
     const ResourceResponse& redirectResponse(passedRedirectResponse.toResourceResponse());
     ASSERT(!redirectResponse.isNull());
     newRequest.setFollowedRedirect(true);
-    if (!isManualRedirectFetchRequest(m_resource->resourceRequest()) && !m_fetcher->canAccessRedirect(m_resource.get(), newRequest, redirectResponse, m_options)) {
+    if (!isManualRedirectFetchRequest(m_resource->resourceRequest()) && !m_fetcher->canAccessRedirect(m_resource, 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.get(), redirectResponse);
+    m_fetcher->redirectReceived(m_resource, redirectResponse);
     ASSERT(m_state != Terminated);
     m_resource->willFollowRedirect(newRequest, redirectResponse);
     if (newRequest.isNull() || m_state == Terminated)
@@ -345,10 +347,14 @@ void ResourceLoader::didReceiveResponse(WebURLLoader*, const WebURLResponse& res
                 return;
             }
         } else {
-            if (!m_resource->isCacheValidator() || resourceResponse.httpStatusCode() != 304)
+            // 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)
                 m_resource->setResponse(resourceResponse);
-            if (!m_fetcher->canAccessResource(m_resource.get(), m_options.securityOrigin.get(), response.url(), ResourceFetcher::ShouldLogAccessControlErrors)) {
-                m_fetcher->didReceiveResponse(m_resource.get(), 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;
             }
@@ -359,7 +365,7 @@ void ResourceLoader::didReceiveResponse(WebURLLoader*, const WebURLResponse& res
     if (m_state == Terminated)
         return;
 
-    m_fetcher->didReceiveResponse(m_resource.get(), resourceResponse);
+    m_fetcher->didReceiveResponse(m_resource, resourceResponse);
     if (m_state == Terminated)
         return;
 
@@ -386,7 +392,7 @@ void ResourceLoader::didReceiveResponse(WebURLLoader*, const WebURLResponse& res
 
     if (!m_notifiedLoadComplete) {
         m_notifiedLoadComplete = true;
-        m_fetcher->didFailLoading(m_resource.get(), ResourceError::cancelledError(m_request.url()));
+        m_fetcher->didFailLoading(m_resource, ResourceError::cancelledError(m_request.url()));
     }
 
     ASSERT(m_state != Terminated);
@@ -414,7 +420,7 @@ void ResourceLoader::didReceiveData(WebURLLoader*, const char* data, int length,
     // 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.get(), data, length, encodedDataLength);
+    m_fetcher->didReceiveData(m_resource, data, length, encodedDataLength);
     if (m_state == Terminated)
         return;
     RELEASE_ASSERT(length >= 0);
@@ -430,7 +436,7 @@ void ResourceLoader::didFinishLoading(WebURLLoader*, double finishTime, int64_t
     ASSERT(m_state != Terminated);
     WTF_LOG(ResourceLoading, "Received '%s'.", m_resource->url().string().latin1().data());
 
-    RefPtrWillBeRawPtr<Resource> protectResource(m_resource.get());
+    ResourcePtr<Resource> protectResource(m_resource);
     m_state = Finishing;
     m_resource->setLoadFinishTime(finishTime);
     didFinishLoadingOnePart(finishTime, encodedDataLength);
@@ -451,13 +457,13 @@ void ResourceLoader::didFail(WebURLLoader*, const WebURLError& error)
     ASSERT(m_state != Terminated);
     WTF_LOG(ResourceLoading, "Failed to load '%s'.\n", m_resource->url().string().latin1().data());
 
-    RefPtrWillBeRawPtr<Resource> protectResource(m_resource.get());
+    ResourcePtr<Resource> protectResource(m_resource);
     m_state = Finishing;
     m_resource->setResourceError(error);
 
     if (!m_notifiedLoadComplete) {
         m_notifiedLoadComplete = true;
-        m_fetcher->didFailLoading(m_resource.get(), error);
+        m_fetcher->didFailLoading(m_resource, error);
     }
     if (m_state == Terminated)
         return;
@@ -483,7 +489,7 @@ void ResourceLoader::requestSynchronously()
     // downloadToFile is not supported for synchronous requests.
     ASSERT(!m_request.downloadToFile());
 
-    RefPtrWillBeRawPtr<Resource> protectResource(m_resource.get());
+    ResourcePtr<Resource> protectResource(m_resource);
 
     RELEASE_ASSERT(m_connectionState == ConnectionStateNew);
     m_connectionState = ConnectionStateStarted;
@@ -515,7 +521,7 @@ void ResourceLoader::requestSynchronously()
     // 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_fetcher->didReceiveData(m_resource, dataOut.data(), dataOut.size(), encodedDataLength);
         m_resource->setResourceBuffer(dataOut);
     }
     didFinishLoading(0, monotonicallyIncreasingTime(), encodedDataLength);
diff --git a/third_party/WebKit/Source/core/fetch/ResourceLoader.h b/third_party/WebKit/Source/core/fetch/ResourceLoader.h
index 320c896..734da2a 100644
--- a/third_party/WebKit/Source/core/fetch/ResourceLoader.h
+++ b/third_party/WebKit/Source/core/fetch/ResourceLoader.h
@@ -61,7 +61,7 @@ public:
     void cancel(const ResourceError&);
     void cancelIfNotFinishing();
 
-    Resource* cachedResource() { return m_resource.get(); }
+    Resource* cachedResource() { return m_resource; }
     const ResourceRequest& originalRequest() const { return m_originalRequest; }
 
     void setDefersLoading(bool);
@@ -134,7 +134,7 @@ private:
         ConnectionStateFailed,
     };
 
-    RefPtrWillBeMember<Resource> m_resource;
+    RawPtrWillBeMember<Resource> m_resource;
     ResourceLoaderState m_state;
 
     // Used for sanity checking to make sure we don't experience illegal state
diff --git a/third_party/WebKit/Source/core/fetch/ResourceOwner.h b/third_party/WebKit/Source/core/fetch/ResourceOwner.h
index 2fb6fe5..69822c1 100644
--- a/third_party/WebKit/Source/core/fetch/ResourceOwner.h
+++ b/third_party/WebKit/Source/core/fetch/ResourceOwner.h
@@ -31,57 +31,54 @@
 #ifndef ResourceOwner_h
 #define ResourceOwner_h
 
-#include "core/fetch/Resource.h"
+#include "core/fetch/ResourcePtr.h"
 
 namespace blink {
 
+
 template<class R, class C = typename R::ClientType>
 class ResourceOwner : public WillBeGarbageCollectedMixin, public C {
-    WILL_BE_USING_PRE_FINALIZER(ResourceOwner, clearResource);
 public:
     using ResourceType = R;
 
     virtual ~ResourceOwner();
     ResourceType* resource() const { return m_resource.get(); }
 
-    DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_resource); }
+    DEFINE_INLINE_VIRTUAL_TRACE() {}
 
 protected:
     ResourceOwner();
 
-    void setResource(const PassRefPtrWillBeRawPtr<ResourceType>&);
+    void setResource(const ResourcePtr<ResourceType>&);
     void clearResource() { setResource(nullptr); }
 
 private:
-    RefPtrWillBeMember<ResourceType> m_resource;
+    ResourcePtr<ResourceType> m_resource;
 };
 
 template<class R, class C>
 inline ResourceOwner<R, C>::ResourceOwner()
 {
-#if ENABLE(OILPAN)
-    ThreadState::current()->registerPreFinalizer(this);
-#endif
 }
 
 template<class R, class C>
 inline ResourceOwner<R, C>::~ResourceOwner()
 {
-#if !ENABLE(OILPAN)
     clearResource();
-#endif
 }
 
 template<class R, class C>
-inline void ResourceOwner<R, C>::setResource(const PassRefPtrWillBeRawPtr<R>& newResource)
+inline void ResourceOwner<R, C>::setResource(const ResourcePtr<R>& newResource)
 {
     if (newResource == m_resource)
         return;
 
     // Some ResourceClient implementations reenter this so
     // we need to prevent double removal.
-    if (RefPtrWillBeRawPtr<ResourceType> oldResource = m_resource.release())
+    if (ResourcePtr<ResourceType> oldResource = m_resource) {
+        m_resource.clear();
         oldResource->removeClient(this);
+    }
 
     if (newResource) {
         m_resource = newResource;
diff --git a/third_party/WebKit/Source/core/fetch/ResourcePtr.cpp b/third_party/WebKit/Source/core/fetch/ResourcePtr.cpp
new file mode 100644
index 0000000..8e0624e
--- /dev/null
+++ b/third_party/WebKit/Source/core/fetch/ResourcePtr.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * 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.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 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/ResourcePtr.h"
+
+namespace blink {
+
+void ResourcePtrBase::setResource(Resource* resource)
+{
+    if (resource == m_resource)
+        return;
+    if (m_resource)
+        m_resource->unregisterHandle(this);
+    m_resource = resource;
+    if (m_resource)
+        m_resource->registerHandle(this);
+}
+
+} // namespace blink
diff --git a/third_party/WebKit/Source/core/fetch/ResourcePtr.h b/third_party/WebKit/Source/core/fetch/ResourcePtr.h
new file mode 100644
index 0000000..77d2901
--- /dev/null
+++ b/third_party/WebKit/Source/core/fetch/ResourcePtr.h
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * 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.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 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.
+ */
+
+#ifndef ResourcePtr_h
+#define ResourcePtr_h
+
+#include "core/CoreExport.h"
+#include "core/fetch/Resource.h"
+#include "wtf/Allocator.h"
+
+namespace blink {
+
+class CORE_EXPORT ResourcePtrBase {
+    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
+public:
+    Resource* get() const { return m_resource; }
+    bool operator!() const { return !m_resource; }
+    void clear() { setResource(nullptr); }
+
+    // This conversion operator allows implicit conversion to bool but not to other integer types.
+    typedef Resource* ResourcePtrBase::*UnspecifiedBoolType;
+    operator UnspecifiedBoolType() const { return m_resource ? &ResourcePtrBase::m_resource : nullptr; }
+
+protected:
+    ResourcePtrBase() : m_resource(nullptr) { }
+    explicit ResourcePtrBase(Resource*);
+    explicit ResourcePtrBase(const ResourcePtrBase&);
+    ~ResourcePtrBase();
+
+    void setResource(Resource*);
+
+private:
+    friend class Resource;
+    ResourcePtrBase& operator=(const ResourcePtrBase&) = delete;
+
+    // The lifetime of the Resource object is explicitly managed by
+    // reference-counting.
+    GC_PLUGIN_IGNORE("503485")
+    Resource* m_resource;
+};
+
+inline ResourcePtrBase::ResourcePtrBase(Resource* res)
+    : m_resource(res)
+{
+    if (m_resource)
+        m_resource->registerHandle(this);
+}
+
+inline ResourcePtrBase::~ResourcePtrBase()
+{
+    if (m_resource)
+        m_resource->unregisterHandle(this);
+}
+
+inline ResourcePtrBase::ResourcePtrBase(const ResourcePtrBase& o)
+    : m_resource(o.m_resource)
+{
+    if (m_resource)
+        m_resource->registerHandle(this);
+}
+
+template <class R> class ResourcePtr final : public ResourcePtrBase {
+public:
+    ResourcePtr() { }
+    ResourcePtr(R* res) : ResourcePtrBase(res) { }
+    ResourcePtr(const ResourcePtr<R>& o) : ResourcePtrBase(o) { }
+    template<typename U> ResourcePtr(const ResourcePtr<U>& o) : ResourcePtrBase(cast(o.get())) { }
+
+    R* get() const { return static_cast<R*>(ResourcePtrBase::get()); }
+    R* operator->() const { return get(); }
+
+    ResourcePtr& operator=(R* res) { setResource(res); return *this; }
+    ResourcePtr& operator=(const ResourcePtr& o) { setResource(o.get()); return *this; }
+    template<typename U> ResourcePtr& operator=(const ResourcePtr<U>& o) { setResource(cast(o.get())); return *this; }
+
+    bool operator==(const ResourcePtrBase& o) const { return get() == o.get(); }
+    bool operator!=(const ResourcePtrBase& o) const { return get() != o.get(); }
+private:
+    template<typename U> static R* cast(U* u) { return u; }
+};
+
+template <class R, class RR> bool operator==(const ResourcePtr<R>& h, const RR* res)
+{
+    return h.get() == res;
+}
+template <class R, class RR> bool operator==(const RR* res, const ResourcePtr<R>& h)
+{
+    return h.get() == res;
+}
+template <class R, class RR> bool operator!=(const ResourcePtr<R>& h, const RR* res)
+{
+    return h.get() != res;
+}
+template <class R, class RR> bool operator!=(const RR* res, const ResourcePtr<R>& h)
+{
+    return h.get() != res;
+}
+} // namespace blink
+
+#endif
diff --git a/third_party/WebKit/Source/core/fetch/ResourceTest.cpp b/third_party/WebKit/Source/core/fetch/ResourceTest.cpp
index 42dd25d..ae04c9b 100644
--- a/third_party/WebKit/Source/core/fetch/ResourceTest.cpp
+++ b/third_party/WebKit/Source/core/fetch/ResourceTest.cpp
@@ -4,6 +4,7 @@
 
 #include "core/fetch/Resource.h"
 
+#include "core/fetch/ResourcePtr.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/testing/TestingPlatformSupport.h"
@@ -47,7 +48,7 @@ ResourceResponse createTestResourceResponse()
 void createTestResourceAndSetCachedMetadata(const ResourceResponse& response)
 {
     const char testData[] = "test data";
-    RefPtrWillBeRawPtr<Resource> resource = Resource::create(ResourceRequest(response.url()), Resource::Raw);
+    ResourcePtr<Resource> resource = new Resource(ResourceRequest(response.url()), Resource::Raw);
     resource->setResponse(response);
     resource->cacheHandler()->setCachedMetadata(100, testData, sizeof(testData), CachedMetadataHandler::SendToPlatform);
     return;
diff --git a/third_party/WebKit/Source/core/fetch/ScriptResource.cpp b/third_party/WebKit/Source/core/fetch/ScriptResource.cpp
index 0dbe1fe..c78a639 100644
--- a/third_party/WebKit/Source/core/fetch/ScriptResource.cpp
+++ b/third_party/WebKit/Source/core/fetch/ScriptResource.cpp
@@ -37,14 +37,14 @@
 
 namespace blink {
 
-PassRefPtrWillBeRawPtr<ScriptResource> ScriptResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<ScriptResource> ScriptResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
 {
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
     request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextScript);
-    RefPtrWillBeRawPtr<ScriptResource> resource = toScriptResource(fetcher->requestResource(request, ScriptResourceFactory()));
+    ResourcePtr<ScriptResource> resource = toScriptResource(fetcher->requestResource(request, ScriptResourceFactory()));
     if (resource && !request.integrityMetadata().isEmpty())
         resource->setIntegrityMetadata(request.integrityMetadata());
-    return resource.release();
+    return resource;
 }
 
 ScriptResource::ScriptResource(const ResourceRequest& resourceRequest, const String& charset)
diff --git a/third_party/WebKit/Source/core/fetch/ScriptResource.h b/third_party/WebKit/Source/core/fetch/ScriptResource.h
index c49f1c0..3cab8be 100644
--- a/third_party/WebKit/Source/core/fetch/ScriptResource.h
+++ b/third_party/WebKit/Source/core/fetch/ScriptResource.h
@@ -49,13 +49,10 @@ public:
 class CORE_EXPORT ScriptResource final : public TextResource {
 public:
     using ClientType = ScriptResourceClient;
-    static PassRefPtrWillBeRawPtr<ScriptResource> fetch(FetchRequest&, ResourceFetcher*);
+    static ResourcePtr<ScriptResource> fetch(FetchRequest&, ResourceFetcher*);
 
     // Public for testing
-    static PassRefPtrWillBeRawPtr<ScriptResource> create(const ResourceRequest& request, const String& charset)
-    {
-        return adoptRefWillBeNoop(new ScriptResource(request, charset));
-    }
+    ScriptResource(const ResourceRequest&, const String& charset);
 
     ~ScriptResource() override;
 
@@ -84,14 +81,12 @@ private:
         ScriptResourceFactory()
             : ResourceFactory(Resource::Script) { }
 
-        PassRefPtrWillBeRawPtr<Resource> create(const ResourceRequest& request, const String& charset) const override
+        Resource* create(const ResourceRequest& request, const String& charset) const override
         {
-            return adoptRefWillBeNoop(new ScriptResource(request, charset));
+            return new ScriptResource(request, charset);
         }
     };
 
-    ScriptResource(const ResourceRequest&, const String& charset);
-
     bool m_integrityChecked;
     IntegrityMetadataSet m_integrityMetadata;
 
diff --git a/third_party/WebKit/Source/core/fetch/TextResource.h b/third_party/WebKit/Source/core/fetch/TextResource.h
index c24b261..f180511 100644
--- a/third_party/WebKit/Source/core/fetch/TextResource.h
+++ b/third_party/WebKit/Source/core/fetch/TextResource.h
@@ -6,7 +6,7 @@
 #define TextResource_h
 
 #include "core/CoreExport.h"
-#include "core/fetch/Resource.h"
+#include "core/fetch/ResourcePtr.h"
 
 namespace blink {
 
diff --git a/third_party/WebKit/Source/core/fetch/XSLStyleSheetResource.cpp b/third_party/WebKit/Source/core/fetch/XSLStyleSheetResource.cpp
index 1aab297..54dcf49 100644
--- a/third_party/WebKit/Source/core/fetch/XSLStyleSheetResource.cpp
+++ b/third_party/WebKit/Source/core/fetch/XSLStyleSheetResource.cpp
@@ -35,20 +35,20 @@
 
 namespace blink {
 
-PassRefPtrWillBeRawPtr<XSLStyleSheetResource> XSLStyleSheetResource::fetchSynchronously(FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<XSLStyleSheetResource> XSLStyleSheetResource::fetchSynchronously(FetchRequest& request, ResourceFetcher* fetcher)
 {
     request.mutableResourceRequest().setTimeoutInterval(10);
     request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextXSLT);
     ResourceLoaderOptions options(request.options());
     options.synchronousPolicy = RequestSynchronously;
     request.setOptions(options);
-    RefPtrWillBeRawPtr<XSLStyleSheetResource> resource = toXSLStyleSheetResource(fetcher->requestResource(request, XSLStyleSheetResourceFactory()));
+    ResourcePtr<XSLStyleSheetResource> resource = toXSLStyleSheetResource(fetcher->requestResource(request, XSLStyleSheetResourceFactory()));
     if (resource && resource->m_data)
         resource->m_sheet = resource->decodedText();
     return resource;
 }
 
-PassRefPtrWillBeRawPtr<XSLStyleSheetResource> XSLStyleSheetResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
+ResourcePtr<XSLStyleSheetResource> XSLStyleSheetResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
 {
     ASSERT(RuntimeEnabledFeatures::xsltEnabled());
     request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextXSLT);
diff --git a/third_party/WebKit/Source/core/fetch/XSLStyleSheetResource.h b/third_party/WebKit/Source/core/fetch/XSLStyleSheetResource.h
index 3368728..f5a2332 100644
--- a/third_party/WebKit/Source/core/fetch/XSLStyleSheetResource.h
+++ b/third_party/WebKit/Source/core/fetch/XSLStyleSheetResource.h
@@ -26,6 +26,7 @@
 #ifndef XSLStyleSheetResource_h
 #define XSLStyleSheetResource_h
 
+#include "core/fetch/ResourcePtr.h"
 #include "core/fetch/StyleSheetResource.h"
 
 namespace blink {
@@ -35,8 +36,8 @@ class ResourceFetcher;
 
 class XSLStyleSheetResource final : public StyleSheetResource {
 public:
-    static PassRefPtrWillBeRawPtr<XSLStyleSheetResource> fetchSynchronously(FetchRequest&, ResourceFetcher*);
-    static PassRefPtrWillBeRawPtr<XSLStyleSheetResource> fetch(FetchRequest&, ResourceFetcher*);
+    static ResourcePtr<XSLStyleSheetResource> fetchSynchronously(FetchRequest&, ResourceFetcher*);
+    static ResourcePtr<XSLStyleSheetResource> fetch(FetchRequest&, ResourceFetcher*);
 
     const String& sheet() const { return m_sheet; }
 
@@ -48,9 +49,9 @@ protected:
         XSLStyleSheetResourceFactory()
             : ResourceFactory(Resource::XSLStyleSheet) { }
 
-        PassRefPtrWillBeRawPtr<Resource> create(const ResourceRequest& request, const String& charset) const override
+        Resource* create(const ResourceRequest& request, const String& charset) const override
         {
-            return adoptRefWillBeNoop(new XSLStyleSheetResource(request, charset));
+            return new XSLStyleSheetResource(request, charset);
         }
     };
     XSLStyleSheetResource(const ResourceRequest&, const String& charset);
diff --git a/third_party/WebKit/Source/core/frame/ImageBitmapTest.cpp b/third_party/WebKit/Source/core/frame/ImageBitmapTest.cpp
index b08bba6..0b6aa4a 100644
--- a/third_party/WebKit/Source/core/frame/ImageBitmapTest.cpp
+++ b/third_party/WebKit/Source/core/frame/ImageBitmapTest.cpp
@@ -36,6 +36,7 @@
 #include "core/fetch/ImageResource.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/MockImageResourceClient.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
@@ -81,8 +82,7 @@ protected:
 TEST_F(ImageBitmapTest, ImageResourceConsistency)
 {
     RefPtrWillBeRawPtr<HTMLImageElement> imageElement = HTMLImageElement::create(*Document::create().get());
-    RefPtrWillBeRawPtr<ImageResource> image = ImageResource::create(StaticBitmapImage::create(m_image).get());
-    imageElement->setImageResource(image.get());
+    imageElement->setImageResource(new ImageResource(StaticBitmapImage::create(m_image).get()));
 
     RefPtrWillBeRawPtr<ImageBitmap> imageBitmapNoCrop = ImageBitmap::create(imageElement.get(),
         IntRect(0, 0, m_image->width(), m_image->height()),
@@ -110,22 +110,22 @@ TEST_F(ImageBitmapTest, ImageResourceConsistency)
 TEST_F(ImageBitmapTest, ImageBitmapLiveResourcePriority)
 {
     RefPtrWillBePersistent<HTMLImageElement> imageNoCrop = HTMLImageElement::create(*Document::create().get());
-    RefPtrWillBeRawPtr<ImageResource> cachedImageNoCrop = ImageResource::create(ResourceRequest("http://foo.com/1"),
+    ResourcePtr<ImageResource> cachedImageNoCrop = new ImageResource(ResourceRequest("http://foo.com/1"),
         StaticBitmapImage::create(m_image).get());
     imageNoCrop->setImageResource(cachedImageNoCrop.get());
 
     RefPtrWillBePersistent<HTMLImageElement> imageInteriorCrop = HTMLImageElement::create(*Document::create().get());
-    RefPtrWillBeRawPtr<ImageResource> cachedImageInteriorCrop = ImageResource::create(ResourceRequest("http://foo.com/2"),
+    ResourcePtr<ImageResource> cachedImageInteriorCrop = new ImageResource(ResourceRequest("http://foo.com/2"),
         StaticBitmapImage::create(m_image).get());
     imageInteriorCrop->setImageResource(cachedImageInteriorCrop.get());
 
     RefPtrWillBePersistent<HTMLImageElement> imageExteriorCrop = HTMLImageElement::create(*Document::create().get());
-    RefPtrWillBeRawPtr<ImageResource> cachedImageExteriorCrop = ImageResource::create(ResourceRequest("http://foo.com/3"),
+    ResourcePtr<ImageResource> cachedImageExteriorCrop = new ImageResource(ResourceRequest("http://foo.com/3"),
         StaticBitmapImage::create(m_image).get());
     imageExteriorCrop->setImageResource(cachedImageExteriorCrop.get());
 
     RefPtrWillBePersistent<HTMLImageElement> imageOutsideCrop = HTMLImageElement::create(*Document::create().get());
-    RefPtrWillBeRawPtr<ImageResource> cachedImageOutsideCrop = ImageResource::create(ResourceRequest("http://foo.com/4"),
+    ResourcePtr<ImageResource> cachedImageOutsideCrop = new ImageResource(ResourceRequest("http://foo.com/4"),
         StaticBitmapImage::create(m_image).get());
     imageOutsideCrop->setImageResource(cachedImageOutsideCrop.get());
 
@@ -191,7 +191,7 @@ TEST_F(ImageBitmapTest, ImageBitmapLiveResourcePriority)
 TEST_F(ImageBitmapTest, ImageBitmapSourceChanged)
 {
     RefPtrWillBeRawPtr<HTMLImageElement> image = HTMLImageElement::create(*Document::create().get());
-    RefPtrWillBeRawPtr<ImageResource> originalImageResource = ImageResource::create(
+    ResourcePtr<ImageResource> originalImageResource = new ImageResource(
         StaticBitmapImage::create(m_image).get());
     image->setImageResource(originalImageResource.get());
 
@@ -200,7 +200,7 @@ TEST_F(ImageBitmapTest, ImageBitmapSourceChanged)
         &(image->document()));
     ASSERT_EQ(imageBitmap->bitmapImage()->imageForCurrentFrame(), originalImageResource->image()->imageForCurrentFrame());
 
-    RefPtrWillBeRawPtr<ImageResource> newImageResource = ImageResource::create(
+    ResourcePtr<ImageResource> newImageResource = new ImageResource(
         StaticBitmapImage::create(m_image2).get());
     image->setImageResource(newImageResource.get());
 
diff --git a/third_party/WebKit/Source/core/frame/SubresourceIntegrityTest.cpp b/third_party/WebKit/Source/core/frame/SubresourceIntegrityTest.cpp
index c7c1f87..02d673d 100644
--- a/third_party/WebKit/Source/core/frame/SubresourceIntegrityTest.cpp
+++ b/third_party/WebKit/Source/core/frame/SubresourceIntegrityTest.cpp
@@ -8,6 +8,7 @@
 #include "core/dom/Document.h"
 #include "core/fetch/IntegrityMetadata.h"
 #include "core/fetch/Resource.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/html/HTMLScriptElement.h"
 #include "platform/Crypto.h"
 #include "platform/weborigin/KURL.h"
@@ -159,7 +160,7 @@ protected:
         EXPECT_FALSE(SubresourceIntegrity::CheckSubresourceIntegrity(*scriptElement, script, size, url, *createTestResource(url, requestorUrl, corsStatus).get()));
     }
 
-    PassRefPtrWillBeRawPtr<Resource> createTestResource(const KURL& url, const KURL& allowOriginUrl, CorsStatus corsStatus)
+    ResourcePtr<Resource> createTestResource(const KURL& url, const KURL& allowOriginUrl, CorsStatus corsStatus)
     {
         ResourceResponse response;
         response.setURL(url);
@@ -168,7 +169,7 @@ protected:
             response.setHTTPHeaderField("access-control-allow-origin", SecurityOrigin::create(allowOriginUrl)->toAtomicString());
             response.setHTTPHeaderField("access-control-allow-credentials", "true");
         }
-        RefPtrWillBeRawPtr<Resource> resource = Resource::create(ResourceRequest(response.url()), Resource::Raw);
+        ResourcePtr<Resource> resource = new Resource(ResourceRequest(response.url()), Resource::Raw);
         resource->setResponse(response);
         return resource;
     }
diff --git a/third_party/WebKit/Source/core/html/HTMLImageElement.cpp b/third_party/WebKit/Source/core/html/HTMLImageElement.cpp
index 3c01b67..febee26 100644
--- a/third_party/WebKit/Source/core/html/HTMLImageElement.cpp
+++ b/third_party/WebKit/Source/core/html/HTMLImageElement.cpp
@@ -370,8 +370,8 @@ void HTMLImageElement::attach(const AttachContext& context)
         if (m_isFallbackImage) {
             float deviceScaleFactor = blink::deviceScaleFactor(layoutImage->frame());
             std::pair<Image*, float> brokenImageAndImageScaleFactor = ImageResource::brokenImage(deviceScaleFactor);
-            RefPtrWillBeRawPtr<ImageResource> newImageResource = ImageResource::create(brokenImageAndImageScaleFactor.first);
-            layoutImage->imageResource()->setImageResource(newImageResource.get());
+            ImageResource* newImageResource = new ImageResource(brokenImageAndImageScaleFactor.first);
+            layoutImage->imageResource()->setImageResource(newImageResource);
         }
         if (layoutImageResource->hasImage())
             return;
diff --git a/third_party/WebKit/Source/core/html/imports/HTMLImportLoader.cpp b/third_party/WebKit/Source/core/html/imports/HTMLImportLoader.cpp
index 4cca829..3b3665d 100644
--- a/third_party/WebKit/Source/core/html/imports/HTMLImportLoader.cpp
+++ b/third_party/WebKit/Source/core/html/imports/HTMLImportLoader.cpp
@@ -69,7 +69,7 @@ void HTMLImportLoader::dispose()
     clearResource();
 }
 
-void HTMLImportLoader::startLoading(const PassRefPtrWillBeRawPtr<RawResource>& resource)
+void HTMLImportLoader::startLoading(const ResourcePtr<RawResource>& resource)
 {
     setResource(resource);
 }
diff --git a/third_party/WebKit/Source/core/html/imports/HTMLImportLoader.h b/third_party/WebKit/Source/core/html/imports/HTMLImportLoader.h
index 1351f2d..412f9b1 100644
--- a/third_party/WebKit/Source/core/html/imports/HTMLImportLoader.h
+++ b/third_party/WebKit/Source/core/html/imports/HTMLImportLoader.h
@@ -86,7 +86,7 @@ public:
     bool hasError() const { return m_state == StateError; }
     bool shouldBlockScriptExecution() const;
 
-    void startLoading(const PassRefPtrWillBeRawPtr<RawResource>&);
+    void startLoading(const ResourcePtr<RawResource>&);
 
     // Tells the loader that all of the import's stylesheets finished
     // loading.
diff --git a/third_party/WebKit/Source/core/html/imports/HTMLImportsController.cpp b/third_party/WebKit/Source/core/html/imports/HTMLImportsController.cpp
index ade5d0e..733d5f1 100644
--- a/third_party/WebKit/Source/core/html/imports/HTMLImportsController.cpp
+++ b/third_party/WebKit/Source/core/html/imports/HTMLImportsController.cpp
@@ -125,7 +125,7 @@ HTMLImportChild* HTMLImportsController::load(HTMLImport* parent, HTMLImportChild
     }
 
     request.setCrossOriginAccessControl(master()->securityOrigin(), CrossOriginAttributeAnonymous);
-    RefPtrWillBeRawPtr<RawResource> resource = RawResource::fetchImport(request, parent->document()->fetcher());
+    ResourcePtr<RawResource> resource = RawResource::fetchImport(request, parent->document()->fetcher());
     if (!resource)
         return nullptr;
 
diff --git a/third_party/WebKit/Source/core/html/parser/HTMLScriptRunner.cpp b/third_party/WebKit/Source/core/html/parser/HTMLScriptRunner.cpp
index 931506a..92af5b6 100644
--- a/third_party/WebKit/Source/core/html/parser/HTMLScriptRunner.cpp
+++ b/third_party/WebKit/Source/core/html/parser/HTMLScriptRunner.cpp
@@ -387,7 +387,7 @@ bool HTMLScriptRunner::requestPendingScript(PendingScript* pendingScript, Elemen
     ASSERT(!pendingScript->element());
     pendingScript->setElement(script);
     // This should correctly return 0 for empty or invalid srcValues.
-    ScriptResource* resource = toScriptLoaderIfPossible(script)->resource();
+    ScriptResource* resource = toScriptLoaderIfPossible(script)->resource().get();
     if (!resource) {
         notImplemented(); // Dispatch error event.
         return false;
diff --git a/third_party/WebKit/Source/core/inspector/InspectorInstrumentation.cpp b/third_party/WebKit/Source/core/inspector/InspectorInstrumentation.cpp
index 0e6f1cd..dec7526 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorInstrumentation.cpp
+++ b/third_party/WebKit/Source/core/inspector/InspectorInstrumentation.cpp
@@ -111,12 +111,12 @@ void continueWithPolicyIgnoreImpl(LocalFrame* frame, DocumentLoader* loader, uns
     didReceiveResourceResponseButCanceledImpl(frame, loader, identifier, r);
 }
 
-void removedResourceFromMemoryCacheImpl(Resource* cachedResource)
+void willDestroyResourceImpl(Resource* cachedResource)
 {
     ASSERT(isMainThread());
     for (InstrumentingAgents* instrumentingAgents: instrumentingAgentsSet()) {
         if (InspectorResourceAgent* inspectorResourceAgent = instrumentingAgents->inspectorResourceAgent())
-            inspectorResourceAgent->removedResourceFromMemoryCache(cachedResource);
+            inspectorResourceAgent->willDestroyResource(cachedResource);
     }
 }
 
diff --git a/third_party/WebKit/Source/core/inspector/InspectorInstrumentation.idl b/third_party/WebKit/Source/core/inspector/InspectorInstrumentation.idl
index f6b2497..1bafa9d 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorInstrumentation.idl
+++ b/third_party/WebKit/Source/core/inspector/InspectorInstrumentation.idl
@@ -327,7 +327,7 @@ interface InspectorInstrumentation {
     void didRunJavaScriptDialog(const InspectorInstrumentationCookie&, bool result);
 
     [Inline=Forward]
-    void removedResourceFromMemoryCache(Resource* cachedResource);
+    void willDestroyResource(Resource* cachedResource);
 
     [AsyncCallTracker, DOMDebugger]
     void didRequestAnimationFrame([Keep] ExecutionContext*, int callbackId);
diff --git a/third_party/WebKit/Source/core/inspector/InspectorPageAgent.cpp b/third_party/WebKit/Source/core/inspector/InspectorPageAgent.cpp
index 0fef05e..dff07c5 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorPageAgent.cpp
+++ b/third_party/WebKit/Source/core/inspector/InspectorPageAgent.cpp
@@ -125,7 +125,7 @@ static bool decodeBuffer(const char* buffer, unsigned size, const String& textEn
 static bool prepareResourceBuffer(Resource* cachedResource, bool* hasZeroSize)
 {
     *hasZeroSize = false;
-    if (!cachedResource)
+    if (!cachedResource || cachedResource->wasPurged())
         return false;
 
     if (cachedResource->dataBufferingPolicy() == DoNotBufferData)
diff --git a/third_party/WebKit/Source/core/inspector/InspectorResourceAgent.cpp b/third_party/WebKit/Source/core/inspector/InspectorResourceAgent.cpp
index d873050..732cf7f 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorResourceAgent.cpp
+++ b/third_party/WebKit/Source/core/inspector/InspectorResourceAgent.cpp
@@ -550,12 +550,7 @@ void InspectorResourceAgent::didReceiveResourceResponse(LocalFrame* frame, unsig
     if (type == InspectorPageAgent::DocumentResource && loader && loader->substituteData().isValid())
         return;
 
-    // It's only safe to reference a Resource in m_resourcesData if it's in the
-    // cache at this point. Resources are added to NetworkResourcesData here
-    // and removed in removedResourceFromMemoryCache(), so if the Resource isn't
-    // in the cache here, NetworkResourceData's strong reference to the
-    // Resource will keep it alive indefinitely.
-    if (cachedResource && memoryCache()->contains(cachedResource))
+    if (cachedResource)
         m_resourcesData->addResource(requestId, cachedResource);
     String frameId = IdentifiersFactory::frameId(frame);
     String loaderId = loader ? IdentifiersFactory::loaderId(loader) : "";
@@ -739,13 +734,13 @@ void InspectorResourceAgent::didFinishEventSourceRequest(ThreadableLoaderClient*
     m_pendingRequest = nullptr;
 }
 
-void InspectorResourceAgent::removedResourceFromMemoryCache(Resource* cachedResource)
+void InspectorResourceAgent::willDestroyResource(Resource* cachedResource)
 {
     String content;
     bool base64Encoded;
     bool hasContent = InspectorPageAgent::cachedResourceContent(cachedResource, &content, &base64Encoded);
     Vector<String> requestIds = m_resourcesData->removeResource(cachedResource);
-    if (hasContent && !isErrorStatusCode(cachedResource->response().httpStatusCode())) {
+    if (hasContent) {
         for (auto& request : requestIds)
             m_resourcesData->setResourceContent(request, content, base64Encoded);
     }
diff --git a/third_party/WebKit/Source/core/inspector/InspectorResourceAgent.h b/third_party/WebKit/Source/core/inspector/InspectorResourceAgent.h
index fa06e2e..d266102 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorResourceAgent.h
+++ b/third_party/WebKit/Source/core/inspector/InspectorResourceAgent.h
@@ -109,7 +109,7 @@ public:
     void willDispachEventSourceEvent(ThreadableLoaderClient*, const AtomicString& eventName, const AtomicString& eventId, const Vector<UChar>& data);
     void didFinishEventSourceRequest(ThreadableLoaderClient*);
 
-    void removedResourceFromMemoryCache(Resource*);
+    void willDestroyResource(Resource*);
 
     void applyUserAgentOverride(String* userAgent);
 
diff --git a/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.cpp b/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.cpp
index b428c73..49fff9b 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.cpp
+++ b/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.cpp
@@ -12,6 +12,7 @@
 #include "core/fetch/RawResource.h"
 #include "core/fetch/Resource.h"
 #include "core/fetch/ResourceFetcher.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/fetch/StyleSheetResourceClient.h"
 #include "core/frame/LocalFrame.h"
 #include "core/inspector/InspectedFrames.h"
@@ -113,7 +114,7 @@ void InspectorResourceContentLoader::start()
         if (!resourceRequest.url().string().isEmpty()) {
             urlsToFetch.add(resourceRequest.url().string());
             FetchRequest request(resourceRequest, FetchInitiatorTypeNames::internal);
-            RefPtrWillBeRawPtr<Resource> resource = RawResource::fetch(request, document->fetcher());
+            ResourcePtr<Resource> resource = RawResource::fetch(request, document->fetcher());
             if (resource) {
                 // Prevent garbage collection by holding a reference to this resource.
                 m_resources.append(resource.get());
@@ -134,7 +135,7 @@ void InspectorResourceContentLoader::start()
             urlsToFetch.add(url);
             FetchRequest request(ResourceRequest(url), FetchInitiatorTypeNames::internal);
             request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextInternal);
-            RefPtrWillBeRawPtr<Resource> resource = CSSStyleSheetResource::fetch(request, document->fetcher());
+            ResourcePtr<Resource> resource = CSSStyleSheetResource::fetch(request, document->fetcher());
             if (!resource)
                 continue;
             // Prevent garbage collection by holding a reference to this resource.
@@ -167,7 +168,6 @@ DEFINE_TRACE(InspectorResourceContentLoader)
 #if ENABLE(OILPAN)
     visitor->trace(m_inspectedFrame);
     visitor->trace(m_pendingResourceClients);
-    visitor->trace(m_resources);
 #endif
 }
 
diff --git a/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.h b/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.h
index f22b146..ff9ab12 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.h
+++ b/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.h
@@ -6,7 +6,7 @@
 #define InspectorResourceContentLoader_h
 
 #include "core/CoreExport.h"
-#include "core/fetch/Resource.h"
+#include "core/fetch/ResourcePtr.h"
 #include "wtf/Functional.h"
 #include "wtf/HashSet.h"
 #include "wtf/Noncopyable.h"
@@ -47,7 +47,7 @@ private:
     bool m_started;
     RawPtrWillBeMember<LocalFrame> m_inspectedFrame;
     WillBeHeapHashSet<RawPtrWillBeMember<ResourceClient>> m_pendingResourceClients;
-    WillBeHeapVector<RefPtrWillBeMember<Resource>> m_resources;
+    Vector<ResourcePtr<Resource>> m_resources;
 
     friend class ResourceClient;
 };
diff --git a/third_party/WebKit/Source/core/inspector/NetworkResourcesData.cpp b/third_party/WebKit/Source/core/inspector/NetworkResourcesData.cpp
index cce304a..22e746d 100644
--- a/third_party/WebKit/Source/core/inspector/NetworkResourcesData.cpp
+++ b/third_party/WebKit/Source/core/inspector/NetworkResourcesData.cpp
@@ -29,7 +29,6 @@
 #include "core/inspector/NetworkResourcesData.h"
 
 #include "core/dom/DOMImplementation.h"
-#include "core/fetch/MemoryCache.h"
 #include "core/fetch/Resource.h"
 #include "platform/SharedBuffer.h"
 #include "platform/network/ResourceResponse.h"
@@ -273,7 +272,6 @@ void NetworkResourcesData::maybeDecodeDataToContent(const String& requestId)
 
 void NetworkResourcesData::addResource(const String& requestId, Resource* cachedResource)
 {
-    ASSERT(memoryCache()->contains(cachedResource));
     ResourceData* resourceData = resourceDataForRequestId(requestId);
     if (!resourceData)
         return;
diff --git a/third_party/WebKit/Source/core/inspector/NetworkResourcesData.h b/third_party/WebKit/Source/core/inspector/NetworkResourcesData.h
index c4ee8b4..3f2a4fb 100644
--- a/third_party/WebKit/Source/core/inspector/NetworkResourcesData.h
+++ b/third_party/WebKit/Source/core/inspector/NetworkResourcesData.h
@@ -124,7 +124,7 @@ public:
         PassRefPtr<SharedBuffer> buffer() const { return m_buffer; }
         void setBuffer(PassRefPtr<SharedBuffer> buffer) { m_buffer = buffer; }
 
-        Resource* cachedResource() const { return m_cachedResource.get(); }
+        Resource* cachedResource() const { return m_cachedResource; }
         void setResource(Resource* cachedResource) { m_cachedResource = cachedResource; }
 
         XHRReplayData* xhrReplayData() const { return m_xhrReplayData.get(); }
@@ -157,7 +157,7 @@ public:
         OwnPtr<TextResourceDecoder> m_decoder;
 
         RefPtr<SharedBuffer> m_buffer;
-        RefPtrWillBeMember<Resource> m_cachedResource;
+        RawPtrWillBeMember<Resource> m_cachedResource;
         RefPtr<BlobDataHandle> m_downloadedFileBlob;
     };
 
diff --git a/third_party/WebKit/Source/core/layout/LayoutImageResource.h b/third_party/WebKit/Source/core/layout/LayoutImageResource.h
index 9680c5a..a83178b 100644
--- a/third_party/WebKit/Source/core/layout/LayoutImageResource.h
+++ b/third_party/WebKit/Source/core/layout/LayoutImageResource.h
@@ -27,6 +27,7 @@
 #define LayoutImageResource_h
 
 #include "core/fetch/ImageResource.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/style/StyleImage.h"
 
 namespace blink {
@@ -63,12 +64,12 @@ public:
 
     virtual WrappedImagePtr imagePtr() const { return m_cachedImage.get(); }
 
-    DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_cachedImage); }
+    DEFINE_INLINE_VIRTUAL_TRACE() { }
 
 protected:
     LayoutImageResource();
     LayoutObject* m_layoutObject;
-    RefPtrWillBeMember<ImageResource> m_cachedImage;
+    ResourcePtr<ImageResource> m_cachedImage;
 };
 
 } // namespace blink
diff --git a/third_party/WebKit/Source/core/layout/LayoutImageResourceStyleImage.cpp b/third_party/WebKit/Source/core/layout/LayoutImageResourceStyleImage.cpp
index be7e3e0..36add16 100644
--- a/third_party/WebKit/Source/core/layout/LayoutImageResourceStyleImage.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutImageResourceStyleImage.cpp
@@ -41,7 +41,6 @@ LayoutImageResourceStyleImage::LayoutImageResourceStyleImage(StyleImage* styleIm
 
 LayoutImageResourceStyleImage::~LayoutImageResourceStyleImage()
 {
-    ASSERT(!m_cachedImage);
 }
 
 void LayoutImageResourceStyleImage::initialize(LayoutObject* layoutObject)
@@ -58,7 +57,7 @@ void LayoutImageResourceStyleImage::shutdown()
 {
     ASSERT(m_layoutObject);
     m_styleImage->removeClient(m_layoutObject);
-    m_cachedImage = nullptr;
+    m_cachedImage = 0;
 }
 
 PassRefPtr<Image> LayoutImageResourceStyleImage::image(const IntSize& size, float zoom) const
diff --git a/third_party/WebKit/Source/core/loader/DocumentLoader.cpp b/third_party/WebKit/Source/core/loader/DocumentLoader.cpp
index ab016f4..29ba34b 100644
--- a/third_party/WebKit/Source/core/loader/DocumentLoader.cpp
+++ b/third_party/WebKit/Source/core/loader/DocumentLoader.cpp
@@ -123,7 +123,7 @@ DEFINE_TRACE(DocumentLoader)
 {
     visitor->trace(m_frame);
     visitor->trace(m_fetcher);
-    visitor->trace(m_mainResource);
+    // TODO(sof): start tracing ResourcePtr<>s (and m_mainResource.)
     visitor->trace(m_writer);
     visitor->trace(m_documentLoadTiming);
     visitor->trace(m_applicationCacheHost);
@@ -157,9 +157,9 @@ const KURL& DocumentLoader::url() const
     return m_request.url();
 }
 
-Resource* DocumentLoader::startPreload(Resource::Type type, FetchRequest& request)
+ResourcePtr<Resource> DocumentLoader::startPreload(Resource::Type type, FetchRequest& request)
 {
-    RefPtrWillBeRawPtr<Resource> resource = nullptr;
+    ResourcePtr<Resource> resource;
     switch (type) {
     case Resource::Image:
         resource = ImageResource::fetch(request, fetcher());
@@ -193,7 +193,7 @@ Resource* DocumentLoader::startPreload(Resource::Type type, FetchRequest& reques
 
     if (resource)
         fetcher()->preloadStarted(resource.get());
-    return resource.get();
+    return resource;
 }
 
 void DocumentLoader::didChangePerformanceTiming()
diff --git a/third_party/WebKit/Source/core/loader/DocumentLoader.h b/third_party/WebKit/Source/core/loader/DocumentLoader.h
index f13f8d9..7d1f482 100644
--- a/third_party/WebKit/Source/core/loader/DocumentLoader.h
+++ b/third_party/WebKit/Source/core/loader/DocumentLoader.h
@@ -35,6 +35,7 @@
 #include "core/fetch/ClientHintsPreferences.h"
 #include "core/fetch/RawResource.h"
 #include "core/fetch/ResourceLoaderOptions.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/fetch/SubstituteData.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/loader/DocumentLoadTiming.h"
@@ -143,7 +144,7 @@ public:
 
     bool loadingMultipartContent() const;
 
-    Resource* startPreload(Resource::Type, FetchRequest&);
+    ResourcePtr<Resource> startPreload(Resource::Type, FetchRequest&);
 
     DECLARE_VIRTUAL_TRACE();
 
@@ -188,7 +189,7 @@ private:
     RawPtrWillBeMember<LocalFrame> m_frame;
     PersistentWillBeMember<ResourceFetcher> m_fetcher;
 
-    RefPtrWillBeMember<RawResource> m_mainResource;
+    ResourcePtr<RawResource> m_mainResource;
 
     RefPtrWillBeMember<DocumentWriter> m_writer;
 
diff --git a/third_party/WebKit/Source/core/loader/DocumentThreadableLoader.cpp b/third_party/WebKit/Source/core/loader/DocumentThreadableLoader.cpp
index f6afbf0..a225253 100644
--- a/third_party/WebKit/Source/core/loader/DocumentThreadableLoader.cpp
+++ b/third_party/WebKit/Source/core/loader/DocumentThreadableLoader.cpp
@@ -818,7 +818,7 @@ void DocumentThreadableLoader::loadRequest(const ResourceRequest& request, Resou
     FetchRequest fetchRequest(request, m_options.initiator, resourceLoaderOptions);
     if (m_options.crossOriginRequestPolicy == AllowCrossOriginRequests)
         fetchRequest.setOriginRestriction(FetchRequest::NoOriginRestriction);
-    RefPtrWillBeRawPtr<Resource> resource = RawResource::fetchSynchronously(fetchRequest, document().fetcher());
+    ResourcePtr<Resource> resource = RawResource::fetchSynchronously(fetchRequest, document().fetcher());
     ResourceResponse response = resource ? resource->response() : ResourceResponse();
     unsigned long identifier = resource ? resource->identifier() : std::numeric_limits<unsigned long>::max();
     ResourceError error = resource ? resource->resourceError() : ResourceError();
diff --git a/third_party/WebKit/Source/core/loader/DocumentThreadableLoader.h b/third_party/WebKit/Source/core/loader/DocumentThreadableLoader.h
index b46bc61..7907c2e 100644
--- a/third_party/WebKit/Source/core/loader/DocumentThreadableLoader.h
+++ b/third_party/WebKit/Source/core/loader/DocumentThreadableLoader.h
@@ -153,20 +153,22 @@ class CORE_EXPORT DocumentThreadableLoader final : public ThreadableLoader, priv
         // this re-implementation of ResourceOwner.
         RawResource* resource() const { return m_resource.get(); }
         void clearResource() { setResource(nullptr); }
-        void setResource(const PassRefPtrWillBeRawPtr<RawResource>& newResource)
+        void setResource(const ResourcePtr<RawResource>& newResource)
         {
             if (newResource == m_resource)
                 return;
 
-            if (PassRefPtrWillBeRawPtr<RawResource> oldResource = m_resource.release())
+            if (ResourcePtr<RawResource> oldResource = m_resource) {
+                m_resource.clear();
                 oldResource->removeClient(this);
+            }
 
             if (newResource) {
                 m_resource = newResource;
                 m_resource->addClient(this);
             }
         }
-        RefPtrWillBePersistent<RawResource> m_resource;
+        ResourcePtr<RawResource> m_resource;
         // End of ResourceOwner re-implementation, see above.
 
         SecurityOrigin* securityOrigin() const;
diff --git a/third_party/WebKit/Source/core/loader/FrameFetchContextTest.cpp b/third_party/WebKit/Source/core/loader/FrameFetchContextTest.cpp
index 8f51fa4..2dd2c83 100644
--- a/third_party/WebKit/Source/core/loader/FrameFetchContextTest.cpp
+++ b/third_party/WebKit/Source/core/loader/FrameFetchContextTest.cpp
@@ -575,7 +575,7 @@ TEST_F(FrameFetchContextDisplayedCertificateErrorsTest, MemoryCacheCertificateEr
     response.setURL(url);
     response.setSecurityInfo(securityInfo);
     response.setHasMajorCertificateErrors(true);
-    RefPtrWillBeRawPtr<Resource> resource = Resource::create(resourceRequest, Resource::Image);
+    ResourcePtr<Resource> resource = new Resource(resourceRequest, Resource::Image);
     resource->setResponse(response);
     fetchContext->dispatchDidLoadResourceFromMemoryCache(resource.get(), WebURLRequest::FrameTypeNone, WebURLRequest::RequestContextImage);
 }
diff --git a/third_party/WebKit/Source/core/loader/ImageLoader.cpp b/third_party/WebKit/Source/core/loader/ImageLoader.cpp
index 7266759..94ba386 100644
--- a/third_party/WebKit/Source/core/loader/ImageLoader.cpp
+++ b/third_party/WebKit/Source/core/loader/ImageLoader.cpp
@@ -142,6 +142,7 @@ private:
 
 ImageLoader::ImageLoader(Element* element)
     : m_element(element)
+    , m_image(0)
     , m_derefElementTimer(this, &ImageLoader::timerFired)
     , m_hasPendingLoadEvent(false)
     , m_hasPendingErrorEvent(false)
@@ -179,10 +180,8 @@ void ImageLoader::dispose()
         willRemoveClient(*client);
 #endif
 
-    if (m_image) {
+    if (m_image)
         m_image->removeClient(this);
-        m_image = nullptr;
-    }
 
 #if !ENABLE(OILPAN)
     ASSERT(m_hasPendingLoadEvent || !loadEventSender().hasPendingEvents(this));
@@ -212,7 +211,6 @@ void ImageLoader::clearWeakMembers(Visitor* visitor)
 
 DEFINE_TRACE(ImageLoader)
 {
-    visitor->trace(m_image);
     visitor->trace(m_element);
 #if ENABLE(OILPAN)
     visitor->template registerWeakMembers<ImageLoader, &ImageLoader::clearWeakMembers>(this);
@@ -312,7 +310,7 @@ void ImageLoader::doUpdateFromElement(BypassMainWorldBehavior bypassBehavior, Up
 
     AtomicString imageSourceURL = m_element->imageSourceURL();
     KURL url = imageSourceToKURL(imageSourceURL);
-    RefPtrWillBeRawPtr<ImageResource> newImage = nullptr;
+    ResourcePtr<ImageResource> newImage = 0;
     RefPtrWillBeRawPtr<Element> protectElement(m_element.get());
     if (!url.isNull()) {
         // Unlike raw <img>, we block mixed content inside of <picture> or <img srcset>.
@@ -362,7 +360,7 @@ void ImageLoader::doUpdateFromElement(BypassMainWorldBehavior bypassBehavior, Up
         noImageResourceToLoad();
     }
 
-    RefPtrWillBeRawPtr<ImageResource> oldImage = m_image.get();
+    ImageResource* oldImage = m_image.get();
     if (updateBehavior == UpdateSizeChanged && m_element->layoutObject() && m_element->layoutObject()->isImage() && newImage == oldImage) {
         toLayoutImage(m_element->layoutObject())->intrinsicSizeChanged();
     } else {
diff --git a/third_party/WebKit/Source/core/loader/ImageLoader.h b/third_party/WebKit/Source/core/loader/ImageLoader.h
index fd3ca94..ec8c8a9 100644
--- a/third_party/WebKit/Source/core/loader/ImageLoader.h
+++ b/third_party/WebKit/Source/core/loader/ImageLoader.h
@@ -26,6 +26,7 @@
 #include "core/CoreExport.h"
 #include "core/fetch/ImageResource.h"
 #include "core/fetch/ImageResourceClient.h"
+#include "core/fetch/ResourcePtr.h"
 #include "platform/heap/Handle.h"
 #include "wtf/HashSet.h"
 #include "wtf/WeakPtr.h"
@@ -168,7 +169,7 @@ private:
 #endif
 
     RawPtrWillBeMember<Element> m_element;
-    RefPtrWillBeMember<ImageResource> m_image;
+    ResourcePtr<ImageResource> m_image;
     // FIXME: Oilpan: We might be able to remove this Persistent hack when
     // ImageResourceClient is traceable.
     GC_PLUGIN_IGNORE("http://crbug.com/383741")
diff --git a/third_party/WebKit/Source/core/loader/LinkLoader.cpp b/third_party/WebKit/Source/core/loader/LinkLoader.cpp
index 5b4b3a1..339e617 100644
--- a/third_party/WebKit/Source/core/loader/LinkLoader.cpp
+++ b/third_party/WebKit/Source/core/loader/LinkLoader.cpp
@@ -187,35 +187,35 @@ Resource::Type LinkLoader::getTypeFromAsAttribute(const String& as, Document* do
     return Resource::LinkPreload;
 }
 
-void LinkLoader::createLinkPreloadResourceClient(Resource* resource)
+void LinkLoader::createLinkPreloadResourceClient(ResourcePtr<Resource> resource)
 {
     if (!resource)
         return;
     switch (resource->type()) {
     case Resource::Image:
-        m_linkPreloadResourceClient = LinkPreloadImageResourceClient::create(this, toImageResource(resource));
+        m_linkPreloadResourceClient = LinkPreloadImageResourceClient::create(this, toImageResource(resource.get()));
         break;
     case Resource::Script:
-        m_linkPreloadResourceClient = LinkPreloadScriptResourceClient::create(this, toScriptResource(resource));
+        m_linkPreloadResourceClient = LinkPreloadScriptResourceClient::create(this, toScriptResource(resource.get()));
         break;
     case Resource::CSSStyleSheet:
-        m_linkPreloadResourceClient = LinkPreloadStyleResourceClient::create(this, toCSSStyleSheetResource(resource));
+        m_linkPreloadResourceClient = LinkPreloadStyleResourceClient::create(this, toCSSStyleSheetResource(resource.get()));
         break;
     case Resource::Font:
-        m_linkPreloadResourceClient = LinkPreloadFontResourceClient::create(this, toFontResource(resource));
+        m_linkPreloadResourceClient = LinkPreloadFontResourceClient::create(this, toFontResource(resource.get()));
         break;
     case Resource::Media:
     case Resource::TextTrack:
     case Resource::Raw:
     case Resource::LinkPreload:
-        m_linkPreloadResourceClient = LinkPreloadRawResourceClient::create(this, toRawResource(resource));
+        m_linkPreloadResourceClient = LinkPreloadRawResourceClient::create(this, toRawResource(resource.get()));
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
-static Resource* preloadIfNeeded(const LinkRelAttribute& relAttribute, const KURL& href, Document& document, const String& as, LinkCaller caller)
+static ResourcePtr<Resource> preloadIfNeeded(const LinkRelAttribute& relAttribute, const KURL& href, Document& document, const String& as, LinkCaller caller)
 {
     if (!document.loader() || !relAttribute.isLinkPreload())
         return nullptr;
diff --git a/third_party/WebKit/Source/core/loader/LinkLoader.h b/third_party/WebKit/Source/core/loader/LinkLoader.h
index 8ac23b4..a872886 100644
--- a/third_party/WebKit/Source/core/loader/LinkLoader.h
+++ b/third_party/WebKit/Source/core/loader/LinkLoader.h
@@ -85,7 +85,7 @@ private:
 
     void linkLoadTimerFired(Timer<LinkLoader>*);
     void linkLoadingErrorTimerFired(Timer<LinkLoader>*);
-    void createLinkPreloadResourceClient(Resource*);
+    void createLinkPreloadResourceClient(ResourcePtr<Resource>);
 
     RawPtrWillBeMember<LinkLoaderClient> m_client;
 
diff --git a/third_party/WebKit/Source/core/loader/LinkLoaderTest.cpp b/third_party/WebKit/Source/core/loader/LinkLoaderTest.cpp
index e1244a6..aef1938 100644
--- a/third_party/WebKit/Source/core/loader/LinkLoaderTest.cpp
+++ b/third_party/WebKit/Source/core/loader/LinkLoaderTest.cpp
@@ -121,7 +121,7 @@ TEST(LinkLoaderTest, Preload)
             dummyPageHolder->document(),
             NetworkHintsMock());
         ASSERT(dummyPageHolder->document().fetcher());
-        WillBeHeapListHashSet<RefPtrWillBeMember<Resource>>* preloads = dummyPageHolder->document().fetcher()->preloads();
+        WillBeHeapListHashSet<RawPtrWillBeMember<Resource>>* preloads = dummyPageHolder->document().fetcher()->preloads();
         if (testCase.shouldLoad)
             ASSERT_NE(nullptr, preloads);
         if (preloads) {
diff --git a/third_party/WebKit/Source/core/paint/PaintLayerFilterInfo.h b/third_party/WebKit/Source/core/paint/PaintLayerFilterInfo.h
index 07e2021..ebb1824 100644
--- a/third_party/WebKit/Source/core/paint/PaintLayerFilterInfo.h
+++ b/third_party/WebKit/Source/core/paint/PaintLayerFilterInfo.h
@@ -103,7 +103,7 @@ private:
 
     // Same as m_internalSVGReferences, except that the reference belongs to a
     // different document.
-    WillBePersistentHeapVector<RefPtrWillBeMember<DocumentResource>> m_externalSVGReferences;
+    Vector<ResourcePtr<DocumentResource>> m_externalSVGReferences;
 };
 
 } // namespace blink
diff --git a/third_party/WebKit/Source/core/style/StyleFetchedImage.cpp b/third_party/WebKit/Source/core/style/StyleFetchedImage.cpp
index 70d0093..6f69be2 100644
--- a/third_party/WebKit/Source/core/style/StyleFetchedImage.cpp
+++ b/third_party/WebKit/Source/core/style/StyleFetchedImage.cpp
@@ -53,7 +53,6 @@ StyleFetchedImage::~StyleFetchedImage()
 void StyleFetchedImage::dispose()
 {
     m_image->removeClient(this);
-    m_image = nullptr;
 }
 
 WrappedImagePtr StyleFetchedImage::data() const
@@ -145,7 +144,6 @@ bool StyleFetchedImage::knownToBeOpaque(const LayoutObject* layoutObject) const
 
 DEFINE_TRACE(StyleFetchedImage)
 {
-    visitor->trace(m_image);
     visitor->trace(m_document);
     StyleImage::trace(visitor);
 }
diff --git a/third_party/WebKit/Source/core/style/StyleFetchedImage.h b/third_party/WebKit/Source/core/style/StyleFetchedImage.h
index 7150261..9f9fdd4 100644
--- a/third_party/WebKit/Source/core/style/StyleFetchedImage.h
+++ b/third_party/WebKit/Source/core/style/StyleFetchedImage.h
@@ -25,6 +25,7 @@
 #define StyleFetchedImage_h
 
 #include "core/fetch/ImageResourceClient.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/style/StyleImage.h"
 
 namespace blink {
@@ -69,7 +70,7 @@ private:
 
     void dispose();
 
-    RefPtrWillBeMember<ImageResource> m_image;
+    ResourcePtr<ImageResource> m_image;
     RawPtrWillBeMember<Document> m_document;
     const KURL m_url;
 };
diff --git a/third_party/WebKit/Source/core/style/StyleFetchedImageSet.cpp b/third_party/WebKit/Source/core/style/StyleFetchedImageSet.cpp
index c02f13b..bab09b1 100644
--- a/third_party/WebKit/Source/core/style/StyleFetchedImageSet.cpp
+++ b/third_party/WebKit/Source/core/style/StyleFetchedImageSet.cpp
@@ -55,7 +55,6 @@ StyleFetchedImageSet::~StyleFetchedImageSet()
 void StyleFetchedImageSet::dispose()
 {
     m_bestFitImage->removeClient(this);
-    m_bestFitImage = nullptr;
 }
 
 WrappedImagePtr StyleFetchedImageSet::data() const
@@ -141,7 +140,6 @@ bool StyleFetchedImageSet::knownToBeOpaque(const LayoutObject* layoutObject) con
 
 DEFINE_TRACE(StyleFetchedImageSet)
 {
-    visitor->trace(m_bestFitImage);
     visitor->trace(m_imageSetValue);
     StyleImage::trace(visitor);
 }
diff --git a/third_party/WebKit/Source/core/style/StyleFetchedImageSet.h b/third_party/WebKit/Source/core/style/StyleFetchedImageSet.h
index a11d001..640aea5 100644
--- a/third_party/WebKit/Source/core/style/StyleFetchedImageSet.h
+++ b/third_party/WebKit/Source/core/style/StyleFetchedImageSet.h
@@ -27,6 +27,7 @@
 #define StyleFetchedImageSet_h
 
 #include "core/fetch/ImageResourceClient.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/style/StyleImage.h"
 #include "platform/geometry/LayoutSize.h"
 
@@ -82,7 +83,7 @@ private:
 
     String debugName() const override { return "StyleFetchedImageSet"; }
 
-    RefPtrWillBeMember<ImageResource> m_bestFitImage;
+    ResourcePtr<ImageResource> m_bestFitImage;
     float m_imageScaleFactor;
 
     RawPtrWillBeMember<CSSImageSetValue> m_imageSetValue; // Not retained; it owns us.
diff --git a/third_party/WebKit/Source/core/svg/SVGFEImageElement.cpp b/third_party/WebKit/Source/core/svg/SVGFEImageElement.cpp
index 5cfd956..06768c7 100644
--- a/third_party/WebKit/Source/core/svg/SVGFEImageElement.cpp
+++ b/third_party/WebKit/Source/core/svg/SVGFEImageElement.cpp
@@ -47,7 +47,7 @@ SVGFEImageElement::~SVGFEImageElement()
 #if ENABLE(OILPAN)
     if (m_cachedImage) {
         m_cachedImage->removeClient(this);
-        m_cachedImage = nullptr;
+        m_cachedImage = 0;
     }
 #else
     clearResourceReferences();
@@ -57,7 +57,6 @@ SVGFEImageElement::~SVGFEImageElement()
 DEFINE_TRACE(SVGFEImageElement)
 {
     visitor->trace(m_preserveAspectRatio);
-    visitor->trace(m_cachedImage);
     SVGFilterPrimitiveStandardAttributes::trace(visitor);
     SVGURIReference::trace(visitor);
 }
@@ -74,7 +73,7 @@ void SVGFEImageElement::clearResourceReferences()
 {
     if (m_cachedImage) {
         m_cachedImage->removeClient(this);
-        m_cachedImage = nullptr;
+        m_cachedImage = 0;
     }
 
     removeAllOutgoingReferences();
diff --git a/third_party/WebKit/Source/core/svg/SVGFEImageElement.h b/third_party/WebKit/Source/core/svg/SVGFEImageElement.h
index 4df7845..fe54161 100644
--- a/third_party/WebKit/Source/core/svg/SVGFEImageElement.h
+++ b/third_party/WebKit/Source/core/svg/SVGFEImageElement.h
@@ -24,6 +24,7 @@
 #include "core/SVGNames.h"
 #include "core/fetch/ImageResource.h"
 #include "core/fetch/ImageResourceClient.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/svg/SVGAnimatedPreserveAspectRatio.h"
 #include "core/svg/SVGFilterPrimitiveStandardAttributes.h"
 #include "core/svg/SVGURIReference.h"
@@ -66,7 +67,7 @@ private:
 
     RefPtrWillBeMember<SVGAnimatedPreserveAspectRatio> m_preserveAspectRatio;
 
-    RefPtrWillBeMember<ImageResource> m_cachedImage;
+    ResourcePtr<ImageResource> m_cachedImage;
 };
 
 } // namespace blink
diff --git a/third_party/WebKit/Source/core/svg/SVGUseElement.cpp b/third_party/WebKit/Source/core/svg/SVGUseElement.cpp
index f1023a8..453af10 100644
--- a/third_party/WebKit/Source/core/svg/SVGUseElement.cpp
+++ b/third_party/WebKit/Source/core/svg/SVGUseElement.cpp
@@ -66,10 +66,6 @@ inline SVGUseElement::SVGUseElement(Document& document)
     addToPropertyMap(m_y);
     addToPropertyMap(m_width);
     addToPropertyMap(m_height);
-
-#if ENABLE(OILPAN)
-    ThreadState::current()->registerPreFinalizer(this);
-#endif
 }
 
 PassRefPtrWillBeRawPtr<SVGUseElement> SVGUseElement::create(Document& document)
@@ -82,19 +78,14 @@ PassRefPtrWillBeRawPtr<SVGUseElement> SVGUseElement::create(Document& document)
 
 SVGUseElement::~SVGUseElement()
 {
+    setDocumentResource(0);
 #if !ENABLE(OILPAN)
     clearShadowTree();
     cancelShadowTreeRecreation();
     svgUseLoadEventSender().cancelEvent(this);
-    dispose();
 #endif
 }
 
-void SVGUseElement::dispose()
-{
-    setDocumentResource(nullptr);
-}
-
 DEFINE_TRACE(SVGUseElement)
 {
     visitor->trace(m_x);
@@ -102,7 +93,6 @@ DEFINE_TRACE(SVGUseElement)
     visitor->trace(m_width);
     visitor->trace(m_height);
     visitor->trace(m_targetElementInstance);
-    visitor->trace(m_resource);
     SVGGraphicsElement::trace(visitor);
     SVGURIReference::trace(visitor);
 }
@@ -242,7 +232,7 @@ void SVGUseElement::svgAttributeChanged(const QualifiedName& attrName)
                 setDocumentResource(DocumentResource::fetchSVGDocument(request, document().fetcher()));
             }
         } else {
-            setDocumentResource(nullptr);
+            setDocumentResource(0);
         }
 
         invalidateShadowTree();
@@ -818,7 +808,7 @@ bool SVGUseElement::instanceTreeIsLoading(const SVGElement* targetInstance)
     return false;
 }
 
-void SVGUseElement::setDocumentResource(PassRefPtrWillBeRawPtr<DocumentResource> resource)
+void SVGUseElement::setDocumentResource(ResourcePtr<DocumentResource> resource)
 {
     if (m_resource == resource)
         return;
diff --git a/third_party/WebKit/Source/core/svg/SVGUseElement.h b/third_party/WebKit/Source/core/svg/SVGUseElement.h
index 0dacc19..cb7702f 100644
--- a/third_party/WebKit/Source/core/svg/SVGUseElement.h
+++ b/third_party/WebKit/Source/core/svg/SVGUseElement.h
@@ -39,7 +39,6 @@ class SVGUseElement final : public SVGGraphicsElement,
 
     DEFINE_WRAPPERTYPEINFO();
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(SVGUseElement);
-    WILL_BE_USING_PRE_FINALIZER(SVGUseElement, dispose);
 public:
     static PassRefPtrWillBeRawPtr<SVGUseElement> create(Document&);
     ~SVGUseElement() override;
@@ -65,8 +64,6 @@ public:
 private:
     explicit SVGUseElement(Document&);
 
-    void dispose();
-
     FloatRect getBBox() override;
 
     bool isPresentationAttribute(const QualifiedName&) const override;
@@ -107,7 +104,7 @@ private:
     void notifyFinished(Resource*) override;
     String debugName() const override { return "SVGUseElement"; }
     TreeScope* referencedScope() const;
-    void setDocumentResource(PassRefPtrWillBeRawPtr<DocumentResource>);
+    void setDocumentResource(ResourcePtr<DocumentResource>);
 
     RefPtrWillBeMember<SVGAnimatedLength> m_x;
     RefPtrWillBeMember<SVGAnimatedLength> m_y;
@@ -117,7 +114,7 @@ private:
     bool m_haveFiredLoadEvent;
     bool m_needsShadowTreeRecreation;
     RefPtrWillBeMember<SVGElement> m_targetElementInstance;
-    RefPtrWillBeMember<DocumentResource> m_resource;
+    ResourcePtr<DocumentResource> m_resource;
 };
 
 } // namespace blink
diff --git a/third_party/WebKit/Source/core/xml/XSLImportRule.cpp b/third_party/WebKit/Source/core/xml/XSLImportRule.cpp
index f3e47ea..b45755f 100644
--- a/third_party/WebKit/Source/core/xml/XSLImportRule.cpp
+++ b/third_party/WebKit/Source/core/xml/XSLImportRule.cpp
@@ -100,7 +100,7 @@ void XSLImportRule::loadSheet()
     ResourceLoaderOptions fetchOptions(ResourceFetcher::defaultResourceOptions());
     FetchRequest request(ResourceRequest(ownerDocument->completeURL(absHref)), FetchInitiatorTypeNames::xml, fetchOptions);
     request.setOriginRestriction(FetchRequest::RestrictToSameOrigin);
-    RefPtrWillBeRawPtr<XSLStyleSheetResource> resource = XSLStyleSheetResource::fetchSynchronously(request, ownerDocument->fetcher());
+    ResourcePtr<XSLStyleSheetResource> resource = XSLStyleSheetResource::fetchSynchronously(request, ownerDocument->fetcher());
     if (!resource || !resource->sheet())
         return;
 
diff --git a/third_party/WebKit/Source/core/xml/XSLImportRule.h b/third_party/WebKit/Source/core/xml/XSLImportRule.h
index c023f78..e9f70fe 100644
--- a/third_party/WebKit/Source/core/xml/XSLImportRule.h
+++ b/third_party/WebKit/Source/core/xml/XSLImportRule.h
@@ -23,6 +23,7 @@
 #ifndef XSLImportRule_h
 #define XSLImportRule_h
 
+#include "core/fetch/ResourcePtr.h"
 #include "core/xml/XSLStyleSheet.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "wtf/PassOwnPtr.h"
diff --git a/third_party/WebKit/Source/core/xml/XSLTProcessorLibxslt.cpp b/third_party/WebKit/Source/core/xml/XSLTProcessorLibxslt.cpp
index 62f3115..c973b57 100644
--- a/third_party/WebKit/Source/core/xml/XSLTProcessorLibxslt.cpp
+++ b/third_party/WebKit/Source/core/xml/XSLTProcessorLibxslt.cpp
@@ -103,7 +103,7 @@ static xmlDocPtr docLoaderFunc(
         ResourceLoaderOptions fetchOptions(ResourceFetcher::defaultResourceOptions());
         FetchRequest request(ResourceRequest(url), FetchInitiatorTypeNames::xml, fetchOptions);
         request.setOriginRestriction(FetchRequest::RestrictToSameOrigin);
-        RefPtrWillBeRawPtr<Resource> resource = RawResource::fetchSynchronously(request, globalResourceFetcher);
+        ResourcePtr<Resource> resource = RawResource::fetchSynchronously(request, globalResourceFetcher);
         if (!resource || !globalProcessor)
             return nullptr;
 
diff --git a/third_party/WebKit/Source/core/xml/parser/XMLDocumentParser.cpp b/third_party/WebKit/Source/core/xml/parser/XMLDocumentParser.cpp
index 84c25a9..49193da 100644
--- a/third_party/WebKit/Source/core/xml/parser/XMLDocumentParser.cpp
+++ b/third_party/WebKit/Source/core/xml/parser/XMLDocumentParser.cpp
@@ -416,10 +416,6 @@ bool XMLDocumentParser::updateLeafTextNode()
 
 void XMLDocumentParser::detach()
 {
-    if (m_pendingScript) {
-        m_pendingScript->removeClient(this);
-        m_pendingScript = nullptr;
-    }
     clearCurrentNodeStack();
     ScriptableDocumentParser::detach();
 }
@@ -490,7 +486,7 @@ void XMLDocumentParser::notifyFinished(Resource* unusedResource)
     bool wasCanceled = m_pendingScript->wasCanceled();
 
     m_pendingScript->removeClient(this);
-    m_pendingScript = nullptr;
+    m_pendingScript = 0;
 
     RefPtrWillBeRawPtr<Element> e = m_scriptElement;
     m_scriptElement = nullptr;
@@ -677,7 +673,7 @@ static void* openFunc(const char* uri)
         XMLDocumentParserScope scope(0);
         // FIXME: We should restore the original global error handler as well.
         FetchRequest request(ResourceRequest(url), FetchInitiatorTypeNames::xml, ResourceFetcher::defaultResourceOptions());
-        RefPtrWillBeRawPtr<Resource> resource = RawResource::fetchSynchronously(request, document->fetcher());
+        ResourcePtr<Resource> resource = RawResource::fetchSynchronously(request, document->fetcher());
         if (resource && !resource->errorOccurred()) {
             data = resource->resourceBuffer();
             finalURL = resource->response().url();
@@ -806,6 +802,7 @@ XMLDocumentParser::XMLDocumentParser(Document& document, FrameView* frameView)
     , m_requestingScript(false)
     , m_finishCalled(false)
     , m_xmlErrors(&document)
+    , m_pendingScript(0)
     , m_scriptStartPosition(TextPosition::belowRangePosition())
     , m_parsingFragment(false)
 {
@@ -829,6 +826,7 @@ XMLDocumentParser::XMLDocumentParser(DocumentFragment* fragment, Element* parent
     , m_requestingScript(false)
     , m_finishCalled(false)
     , m_xmlErrors(&fragment->document())
+    , m_pendingScript(0)
     , m_scriptStartPosition(TextPosition::belowRangePosition())
     , m_parsingFragment(true)
 {
@@ -875,12 +873,15 @@ XMLParserContext::~XMLParserContext()
 
 XMLDocumentParser::~XMLDocumentParser()
 {
-    ASSERT(!m_pendingScript);
 #if !ENABLE(OILPAN)
     // The XMLDocumentParser will always be detached before being destroyed.
     ASSERT(m_currentNodeStack.isEmpty());
     ASSERT(!m_currentNode);
 #endif
+
+    // FIXME: m_pendingScript handling should be moved into XMLDocumentParser.cpp!
+    if (m_pendingScript)
+        m_pendingScript->removeClient(this);
 }
 
 DEFINE_TRACE(XMLDocumentParser)
@@ -891,7 +892,6 @@ DEFINE_TRACE(XMLDocumentParser)
 #endif
     visitor->trace(m_leafTextNode);
     visitor->trace(m_xmlErrors);
-    visitor->trace(m_pendingScript);
     visitor->trace(m_scriptElement);
     ScriptableDocumentParser::trace(visitor);
 }
diff --git a/third_party/WebKit/Source/core/xml/parser/XMLDocumentParser.h b/third_party/WebKit/Source/core/xml/parser/XMLDocumentParser.h
index 8eb344d..b35376b 100644
--- a/third_party/WebKit/Source/core/xml/parser/XMLDocumentParser.h
+++ b/third_party/WebKit/Source/core/xml/parser/XMLDocumentParser.h
@@ -28,6 +28,7 @@
 #include "core/dom/ParserContentPolicy.h"
 #include "core/dom/ScriptableDocumentParser.h"
 #include "core/fetch/ResourceClient.h"
+#include "core/fetch/ResourcePtr.h"
 #include "core/fetch/ScriptResource.h"
 #include "core/xml/parser/XMLErrors.h"
 #include "platform/heap/Handle.h"
@@ -184,7 +185,7 @@ private:
 
     XMLErrors m_xmlErrors;
 
-    RefPtrWillBeMember<ScriptResource> m_pendingScript;
+    ResourcePtr<ScriptResource> m_pendingScript;
     RefPtrWillBeMember<Element> m_scriptElement;
     TextPosition m_scriptStartPosition;
 
diff --git a/third_party/WebKit/Source/web/tests/WebFrameTest.cpp b/third_party/WebKit/Source/web/tests/WebFrameTest.cpp
index 2e165f3..d700a1c 100644
--- a/third_party/WebKit/Source/web/tests/WebFrameTest.cpp
+++ b/third_party/WebKit/Source/web/tests/WebFrameTest.cpp
@@ -6722,7 +6722,7 @@ TEST_P(ParameterizedWebFrameTest, NotifyManifestChange)
     EXPECT_EQ(14, webFrameClient.manifestChangeCount());
 }
 
-static PassRefPtrWillBeRawPtr<Resource> fetchManifest(Document* document, const KURL& url)
+static ResourcePtr<Resource> fetchManifest(Document* document, const KURL& url)
 {
     FetchRequest fetchRequest = FetchRequest(ResourceRequest(url), FetchInitiatorInfo());
     fetchRequest.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextManifest);
@@ -6739,7 +6739,7 @@ TEST_P(ParameterizedWebFrameTest, ManifestFetch)
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html");
     Document* document = toWebLocalFrameImpl(webViewHelper.webViewImpl()->mainFrame())->frame()->document();
 
-    RefPtrWillBeRawPtr<Resource> resource = fetchManifest(document, toKURL(m_baseURL + "link-manifest-fetch.json"));
+    ResourcePtr<Resource> resource = fetchManifest(document, toKURL(m_baseURL + "link-manifest-fetch.json"));
 
     EXPECT_TRUE(resource->isLoaded());
 }
@@ -6753,7 +6753,7 @@ TEST_P(ParameterizedWebFrameTest, ManifestCSPFetchAllow)
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html");
     Document* document = toWebLocalFrameImpl(webViewHelper.webViewImpl()->mainFrame())->frame()->document();
 
-    RefPtrWillBeRawPtr<Resource> resource = fetchManifest(document, toKURL(m_notBaseURL + "link-manifest-fetch.json"));
+    ResourcePtr<Resource> resource = fetchManifest(document, toKURL(m_notBaseURL + "link-manifest-fetch.json"));
 
     EXPECT_TRUE(resource->isLoaded());
 }
@@ -6767,7 +6767,7 @@ TEST_P(ParameterizedWebFrameTest, ManifestCSPFetchSelf)
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html");
     Document* document = toWebLocalFrameImpl(webViewHelper.webViewImpl()->mainFrame())->frame()->document();
 
-    RefPtrWillBeRawPtr<Resource> resource = fetchManifest(document, toKURL(m_notBaseURL + "link-manifest-fetch.json"));
+    ResourcePtr<Resource> resource = fetchManifest(document, toKURL(m_notBaseURL + "link-manifest-fetch.json"));
 
     EXPECT_EQ(0, resource.get()); // Fetching resource wasn't allowed.
 }
@@ -6781,7 +6781,7 @@ TEST_P(ParameterizedWebFrameTest, ManifestCSPFetchSelfReportOnly)
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html");
     Document* document = toWebLocalFrameImpl(webViewHelper.webViewImpl()->mainFrame())->frame()->document();
 
-    RefPtrWillBeRawPtr<Resource> resource = fetchManifest(document, toKURL(m_notBaseURL + "link-manifest-fetch.json"));
+    ResourcePtr<Resource> resource = fetchManifest(document, toKURL(m_notBaseURL + "link-manifest-fetch.json"));
 
     EXPECT_TRUE(resource->isLoaded());
 }
author	picksi <picksi@google.com>	2016-02-03 05:50:23 -0800
committer	Commit bot <commit-bot@chromium.org>	2016-02-03 13:51:22 +0000
commit	783c4ec025ab4ed46d0cf2f8a1acde990928e39d (patch)
tree	4e24e077badc63fb6037cfabd6d1582ca5314b37
parent	36b4e445347aab5b32b5f7fa39b2199ddb85968c (diff)
download	chromium_src-783c4ec025ab4ed46d0cf2f8a1acde990928e39d.zip chromium_src-783c4ec025ab4ed46d0cf2f8a1acde990928e39d.tar.gz chromium_src-783c4ec025ab4ed46d0cf2f8a1acde990928e39d.tar.bz2