Attachment 411096 Details for Bug 217596 – Patch

[patch] Patch

bug-217596-20201011215407.patch (text/plain), 195.18 KB, created by Said Abou-Hallawa on 2020-10-11 21:54:07 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Said Abou-Hallawa

Created: 2020-10-11 21:54:07 PDT

Size: 195.18 KB

patch

obsolete

>Subversion Revision: 268303
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 931aa8694034f1ed850dff7ec1e6eba8de3b4bbe..010545b27a7b423857a3e114cc3d5c8fdd57feaf 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,231 @@
>+2020-10-11  Said Abou-Hallawa  <sabouhallawa@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!).
>+
>+        * 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:
>+        (WebCore::CachedImageClient::nativeImageWillBeDestroyed):
>+        * platform/graphics/BitmapImage.cpp:
>+        (WebCore::drawNativeImage):
>+        (WebCore::BitmapImage::draw):
>+        (WebCore::BitmapImage::subsamplingLevelForScaleFactor):
>+        * platform/graphics/GraphicsContext.cpp:
>+        (WebCore::GraphicsContext::drawNativeImage):
>+        * platform/graphics/GraphicsContext.h:
>+        (WebCore::GraphicsContext::drawNativeImage):
>+        * platform/graphics/GraphicsContextImpl.h:
>+        * platform/graphics/ImageObserver.h:
>+        * platform/graphics/ImageSource.cpp:
>+        (WebCore::ImageSource::destroyDecodedData):
>+        * platform/graphics/displaylists/DisplayListItems.cpp:
>+        (WebCore::DisplayList::DrawNativeImage::DrawNativeImage):
>+        (WebCore::DisplayList::DrawNativeImage::apply const):
>+        * platform/graphics/displaylists/DisplayListItems.h:
>+        (WebCore::DisplayList::DrawNativeImage::remoteResourceIdentifier const):
>+        (WebCore::DisplayList::DrawNativeImage::nativeImagePtr const):
>+        (WebCore::DisplayList::DrawNativeImage::create):
>+        (WebCore::DisplayList::DrawNativeImage::imageSize const):
>+        (WebCore::DisplayList::DrawNativeImage::options const):
>+        (WebCore::DisplayList::DrawNativeImage::decode):
>+        * platform/graphics/displaylists/DisplayListRecorder.cpp:
>+        (WebCore::DisplayList::Recorder::drawNativeImage):
>+        * platform/graphics/displaylists/DisplayListRecorder.h:
>+        (WebCore::DisplayList::Recorder::Delegate::createDrawNativeImageItem):
>+
>+2020-10-11  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        [GPU Process] Clean the DisplayList recording of the NativeImage
>+        https://bugs.webkit.org/show_bug.cgi?id=217573
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        1) Move the definition of NativeImagePtr to a separate header file named
>+           NativeImagePtr.
>+        2) Remove the class ImageHandle and allow encoding and decoding NativeImagePtr
>+           directly.
>+        3) Remove the compilation directives around the DisplayList::DrawNativeImage
>+           item and the method drawNativeImage().
>+        4) Move the drawNativeImage() methods to the sources of their callers.
>+        5) In the case of recording the drawing commands, make GraphicsContext::drawImage()
>+           process drawing the images such that primitives drawing commands are
>+           recorded. For example a BitmapImage will render a NativeImage eventually.
>+           And SVGImage will record its render tree.
>+
>+        * Headers.cmake:
>+        * WebCore.xcodeproj/project.pbxproj:
>+        * loader/cache/MemoryCache.h:
>+        * platform/graphics/BitmapImage.cpp:
>+        (WebCore::drawNativeImage):
>+        * 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/Image.h:
>+        * platform/graphics/ImageBufferBackend.h:
>+        * platform/graphics/NativeImage.h:
>+        * platform/graphics/NativeImagePtr.h: Added.
>+        * platform/graphics/cairo/GraphicsContextCairo.cpp:
>+        (WebCore::GraphicsContext::platformDrawNativeImage):
>+        (WebCore::GraphicsContext::drawNativeImage): Deleted.
>+        * platform/graphics/cg/GraphicsContextCG.cpp:
>+        (WebCore::GraphicsContext::platformDrawNativeImage):
>+        (WebCore::GraphicsContext::drawNativeImage): Deleted.
>+        * platform/graphics/cg/NativeImageCG.cpp:
>+        (WebCore::drawNativeImage): Deleted.
>+        * platform/graphics/displaylists/DisplayList.h:
>+        * platform/graphics/displaylists/DisplayListItems.cpp:
>+        (WebCore::DisplayList::Item::sizeInBytes):
>+        (WebCore::DisplayList::DrawNativeImage::DrawNativeImage):
>+        (WebCore::DisplayList::DrawNativeImage::apply const):
>+        (WebCore::DisplayList::DrawImageBuffer::DrawImageBuffer):
>+        (WebCore::DisplayList::DrawImageBuffer::apply const):
>+        (WebCore::DisplayList::operator<<):
>+        * platform/graphics/displaylists/DisplayListItems.h:
>+        (WebCore::DisplayList::DrawNativeImage::encode const):
>+        (WebCore::DisplayList::DrawNativeImage::decode):
>+        (WebCore::DisplayList::DrawImageBuffer::create):
>+        (WebCore::DisplayList::DrawImageBuffer::remoteResourceIdentifier const):
>+        (WebCore::DisplayList::DrawImageBuffer::source const):
>+        (WebCore::DisplayList::DrawImageBuffer::destinationRect const):
>+        (WebCore::DisplayList::DrawImageBuffer::options const):
>+        (WebCore::DisplayList::DrawImageBuffer::encode const):
>+        (WebCore::DisplayList::DrawImageBuffer::decode):
>+        (WebCore::DisplayList::Item::encode const):
>+        (WebCore::DisplayList::Item::decode):
>+        * platform/graphics/displaylists/DisplayListRecorder.cpp:
>+        * platform/graphics/displaylists/DisplayListRecorder.h:
>+        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
>+        * platform/graphics/nicosia/NicosiaImageBufferPipe.cpp:
>+        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp:
>+        (Nicosia::CairoOperationRecorder::drawImageBuffer):
>+        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h:
>+        * platform/graphics/win/GraphicsContextDirect2D.cpp:
>+        (WebCore::GraphicsContext::platformDrawNativeImage):
>+        (WebCore::GraphicsContext::drawNativeImage): Deleted.
>+
>+2020-10-10  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        [GPU Process] Implement DisplayList::DrawImageBuffer item
>+        https://bugs.webkit.org/show_bug.cgi?id=217566
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        The sequence in the Web Process is the following:
>+
>+        -- GraphicsContext::drawImageBuffer() uses DisplayList::Recorder to check
>+           whether it is appropriate to create DrawImageBuffer item or not.
>+
>+        -- DisplayList::Recorder::drawImageBuffer() uses the delegate to to create
>+           the DrawImageBuffer item.
>+
>+        -- Since RemoteImageBuffer inherits DisplayList::Recorder::Delegate, 
>+           RemoteImageBuffer::createDrawImageBufferItem() will be called.
>+
>+        -- RemoteRenderingBackend::createDrawImageBufferItem() will be called next
>+           which will call RemoteResourceCache::createDrawImageBufferItem().
>+
>+        -- RemoteResourceCache::createDrawImageBufferItem() checks its HashMap
>+           using the ImageBuffer* to find the corresponding RemoteResourceIdentifier.
>+           If it finds it, it will create the DrawImageBuffer item.
>+
>+        The sequence in the GPU Process is the following:
>+
>+        -- When replaying back the DisplayList, DisplayList::Replayer will call
>+           its delegate to check if it wants to apply the DrawImageBuffer.
>+
>+        -- Because RemoteImageBufferProxy inherits DisplayList::Replayer::Delegate,
>+           RemoteImageBufferProxy::apply() will be called.
>+
>+        -- RemoteImageBufferProxy will call RemoteRenderingBackendProxy::applyResourceItem()
>+           which will pass it to its RemoteResourceCacheProxy.
>+
>+        -- RemoteResourceCacheProxy::applyResourceItem() will search for a
>+           RemoteImageBuffer whose RemoteResourceIdentifier matches the one in
>+           DrawImageBuffer. And there is one, it will draws to GraphicsContext.
>+
>+        * platform/graphics/GraphicsContext.cpp:
>+        (WebCore::GraphicsContext::drawImageBuffer):
>+        * platform/graphics/GraphicsContextImpl.h:
>+        * platform/graphics/cairo/GraphicsContextImplCairo.cpp:
>+        (WebCore::GraphicsContextImplCairo::drawImageBuffer):
>+        * platform/graphics/cairo/GraphicsContextImplCairo.h:
>+        * platform/graphics/displaylists/DisplayList.h:
>+        * platform/graphics/displaylists/DisplayListDrawingContext.cpp:
>+        (WebCore::DisplayList::DrawingContext::DrawingContext):
>+        * platform/graphics/displaylists/DisplayListDrawingContext.h:
>+        (WebCore::DisplayList::DrawingContext::DrawingContext):
>+        * platform/graphics/displaylists/DisplayListImageBuffer.h:
>+        (WebCore::DisplayList::ImageBuffer::ImageBuffer):
>+        * platform/graphics/displaylists/DisplayListItems.cpp:
>+        (WebCore::DisplayList::Item::sizeInBytes):
>+        (WebCore::DisplayList::DrawImageBuffer::DrawImageBuffer):
>+        (WebCore::DisplayList::DrawImageBuffer::apply const):
>+        (WebCore::DisplayList::operator<<):
>+        * platform/graphics/displaylists/DisplayListItems.h:
>+        (WebCore::DisplayList::DrawImageBuffer::create):
>+        (WebCore::DisplayList::DrawImageBuffer::remoteResourceIdentifier const):
>+        (WebCore::DisplayList::DrawImageBuffer::source const):
>+        (WebCore::DisplayList::DrawImageBuffer::destinationRect const):
>+        (WebCore::DisplayList::DrawImageBuffer::options const):
>+        (WebCore::DisplayList::DrawImageBuffer::encode const):
>+        (WebCore::DisplayList::DrawImageBuffer::decode):
>+        (WebCore::DisplayList::Item::encode const):
>+        (WebCore::DisplayList::Item::decode):
>+        * platform/graphics/displaylists/DisplaxListRecorder.cpp:
>+        (WebCore::DisplayList::Recorder::Recorder):
>+        (WebCore::DisplayList::Recorder::putImageData):
>+        (WebCore::DisplayList::Recorder::willAppendItem):
>+        (WebCore::DisplayList::Recorder::drawImageBuffer):
>+        * platform/graphics/displaylists/DisplayListRecorder.h:
>+        (WebCore::DisplayList::Recorder::Delegate::~Delegate):
>+        (WebCore::DisplayList::Recorder::Delegate::createDrawImageBufferItem):
>+        (WebCore::DisplayList::Recorder::Observer::~Observer): Deleted.
>+        (WebCore::DisplayList::Recorder::Observer::willAppendItem): Deleted.
>+        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp:
>+        (Nicosia::CairoOperationRecorder::drawImageBuffer):
>+        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h:
>+
>+2020-10-09  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        [GPU Process] Introduce RemoteResourceCacheProxy to manage the resources in the GPU Process
>+        https://bugs.webkit.org/show_bug.cgi?id=217554
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Add a new virtual methods to ImageBuffer which used to be a virtual method
>+        of RemoteImageBufferMessageHandlerProxy. This method is already overridden
>+        by RemoteImageBufferProxy and is called by RemoteResourceCacheProxy. But
>+        RemoteResourceCacheProxy keeps a HashMap of ImageBuffers.
>+
>+        * platform/graphics/ImageBuffer.h:
>+        (WebCore::ImageBuffer::flushDrawingContext):
>+
>+2020-10-09  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        [GPU Process]: Replace "ImageBufferIdentifier" by a generic identifier named "RemoteResourceIdentifier"
>+        https://bugs.webkit.org/show_bug.cgi?id=217550
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        RemoteResourceIdentifier will be used in WebCore when recording drawing
>+        a remote ImageBuffer to another remote ImageBuffer. Eventually it will
>+        be used drawing a remote NativeImage to a remote ImageBuffer or DOM layer.
>+
>+        * Headers.cmake:
>+        * WebCore.xcodeproj/project.pbxproj:
>+        * platform/graphics/RemoteResourceIdentifier.h: Added.
>+
> 2020-10-09  Myles C. Maxfield  <mmaxfield@apple.com>
> 
>         [GPU Process] Mechanical cleanup in DisplayListRecorder
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index a5ba347b1a1fff291dea84123c0466e9a0e6478e..28c12319031de29da015f811260fbafd1399ae6d 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,254 @@
>+2020-10-11  Said Abou-Hallawa  <sabouhallawa@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!).
>+
>+        * GPUProcess/graphics/RemoteRenderingBackendProxy.cpp:
>+        (WebKit::RemoteRenderingBackendProxy::cacheNativeImage):
>+        * GPUProcess/graphics/RemoteRenderingBackendProxy.h:
>+        * GPUProcess/graphics/RemoteRenderingBackendProxy.messages.in:
>+        * GPUProcess/graphics/RemoteResourceCacheProxy.cpp:
>+        (WebKit::RemoteResourceCacheProxy::cacheNativeImage):
>+        (WebKit::RemoteResourceCacheProxy::drawNativeImageItem const):
>+        (WebKit::RemoteResourceCacheProxy::applyResourceItem const):
>+        (WebKit::RemoteResourceCacheProxy::releaseRemoteResource):
>+        * GPUProcess/graphics/RemoteResourceCacheProxy.h:
>+        * WebProcess/GPU/graphics/RemoteImageBuffer.h:
>+        * WebProcess/GPU/graphics/RemoteRenderingBackend.cpp:
>+        (WebKit::RemoteRenderingBackend::createDrawNativeImageItem):
>+        (WebKit::RemoteRenderingBackend::remoteCacheNativeImage):
>+        * WebProcess/GPU/graphics/RemoteRenderingBackend.h:
>+        * WebProcess/GPU/graphics/RemoteResourceCache.cpp:
>+        (WebKit::RemoteResourceCache::createDrawNativeImageItem):
>+        (WebKit::RemoteResourceCache::releaseNativeImage):
>+        (WebKit::RemoteResourceCache::findNativeImageForClient):
>+        * WebProcess/GPU/graphics/RemoteResourceCache.h:
>+
>+2020-10-11  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        [GPU Process] Clean the DisplayList recording of the NativeImage
>+        https://bugs.webkit.org/show_bug.cgi?id=217573
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * Scripts/webkit/messages.py:
>+        * Shared/WebCoreArgumentCoders.cpp:
>+        (IPC::encodeNativeImage):
>+        (IPC::encodeOptionalNativeImage):
>+        (IPC::ArgumentCoder<NativeImagePtr>::encode):
>+        (IPC::ArgumentCoder<NativeImagePtr>::decode):
>+        (IPC::ArgumentCoder<NativeImageHandle>::encode): Deleted.
>+        (IPC::ArgumentCoder<NativeImageHandle>::decode): Deleted.
>+        * Shared/WebCoreArgumentCoders.h:
>+        * Shared/cg/ShareableBitmapCG.cpp:
>+        (WebKit::ShareableBitmap::paint):
>+
>+2020-10-10  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        [GPU Process] Implement DisplayList::DrawImageBuffer item
>+        https://bugs.webkit.org/show_bug.cgi?id=217566
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * GPUProcess/graphics/RemoteImageBufferProxy.h:
>+        (WebKit::RemoteImageBufferProxy::apply):
>+        * GPUProcess/graphics/RemoteRenderingBackendProxy.cpp:
>+        (WebKit::RemoteRenderingBackendProxy::applyResourceItem):
>+        * GPUProcess/graphics/RemoteRenderingBackendProxy.h:
>+        * GPUProcess/graphics/RemoteResourceCacheProxy.cpp:
>+        (WebKit::RemoteResourceCacheProxy::RemoteResourceCacheProxy):
>+        (WebKit::RemoteResourceCacheProxy::drawImageBufferItem const):
>+        (WebKit::RemoteResourceCacheProxy::applyResourceItem const):
>+        * GPUProcess/graphics/RemoteResourceCacheProxy.h:
>+        * WebProcess/GPU/graphics/RemoteImageBuffer.h:
>+        (WebKit::RemoteImageBuffer::~RemoteImageBuffer):
>+        * WebProcess/GPU/graphics/RemoteRenderingBackend.cpp:
>+        (WebKit::RemoteRenderingBackend::createDrawImageBufferItem):
>+        * WebProcess/GPU/graphics/RemoteResourceCache.cpp:
>+        (WebKit::RemoteResourceCache::createDrawImageBufferItem):
>+        * WebProcess/GPU/graphics/RemoteResourceCache.h:
>+
>+2020-10-10  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        [GPU Process] Introduce RemoteResourceCache to manage the remote resources in Web Process
>+        https://bugs.webkit.org/show_bug.cgi?id=217558
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        RemoteResourceCache will be responsible for managing the remote resources
>+        including their actual life cycle in the Web Process side. RemoteRenderingBackend
>+        will be responsible only for the IPC communications with RemoteRenderingBackendProxy.
>+        It will delegate all the resource management to its RemoteResourceCache.
>+
>+        Because RemoteImageBuffer does the communication between WebCore and GPU
>+        Process, RemoteResourceCache will keep two HashMaps to ease the mapping
>+        in both directions:
>+
>+        -- m_remoteImageBufferHashMap maps ImageBuffer* -> RemoteResourceIdentifier
>+        -- m_remoteImageBufferMessageHandlerHashMap maps RemoteResourceIdentifier
>+           -> RemoteImageBufferMessageHandler*
>+
>+        To keep track of the resource referencing, RemoteResourceCache uses another 
>+        map which relates a remote resource with the set of remote drawing clients.
>+        
>+        -- m_remoteResourceClientsHashMap maps RemoteResourceIdentifier ->
>+           HashSet<RemoteResourceIdentifier>
>+
>+        The remote resource has stay alive till their clients replayed back their
>+        DisplayList::Items which reference these resources. Once RemoteResourceCache
>+        is requested to release a remote resource but it finds this resource is
>+        referenced by a set of remote drawing clients, it moves the entry of this
>+        resource from m_remoteResourceClientsHashMap to another HashMap named:
>+
>+        -- m_remoteResourceClientsPendingReleaseHashMap maps RemoteResourceIdentifier
>+           -> HashSet<RemoteResourceIdentifier>
>+
>+        When an entry for a remote resource exists in m_remoteResourceClientsPendingReleaseHashMap 
>+        and no remote client references it anymore, RemoteResourceCache will tell 
>+        GPU Process to release its remote resource as well.
>+
>+        * Sources.txt:
>+        * WebKit.xcodeproj/project.pbxproj:
>+        * WebProcess/GPU/graphics/RemoteImageBuffer.h:
>+        (WebKit::RemoteImageBuffer::~RemoteImageBuffer):
>+        (WebKit::RemoteImageBuffer::remoteResourceIdentifier const):
>+        (WebKit::RemoteImageBuffer::RemoteImageBuffer):
>+        * WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.cpp: Removed.
>+        * WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.h:
>+        (WebKit::RemoteImageBufferMessageHandler::commitFlushContext):
>+        (WebKit::RemoteImageBufferMessageHandler::imageBufferIdentifier const): Deleted.
>+        (): Deleted.
>+        * WebProcess/GPU/graphics/RemoteRenderingBackend.cpp:
>+        (WebKit::RemoteRenderingBackend::createImageBuffer):
>+        (WebKit::RemoteRenderingBackend::releaseImageBuffer):
>+        (WebKit::RemoteRenderingBackend::releaseRemoteClient):
>+        (WebKit::RemoteRenderingBackend::remoteCreateImageBuffer):
>+        (WebKit::RemoteRenderingBackend::remoteGetImageData):
>+        (WebKit::RemoteRenderingBackend::remoteFlushDrawingContext):
>+        (WebKit::RemoteRenderingBackend::remoteFlushDrawingContextAndCommit):
>+        (WebKit::RemoteRenderingBackend::remoteReleaseRemoteResource):
>+        (WebKit::RemoteRenderingBackend::createImageBufferBackend):
>+        (WebKit::RemoteRenderingBackend::commitImageBufferFlushContext):
>+        * WebProcess/GPU/graphics/RemoteRenderingBackend.h:
>+        (WebKit::RemoteRenderingBackend::renderingBackendIdentifier const): Deleted.
>+        * WebProcess/GPU/graphics/RemoteResourceCache.cpp: Added.
>+        (WebKit::RemoteResourceCache::RemoteResourceCache):
>+        (WebKit::RemoteResourceCache::createImageBuffer):
>+        (WebKit::RemoteResourceCache::createImageBufferBackend):
>+        (WebKit::RemoteResourceCache::commitImageBufferFlushContext):
>+        (WebKit::RemoteResourceCache::releaseImageBuffer):
>+        (WebKit::RemoteResourceCache::findImageBufferForClient):
>+        (WebKit::RemoteResourceCache::addRemoteClient):
>+        Links a remote resource with a drawing remote client.
>+
>+        (WebKit::RemoteResourceCache::releaseRemoteResourcePendingRemoveClients):
>+        (WebKit::RemoteResourceCache::removeRemoteClient):
>+        Remove all the entries which includes a certain remote client.
>+
>+        (WebKit::RemoteResourceCache::releaseRemoteClient):
>+        A remote client has done flushing its DrawingContext. It's time to book-
>+        keep the resource referencing and sync up with the GPU side if it has to
>+        release some of the remote resources.
>+
>+        * WebProcess/GPU/graphics/RemoteResourceCache.h: Added.
>+        * WebProcess/Gamepad/WebGamepadProvider.cpp:
>+
>+2020-10-09  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        [GPU Process] Introduce RemoteResourceCacheProxy to manage the resources in the GPU Process
>+        https://bugs.webkit.org/show_bug.cgi?id=217554
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        RemoteResourceCacheProxy will be responsible for managing the remote resources
>+        including their actual life cycle. RemoteRenderingBackendProxy will be 
>+        responsible for the IPC communications with RemoteRenderingBackend. It will
>+        delegate all the resource management to its RemoteResourceCacheProxy.
>+
>+        We can get rid of RemoteImageBufferMessageHandlerProxy because all it does
>+        is sending messages to WebProcess. Removing it will simplify the interface
>+        of RemoteImageBufferProxy. Sending the messages will be moved to
>+        RemoteRenderingBackendProxy.
>+
>+        * GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.cpp: Removed.
>+        * GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.h: Removed.
>+        * GPUProcess/graphics/RemoteImageBufferProxy.h:
>+        (WebKit::RemoteImageBufferProxy::create):
>+        (WebKit::RemoteImageBufferProxy::RemoteImageBufferProxy):
>+        (WebKit::RemoteImageBufferProxy::apply):
>+        * GPUProcess/graphics/RemoteRenderingBackendProxy.cpp:
>+        (WebKit::RemoteRenderingBackendProxy::gpuConnectionToWebProcess const):
>+        (WebKit::RemoteRenderingBackendProxy::remoteCreateImageBufferBackend):
>+        (WebKit::RemoteRenderingBackendProxy::createImageBuffer):
>+        (WebKit::RemoteRenderingBackendProxy::flushImageBufferDrawingContext):
>+        (WebKit::RemoteRenderingBackendProxy::flushImageBufferDrawingContextAndCommit):
>+        (WebKit::RemoteRenderingBackendProxy::getImageData):
>+        (WebKit::RemoteRenderingBackendProxy::releaseRemoteResource):
>+        (WebKit::RemoteRenderingBackendProxy::releaseImageBuffer): Deleted.
>+        * GPUProcess/graphics/RemoteRenderingBackendProxy.h:
>+        * GPUProcess/graphics/RemoteResourceCacheProxy.cpp: Added.
>+        (WebKit::RemoteResourceCacheProxy::RemoteResourceCacheProxy):
>+        (WebKit::RemoteResourceCacheProxy::createImageBuffer):
>+        (WebKit::RemoteResourceCacheProxy::flushDrawingContext):
>+        (WebKit::RemoteResourceCacheProxy::flushDrawingContextAndCommit):
>+        (WebKit::RemoteResourceCacheProxy::getImageData const):
>+        (WebKit::RemoteResourceCacheProxy::releaseRemoteResource):
>+        * GPUProcess/graphics/RemoteResourceCacheProxy.h: Added.
>+        * GPUProcess/webrtc/RemoteMediaRecorder.cpp:
>+        * GPUProcess/webrtc/RemoteSampleBufferDisplayLayerManager.cpp:
>+        * Sources.txt:
>+        * WebKit.xcodeproj/project.pbxproj:
>+
>+2020-10-09  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        [GPU Process]: Replace "ImageBufferIdentifier" by a generic identifier named "RemoteResourceIdentifier"
>+        https://bugs.webkit.org/show_bug.cgi?id=217550
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        GPU Process needs a universal identifier for drawing cached resources and 
>+        drawing buffers and layers. The meaning of RemoteResourceIdentifier will
>+        depend on the context it is used in.
>+
>+        * GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.cpp:
>+        (WebKit::RemoteImageBufferMessageHandlerProxy::RemoteImageBufferMessageHandlerProxy):
>+        (WebKit::RemoteImageBufferMessageHandlerProxy::createBackend):
>+        (WebKit::RemoteImageBufferMessageHandlerProxy::commitFlushContext):
>+        * GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.h:
>+        * GPUProcess/graphics/RemoteImageBufferProxy.h:
>+        (WebKit::RemoteImageBufferProxy::create):
>+        (WebKit::RemoteImageBufferProxy::RemoteImageBufferProxy):
>+        * GPUProcess/graphics/RemoteRenderingBackendProxy.cpp:
>+        (WebKit::RemoteRenderingBackendProxy::createImageBuffer):
>+        (WebKit::RemoteRenderingBackendProxy::releaseRemoteResource):
>+        (WebKit::RemoteRenderingBackendProxy::getImageData):
>+        (WebKit::RemoteRenderingBackendProxy::flushImageBufferDrawingContext):
>+        (WebKit::RemoteRenderingBackendProxy::flushImageBufferDrawingContextAndCommit):
>+        (WebKit::RemoteRenderingBackendProxy::releaseImageBuffer): Deleted.
>+        * GPUProcess/graphics/RemoteRenderingBackendProxy.h:
>+        * GPUProcess/graphics/RemoteRenderingBackendProxy.messages.in:
>+        * Scripts/webkit/messages.py:
>+        * WebKit.xcodeproj/project.pbxproj:
>+        * WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.cpp:
>+        (WebKit::RemoteImageBufferMessageHandler::RemoteImageBufferMessageHandler):
>+        (WebKit::RemoteImageBufferMessageHandler::~RemoteImageBufferMessageHandler):
>+        (WebKit::RemoteImageBufferMessageHandler::getImageData const):
>+        (WebKit::RemoteImageBufferMessageHandler::flushDrawingContext):
>+        (WebKit::RemoteImageBufferMessageHandler::flushDrawingContextAndWaitCommit):
>+        * WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.h:
>+        (WebKit::RemoteImageBufferMessageHandler::remoteResourceIdentifier const):
>+        (WebKit::RemoteImageBufferMessageHandler::imageBufferIdentifier const): Deleted.
>+        * WebProcess/GPU/graphics/RemoteRenderingBackend.cpp:
>+        (WebKit::RemoteRenderingBackend::createImageBuffer):
>+        (WebKit::RemoteRenderingBackend::releaseRemoteResource):
>+        (WebKit::RemoteRenderingBackend::createImageBufferBackend):
>+        (WebKit::RemoteRenderingBackend::commitImageBufferFlushContext):
>+        (WebKit::RemoteRenderingBackend::releaseImageBuffer): Deleted.
>+        * WebProcess/GPU/graphics/RemoteRenderingBackend.h:
>+        * WebProcess/GPU/graphics/RemoteRenderingBackend.messages.in:
>+
> 2020-10-09  Wenson Hsieh  <wenson_hsieh@apple.com>
> 
>         [GPU Process] Add additional support for painting video elements to 2D contexts
>diff --git a/Source/WebCore/Headers.cmake b/Source/WebCore/Headers.cmake
>index a847b05ab44e5cd4a706be308c8b645b525400fe..bf07a25b6a9046e91080f7d41e85d92294c5f744 100644
>--- a/Source/WebCore/Headers.cmake
>+++ b/Source/WebCore/Headers.cmake
>@@ -1194,6 +1194,7 @@ set(WebCore_PRIVATE_FRAMEWORK_HEADERS
>     platform/graphics/MediaPlayerPrivate.h
>     platform/graphics/MediaUsageInfo.h
>     platform/graphics/NativeImage.h
>+    platform/graphics/NativeImagePtr.h
>     platform/graphics/OpenGLESShims.h
>     platform/graphics/OpenGLShims.h
>     platform/graphics/Path.h
>@@ -1207,6 +1208,7 @@ set(WebCore_PRIVATE_FRAMEWORK_HEADERS
>     platform/graphics/PlatformTextTrack.h
>     platform/graphics/PlatformTimeRanges.h
>     platform/graphics/Region.h
>+    platform/graphics/RemoteResourceIdentifier.h
>     platform/graphics/RemoteVideoSample.h
>     platform/graphics/RenderingMode.h
>     platform/graphics/RoundedRect.h
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index 7d61e05b3577304c183c503f831ec89410100021..3fe29f8bce84a24b6976ee0d732ebff45baaed38 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -2007,7 +2007,6 @@
> 		6A72798B1F16C29C003F39B8 /* InspectorShaderProgram.h in Headers */ = {isa = PBXBuildFile; fileRef = 6A7279881F16C29B003F39B8 /* InspectorShaderProgram.h */; };
> 		6B0A07F221FA4B5C00D57391 /* AdClickAttribution.h in Headers */ = {isa = PBXBuildFile; fileRef = 6B0A07F021FA4B5C00D57391 /* AdClickAttribution.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		6B1F48112298A37E00DE8B82 /* CrossSiteNavigationDataTransfer.h in Headers */ = {isa = PBXBuildFile; fileRef = 6B1F480F22989EC400DE8B82 /* CrossSiteNavigationDataTransfer.h */; settings = {ATTRIBUTES = (Private, ); }; };
>-		6B3480940EEF50D400AC1B41 /* NativeImage.h in Headers */ = {isa = PBXBuildFile; fileRef = 6B3480920EEF50D400AC1B41 /* NativeImage.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		6B4D412D23983F88002494C2 /* LoggedInStatus.h in Headers */ = {isa = PBXBuildFile; fileRef = 6B4D412B23983F88002494C2 /* LoggedInStatus.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		6B4E8613221B713F0022F389 /* RegistrableDomain.h in Headers */ = {isa = PBXBuildFile; fileRef = 6B4E8612221B713F0022F389 /* RegistrableDomain.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		6B507A24234BF34100BE7C62 /* NavigatorIsLoggedIn.h in Headers */ = {isa = PBXBuildFile; fileRef = 6B507A21234BF34100BE7C62 /* NavigatorIsLoggedIn.h */; };
>@@ -2161,6 +2160,9 @@
> 		727A7F3A24078B84004D2931 /* ImageBufferIOSurfaceBackend.h in Headers */ = {isa = PBXBuildFile; fileRef = 72BAC3AB23E1E544008D741C /* ImageBufferIOSurfaceBackend.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		7299BC6723D6A53200CC6883 /* AlphaPremultiplication.h in Headers */ = {isa = PBXBuildFile; fileRef = 7299BC6423D686A600CC6883 /* AlphaPremultiplication.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		7299BC6823D6A53E00CC6883 /* RenderingMode.h in Headers */ = {isa = PBXBuildFile; fileRef = 7299BC6623D686C600CC6883 /* RenderingMode.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		729D05302531424300422098 /* RemoteResourceIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 729D052E25313E2600422098 /* RemoteResourceIdentifier.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		729D053C2532EEE300422098 /* NativeImage.h in Headers */ = {isa = PBXBuildFile; fileRef = 55A336F61D8209F40022C4C7 /* NativeImage.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		729D053D2532EF9100422098 /* NativeImagePtr.h in Headers */ = {isa = PBXBuildFile; fileRef = 729D05392532D2E700422098 /* NativeImagePtr.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		72A73BEF245A3F90001C9D03 /* AnimationFrameRate.h in Headers */ = {isa = PBXBuildFile; fileRef = 722A815C238FD50500C00583 /* AnimationFrameRate.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		72BAC3AE23E1F0B0008D741C /* ImageBufferBackend.h in Headers */ = {isa = PBXBuildFile; fileRef = 72BAC3A523E17328008D741C /* ImageBufferBackend.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		7553CFE8108F473F00EA281E /* TimelineRecordFactory.h in Headers */ = {isa = PBXBuildFile; fileRef = 7553CFE6108F473F00EA281E /* TimelineRecordFactory.h */; };
>@@ -9487,7 +9489,6 @@
> 		6B0A07F021FA4B5C00D57391 /* AdClickAttribution.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AdClickAttribution.h; sourceTree = "<group>"; };
> 		6B0A07F121FA4B5C00D57391 /* AdClickAttribution.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = AdClickAttribution.cpp; sourceTree = "<group>"; };
> 		6B1F480F22989EC400DE8B82 /* CrossSiteNavigationDataTransfer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CrossSiteNavigationDataTransfer.h; sourceTree = "<group>"; };
>-		6B3480920EEF50D400AC1B41 /* NativeImage.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = NativeImage.h; sourceTree = "<group>"; };
> 		6B4D412B23983F88002494C2 /* LoggedInStatus.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = LoggedInStatus.h; sourceTree = "<group>"; };
> 		6B4D412C23983F88002494C2 /* LoggedInStatus.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = LoggedInStatus.cpp; sourceTree = "<group>"; };
> 		6B4E8612221B713F0022F389 /* RegistrableDomain.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RegistrableDomain.h; sourceTree = "<group>"; };
>@@ -9923,6 +9924,8 @@
> 		727AFED31A2EA6A0000442E8 /* EXTsRGB.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = EXTsRGB.idl; sourceTree = "<group>"; };
> 		7299BC6423D686A600CC6883 /* AlphaPremultiplication.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AlphaPremultiplication.h; sourceTree = "<group>"; };
> 		7299BC6623D686C600CC6883 /* RenderingMode.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RenderingMode.h; sourceTree = "<group>"; };
>+		729D052E25313E2600422098 /* RemoteResourceIdentifier.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteResourceIdentifier.h; sourceTree = "<group>"; };
>+		729D05392532D2E700422098 /* NativeImagePtr.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = NativeImagePtr.h; sourceTree = "<group>"; };
> 		72BAC3A423E17327008D741C /* ImageBufferBackend.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageBufferBackend.cpp; sourceTree = "<group>"; };
> 		72BAC3A523E17328008D741C /* ImageBufferBackend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageBufferBackend.h; sourceTree = "<group>"; };
> 		72BAC3A623E17328008D741C /* PlatformImageBuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlatformImageBuffer.h; sourceTree = "<group>"; };
>@@ -26220,8 +26223,8 @@
> 				07B93FF923B92AAA0036F8EA /* MIMETypeCache.h */,
> 				314BE3A41B3103FB00141982 /* NamedImageGeneratedImage.cpp */,
> 				314BE3A51B3103FB00141982 /* NamedImageGeneratedImage.h */,
>-				6B3480920EEF50D400AC1B41 /* NativeImage.h */,
> 				55A336F61D8209F40022C4C7 /* NativeImage.h */,
>+				729D05392532D2E700422098 /* NativeImagePtr.h */,
> 				B27535520B053814002CE64F /* Path.cpp */,
> 				B27535530B053814002CE64F /* Path.h */,
> 				A88DD4880B4629B000C02990 /* PathTraversalState.cpp */,
>@@ -26239,6 +26242,7 @@
> 				074E82B918A69F0E007EF54C /* PlatformTimeRanges.h */,
> 				BCAB417F13E356E800D8AAF3 /* Region.cpp */,
> 				BCAB418013E356E800D8AAF3 /* Region.h */,
>+				729D052E25313E2600422098 /* RemoteResourceIdentifier.h */,
> 				073A15512177A39800EA08F2 /* RemoteVideoSample.cpp */,
> 				073A15532177A39A00EA08F2 /* RemoteVideoSample.h */,
> 				7299BC6623D686C600CC6883 /* RenderingMode.h */,
>@@ -33168,7 +33172,8 @@
> 				314BE3A71B3103FB00141982 /* NamedImageGeneratedImage.h in Headers */,
> 				A81872230977D3C0005826D9 /* NamedNodeMap.h in Headers */,
> 				A818721E0977D3C0005826D9 /* NameNodeList.h in Headers */,
>-				6B3480940EEF50D400AC1B41 /* NativeImage.h in Headers */,
>+				729D053C2532EEE300422098 /* NativeImage.h in Headers */,
>+				729D053D2532EF9100422098 /* NativeImagePtr.h in Headers */,
> 				83B2D1751B8BCD6A00A02E47 /* NativeNodeFilter.h in Headers */,
> 				E10B9B6C0B747599003ED890 /* NativeXPathNSResolver.h in Headers */,
> 				93CCF0270AF6C52900018E89 /* NavigationAction.h in Headers */,
>@@ -33541,6 +33546,7 @@
> 				46B9519A207D635400A7D2DD /* RemoteFrame.h in Headers */,
> 				CDC312E922FCD7C0001204EC /* RemotePlayback.h in Headers */,
> 				CDC312EB22FCD7C9001204EC /* RemotePlaybackAvailabilityCallback.h in Headers */,
>+				729D05302531424300422098 /* RemoteResourceIdentifier.h in Headers */,
> 				073A15542177A42600EA08F2 /* RemoteVideoSample.h in Headers */,
> 				D06C0D8F0CFD11460065F43F /* RemoveFormatCommand.h in Headers */,
> 				93309E05099E64920056E581 /* RemoveNodeCommand.h in Headers */,
>diff --git a/Source/WebCore/html/ImageBitmap.cpp b/Source/WebCore/html/ImageBitmap.cpp
>index 439b6a9d7d8120d91e1e1afc56d1aaf6be0b49e4..62f59d692b7f36d699574ad50c818f99973d729b 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 5cc933832574dcbebed82c2c0bce8f00c2bca72e..82d2919c83ca7c40beb3f902f8c6c78bee7ebdcf 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(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 72d59c1ff4845c23275920bc8d12f2734327f72c..8679832a4cc10bc64f7a3e54b259be53fa7128ff 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 ba6445b7ea7ed963d61bff30f28a9a4ed7f9c136..21aaf07f1bb5d53b9294224b644372abd352b013 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(const NativeImagePtr&) { }
>+
>     virtual void didRemoveCachedImageClient(CachedImage&) { }
> 
>     virtual void scheduleRenderingUpdateForImage(CachedImage&) { }
>diff --git a/Source/WebCore/loader/cache/MemoryCache.h b/Source/WebCore/loader/cache/MemoryCache.h
>index a1413c6f679b15e907c7b6cfa7605f270e2f9557..57447ff1af046c648e84d976abf00610bf0028db 100644
>--- a/Source/WebCore/loader/cache/MemoryCache.h
>+++ b/Source/WebCore/loader/cache/MemoryCache.h
>@@ -24,7 +24,6 @@
> 
> #pragma once
> 
>-#include "NativeImage.h"
> #include "SecurityOriginHash.h"
> #include "Timer.h"
> #include <pal/SessionID.h>
>diff --git a/Source/WebCore/platform/graphics/BitmapImage.cpp b/Source/WebCore/platform/graphics/BitmapImage.cpp
>index b476a35b82d93708d3b0f2b4d1a6d254812d0e11..0af6c3d8b2318517789b072345f96743b1d7f6ee 100644
>--- a/Source/WebCore/platform/graphics/BitmapImage.cpp
>+++ b/Source/WebCore/platform/graphics/BitmapImage.cpp
>@@ -28,6 +28,7 @@
> #include "BitmapImage.h"
> 
> #include "FloatRect.h"
>+#include "GeometryUtilities.h"
> #include "GraphicsContext.h"
> #include "ImageBuffer.h"
> #include "ImageObserver.h"
>@@ -204,6 +205,24 @@ bool BitmapImage::notSolidColor()
> }
> #endif // ASSERT_ENABLED
> 
>+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(nativeImage);
>+    if (options.orientation().usesWidthAsHeight())
>+        subsampledImageSize = subsampledImageSize.transposedSize();
>+
>+    // srcRect is in the coordinates of the unsubsampled image, so we have to map it to the subsampled image.
>+    FloatRect adjustedSrcRect = srcRect;
>+    if (subsampledImageSize != srcSize)
>+        adjustedSrcRect = mapRect(srcRect, FloatRect({ }, srcSize), FloatRect({ }, subsampledImageSize));
>+
>+    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)
> {
>     if (destRect.isEmpty() || srcRect.isEmpty())
>@@ -292,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);
> 
>@@ -379,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 555cc664570a34bea995deccd52ac861f5fe3144..7113d7f64e1a7628981fc0996fd68d868526b3d0 100644
>--- a/Source/WebCore/platform/graphics/GraphicsContext.cpp
>+++ b/Source/WebCore/platform/graphics/GraphicsContext.cpp
>@@ -731,6 +731,19 @@ 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, CachedImage* cachedImage)
>+{
>+    if (paintingDisabled())
>+        return;
>+
>+    if (m_impl) {
>+        m_impl->drawNativeImage(image, imageSize, destRect, srcRect, options, cachedImage);
>+        return;
>+    }
>+
>+    platformDrawNativeImage(image, imageSize, destRect, srcRect, options);
>+}
>+
> ImageDrawResult GraphicsContext::drawImage(Image& image, const FloatPoint& destination, const ImagePaintingOptions& imagePaintingOptions)
> {
>     return drawImage(image, FloatRect(destination, image.size()), FloatRect(FloatPoint(), image.size()), imagePaintingOptions);
>@@ -747,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());
>@@ -759,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());
>@@ -772,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) {
>@@ -799,6 +812,9 @@ void GraphicsContext::drawImageBuffer(ImageBuffer& image, const FloatRect& desti
>     if (paintingDisabled())
>         return;
> 
>+    if (m_impl && m_impl->drawImageBuffer(image, destination, source, options))
>+        return;
>+
>     InterpolationQualityMaintainer interpolationQualityForThisScope(*this, options.interpolationQuality());
>     image.draw(*this, destination, source, options);
> }
>diff --git a/Source/WebCore/platform/graphics/GraphicsContext.h b/Source/WebCore/platform/graphics/GraphicsContext.h
>index db4c002eccd22e6fe94087c69f9128d4289927bf..2519d7bea1821987f71ba70f441f2ffb05d2bf01 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;
>@@ -334,10 +335,6 @@ public:
> 
>     const GraphicsContextState& state() const { return m_state; }
> 
>-#if USE(CG) || USE(DIRECT2D) || USE(CAIRO)
>-    WEBCORE_EXPORT void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& = { });
>-#endif
>-
> #if USE(CG) || USE(DIRECT2D)
>     void applyStrokePattern();
>     void applyFillPattern();
>@@ -383,6 +380,8 @@ 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& = { }, 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 });
>     ImageDrawResult drawImage(Image&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& = { ImageOrientation::FromImage });
>@@ -652,6 +651,8 @@ private:
> 
>     void platformFillRoundedRect(const FloatRoundedRect&, const Color&);
> 
>+    void platformDrawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&);
>+
>     FloatRect computeLineBoundsAndAntialiasingModeForText(const FloatRect&, bool printing, Color&);
> 
>     float dashedLineCornerWidthForStrokeWidth(float) const;
>diff --git a/Source/WebCore/platform/graphics/GraphicsContextImpl.h b/Source/WebCore/platform/graphics/GraphicsContextImpl.h
>index 3d5075bcedcbf502871cd550935f51ac8db2f55c..f44d9e543a3944039fe98fe34c083295934c2888 100644
>--- a/Source/WebCore/platform/graphics/GraphicsContextImpl.h
>+++ b/Source/WebCore/platform/graphics/GraphicsContextImpl.h
>@@ -72,9 +72,9 @@ public:
>     virtual ImageDrawResult drawImage(Image&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&) = 0;
>     virtual ImageDrawResult drawTiledImage(Image&, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions&) = 0;
>     virtual ImageDrawResult drawTiledImage(Image&, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions&) = 0;
>-#if USE(CG) || USE(CAIRO) || USE(DIRECT2D)
>-    virtual void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) = 0;
>-#endif
>+
>+    virtual void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&, CachedImage*) = 0;
>+    virtual bool drawImageBuffer(ImageBuffer&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&) = 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/Image.h b/Source/WebCore/platform/graphics/Image.h
>index d39feaa82f371cf8aaf76d27f33573f35198d089..ea4d63a94ed6cf0223fd9ea05088a37bd712d6c6 100644
>--- a/Source/WebCore/platform/graphics/Image.h
>+++ b/Source/WebCore/platform/graphics/Image.h
>@@ -32,8 +32,9 @@
> #include "FloatSize.h"
> #include "GraphicsTypes.h"
> #include "ImageOrientation.h"
>+#include "ImagePaintingOptions.h"
> #include "ImageTypes.h"
>-#include "NativeImage.h"
>+#include "NativeImagePtr.h"
> #include "Timer.h"
> #include <wtf/EnumTraits.h>
> #include <wtf/Optional.h>
>@@ -72,7 +73,6 @@ class FloatSize;
> class GraphicsContext;
> class GraphicsContextImpl;
> class SharedBuffer;
>-struct ImagePaintingOptions;
> struct Length;
> 
> // This class gets notified when an image creates or destroys decoded frames and when it advances animation frames.
>diff --git a/Source/WebCore/platform/graphics/ImageBuffer.h b/Source/WebCore/platform/graphics/ImageBuffer.h
>index d146492c4a8df935caf94b9fb955909aad1cbaf0..dbe025ee9e1a440f02ea9664a34f98a0f6c51a08 100644
>--- a/Source/WebCore/platform/graphics/ImageBuffer.h
>+++ b/Source/WebCore/platform/graphics/ImageBuffer.h
>@@ -33,6 +33,7 @@
> namespace WebCore {
> 
> namespace DisplayList {
>+class DisplayList;
> class DrawingContext;
> }
> 
>@@ -64,6 +65,7 @@ public:
> 
>     virtual DisplayList::DrawingContext* drawingContext() { return nullptr; }
>     virtual void flushDrawingContext() { }
>+    virtual void flushDrawingContext(const DisplayList::DisplayList&) { }
> 
>     virtual AffineTransform baseTransform() const = 0;
>     virtual IntSize logicalSize() const = 0;
>diff --git a/Source/WebCore/platform/graphics/ImageBufferBackend.h b/Source/WebCore/platform/graphics/ImageBufferBackend.h
>index c010a0f0cfcd8c5e7ab6c94c5c3c36f48386d01f..58fc14836d92aa20019f20feedc5571e9ab5e95c 100644
>--- a/Source/WebCore/platform/graphics/ImageBufferBackend.h
>+++ b/Source/WebCore/platform/graphics/ImageBufferBackend.h
>@@ -31,13 +31,14 @@
> #include "GraphicsTypesGL.h"
> #include "ImagePaintingOptions.h"
> #include "IntRect.h"
>-#include "NativeImage.h"
>+#include "NativeImagePtr.h"
> #include "PlatformLayer.h"
> #include <wtf/RefPtr.h>
> #include <wtf/Vector.h>
> 
> namespace WebCore {
> 
>+class GraphicsContext;
> class GraphicsContextGLOpenGL;
> class HostWindow;
> class Image;
>diff --git a/Source/WebCore/platform/graphics/ImageObserver.h b/Source/WebCore/platform/graphics/ImageObserver.h
>index 8b089e594c1afccee4ffb50711597874695cb2de..b4d710ac6730c85dfeea75eab0f3db6676f60f2e 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 775032239a5d5abaa763f7a263ed7cb245982652..45515c59a1ff284cd8d2803837b085b5022d6c09 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/NativeImage.h b/Source/WebCore/platform/graphics/NativeImage.h
>index 6b2d81e35b08cf74f4f361aebc74f3129c7d9b7f..43378790b2291ea00b1208e0a5cbc9729f771d17 100644
>--- a/Source/WebCore/platform/graphics/NativeImage.h
>+++ b/Source/WebCore/platform/graphics/NativeImage.h
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2004, 2005, 2006, 2016 Apple Inc.  All rights reserved.
>+ * Copyright (C) 2004-2020 Apple Inc.  All rights reserved.
>  * Copyright (C) 2007-2008 Torch Mobile, Inc.
>  * Copyright (C) 2012 Company 100 Inc.
>  *
>@@ -27,52 +27,16 @@
> 
> #pragma once
> 
>-#include "ImagePaintingOptions.h"
>-
>-#if USE(CG)
>-#include <wtf/RetainPtr.h>
>-typedef struct CGImage* CGImageRef;
>-#elif USE(CAIRO)
>-#include "RefPtrCairo.h"
>-#elif USE(WINGDI)
>-#include "SharedBitmap.h"
>-#endif
>-
>-#if USE(DIRECT2D)
>-#include "COMPtr.h"
>-#include <d2d1.h>
>-#include <wincodec.h>
>-#endif
>+#include "NativeImagePtr.h"
> 
> namespace WebCore {
> 
> class Color;
>-class FloatRect;
> class IntSize;
>-class GraphicsContext;
>-
>-#if USE(CG)
>-typedef RetainPtr<CGImageRef> NativeImagePtr;
>-#elif USE(DIRECT2D)
>-typedef COMPtr<ID2D1Bitmap> NativeImagePtr;
>-#elif USE(CAIRO)
>-typedef RefPtr<cairo_surface_t> NativeImagePtr;
>-#elif USE(WINGDI)
>-typedef RefPtr<SharedBitmap> NativeImagePtr;
>-#endif
> 
> WEBCORE_EXPORT IntSize nativeImageSize(const NativeImagePtr&);
> bool nativeImageHasAlpha(const NativeImagePtr&);
> Color nativeImageSinglePixelSolidColor(const NativeImagePtr&);
>-
>-void drawNativeImage(const NativeImagePtr&, GraphicsContext&, const FloatRect&, const FloatRect&, const IntSize&, const ImagePaintingOptions&);
>-WEBCORE_EXPORT void drawNativeImage(const NativeImagePtr&, GraphicsContext&, float scaleFactor, const IntPoint& destination, const IntRect& source);
>-
> void clearNativeImageSubimages(const NativeImagePtr&);
>-
>-class NativeImageHandle {
>-public:
>-    NativeImagePtr image;
>-};
>     
> }
>diff --git a/Source/WebCore/platform/graphics/NativeImagePtr.h b/Source/WebCore/platform/graphics/NativeImagePtr.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..3d77a898d398736411174f19f7514071d07c9582
>--- /dev/null
>+++ b/Source/WebCore/platform/graphics/NativeImagePtr.h
>@@ -0,0 +1,49 @@
>+/*
>+ * Copyright (C) 2020 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.
>+ */
>+
>+#pragma once
>+
>+#if USE(CG)
>+#include <wtf/RetainPtr.h>
>+typedef struct CGImage* CGImageRef;
>+#elif USE(CAIRO)
>+#include "RefPtrCairo.h"
>+#elif USE(WINGDI)
>+#include "SharedBitmap.h"
>+#endif
>+
>+namespace WebCore {
>+
>+#if USE(CG)
>+typedef RetainPtr<CGImageRef> NativeImagePtr;
>+#elif USE(DIRECT2D)
>+typedef COMPtr<ID2D1Bitmap> NativeImagePtr;
>+#elif USE(CAIRO)
>+typedef RefPtr<cairo_surface_t> NativeImagePtr;
>+#elif USE(WINGDI)
>+typedef RefPtr<SharedBitmap> NativeImagePtr;
>+#endif
>+
>+}
>diff --git a/Source/WebCore/platform/graphics/RemoteResourceIdentifier.h b/Source/WebCore/platform/graphics/RemoteResourceIdentifier.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..2af542dfec847abc371aa2f1e8e4b8dd9fb110e5
>--- /dev/null
>+++ b/Source/WebCore/platform/graphics/RemoteResourceIdentifier.h
>@@ -0,0 +1,39 @@
>+/*
>+ * Copyright (C) 2020 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. AND ITS CONTRIBUTORS ``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 ITS 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.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(GPU_PROCESS)
>+
>+#include <wtf/ObjectIdentifier.h>
>+
>+namespace WebCore {
>+
>+enum RemoteResourceIdentifierType { };
>+using RemoteResourceIdentifier = ObjectIdentifier<RemoteResourceIdentifierType>;
>+
>+} // namespace WebCore
>+
>+#endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebCore/platform/graphics/cairo/GraphicsContextCairo.cpp b/Source/WebCore/platform/graphics/cairo/GraphicsContextCairo.cpp
>index a104656cb5d5ddea0321daa44a04465175088e4f..2ab9ce3bba25ea5485448f34aa777afe04e734ee 100644
>--- a/Source/WebCore/platform/graphics/cairo/GraphicsContextCairo.cpp
>+++ b/Source/WebCore/platform/graphics/cairo/GraphicsContextCairo.cpp
>@@ -123,16 +123,11 @@ void GraphicsContext::drawRect(const FloatRect& rect, float borderThickness)
>     Cairo::drawRect(*platformContext(), rect, borderThickness, state.fillColor, state.strokeStyle, state.strokeColor);
> }
> 
>-void GraphicsContext::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+void GraphicsContext::platformDrawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
> {
>     if (paintingDisabled())
>         return;
> 
>-    if (m_impl) {
>-        m_impl->drawNativeImage(image, imageSize, destRect, srcRect, options);
>-        return;
>-    }
>-
>     ASSERT(hasPlatformContext());
>     auto& state = this->state();
>     Cairo::drawNativeImage(*platformContext(), image.get(), destRect, srcRect, { options, state.imageInterpolationQuality }, state.alpha, Cairo::ShadowState(state));
>diff --git a/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp b/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp
>index b65b4d64406beb76c409d3e8c654975ca9f7eb63..fe9049527afecedb17b81f62c46e8f271db82768 100644
>--- a/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp
>+++ b/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp
>@@ -279,13 +279,19 @@ ImageDrawResult GraphicsContextImplCairo::drawTiledImage(Image& image, const Flo
>     return GraphicsContextImpl::drawTiledImageImpl(graphicsContext(), image, destination, source, tileScaleFactor, hRule, vRule, imagePaintingOptions);
> }
> 
>-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();
>     Cairo::drawNativeImage(m_platformContext, image.get(), destRect, srcRect, { options, state.imageInterpolationQuality }, state.alpha, Cairo::ShadowState(state));
> }
> 
>+bool GraphicsContextImplCairo::drawImageBuffer(ImageBuffer&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&)
>+{
>+    // FIXME: Not implemented.
>+    return false;
>+}
>+
> void GraphicsContextImplCairo::drawPattern(Image& image, const FloatRect& destRect, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize&, const ImagePaintingOptions& options)
> {
>     if (auto surface = image.nativeImageForCurrentFrame())
>diff --git a/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h b/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h
>index e5e20748c6d7620f10cf2156628ef7e0be601c7b..2c1c70154c1fa466072ce722ff64366f5ae9791d 100644
>--- a/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h
>+++ b/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h
>@@ -74,7 +74,9 @@ public:
>     ImageDrawResult drawImage(Image&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&) override;
>     ImageDrawResult drawTiledImage(Image&, const FloatRect&, const FloatPoint&, const FloatSize&, const FloatSize&, const ImagePaintingOptions&) override;
>     ImageDrawResult drawTiledImage(Image&, const FloatRect&, const FloatRect&, const FloatSize&, Image::TileRule, Image::TileRule, 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;
>+    bool drawImageBuffer(ImageBuffer&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&) 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/cg/GraphicsContextCG.cpp b/Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp
>index ea37c786ef6db6e5afeb917798fa531bf98ac84d..c292db42cc0f9f0f9c47c78ed69c2d8331c98239 100644
>--- a/Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp
>+++ b/Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp
>@@ -280,16 +280,11 @@ void GraphicsContext::restorePlatformState()
>     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
> }
> 
>-void GraphicsContext::drawNativeImage(const RetainPtr<CGImageRef>& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+void GraphicsContext::platformDrawNativeImage(const RetainPtr<CGImageRef>& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
> {
>     if (paintingDisabled())
>         return;
> 
>-    if (m_impl) {
>-        m_impl->drawNativeImage(image, imageSize, destRect, srcRect, options);
>-        return;
>-    }
>-
> #if !LOG_DISABLED
>     MonotonicTime startTime = MonotonicTime::now();
> #endif
>diff --git a/Source/WebCore/platform/graphics/cg/NativeImageCG.cpp b/Source/WebCore/platform/graphics/cg/NativeImageCG.cpp
>index 5cc5c207b44a4835be2e08028a3a71095a55e1e0..400d6ef0a4577d5d7cc5bd9cb646a5badebdadc2 100644
>--- a/Source/WebCore/platform/graphics/cg/NativeImageCG.cpp
>+++ b/Source/WebCore/platform/graphics/cg/NativeImageCG.cpp
>@@ -30,7 +30,6 @@
> 
> #include "Color.h"
> #include "FloatRect.h"
>-#include "GeometryUtilities.h"
> #include "GraphicsContextCG.h"
> #include "IntSize.h"
> #include "SubimageCacheWithTimer.h"
>@@ -69,40 +68,6 @@ Color nativeImageSinglePixelSolidColor(const NativeImagePtr& image)
>     return clampToComponentBytes<SRGBA>(pixel[0] * 255 / pixel[3], pixel[1] * 255 / pixel[3], pixel[2] * 255 / pixel[3], pixel[3]);
> }
> 
>-void drawNativeImage(const NativeImagePtr& image, GraphicsContext& context, 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);
>-    if (options.orientation().usesWidthAsHeight())
>-        subsampledImageSize = subsampledImageSize.transposedSize();
>-
>-    // srcRect is in the coordinates of the unsubsampled image, so we have to map it to the subsampled image.
>-    FloatRect adjustedSrcRect = srcRect;
>-    if (subsampledImageSize != srcSize)
>-        adjustedSrcRect = mapRect(srcRect, FloatRect({ }, srcSize), FloatRect({ }, subsampledImageSize));
>-
>-    context.drawNativeImage(image, subsampledImageSize, destRect, adjustedSrcRect, options);
>-}
>-
>-void drawNativeImage(const NativeImagePtr& image, GraphicsContext& context, float scaleFactor, const IntPoint& destination, const IntRect& source)
>-{
>-    CGContextRef cgContext = context.platformContext();
>-    CGContextSaveGState(cgContext);
>-
>-    CGContextClipToRect(cgContext, CGRectMake(destination.x(), destination.y(), source.width(), source.height()));
>-    CGContextScaleCTM(cgContext, 1, -1);
>-
>-    CGFloat imageHeight = CGImageGetHeight(image.get()) / scaleFactor;
>-    CGFloat imageWidth = CGImageGetWidth(image.get()) / scaleFactor;
>-
>-    CGFloat destX = destination.x() - source.x();
>-    CGFloat destY = -imageHeight - destination.y() + source.y();
>-
>-    CGContextDrawImage(cgContext, CGRectMake(destX, destY, imageWidth, imageHeight), image.get());
>-
>-    CGContextRestoreGState(cgContext);
>-}
>-
> void clearNativeImageSubimages(const NativeImagePtr& image)
> {
> #if CACHE_SUBIMAGES
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayList.h b/Source/WebCore/platform/graphics/displaylists/DisplayList.h
>index a63836921d8dfca16638bd86aa933efa7e264d81..b35893c582e417c2bb3352a516e3cb59fe0243a2 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayList.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayList.h
>@@ -62,8 +62,9 @@ enum class ItemType : uint8_t {
>     DrawImage,
>     DrawTiledImage,
>     DrawTiledScaledImage,
>-#if USE(CG) || USE(CAIRO) || USE(DIRECT2D)
>     DrawNativeImage,
>+#if ENABLE(GPU_PROCESS)
>+    DrawImageBuffer,
> #endif
>     DrawPattern,
>     DrawRect,
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.cpp
>index 23cc07e8ae442bdcea0d3674a5a8551c65cfdc87..d4617d3516f4f3e51d75d64434a6a39457a0001f 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.cpp
>@@ -33,9 +33,9 @@
> namespace WebCore {
> namespace DisplayList {
> 
>-DrawingContext::DrawingContext(const FloatSize& logicalSize, const AffineTransform& initialCTM, Recorder::Observer* observer)
>+DrawingContext::DrawingContext(const FloatSize& logicalSize, const AffineTransform& initialCTM, Recorder::Delegate* delegate)
>     : m_context([&](GraphicsContext& displayListContext) {
>-        return makeUnique<Recorder>(displayListContext, m_displayList, GraphicsContextState(), FloatRect({ }, logicalSize), initialCTM, observer);
>+        return makeUnique<Recorder>(displayListContext, m_displayList, GraphicsContextState(), FloatRect({ }, logicalSize), initialCTM, delegate);
>     })
> {
> }
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.h b/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.h
>index 7b673f32ad815a50081b7e7ab108131717fde543..22ed256e80ad293a052069b743088a1351f47cc0 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.h
>@@ -35,7 +35,7 @@ namespace DisplayList {
> class DrawingContext {
>     WTF_MAKE_FAST_ALLOCATED;
> public:
>-    WEBCORE_EXPORT DrawingContext(const FloatSize& logicalSize, const AffineTransform& initialCTM = { }, Recorder::Observer* = nullptr);
>+    WEBCORE_EXPORT DrawingContext(const FloatSize& logicalSize, const AffineTransform& initialCTM = { }, Recorder::Delegate* = nullptr);
> 
>     GraphicsContext& context() const { return const_cast<DrawingContext&>(*this).m_context; }
>     WEBCORE_EXPORT Recorder& recorder();
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListImageBuffer.h b/Source/WebCore/platform/graphics/displaylists/DisplayListImageBuffer.h
>index 6fd912dfb8fe11c098dd6126a8c878ac6ba7ae02..32599e062d7cf59d1dc2ead01e760d66e3f7ec3c 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListImageBuffer.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListImageBuffer.h
>@@ -32,7 +32,7 @@ namespace WebCore {
> namespace DisplayList {
> 
> template<typename BackendType>
>-class ImageBuffer : public ConcreteImageBuffer<BackendType>, public Recorder::Observer {
>+class ImageBuffer : public ConcreteImageBuffer<BackendType> {
>     using BaseConcreteImageBuffer = ConcreteImageBuffer<BackendType>;
> 
> public:
>@@ -48,12 +48,12 @@ public:
> 
>     ImageBuffer(std::unique_ptr<BackendType>&& dataBackend, const FloatSize& size)
>         : BaseConcreteImageBuffer(WTFMove(dataBackend))
>-        , m_drawingContext(size, initialDrawingContextCTM(size), this)
>+        , m_drawingContext(size, initialDrawingContextCTM(size))
>     {
>     }
> 
>-    ImageBuffer(const FloatSize& size)
>-        : m_drawingContext(size, initialDrawingContextCTM(size), this)
>+    ImageBuffer(const FloatSize& size, Recorder::Delegate* delegate = nullptr)
>+        : m_drawingContext(size, initialDrawingContextCTM(size), delegate)
>     {
>     }
> 
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp
>index 18d70cfbd240985868449fb359a9f85ebdfd3636..f15c770e1da4d51f5fa4661e7c50d7404f34ad08 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp
>@@ -30,7 +30,6 @@
> #include "FontCascade.h"
> #include "ImageData.h"
> #include "MediaPlayer.h"
>-#include "SharedBuffer.h"
> #include <wtf/text/TextStream.h>
> 
> #if USE(CG)
>@@ -106,9 +105,11 @@ size_t Item::sizeInBytes(const Item& item)
>         return sizeof(downcast<DrawTiledImage>(item));
>     case ItemType::DrawTiledScaledImage:
>         return sizeof(downcast<DrawTiledScaledImage>(item));
>-#if USE(CG) || USE(CAIRO)
>     case ItemType::DrawNativeImage:
>         return sizeof(downcast<DrawNativeImage>(item));
>+#if ENABLE(GPU_PROCESS)
>+    case ItemType::DrawImageBuffer:
>+        return sizeof(downcast<DrawImageBuffer>(item));
> #endif
>     case ItemType::DrawPattern:
>         return sizeof(downcast<DrawPattern>(item));
>@@ -703,32 +704,22 @@ static TextStream& operator<<(TextStream& ts, const DrawTiledScaledImage& item)
>     return ts;
> }
> 
>-#if USE(CG) || USE(CAIRO) || USE(DIRECT2D)
>-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)
>-#if USE(CG)
>-    // FIXME: Need to store an image for Cairo.
>     , m_image(image)
>-#endif
>     , m_imageSize(imageSize)
>     , m_destinationRect(destRect)
>     , m_srcRect(srcRect)
>     , m_options(options)
> {
>-#if !USE(CG)
>-    UNUSED_PARAM(image);
>-#endif
> }
> 
> DrawNativeImage::~DrawNativeImage() = default;
> 
> void DrawNativeImage::apply(GraphicsContext& context) const
> {
>-#if USE(CG)
>-    context.drawNativeImage(m_image, m_imageSize, m_destinationRect, m_srcRect, m_options);
>-#else
>-    UNUSED_PARAM(context);
>-#endif
>+    ASSERT(nativeImagePtr());
>+    context.drawNativeImage(nativeImagePtr(), m_imageSize, m_destinationRect, m_srcRect, m_options);
> }
> 
> static TextStream& operator<<(TextStream& ts, const DrawNativeImage& item)
>@@ -739,6 +730,33 @@ static TextStream& operator<<(TextStream& ts, const DrawNativeImage& item)
>     ts.dumpProperty("dest-rect", item.destinationRect());
>     return ts;
> }
>+
>+#if ENABLE(GPU_PROCESS)
>+DrawImageBuffer::DrawImageBuffer(RemoteResourceIdentifier remoteResourceIdentifier, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+    : DrawingItem(ItemType::DrawImageBuffer)
>+    , m_remoteResourceIdentifier(remoteResourceIdentifier)
>+    , m_destinationRect(destRect)
>+    , m_srcRect(srcRect)
>+    , m_options(options)
>+{
>+}
>+
>+DrawImageBuffer::~DrawImageBuffer() = default;
>+
>+void DrawImageBuffer::apply(GraphicsContext&) const
>+{
>+    // Should be handled by the delegate.
>+    ASSERT_NOT_REACHED();
>+}
>+
>+static TextStream& operator<<(TextStream& ts, const DrawImageBuffer& item)
>+{
>+    ts << static_cast<const DrawingItem&>(item);
>+    ts.dumpProperty("remote-resource-identifier", item.remoteResourceIdentifier());
>+    ts.dumpProperty("source-rect", item.source());
>+    ts.dumpProperty("dest-rect", item.destinationRect());
>+    return ts;
>+}
> #endif
> 
> DrawPattern::DrawPattern(Image& image, const FloatRect& destRect, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& options)
>@@ -1469,8 +1487,9 @@ static TextStream& operator<<(TextStream& ts, const ItemType& type)
>     case ItemType::DrawImage: ts << "draw-image"; break;
>     case ItemType::DrawTiledImage: ts << "draw-tiled-image"; break;
>     case ItemType::DrawTiledScaledImage: ts << "draw-tiled-scaled-image"; break;
>-#if USE(CG) || USE(CAIRO)
>     case ItemType::DrawNativeImage: ts << "draw-native-image"; break;
>+#if ENABLE(GPU_PROCESS)
>+    case ItemType::DrawImageBuffer: ts << "draw-image-buffer"; break;
> #endif
>     case ItemType::DrawPattern: ts << "draw-pattern"; break;
>     case ItemType::DrawRect: ts << "draw-rect"; break;
>@@ -1571,10 +1590,13 @@ TextStream& operator<<(TextStream& ts, const Item& item)
>     case ItemType::DrawTiledScaledImage:
>         ts << downcast<DrawTiledScaledImage>(item);
>         break;
>-#if USE(CG) || USE(CAIRO)
>     case ItemType::DrawNativeImage:
>         ts << downcast<DrawNativeImage>(item);
>         break;
>+#if ENABLE(GPU_PROCESS)
>+    case ItemType::DrawImageBuffer:
>+        ts << downcast<DrawImageBuffer>(item);
>+        break;
> #endif
>     case ItemType::DrawPattern:
>         ts << downcast<DrawPattern>(item);
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>index cb684d23ce75b4fab9ec4131627acd32d624aedb..3b64d3ba3407546031ee9bb0caa327659f954d36 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>@@ -35,6 +35,7 @@
> #include "ImageData.h"
> #include "MediaPlayerIdentifier.h"
> #include "Pattern.h"
>+#include "RemoteResourceIdentifier.h"
> #include "SharedBuffer.h"
> #include <wtf/TypeCasts.h>
> 
>@@ -1432,32 +1433,52 @@ Optional<Ref<DrawTiledScaledImage>> DrawTiledScaledImage::decode(Decoder& decode
>     return DrawTiledScaledImage::create(*imageHandle->image, *destination, *source, *tileScaleFactor, hRule, vRule, *imagePaintingOptions);
> }
> 
>-#if USE(CG) || USE(CAIRO) || USE(DIRECT2D)
> class DrawNativeImage : public DrawingItem {
> public:
>-    static Ref<DrawNativeImage> create(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+#if ENABLE(GPU_PROCESS)
>+    using NativeImageType = Variant<NativeImagePtr, RemoteResourceIdentifier>;
>+
>+    RemoteResourceIdentifier remoteResourceIdentifier() const
>+    {
>+        if (!WTF::holds_alternative<RemoteResourceIdentifier>(m_image))
>+            return { };
>+        return WTF::get<RemoteResourceIdentifier>(m_image);
>+    }
>+
>+    NativeImagePtr nativeImagePtr() const
>+    {
>+        if (!WTF::holds_alternative<NativeImagePtr>(m_image))
>+            return nullptr;
>+        return WTF::get<NativeImagePtr>(m_image);
>+    }
>+#else
>+    using NativeImageType = NativeImagePtr;
>+
>+    NativeImagePtr nativeImagePtr() const { return m_image; }
>+#endif
>+    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();
> 
>+    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; }
> 
>-#if USE(CG)
>-    NativeImagePtr m_image;
>-#endif
>+    NativeImageType m_image;
>     FloatSize m_imageSize;
>     FloatRect m_destinationRect;
>     FloatRect m_srcRect;
>@@ -1467,10 +1488,7 @@ private:
> template<class Encoder>
> void DrawNativeImage::encode(Encoder& encoder) const
> {
>-#if USE(CG)
>-    NativeImageHandle handle { m_image };
>-    encoder << handle;
>-#endif
>+    encoder << m_image;
>     encoder << m_imageSize;
>     encoder << m_destinationRect;
>     encoder << m_srcRect;
>@@ -1480,12 +1498,10 @@ void DrawNativeImage::encode(Encoder& encoder) const
> template<class Decoder>
> Optional<Ref<DrawNativeImage>> DrawNativeImage::decode(Decoder& decoder)
> {
>-#if USE(CG)
>-    Optional<NativeImageHandle> handle;
>-    decoder >> handle;
>-    if (!handle)
>+    Optional<NativeImageType> image;
>+    decoder >> image;
>+    if (!image)
>         return WTF::nullopt;
>-#endif
> 
>     Optional<FloatSize> imageSize;
>     decoder >> imageSize;
>@@ -1507,14 +1523,75 @@ Optional<Ref<DrawNativeImage>> DrawNativeImage::decode(Decoder& decoder)
>     if (!options)
>         return WTF::nullopt;
> 
>-#if USE(CG)
>-    NativeImagePtr image = handle->image;
>-#else
>-    NativeImagePtr image = nullptr;
>-#endif
>-    return DrawNativeImage::create(image, *imageSize, *destinationRect, *srcRect, *options);
>+    return DrawNativeImage::create(*image, *imageSize, *destinationRect, *srcRect, *options);
> }
>-#endif
>+
>+#if ENABLE(GPU_PROCESS)
>+class DrawImageBuffer : public DrawingItem {
>+public:
>+    static Ref<DrawImageBuffer> create(RemoteResourceIdentifier remoteResourceIdentifier, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& options)
>+    {
>+        return adoptRef(*new DrawImageBuffer(remoteResourceIdentifier, destination, source, options));
>+    }
>+
>+    WEBCORE_EXPORT virtual ~DrawImageBuffer();
>+
>+    RemoteResourceIdentifier remoteResourceIdentifier() const { return m_remoteResourceIdentifier; }
>+    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<DrawImageBuffer>> decode(Decoder&);
>+
>+private:
>+    WEBCORE_EXPORT DrawImageBuffer(RemoteResourceIdentifier, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&);
>+
>+    void apply(GraphicsContext&) const override;
>+
>+    Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destinationRect; }
>+
>+    RemoteResourceIdentifier m_remoteResourceIdentifier;
>+    FloatRect m_destinationRect;
>+    FloatRect m_srcRect;
>+    ImagePaintingOptions m_options;
>+};
>+
>+template<class Encoder>
>+void DrawImageBuffer::encode(Encoder& encoder) const
>+{
>+    encoder << m_remoteResourceIdentifier;
>+    encoder << m_destinationRect;
>+    encoder << m_srcRect;
>+    encoder << m_options;
>+}
>+
>+template<class Decoder>
>+Optional<Ref<DrawImageBuffer>> DrawImageBuffer::decode(Decoder& decoder)
>+{
>+    Optional<RemoteResourceIdentifier> remoteResourceIdentifier;
>+    decoder >> remoteResourceIdentifier;
>+    if (!remoteResourceIdentifier)
>+        return WTF::nullopt;
>+
>+    Optional<FloatRect> destination;
>+    decoder >> destination;
>+    if (!destination)
>+        return WTF::nullopt;
>+
>+    Optional<FloatRect> source;
>+    decoder >> source;
>+    if (!source)
>+        return WTF::nullopt;
>+
>+    Optional<ImagePaintingOptions> options;
>+    decoder >> options;
>+    if (!options)
>+        return WTF::nullopt;
>+
>+    return DrawImageBuffer::create(*remoteResourceIdentifier, *destination, *source, *options);
>+}
>+#endif // ENABLE(GPU_PROCESS)
> 
> class DrawPattern : public DrawingItem {
> public:
>@@ -2973,10 +3050,13 @@ void Item::encode(Encoder& encoder) const
>     case ItemType::DrawTiledScaledImage:
>         encoder << downcast<DrawTiledScaledImage>(*this);
>         break;
>-#if USE(CG) || USE(CAIRO) || USE(DIRECT2D)
>     case ItemType::DrawNativeImage:
>         encoder << downcast<DrawNativeImage>(*this);
>         break;
>+#if ENABLE(GPU_PROCESS)
>+    case ItemType::DrawImageBuffer:
>+        encoder << downcast<DrawImageBuffer>(*this);
>+        break;
> #endif
>     case ItemType::DrawPattern:
>         encoder << downcast<DrawPattern>(*this);
>@@ -3164,11 +3244,15 @@ Optional<Ref<Item>> Item::decode(Decoder& decoder)
>         if (auto item = DrawTiledScaledImage::decode(decoder))
>             return static_reference_cast<Item>(WTFMove(*item));
>         break;
>-#if USE(CG) || USE(CAIRO) || USE(DIRECT2D)
>     case ItemType::DrawNativeImage:
>         if (auto item = DrawNativeImage::decode(decoder))
>             return static_reference_cast<Item>(WTFMove(*item));
>         break;
>+#if ENABLE(GPU_PROCESS)
>+    case ItemType::DrawImageBuffer:
>+        if (auto item = DrawImageBuffer::decode(decoder))
>+            return static_reference_cast<Item>(WTFMove(*item));
>+        break;
> #endif
>     case ItemType::DrawPattern:
>         if (auto item = DrawPattern::decode(decoder))
>@@ -3326,8 +3410,9 @@ SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawGlyphs)
> SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawImage)
> SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawTiledImage)
> SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawTiledScaledImage)
>-#if USE(CG) || USE(CAIRO)
> SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawNativeImage)
>+#if ENABLE(GPU_PROCESS)
>+SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawImageBuffer)
> #endif
> SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawPattern)
> SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawRect)
>@@ -3388,8 +3473,9 @@ template<> struct EnumTraits<WebCore::DisplayList::ItemType> {
>     WebCore::DisplayList::ItemType::DrawImage,
>     WebCore::DisplayList::ItemType::DrawTiledImage,
>     WebCore::DisplayList::ItemType::DrawTiledScaledImage,
>-#if USE(CG) || USE(CAIRO) || USE(DIRECT2D)
>     WebCore::DisplayList::ItemType::DrawNativeImage,
>+#if ENABLE(GPU_PROCESS)
>+    WebCore::DisplayList::ItemType::DrawImageBuffer,
> #endif
>     WebCore::DisplayList::ItemType::DrawPattern,
>     WebCore::DisplayList::ItemType::DrawRect,
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp
>index dd35ef1a28a9071daef9a0a8d77d98401ea0801d..95575d0f414c2ede5f19102006e36f5d844a4771 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp
>@@ -37,10 +37,10 @@
> namespace WebCore {
> namespace DisplayList {
> 
>-Recorder::Recorder(GraphicsContext& context, DisplayList& displayList, const GraphicsContextState& state, const FloatRect& initialClip, const AffineTransform& initialCTM, Observer* observer)
>+Recorder::Recorder(GraphicsContext& context, DisplayList& displayList, const GraphicsContextState& state, const FloatRect& initialClip, const AffineTransform& initialCTM, Delegate* delegate)
>     : GraphicsContextImpl(context, initialClip, AffineTransform())
>     , m_displayList(displayList)
>-    , m_observer(observer)
>+    , m_delegate(delegate)
> {
>     LOG_WITH_STREAM(DisplayLists, stream << "\nRecording with clip " << initialClip);
>     m_stateStack.append({ state, initialCTM, initialClip });
>@@ -52,15 +52,15 @@ Recorder::~Recorder()
>     LOG(DisplayLists, "Recorded display list:\n%s", m_displayList.description().data());
> }
> 
>-void Recorder::putImageData(WebCore::AlphaPremultiplication inputFormat, const WebCore::ImageData& imageData, const WebCore::IntRect& srcRect, const WebCore::IntPoint& destPoint, WebCore::AlphaPremultiplication destFormat)
>+void Recorder::putImageData(AlphaPremultiplication inputFormat, const ImageData& imageData, const IntRect& srcRect, const IntPoint& destPoint, AlphaPremultiplication destFormat)
> {
>-    appendItem(WebCore::DisplayList::PutImageData::create(inputFormat, imageData, srcRect, destPoint, destFormat));
>+    appendItem(PutImageData::create(inputFormat, imageData, srcRect, destPoint, destFormat));
> }
> 
> void Recorder::willAppendItem(const Item& item)
> {
>-    if (m_observer)
>-        m_observer->willAppendItem(item);
>+    if (m_delegate)
>+        m_delegate->willAppendItem(item);
> 
>     if (item.isDrawingItem()
> #if USE(CG)
>@@ -132,12 +132,29 @@ ImageDrawResult Recorder::drawTiledImage(Image& image, const FloatRect& destinat
>     return ImageDrawResult::DidRecord;
> }
> 
>-#if USE(CG) || USE(CAIRO) || USE(DIRECT2D)
>-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 item = m_delegate->createDrawNativeImageItem(image, imageSize, destRect, srcRect, options, *cachedImage)) {
>+            appendItemAndUpdateExtent(static_reference_cast<DrawingItem>(item.releaseNonNull()));
>+            return;
>+        }
>+    }
>     appendItemAndUpdateExtent(DrawNativeImage::create(image, imageSize, destRect, srcRect, options));
> }
>-#endif
>+
>+bool Recorder::drawImageBuffer(ImageBuffer& image, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& options)
>+{
>+    if (!m_delegate)
>+        return false;
>+
>+    if (auto item = m_delegate->createDrawImageBufferItem(image, destination, source, options)) {
>+        appendItemAndUpdateExtent(static_reference_cast<DrawingItem>(item.releaseNonNull()));
>+        return true;
>+    }
>+
>+    return false;
>+}
> 
> void Recorder::drawPattern(Image& image, const FloatRect& destRect, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& options)
> {
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h
>index 9ee1d3938f232f3f18d978af718701d8be463072..e140be11d7d6a76667961569d145c4e3385c3ed7 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;
>@@ -53,8 +55,8 @@ class Recorder : public GraphicsContextImpl {
>     WTF_MAKE_FAST_ALLOCATED;
>     WTF_MAKE_NONCOPYABLE(Recorder);
> public:
>-    class Observer;
>-    WEBCORE_EXPORT Recorder(GraphicsContext&, DisplayList&, const GraphicsContextState&, const FloatRect& initialClip, const AffineTransform&, Observer* = nullptr);
>+    class Delegate;
>+    WEBCORE_EXPORT Recorder(GraphicsContext&, DisplayList&, const GraphicsContextState&, const FloatRect& initialClip, const AffineTransform&, Delegate* = nullptr);
>     WEBCORE_EXPORT virtual ~Recorder();
> 
>     WEBCORE_EXPORT void putImageData(AlphaPremultiplication inputFormat, const ImageData&, const IntRect& srcRect, const IntPoint& destPoint, AlphaPremultiplication destFormat);
>@@ -63,9 +65,11 @@ public:
> 
>     void appendItemAndUpdateExtent(Ref<DrawingItem>&&);
> 
>-    class Observer {
>+    class Delegate {
>     public:
>-        virtual ~Observer() { }
>+        virtual ~Delegate() { }
>+        virtual RefPtr<Item> createDrawImageBufferItem(ImageBuffer&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&) { return nullptr; }
>+        virtual RefPtr<Item> createDrawNativeImageItem(const NativeImagePtr&, const FloatSize&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&, CachedImage&) { return nullptr; }
>         virtual void willAppendItem(const Item&) { };
>     };
> 
>@@ -104,9 +108,9 @@ private:
>     ImageDrawResult drawImage(Image&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&) override;
>     ImageDrawResult drawTiledImage(Image&, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions&) override;
>     ImageDrawResult drawTiledImage(Image&, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions&) override;
>-#if USE(CG) || USE(CAIRO) || USE(DIRECT2D)
>-    void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) override;
>-#endif
>+
>+    void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&, CachedImage*) override;
>+    bool drawImageBuffer(ImageBuffer&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&) 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;
>@@ -188,7 +192,7 @@ private:
>     ContextState& currentState();
> 
>     DisplayList& m_displayList;
>-    Observer* m_observer;
>+    Delegate* m_delegate;
> 
>     Vector<ContextState, 32> m_stateStack;
> };
>diff --git a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h
>index f31d375b02da0979289acc200dd862fae134104b..4b5e3e43b03964a51c273e5be7aedb0df1aa91f7 100644
>--- a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h
>+++ b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h
>@@ -28,6 +28,7 @@
> 
> #include "GStreamerCommon.h"
> #include "GStreamerEMEUtilities.h"
>+#include "ImageOrientation.h"
> #include "Logging.h"
> #include "MainThreadNotifier.h"
> #include "MediaPlayerPrivate.h"
>diff --git a/Source/WebCore/platform/graphics/nicosia/NicosiaImageBufferPipe.cpp b/Source/WebCore/platform/graphics/nicosia/NicosiaImageBufferPipe.cpp
>index 18b4f8de97170ce644eb64be3eab857f3a7432f4..6298cf36073c7ae44f43c6b564422b37b86cf107 100644
>--- a/Source/WebCore/platform/graphics/nicosia/NicosiaImageBufferPipe.cpp
>+++ b/Source/WebCore/platform/graphics/nicosia/NicosiaImageBufferPipe.cpp
>@@ -28,6 +28,7 @@
> #include "ImageBuffer.h"
> 
> #include "ImageBufferPipe.h"
>+#include "NativeImage.h"
> #include "NicosiaContentLayerTextureMapperImpl.h"
> #include "NicosiaPlatformLayer.h"
> #include "TextureMapperPlatformLayerBuffer.h"
>diff --git a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp
>index 304facbab1521791daa86db1531753e38671084d..4e24eebadb6587bac62a1f15d51f6f876cdbb48e 100644
>--- a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp
>+++ b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp
>@@ -570,6 +570,12 @@ void CairoOperationRecorder::drawNativeImage(const NativeImagePtr& image, const
>     append(createCommand<DrawNativeImage>(RefPtr<cairo_surface_t>(image.get()), destRect, srcRect, ImagePaintingOptions(options, state.imageInterpolationQuality), state.alpha, Cairo::ShadowState(state)));
> }
> 
>+bool CairoOperationRecorder::drawImageBuffer(ImageBuffer&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&)
>+{
>+    // FIXME: Not implemented.
>+    return false;
>+}
>+
> void CairoOperationRecorder::drawPattern(Image& image, const FloatRect& destRect, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& options)
> {
>     struct DrawPattern final : PaintingOperation, OperationData<RefPtr<cairo_surface_t>, IntSize, FloatRect, FloatRect, AffineTransform, FloatPoint, ImagePaintingOptions> {
>diff --git a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h
>index 572ff2166f6e973a763b67cb6bb96f43f26a8d50..38093d4135b4d7b6511a16087aff13f603ed13ba 100644
>--- a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h
>+++ b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h
>@@ -67,6 +67,8 @@ private:
>     WebCore::ImageDrawResult drawImage(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::ImagePaintingOptions&) override;
>     WebCore::ImageDrawResult drawTiledImage(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatPoint&, const WebCore::FloatSize&, const WebCore::FloatSize&, const WebCore::ImagePaintingOptions&) override;
>     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 drawPattern(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::AffineTransform&, const WebCore::FloatPoint&, const WebCore::FloatSize&, const WebCore::ImagePaintingOptions&) override;
> 
>diff --git a/Source/WebCore/platform/graphics/win/GraphicsContextDirect2D.cpp b/Source/WebCore/platform/graphics/win/GraphicsContextDirect2D.cpp
>index 374071715bcb791d589d50d99b29c66b010b7081..57ba858ff99c2db29f5d91492e6aac8ed974ec99 100644
>--- a/Source/WebCore/platform/graphics/win/GraphicsContextDirect2D.cpp
>+++ b/Source/WebCore/platform/graphics/win/GraphicsContextDirect2D.cpp
>@@ -207,16 +207,11 @@ void GraphicsContext::restorePlatformState()
>     Direct2D::restore(*platformContext());
> }
> 
>-void GraphicsContext::drawNativeImage(const COMPtr<ID2D1Bitmap>& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+void GraphicsContext::platformDrawNativeImage(const COMPtr<ID2D1Bitmap>& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
> {
>     if (paintingDisabled())
>         return;
> 
>-    if (m_impl) {
>-        m_impl->drawNativeImage(image, imageSize, destRect, srcRect, options);
>-        return;
>-    }
>-
>     ASSERT(hasPlatformContext());
>     auto& state = this->state();
>     Direct2D::drawNativeImage(*platformContext(), image.get(), imageSize, destRect, srcRect, options, state.alpha, Direct2D::ShadowState(state));
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.cpp b/Source/WebKit/GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.cpp
>deleted file mode 100644
>index 3e247a7ad4cd29538e4eaf40bd80369686008b86..0000000000000000000000000000000000000000
>--- a/Source/WebKit/GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.cpp
>+++ /dev/null
>@@ -1,55 +0,0 @@
>-/*
>- * Copyright (C) 2020 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. AND ITS CONTRIBUTORS ``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 ITS 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 "config.h"
>-#include "RemoteImageBufferMessageHandlerProxy.h"
>-
>-#if ENABLE(GPU_PROCESS)
>-
>-#include "RemoteRenderingBackendMessages.h"
>-#include "RemoteRenderingBackendProxy.h"
>-
>-namespace WebKit {
>-using namespace WebCore;
>-
>-RemoteImageBufferMessageHandlerProxy::RemoteImageBufferMessageHandlerProxy(RemoteRenderingBackendProxy& remoteRenderingBackendProxy, ImageBufferIdentifier imageBufferIdentifier)
>-    : m_remoteRenderingBackendProxy(remoteRenderingBackendProxy)
>-    , m_imageBufferIdentifier(imageBufferIdentifier)
>-{
>-}
>-
>-void RemoteImageBufferMessageHandlerProxy::createBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, ImageBufferBackendHandle handle)
>-{
>-    m_remoteRenderingBackendProxy.send(Messages::RemoteRenderingBackend::CreateImageBufferBackend(logicalSize, backendSize, resolutionScale, colorSpace, WTFMove(handle), m_imageBufferIdentifier), m_remoteRenderingBackendProxy.renderingBackendIdentifier());
>-}
>-
>-void RemoteImageBufferMessageHandlerProxy::commitFlushContext(ImageBufferFlushIdentifier flushIdentifier)
>-{
>-    m_remoteRenderingBackendProxy.send(Messages::RemoteRenderingBackend::CommitImageBufferFlushContext(flushIdentifier, m_imageBufferIdentifier), m_remoteRenderingBackendProxy.renderingBackendIdentifier());
>-}
>-
>-} // namespace WebKit
>-
>-#endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.h b/Source/WebKit/GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.h
>deleted file mode 100644
>index a4d05eaef549416fdb6425952e0b4cf3aa205ec2..0000000000000000000000000000000000000000
>--- a/Source/WebKit/GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.h
>+++ /dev/null
>@@ -1,71 +0,0 @@
>-/*
>- * Copyright (C) 2020 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.
>- */
>-
>-#pragma once
>-
>-#if ENABLE(GPU_PROCESS)
>-
>-#include "ImageBufferBackendHandle.h"
>-#include "ImageBufferFlushIdentifier.h"
>-#include "ImageBufferIdentifier.h"
>-#include <WebCore/ColorSpace.h>
>-#include <WebCore/DisplayList.h>
>-#include <WebCore/FloatSize.h>
>-
>-namespace WebCore {
>-enum class AlphaPremultiplication : uint8_t;
>-class ImageData;
>-}
>-
>-namespace WebKit {
>-
>-class RemoteRenderingBackendProxy;
>-
>-class RemoteImageBufferMessageHandlerProxy {
>-public:
>-    virtual ~RemoteImageBufferMessageHandlerProxy() = default;
>-
>-    // Messages to be received. See RemoteRenderingBackendProxy.messages.in.
>-    virtual void flushDrawingContext(const WebCore::DisplayList::DisplayList&) = 0;
>-    virtual void flushDrawingContextAndCommit(const WebCore::DisplayList::DisplayList&, ImageBufferFlushIdentifier) = 0;
>-    virtual RefPtr<WebCore::ImageData> getImageData(WebCore::AlphaPremultiplication outputFormat, const WebCore::IntRect& srcRect) const = 0;
>-
>-protected:
>-    RemoteImageBufferMessageHandlerProxy(RemoteRenderingBackendProxy&, ImageBufferIdentifier);
>-
>-    // Messages to be sent. See RemoteRenderingBackend.messages.in.
>-    void createBackend(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle);
>-    void commitFlushContext(ImageBufferFlushIdentifier);
>-
>-    RemoteRenderingBackendProxy& backend() { return m_remoteRenderingBackendProxy; }
>-
>-private:
>-    RemoteRenderingBackendProxy& m_remoteRenderingBackendProxy;
>-    ImageBufferIdentifier m_imageBufferIdentifier;
>-};
>-
>-} // namespace WebKit
>-
>-#endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteImageBufferProxy.h b/Source/WebKit/GPUProcess/graphics/RemoteImageBufferProxy.h
>index 7721cce8456269aef9020b8bd8965dd35b722ddc..1d1b5ee8fcf07efc329d7981f3b0a1ac2efbe71c 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteImageBufferProxy.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteImageBufferProxy.h
>@@ -28,29 +28,29 @@
> #if ENABLE(GPU_PROCESS)
> 
> #include "GPUConnectionToWebProcess.h"
>-#include "RemoteImageBufferMessageHandlerProxy.h"
> #include <WebCore/ConcreteImageBuffer.h>
> #include <WebCore/DisplayListReplayer.h>
> 
> namespace WebKit {
> 
> template<typename BackendType>
>-class RemoteImageBufferProxy : public WebCore::ConcreteImageBuffer<BackendType>, public RemoteImageBufferMessageHandlerProxy, public WebCore::DisplayList::Replayer::Delegate {
>+class RemoteImageBufferProxy : public WebCore::ConcreteImageBuffer<BackendType>, public WebCore::DisplayList::Replayer::Delegate {
>     using BaseConcreteImageBuffer = WebCore::ConcreteImageBuffer<BackendType>;
>     using BaseConcreteImageBuffer::context;
>     using BaseConcreteImageBuffer::m_backend;
>+    using BaseConcreteImageBuffer::putImageData;
> 
> public:
>-    static auto create(const WebCore::FloatSize& size, float resolutionScale, WebCore::ColorSpace colorSpace, RemoteRenderingBackendProxy& remoteRenderingBackendProxy, ImageBufferIdentifier imageBufferIdentifier)
>+    static auto create(const WebCore::FloatSize& size, float resolutionScale, WebCore::ColorSpace colorSpace, RemoteRenderingBackendProxy& remoteRenderingBackendProxy, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
>     {
>-        return BaseConcreteImageBuffer::template create<RemoteImageBufferProxy>(size, resolutionScale, colorSpace, nullptr, remoteRenderingBackendProxy, imageBufferIdentifier);
>+        return BaseConcreteImageBuffer::template create<RemoteImageBufferProxy>(size, resolutionScale, colorSpace, nullptr, remoteRenderingBackendProxy, remoteResourceIdentifier);
>     }
> 
>-    RemoteImageBufferProxy(std::unique_ptr<BackendType>&& backend, RemoteRenderingBackendProxy& remoteRenderingBackendProxy, ImageBufferIdentifier imageBufferIdentifier)
>+    RemoteImageBufferProxy(std::unique_ptr<BackendType>&& backend, RemoteRenderingBackendProxy& remoteRenderingBackendProxy, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
>         : BaseConcreteImageBuffer(WTFMove(backend))
>-        , RemoteImageBufferMessageHandlerProxy(remoteRenderingBackendProxy, imageBufferIdentifier)
>+        , m_remoteRenderingBackendProxy(remoteRenderingBackendProxy)
>     {
>-        createBackend(m_backend->logicalSize(), m_backend->backendSize(), m_backend->resolutionScale(), m_backend->colorSpace(), m_backend->createImageBufferBackendHandle());
>+        m_remoteRenderingBackendProxy.remoteCreateImageBufferBackend(m_backend->logicalSize(), m_backend->backendSize(), m_backend->resolutionScale(), m_backend->colorSpace(), m_backend->createImageBufferBackendHandle(), remoteResourceIdentifier);
>     }
> 
>     ~RemoteImageBufferProxy()
>@@ -62,9 +62,6 @@ public:
>     }
> 
> private:
>-    using BaseConcreteImageBuffer::flushDrawingContext;
>-    using BaseConcreteImageBuffer::putImageData;
>-
>     void flushDrawingContext(const WebCore::DisplayList::DisplayList& displayList) override
>     {
>         if (displayList.itemCount()) {
>@@ -73,18 +70,6 @@ private:
>         }
>     }
> 
>-    void flushDrawingContextAndCommit(const WebCore::DisplayList::DisplayList& displayList, ImageBufferFlushIdentifier flushIdentifier) override
>-    {
>-        flushDrawingContext(displayList);
>-        m_backend->flushContext();
>-        commitFlushContext(flushIdentifier);
>-    }
>-
>-    RefPtr<WebCore::ImageData> getImageData(WebCore::AlphaPremultiplication outputFormat, const WebCore::IntRect& srcRect) const override
>-    {
>-        return BaseConcreteImageBuffer::getImageData(outputFormat, srcRect);
>-    }
>-
>     bool apply(WebCore::DisplayList::Item& item, WebCore::GraphicsContext& context) override
>     {
>         if (item.type() == WebCore::DisplayList::ItemType::PutImageData) {
>@@ -98,12 +83,12 @@ private:
>             return true;
>         }
> 
>-        return false;
>+        return m_remoteRenderingBackendProxy.applyResourceItem(item, context);
>     }
> 
>     void apply(WebCore::DisplayList::PaintFrameForMedia& item, WebCore::GraphicsContext& context)
>     {
>-        auto process = backend().gpuConnectionToWebProcess();
>+        auto process = m_remoteRenderingBackendProxy.gpuConnectionToWebProcess();
>         if (!process)
>             return;
> 
>@@ -117,6 +102,8 @@ private:
> 
>         context.paintFrameForMedia(*player, item.destination());
>     }
>+
>+    RemoteRenderingBackendProxy& m_remoteRenderingBackendProxy;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.cpp b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.cpp
>index 753a5c8ba97fe720831058e84c5cd83b4b175579..c1a31cbc94b606b50d41f99c5022704deaed7391 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.cpp
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.cpp
>@@ -29,7 +29,7 @@
> #if ENABLE(GPU_PROCESS)
> 
> #include "GPUConnectionToWebProcess.h"
>-#include "PlatformRemoteImageBufferProxy.h"
>+#include "RemoteRenderingBackendMessages.h"
> #include "RemoteRenderingBackendProxyMessages.h"
> 
> namespace WebKit {
>@@ -54,6 +54,11 @@ RemoteRenderingBackendProxy::~RemoteRenderingBackendProxy()
>         gpuConnectionToWebProcess->messageReceiverMap().removeMessageReceiver(Messages::RemoteRenderingBackendProxy::messageReceiverName(), m_renderingBackendIdentifier.toUInt64());
> }
> 
>+GPUConnectionToWebProcess* RemoteRenderingBackendProxy::gpuConnectionToWebProcess() const
>+{
>+    return m_gpuConnectionToWebProcess.get();
>+}
>+
> IPC::Connection* RemoteRenderingBackendProxy::messageSenderConnection() const
> {
>     if (auto* gpuConnectionToWebProcess = m_gpuConnectionToWebProcess.get())
>@@ -66,64 +71,46 @@ uint64_t RemoteRenderingBackendProxy::messageSenderDestinationID() const
>     return m_renderingBackendIdentifier.toUInt64();
> }
> 
>-void RemoteRenderingBackendProxy::createImageBuffer(const FloatSize& logicalSize, RenderingMode renderingMode, float resolutionScale, ColorSpace colorSpace, ImageBufferIdentifier imageBufferIdentifier)
>+bool RemoteRenderingBackendProxy::applyResourceItem(DisplayList::Item& item, GraphicsContext& context)
> {
>-    auto* gpuConnectionToWebProcess = m_gpuConnectionToWebProcess.get();
>-    if (!gpuConnectionToWebProcess)
>-        return;
>-
>-    if (m_imageBufferMessageHandlerMap.contains(imageBufferIdentifier)) {
>-        ASSERT_NOT_REACHED();
>-        return;
>-    }
>-
>-    if (renderingMode == RenderingMode::RemoteAccelerated) {
>-        if (auto imageBuffer = AcceleratedRemoteImageBufferProxy::create(logicalSize, resolutionScale, colorSpace, *this, imageBufferIdentifier)) {
>-            m_imageBufferMessageHandlerMap.add(imageBufferIdentifier, WTFMove(imageBuffer));
>-            return;
>-        }
>-    }
>-
>-    if (renderingMode == RenderingMode::RemoteAccelerated || renderingMode == RenderingMode::RemoteUnaccelerated) {
>-        if (auto imageBuffer = UnacceleratedRemoteImageBufferProxy::create(logicalSize, resolutionScale, colorSpace, *this, imageBufferIdentifier)) {
>-            m_imageBufferMessageHandlerMap.add(imageBufferIdentifier, WTFMove(imageBuffer));
>-            return;
>-        }
>-    }
>-
>-    ASSERT_NOT_REACHED();
>+    return m_remoteResourceCacheProxy.applyResourceItem(item, context);
> }
> 
>-void RemoteRenderingBackendProxy::releaseImageBuffer(ImageBufferIdentifier imageBufferIdentifier)
>+void RemoteRenderingBackendProxy::remoteCreateImageBufferBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, ImageBufferBackendHandle handle, RemoteResourceIdentifier remoteResourceIdentifier)
> {
>-    // CreateImageBuffer message should have been received before this one.
>-    bool found = m_imageBufferMessageHandlerMap.remove(imageBufferIdentifier);
>-    ASSERT_UNUSED(found, found);
>+    send(Messages::RemoteRenderingBackend::CreateImageBufferBackend(logicalSize, backendSize, resolutionScale, colorSpace, WTFMove(handle), remoteResourceIdentifier), m_renderingBackendIdentifier);
> }
> 
>-void RemoteRenderingBackendProxy::getImageData(WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, ImageBufferIdentifier imageBufferIdentifier, CompletionHandler<void(IPC::ImageDataReference&&)>&& completionHandler)
>+void RemoteRenderingBackendProxy::createImageBuffer(const FloatSize& logicalSize, RenderingMode renderingMode, float resolutionScale, ColorSpace colorSpace, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
> {
>-    if (auto imageBuffer = m_imageBufferMessageHandlerMap.get(imageBufferIdentifier)) {
>-        auto imageData = imageBuffer->getImageData(outputFormat, srcRect);
>-        completionHandler(IPC::ImageDataReference(WTFMove(imageData)));
>-    }
>+    m_remoteResourceCacheProxy.createImageBuffer(logicalSize, renderingMode, resolutionScale, colorSpace, remoteResourceIdentifier);
> }
> 
>-void RemoteRenderingBackendProxy::flushImageBufferDrawingContext(const WebCore::DisplayList::DisplayList& displayList, ImageBufferIdentifier imageBufferIdentifier)
>+void RemoteRenderingBackendProxy::flushImageBufferDrawingContext(const WebCore::DisplayList::DisplayList& displayList, RemoteResourceIdentifier remoteResourceIdentifier)
> {
>-    if (auto imageBuffer = m_imageBufferMessageHandlerMap.get(imageBufferIdentifier))
>-        imageBuffer->flushDrawingContext(displayList);
>+    m_remoteResourceCacheProxy.flushDrawingContext(displayList, remoteResourceIdentifier);
> }
> 
>-void RemoteRenderingBackendProxy::flushImageBufferDrawingContextAndCommit(const WebCore::DisplayList::DisplayList& displayList, ImageBufferFlushIdentifier flushIdentifier, ImageBufferIdentifier imageBufferIdentifier)
>+void RemoteRenderingBackendProxy::flushImageBufferDrawingContextAndCommit(const WebCore::DisplayList::DisplayList& displayList, ImageBufferFlushIdentifier flushIdentifier, RemoteResourceIdentifier remoteResourceIdentifier)
> {
>-    if (auto imageBuffer = m_imageBufferMessageHandlerMap.get(imageBufferIdentifier))
>-        imageBuffer->flushDrawingContextAndCommit(displayList, flushIdentifier);
>+    m_remoteResourceCacheProxy.flushDrawingContextAndCommit(displayList, remoteResourceIdentifier);
>+    send(Messages::RemoteRenderingBackend::CommitImageBufferFlushContext(flushIdentifier, remoteResourceIdentifier), m_renderingBackendIdentifier);
> }
> 
>-GPUConnectionToWebProcess* RemoteRenderingBackendProxy::gpuConnectionToWebProcess() const
>+void RemoteRenderingBackendProxy::getImageData(WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, RemoteResourceIdentifier remoteResourceIdentifier, CompletionHandler<void(IPC::ImageDataReference&&)>&& completionHandler)
> {
>-    return m_gpuConnectionToWebProcess.get();
>+    auto imageData = m_remoteResourceCacheProxy.getImageData(outputFormat, srcRect, remoteResourceIdentifier);
>+    completionHandler(IPC::ImageDataReference(WTFMove(imageData)));
>+}
>+
>+void RemoteRenderingBackendProxy::cacheNativeImage(const NativeImagePtr& image, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    m_remoteResourceCacheProxy.cacheNativeImage(image, remoteResourceIdentifier);
>+}
>+
>+void RemoteRenderingBackendProxy::releaseRemoteResource(RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    m_remoteResourceCacheProxy.releaseRemoteResource(remoteResourceIdentifier);
> }
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.h b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.h
>index a0952bafb3c1532d7dc99006eb40f31bf91d253b..af96262dc307b347eb2adefd0375a5f47b326c95 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.h
>@@ -28,24 +28,24 @@
> #if ENABLE(GPU_PROCESS)
> 
> #include "Connection.h"
>+#include "ImageBufferBackendHandle.h"
> #include "ImageBufferFlushIdentifier.h"
>-#include "ImageBufferIdentifier.h"
> #include "ImageDataReference.h"
> #include "MessageReceiver.h"
> #include "MessageSender.h"
>-#include "RemoteImageBufferMessageHandlerProxy.h"
>+#include "RemoteResourceCacheProxy.h"
> #include "RenderingBackendIdentifier.h"
> #include <WebCore/ColorSpace.h>
> #include <WebCore/DisplayListItems.h>
>-#include <WebCore/FloatSize.h>
>-#include <WebCore/RenderingMode.h>
>-#include <wtf/HashMap.h>
> #include <wtf/WeakPtr.h>
> 
> namespace WebCore {
> namespace DisplayList {
> class DisplayList;
> }
>+class FloatSize;
>+enum class ColorSpace : uint8_t;
>+enum class RenderingMode : uint8_t;
> }
> 
> namespace WebKit {
>@@ -59,8 +59,11 @@ public:
>     static std::unique_ptr<RemoteRenderingBackendProxy> create(GPUConnectionToWebProcess&, RenderingBackendIdentifier);
>     virtual ~RemoteRenderingBackendProxy();
> 
>-    RenderingBackendIdentifier renderingBackendIdentifier() const { return m_renderingBackendIdentifier; }
>     GPUConnectionToWebProcess* gpuConnectionToWebProcess() const;
>+    bool applyResourceItem(WebCore::DisplayList::Item&, WebCore::GraphicsContext&);
>+
>+    // Messages to be sent.
>+    void remoteCreateImageBufferBackend(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle, WebCore::RemoteResourceIdentifier);
> 
> private:
>     RemoteRenderingBackendProxy(GPUConnectionToWebProcess&, RenderingBackendIdentifier);
>@@ -74,14 +77,14 @@ private:
>     void didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, std::unique_ptr<IPC::Encoder>&) override;
> 
>     // Messages to be received.
>-    void createImageBuffer(const WebCore::FloatSize& logicalSize, WebCore::RenderingMode, float resolutionScale, WebCore::ColorSpace, ImageBufferIdentifier);
>-    void releaseImageBuffer(ImageBufferIdentifier);
>-    void flushImageBufferDrawingContext(const WebCore::DisplayList::DisplayList&, ImageBufferIdentifier);
>-    void flushImageBufferDrawingContextAndCommit(const WebCore::DisplayList::DisplayList&, ImageBufferFlushIdentifier, ImageBufferIdentifier);
>-    void getImageData(WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, ImageBufferIdentifier, CompletionHandler<void(IPC::ImageDataReference&&)>&&);
>-
>-    using ImageBufferMessageHandlerMap = HashMap<ImageBufferIdentifier, std::unique_ptr<RemoteImageBufferMessageHandlerProxy>>;
>-    ImageBufferMessageHandlerMap m_imageBufferMessageHandlerMap;
>+    void createImageBuffer(const WebCore::FloatSize& logicalSize, WebCore::RenderingMode, float resolutionScale, WebCore::ColorSpace, WebCore::RemoteResourceIdentifier);
>+    void flushImageBufferDrawingContext(const WebCore::DisplayList::DisplayList&, WebCore::RemoteResourceIdentifier);
>+    void flushImageBufferDrawingContextAndCommit(const WebCore::DisplayList::DisplayList&, ImageBufferFlushIdentifier, 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);
>+
>+    RemoteResourceCacheProxy m_remoteResourceCacheProxy { *this };
>     WeakPtr<GPUConnectionToWebProcess> m_gpuConnectionToWebProcess;
>     RenderingBackendIdentifier m_renderingBackendIdentifier;
> };
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.messages.in b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.messages.in
>index 798c8b4edb57f5ad082ba81c1008b0dcdefdf18a..b31cc673e8a3a933785cb69e1f33881ea1a84e53 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.messages.in
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.messages.in
>@@ -23,11 +23,12 @@
> #if ENABLE(GPU_PROCESS)
> 
> messages -> RemoteRenderingBackendProxy NotRefCounted {
>-    void CreateImageBuffer(WebCore::FloatSize logicalSize, WebCore::RenderingMode renderingMode, float resolutionScale, WebCore::ColorSpace colorSpace, WebKit::ImageBufferIdentifier imageBufferIdentifier)
>-    void ReleaseImageBuffer(WebKit::ImageBufferIdentifier imageBufferIdentifier)
>-    void FlushImageBufferDrawingContext(WebCore::DisplayList::DisplayList displayList, WebKit::ImageBufferIdentifier imageBufferIdentifier)
>-    void FlushImageBufferDrawingContextAndCommit(WebCore::DisplayList::DisplayList displayList, WebKit::ImageBufferFlushIdentifier flushIdentifier, WebKit::ImageBufferIdentifier imageBufferIdentifier)
>-    GetImageData(enum:uint8_t WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, WebKit::ImageBufferIdentifier imageBufferIdentifier) -> (IPC::ImageDataReference imageData) Synchronous
>+    void CreateImageBuffer(WebCore::FloatSize logicalSize, WebCore::RenderingMode renderingMode, float resolutionScale, WebCore::ColorSpace colorSpace, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
>+    void FlushImageBufferDrawingContext(WebCore::DisplayList::DisplayList displayList, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
>+    void FlushImageBufferDrawingContextAndCommit(WebCore::DisplayList::DisplayList displayList, WebKit::ImageBufferFlushIdentifier 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)
> }
> 
> #endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteResourceCacheProxy.cpp b/Source/WebKit/GPUProcess/graphics/RemoteResourceCacheProxy.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..60af59695c4fd9848ea4f2f79a88dfaa826084ad
>--- /dev/null
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteResourceCacheProxy.cpp
>@@ -0,0 +1,146 @@
>+/*
>+ * Copyright (C) 2020 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. AND ITS CONTRIBUTORS ``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 ITS 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 "config.h"
>+#include "RemoteResourceCacheProxy.h"
>+
>+#if ENABLE(GPU_PROCESS)
>+
>+#include "PlatformRemoteImageBufferProxy.h"
>+
>+namespace WebKit {
>+using namespace WebCore;
>+
>+RemoteResourceCacheProxy::RemoteResourceCacheProxy(RemoteRenderingBackendProxy& remoteRenderingBackendProxy)
>+    : m_remoteRenderingBackendProxy(remoteRenderingBackendProxy)
>+{
>+}
>+
>+void RemoteResourceCacheProxy::createImageBuffer(const FloatSize& logicalSize, RenderingMode renderingMode, float resolutionScale, ColorSpace colorSpace, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    if (m_remoteImageBufferHashMap.contains(remoteResourceIdentifier)) {
>+        ASSERT_NOT_REACHED();
>+        return;
>+    }
>+
>+    std::unique_ptr<WebCore::ImageBuffer> image;
>+
>+    if (renderingMode == RenderingMode::RemoteAccelerated)
>+        image = AcceleratedRemoteImageBufferProxy::create(logicalSize, resolutionScale, colorSpace, m_remoteRenderingBackendProxy, remoteResourceIdentifier);
>+
>+    if (!image || renderingMode == RenderingMode::RemoteUnaccelerated)
>+        image = UnacceleratedRemoteImageBufferProxy::create(logicalSize, resolutionScale, colorSpace, m_remoteRenderingBackendProxy, remoteResourceIdentifier);
>+
>+    if (image) {
>+        m_remoteImageBufferHashMap.add(remoteResourceIdentifier, WTFMove(image));
>+        return;
>+    }
>+
>+    ASSERT_NOT_REACHED();
>+}
>+
>+ImageBuffer* RemoteResourceCacheProxy::flushDrawingContext(const DisplayList::DisplayList& displayList, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    if (auto image = m_remoteImageBufferHashMap.get(remoteResourceIdentifier)) {
>+        image->flushDrawingContext(displayList);
>+        return image;
>+    }
>+    return nullptr;
>+}
>+
>+ImageBuffer* RemoteResourceCacheProxy::flushDrawingContextAndCommit(const DisplayList::DisplayList& displayList, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    if (auto image = flushDrawingContext(displayList, remoteResourceIdentifier)) {
>+        image->flushContext();
>+        return image;
>+    }
>+    return nullptr;
>+}
>+
>+RefPtr<ImageData> RemoteResourceCacheProxy::getImageData(AlphaPremultiplication outputFormat, const IntRect& srcRect, RemoteResourceIdentifier remoteResourceIdentifier) const
>+{
>+    if (auto image = m_remoteImageBufferHashMap.get(remoteResourceIdentifier))
>+        return image->getImageData(outputFormat, srcRect);
>+    return nullptr;
>+}
>+
>+void RemoteResourceCacheProxy::cacheNativeImage(const NativeImagePtr& image, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    auto addResult = m_remoteNativeImageHashMap.add(remoteResourceIdentifier, image);
>+    ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+}
>+
>+bool RemoteResourceCacheProxy::drawNativeImageItem(const DisplayList::Item& item, GraphicsContext& context) const
>+{
>+    auto& drawItem = static_cast<const DisplayList::DrawNativeImage&>(item);
>+    auto remoteResourceIdentifier = drawItem.remoteResourceIdentifier();
>+    if (!remoteResourceIdentifier)
>+        return false;
>+
>+    auto image = m_remoteNativeImageHashMap.get(remoteResourceIdentifier);
>+    if (!image)
>+        return false;
>+
>+    context.drawNativeImage(image, drawItem.imageSize(), drawItem.destinationRect(), drawItem.source(), drawItem.options());
>+    return true;
>+}
>+
>+bool RemoteResourceCacheProxy::drawImageBufferItem(const DisplayList::Item& item, GraphicsContext& context) const
>+{
>+    auto& drawItem = static_cast<const DisplayList::DrawImageBuffer&>(item);
>+    auto remoteResourceIdentifier = drawItem.remoteResourceIdentifier();
>+    if (!remoteResourceIdentifier)
>+        return false;
>+
>+    auto image = m_remoteImageBufferHashMap.get(remoteResourceIdentifier);
>+    if (!image)
>+        return false;
>+
>+    image->draw(context, drawItem.destinationRect(), drawItem.source(), drawItem.options());
>+    return true;
>+}
>+
>+bool RemoteResourceCacheProxy::applyResourceItem(const DisplayList::Item& item, GraphicsContext& context) const
>+{
>+    if (item.type() == DisplayList::ItemType::DrawImageBuffer)
>+        return drawImageBufferItem(item, context);
>+    if (item.type() == DisplayList::ItemType::DrawNativeImage)
>+        return drawNativeImageItem(item, context);
>+    return false;
>+}
>+
>+void RemoteResourceCacheProxy::releaseRemoteResource(RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    if (m_remoteImageBufferHashMap.remove(remoteResourceIdentifier))
>+        return;
>+    if (m_remoteNativeImageHashMap.remove(remoteResourceIdentifier))
>+        return;
>+    // Caching the remote resource should have happened before releasing it.
>+    ASSERT_NOT_REACHED();
>+}
>+
>+} // namespace WebKit
>+
>+#endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteResourceCacheProxy.h b/Source/WebKit/GPUProcess/graphics/RemoteResourceCacheProxy.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..23e422c8aadca6503d0d683f104ee3ec6cbeb3d8
>--- /dev/null
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteResourceCacheProxy.h
>@@ -0,0 +1,73 @@
>+/*
>+ * Copyright (C) 2020 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.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(GPU_PROCESS)
>+
>+#include <WebCore/RemoteResourceIdentifier.h>
>+#include <wtf/HashMap.h>
>+
>+namespace WebCore {
>+namespace DisplayList {
>+class DisplayList;
>+class Item;
>+}
>+}
>+
>+namespace WebKit {
>+
>+class RemoteRenderingBackendProxy;
>+
>+class RemoteResourceCacheProxy {
>+public:
>+    RemoteResourceCacheProxy(RemoteRenderingBackendProxy&);
>+
>+    void createImageBuffer(const WebCore::FloatSize& logicalSize, WebCore::RenderingMode, float resolutionScale, WebCore::ColorSpace, WebCore::RemoteResourceIdentifier);
>+    WebCore::ImageBuffer* flushDrawingContext(const WebCore::DisplayList::DisplayList&, WebCore::RemoteResourceIdentifier);
>+    WebCore::ImageBuffer* flushDrawingContextAndCommit(const WebCore::DisplayList::DisplayList&, WebCore::RemoteResourceIdentifier);
>+    RefPtr<WebCore::ImageData> getImageData(WebCore::AlphaPremultiplication outputFormat, const WebCore::IntRect& srcRect, WebCore::RemoteResourceIdentifier) const;
>+
>+    void cacheNativeImage(const WebCore::NativeImagePtr&, WebCore::RemoteResourceIdentifier);
>+
>+    bool applyResourceItem(const WebCore::DisplayList::Item&, WebCore::GraphicsContext&) const;
>+
>+    void releaseRemoteResource(WebCore::RemoteResourceIdentifier);
>+
>+private:
>+    using RemoteImageBufferHashMap = HashMap<WebCore::RemoteResourceIdentifier, std::unique_ptr<WebCore::ImageBuffer>>;
>+    using RemoteNativeImageHashMap = HashMap<WebCore::RemoteResourceIdentifier, WebCore::NativeImagePtr>;
>+
>+    bool drawImageBufferItem(const WebCore::DisplayList::Item&, WebCore::GraphicsContext&) const;
>+    bool drawNativeImageItem(const WebCore::DisplayList::Item&, WebCore::GraphicsContext&) const;
>+
>+    RemoteImageBufferHashMap m_remoteImageBufferHashMap;
>+    RemoteNativeImageHashMap m_remoteNativeImageHashMap;
>+    RemoteRenderingBackendProxy& m_remoteRenderingBackendProxy;
>+};
>+
>+} // namespace WebKit
>+
>+#endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/GPUProcess/webrtc/RemoteMediaRecorder.cpp b/Source/WebKit/GPUProcess/webrtc/RemoteMediaRecorder.cpp
>index 4017a2a8f22cececc2151a30a3278ff906eaf32a..6748d1f5d800d9574f238075b1890b4e4acee914 100644
>--- a/Source/WebKit/GPUProcess/webrtc/RemoteMediaRecorder.cpp
>+++ b/Source/WebKit/GPUProcess/webrtc/RemoteMediaRecorder.cpp
>@@ -29,6 +29,7 @@
> #if PLATFORM(COCOA) && ENABLE(GPU_PROCESS) && ENABLE(MEDIA_STREAM) && HAVE(AVASSETWRITERDELEGATE)
> 
> #include "Connection.h"
>+#include "GPUConnectionToWebProcess.h"
> #include "SharedRingBufferStorage.h"
> #include <WebCore/CARingBuffer.h>
> #include <WebCore/ImageTransferSessionVT.h>
>diff --git a/Source/WebKit/GPUProcess/webrtc/RemoteSampleBufferDisplayLayerManager.cpp b/Source/WebKit/GPUProcess/webrtc/RemoteSampleBufferDisplayLayerManager.cpp
>index 977f93ff5c3c2b817846c9a9a7551789c8efe05c..61b890dc7867c33b005f22e93bb1af47ddd3b17c 100644
>--- a/Source/WebKit/GPUProcess/webrtc/RemoteSampleBufferDisplayLayerManager.cpp
>+++ b/Source/WebKit/GPUProcess/webrtc/RemoteSampleBufferDisplayLayerManager.cpp
>@@ -30,6 +30,7 @@
> 
> #include "Decoder.h"
> #include "GPUConnectionToWebProcess.h"
>+#include "GPUProcess.h"
> #include "RemoteSampleBufferDisplayLayer.h"
> #include "RemoteSampleBufferDisplayLayerManagerMessages.h"
> #include "RemoteSampleBufferDisplayLayerMessages.h"
>diff --git a/Source/WebKit/Scripts/webkit/messages.py b/Source/WebKit/Scripts/webkit/messages.py
>index facd2f7afb5a392ee20967a76fd41e14dfb150b9..158c4ef97c2e99b87667936eb40a5e1878d18b3a 100644
>--- a/Source/WebKit/Scripts/webkit/messages.py
>+++ b/Source/WebKit/Scripts/webkit/messages.py
>@@ -217,11 +217,13 @@ def types_that_cannot_be_forward_declared():
>         'WebCore::PlaybackTargetClientContextIdentifier',
>         'WebCore::MediaPlayerIdentifier',
>         'WebCore::MediaSessionIdentifier',
>+        'WebCore::NativeImagePtr',
>         'WebCore::PageIdentifier',
>         'WebCore::PluginLoadClientPolicy',
>         'WebCore::PointerID',
>         'WebCore::ProcessIdentifier',
>         'WebCore::RealtimeMediaSourceIdentifier',
>+        'WebCore::RemoteResourceIdentifier',
>         'WebCore::RenderingMode',
>         'WebCore::ServiceWorkerIdentifier',
>         'WebCore::ServiceWorkerJobIdentifier',
>@@ -240,7 +242,6 @@ def types_that_cannot_be_forward_declared():
>         'WebKit::GeolocationIdentifier',
>         'WebKit::ImageBufferBackendHandle',
>         'WebKit::ImageBufferFlushIdentifier',
>-        'WebKit::ImageBufferIdentifier',
>         'WebKit::LayerHostingContextID',
>         'WebKit::LegacyCustomProtocolID',
>         'WebKit::LibWebRTCResolverIdentifier',
>diff --git a/Source/WebKit/Shared/WebCoreArgumentCoders.cpp b/Source/WebKit/Shared/WebCoreArgumentCoders.cpp
>index e0bbbbc5ba2318bfa8e63196d54eebb890364441..a077530957ba8d47d5429badd66757554d06211d 100644
>--- a/Source/WebKit/Shared/WebCoreArgumentCoders.cpp
>+++ b/Source/WebKit/Shared/WebCoreArgumentCoders.cpp
>@@ -1100,7 +1100,7 @@ bool ArgumentCoder<ImageHandle>::decode(Decoder& decoder, ImageHandle& imageHand
>     return true;
> }
> 
>-static void encodeNativeImage(Encoder& encoder, NativeImagePtr image)
>+static void encodeNativeImage(Encoder& encoder, const NativeImagePtr& image)
> {
>     auto imageSize = nativeImageSize(image);
>     auto bitmap = ShareableBitmap::createShareable(imageSize, { });
>@@ -1143,7 +1143,7 @@ static WARN_UNUSED_RETURN bool decodeNativeImage(Decoder& decoder, NativeImagePt
>     return true;
> }
> 
>-static void encodeOptionalNativeImage(Encoder& encoder, NativeImagePtr image)
>+static void encodeOptionalNativeImage(Encoder& encoder, const NativeImagePtr& image)
> {
>     bool hasImage = !!image;
>     encoder << hasImage;
>@@ -1166,14 +1166,14 @@ static WARN_UNUSED_RETURN bool decodeOptionalNativeImage(Decoder& decoder, Nativ
>     return decodeNativeImage(decoder, image);
> }
> 
>-void ArgumentCoder<NativeImageHandle>::encode(Encoder& encoder, const NativeImageHandle& imageHandle)
>+void ArgumentCoder<NativeImagePtr>::encode(Encoder& encoder, const NativeImagePtr& image)
> {
>-    encodeOptionalNativeImage(encoder, imageHandle.image.get());
>+    encodeOptionalNativeImage(encoder, image);
> }
> 
>-bool ArgumentCoder<NativeImageHandle>::decode(Decoder& decoder, NativeImageHandle& imageHandle)
>+bool ArgumentCoder<NativeImagePtr>::decode(Decoder& decoder, NativeImagePtr& image)
> {
>-    return decodeOptionalNativeImage(decoder, imageHandle.image);
>+    return decodeOptionalNativeImage(decoder, image);
> }
> 
> void ArgumentCoder<Ref<Font>>::encode(Encoder& encoder, const Ref<WebCore::Font>& font)
>diff --git a/Source/WebKit/Shared/WebCoreArgumentCoders.h b/Source/WebKit/Shared/WebCoreArgumentCoders.h
>index 05d03554b9eca9a041c368ef4538824434ce6e23..9f3b10669333ba301529783c9e1e91eaba4cab85 100644
>--- a/Source/WebKit/Shared/WebCoreArgumentCoders.h
>+++ b/Source/WebKit/Shared/WebCoreArgumentCoders.h
>@@ -34,6 +34,7 @@
> #include <WebCore/IndexedDB.h>
> #include <WebCore/InputMode.h>
> #include <WebCore/MediaSelectionOption.h>
>+#include <WebCore/NativeImagePtr.h>
> #include <WebCore/NetworkLoadMetrics.h>
> #include <WebCore/NotificationDirection.h>
> #include <WebCore/RealtimeMediaSource.h>
>@@ -105,7 +106,6 @@ class KeyframeValueList;
> class LayoutSize;
> class LayoutPoint;
> class LinearTimingFunction;
>-class NativeImageHandle;
> class Notification;
> class PasteboardCustomData;
> class PaymentInstallmentConfiguration;
>@@ -416,9 +416,9 @@ template<> struct ArgumentCoder<WebCore::ImageHandle> {
>     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ImageHandle&);
> };
> 
>-template<> struct ArgumentCoder<WebCore::NativeImageHandle> {
>-    static void encode(Encoder&, const WebCore::NativeImageHandle&);
>-    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::NativeImageHandle&);
>+template<> struct ArgumentCoder<WebCore::NativeImagePtr> {
>+    static void encode(Encoder&, const WebCore::NativeImagePtr&);
>+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::NativeImagePtr&);
> };
> 
> template<> struct ArgumentCoder<WebCore::ResourceRequest> {
>diff --git a/Source/WebKit/Shared/cg/ShareableBitmapCG.cpp b/Source/WebKit/Shared/cg/ShareableBitmapCG.cpp
>index 730da648f2b2fe9e784fd04052e190f0d0bf21ad..959da83d5f6988b211588da7ddb4ff183dce7d60 100644
>--- a/Source/WebKit/Shared/cg/ShareableBitmapCG.cpp
>+++ b/Source/WebKit/Shared/cg/ShareableBitmapCG.cpp
>@@ -106,12 +106,27 @@ std::unique_ptr<GraphicsContext> ShareableBitmap::createGraphicsContext()
> 
> void ShareableBitmap::paint(WebCore::GraphicsContext& context, const IntPoint& destination, const IntRect& source)
> {
>-    drawNativeImage(makeCGImageCopy(), context, 1, destination, source);
>+    paint(context, 1, destination, source);
> }
> 
> void ShareableBitmap::paint(WebCore::GraphicsContext& context, float scaleFactor, const IntPoint& destination, const IntRect& source)
> {
>-    drawNativeImage(makeCGImageCopy(), context, scaleFactor, destination, source);
>+    CGContextRef cgContext = context.platformContext();
>+    CGContextSaveGState(cgContext);
>+
>+    CGContextClipToRect(cgContext, CGRectMake(destination.x(), destination.y(), source.width(), source.height()));
>+    CGContextScaleCTM(cgContext, 1, -1);
>+
>+    auto image = makeCGImageCopy();
>+    CGFloat imageHeight = CGImageGetHeight(image.get()) / scaleFactor;
>+    CGFloat imageWidth = CGImageGetWidth(image.get()) / scaleFactor;
>+
>+    CGFloat destX = destination.x() - source.x();
>+    CGFloat destY = -imageHeight - destination.y() + source.y();
>+
>+    CGContextDrawImage(cgContext, CGRectMake(destX, destY, imageWidth, imageHeight), image.get());
>+
>+    CGContextRestoreGState(cgContext);
> }
> 
> RetainPtr<CGImageRef> ShareableBitmap::makeCGImageCopy()
>diff --git a/Source/WebKit/Sources.txt b/Source/WebKit/Sources.txt
>index daf5fb7313bdd98068dedd39cbac4dfbe9377ca8..8e3b2affca0034b326da9b2198c857974e04914c 100644
>--- a/Source/WebKit/Sources.txt
>+++ b/Source/WebKit/Sources.txt
>@@ -24,8 +24,8 @@
> GPUProcess/GPUProcess.cpp
> GPUProcess/GPUConnectionToWebProcess.cpp
> GPUProcess/GPUProcessCreationParameters.cpp
>-GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.cpp
> GPUProcess/graphics/RemoteRenderingBackendProxy.cpp
>+GPUProcess/graphics/RemoteResourceCacheProxy.cpp
> GPUProcess/media/RemoteAudioSessionProxy.cpp
> GPUProcess/media/RemoteAudioSessionProxyManager.cpp
> GPUProcess/media/RemoteAudioTrackProxy.cpp
>@@ -552,8 +552,8 @@ WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp
> 
> WebProcess/GPU/GPUProcessConnection.cpp
> WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.cpp
>-WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.cpp
> WebProcess/GPU/graphics/RemoteRenderingBackend.cpp
>+WebProcess/GPU/graphics/RemoteResourceCache.cpp
> WebProcess/GPU/media/AudioTrackPrivateRemote.cpp
> WebProcess/GPU/media/MediaPlayerPrivateRemote.cpp
> WebProcess/GPU/media/RemoteAudioDestinationProxy.cpp
>diff --git a/Source/WebKit/WebKit.xcodeproj/project.pbxproj b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>index 98434cbac0c2f61a2d6e280716ecd72882889282..2a8c42a5abe415bf9d11c7b0b3ef718802b20c0f 100644
>--- a/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>+++ b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>@@ -3889,7 +3889,6 @@
> 		550640A224071A6100AAE045 /* RemoteRenderingBackendProxy.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteRenderingBackendProxy.cpp; sourceTree = "<group>"; };
> 		550640A324071A6100AAE045 /* RemoteRenderingBackendProxy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteRenderingBackendProxy.h; sourceTree = "<group>"; };
> 		550640A424071C2100AAE045 /* RemoteRenderingBackendProxy.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = RemoteRenderingBackendProxy.messages.in; sourceTree = "<group>"; };
>-		550640A524071CC000AAE045 /* ImageBufferIdentifier.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ImageBufferIdentifier.h; sourceTree = "<group>"; };
> 		55AD09422408A02E00DE4D2F /* RemoteImageBufferProxy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteImageBufferProxy.h; sourceTree = "<group>"; };
> 		55AD09432408A0E600DE4D2F /* PlatformRemoteImageBufferProxy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PlatformRemoteImageBufferProxy.h; sourceTree = "<group>"; };
> 		55AD09442408ABB300DE4D2F /* ImageBufferFlushIdentifier.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ImageBufferFlushIdentifier.h; sourceTree = "<group>"; };
>@@ -4178,10 +4177,7 @@
> 		71A676A522C62318007D6295 /* WKTouchActionGestureRecognizer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = WKTouchActionGestureRecognizer.mm; path = ios/WKTouchActionGestureRecognizer.mm; sourceTree = "<group>"; };
> 		71FB810A2260627A00323677 /* WebsiteSimulatedMouseEventsDispatchPolicy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebsiteSimulatedMouseEventsDispatchPolicy.h; sourceTree = "<group>"; };
> 		7227800B2408BD7D007D376B /* PlatformRemoteImageBuffer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PlatformRemoteImageBuffer.h; sourceTree = "<group>"; };
>-		7227800C24097A02007D376B /* RemoteImageBufferMessageHandler.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteImageBufferMessageHandler.cpp; sourceTree = "<group>"; };
> 		7227800D24097A02007D376B /* RemoteImageBufferMessageHandler.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteImageBufferMessageHandler.h; sourceTree = "<group>"; };
>-		722780112409906E007D376B /* RemoteImageBufferMessageHandlerProxy.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteImageBufferMessageHandlerProxy.cpp; sourceTree = "<group>"; };
>-		722780122409906E007D376B /* RemoteImageBufferMessageHandlerProxy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteImageBufferMessageHandlerProxy.h; sourceTree = "<group>"; };
> 		727A7F342407857D004D2931 /* ImageBufferShareableIOSurfaceBackend.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageBufferShareableIOSurfaceBackend.cpp; sourceTree = "<group>"; };
> 		727A7F352407857F004D2931 /* ImageBufferShareableIOSurfaceBackend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageBufferShareableIOSurfaceBackend.h; sourceTree = "<group>"; };
> 		727A7F36240788F0004D2931 /* ImageBufferShareableBitmapBackend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageBufferShareableBitmapBackend.h; sourceTree = "<group>"; };
>@@ -4191,6 +4187,10 @@
> 		727A7F492408AEE6004D2931 /* RemoteImageBuffer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteImageBuffer.h; sourceTree = "<group>"; };
> 		728E86EF1795188C0087879E /* WebColorPickerMac.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebColorPickerMac.h; sourceTree = "<group>"; };
> 		728E86F01795188C0087879E /* WebColorPickerMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebColorPickerMac.mm; sourceTree = "<group>"; };
>+		729D053225314FEF00422098 /* RemoteResourceCacheProxy.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteResourceCacheProxy.cpp; sourceTree = "<group>"; };
>+		729D053325314FEF00422098 /* RemoteResourceCacheProxy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteResourceCacheProxy.h; sourceTree = "<group>"; };
>+		729D0535253173CC00422098 /* RemoteResourceCache.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteResourceCache.cpp; sourceTree = "<group>"; };
>+		729D0536253173CC00422098 /* RemoteResourceCache.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteResourceCache.h; sourceTree = "<group>"; };
> 		75A8D2C4187CCF9F00C39C9E /* WKWebsiteDataStore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKWebsiteDataStore.h; sourceTree = "<group>"; };
> 		75A8D2C5187CCF9F00C39C9E /* WKWebsiteDataStore.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WKWebsiteDataStore.mm; sourceTree = "<group>"; };
> 		75A8D2D4187D1C0100C39C9E /* WKWebsiteDataStoreInternal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKWebsiteDataStoreInternal.h; sourceTree = "<group>"; };
>@@ -8076,17 +8076,17 @@
> 				727A7F3324078527004D2931 /* cocoa */,
> 				727A7F39240788F1004D2931 /* ImageBufferBackendHandle.h */,
> 				55AD09442408ABB300DE4D2F /* ImageBufferFlushIdentifier.h */,
>-				550640A524071CC000AAE045 /* ImageBufferIdentifier.h */,
> 				727A7F37240788F0004D2931 /* ImageBufferShareableBitmapBackend.cpp */,
> 				727A7F36240788F0004D2931 /* ImageBufferShareableBitmapBackend.h */,
> 				727A7F38240788F0004D2931 /* PlatformImageBufferShareableBackend.h */,
> 				7227800B2408BD7D007D376B /* PlatformRemoteImageBuffer.h */,
> 				727A7F492408AEE6004D2931 /* RemoteImageBuffer.h */,
>-				7227800C24097A02007D376B /* RemoteImageBufferMessageHandler.cpp */,
> 				7227800D24097A02007D376B /* RemoteImageBufferMessageHandler.h */,
> 				5506409D2407160900AAE045 /* RemoteRenderingBackend.cpp */,
> 				5506409E2407160900AAE045 /* RemoteRenderingBackend.h */,
> 				550640A0240719E100AAE045 /* RemoteRenderingBackend.messages.in */,
>+				729D0535253173CC00422098 /* RemoteResourceCache.cpp */,
>+				729D0536253173CC00422098 /* RemoteResourceCache.h */,
> 				5506409F2407196A00AAE045 /* RenderingBackendIdentifier.h */,
> 			);
> 			path = graphics;
>@@ -8096,12 +8096,12 @@
> 			isa = PBXGroup;
> 			children = (
> 				55AD09432408A0E600DE4D2F /* PlatformRemoteImageBufferProxy.h */,
>-				722780112409906E007D376B /* RemoteImageBufferMessageHandlerProxy.cpp */,
>-				722780122409906E007D376B /* RemoteImageBufferMessageHandlerProxy.h */,
> 				55AD09422408A02E00DE4D2F /* RemoteImageBufferProxy.h */,
> 				550640A224071A6100AAE045 /* RemoteRenderingBackendProxy.cpp */,
> 				550640A324071A6100AAE045 /* RemoteRenderingBackendProxy.h */,
> 				550640A424071C2100AAE045 /* RemoteRenderingBackendProxy.messages.in */,
>+				729D053225314FEF00422098 /* RemoteResourceCacheProxy.cpp */,
>+				729D053325314FEF00422098 /* RemoteResourceCacheProxy.h */,
> 			);
> 			path = graphics;
> 			sourceTree = "<group>";
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/ImageBufferIdentifier.h b/Source/WebKit/WebProcess/GPU/graphics/ImageBufferIdentifier.h
>deleted file mode 100644
>index 9a1bc9ae87dc8d72428a0b809cad0d80a4cd1cb9..0000000000000000000000000000000000000000
>--- a/Source/WebKit/WebProcess/GPU/graphics/ImageBufferIdentifier.h
>+++ /dev/null
>@@ -1,39 +0,0 @@
>-/*
>- * Copyright (C) 2020 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. AND ITS CONTRIBUTORS ``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 ITS 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.
>- */
>-
>-#pragma once
>-
>-#if ENABLE(GPU_PROCESS)
>-
>-#include <wtf/ObjectIdentifier.h>
>-
>-namespace WebKit {
>-
>-enum ImageBufferIdentifierType { };
>-using ImageBufferIdentifier = ObjectIdentifier<ImageBufferIdentifierType>;
>-
>-} // namespace WebKit
>-
>-#endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBuffer.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBuffer.h
>index e8491664514596287ef2c78f9076e1d4382191f2..e851dd038b77cbd5e0527df1a102687691339078 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBuffer.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBuffer.h
>@@ -37,7 +37,7 @@ namespace WebKit {
> class RemoteRenderingBackend;
> 
> template<typename BackendType>
>-class RemoteImageBuffer : public WebCore::DisplayList::ImageBuffer<BackendType>, public RemoteImageBufferMessageHandler {
>+class RemoteImageBuffer : public WebCore::DisplayList::ImageBuffer<BackendType>, public RemoteImageBufferMessageHandler, public WebCore::DisplayList::Recorder::Delegate {
>     using BaseDisplayListImageBuffer = WebCore::DisplayList::ImageBuffer<BackendType>;
>     using BaseDisplayListImageBuffer::m_backend;
>     using BaseDisplayListImageBuffer::m_drawingContext;
>@@ -53,14 +53,20 @@ public:
> 
>     ~RemoteImageBuffer()
>     {
>+        if (!m_remoteRenderingBackend)
>+            return;
>         flushDrawingContext();
>+        m_remoteRenderingBackend->releaseImageBuffer(*this);
>     }
> 
>+    WebCore::RemoteResourceIdentifier remoteResourceIdentifier() const { return m_remoteResourceIdentifier; }
>+
> protected:
>     RemoteImageBuffer(const WebCore::FloatSize& size, WebCore::RenderingMode renderingMode, float resolutionScale, WebCore::ColorSpace colorSpace, RemoteRenderingBackend& remoteRenderingBackend)
>-        : BaseDisplayListImageBuffer(size)
>-        , RemoteImageBufferMessageHandler(size, renderingMode, resolutionScale, colorSpace, remoteRenderingBackend)
>+        : BaseDisplayListImageBuffer(size, this)
>+        , m_remoteRenderingBackend(makeWeakPtr(remoteRenderingBackend))
>     {
>+        m_remoteResourceIdentifier = m_remoteRenderingBackend->remoteCreateImageBuffer(size, renderingMode, resolutionScale, colorSpace);
>     }
> 
>     void createBackend(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace colorSpace, ImageBufferBackendHandle handle) override
>@@ -69,22 +75,50 @@ protected:
>         m_backend = BackendType::create(logicalSize, backendSize, resolutionScale, colorSpace, WTFMove(handle));
>     }
>     
>-    bool isBackendCreated() const override { return m_backend.get(); }
>-
>     BackendType* ensureBackendCreated() const override
>     {
>-        if (!m_backend)
>-            const_cast<RemoteImageBuffer&>(*this).RemoteImageBufferMessageHandler::waitForCreateImageBufferBackend();
>+        if (!m_backend && m_remoteRenderingBackend)
>+            m_remoteRenderingBackend->waitForCreateImageBufferBackend();
>         return m_backend.get();
>     }
> 
>+    void flushContext() override
>+    {
>+        flushDrawingContext();
>+        m_backend->flushContext();
>+    }
>+
>+    void flushDrawingContext() override
>+    {
>+        auto& displayList = m_drawingContext.displayList();
>+        if (!displayList.itemCount() || !m_remoteRenderingBackend)
>+            return;
>+        m_sentFlushIdentifier = m_remoteRenderingBackend->remoteFlushDrawingContextAndCommit(displayList, m_remoteResourceIdentifier);
>+        m_remoteRenderingBackend->waitForCommitImageBufferFlushContext();
>+        m_remoteRenderingBackend->releaseRemoteClient(m_remoteResourceIdentifier);
>+        displayList.clear();
>+    }
>+
>+    void flushDrawingContext(const WebCore::DisplayList::DisplayList& displayList) override
>+    {
>+        if (!displayList.itemCount() || !m_remoteRenderingBackend)
>+            return;
>+        m_remoteRenderingBackend->remoteFlushDrawingContext(displayList, m_remoteResourceIdentifier);
>+    }
>+    
>     RefPtr<WebCore::ImageData> getImageData(WebCore::AlphaPremultiplication outputFormat, const WebCore::IntRect& srcRect) const override
>     {
>+        if (!m_remoteRenderingBackend)
>+            return nullptr;
>+
>         auto& displayList = const_cast<RemoteImageBuffer*>(this)->m_drawingContext.displayList();
>-        const_cast<RemoteImageBuffer*>(this)->RemoteImageBufferMessageHandler::flushDrawingContext(displayList);
>-        auto result = const_cast<RemoteImageBuffer*>(this)->RemoteImageBufferMessageHandler::getImageData(outputFormat, srcRect);
>+        if (displayList.itemCount()) {
>+            const_cast<RemoteImageBuffer*>(this)->flushDrawingContext(displayList);
>+            displayList.clear();
>+        }
>+
>         // getImageData is synchronous, which means we've already received the CommitImageBufferFlushContext message.
>-        return result;
>+        return m_remoteRenderingBackend->remoteGetImageData(outputFormat, srcRect, m_remoteResourceIdentifier);
>     }
> 
>     void putImageData(WebCore::AlphaPremultiplication inputFormat, const WebCore::ImageData& imageData, const WebCore::IntRect& srcRect, const WebCore::IntPoint& destPoint = { }, WebCore::AlphaPremultiplication destFormat = WebCore::AlphaPremultiplication::Premultiplied) override
>@@ -95,26 +129,32 @@ protected:
>         m_drawingContext.recorder().putImageData(inputFormat, imageData, srcRect, destPoint, destFormat);
>     }
> 
>-    void flushContext() override
>+    RefPtr<WebCore::DisplayList::Item> createDrawImageBufferItem(WebCore::ImageBuffer& image, const WebCore::FloatRect& destRect, const WebCore::FloatRect& srcRect, const WebCore::ImagePaintingOptions& options) override
>     {
>-        flushDrawingContext();
>-        m_backend->flushContext();
>+        if (!m_remoteRenderingBackend)
>+            return nullptr;
>+        return m_remoteRenderingBackend->createDrawImageBufferItem(image, destRect, srcRect, options, m_remoteResourceIdentifier);
>     }
> 
>-    void flushDrawingContext() override
>+    RefPtr<WebCore::DisplayList::Item> createDrawNativeImageItem(const WebCore::NativeImagePtr& image, const WebCore::FloatSize& imageSize, const WebCore::FloatRect& destRect, const WebCore::FloatRect& srcRect, const WebCore::ImagePaintingOptions& options, WebCore::CachedImage& cachedImage) override
>     {
>-        auto& displayList = m_drawingContext.displayList();
>-        if (displayList.itemCount())
>-            RemoteImageBufferMessageHandler::flushDrawingContextAndWaitCommit(displayList);
>+        if (!m_remoteRenderingBackend)
>+            return nullptr;
>+        return m_remoteRenderingBackend->createDrawNativeImageItem(image, imageSize, destRect, srcRect, options, cachedImage, m_remoteResourceIdentifier);
>     }
>-    
>+
>     void willAppendItem(const WebCore::DisplayList::Item&) override
>     {
>         constexpr size_t DisplayListBatchSize = 512;
>         auto& displayList = m_drawingContext.displayList();
>-        if (displayList.itemCount() >= DisplayListBatchSize)
>-            RemoteImageBufferMessageHandler::flushDrawingContext(displayList);
>+        if (displayList.itemCount() < DisplayListBatchSize || !m_remoteRenderingBackend)
>+            return;
>+        flushDrawingContext(displayList);
>+        displayList.clear();
>     }
>+
>+    WeakPtr<RemoteRenderingBackend> m_remoteRenderingBackend;
>+    WebCore::RemoteResourceIdentifier m_remoteResourceIdentifier;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.cpp b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.cpp
>deleted file mode 100644
>index 77150c7b0793afe9ac5c83a9ac746ba318e51b8f..0000000000000000000000000000000000000000
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.cpp
>+++ /dev/null
>@@ -1,99 +0,0 @@
>-/*
>- * Copyright (C) 2020 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. AND ITS CONTRIBUTORS ``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 ITS 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 "config.h"
>-#include "RemoteImageBufferMessageHandler.h"
>-
>-#if ENABLE(GPU_PROCESS)
>-
>-#include "ImageDataReference.h"
>-#include "RemoteRenderingBackend.h"
>-#include "RemoteRenderingBackendProxyMessages.h"
>-#include <WebCore/DisplayListItems.h>
>-
>-namespace WebKit {
>-using namespace WebCore;
>-
>-RemoteImageBufferMessageHandler::RemoteImageBufferMessageHandler(const FloatSize& size, RenderingMode renderingMode, float resolutionScale, ColorSpace colorSpace, RemoteRenderingBackend& remoteRenderingBackend)
>-    : m_remoteRenderingBackend(makeWeakPtr(remoteRenderingBackend))
>-{
>-    // Create the RemoteImageBufferProxy.
>-    m_remoteRenderingBackend->send(Messages::RemoteRenderingBackendProxy::CreateImageBuffer(size, renderingMode, resolutionScale, colorSpace, m_imageBufferIdentifier), m_remoteRenderingBackend->renderingBackendIdentifier());
>-}
>-
>-RemoteImageBufferMessageHandler::~RemoteImageBufferMessageHandler()
>-{
>-    // Release the RemoteImageBufferProxy.
>-    if (!m_remoteRenderingBackend)
>-        return;
>-    m_remoteRenderingBackend->send(Messages::RemoteRenderingBackendProxy::ReleaseImageBuffer(m_imageBufferIdentifier), m_remoteRenderingBackend->renderingBackendIdentifier());
>-}
>-
>-RefPtr<ImageData> RemoteImageBufferMessageHandler::getImageData(AlphaPremultiplication outputFormat, const IntRect& srcRect) const
>-{
>-    IPC::ImageDataReference imageDataReference;
>-    m_remoteRenderingBackend->sendSync(Messages::RemoteRenderingBackendProxy::GetImageData(outputFormat, srcRect, m_imageBufferIdentifier), Messages::RemoteRenderingBackendProxy::GetImageData::Reply(imageDataReference), m_remoteRenderingBackend->renderingBackendIdentifier(), 1_s);
>-    return imageDataReference.buffer();
>-}
>-
>-void RemoteImageBufferMessageHandler::waitForCreateImageBufferBackend()
>-{
>-    if (m_remoteRenderingBackend && !isBackendCreated())
>-        m_remoteRenderingBackend->waitForCreateImageBufferBackend();
>-}
>-
>-void RemoteImageBufferMessageHandler::waitForCommitImageBufferFlushContext()
>-{
>-    if (m_remoteRenderingBackend && isPendingFlush())
>-        m_remoteRenderingBackend->waitForCommitImageBufferFlushContext();
>-}
>-
>-void RemoteImageBufferMessageHandler::flushDrawingContext(WebCore::DisplayList::DisplayList& displayList)
>-{
>-    if (!m_remoteRenderingBackend)
>-        return;
>-    
>-    m_remoteRenderingBackend->send(Messages::RemoteRenderingBackendProxy::FlushImageBufferDrawingContext(displayList, m_imageBufferIdentifier), m_remoteRenderingBackend->renderingBackendIdentifier());
>-    displayList.clear();
>-}
>-
>-void RemoteImageBufferMessageHandler::flushDrawingContextAndWaitCommit(WebCore::DisplayList::DisplayList& displayList)
>-{
>-    if (!m_remoteRenderingBackend)
>-        return;
>-    m_sentFlushIdentifier = ImageBufferFlushIdentifier::generate();
>-    m_remoteRenderingBackend->send(Messages::RemoteRenderingBackendProxy::FlushImageBufferDrawingContextAndCommit(displayList, m_sentFlushIdentifier, m_imageBufferIdentifier), m_remoteRenderingBackend->renderingBackendIdentifier());
>-    displayList.clear();
>-    waitForCommitImageBufferFlushContext();
>-}
>-
>-void RemoteImageBufferMessageHandler::commitFlushContext(ImageBufferFlushIdentifier flushIdentifier)
>-{
>-    m_receivedFlushIdentifier = flushIdentifier;
>-}
>-
>-} // namespace WebKit
>-
>-#endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.h
>index 620418d78c27f28c574902c2e1ba9a23717517b9..61dd58ce52fdced4f184af0ea6797b266275a243 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.h
>@@ -29,50 +29,31 @@
> 
> #include "ImageBufferBackendHandle.h"
> #include "ImageBufferFlushIdentifier.h"
>-#include "ImageBufferIdentifier.h"
>-#include <WebCore/ColorSpace.h>
>-#include <WebCore/DisplayList.h>
>-#include <WebCore/FloatSize.h>
>-#include <WebCore/RenderingMode.h>
>+#include <WebCore/RemoteResourceIdentifier.h>
> 
> namespace WebCore {
>+class FloatSize;
> class ImageData;
> enum class AlphaPremultiplication : uint8_t;
>+enum class ColorSpace : uint8_t;
> }
> 
> namespace WebKit {
> 
>-class RemoteRenderingBackend;
>-
> class RemoteImageBufferMessageHandler {
> public:
>-    virtual ~RemoteImageBufferMessageHandler();
>-
>-    ImageBufferIdentifier imageBufferIdentifier() const { return m_imageBufferIdentifier; }
>-
>     // Messages to be received. See RemoteRenderingBackend.messages.in.
>     virtual void createBackend(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle) = 0;
> 
>-    void commitFlushContext(ImageBufferFlushIdentifier);
>-
>-protected:
>-    RemoteImageBufferMessageHandler(const WebCore::FloatSize&, WebCore::RenderingMode, float resolutionScale, WebCore::ColorSpace, RemoteRenderingBackend&);
>-
>-    virtual bool isBackendCreated() const = 0;
>     bool isPendingFlush() const { return m_sentFlushIdentifier != m_receivedFlushIdentifier; }
> 
>-    RefPtr<WebCore::ImageData> getImageData(WebCore::AlphaPremultiplication outputFormat, const WebCore::IntRect& srcRect) const;
>-
>-    void waitForCreateImageBufferBackend();
>-    void waitForCommitImageBufferFlushContext();
>+    void commitFlushContext(ImageBufferFlushIdentifier flushIdentifier)
>+    {
>+        m_receivedFlushIdentifier = flushIdentifier;
>+    }
> 
>-    // Messages to be sent. See RemoteRenderingBackendProxy.messages.in.
>-    void flushDrawingContext(WebCore::DisplayList::DisplayList&);
>-    void flushDrawingContextAndWaitCommit(WebCore::DisplayList::DisplayList&);
>-
>-private:
>-    WeakPtr<RemoteRenderingBackend> m_remoteRenderingBackend;
>-    ImageBufferIdentifier m_imageBufferIdentifier { ImageBufferIdentifier::generate() };
>+protected:
>+    virtual ~RemoteImageBufferMessageHandler() = default;
> 
>     ImageBufferFlushIdentifier m_sentFlushIdentifier;
>     ImageBufferFlushIdentifier m_receivedFlushIdentifier;
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.cpp b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.cpp
>index 995341787eda20a554e4d67ba53dc698a5370cc0..06578142c6ae21518f302fbdc04e5ef1998a440c 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.cpp
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.cpp
>@@ -88,38 +88,75 @@ bool RemoteRenderingBackend::waitForCommitImageBufferFlushContext()
> 
> std::unique_ptr<ImageBuffer> RemoteRenderingBackend::createImageBuffer(const FloatSize& size, ShouldAccelerate shouldAccelerate, float resolutionScale, ColorSpace colorSpace)
> {
>-    if (shouldAccelerate == ShouldAccelerate::Yes) {
>-        if (auto imageBuffer = AcceleratedRemoteImageBuffer::create(size, RenderingMode::RemoteAccelerated, resolutionScale, colorSpace, *this)) {
>-            m_imageBufferMessageHandlerMap.add(imageBuffer->imageBufferIdentifier(), imageBuffer.get());
>-            return imageBuffer;
>-        }
>-    }
>+    return m_remoteResourceCache.createImageBuffer(size, shouldAccelerate, resolutionScale, colorSpace);
>+}
> 
>-    if (auto imageBuffer = UnacceleratedRemoteImageBuffer::create(size, RenderingMode::RemoteUnaccelerated, resolutionScale, colorSpace, *this)) {
>-        m_imageBufferMessageHandlerMap.add(imageBuffer->imageBufferIdentifier(), imageBuffer.get());
>-        return imageBuffer;
>-    }
>+void RemoteRenderingBackend::releaseImageBuffer(ImageBuffer& image)
>+{
>+    m_remoteResourceCache.releaseImageBuffer(image);
>+}
> 
>-    return nullptr;
>+RefPtr<DisplayList::Item> RemoteRenderingBackend::createDrawImageBufferItem(ImageBuffer& image, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options, RemoteResourceIdentifier remoteClientIdentifier)
>+{
>+    return m_remoteResourceCache.createDrawImageBufferItem(image, destRect, srcRect, options, remoteClientIdentifier);
>+}
>+
>+RefPtr<DisplayList::Item> RemoteRenderingBackend::createDrawNativeImageItem(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options, CachedImage& cachedImage, RemoteResourceIdentifier remoteClientIdentifier)
>+{
>+    return m_remoteResourceCache.createDrawNativeImageItem(image, imageSize, destRect, srcRect, options, cachedImage, remoteClientIdentifier);
>+}
>+
>+void RemoteRenderingBackend::releaseRemoteClient(RemoteResourceIdentifier remoteClientIdentifier)
>+{
>+    m_remoteResourceCache.releaseRemoteClient(remoteClientIdentifier);
>+}
>+
>+RemoteResourceIdentifier RemoteRenderingBackend::remoteCreateImageBuffer(const FloatSize& size, RenderingMode renderingMode, float resolutionScale, ColorSpace colorSpace)
>+{
>+    RemoteResourceIdentifier remoteResourceIdentifier = RemoteResourceIdentifier::generate();
>+    send(Messages::RemoteRenderingBackendProxy::CreateImageBuffer(size, renderingMode, resolutionScale, colorSpace, remoteResourceIdentifier), m_renderingBackendIdentifier);
>+    return remoteResourceIdentifier;
>+}
>+
>+RefPtr<ImageData> RemoteRenderingBackend::remoteGetImageData(AlphaPremultiplication outputFormat, const IntRect& srcRect, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    IPC::ImageDataReference imageDataReference;
>+    sendSync(Messages::RemoteRenderingBackendProxy::GetImageData(outputFormat, srcRect, remoteResourceIdentifier), Messages::RemoteRenderingBackendProxy::GetImageData::Reply(imageDataReference), m_renderingBackendIdentifier, 1_s);
>+    return imageDataReference.buffer();
>+}
>+
>+void RemoteRenderingBackend::remoteFlushDrawingContext(const DisplayList::DisplayList& displayList, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    send(Messages::RemoteRenderingBackendProxy::FlushImageBufferDrawingContext(displayList, remoteResourceIdentifier), m_renderingBackendIdentifier);
>+}
>+
>+ImageBufferFlushIdentifier RemoteRenderingBackend::remoteFlushDrawingContextAndCommit(const DisplayList::DisplayList& displayList, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    ImageBufferFlushIdentifier sentFlushIdentifier = ImageBufferFlushIdentifier::generate();
>+    send(Messages::RemoteRenderingBackendProxy::FlushImageBufferDrawingContextAndCommit(displayList, sentFlushIdentifier, remoteResourceIdentifier), m_renderingBackendIdentifier);
>+    return sentFlushIdentifier;
>+}
>+
>+RemoteResourceIdentifier RemoteRenderingBackend::remoteCacheNativeImage(const NativeImagePtr& image)
>+{
>+    RemoteResourceIdentifier remoteResourceIdentifier = RemoteResourceIdentifier::generate();
>+    send(Messages::RemoteRenderingBackendProxy::CacheNativeImage(image, remoteResourceIdentifier), m_renderingBackendIdentifier);
>+    return remoteResourceIdentifier;
> }
> 
>-void RemoteRenderingBackend::releaseImageBuffer(ImageBufferIdentifier imageBufferIdentifier)
>+void RemoteRenderingBackend::remoteReleaseRemoteResource(RemoteResourceIdentifier remoteResourceIdentifier)
> {
>-    // CreateImageBuffer message should have been received before this one.
>-    bool found = m_imageBufferMessageHandlerMap.remove(imageBufferIdentifier);
>-    ASSERT_UNUSED(found, found);
>+    send(Messages::RemoteRenderingBackendProxy::ReleaseRemoteResource(remoteResourceIdentifier), m_renderingBackendIdentifier);
> }
> 
>-void RemoteRenderingBackend::createImageBufferBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, ImageBufferBackendHandle handle, ImageBufferIdentifier imageBufferIdentifier)
>+void RemoteRenderingBackend::createImageBufferBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, ImageBufferBackendHandle handle, RemoteResourceIdentifier remoteResourceIdentifier)
> {
>-    if (auto imageBuffer = m_imageBufferMessageHandlerMap.get(imageBufferIdentifier))
>-        imageBuffer->createBackend(logicalSize, backendSize, resolutionScale, colorSpace, WTFMove(handle));
>+    m_remoteResourceCache.createImageBufferBackend(logicalSize, backendSize, resolutionScale, colorSpace, WTFMove(handle), remoteResourceIdentifier);
> }
> 
>-void RemoteRenderingBackend::commitImageBufferFlushContext(ImageBufferFlushIdentifier flushIdentifier, ImageBufferIdentifier imageBufferIdentifier)
>+void RemoteRenderingBackend::commitImageBufferFlushContext(ImageBufferFlushIdentifier flushIdentifier, RemoteResourceIdentifier remoteResourceIdentifier)
> {
>-    if (auto imageBuffer = m_imageBufferMessageHandlerMap.get(imageBufferIdentifier))
>-        imageBuffer->commitFlushContext(flushIdentifier);
>+    m_remoteResourceCache.commitImageBufferFlushContext(flushIdentifier, remoteResourceIdentifier);
> }
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.h
>index f496158e7d40eeb05ac39434af24633babc7f0ef..e93330e75ac83c84c4cc9faaa277e328cfc565ff 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.h
>@@ -29,18 +29,24 @@
> 
> #include "ImageBufferBackendHandle.h"
> #include "ImageBufferFlushIdentifier.h"
>-#include "ImageBufferIdentifier.h"
> #include "MessageReceiver.h"
> #include "MessageSender.h"
> #include "RemoteImageBufferMessageHandler.h"
>+#include "RemoteResourceCache.h"
> #include "RenderingBackendIdentifier.h"
>-#include <WebCore/ColorSpace.h>
>-#include <WebCore/DisplayList.h>
>-#include <WebCore/FloatSize.h>
>-#include <WebCore/RenderingMode.h>
>-#include <wtf/HashMap.h>
>+#include <WebCore/RemoteResourceIdentifier.h>
> #include <wtf/WeakPtr.h>
> 
>+namespace WebCore {
>+namespace DisplayList {
>+class DisplayList;
>+class Item;
>+}
>+class FloatSize;
>+enum class ColorSpace : uint8_t;
>+enum class RenderingMode : uint8_t;
>+}
>+
> namespace WebKit {
> 
> class RemoteRenderingBackend
>@@ -52,8 +58,6 @@ public:
> 
>     ~RemoteRenderingBackend();
> 
>-    RenderingBackendIdentifier renderingBackendIdentifier() const { return m_renderingBackendIdentifier; }
>-
>     // IPC::MessageSender.
>     IPC::Connection* messageSenderConnection() const override;
>     uint64_t messageSenderDestinationID() const override;
>@@ -61,21 +65,32 @@ public:
>     // IPC::MessageReceiver
>     void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
> 
>-    std::unique_ptr<WebCore::ImageBuffer> createImageBuffer(const WebCore::FloatSize&, WebCore::ShouldAccelerate, float resolutionScale, WebCore::ColorSpace);
>-    void releaseImageBuffer(ImageBufferIdentifier);
>-
>     bool waitForCreateImageBufferBackend();
>     bool waitForCommitImageBufferFlushContext();
>+        
>+    // Resouce cache.
>+    std::unique_ptr<WebCore::ImageBuffer> createImageBuffer(const WebCore::FloatSize&, WebCore::ShouldAccelerate, float resolutionScale, WebCore::ColorSpace);
>+    void releaseImageBuffer(WebCore::ImageBuffer&);
>+    RefPtr<WebCore::DisplayList::Item> createDrawImageBufferItem(WebCore::ImageBuffer&, const WebCore::FloatRect& destRect, const WebCore::FloatRect& srcRect, const WebCore::ImagePaintingOptions&, WebCore::RemoteResourceIdentifier);
>+    RefPtr<WebCore::DisplayList::Item> createDrawNativeImageItem(const WebCore::NativeImagePtr&, const WebCore::FloatSize& imageSize, const WebCore::FloatRect& destRect, const WebCore::FloatRect& srcRect, const WebCore::ImagePaintingOptions&, WebCore::CachedImage&, WebCore::RemoteResourceIdentifier);
>+    void releaseRemoteClient(WebCore::RemoteResourceIdentifier);
>+
>+    // Messages to be sent.
>+    WebCore::RemoteResourceIdentifier remoteCreateImageBuffer(const WebCore::FloatSize&, WebCore::RenderingMode, float resolutionScale, WebCore::ColorSpace);
>+    RefPtr<WebCore::ImageData> remoteGetImageData(WebCore::AlphaPremultiplication outputFormat, const WebCore::IntRect& srcRect, WebCore::RemoteResourceIdentifier);
>+    void remoteFlushDrawingContext(const WebCore::DisplayList::DisplayList&, WebCore::RemoteResourceIdentifier);
>+    ImageBufferFlushIdentifier remoteFlushDrawingContextAndCommit(const WebCore::DisplayList::DisplayList&, WebCore::RemoteResourceIdentifier);
>+    WebCore::RemoteResourceIdentifier remoteCacheNativeImage(const WebCore::NativeImagePtr&);
>+    void remoteReleaseRemoteResource(WebCore::RemoteResourceIdentifier);
> 
> private:
>     RemoteRenderingBackend();
> 
>     // Messages to be received.
>-    void createImageBufferBackend(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle, ImageBufferIdentifier);
>-    void commitImageBufferFlushContext(ImageBufferFlushIdentifier, ImageBufferIdentifier);
>+    void createImageBufferBackend(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle, WebCore::RemoteResourceIdentifier);
>+    void commitImageBufferFlushContext(ImageBufferFlushIdentifier, WebCore::RemoteResourceIdentifier);
> 
>-    using ImageBufferMessageHandlerMap = HashMap<ImageBufferIdentifier, RemoteImageBufferMessageHandler*>;
>-    ImageBufferMessageHandlerMap m_imageBufferMessageHandlerMap;
>+    RemoteResourceCache m_remoteResourceCache { *this };
>     RenderingBackendIdentifier m_renderingBackendIdentifier { RenderingBackendIdentifier::generate() };
> };
> 
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.messages.in b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.messages.in
>index 12a7bf8da4c82570bca36a135fd71af2588b64d5..2c0f7e8a1203f268652a00fc1f7b17da599d2aa8 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.messages.in
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.messages.in
>@@ -23,8 +23,8 @@
> #if ENABLE(GPU_PROCESS)
> 
> messages -> RemoteRenderingBackend NotRefCounted {
>-    void CreateImageBufferBackend(WebCore::FloatSize logicalSize, WebCore::IntSize backendSize, float resolutionScale, WebCore::ColorSpace colorSpace, WebKit::ImageBufferBackendHandle handle, WebKit::ImageBufferIdentifier imageBufferIdentifier)
>-    void CommitImageBufferFlushContext(WebKit::ImageBufferFlushIdentifier flushIdentifier, WebKit::ImageBufferIdentifier imageBufferIdentifier)
>+    void CreateImageBufferBackend(WebCore::FloatSize logicalSize, WebCore::IntSize backendSize, float resolutionScale, WebCore::ColorSpace colorSpace, WebKit::ImageBufferBackendHandle handle, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
>+    void CommitImageBufferFlushContext(WebKit::ImageBufferFlushIdentifier flushIdentifier, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
> }
> 
> #endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCache.cpp b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCache.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..63f972c10dd1cad2b70d6c34155f715e85821b3c
>--- /dev/null
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCache.cpp
>@@ -0,0 +1,197 @@
>+/*
>+ * Copyright (C) 2020 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. AND ITS CONTRIBUTORS ``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 ITS 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 "config.h"
>+#include "RemoteResourceCache.h"
>+
>+#if ENABLE(GPU_PROCESS)
>+
>+#include "PlatformRemoteImageBuffer.h"
>+#include "RemoteRenderingBackend.h"
>+#include "RemoteRenderingBackendProxyMessages.h"
>+#include "WebPage.h"
>+#include <WebCore/CachedImage.h>
>+#include <WebCore/Settings.h>
>+
>+namespace WebKit {
>+using namespace WebCore;
>+
>+RemoteResourceCache::RemoteResourceCache(RemoteRenderingBackend& remoteRenderingBackend)
>+    : m_remoteRenderingBackend(remoteRenderingBackend)
>+{
>+}
>+
>+std::unique_ptr<ImageBuffer> RemoteResourceCache::createImageBuffer(const FloatSize& size, ShouldAccelerate shouldAccelerate, float resolutionScale, ColorSpace colorSpace)
>+{
>+    if (shouldAccelerate == ShouldAccelerate::Yes) {
>+        if (auto imageBuffer = AcceleratedRemoteImageBuffer::create(size, RenderingMode::RemoteAccelerated, resolutionScale, colorSpace, m_remoteRenderingBackend)) {
>+            m_remoteImageBufferHashMap.add(imageBuffer.get(), imageBuffer->remoteResourceIdentifier());
>+            m_remoteImageBufferMessageHandlerHashMap.add(imageBuffer->remoteResourceIdentifier(), imageBuffer.get());
>+            return imageBuffer;
>+        }
>+    }
>+
>+    if (auto imageBuffer = UnacceleratedRemoteImageBuffer::create(size, RenderingMode::RemoteUnaccelerated, resolutionScale, colorSpace, m_remoteRenderingBackend)) {
>+        m_remoteImageBufferHashMap.add(imageBuffer.get(), imageBuffer->remoteResourceIdentifier());
>+        m_remoteImageBufferMessageHandlerHashMap.add(imageBuffer->remoteResourceIdentifier(), imageBuffer.get());
>+        return imageBuffer;
>+    }
>+
>+    return nullptr;
>+}
>+
>+void RemoteResourceCache::createImageBufferBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, ImageBufferBackendHandle handle, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    if (auto imageBuffer = m_remoteImageBufferMessageHandlerHashMap.get(remoteResourceIdentifier))
>+        imageBuffer->createBackend(logicalSize, backendSize, resolutionScale, colorSpace, WTFMove(handle));
>+}
>+
>+void RemoteResourceCache::commitImageBufferFlushContext(ImageBufferFlushIdentifier flushIdentifier, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    if (auto imageBuffer = m_remoteImageBufferMessageHandlerHashMap.get(remoteResourceIdentifier))
>+        imageBuffer->commitFlushContext(flushIdentifier);
>+}
>+
>+RefPtr<WebCore::DisplayList::Item> RemoteResourceCache::createDrawImageBufferItem(WebCore::ImageBuffer& image, const WebCore::FloatRect& destRect, const WebCore::FloatRect& srcRect, const WebCore::ImagePaintingOptions& options, RemoteResourceIdentifier remoteClientIdentifier)
>+{
>+    auto remoteResourceIdentifier = findImageBufferForClient(image, remoteClientIdentifier);
>+    if (!remoteResourceIdentifier)
>+        return nullptr;
>+    // Flush the DrawingContext of the source ImageBuffer so this ImageBuffer gets an updated image.
>+    image.flushDrawingContext();
>+    return WebCore::DisplayList::DrawImageBuffer::create(remoteResourceIdentifier, destRect, srcRect, options);
>+}
>+
>+RefPtr<WebCore::DisplayList::Item> RemoteResourceCache::createDrawNativeImageItem(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options, CachedImage& cachedImage, RemoteResourceIdentifier remoteClientIdentifier)
>+{
>+    auto remoteResourceIdentifier = findNativeImageForClient(cachedImage, image, remoteClientIdentifier);
>+    if (!remoteResourceIdentifier)
>+        return nullptr;
>+    return WebCore::DisplayList::DrawNativeImage::create(remoteResourceIdentifier, imageSize, destRect, srcRect, options);
>+}
>+
>+RemoteResourceIdentifier RemoteResourceCache::releaseImageBuffer(ImageBuffer& image)
>+{
>+    // Remove the resource from the cache.
>+    auto remoteResourceIdentifier = m_remoteImageBufferHashMap.take(&image);
>+    ASSERT(remoteResourceIdentifier);
>+
>+    // createImageBuffer should have been returned this ImageBuffer before.
>+    bool found = m_remoteImageBufferMessageHandlerHashMap.remove(remoteResourceIdentifier);
>+    ASSERT_UNUSED(found, found);
>+
>+    // Tell the GPU process to remove this resource unless it's pending replaying back.
>+    releaseRemoteResourcePendingRemoveClients(remoteResourceIdentifier);
>+    return remoteResourceIdentifier;
>+}
>+
>+RemoteResourceIdentifier RemoteResourceCache::releaseNativeImage(const WebCore::NativeImagePtr& image)
>+{
>+    // Remove the resource from the cache.
>+    auto remoteResourceIdentifier = m_remoteNativeImageHashMap.take(image);
>+
>+    // Tell the GPU process to remove this resource unless it's pending replaying back.
>+    if (remoteResourceIdentifier)
>+        releaseRemoteResourcePendingRemoveClients(remoteResourceIdentifier);
>+    return remoteResourceIdentifier;
>+}
>+
>+RemoteResourceIdentifier RemoteResourceCache::findImageBufferForClient(ImageBuffer& image, RemoteResourceIdentifier remoteClientIdentifier)
>+{
>+    auto remoteResourceIdentifier = m_remoteImageBufferHashMap.get(&image);
>+    addRemoteClient(remoteResourceIdentifier, remoteClientIdentifier);
>+    return remoteResourceIdentifier;
>+}
>+
>+RemoteResourceIdentifier RemoteResourceCache::findNativeImageForClient(WebCore::CachedImage& cachedImage, const NativeImagePtr& image, RemoteResourceIdentifier remoteClientIdentifier)
>+{
>+    auto remoteResourceIdentifier = m_remoteNativeImageHashMap.ensure(image, [&] {
>+        cachedImage.addClient(*this);
>+        return m_remoteRenderingBackend.remoteCacheNativeImage(image);
>+    }).iterator->value;
>+
>+    addRemoteClient(remoteResourceIdentifier, remoteClientIdentifier);
>+    return remoteResourceIdentifier;
>+}
>+
>+void RemoteResourceCache::addRemoteClient(RemoteResourceIdentifier remoteResourceIdentifier, RemoteResourceIdentifier remoteClientIdentifier)
>+{
>+    if (!remoteResourceIdentifier)
>+        return;
>+
>+    // Add the "resource -> client" dependency in m_remoteResourceClientsHashMap.
>+    auto& clients = m_remoteResourceClientsHashMap.ensure(remoteResourceIdentifier, [&] {
>+        return RemoteClientsHashSet();
>+    }).iterator->value;
>+
>+    clients.add(remoteClientIdentifier);
>+}
>+
>+void RemoteResourceCache::releaseRemoteResourcePendingRemoveClients(RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    ASSERT(!m_remoteResourceClientsPendingReleaseHashMap.contains(remoteResourceIdentifier));
>+
>+    // If we have recorded the resource -> client dependency before in m_remoteResourceClientsHashMap, move this
>+    // dependency to m_remoteResourceClientsPendingReleaseHashMap. Otherwise remove the resource from the cache.
>+    if (m_remoteResourceClientsHashMap.contains(remoteResourceIdentifier))
>+        m_remoteResourceClientsPendingReleaseHashMap.add(remoteResourceIdentifier, m_remoteResourceClientsHashMap.take(remoteResourceIdentifier));
>+    else
>+        m_remoteRenderingBackend.remoteReleaseRemoteResource(remoteResourceIdentifier);
>+}
>+
>+Vector<RemoteResourceIdentifier> RemoteResourceCache::removeRemoteClient(RemoteResourceClientsHashMap& remoteResourceClientsHashMap, RemoteResourceIdentifier remoteClientIdentifier)
>+{
>+    Vector<RemoteResourceIdentifier> remoteResourceClientsToBeRemoved;
>+
>+    // Remove all the resource -> client dependencies from remoteResourceClientsHashMap.
>+    for (auto& pair : remoteResourceClientsHashMap) {
>+        pair.value.remove(remoteClientIdentifier);
>+        if (pair.value.isEmpty())
>+            remoteResourceClientsToBeRemoved.append(pair.key);
>+    }
>+
>+    // Return a list of the unreferenced resources.
>+    return remoteResourceClientsToBeRemoved;
>+}
>+
>+void RemoteResourceCache::releaseRemoteClient(RemoteResourceIdentifier remoteClientIdentifier)
>+{
>+    // Remove all the resource -> client dependencies from m_remoteResourceClientsHashMap.
>+    for (auto remoteResourceIdentifier : removeRemoteClient(m_remoteResourceClientsHashMap, remoteClientIdentifier))
>+        m_remoteResourceClientsHashMap.remove(remoteResourceIdentifier);
>+
>+    // Remove all the resource -> client dependencies from m_remoteResourceClientsPendingReleaseHashMap.
>+    for (auto remoteResourceIdentifier : removeRemoteClient(m_remoteResourceClientsPendingReleaseHashMap, remoteClientIdentifier)) {
>+        // Remove the unreferenced resources from m_remoteResourceClientsPendingReleaseHashMap.
>+        m_remoteResourceClientsPendingReleaseHashMap.remove(remoteResourceIdentifier);
>+
>+        // Tell the GPU process to remove this resource.
>+        m_remoteRenderingBackend.remoteReleaseRemoteResource(remoteResourceIdentifier);
>+    }
>+}
>+
>+} // namespace WebKit
>+
>+#endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCache.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCache.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..e17801151c6a1d2443e367d66a48166c3bf0e80d
>--- /dev/null
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCache.h
>@@ -0,0 +1,94 @@
>+/*
>+ * Copyright (C) 2020 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.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(GPU_PROCESS)
>+
>+#include "ImageBufferBackendHandle.h"
>+#include "ImageBufferFlushIdentifier.h"
>+#include <WebCore/CachedImageClient.h>
>+#include <WebCore/ImageBuffer.h>
>+#include <WebCore/RemoteResourceIdentifier.h>
>+#include <wtf/HashMap.h>
>+#include <wtf/HashSet.h>
>+
>+namespace WebCore {
>+namespace DisplayList {
>+class Item;
>+}
>+enum class ColorSpace : uint8_t;
>+class Color;
>+class FloatRect;
>+class FloatSize;
>+}
>+
>+namespace WebKit {
>+
>+class RemoteImageBufferMessageHandler;
>+class RemoteRenderingBackend;
>+
>+class RemoteResourceCache : public WebCore::CachedImageClient {
>+public:
>+    RemoteResourceCache(RemoteRenderingBackend&);
>+
>+    std::unique_ptr<WebCore::ImageBuffer> createImageBuffer(const WebCore::FloatSize&, WebCore::ShouldAccelerate, float resolutionScale, WebCore::ColorSpace);
>+    void createImageBufferBackend(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle, WebCore::RemoteResourceIdentifier);
>+    void commitImageBufferFlushContext(ImageBufferFlushIdentifier, WebCore::RemoteResourceIdentifier);
>+
>+    RefPtr<WebCore::DisplayList::Item> createDrawImageBufferItem(WebCore::ImageBuffer&, const WebCore::FloatRect& destRect, const WebCore::FloatRect& srcRect, const WebCore::ImagePaintingOptions&, WebCore::RemoteResourceIdentifier);
>+    RefPtr<WebCore::DisplayList::Item> createDrawNativeImageItem(const WebCore::NativeImagePtr&, const WebCore::FloatSize& imageSize, const WebCore::FloatRect& destRect, const WebCore::FloatRect& srcRect, const WebCore::ImagePaintingOptions&, WebCore::CachedImage&, WebCore::RemoteResourceIdentifier);
>+
>+    WebCore::RemoteResourceIdentifier releaseImageBuffer(WebCore::ImageBuffer&);
>+    WebCore::RemoteResourceIdentifier releaseNativeImage(const WebCore::NativeImagePtr&);
>+    void releaseRemoteClient(WebCore::RemoteResourceIdentifier remoteClientIdentifier);
>+
>+private:
>+    using RemoteClientsHashSet = HashSet<WebCore::RemoteResourceIdentifier>;
>+    using RemoteImageBufferHashMap = HashMap<WebCore::ImageBuffer*, WebCore::RemoteResourceIdentifier>;
>+    using RemoteNativeImageHashMap = HashMap<WebCore::NativeImagePtr, WebCore::RemoteResourceIdentifier>;
>+    using RemoteResourceClientsHashMap = HashMap<WebCore::RemoteResourceIdentifier, RemoteClientsHashSet>;
>+    using RemoteImageBufferMessageHandlerHashMap = HashMap<WebCore::RemoteResourceIdentifier, RemoteImageBufferMessageHandler*>;
>+
>+    void nativeImageWillBeDestroyed(const WebCore::NativeImagePtr& image) override { releaseNativeImage(image); }
>+
>+    WebCore::RemoteResourceIdentifier findImageBufferForClient(WebCore::ImageBuffer&, WebCore::RemoteResourceIdentifier);
>+    WebCore::RemoteResourceIdentifier findNativeImageForClient(WebCore::CachedImage&, const WebCore::NativeImagePtr&, WebCore::RemoteResourceIdentifier remoteClientIdentifier);
>+
>+    void addRemoteClient(WebCore::RemoteResourceIdentifier, WebCore::RemoteResourceIdentifier remoteClientIdentifier);
>+    Vector<WebCore::RemoteResourceIdentifier> removeRemoteClient(RemoteResourceClientsHashMap&, WebCore::RemoteResourceIdentifier remoteClientIdentifier);
>+    void releaseRemoteResourcePendingRemoveClients(WebCore::RemoteResourceIdentifier);
>+
>+    RemoteImageBufferHashMap m_remoteImageBufferHashMap;
>+    RemoteNativeImageHashMap m_remoteNativeImageHashMap;
>+    RemoteResourceClientsHashMap m_remoteResourceClientsHashMap;
>+    RemoteResourceClientsHashMap m_remoteResourceClientsPendingReleaseHashMap;
>+    RemoteImageBufferMessageHandlerHashMap m_remoteImageBufferMessageHandlerHashMap;
>+    RemoteRenderingBackend& m_remoteRenderingBackend;
>+};
>+
>+} // namespace WebKit
>+
>+#endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/WebProcess/Gamepad/WebGamepadProvider.cpp b/Source/WebKit/WebProcess/Gamepad/WebGamepadProvider.cpp
>index 1ae515725361d22821914aed0f28bb16e76358ff..30050ac07dc9ad5c83f3de2832906a987410d3f8 100644
>--- a/Source/WebKit/WebProcess/Gamepad/WebGamepadProvider.cpp
>+++ b/Source/WebKit/WebProcess/Gamepad/WebGamepadProvider.cpp
>@@ -29,6 +29,7 @@
> #if ENABLE(GAMEPAD)
> 
> #include "GamepadData.h"
>+#include "Logging.h"
> #include "WebGamepad.h"
> #include "WebProcess.h"
> #include "WebProcessPoolMessages.h"

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