webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 174 insertions, 258 deletions

diff --git a/Source/WebCore/loader/cache/CachedImage.cpp b/Source/WebCore/loader/cache/CachedImage.cpp
index 5525fb1f3..65f0bf79c 100644
--- a/Source/WebCore/loader/cache/CachedImage.cpp
+++ b/Source/WebCore/loader/cache/CachedImage.cpp
@@ -35,15 +35,15 @@
 #include "FrameLoaderTypes.h"
 #include "FrameView.h"
 #include "MemoryCache.h"
-#include "Page.h"
 #include "RenderElement.h"
-#include "ResourceBuffer.h"
+#include "SVGImage.h"
 #include "SecurityOrigin.h"
 #include "Settings.h"
+#include "SharedBuffer.h"
 #include "SubresourceLoader.h"
 #include <wtf/CurrentTime.h>
+#include <wtf/NeverDestroyed.h>
 #include <wtf/StdLibExtras.h>
-#include <wtf/Vector.h>
 
 #if PLATFORM(IOS)
 #include "SystemMemory.h"
@@ -53,40 +53,28 @@
 #include "PDFDocumentImage.h"
 #endif
 
-#if ENABLE(SVG)
-#include "SVGImage.h"
-#endif
-
-#if ENABLE(DISK_IMAGE_CACHE)
-#include "DiskImageCacheIOS.h"
-#endif
-
 namespace WebCore {
 
-CachedImage::CachedImage(const ResourceRequest& resourceRequest)
-    : CachedResource(resourceRequest, ImageResource)
-    , m_image(0)
-    , m_shouldPaintBrokenImage(true)
+CachedImage::CachedImage(CachedResourceRequest&& request, SessionID sessionID)
+    : CachedResource(WTFMove(request), ImageResource, sessionID)
 {
     setStatus(Unknown);
 }
 
-CachedImage::CachedImage(Image* image)
-    : CachedResource(ResourceRequest(), ImageResource)
+CachedImage::CachedImage(Image* image, SessionID sessionID)
+    : CachedResource(URL(), ImageResource, sessionID)
     , m_image(image)
-    , m_shouldPaintBrokenImage(true)
 {
-    setStatus(Cached);
-    setLoading(false);
 }
 
-CachedImage::CachedImage(const URL& url, Image* image)
-    : CachedResource(ResourceRequest(url), ImageResource)
+CachedImage::CachedImage(const URL& url, Image* image, SessionID sessionID)
+    : CachedResource(url, ImageResource, sessionID)
     , m_image(image)
-    , m_shouldPaintBrokenImage(true)
+    , m_isManuallyCached(true)
 {
-    setStatus(Cached);
-    setLoading(false);
+    // Use the incoming URL in the response field. This ensures that code using the response directly,
+    // such as origin checks for security, actually see something.
+    m_response.setURL(url);
 }
 
 CachedImage::~CachedImage()
@@ -94,56 +82,69 @@ CachedImage::~CachedImage()
     clearImage();
 }
 
-void CachedImage::load(CachedResourceLoader* cachedResourceLoader, const ResourceLoaderOptions& options)
+void CachedImage::load(CachedResourceLoader& loader)
 {
-    if (!cachedResourceLoader || cachedResourceLoader->autoLoadImages())
-        CachedResource::load(cachedResourceLoader, options);
+    if (loader.shouldPerformImageLoad(url()))
+        CachedResource::load(loader);
     else
         setLoading(false);
 }
 
-void CachedImage::didAddClient(CachedResourceClient* c)
+void CachedImage::setBodyDataFrom(const CachedResource& resource)
+{
+    ASSERT(resource.type() == type());
+    const CachedImage& image = static_cast<const CachedImage&>(resource);
+
+    CachedResource::setBodyDataFrom(resource);
+
+    m_image = image.m_image;
+    m_imageObserver = image.m_imageObserver;
+    if (m_imageObserver)
+        m_imageObserver->add(*this);
+
+    if (m_image && is<SVGImage>(*m_image))
+        m_svgImageCache = std::make_unique<SVGImageCache>(&downcast<SVGImage>(*m_image));
+}
+
+void CachedImage::didAddClient(CachedResourceClient& client)
 {
     if (m_data && !m_image && !errorOccurred()) {
         createImage();
-        m_image->setData(m_data->sharedBuffer(), true);
+        m_image->setData(m_data.copyRef(), true);
     }
-    
-    ASSERT(c->resourceClientType() == CachedImageClient::expectedType());
+
+    ASSERT(client.resourceClientType() == CachedImageClient::expectedType());
     if (m_image && !m_image->isNull())
-        static_cast<CachedImageClient*>(c)->imageChanged(this);
+        static_cast<CachedImageClient&>(client).imageChanged(this);
 
-    CachedResource::didAddClient(c);
+    CachedResource::didAddClient(client);
 }
 
-void CachedImage::didRemoveClient(CachedResourceClient* c)
+void CachedImage::didRemoveClient(CachedResourceClient& client)
 {
-    ASSERT(c);
-    ASSERT(c->resourceClientType() == CachedImageClient::expectedType());
+    ASSERT(client.resourceClientType() == CachedImageClient::expectedType());
+
+    m_pendingContainerSizeRequests.remove(&static_cast<CachedImageClient&>(client));
 
-    m_pendingContainerSizeRequests.remove(static_cast<CachedImageClient*>(c));
-#if ENABLE(SVG)
     if (m_svgImageCache)
-        m_svgImageCache->removeClientFromCache(static_cast<CachedImageClient*>(c));
-#endif
+        m_svgImageCache->removeClientFromCache(&static_cast<CachedImageClient&>(client));
 
-    CachedResource::didRemoveClient(c);
+    CachedResource::didRemoveClient(client);
 }
 
 void CachedImage::switchClientsToRevalidatedResource()
 {
-    ASSERT(resourceToRevalidate());
-    ASSERT(resourceToRevalidate()->isImage());
+    ASSERT(is<CachedImage>(resourceToRevalidate()));
     // Pending container size requests need to be transferred to the revalidated resource.
     if (!m_pendingContainerSizeRequests.isEmpty()) {
         // A copy of pending size requests is needed as they are deleted during CachedResource::switchClientsToRevalidateResouce().
         ContainerSizeRequests switchContainerSizeRequests;
-        for (ContainerSizeRequests::iterator it = m_pendingContainerSizeRequests.begin(); it != m_pendingContainerSizeRequests.end(); ++it)
-            switchContainerSizeRequests.set(it->key, it->value);
+        for (auto& request : m_pendingContainerSizeRequests)
+            switchContainerSizeRequests.set(request.key, request.value);
         CachedResource::switchClientsToRevalidatedResource();
-        CachedImage* revalidatedCachedImage = static_cast<CachedImage*>(resourceToRevalidate());
-        for (ContainerSizeRequests::iterator it = switchContainerSizeRequests.begin(); it != switchContainerSizeRequests.end(); ++it)
-            revalidatedCachedImage->setContainerSizeForRenderer(it->key, it->value.first, it->value.second);
+        CachedImage& revalidatedCachedImage = downcast<CachedImage>(*resourceToRevalidate());
+        for (auto& request : switchContainerSizeRequests)
+            revalidatedCachedImage.setContainerSizeForRenderer(request.key, request.value.first, request.value.second);
         return;
     }
 
@@ -159,12 +160,17 @@ void CachedImage::allClientsRemoved()
 
 std::pair<Image*, float> CachedImage::brokenImage(float deviceScaleFactor) const
 {
+    if (deviceScaleFactor >= 3) {
+        static NeverDestroyed<Image*> brokenImageVeryHiRes(Image::loadPlatformResource("missingImage@3x").leakRef());
+        return std::make_pair(brokenImageVeryHiRes, 3);
+    }
+
     if (deviceScaleFactor >= 2) {
-        DEFINE_STATIC_LOCAL(Image*, brokenImageHiRes, (Image::loadPlatformResource("missingImage@2x").leakRef()));
+        static NeverDestroyed<Image*> brokenImageHiRes(Image::loadPlatformResource("missingImage@2x").leakRef());
         return std::make_pair(brokenImageHiRes, 2);
     }
 
-    DEFINE_STATIC_LOCAL(Image*, brokenImageLoRes, (Image::loadPlatformResource("missingImage").leakRef()));
+    static NeverDestroyed<Image*> brokenImageLoRes(Image::loadPlatformResource("missingImage").leakRef());
     return std::make_pair(brokenImageLoRes, 1);
 }
 
@@ -175,8 +181,6 @@ bool CachedImage::willPaintBrokenImage() const
 
 Image* CachedImage::image()
 {
-    ASSERT(!isPurgeable());
-
     if (errorOccurred() && m_shouldPaintBrokenImage) {
         // Returning the 1x broken image is non-ideal, but we cannot reliably access the appropriate
         // deviceScaleFactor from here. It is critical that callers use CachedImage::brokenImage() 
@@ -192,8 +196,6 @@ Image* CachedImage::image()
 
 Image* CachedImage::imageForRenderer(const RenderObject* renderer)
 {
-    ASSERT(!isPurgeable());
-
     if (errorOccurred() && m_shouldPaintBrokenImage) {
         // Returning the 1x broken image is non-ideal, but we cannot reliably access the appropriate
         // deviceScaleFactor from here. It is critical that callers use CachedImage::brokenImage() 
@@ -204,19 +206,15 @@ Image* CachedImage::imageForRenderer(const RenderObject* renderer)
     if (!m_image)
         return Image::nullImage();
 
-#if ENABLE(SVG)
     if (m_image->isSVGImage()) {
         Image* image = m_svgImageCache->imageForRenderer(renderer);
         if (image != Image::nullImage())
             return image;
     }
-#else
-    UNUSED_PARAM(renderer);
-#endif
     return m_image.get();
 }
 
-void CachedImage::setContainerSizeForRenderer(const CachedImageClient* renderer, const IntSize& containerSize, float containerZoom)
+void CachedImage::setContainerSizeForRenderer(const CachedImageClient* renderer, const LayoutSize& containerSize, float containerZoom)
 {
     if (containerSize.isEmpty())
         return;
@@ -226,17 +224,13 @@ void CachedImage::setContainerSizeForRenderer(const CachedImageClient* renderer,
         m_pendingContainerSizeRequests.set(renderer, SizeAndZoom(containerSize, containerZoom));
         return;
     }
-#if ENABLE(SVG)
+
     if (!m_image->isSVGImage()) {
         m_image->setContainerSize(containerSize);
         return;
     }
 
     m_svgImageCache->setContainerSizeForRenderer(renderer, containerSize, containerZoom);
-#else
-    UNUSED_PARAM(containerZoom);
-    m_image->setContainerSize(containerSize);
-#endif
 }
 
 bool CachedImage::usesImageContainerSize() const
@@ -263,42 +257,19 @@ bool CachedImage::imageHasRelativeHeight() const
     return false;
 }
 
-LayoutSize CachedImage::imageSizeForRenderer(const RenderObject* renderer, float multiplier, SizeType sizeType)
+LayoutSize CachedImage::imageSizeForRenderer(const RenderElement* renderer, float multiplier, SizeType sizeType)
 {
-    ASSERT(!isPurgeable());
-
     if (!m_image)
-        return IntSize();
+        return LayoutSize();
 
-    LayoutSize imageSize(m_image->size());
+    LayoutSize imageSize;
 
-#if ENABLE(CSS_IMAGE_ORIENTATION)
-    if (renderer && m_image->isBitmapImage()) {
-        ImageOrientationDescription orientationDescription(renderer->shouldRespectImageOrientation(), renderer->style().imageOrientation());
-        if (orientationDescription.respectImageOrientation() == RespectImageOrientation)
-            imageSize = toBitmapImage(m_image.get())->sizeRespectingOrientation(orientationDescription);
-    }
-#else
-    if (m_image->isBitmapImage() && (renderer && renderer->shouldRespectImageOrientation() == RespectImageOrientation))
-#if !PLATFORM(IOS)
-        imageSize = toBitmapImage(m_image.get())->sizeRespectingOrientation();
-#else
-    {
-        // On iOS, the image may have been subsampled to accommodate our size restrictions. However
-        // we should tell the renderer what the original size was.
-        imageSize = toBitmapImage(m_image.get())->originalSizeRespectingOrientation();
-    } else if (m_image->isBitmapImage())
-        imageSize = toBitmapImage(m_image.get())->originalSize();
-#endif // !PLATFORM(IOS)
-#endif // ENABLE(CSS_IMAGE_ORIENTATION)
-
-#if ENABLE(SVG)
-    else if (m_image->isSVGImage() && sizeType == UsedSize) {
-        imageSize = m_svgImageCache->imageSizeForRenderer(renderer);
-    }
-#else
-    UNUSED_PARAM(sizeType);
-#endif
+    if (is<BitmapImage>(*m_image) && renderer && renderer->shouldRespectImageOrientation() == RespectImageOrientation)
+        imageSize = LayoutSize(downcast<BitmapImage>(*m_image).sizeRespectingOrientation());
+    else if (is<SVGImage>(*m_image) && sizeType == UsedSize)
+        imageSize = LayoutSize(m_svgImageCache->imageSizeForRenderer(renderer));
+    else
+        imageSize = LayoutSize(m_image->size());
 
     if (multiplier == 1.0f)
         return imageSize;
@@ -331,7 +302,7 @@ void CachedImage::checkShouldPaintBrokenImage()
     if (!m_loader || m_loader->reachedTerminalState())
         return;
 
-    m_shouldPaintBrokenImage = m_loader->frameLoader()->client().shouldPaintBrokenImage(m_resourceRequest.url());
+    m_shouldPaintBrokenImage = m_loader->frameLoader()->client().shouldPaintBrokenImage(url());
 }
 
 void CachedImage::clear()
@@ -347,77 +318,98 @@ inline void CachedImage::createImage()
     // Create the image if it doesn't yet exist.
     if (m_image)
         return;
+
+    m_imageObserver = CachedImageObserver::create(*this);
+
+    if (m_response.mimeType() == "image/svg+xml") {
+        auto svgImage = SVGImage::create(*m_imageObserver, url());
+        m_svgImageCache = std::make_unique<SVGImageCache>(svgImage.ptr());
+        m_image = WTFMove(svgImage);
 #if USE(CG) && !USE(WEBKIT_IMAGE_DECODERS)
-    else if (m_response.mimeType() == "application/pdf")
-        m_image = PDFDocumentImage::create(this);
+    } else if (m_response.mimeType() == "application/pdf") {
+        m_image = PDFDocumentImage::create(m_imageObserver.get());
 #endif
-#if ENABLE(SVG)
-    else if (m_response.mimeType() == "image/svg+xml") {
-        RefPtr<SVGImage> svgImage = SVGImage::create(this);
-        m_svgImageCache = std::make_unique<SVGImageCache>(svgImage.get());
-        m_image = svgImage.release();
-    }
-#endif
-    else
-        m_image = BitmapImage::create(this);
+    } else
+        m_image = BitmapImage::create(m_imageObserver.get());
 
     if (m_image) {
         // Send queued container size requests.
         if (m_image->usesContainerSize()) {
-            for (ContainerSizeRequests::iterator it = m_pendingContainerSizeRequests.begin(); it != m_pendingContainerSizeRequests.end(); ++it)
-                setContainerSizeForRenderer(it->key, it->value.first, it->value.second);
+            for (auto& request : m_pendingContainerSizeRequests)
+                setContainerSizeForRenderer(request.key, request.value.first, request.value.second);
         }
         m_pendingContainerSizeRequests.clear();
     }
 }
 
-inline void CachedImage::clearImage()
+CachedImage::CachedImageObserver::CachedImageObserver(CachedImage& image)
 {
-    // If our Image has an observer, it's always us so we need to clear the back pointer
-    // before dropping our reference.
-    if (m_image)
-        m_image->setImageObserver(0);
-    m_image.clear();
+    m_cachedImages.reserveInitialCapacity(1);
+    m_cachedImages.append(&image);
+    if (auto* loader = image.loader()) {
+        m_allowSubsampling = loader->frameLoader()->frame().settings().imageSubsamplingEnabled();
+        m_allowLargeImageAsyncDecoding = loader->frameLoader()->frame().settings().largeImageAsyncDecodingEnabled();
+        m_allowAnimatedImageAsyncDecoding = loader->frameLoader()->frame().settings().animatedImageAsyncDecodingEnabled();
+        m_showDebugBackground = loader->frameLoader()->frame().settings().showDebugBorders();
+    }
 }
 
-bool CachedImage::canBeDrawn() const
+void CachedImage::CachedImageObserver::decodedSizeChanged(const Image* image, long long delta)
 {
-    if (!m_image || m_image->isNull())
-        return false;
+    for (auto cachedImage : m_cachedImages)
+        cachedImage->decodedSizeChanged(image, delta);
+}
 
-    if (!m_loader || m_loader->reachedTerminalState())
-        return true;
+void CachedImage::CachedImageObserver::didDraw(const Image* image)
+{
+    for (auto cachedImage : m_cachedImages)
+        cachedImage->didDraw(image);
+}
 
-    size_t estimatedDecodedImageSize = m_image->width() * m_image->height() * 4; // no overflow check
-    return estimatedDecodedImageSize <= m_loader->frameLoader()->frame().settings().maximumDecodedImageSize();
+void CachedImage::CachedImageObserver::animationAdvanced(const Image* image)
+{
+    for (auto cachedImage : m_cachedImages)
+        cachedImage->animationAdvanced(image);
 }
 
-void CachedImage::addIncrementalDataBuffer(ResourceBuffer* data)
+void CachedImage::CachedImageObserver::changedInRect(const Image* image, const IntRect* rect)
 {
-    m_data = data;
-    if (!data)
-        return;
+    for (auto cachedImage : m_cachedImages)
+        cachedImage->changedInRect(image, rect);
+}
+
+inline void CachedImage::clearImage()
+{
+    if (m_imageObserver) {
+        m_imageObserver->remove(*this);
+        m_imageObserver = nullptr;
+    }
+    m_image = nullptr;
+}
+
+void CachedImage::addIncrementalDataBuffer(SharedBuffer& data)
+{
+    m_data = &data;
 
     createImage();
 
     // Have the image update its data from its internal buffer.
     // It will not do anything now, but will delay decoding until
     // queried for info (like size or specific image frames).
-    bool sizeAvailable = m_image->setData(m_data->sharedBuffer(), false);
+    bool sizeAvailable = m_image->setData(&data, false);
     if (!sizeAvailable)
         return;
 
-    if (!canBeDrawn()) {
-        // There's no image to draw or its decoded size is bigger than the maximum allowed.
+    if (m_image->isNull()) {
+        // Image decoding failed. Either we need more image data or the image data is malformed.
         error(errorOccurred() ? status() : DecodeError);
         if (inCache())
-            memoryCache()->remove(this);
+            MemoryCache::singleton().remove(*this);
         return;
     }
 
-    // Go ahead and tell our observers to try to draw.
-    // Each chunk from the network causes observers to repaint, which will
-    // force that chunk to decode.
+    // Tell our observers to try to draw.
+    // Each chunk from the network causes observers to repaint, which will force that chunk to decode.
     // It would be nice to only redraw the decoded band of the image, but with the current design
     // (decoding delayed until painting) that seems hard.
     notifyObservers();
@@ -425,32 +417,34 @@ void CachedImage::addIncrementalDataBuffer(ResourceBuffer* data)
     setEncodedSize(m_image->data() ? m_image->data()->size() : 0);
 }
 
-void CachedImage::addDataBuffer(ResourceBuffer* data)
+void CachedImage::addDataBuffer(SharedBuffer& data)
 {
-    ASSERT(m_options.dataBufferingPolicy == BufferData);
+    ASSERT(dataBufferingPolicy() == BufferData);
     addIncrementalDataBuffer(data);
+    CachedResource::addDataBuffer(data);
 }
 
 void CachedImage::addData(const char* data, unsigned length)
 {
-    ASSERT(m_options.dataBufferingPolicy == DoNotBufferData);
-    addIncrementalDataBuffer(ResourceBuffer::create(data, length).get());
+    ASSERT(dataBufferingPolicy() == DoNotBufferData);
+    addIncrementalDataBuffer(SharedBuffer::create(data, length));
+    CachedResource::addData(data, length);
 }
 
-void CachedImage::finishLoading(ResourceBuffer* data)
+void CachedImage::finishLoading(SharedBuffer* data)
 {
     m_data = data;
     if (!m_image && data)
         createImage();
 
     if (m_image)
-        m_image->setData(m_data->sharedBuffer(), true);
+        m_image->setData(data, true);
 
-    if (!canBeDrawn()) {
-        // There's no image to draw or its decoded size is bigger than the maximum allowed.
+    if (!m_image || m_image->isNull()) {
+        // Image decoding failed; the image data is malformed.
         error(errorOccurred() ? status() : DecodeError);
         if (inCache())
-            memoryCache()->remove(this);
+            MemoryCache::singleton().remove(*this);
         return;
     }
 
@@ -460,6 +454,16 @@ void CachedImage::finishLoading(ResourceBuffer* data)
     CachedResource::finishLoading(data);
 }
 
+void CachedImage::didReplaceSharedBufferContents()
+{
+    if (m_image) {
+        // Let the Image know that the SharedBuffer has been rejigged, so it can let go of any references to the heap-allocated resource buffer.
+        // FIXME(rdar://problem/24275617): It would be better if we could somehow tell the Image's decoder to swap in the new contents without destroying anything.
+        m_image->destroyDecodedData(true);
+    }
+    CachedResource::didReplaceSharedBufferContents();
+}
+
 void CachedImage::error(CachedResource::Status status)
 {
     checkShouldPaintBrokenImage();
@@ -478,23 +482,20 @@ void CachedImage::responseReceived(const ResourceResponse& response)
 void CachedImage::destroyDecodedData()
 {
     bool canDeleteImage = !m_image || (m_image->hasOneRef() && m_image->isBitmapImage());
-    if (isSafeToMakePurgeable() && canDeleteImage && !isLoading()) {
-        // Image refs the data buffer so we should not make it purgeable while the image is alive. 
-        // Invoking addClient() will reconstruct the image object.
-        m_image = 0;
+    if (canDeleteImage && !isLoading() && !hasClients()) {
+        m_image = nullptr;
         setDecodedSize(0);
-        if (!MemoryCache::shouldMakeResourcePurgeableOnEviction())
-            makePurgeable(true);
     } else if (m_image && !errorOccurred())
         m_image->destroyDecodedData();
 }
 
-void CachedImage::decodedSizeChanged(const Image* image, int delta)
+void CachedImage::decodedSizeChanged(const Image* image, long long delta)
 {
     if (!image || image != m_image)
         return;
-    
-    setDecodedSize(decodedSize() + delta);
+
+    ASSERT(delta >= 0 || decodedSize() + delta >= 0);
+    setDecodedSize(static_cast<unsigned>(decodedSize() + delta));
 }
 
 void CachedImage::didDraw(const Image* image)
@@ -509,132 +510,47 @@ void CachedImage::didDraw(const Image* image)
     CachedResource::didAccessDecodedData(timeStamp);
 }
 
-bool CachedImage::shouldPauseAnimation(const Image* image)
-{
-    if (!image || image != m_image)
-        return false;
-    
-    CachedResourceClientWalker<CachedImageClient> w(m_clients);
-    while (CachedImageClient* c = w.next()) {
-        if (c->willRenderImage(this))
-            return false;
-    }
-
-    return true;
-}
-
 void CachedImage::animationAdvanced(const Image* image)
 {
     if (!image || image != m_image)
         return;
-    notifyObservers();
+    CachedResourceClientWalker<CachedImageClient> clientWalker(m_clients);
+    while (CachedImageClient* client = clientWalker.next())
+        client->newImageAnimationFrameAvailable(*this);
 }
 
-void CachedImage::changedInRect(const Image* image, const IntRect& rect)
+void CachedImage::changedInRect(const Image* image, const IntRect* rect)
 {
     if (!image || image != m_image)
         return;
-    notifyObservers(&rect);
-}
-
-void CachedImage::resumeAnimatingImagesForLoader(CachedResourceLoader* loader)
-{
-    const CachedResourceLoader::DocumentResourceMap& resources = loader->allCachedResources();
-
-    for (CachedResourceLoader::DocumentResourceMap::const_iterator it = resources.begin(), end = resources.end(); it != end; ++it) {
-        const CachedResourceHandle<CachedResource>& resource = it->value;
-        if (!resource || !resource->isImage())
-            continue;
-        CachedImage* cachedImage = static_cast<CachedImage*>(resource.get());
-        if (!cachedImage->hasImage())
-            continue;
-        Image* image = cachedImage->image();
-        if (!image->isBitmapImage())
-            continue;
-        BitmapImage* bitmapImage = toBitmapImage(image);
-        if (!bitmapImage->canAnimate())
-            continue;
-        cachedImage->animationAdvanced(bitmapImage);
-    }
+    notifyObservers(rect);
 }
 
 bool CachedImage::currentFrameKnownToBeOpaque(const RenderElement* renderer)
 {
     Image* image = imageForRenderer(renderer);
-    if (image->isBitmapImage())
-        image->nativeImageForCurrentFrame(); // force decode
     return image->currentFrameKnownToBeOpaque();
 }
 
-#if ENABLE(DISK_IMAGE_CACHE)
-bool CachedImage::canUseDiskImageCache() const
-{
-    if (isLoading() || errorOccurred())
-        return false;
-
-    if (!m_data)
-        return false;
-
-    if (isPurgeable())
-        return false;
-
-    if (m_data->size() < diskImageCache().minimumImageSize())
-        return false;
-
-    // "Cache-Control: no-store" resources may be marked as such because they may
-    // contain sensitive information. We should not write these resources to disk.
-    if (m_response.cacheControlContainsNoStore())
-        return false;
-
-    // Testing shows that PDF images did not work when memory mapped.
-    // However, SVG images and Bitmap images were fine. See:
-    // <rdar://problem/8591834> Disk Image Cache should support PDF Images
-    if (m_response.mimeType() == "application/pdf")
-        return false;
-
-    return true;
-}
-
-void CachedImage::useDiskImageCache()
+bool CachedImage::isOriginClean(SecurityOrigin* origin)
 {
-    ASSERT(canUseDiskImageCache());
-    ASSERT(!isUsingDiskImageCache());
-    m_data->sharedBuffer()->allowToBeMemoryMapped();
-}
-#endif
-
-bool CachedImage::isOriginClean(SecurityOrigin* securityOrigin)
-{
-    if (!image()->hasSingleSecurityOrigin())
-        return false;
-    if (passesAccessControlCheck(securityOrigin))
-        return true;
-    return !securityOrigin->taintsCanvas(response().url());
+    ASSERT_UNUSED(origin, origin);
+    ASSERT(this->origin());
+    ASSERT(origin->toString() == this->origin()->toString());
+    return !loadFailedOrCanceled() && isCORSSameOrigin();
 }
 
-#if USE(CF)
-// FIXME: We should look to incorporate the functionality of CachedImageManual
-// into CachedImage or find a better place for this class.
-// FIXME: Remove the USE(CF) once we make MemoryCache::addImageToCache() platform-independent.
-CachedImageManual::CachedImageManual(const URL& url, Image* image)
-    : CachedImage(url, image)
-    , m_fakeClient(std::make_unique<CachedImageClient>())
+CachedResource::RevalidationDecision CachedImage::makeRevalidationDecision(CachePolicy cachePolicy) const
 {
-    // Use the incoming URL in the response field. This ensures that code
-    // using the response directly, such as origin checks for security,
-    // actually see something.
-    m_response.setURL(url);
-}
-
-bool CachedImageManual::mustRevalidateDueToCacheHeaders(CachePolicy) const
-{
-    // Do not revalidate manually cached images. This mechanism is used as a
-    // way to efficiently share an image from the client to content and
-    // the URL for that image may not represent a resource that can be
-    // retrieved by standard means. If the manual caching SPI is used, it is
-    // incumbent on the client to only use valid resources.
-    return false;
+    if (UNLIKELY(isManuallyCached())) {
+        // Do not revalidate manually cached images. This mechanism is used as a
+        // way to efficiently share an image from the client to content and
+        // the URL for that image may not represent a resource that can be
+        // retrieved by standard means. If the manual caching SPI is used, it is
+        // incumbent on the client to only use valid resources.
+        return RevalidationDecision::No;
+    }
+    return CachedResource::makeRevalidationDecision(cachePolicy);
 }
-#endif
 
 } // namespace WebCore