Attachment 412070 Details for Bug 217596 – Patch for review

[patch] Patch for review

217596.patch (text/plain), 55.13 KB, created by Said Abou-Hallawa on 2020-10-21 23:33:35 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Said Abou-Hallawa

Created: 2020-10-21 23:33:35 PDT

Size: 55.13 KB

patch

obsolete

>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 9626f1de5716..91ebdefa0683 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,81 @@
>+2020-10-21  Said Abou-Hallawa  <said@apple.com>
>+
>+        [GPU Process] Cache the BitmapImage frame in GPU Process and allow referencing it with its RemoteResourceIdentifier
>+        https://bugs.webkit.org/show_bug.cgi?id=217596
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Only the frames of the BitmapImage will be cached in the GPU side. The
>+        frames of BitmapImage have a well defined life cycle in the Web Process.
>+        The counterpart frames in the GPU Process will have a similar life cycle.
>+        When the frame is drawn for the first time it will be transfered from Web
>+        Process via a ShareableBitmap to the GPU Process and cached under a unique
>+        RemoteResourceIdentifier which will be used to record the NativeDrawImage
>+        item. When the BitmapImage decides to destroy its decoded frame, a message
>+        will be sent from the Web Process to the GPU Process to remove the cached
>+        frame. For the details about the life cycle of the cached NativeImages,
>+        see the WebKit ChangeLog.
>+
>+        * html/ImageBitmap.cpp:
>+        * loader/cache/CachedImage.cpp:
>+        (WebCore::CachedImage::CachedImageObserver::drawNativeImage):
>+        (WebCore::CachedImage::CachedImageObserver::nativeImageWillBeDestroyed):
>+        (WebCore::CachedImage::nativeImageWillBeDestroyed):
>+        * loader/cache/CachedImage.h:
>+        * loader/cache/CachedImageClient.h:
>+        We need the CachedImage to be sent along with the NativeImage to
>+        GraphicsContext::drawNativeImage().
>+
>+        (WebCore::CachedImageClient::nativeImageWillBeDestroyed):
>+        RemoteResourceCacheProxy is a superclass of CachedImageClient. It will be
>+        called for any NativeImage before it is deleted.
>+
>+        * platform/graphics/BitmapImage.cpp:
>+        (WebCore::drawNativeImage):
>+        (WebCore::BitmapImage::draw):
>+        (WebCore::BitmapImage::subsamplingLevelForScaleFactor):
>+        * platform/graphics/GraphicsContext.cpp:
>+        (WebCore::GraphicsContext::drawNativeImage):
>+        (WebCore::GraphicsContext::drawImage):
>+        (WebCore::GraphicsContext::drawTiledImage):
>+        * platform/graphics/GraphicsContext.h:
>+        (WebCore::GraphicsContext::drawNativeImage):
>+        * platform/graphics/GraphicsContextImpl.h:
>+        * platform/graphics/ImageObserver.h:
>+        * platform/graphics/ImageSource.cpp:
>+        (WebCore::ImageSource::destroyDecodedData):
>+        Notify the CachedImageClients before destroying the NativeImage.
>+
>+        * platform/graphics/cairo/GraphicsContextImplCairo.cpp:
>+        (WebCore::GraphicsContextImplCairo::drawNativeImage):
>+        * platform/graphics/cairo/GraphicsContextImplCairo.h:
>+        * platform/graphics/displaylists/DisplayListItems.cpp:
>+        (WebCore::DisplayList::DrawNativeImage::DrawNativeImage):
>+        (WebCore::DisplayList::DrawNativeImage::apply const):
>+        DrawNativeImage can hold a NativeImagePtr or RemoteResourceIdentifier. 
>+        Only the one with the NativeImagePtr will be replayed back here. The one
>+        with RemoteResourceIdentifier (which is RemoteImageBuffer right now) is
>+        responsible for replaying it back.
>+
>+        * platform/graphics/displaylists/DisplayListItems.h:
>+        (WebCore::DisplayList::DrawNativeImage::create):
>+        (WebCore::DisplayList::DrawNativeImage::remoteResourceIdentifier const):
>+        (WebCore::DisplayList::DrawNativeImage::nativeImagePtr const):
>+        (WebCore::DisplayList::DrawNativeImage::imageSize const):
>+        (WebCore::DisplayList::DrawNativeImage::options const):
>+        (WebCore::DisplayList::DrawNativeImage::decode):
>+        Allow DrawNativeImage to hold RemoteResourceIdentifier. In this case, it
>+        will be sent to the GPU process to be replayed back.
>+
>+        * platform/graphics/displaylists/DisplayListRecorder.cpp:
>+        (WebCore::DisplayList::Recorder::drawNativeImage):
>+        * platform/graphics/displaylists/DisplayListRecorder.h:
>+        (WebCore::DisplayList::Recorder::Delegate::lockRemoteNativeImage):
>+        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp:
>+        (Nicosia::CairoOperationRecorder::drawNativeImage):
>+        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h:
>+
>+
> 2020-10-20  Said Abou-Hallawa  <said@apple.com>
> 
>         [GPU Process]: Implement DisplayList::DrawImageBuffer item
>diff --git a/Source/WebCore/html/ImageBitmap.cpp b/Source/WebCore/html/ImageBitmap.cpp
>index ba1298e4f747..129dddd02dee 100644
>--- a/Source/WebCore/html/ImageBitmap.cpp
>+++ b/Source/WebCore/html/ImageBitmap.cpp
>@@ -601,10 +601,17 @@ public:
> 
>     void decodedSizeChanged(const Image&, long long) override { }
> 
>+    void drawNativeImage(const Image&, GraphicsContext& context, const NativeImagePtr& nativeImage, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options) override
>+    {
>+        context.drawNativeImage(nativeImage, imageSize, destRect, srcRect, options);
>+    }
>+
>     void didDraw(const Image&) override { }
> 
>     bool canDestroyDecodedData(const Image&) override { return true; }
>     void imageFrameAvailable(const Image&, ImageAnimatingState, const IntRect* = nullptr, DecodingStatus = DecodingStatus::Invalid) override { }
>+    void nativeImageWillBeDestroyed(const Image&, const NativeImagePtr&) override { }
>+
>     void changedInRect(const Image&, const IntRect* = nullptr) override { }
>     void scheduleRenderingUpdate(const Image&) override { }
> 
>diff --git a/Source/WebCore/loader/cache/CachedImage.cpp b/Source/WebCore/loader/cache/CachedImage.cpp
>index 5cc933832574..fea92925558b 100644
>--- a/Source/WebCore/loader/cache/CachedImage.cpp
>+++ b/Source/WebCore/loader/cache/CachedImage.cpp
>@@ -411,6 +411,17 @@ void CachedImage::CachedImageObserver::decodedSizeChanged(const Image& image, lo
>         cachedImage->decodedSizeChanged(image, delta);
> }
> 
>+void CachedImage::CachedImageObserver::drawNativeImage(const Image& image, GraphicsContext& context, const NativeImagePtr& nativeImage, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+{
>+    for (auto cachedImage : m_cachedImages) {
>+        if (&image != cachedImage->image())
>+            continue;
>+        context.drawNativeImage(nativeImage, imageSize, destRect, srcRect, options, cachedImage);
>+        return;
>+    }
>+    context.drawNativeImage(nativeImage, imageSize, destRect, srcRect, options);
>+}
>+
> void CachedImage::CachedImageObserver::didDraw(const Image& image)
> {
>     for (auto cachedImage : m_cachedImages)
>@@ -434,6 +445,12 @@ void CachedImage::CachedImageObserver::imageFrameAvailable(const Image& image, I
>         cachedImage->imageFrameAvailable(image, animatingState, changeRect, decodingStatus);
> }
> 
>+void CachedImage::CachedImageObserver::nativeImageWillBeDestroyed(const Image& image, const NativeImagePtr& nativeImage)
>+{
>+    for (auto cachedImage : m_cachedImages)
>+        cachedImage->nativeImageWillBeDestroyed(image, nativeImage);
>+}
>+
> void CachedImage::CachedImageObserver::changedInRect(const Image& image, const IntRect* rect)
> {
>     for (auto cachedImage : m_cachedImages)
>@@ -689,6 +706,16 @@ void CachedImage::imageFrameAvailable(const Image& image, ImageAnimatingState an
>         m_clientsWaitingForAsyncDecoding.clear();
> }
> 
>+void CachedImage::nativeImageWillBeDestroyed(const Image& image, const NativeImagePtr& nativeImage)
>+{
>+    if (&image != m_image)
>+        return;
>+
>+    CachedResourceClientWalker<CachedImageClient> clientWalker(m_clients);
>+    while (CachedImageClient* client = clientWalker.next())
>+        client->nativeImageWillBeDestroyed(*this, nativeImage);
>+}
>+
> void CachedImage::changedInRect(const Image& image, const IntRect* rect)
> {
>     if (&image != m_image)
>diff --git a/Source/WebCore/loader/cache/CachedImage.h b/Source/WebCore/loader/cache/CachedImage.h
>index 72d59c1ff484..8679832a4cc1 100644
>--- a/Source/WebCore/loader/cache/CachedImage.h
>+++ b/Source/WebCore/loader/cache/CachedImage.h
>@@ -149,10 +149,14 @@ private:
> 
>         void encodedDataStatusChanged(const Image&, EncodedDataStatus) final;
>         void decodedSizeChanged(const Image&, long long delta) final;
>+
>+        void drawNativeImage(const Image&, GraphicsContext&, const NativeImagePtr&, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) final;
>         void didDraw(const Image&) final;
> 
>         bool canDestroyDecodedData(const Image&) final;
>         void imageFrameAvailable(const Image&, ImageAnimatingState, const IntRect* changeRect = nullptr, DecodingStatus = DecodingStatus::Invalid) final;
>+        void nativeImageWillBeDestroyed(const Image&, const NativeImagePtr&) final;
>+
>         void changedInRect(const Image&, const IntRect*) final;
>         void scheduleRenderingUpdate(const Image&) final;
> 
>@@ -164,6 +168,7 @@ private:
>     void didDraw(const Image&);
>     bool canDestroyDecodedData(const Image&);
>     void imageFrameAvailable(const Image&, ImageAnimatingState, const IntRect* changeRect = nullptr, DecodingStatus = DecodingStatus::Invalid);
>+    void nativeImageWillBeDestroyed(const Image&, const NativeImagePtr&);
>     void changedInRect(const Image&, const IntRect*);
>     void scheduleRenderingUpdate(const Image&);
> 
>diff --git a/Source/WebCore/loader/cache/CachedImageClient.h b/Source/WebCore/loader/cache/CachedImageClient.h
>index ba6445b7ea7e..b92e79ce4e43 100644
>--- a/Source/WebCore/loader/cache/CachedImageClient.h
>+++ b/Source/WebCore/loader/cache/CachedImageClient.h
>@@ -24,6 +24,7 @@
> 
> #include "CachedResourceClient.h"
> #include "ImageTypes.h"
>+#include "NativeImagePtr.h"
> 
> namespace WebCore {
> 
>@@ -47,6 +48,8 @@ public:
>     // Called when a new decoded frame for a large image is available or when an animated image is ready to advance to the next frame.
>     virtual VisibleInViewportState imageFrameAvailable(CachedImage& image, ImageAnimatingState, const IntRect* changeRect) { imageChanged(&image, changeRect); return VisibleInViewportState::No; }
> 
>+    virtual void nativeImageWillBeDestroyed(CachedImage&, const NativeImagePtr&) { }
>+
>     virtual void didRemoveCachedImageClient(CachedImage&) { }
> 
>     virtual void scheduleRenderingUpdateForImage(CachedImage&) { }
>diff --git a/Source/WebCore/platform/graphics/BitmapImage.cpp b/Source/WebCore/platform/graphics/BitmapImage.cpp
>index b1ed4e4e8479..0af6c3d8b231 100644
>--- a/Source/WebCore/platform/graphics/BitmapImage.cpp
>+++ b/Source/WebCore/platform/graphics/BitmapImage.cpp
>@@ -205,10 +205,10 @@ bool BitmapImage::notSolidColor()
> }
> #endif // ASSERT_ENABLED
> 
>-static inline void drawNativeImage(const NativeImagePtr& image, GraphicsContext& context, const FloatRect& destRect, const FloatRect& srcRect, const IntSize& srcSize, const ImagePaintingOptions& options)
>+static inline void drawNativeImage(BitmapImage& image, GraphicsContext& context, const NativeImagePtr& nativeImage, const FloatRect& destRect, const FloatRect& srcRect, const IntSize& srcSize, const ImagePaintingOptions& options)
> {
>     // Subsampling may have given us an image that is smaller than size().
>-    IntSize subsampledImageSize = nativeImageSize(image);
>+    IntSize subsampledImageSize = nativeImageSize(nativeImage);
>     if (options.orientation().usesWidthAsHeight())
>         subsampledImageSize = subsampledImageSize.transposedSize();
> 
>@@ -217,7 +217,10 @@ static inline void drawNativeImage(const NativeImagePtr& image, GraphicsContext&
>     if (subsampledImageSize != srcSize)
>         adjustedSrcRect = mapRect(srcRect, FloatRect({ }, srcSize), FloatRect({ }, subsampledImageSize));
> 
>-    context.drawNativeImage(image, subsampledImageSize, destRect, adjustedSrcRect, options);
>+    if (image.imageObserver())
>+        image.imageObserver()->drawNativeImage(image, context, nativeImage, subsampledImageSize, destRect, adjustedSrcRect, options);
>+    else
>+        context.drawNativeImage(nativeImage, subsampledImageSize, destRect, adjustedSrcRect, options);
> }
> 
> ImageDrawResult BitmapImage::draw(GraphicsContext& context, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>@@ -308,9 +311,9 @@ ImageDrawResult BitmapImage::draw(GraphicsContext& context, const FloatRect& des
>     auto orientation = options.orientation();
>     if (orientation == ImageOrientation::FromImage) {
>         orientation = frameOrientationAtIndex(m_currentFrame);
>-        drawNativeImage(image, context, destRect, srcRect, IntSize(size(orientation)), { options, orientation });
>+        drawNativeImage(*this, context, image, destRect, srcRect, IntSize(size(orientation)), { options, orientation });
>     } else
>-        drawNativeImage(image, context, destRect, srcRect, IntSize(size(orientation)), options);
>+        drawNativeImage(*this, context, image, destRect, srcRect, IntSize(size(orientation)), options);
> 
>     m_currentFrameDecodingStatus = frameDecodingStatusAtIndex(m_currentFrame);
> 
>@@ -395,7 +398,7 @@ SubsamplingLevel BitmapImage::subsamplingLevelForScaleFactor(GraphicsContext& co
> {
> #if USE(CG)
>     // Never use subsampled images for drawing into PDF contexts.
>-    if (CGContextGetType(context.platformContext()) == kCGContextTypePDF)
>+    if (context.hasPlatformContext() && CGContextGetType(context.platformContext()) == kCGContextTypePDF)
>         return SubsamplingLevel::Default;
> 
>     float scale = std::min(float(1), std::max(scaleFactor.width(), scaleFactor.height()));
>diff --git a/Source/WebCore/platform/graphics/GraphicsContext.cpp b/Source/WebCore/platform/graphics/GraphicsContext.cpp
>index 210bbac32715..7113d7f64e1a 100644
>--- a/Source/WebCore/platform/graphics/GraphicsContext.cpp
>+++ b/Source/WebCore/platform/graphics/GraphicsContext.cpp
>@@ -731,13 +731,13 @@ void GraphicsContext::drawBidiText(const FontCascade& font, const TextRun& run,
>     bidiRuns.clear();
> }
> 
>-void GraphicsContext::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+void GraphicsContext::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options, CachedImage* cachedImage)
> {
>     if (paintingDisabled())
>         return;
> 
>     if (m_impl) {
>-        m_impl->drawNativeImage(image, imageSize, destRect, srcRect, options);
>+        m_impl->drawNativeImage(image, imageSize, destRect, srcRect, options, cachedImage);
>         return;
>     }
> 
>@@ -760,7 +760,7 @@ ImageDrawResult GraphicsContext::drawImage(Image& image, const FloatRect& destin
>     if (paintingDisabled())
>         return ImageDrawResult::DidNothing;
> 
>-    if (m_impl)
>+    if (m_impl && image.isPDFDocumentImage())
>         return m_impl->drawImage(image, destination, source, options);
> 
>     InterpolationQualityMaintainer interpolationQualityForThisScope(*this, options.interpolationQuality());
>@@ -772,7 +772,7 @@ ImageDrawResult GraphicsContext::drawTiledImage(Image& image, const FloatRect& d
>     if (paintingDisabled())
>         return ImageDrawResult::DidNothing;
> 
>-    if (m_impl)
>+    if (m_impl && image.isPDFDocumentImage())
>         return m_impl->drawTiledImage(image, destination, source, tileSize, spacing, options);
> 
>     InterpolationQualityMaintainer interpolationQualityForThisScope(*this, options.interpolationQuality());
>@@ -785,7 +785,7 @@ ImageDrawResult GraphicsContext::drawTiledImage(Image& image, const FloatRect& d
>     if (paintingDisabled())
>         return ImageDrawResult::DidNothing;
> 
>-    if (m_impl)
>+    if (m_impl && image.isPDFDocumentImage())
>         return m_impl->drawTiledImage(image, destination, source, tileScaleFactor, hRule, vRule, options);
> 
>     if (hRule == Image::StretchTile && vRule == Image::StretchTile) {
>diff --git a/Source/WebCore/platform/graphics/GraphicsContext.h b/Source/WebCore/platform/graphics/GraphicsContext.h
>index 0d1ca92d6045..2519d7bea182 100644
>--- a/Source/WebCore/platform/graphics/GraphicsContext.h
>+++ b/Source/WebCore/platform/graphics/GraphicsContext.h
>@@ -86,6 +86,7 @@ class GlyphBuffer;
> #endif
> 
> class AffineTransform;
>+class CachedImage;
> class FloatRoundedRect;
> class Gradient;
> class GraphicsContextImpl;
>@@ -379,7 +380,7 @@ public:
> 
>     WEBCORE_EXPORT void strokeRect(const FloatRect&, float lineWidth);
> 
>-    WEBCORE_EXPORT void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& = { });
>+    WEBCORE_EXPORT void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& = { }, CachedImage* = nullptr);
> 
>     WEBCORE_EXPORT ImageDrawResult drawImage(Image&, const FloatPoint& destination, const ImagePaintingOptions& = { ImageOrientation::FromImage });
>     WEBCORE_EXPORT ImageDrawResult drawImage(Image&, const FloatRect& destination, const ImagePaintingOptions& = { ImageOrientation::FromImage });
>diff --git a/Source/WebCore/platform/graphics/GraphicsContextImpl.h b/Source/WebCore/platform/graphics/GraphicsContextImpl.h
>index 3536d2f3b73c..6d085ed8c42c 100644
>--- a/Source/WebCore/platform/graphics/GraphicsContextImpl.h
>+++ b/Source/WebCore/platform/graphics/GraphicsContextImpl.h
>@@ -74,7 +74,7 @@ public:
>     virtual ImageDrawResult drawTiledImage(Image&, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions&) = 0;
> 
>     virtual bool drawImageBuffer(ImageBuffer&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&) = 0;
>-    virtual void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) = 0;
>+    virtual void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&, CachedImage*) = 0;
>     virtual void drawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions&) = 0;
> 
>     virtual void drawRect(const FloatRect&, float borderThickness) = 0;
>diff --git a/Source/WebCore/platform/graphics/ImageObserver.h b/Source/WebCore/platform/graphics/ImageObserver.h
>index 8b089e594c1a..b4d710ac6730 100644
>--- a/Source/WebCore/platform/graphics/ImageObserver.h
>+++ b/Source/WebCore/platform/graphics/ImageObserver.h
>@@ -45,10 +45,13 @@ public:
>     virtual void encodedDataStatusChanged(const Image&, EncodedDataStatus) { };
>     virtual void decodedSizeChanged(const Image&, long long delta) = 0;
> 
>+    virtual void drawNativeImage(const Image&, GraphicsContext&, const NativeImagePtr&, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) = 0;
>     virtual void didDraw(const Image&) = 0;
> 
>     virtual bool canDestroyDecodedData(const Image&) = 0;
>     virtual void imageFrameAvailable(const Image&, ImageAnimatingState, const IntRect* changeRect = nullptr, DecodingStatus = DecodingStatus::Invalid) = 0;
>+    virtual void nativeImageWillBeDestroyed(const Image&, const NativeImagePtr&) = 0;
>+
>     virtual void changedInRect(const Image&, const IntRect* changeRect = nullptr) = 0;
>     virtual void scheduleRenderingUpdate(const Image&) = 0;
> };
>diff --git a/Source/WebCore/platform/graphics/ImageSource.cpp b/Source/WebCore/platform/graphics/ImageSource.cpp
>index 775032239a5d..45515c59a1ff 100644
>--- a/Source/WebCore/platform/graphics/ImageSource.cpp
>+++ b/Source/WebCore/platform/graphics/ImageSource.cpp
>@@ -130,8 +130,10 @@ void ImageSource::destroyDecodedData(size_t frameCount, size_t excludeFrame)
>     ASSERT(frameCount <= m_frames.size());
> 
>     for (size_t index = 0; index < frameCount; ++index) {
>-        if (index == excludeFrame)
>+        if (index == excludeFrame || !m_frames[index].nativeImage())
>             continue;
>+        if (m_image && m_image->imageObserver())
>+            m_image->imageObserver()->nativeImageWillBeDestroyed(*m_image, m_frames[index].nativeImage());
>         decodedSize += m_frames[index].clearImage();
>     }
> 
>diff --git a/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp b/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp
>index 8ef4f786b724..8c8a1013baff 100644
>--- a/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp
>+++ b/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp
>@@ -285,7 +285,7 @@ bool GraphicsContextImplCairo::drawImageBuffer(ImageBuffer&, const FloatRect&, c
>     return false;
> }
> 
>-void GraphicsContextImplCairo::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+void GraphicsContextImplCairo::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options, CachedImage*)
> {
>     UNUSED_PARAM(imageSize);
>     auto& state = graphicsContext().state();
>diff --git a/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h b/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h
>index 2858fc22fc1f..f768f8620230 100644
>--- a/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h
>+++ b/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h
>@@ -76,7 +76,7 @@ public:
>     ImageDrawResult drawTiledImage(Image&, const FloatRect&, const FloatRect&, const FloatSize&, Image::TileRule, Image::TileRule, const ImagePaintingOptions&) override;
> 
>     bool drawImageBuffer(ImageBuffer&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&) override;
>-    void drawNativeImage(const NativeImagePtr&, const FloatSize&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&) override;
>+    void drawNativeImage(const NativeImagePtr&, const FloatSize&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&, CachedImage*) override;
>     void drawPattern(Image&, const FloatRect&, const FloatRect&, const AffineTransform&, const FloatPoint&, const FloatSize&, const ImagePaintingOptions&) override;
> 
>     void drawRect(const FloatRect&, float) override;
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp
>index cf8892125610..30035a02452d 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp
>@@ -766,7 +766,7 @@ static TextStream& operator<<(TextStream& ts, const DrawImageBuffer& item)
>     return ts;
> }
> 
>-DrawNativeImage::DrawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+DrawNativeImage::DrawNativeImage(const NativeImageType& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>     : DrawingItem(ItemType::DrawNativeImage)
>     , m_image(image)
>     , m_imageSize(imageSize)
>@@ -780,7 +780,8 @@ DrawNativeImage::~DrawNativeImage() = default;
> 
> void DrawNativeImage::apply(GraphicsContext& context) const
> {
>-    context.drawNativeImage(m_image, m_imageSize, m_destinationRect, m_srcRect, m_options);
>+    ASSERT(nativeImagePtr());
>+    context.drawNativeImage(nativeImagePtr(), m_imageSize, m_destinationRect, m_srcRect, m_options);
> }
> 
> static TextStream& operator<<(TextStream& ts, const DrawNativeImage& item)
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>index 6c3ec282505e..278419957257 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>@@ -1601,27 +1601,45 @@ Optional<Ref<DrawImageBuffer>> DrawImageBuffer::decode(Decoder& decoder)
> 
> class DrawNativeImage : public DrawingItem {
> public:
>-    static Ref<DrawNativeImage> create(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+    using NativeImageType = Variant<NativeImagePtr, RemoteResourceIdentifier>;
>+
>+    static Ref<DrawNativeImage> create(const NativeImageType& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>     {
>         return adoptRef(*new DrawNativeImage(image, imageSize, destRect, srcRect, options));
>     }
> 
>     WEBCORE_EXPORT virtual ~DrawNativeImage();
> 
>+    RemoteResourceIdentifier remoteResourceIdentifier() const
>+    {
>+        if (auto result = WTF::get_if<RemoteResourceIdentifier>(m_image))
>+            return *result;
>+        return { };
>+    }
>+
>+    NativeImagePtr nativeImagePtr() const
>+    {
>+        if (auto result = WTF::get_if<NativeImagePtr>(m_image))
>+            return *result;
>+        return nullptr;
>+    }
>+
>+    FloatSize imageSize() const { return m_imageSize; }
>     FloatRect source() const { return m_srcRect; }
>     FloatRect destinationRect() const { return m_destinationRect; }
>+    ImagePaintingOptions options() const { return m_options; }
> 
>     template<class Encoder> void encode(Encoder&) const;
>     template<class Decoder> static Optional<Ref<DrawNativeImage>> decode(Decoder&);
> 
> private:
>-    WEBCORE_EXPORT DrawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&);
>+    WEBCORE_EXPORT DrawNativeImage(const NativeImageType&, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&);
> 
>     void apply(GraphicsContext&) const override;
> 
>     Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destinationRect; }
> 
>-    NativeImagePtr m_image;
>+    NativeImageType m_image;
>     FloatSize m_imageSize;
>     FloatRect m_destinationRect;
>     FloatRect m_srcRect;
>@@ -1641,7 +1659,7 @@ void DrawNativeImage::encode(Encoder& encoder) const
> template<class Decoder>
> Optional<Ref<DrawNativeImage>> DrawNativeImage::decode(Decoder& decoder)
> {
>-    Optional<NativeImagePtr> image;
>+    Optional<NativeImageType> image;
>     decoder >> image;
>     if (!image)
>         return WTF::nullopt;
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp
>index 8b71a655b2e2..533f020c5e31 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp
>@@ -176,8 +176,14 @@ bool Recorder::drawImageBuffer(WebCore::ImageBuffer& imageBuffer, const FloatRec
>     return true;
> }
> 
>-void Recorder::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+void Recorder::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options, CachedImage* cachedImage)
> {
>+    if (m_delegate && cachedImage) {
>+        if (auto remoteResourceIdentifer = m_delegate->lockRemoteNativeImage(*cachedImage, image)) {
>+            appendItemAndUpdateExtent(DrawNativeImage::create(remoteResourceIdentifer, imageSize, destRect, srcRect, options));
>+            return;
>+        }
>+    }
>     appendItemAndUpdateExtent(DrawNativeImage::create(image, imageSize, destRect, srcRect, options));
> }
> 
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h
>index 923c54885729..430da87ada36 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h
>@@ -28,12 +28,14 @@
> #include "DisplayList.h"
> #include "GraphicsContextImpl.h"
> #include "Image.h" // For Image::TileRule.
>+#include "RemoteResourceIdentifier.h"
> #include "TextFlags.h"
> #include <wtf/Noncopyable.h>
> 
> namespace WebCore {
> 
> enum class AlphaPremultiplication : uint8_t;
>+class CachedImage;
> class FloatPoint;
> class FloatRect;
> class GlyphBuffer;
>@@ -68,6 +70,7 @@ public:
>         virtual ~Delegate() { }
>         virtual void willAppendItem(const Item&) { };
>         virtual bool lockRemoteImageBuffer(WebCore::ImageBuffer&) { return false; }
>+        virtual RemoteResourceIdentifier lockRemoteNativeImage(CachedImage&, const WebCore::NativeImagePtr&) { return { }; }
>     };
> 
> private:
>@@ -107,7 +110,7 @@ private:
>     ImageDrawResult drawTiledImage(Image&, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions&) override;
> 
>     bool drawImageBuffer(WebCore::ImageBuffer&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&) override;
>-    void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) override;
>+    void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&, CachedImage*) override;
>     void drawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions&) override;
> 
>     void drawRect(const FloatRect&, float borderThickness) override;
>diff --git a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp
>index a2c9e093fc14..2cf72e77e22f 100644
>--- a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp
>+++ b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp
>@@ -555,7 +555,7 @@ bool CairoOperationRecorder::drawImageBuffer(ImageBuffer&, const FloatRect&, con
>     return false;
> }
> 
>-void CairoOperationRecorder::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+void CairoOperationRecorder::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options, CachedImage*)
> {
>     struct DrawNativeImage final : PaintingOperation, OperationData<RefPtr<cairo_surface_t>, FloatRect, FloatRect, ImagePaintingOptions, float, Cairo::ShadowState> {
>         virtual ~DrawNativeImage() = default;
>diff --git a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h
>index 38093d4135b4..1d49013c89cf 100644
>--- a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h
>+++ b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h
>@@ -69,7 +69,7 @@ private:
>     WebCore::ImageDrawResult drawTiledImage(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::FloatSize&, WebCore::Image::TileRule, WebCore::Image::TileRule, const WebCore::ImagePaintingOptions&) override;
> 
>     bool drawImageBuffer(WebCore::ImageBuffer&, const WebCore::FloatRect& destination, const WebCore::FloatRect& source, const WebCore::ImagePaintingOptions&) override;
>-    void drawNativeImage(const WebCore::NativeImagePtr&, const WebCore::FloatSize&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::ImagePaintingOptions&) override;
>+    void drawNativeImage(const WebCore::NativeImagePtr&, const WebCore::FloatSize&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::ImagePaintingOptions&, WebCore::CachedImage*) override;
>     void drawPattern(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::AffineTransform&, const WebCore::FloatPoint&, const WebCore::FloatSize&, const WebCore::ImagePaintingOptions&) override;
> 
>     void drawRect(const WebCore::FloatRect&, float) override;
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 7478c0a5f61d..8c3f5d151f15 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,76 @@
>+2020-10-21  Said Abou-Hallawa  <said@apple.com>
>+
>+        [GPU Process] Cache the BitmapImage frame in GPU Process and allow referencing it with its RemoteResourceIdentifier
>+        https://bugs.webkit.org/show_bug.cgi?id=217596
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This is the drawing sequence of a BitmapImage frame in the Web Process:
>+
>+        1) BitmapImage::draw() calls ImageObserver::drawNativeImage().
>+        2) CachedImage::CachedImageObserver::drawNativeImage() finds the associated
>+           CachedImage and calls GraphicsContext::drawNativeImage().
>+        3) Recorder::drawNativeImage() calls the lockRemoteNativeImage() of its
>+           delegate which is RemoteImageBufferPorxy in the case of 2D canvas.
>+        4) RemoteImageBufferPorxy calls lockRemoteNativeImageForRemoteClient() of
>+           the RemoteResourceCacheProxy of its RemoteRenderingBackendProxy.
>+        5) RemoteResourceCacheProxy finds the NativeImage of the given CachedImage
>+           in its cache. If it does not find it, it adds it to the cache, assigns
>+           a RemoteResourceIdentifier to it and asks the GPU Process to cache it
>+           also, mark the cached NativeImage a locked resource for the 
>+           RemoteResourceCacheProxy and returns the RemoteResourceIdentifier.
>+
>+        The drawing sequence in the GPU Process is the following:
>+
>+        1) When flushing a DisplyList happens, DisplayList::Replayer::reply()
>+           calls apply() of its delegate (which is RemoteImageBuffer).
>+        2) RemoteImageBuffer::apply() calls RemoteRenderingBackend::applyResourceItem()
>+           which will check if the type of the Item is DrawNativeImage.
>+        3) If it is a DrawNativeImage, RemoteRenderingBackend finds the cached
>+           NativeImage in its RemoteResourceCache given the RemoteResourceIdentifier
>+           and draws it to the context of the RemoteImageBuffer.
>+
>+        The release sequence in the Web Process is the following:
>+
>+        1) ImageSource::destroyDecodedData() calls the ImageObserver when a decoded
>+           frame is about to be destroyed.
>+        2) CachedImage::CachedImageObserver::nativeImageWillBeDestroyed() finds
>+           the associated CachedImage and calls CachedImage::nativeImageWillBeDestroyed().
>+        3) CachedImage calls all the CachedImageClients to notify them.
>+        4) Because RemoteResourceCacheProxy registers itself as a CachedImageClient
>+           of this CachedImage, RemoteResourceCacheProxy::nativeImageWillBeDestroyed()
>+           will be called.
>+        5) The cached NativeImage will be removed from the cache and a message will
>+           be sent to the GPU Process when no remote client is referencing this
>+           NativeImage.
>+
>+        The release sequence in the GPU Process is the following:
>+
>+        1) RemoteResourceCache::releaseRemoteResource releases the cached
>+           NativeImage via RemoteRenderingBackend.
>+
>+        * GPUProcess/graphics/RemoteImageBuffer.h:
>+        (WebKit::RemoteImageBuffer::apply): Deleted.
>+        * GPUProcess/graphics/RemoteRenderingBackend.cpp:
>+        (WebKit::RemoteRenderingBackend::applyResourceItem):
>+        (WebKit::RemoteRenderingBackend::applyMediaItem):
>+        (WebKit::RemoteRenderingBackend::cacheNativeImage):
>+        * GPUProcess/graphics/RemoteRenderingBackend.h:
>+        * GPUProcess/graphics/RemoteRenderingBackend.messages.in:
>+        * GPUProcess/graphics/RemoteResourceCache.cpp:
>+        (WebKit::RemoteResourceCache::cacheNativeImage):
>+        (WebKit::RemoteResourceCache::cachedNativeImage):
>+        (WebKit::RemoteResourceCache::releaseRemoteResource):
>+        * GPUProcess/graphics/RemoteResourceCache.h:
>+        * WebProcess/GPU/graphics/RemoteImageBufferProxy.h:
>+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:
>+        (WebKit::RemoteRenderingBackendProxy::cacheNativeImage):
>+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
>+        * WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp:
>+        (WebKit::RemoteResourceCacheProxy::nativeImageWillBeDestroyed):
>+        (WebKit::RemoteResourceCacheProxy::lockRemoteNativeImageForRemoteClient):
>+        * WebProcess/GPU/graphics/RemoteResourceCacheProxy.h:
>+
> 2020-10-20  Said Abou-Hallawa  <said@apple.com>
> 
>         [GPU Process]: Implement DisplayList::DrawImageBuffer item
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h b/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h
>index e268362a514b..001febb6c936 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h
>@@ -78,31 +78,12 @@ private:
>             return true;
>         }
> 
>-        if (item.type() == WebCore::DisplayList::ItemType::PaintFrameForMedia) {
>-            apply(static_cast<WebCore::DisplayList::PaintFrameForMedia&>(item), context);
>+        if (m_remoteRenderingBackend.applyResourceItem(item, context))
>             return true;
>-        }
>-
>-        return m_remoteRenderingBackend.applyResourceItem(item, context);
>+        
>+        return m_remoteRenderingBackend.applyMediaItem(item, context);
>     }
> 
>-    void apply(WebCore::DisplayList::PaintFrameForMedia& item, WebCore::GraphicsContext& context)
>-    {
>-        auto process = m_remoteRenderingBackend.gpuConnectionToWebProcess();
>-        if (!process)
>-            return;
>-
>-        auto playerProxy = process->remoteMediaPlayerManagerProxy().getProxy(item.identifier());
>-        if (!playerProxy)
>-            return;
>-
>-        auto player = playerProxy->mediaPlayer();
>-        if (!player)
>-            return;
>-
>-        context.paintFrameForMedia(*player, item.destination());
>-    }
>-    
>     RemoteRenderingBackend& m_remoteRenderingBackend;
> };
> 
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>index 653912ae4af8..22e1ca338b71 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>@@ -76,14 +76,50 @@ bool RemoteRenderingBackend::applyResourceItem(const DisplayList::Item& item, Gr
> {
>     if (item.type() == DisplayList::ItemType::DrawImageBuffer) {
>         auto& drawItem = static_cast<const DisplayList::DrawImageBuffer&>(item);
>-        if (auto imageBuffer = m_remoteResourceCache.cachedImageBuffer(drawItem.remoteResourceIdentifier())) {
>-            imageBuffer->draw(context, drawItem.destinationRect(), drawItem.source(), drawItem.options());
>-            return true;
>-        }
>+        auto imageBuffer = m_remoteResourceCache.cachedImageBuffer(drawItem.remoteResourceIdentifier());
>+        if (!imageBuffer)
>+            return false;
>+
>+        imageBuffer->draw(context, drawItem.destinationRect(), drawItem.source(), drawItem.options());
>+        return true;
>+    }
>+    
>+    if (item.type() == DisplayList::ItemType::DrawNativeImage) {
>+        auto& drawItem = static_cast<const DisplayList::DrawNativeImage&>(item);
>+        auto image = m_remoteResourceCache.cachedNativeImage(drawItem.remoteResourceIdentifier());
>+        if (!image)
>+            return false;
>+
>+        context.drawNativeImage(image, drawItem.imageSize(), drawItem.destinationRect(), drawItem.source(), drawItem.options());
>+        return true;
>     }
>+    
>     return false;
> }
> 
>+bool RemoteRenderingBackend::applyMediaItem(const DisplayList::Item& item, GraphicsContext& context)
>+{
>+    if (item.type() != WebCore::DisplayList::ItemType::PaintFrameForMedia)
>+        return false;
>+    
>+    auto& mediaItem = static_cast<const DisplayList::PaintFrameForMedia&>(item);
>+        
>+    auto process = gpuConnectionToWebProcess();
>+    if (!process)
>+        return false;
>+
>+    auto playerProxy = process->remoteMediaPlayerManagerProxy().getProxy(mediaItem.identifier());
>+    if (!playerProxy)
>+        return false;
>+
>+    auto player = playerProxy->mediaPlayer();
>+    if (!player)
>+        return false;
>+
>+    context.paintFrameForMedia(*player, mediaItem.destination());
>+    return true;
>+}
>+
> void RemoteRenderingBackend::imageBufferBackendWasCreated(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, ImageBufferBackendHandle handle, RemoteResourceIdentifier remoteResourceIdentifier)
> {
>     send(Messages::RemoteRenderingBackendProxy::ImageBufferBackendWasCreated(logicalSize, backendSize, resolutionScale, colorSpace, WTFMove(handle), remoteResourceIdentifier), m_renderingBackendIdentifier);
>@@ -136,6 +172,10 @@ void RemoteRenderingBackend::getImageData(WebCore::AlphaPremultiplication output
>         imageData = imageBuffer->getImageData(outputFormat, srcRect);
>     completionHandler(IPC::ImageDataReference(WTFMove(imageData)));
> }
>+void RemoteRenderingBackend::cacheNativeImage(const NativeImagePtr& image, RemoteResourceIdentifier  remoteResourceIdentifier)
>+{
>+    m_remoteResourceCache.cacheNativeImage(image, remoteResourceIdentifier);
>+}
> 
> void RemoteRenderingBackend::releaseRemoteResource(RemoteResourceIdentifier remoteResourceIdentifier)
> {
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>index 81874fae65d2..3eb4b7d1ab10 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>@@ -64,6 +64,7 @@ public:
> 
>     // Rendering operations.
>     bool applyResourceItem(const WebCore::DisplayList::Item&, WebCore::GraphicsContext&);
>+    bool applyMediaItem(const WebCore::DisplayList::Item&, WebCore::GraphicsContext&);
> 
>     // Messages to be sent.
>     void imageBufferBackendWasCreated(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle, WebCore::RemoteResourceIdentifier);
>@@ -85,6 +86,7 @@ private:
>     void flushDisplayList(const WebCore::DisplayList::DisplayList&, WebCore::RemoteResourceIdentifier);
>     void flushDisplayListAndCommit(const WebCore::DisplayList::DisplayList&, DisplayListFlushIdentifier, WebCore::RemoteResourceIdentifier);
>     void getImageData(WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, WebCore::RemoteResourceIdentifier, CompletionHandler<void(IPC::ImageDataReference&&)>&&);
>+    void cacheNativeImage(const WebCore::NativeImagePtr&, WebCore::RemoteResourceIdentifier);
>     void releaseRemoteResource(WebCore::RemoteResourceIdentifier);
> 
>     RemoteResourceCache m_remoteResourceCache;
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in
>index 035d6bb462c1..96c19e908be6 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in
>@@ -27,6 +27,7 @@ messages -> RemoteRenderingBackend NotRefCounted {
>     void FlushDisplayList(WebCore::DisplayList::DisplayList displayList, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
>     void FlushDisplayListAndCommit(WebCore::DisplayList::DisplayList displayList, WebKit::DisplayListFlushIdentifier flushIdentifier, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
>     GetImageData(enum:uint8_t WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, WebCore::RemoteResourceIdentifier remoteResourceIdentifier) -> (IPC::ImageDataReference imageData) Synchronous
>+    void CacheNativeImage(WebCore::NativeImagePtr image, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
>     void ReleaseRemoteResource(WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
> }
> 
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp b/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp
>index ad0472625219..2ef4c02d6582 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp
>@@ -37,15 +37,28 @@ void RemoteResourceCache::cacheImageBuffer(RemoteResourceIdentifier remoteResour
>     ASSERT_UNUSED(addResult, addResult.isNewEntry);
> }
> 
>-WebCore::ImageBuffer* RemoteResourceCache::cachedImageBuffer(RemoteResourceIdentifier remoteResourceIdentifier)
>+ImageBuffer* RemoteResourceCache::cachedImageBuffer(RemoteResourceIdentifier remoteResourceIdentifier)
> {
>     return m_imageBuffers.get(remoteResourceIdentifier);
> }
> 
>+void RemoteResourceCache::cacheNativeImage(const NativeImagePtr& image, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    auto addResult = m_nativeImages.add(remoteResourceIdentifier, image);
>+    ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+}
>+
>+NativeImagePtr RemoteResourceCache::cachedNativeImage(RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    return m_nativeImages.get(remoteResourceIdentifier);
>+}
>+
> void RemoteResourceCache::releaseRemoteResource(RemoteResourceIdentifier remoteResourceIdentifier)
> {
>     if (m_imageBuffers.remove(remoteResourceIdentifier))
>         return;
>+    if (m_nativeImages.remove(remoteResourceIdentifier))
>+        return;
>     // Caching the remote resource should have happened before releasing it.
>     ASSERT_NOT_REACHED();
> }
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h b/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h
>index 4ed8ce0acc15..716c13d194aa 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h
>@@ -44,12 +44,16 @@ public:
> 
>     void cacheImageBuffer(WebCore::RemoteResourceIdentifier, std::unique_ptr<WebCore::ImageBuffer>&&);
>     WebCore::ImageBuffer* cachedImageBuffer(WebCore::RemoteResourceIdentifier);
>+    void cacheNativeImage(const WebCore::NativeImagePtr&, WebCore::RemoteResourceIdentifier);
>+    WebCore::NativeImagePtr cachedNativeImage(WebCore::RemoteResourceIdentifier);
>     void releaseRemoteResource(WebCore::RemoteResourceIdentifier);
> 
> private:
>     using RemoteImageBufferHashMap = HashMap<WebCore::RemoteResourceIdentifier, std::unique_ptr<WebCore::ImageBuffer>>;
>+    using RemoteNativeImageHashMap = HashMap<WebCore::RemoteResourceIdentifier, WebCore::NativeImagePtr>;
> 
>     RemoteImageBufferHashMap m_imageBuffers;
>+    RemoteNativeImageHashMap m_nativeImages;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>index e0d2ff7d1a66..9116edf6a4d4 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>@@ -163,6 +163,13 @@ protected:
>         return m_remoteRenderingBackendProxy->remoteResourceCacheProxy().lockRemoteImageBufferForRemoteClient(imageBuffer, m_remoteResourceIdentifier);
>     }
> 
>+    WebCore::RemoteResourceIdentifier lockRemoteNativeImage(WebCore::CachedImage& cachedImage, const WebCore::NativeImagePtr& image) override
>+    {
>+        if (!m_remoteRenderingBackendProxy)
>+            return { };
>+        return m_remoteRenderingBackendProxy->remoteResourceCacheProxy().lockRemoteNativeImageForRemoteClient(cachedImage, image, m_remoteResourceIdentifier);
>+    }
>+
>     DisplayListFlushIdentifier m_sentFlushIdentifier;
>     DisplayListFlushIdentifier m_receivedFlushIdentifier;
>     WebCore::RemoteResourceIdentifier m_remoteResourceIdentifier { WebCore::RemoteResourceIdentifier::generate() };
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>index 5d4e0820e09a..ad7f088c9273 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>@@ -131,6 +131,11 @@ DisplayListFlushIdentifier RemoteRenderingBackendProxy::flushDisplayListAndCommi
>     return sentFlushIdentifier;
> }
> 
>+void RemoteRenderingBackendProxy::cacheNativeImage(const WebCore::NativeImagePtr& image, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    send(Messages::RemoteRenderingBackend::CacheNativeImage(image, remoteResourceIdentifier), m_renderingBackendIdentifier);
>+}
>+
> void RemoteRenderingBackendProxy::releaseRemoteResource(RemoteResourceIdentifier remoteResourceIdentifier)
> {
>     send(Messages::RemoteRenderingBackend::ReleaseRemoteResource(remoteResourceIdentifier), m_renderingBackendIdentifier);
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>index 3fe51c5da95e..bdb180989003 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>@@ -74,6 +74,7 @@ public:
>     RefPtr<WebCore::ImageData> getImageData(WebCore::AlphaPremultiplication outputFormat, const WebCore::IntRect& srcRect, WebCore::RemoteResourceIdentifier);
>     void flushDisplayList(const WebCore::DisplayList::DisplayList&, WebCore::RemoteResourceIdentifier);
>     DisplayListFlushIdentifier flushDisplayListAndCommit(const WebCore::DisplayList::DisplayList&, WebCore::RemoteResourceIdentifier);
>+    void cacheNativeImage(const WebCore::NativeImagePtr&, WebCore::RemoteResourceIdentifier);
>     void releaseRemoteResource(WebCore::RemoteResourceIdentifier);
> 
>     bool waitForImageBufferBackendWasCreated();
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp
>index f40f41974111..8d5c8fc3ea37 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp
>@@ -29,6 +29,7 @@
> #if ENABLE(GPU_PROCESS)
> 
> #include "RemoteRenderingBackendProxy.h"
>+#include <WebCore/CachedImage.h>
> 
> namespace WebKit {
> using namespace WebCore;
>@@ -38,7 +39,7 @@ RemoteResourceCacheProxy::RemoteResourceCacheProxy(RemoteRenderingBackendProxy&
> {
> }
> 
>-void RemoteResourceCacheProxy::cacheImageBuffer(RemoteResourceIdentifier identifier, WebCore::ImageBuffer* imageBuffer)
>+void RemoteResourceCacheProxy::cacheImageBuffer(RemoteResourceIdentifier identifier, ImageBuffer* imageBuffer)
> {
>     auto addResult = m_imageBuffers.add(identifier, imageBuffer);
>     ASSERT_UNUSED(addResult, addResult.isNewEntry);
>@@ -58,6 +59,27 @@ void RemoteResourceCacheProxy::releaseImageBuffer(RemoteResourceIdentifier remot
>     releaseRemoteResource(remoteResourceIdentifier);
> }
> 
>+void RemoteResourceCacheProxy::nativeImageWillBeDestroyed(WebCore::CachedImage& cachedImage, const NativeImagePtr& image)
>+{
>+    auto iter = m_cachedImages.find(&cachedImage);
>+    if (iter == m_cachedImages.end())
>+        return;
>+
>+    // Remove the resource from the cache.
>+    auto remoteResourceIdentifier = iter->value.take(image);
>+    if (!remoteResourceIdentifier)
>+        return;
>+
>+    // Tell the GPU process to remove this resource unless it's pending replaying back.
>+    releaseRemoteResource(remoteResourceIdentifier);
>+
>+    // Remove *this* from being a client of achedImage, if there is no NativeImages cached for it.
>+    if (iter->value.isEmpty()) {
>+        iter->key->removeClient(*this);
>+        m_cachedImages.remove(iter);
>+    }
>+}
>+
> bool RemoteResourceCacheProxy::lockRemoteImageBufferForRemoteClient(ImageBuffer& imageBuffer, RemoteResourceIdentifier remoteClientIdentifier)
> {
>     if (!imageBuffer.remoteResourceIdentifier())
>@@ -72,6 +94,23 @@ bool RemoteResourceCacheProxy::lockRemoteImageBufferForRemoteClient(ImageBuffer&
>     return true;
> }
> 
>+RemoteResourceIdentifier RemoteResourceCacheProxy::lockRemoteNativeImageForRemoteClient(WebCore::CachedImage& cachedImage, const NativeImagePtr& image, RemoteResourceIdentifier remoteClientIdentifier)
>+{
>+    auto& nativeImages = m_cachedImages.ensure(&cachedImage, [&] {
>+        cachedImage.addClient(*this);
>+        return RemoteNativeImageHashMap();
>+    }).iterator->value;
>+
>+    auto remoteResourceIdentifier = nativeImages.ensure(image, [&] {
>+        auto remoteResourceIdentifier = RemoteResourceIdentifier::generate();
>+        m_remoteRenderingBackendProxy.cacheNativeImage(image, remoteResourceIdentifier);
>+        return remoteResourceIdentifier;
>+    }).iterator->value;
>+
>+    lockRemoteResourceForRemoteClient(remoteResourceIdentifier, remoteClientIdentifier);
>+    return remoteResourceIdentifier;
>+}
>+
> void RemoteResourceCacheProxy::lockRemoteResourceForRemoteClient(RemoteResourceIdentifier remoteResourceIdentifier, RemoteResourceIdentifier remoteClientIdentifier)
> {
>     // Add the "resource -> client" dependency in m_lockedRemoteResourceForRemoteClients.
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.h
>index 478e4b993d77..d4601961e91d 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.h
>@@ -27,10 +27,12 @@
> 
> #if ENABLE(GPU_PROCESS)
> 
>+#include <WebCore/CachedImageClient.h>
> #include <WebCore/RemoteResourceIdentifier.h>
> #include <wtf/HashMap.h>
> 
> namespace WebCore {
>+class CachedImage;
> class ImageBuffer;
> }
> 
>@@ -38,7 +40,7 @@ namespace WebKit {
> 
> class RemoteRenderingBackendProxy;
> 
>-class RemoteResourceCacheProxy {
>+class RemoteResourceCacheProxy : public WebCore::CachedImageClient {
> public:
>     RemoteResourceCacheProxy(RemoteRenderingBackendProxy&);
> 
>@@ -47,12 +49,17 @@ public:
>     void releaseImageBuffer(WebCore::RemoteResourceIdentifier);
> 
>     bool lockRemoteImageBufferForRemoteClient(WebCore::ImageBuffer&, WebCore::RemoteResourceIdentifier remoteClientIdentifier);
>+    WebCore::RemoteResourceIdentifier lockRemoteNativeImageForRemoteClient(WebCore::CachedImage&, const WebCore::NativeImagePtr&, WebCore::RemoteResourceIdentifier remoteClientIdentifier);
>     void unlockRemoteResourcesForRemoteClient(WebCore::RemoteResourceIdentifier remoteClientIdentifier);
>     
> private:
>     using RemoteClientsHashSet = HashSet<WebCore::RemoteResourceIdentifier>;
>     using RemoteResourceClientsHashMap = HashMap<WebCore::RemoteResourceIdentifier, RemoteClientsHashSet>;
>     using RemoteImageBufferProxyHashMap = HashMap<WebCore::RemoteResourceIdentifier, WebCore::ImageBuffer*>;
>+    using RemoteNativeImageHashMap = HashMap<WebCore::NativeImagePtr, WebCore::RemoteResourceIdentifier>;
>+    using RemoteCachedImageHashMap = HashMap<WebCore::CachedImage*, RemoteNativeImageHashMap>;
>+
>+    void nativeImageWillBeDestroyed(WebCore::CachedImage&, const WebCore::NativeImagePtr&) override;
> 
>     void lockRemoteResourceForRemoteClient(WebCore::RemoteResourceIdentifier, WebCore::RemoteResourceIdentifier remoteClientIdentifier);
>     void releaseRemoteResource(WebCore::RemoteResourceIdentifier);
>@@ -60,6 +67,7 @@ private:
>     RemoteImageBufferProxyHashMap m_imageBuffers;
>     RemoteResourceClientsHashMap m_lockedRemoteResourceForRemoteClients;
>     RemoteResourceClientsHashMap m_pendingUnlockRemoteResourceForRemoteClients;
>+    RemoteCachedImageHashMap m_cachedImages;
>     RemoteRenderingBackendProxy& m_remoteRenderingBackendProxy;
> };
>

Actions: View | Formatted Diff | Diff

Attachments on bug 217596: 411086 | 411096 | 411098 | 411125 | 412064 | 412070 | 412586 | 412945 | 412947 | 413740 | 413742 | 413754 | 413761 | 413786 | 413842 | 413847 | 413875