Attachment 410738 Details for Bug 217342 – Patch

[patch] Patch

bug-217342-20201007020018.patch (text/plain), 185.69 KB, created by Said Abou-Hallawa on 2020-10-07 02:00:19 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Said Abou-Hallawa

Created: 2020-10-07 02:00:19 PDT

Size: 185.69 KB

patch

obsolete

>Subversion Revision: 267970
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 1ceaac441146f5876c467de0fd3b3faa4b5712c4..c8331c145095af6bc2b0edf58ff9737a8ef39ae1 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,109 @@
>+2020-10-07  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        [GPU Process] Implement GPU rendering resource cache
>+        https://bugs.webkit.org/show_bug.cgi?id=217342
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This is a work in progress patch. The goal is to get the EWS bots clean 
>+        first. Then it may be split into smaller patches.
>+
>+        * Headers.cmake:
>+        * WebCore.xcodeproj/project.pbxproj:
>+        * 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::drawGPUBadge):
>+        (WebCore::GraphicsContext::drawNativeImage):
>+        (WebCore::GraphicsContext::drawImage):
>+        (WebCore::GraphicsContext::drawTiledImage):
>+        (WebCore::GraphicsContext::drawImageBuffer):
>+        * platform/graphics/GraphicsContext.h:
>+        (WebCore::GraphicsContext::drawNativeImage):
>+        * platform/graphics/GraphicsContextImpl.h:
>+        * platform/graphics/Image.h:
>+        * platform/graphics/ImageBuffer.h:
>+        (WebCore::ImageBuffer::flushDrawingContext):
>+        * platform/graphics/ImageBufferBackend.h:
>+        * platform/graphics/ImageObserver.h:
>+        * platform/graphics/ImageSource.cpp:
>+        (WebCore::ImageSource::destroyDecodedData):
>+        * platform/graphics/NativeImage.h:
>+        * platform/graphics/NativeImagePtr.h: Copied from Source/WebCore/platform/graphics/NativeImage.h.
>+        * platform/graphics/RemoteResourceIdentifier.h: Renamed from Source/WebKit/WebProcess/GPU/graphics/ImageBufferIdentifier.h.
>+        * platform/graphics/cairo/GraphicsContextCairo.cpp:
>+        (WebCore::GraphicsContext::platformDrawNativeImage):
>+        (WebCore::GraphicsContext::drawNativeImage): Deleted.
>+        * platform/graphics/cairo/GraphicsContextImplCairo.cpp:
>+        (WebCore::GraphicsContextImplCairo::drawNativeImage):
>+        (WebCore::GraphicsContextImplCairo::drawImageBuffer):
>+        * platform/graphics/cairo/GraphicsContextImplCairo.h:
>+        * 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/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::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::remoteResourceIdentifier const):
>+        (WebCore::DisplayList::DrawNativeImage::nativeImagePtr const):
>+        (WebCore::DisplayList::DrawNativeImage::create):
>+        (WebCore::DisplayList::DrawNativeImage::imageSize const):
>+        (WebCore::DisplayList::DrawNativeImage::options const):
>+        (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:
>+        (WebCore::DisplayList::Recorder::Recorder):
>+        (WebCore::DisplayList::Recorder::putImageData):
>+        (WebCore::DisplayList::Recorder::willAppendItem):
>+        (WebCore::DisplayList::Recorder::drawNativeImage):
>+        (WebCore::DisplayList::Recorder::drawImageBuffer):
>+        * platform/graphics/displaylists/DisplayListRecorder.h:
>+        (WebCore::DisplayList::Recorder::Delegate::~Delegate):
>+        (WebCore::DisplayList::Recorder::Delegate::createDrawNativeImageItem):
>+        (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::drawNativeImage):
>+        (Nicosia::CairoOperationRecorder::drawImageBuffer):
>+        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h:
>+        * platform/graphics/win/GraphicsContextDirect2D.cpp:
>+        (WebCore::GraphicsContext::platformDrawNativeImage):
>+        (WebCore::GraphicsContext::drawNativeImage): Deleted.
>+
> 2020-10-05  Sam Weinig  <weinig@apple.com>
> 
>         Remove support for enabling subpixel CSSOM values, it's off by default everywhere and known to be not-compatible with the web
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 814400ffcdc43fb7ae3871486676f68dfe8e7f7a..22634314453d707ef5b28c39a48ecf58bdf45fbf 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,104 @@
>+2020-10-07  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        [GPU Process] Implement GPU rendering resource cache
>+        https://bugs.webkit.org/show_bug.cgi?id=217342
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.cpp: Removed.
>+        * GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.h: Removed.
>+        * GPUProcess/graphics/RemoteImageBufferProxy.h:
>+        (WebKit::RemoteImageBufferProxy::create):
>+        (WebKit::RemoteImageBufferProxy::RemoteImageBufferProxy):
>+        * GPUProcess/graphics/RemoteRenderingBackendProxy.cpp:
>+        (WebKit::RemoteRenderingBackendProxy::applyResourceItem):
>+        (WebKit::RemoteRenderingBackendProxy::remoteCreateImageBufferBackend):
>+        (WebKit::RemoteRenderingBackendProxy::createImageBuffer):
>+        (WebKit::RemoteRenderingBackendProxy::flushImageBufferDrawingContext):
>+        (WebKit::RemoteRenderingBackendProxy::flushImageBufferDrawingContextAndCommit):
>+        (WebKit::RemoteRenderingBackendProxy::getImageData):
>+        (WebKit::RemoteRenderingBackendProxy::cacheNativeImage):
>+        (WebKit::RemoteRenderingBackendProxy::releaseRemoteResource):
>+        (WebKit::RemoteRenderingBackendProxy::releaseImageBuffer): Deleted.
>+        * GPUProcess/graphics/RemoteRenderingBackendProxy.h:
>+        (WebKit::RemoteRenderingBackendProxy::renderingBackendIdentifier const): Deleted.
>+        * GPUProcess/graphics/RemoteRenderingBackendProxy.messages.in:
>+        * GPUProcess/graphics/RemoteResourceCacheProxy.cpp: Added.
>+        (WebKit::RemoteResourceCacheProxy::RemoteResourceCacheProxy):
>+        (WebKit::RemoteResourceCacheProxy::createImageBuffer):
>+        (WebKit::RemoteResourceCacheProxy::flushDrawingContext):
>+        (WebKit::RemoteResourceCacheProxy::flushDrawingContextAndCommit):
>+        (WebKit::RemoteResourceCacheProxy::getImageData const):
>+        (WebKit::RemoteResourceCacheProxy::cacheNativeImage):
>+        (WebKit::RemoteResourceCacheProxy::drawGPUBadge const):
>+        (WebKit::RemoteResourceCacheProxy::drawNativeImageItem const):
>+        (WebKit::RemoteResourceCacheProxy::drawImageBufferItem const):
>+        (WebKit::RemoteResourceCacheProxy::applyResourceItem const):
>+        (WebKit::RemoteResourceCacheProxy::releaseRemoteResource):
>+        * GPUProcess/graphics/RemoteResourceCacheProxy.h: Added.
>+        * 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):
>+        * 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::create):
>+        (WebKit::RemoteRenderingBackend::RemoteRenderingBackend):
>+        (WebKit::RemoteRenderingBackend::drawGPUBadge):
>+        (WebKit::RemoteRenderingBackend::createImageBuffer):
>+        (WebKit::RemoteRenderingBackend::releaseImageBuffer):
>+        (WebKit::RemoteRenderingBackend::createDrawImageBufferItem):
>+        (WebKit::RemoteRenderingBackend::createDrawNativeImageItem):
>+        (WebKit::RemoteRenderingBackend::releaseRemoteClient):
>+        (WebKit::RemoteRenderingBackend::remoteCreateImageBuffer):
>+        (WebKit::RemoteRenderingBackend::remoteCacheNativeImage):
>+        (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/RemoteRenderingBackend.messages.in:
>+        * WebProcess/GPU/graphics/RemoteResourceCache.cpp: Added.
>+        (WebKit::RemoteResourceCache::RemoteResourceCache):
>+        (WebKit::RemoteResourceCache::shouldDrawGPUBadge const):
>+        (WebKit::RemoteResourceCache::drawGPUBadge):
>+        (WebKit::RemoteResourceCache::createImageBuffer):
>+        (WebKit::RemoteResourceCache::createImageBufferBackend):
>+        (WebKit::RemoteResourceCache::commitImageBufferFlushContext):
>+        (WebKit::RemoteResourceCache::createDrawImageBufferItem):
>+        (WebKit::RemoteResourceCache::createDrawNativeImageItem):
>+        (WebKit::RemoteResourceCache::releaseImageBuffer):
>+        (WebKit::RemoteResourceCache::releaseNativeImage):
>+        (WebKit::RemoteResourceCache::findImageBufferForClient):
>+        (WebKit::RemoteResourceCache::findNativeImageForClient):
>+        (WebKit::RemoteResourceCache::addRemoteClient):
>+        (WebKit::RemoteResourceCache::removeRemoteClient):
>+        (WebKit::RemoteResourceCache::releaseRemoteResourcePendingRemoveClients):
>+        (WebKit::RemoteResourceCache::releaseRemoteClient):
>+        * WebProcess/GPU/graphics/RemoteResourceCache.h: Added.
>+        * WebProcess/WebCoreSupport/WebChromeClient.cpp:
>+        (WebKit::WebChromeClient::ensureRemoteRenderingBackend const):
>+
> 2020-10-05  Sam Weinig  <weinig@apple.com>
> 
>         Remove support for enabling subpixel CSSOM values, it's off by default everywhere and known to be not-compatible with the web
>diff --git a/Source/WebCore/Headers.cmake b/Source/WebCore/Headers.cmake
>index 5656f7b30703dfe335399ea89abc35ed31d4c5d7..41b69ea5bc7d284fbbbf20c83889972567c13c4f 100644
>--- a/Source/WebCore/Headers.cmake
>+++ b/Source/WebCore/Headers.cmake
>@@ -1190,6 +1190,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
>@@ -1203,6 +1204,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 bf0410a0e8c78fbfc0f71c20e4334e0136530c46..c6047114cf8655e56b5a6ac64a6adc8fa1dc662a 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -2167,6 +2167,8 @@
> 		7299BC6823D6A53E00CC6883 /* RenderingMode.h in Headers */ = {isa = PBXBuildFile; fileRef = 7299BC6623D686C600CC6883 /* RenderingMode.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, ); }; };
>+		72BEFA1A251BEFFE00DD78D2 /* RemoteResourceIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 72BEFA19251BEFFD00DD78D2 /* RemoteResourceIdentifier.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		72DCA1E82523DFC000C9B20D /* NativeImagePtr.h in Headers */ = {isa = PBXBuildFile; fileRef = 72DCA1E62523DE5500C9B20D /* NativeImagePtr.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		7553CFE8108F473F00EA281E /* TimelineRecordFactory.h in Headers */ = {isa = PBXBuildFile; fileRef = 7553CFE6108F473F00EA281E /* TimelineRecordFactory.h */; };
> 		75793E840D0CE0B3007FC0AC /* MessageEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = 75793E810D0CE0B3007FC0AC /* MessageEvent.h */; };
> 		75793EC90D0CE72D007FC0AC /* JSMessageEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = 75793EC70D0CE72D007FC0AC /* JSMessageEvent.h */; };
>@@ -9932,7 +9934,9 @@
> 		72BAC3AB23E1E544008D741C /* ImageBufferIOSurfaceBackend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageBufferIOSurfaceBackend.h; sourceTree = "<group>"; };
> 		72BAC3AC23E1E545008D741C /* ImageBufferCGBackend.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageBufferCGBackend.cpp; sourceTree = "<group>"; };
> 		72BAC3AD23E1E545008D741C /* ImageBufferCGBackend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageBufferCGBackend.h; sourceTree = "<group>"; };
>+		72BEFA19251BEFFD00DD78D2 /* RemoteResourceIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RemoteResourceIdentifier.h; sourceTree = "<group>"; };
> 		72C18A3F230B04B7006847C7 /* ImagePaintingOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ImagePaintingOptions.h; sourceTree = "<group>"; };
>+		72DCA1E62523DE5500C9B20D /* NativeImagePtr.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = NativeImagePtr.h; sourceTree = "<group>"; };
> 		72E417611A2E8D2F004C562A /* JSEXTsRGB.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSEXTsRGB.cpp; sourceTree = "<group>"; };
> 		72E417621A2E8D2F004C562A /* JSEXTsRGB.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSEXTsRGB.h; sourceTree = "<group>"; };
> 		72EA09F723FCCB3D008504A5 /* DisplayListImageBuffer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DisplayListImageBuffer.h; sourceTree = "<group>"; };
>@@ -26197,6 +26201,7 @@
> 				314BE3A51B3103FB00141982 /* NamedImageGeneratedImage.h */,
> 				6B3480920EEF50D400AC1B41 /* NativeImage.h */,
> 				55A336F61D8209F40022C4C7 /* NativeImage.h */,
>+				72DCA1E62523DE5500C9B20D /* NativeImagePtr.h */,
> 				B27535520B053814002CE64F /* Path.cpp */,
> 				B27535530B053814002CE64F /* Path.h */,
> 				A88DD4880B4629B000C02990 /* PathTraversalState.cpp */,
>@@ -26214,6 +26219,7 @@
> 				074E82B918A69F0E007EF54C /* PlatformTimeRanges.h */,
> 				BCAB417F13E356E800D8AAF3 /* Region.cpp */,
> 				BCAB418013E356E800D8AAF3 /* Region.h */,
>+				72BEFA19251BEFFD00DD78D2 /* RemoteResourceIdentifier.h */,
> 				073A15512177A39800EA08F2 /* RemoteVideoSample.cpp */,
> 				073A15532177A39A00EA08F2 /* RemoteVideoSample.h */,
> 				7299BC6623D686C600CC6883 /* RenderingMode.h */,
>@@ -31180,9 +31186,7 @@
> 				835D54C51F4DE53800E60671 /* DirectoryFileListCreator.h in Headers */,
> 				F47A09D120A93A9700240FAE /* DisabledAdaptations.h in Headers */,
> 				7EDAAFC919A2CCDC0034DFD1 /* DiskCacheMonitorCocoa.h in Headers */,
>-				E451C6342394058F00993190 /* LayoutIntegrationInlineContent.h in Headers */,
> 				0F790F422517CE6E009BA034 /* DisplayLayerController.h in Headers */,
>-				6FB47E632277425A00C7BCB0 /* LayoutIntegrationLine.h in Headers */,
> 				0FE5FBD31C3DD51E0007A2CA /* DisplayList.h in Headers */,
> 				55AD09402408964000DE4D2F /* DisplayListDrawingContext.h in Headers */,
> 				55AD093E2408963500DE4D2F /* DisplayListImageBuffer.h in Headers */,
>@@ -31195,7 +31199,6 @@
> 				2D29ECCA192F1F1D00984B78 /* DisplayRefreshMonitorIOS.h in Headers */,
> 				2DE70023192FE82A00B0975C /* DisplayRefreshMonitorMac.h in Headers */,
> 				2D29ECC8192ECC8300984B78 /* DisplayRefreshMonitorManager.h in Headers */,
>-				6FCE1A1A22618ABD004F0343 /* LayoutIntegrationRun.h in Headers */,
> 				0F790F432517CE6E009BA034 /* DisplayView.h in Headers */,
> 				FD31609112B026F700C1A359 /* Distance.h in Headers */,
> 				83040283249A7A6200A90D8D /* DistanceModelType.h in Headers */,
>@@ -31886,6 +31889,7 @@
> 				6FC3F9472516756700A49BEA /* InlineLineRun.h in Headers */,
> 				F45775CE241437D5002DF1A0 /* InlinePathData.h in Headers */,
> 				6F40DA822513033A00EC04B7 /* InlineRect.h in Headers */,
>+				E4D33F3B252AEECD00837D05 /* InlineRunAndOffset.h in Headers */,
> 				6F360E5023999421001512A7 /* InlineSoftLineBreakItem.h in Headers */,
> 				AA4C3A770B2B1679002334A2 /* InlineStyleSheetOwner.h in Headers */,
> 				BCEA485A097D93020094C9E4 /* InlineTextBox.h in Headers */,
>@@ -32854,8 +32858,11 @@
> 				6F0B98B523F268EC00EEC2F2 /* LayoutInlineTextBox.h in Headers */,
> 				E418025523D4549B00FFB071 /* LayoutIntegrationBoxTree.h in Headers */,
> 				E403B7A2251B11930019E800 /* LayoutIntegrationCoverage.h in Headers */,
>+				E451C6342394058F00993190 /* LayoutIntegrationInlineContent.h in Headers */,
>+				6FB47E632277425A00C7BCB0 /* LayoutIntegrationLine.h in Headers */,
> 				E4ABABDD236088FE00FA4345 /* LayoutIntegrationLineLayout.h in Headers */,
> 				E403B7A3251B11C10019E800 /* LayoutIntegrationPagination.h in Headers */,
>+				6FCE1A1A22618ABD004F0343 /* LayoutIntegrationRun.h in Headers */,
> 				E4A664CC2521D4AF007081DC /* LayoutIntegrationRunIterator.h in Headers */,
> 				E4A664CF2521D4E2007081DC /* LayoutIntegrationRunIteratorLegacyPath.h in Headers */,
> 				E4A664CE2521D4C9007081DC /* LayoutIntegrationRunIteratorModernPath.h in Headers */,
>@@ -33118,6 +33125,7 @@
> 				A81872230977D3C0005826D9 /* NamedNodeMap.h in Headers */,
> 				A818721E0977D3C0005826D9 /* NameNodeList.h in Headers */,
> 				6B3480940EEF50D400AC1B41 /* NativeImage.h in Headers */,
>+				72DCA1E82523DFC000C9B20D /* NativeImagePtr.h in Headers */,
> 				83B2D1751B8BCD6A00A02E47 /* NativeNodeFilter.h in Headers */,
> 				E10B9B6C0B747599003ED890 /* NativeXPathNSResolver.h in Headers */,
> 				93CCF0270AF6C52900018E89 /* NavigationAction.h in Headers */,
>@@ -33488,6 +33496,7 @@
> 				46B9519A207D635400A7D2DD /* RemoteFrame.h in Headers */,
> 				CDC312E922FCD7C0001204EC /* RemotePlayback.h in Headers */,
> 				CDC312EB22FCD7C9001204EC /* RemotePlaybackAvailabilityCallback.h in Headers */,
>+				72BEFA1A251BEFFE00DD78D2 /* RemoteResourceIdentifier.h in Headers */,
> 				073A15542177A42600EA08F2 /* RemoteVideoSample.h in Headers */,
> 				D06C0D8F0CFD11460065F43F /* RemoveFormatCommand.h in Headers */,
> 				93309E05099E64920056E581 /* RemoveNodeCommand.h in Headers */,
>@@ -34759,7 +34768,6 @@
> 				E1EE8B992413195000E794D6 /* XRInputSourcesChangeEvent.h in Headers */,
> 				E12A9F4A248A99E2003F06C8 /* XRInteractionMode.h in Headers */,
> 				E1EE8B842413191F00E794D6 /* XRReferenceSpaceEvent.h in Headers */,
>-				E4D33F3B252AEECD00837D05 /* InlineRunAndOffset.h in Headers */,
> 				E1EE8B772413191F00E794D6 /* XRReferenceSpaceType.h in Headers */,
> 				E1EE8B792413191F00E794D6 /* XRRenderStateInit.h in Headers */,
> 				E1EE8B8D2413195000E794D6 /* XRSessionEvent.h in Headers */,
>diff --git a/Source/WebCore/html/ImageBitmap.cpp b/Source/WebCore/html/ImageBitmap.cpp
>index 39296a898b6ae1157023e0571a170f2d65186464..ab960dafedef1299350a69cc4b1f00f68b229fd0 100644
>--- a/Source/WebCore/html/ImageBitmap.cpp
>+++ b/Source/WebCore/html/ImageBitmap.cpp
>@@ -602,10 +602,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 scheduleTimedRenderingUpdate(const Image&) override { }
> 
>diff --git a/Source/WebCore/loader/cache/CachedImage.cpp b/Source/WebCore/loader/cache/CachedImage.cpp
>index 3fa1817a9d6668fb433b1bd45c60862f0c387dd6..b392ae814b9dfcecd23d3f90973e5c6dda836a8c 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 2a02be85f1a05522f59b44b5aa267aa9f97f8d7f..e47f2a09f20365caa86ee45e1c426d09f6a2ff1a 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 scheduleTimedRenderingUpdate(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 scheduleTimedRenderingUpdate(const Image&);
> 
>diff --git a/Source/WebCore/loader/cache/CachedImageClient.h b/Source/WebCore/loader/cache/CachedImageClient.h
>index 295e656ab1ebc1b90fd1ace783d3419c2f69a08b..33accf9269281f7515f8de6b691346e794a0b8db 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 {
> 
>@@ -46,6 +47,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&) { }
> 
>diff --git a/Source/WebCore/platform/graphics/BitmapImage.cpp b/Source/WebCore/platform/graphics/BitmapImage.cpp
>index b476a35b82d93708d3b0f2b4d1a6d254812d0e11..fcbb33da9e02d4fe0804e1e113d113e13c7cc508 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,26 @@ bool BitmapImage::notSolidColor()
> }
> #endif // ASSERT_ENABLED
> 
>+static void drawNativeImage(const BitmapImage& image, const NativeImagePtr& nativeImage, 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(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));
>+
>+    fprintf(stderr, "drawNativeImage(): url = %s]", image.sourceURL().string().utf8().data());
>+    
>+    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 +313,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, image, context, destRect, srcRect, IntSize(size(orientation)), { options, orientation });
>     } else
>-        drawNativeImage(image, context, destRect, srcRect, IntSize(size(orientation)), options);
>+        drawNativeImage(*this, image, context, destRect, srcRect, IntSize(size(orientation)), options);
> 
>     m_currentFrameDecodingStatus = frameDecodingStatusAtIndex(m_currentFrame);
> 
>@@ -379,7 +400,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 265cb57d39395038a629f35bcd6863aa44439c67..e84c43f9b71ec59d4f8b2a873eb1d6008322852f 100644
>--- a/Source/WebCore/platform/graphics/GraphicsContext.cpp
>+++ b/Source/WebCore/platform/graphics/GraphicsContext.cpp
>@@ -425,6 +425,40 @@ void GraphicsContext::restore()
>     restorePlatformState();
> }
> 
>+void GraphicsContext::drawGPUBadge(const FloatRect& containerRect, const FloatPoint& badgePosition, const Color& color, const String& text)
>+{
>+    GraphicsContextStateSaver stateSaver(*this);
>+
>+    setShouldAntialias(false);
>+    setStrokeColor(color);
>+    strokeRect(containerRect, 0.5);
>+
>+    const unsigned fontSize = 10;
>+    FontCascadeDescription fontDescription;
>+    fontDescription.setOneFamily("Arial");
>+    fontDescription.setSpecifiedSize(fontSize);
>+    fontDescription.setComputedSize(fontSize);
>+    fontDescription.setWeight(FontSelectionValue(500));
>+
>+    FontCascade cascade(WTFMove(fontDescription));
>+    cascade.update(nullptr);
>+
>+    TextRun textRun(text);
>+    float textWidth = cascade.width(textRun);
>+    
>+    FloatRect badgeRect(badgePosition, FloatSize(textWidth + 2, fontSize + 2));
>+    if (badgePosition.x() == containerRect.maxX())
>+        badgeRect.setX(badgePosition.x() - badgeRect.width());
>+
>+    if (badgePosition.y() == containerRect.maxY())
>+        badgeRect.setY(badgePosition.y() - badgeRect.height());
>+
>+    fillRect(badgeRect, color);
>+    
>+    setFillColor(Color::white);
>+    cascade.drawText(*this, textRun, FloatPoint(badgeRect.x() + 1, badgeRect.y() + 1 + fontSize));
>+}
>+
> void GraphicsContext::drawRaisedEllipse(const FloatRect& rect, const Color& ellipseColor, const Color& shadowColor)
> {
>     if (paintingDisabled())
>@@ -729,6 +763,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);
>@@ -745,7 +792,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());
>@@ -757,7 +804,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());
>@@ -770,7 +817,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) {
>@@ -797,6 +844,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 088f2e5396b9b4385887ec01faca8e7dd90e1807..51fca4d628b39b10aa8efb4fb4e818cbc112f1d3 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;
>@@ -333,10 +334,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();
>@@ -355,6 +352,8 @@ public:
>     
>     unsigned stackSize() const { return m_stack.size(); }
> 
>+    WEBCORE_EXPORT void drawGPUBadge(const FloatRect& containerRect, const FloatPoint& badgePosition, const Color&, const String& text);
>+    
>     // These draw methods will do both stroking and filling.
>     // FIXME: ...except drawRect(), which fills properly but always strokes
>     // using a 1-pixel stroke inset from the rect borders (of the correct
>@@ -382,6 +381,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 });
>@@ -649,6 +650,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 8bc9c1c2ecc0cbfc3826aa1e019131c89372d3fe..e52bc4e219228c2b4365528690e76975208bc06b 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& imageSize, 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 f032484728367390b3059cf58ce120ab372a3555..17d927a3ee9d60d1d048fc0cc52f0339e4843b51 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 scheduleTimedRenderingUpdate(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..4b41cf89d8972c6f1e6fefde89992d6b9e4f5ba8 100644
>--- a/Source/WebCore/platform/graphics/NativeImage.h
>+++ b/Source/WebCore/platform/graphics/NativeImage.h
>@@ -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 3d46a5053b17c9a3ef9f82b20b4d971f02a543e6..82d27bd65a8e60bda76926332eab4b2a03a4c54f 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 31ba71617efa456c11f043a19a4493fd585b23e5..0bff7817eda5d2d9ee3b1c748ead299c8b31fa73 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 63fb5dd61babcccf70904e56d2f9d4e5ad58cac5..acb1e4e4cab96be4bcd09ffc5a28ce99816ff043 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 61064a8863b40f1905daa4053387c224b6423a8a..24f6af9ca776ec282a7826f2ab482e18fabbbb82 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 8672b1b470847690185084959a77af42fdb8043f..03caef059d0e9e056dc41ba5757c5a370deb3ea5 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 dbf1884a21a349f6aa03337f76ed592923c04de3..88f8889aeb37ba6fe8f63a6119f41d8ad488e710 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp
>@@ -29,7 +29,6 @@
> #include "DisplayListReplayer.h"
> #include "FontCascade.h"
> #include "ImageData.h"
>-#include "SharedBuffer.h"
> #include <wtf/text/TextStream.h>
> 
> #if USE(CG)
>@@ -105,9 +104,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));
>@@ -700,32 +701,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)
>@@ -736,6 +727,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)
>@@ -1427,8 +1445,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;
>@@ -1528,10 +1547,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 f055869e17aaa9664eb53fb1bee795806428d363..c8ac00e34e095f22edb0b6be582a870c8bea6047 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>@@ -34,6 +34,7 @@
> #include "Image.h"
> #include "ImageData.h"
> #include "Pattern.h"
>+#include "RemoteResourceIdentifier.h"
> #include "SharedBuffer.h"
> #include <wtf/TypeCasts.h>
> 
>@@ -1430,32 +1431,53 @@ 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;
>@@ -1465,10 +1487,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;
>@@ -1478,12 +1497,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;
>@@ -1505,14 +1522,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:
>@@ -2924,10 +3002,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);
>@@ -3112,11 +3193,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))
>@@ -3270,8 +3355,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)
>@@ -3331,9 +3417,10 @@ 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::DrawNativeImage,
>     WebCore::DisplayList::ItemType::DrawPattern,
>     WebCore::DisplayList::ItemType::DrawRect,
>     WebCore::DisplayList::ItemType::DrawLine,
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp
>index bd0438c6a4b256c8856bb129a3ab5fa23e78dc8a..dccc02d17ee064138cbf89a7d9257f50ca51c32a 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp
>@@ -30,6 +30,7 @@
> #include "DisplayListDrawingContext.h"
> #include "DisplayListItems.h"
> #include "GraphicsContext.h"
>+#include "ImageBuffer.h"
> #include "Logging.h"
> #include <wtf/MathExtras.h>
> #include <wtf/text/TextStream.h>
>@@ -37,10 +38,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 +53,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)
>@@ -136,13 +137,33 @@ 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 drawNativeImageItem = m_delegate->createDrawNativeImageItem(image, imageSize, destRect, srcRect, options, *cachedImage)) {
>+            DrawingItem& newItem = downcast<DrawingItem>(appendItem(drawNativeImageItem.releaseNonNull()));
>+            updateItemExtent(newItem);
>+            return;
>+        }
>+    }
>+
>     DrawingItem& newItem = downcast<DrawingItem>(appendItem(DrawNativeImage::create(image, imageSize, destRect, srcRect, options)));
>     updateItemExtent(newItem);
> }
>-#endif
>+
>+bool Recorder::drawImageBuffer(ImageBuffer& image, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& options)
>+{
>+    if (!m_delegate)
>+        return false;
>+
>+    auto drawImageBufferItem = m_delegate->createDrawImageBufferItem(image, destination, source, options);
>+    if (!drawImageBufferItem)
>+        return false;
>+
>+    DrawingItem& newItem = downcast<DrawingItem>(appendItem(drawImageBufferItem.releaseNonNull()));
>+    updateItemExtent(newItem);
>+    return true;
>+}
> 
> 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 d270c5d908ac68d7808363bba91b2e761aedc92b..efac6bace742cc870fddac14cddf87d85c428539 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h
>@@ -28,6 +28,7 @@
> #include "DisplayList.h"
> #include "GraphicsContextImpl.h"
> #include "Image.h" // For Image::TileRule.
>+#include "RemoteResourceIdentifier.h"
> #include "TextFlags.h"
> #include <wtf/Noncopyable.h>
> 
>@@ -53,17 +54,19 @@ 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);
> 
>     size_t itemCount() const { return m_displayList.itemCount(); }
> 
>-    class Observer {
>+    class Delegate {
>     public:
>-        virtual ~Observer() { }
>+        virtual ~Delegate() { }
>+        virtual RefPtr<Item> createDrawNativeImageItem(const NativeImagePtr&, const FloatSize&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&, CachedImage&) { return nullptr; }
>+        virtual RefPtr<Item> createDrawImageBufferItem(ImageBuffer&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&) { return nullptr; }
>         virtual void willAppendItem(const Item&) { };
>     };
> 
>@@ -102,9 +105,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& imageSize, 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;
>@@ -183,7 +186,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/nicosia/cairo/NicosiaCairoOperationRecorder.cpp b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp
>index cea2a6ea044534ff4544ea2109c2617d797ca2f1..1bc226c390badcdad331af249f55614f13a535c2 100644
>--- a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp
>+++ b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp
>@@ -549,7 +549,7 @@ ImageDrawResult CairoOperationRecorder::drawTiledImage(Image& image, const Float
>     return GraphicsContextImpl::drawTiledImageImpl(graphicsContext(), image, destination, source, tileScaleFactor, hRule, vRule, imagePaintingOptions);
> }
> 
>-void CairoOperationRecorder::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+void CairoOperationRecorder::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options, CachedImage*)
> {
>     struct DrawNativeImage final : PaintingOperation, OperationData<RefPtr<cairo_surface_t>, FloatRect, FloatRect, ImagePaintingOptions, float, Cairo::ShadowState> {
>         virtual ~DrawNativeImage() = default;
>@@ -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 de24ab8bd52432ce293a80f6b4f9860f222fa7ff..a2972061ca838d6d52e55c6339a7d93b4b023c75 100644
>--- a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h
>+++ b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h
>@@ -67,7 +67,9 @@ 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;
>-    void drawNativeImage(const WebCore::NativeImagePtr&, const WebCore::FloatSize&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::ImagePaintingOptions&) override;
>+
>+    void drawNativeImage(const WebCore::NativeImagePtr&, const WebCore::FloatSize&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::ImagePaintingOptions&, WebCore::CachedImage*) override;
>+    bool drawImageBuffer(WebCore::ImageBuffer&, const WebCore::FloatRect& destination, const WebCore::FloatRect& source, 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;
> 
>     void drawRect(const WebCore::FloatRect&, float) 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 2e920efddc179f63fd4fd24bcf7913241095e635..0000000000000000000000000000000000000000
>--- a/Source/WebKit/GPUProcess/graphics/RemoteImageBufferMessageHandlerProxy.h
>+++ /dev/null
>@@ -1,69 +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);
>-
>-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 81b8978d0e791157f9c7e497039817e47959e514..5b3a8712efc14c2f47eba4b25c5d2c6bb8987ef5 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteImageBufferProxy.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteImageBufferProxy.h
>@@ -27,29 +27,29 @@
> 
> #if ENABLE(GPU_PROCESS)
> 
>-#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, 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, 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()
>@@ -61,9 +61,6 @@ public:
>     }
> 
> private:
>-    using BaseConcreteImageBuffer::flushDrawingContext;
>-    using BaseConcreteImageBuffer::putImageData;
>-
>     void flushDrawingContext(const WebCore::DisplayList::DisplayList& displayList) override
>     {
>         if (displayList.itemCount()) {
>@@ -72,27 +69,18 @@ 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
>+    bool apply(WebCore::DisplayList::Item& item, WebCore::GraphicsContext& context) override
>     {
>-        return BaseConcreteImageBuffer::getImageData(outputFormat, srcRect);
>-    }
>-
>-    bool apply(WebCore::DisplayList::Item& item, WebCore::GraphicsContext&) override
>-    {
>-        if (item.type() != WebCore::DisplayList::ItemType::PutImageData)
>-            return false;
>+        if (item.type() == WebCore::DisplayList::ItemType::PutImageData) {
>+            auto& putImageDataItem = static_cast<WebCore::DisplayList::PutImageData&>(item);
>+            putImageData(putImageDataItem.inputFormat(), putImageDataItem.imageData(), putImageDataItem.srcRect(), putImageDataItem.destPoint(), putImageDataItem.destFormat());
>+            return true;
>+        }
> 
>-        auto& putImageDataItem = static_cast<WebCore::DisplayList::PutImageData&>(item);
>-        putImageData(putImageDataItem.inputFormat(), putImageDataItem.imageData(), putImageDataItem.srcRect(), putImageDataItem.destPoint(), putImageDataItem.destFormat());
>-        return true;
>+        return m_remoteRenderingBackendProxy.applyResourceItem(item, context);
>     }
>+    
>+    RemoteRenderingBackendProxy& m_remoteRenderingBackendProxy;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.cpp b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.cpp
>index dbb55ba3c220de86f18a533cfa08718f38924f08..30b5dc34d04068d83d6f4874079affe516ca0ddd 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 {
>@@ -66,59 +66,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, 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, bool shouldDrawGPUBadge, RemoteResourceIdentifier remoteResourceIdentifier)
> {
>-    if (auto imageBuffer = m_imageBufferMessageHandlerMap.get(imageBufferIdentifier))
>-        imageBuffer->flushDrawingContext(displayList);
>+    m_remoteResourceCacheProxy.flushDrawingContext(displayList, shouldDrawGPUBadge, remoteResourceIdentifier);
> }
> 
>-void RemoteRenderingBackendProxy::flushImageBufferDrawingContextAndCommit(const WebCore::DisplayList::DisplayList& displayList, ImageBufferFlushIdentifier flushIdentifier, ImageBufferIdentifier imageBufferIdentifier)
>+void RemoteRenderingBackendProxy::flushImageBufferDrawingContextAndCommit(const WebCore::DisplayList::DisplayList& displayList, bool shouldDrawGPUBadge, ImageBufferFlushIdentifier flushIdentifier, RemoteResourceIdentifier remoteResourceIdentifier)
> {
>-    if (auto imageBuffer = m_imageBufferMessageHandlerMap.get(imageBufferIdentifier))
>-        imageBuffer->flushDrawingContextAndCommit(displayList, flushIdentifier);
>+    m_remoteResourceCacheProxy.flushDrawingContextAndCommit(displayList, shouldDrawGPUBadge, remoteResourceIdentifier);
>+    send(Messages::RemoteRenderingBackend::CommitImageBufferFlushContext(flushIdentifier, remoteResourceIdentifier), m_renderingBackendIdentifier);
>+}
>+
>+void RemoteRenderingBackendProxy::getImageData(WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, RemoteResourceIdentifier remoteResourceIdentifier, CompletionHandler<void(IPC::ImageDataReference&&)>&& completionHandler)
>+{
>+    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 6764ac10c5e7e02a4c97877b9c5e55ca0b78cb1e..06228fef94eae9f23a712da481abb6aef010fef9 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendProxy.h
>@@ -28,24 +28,23 @@
> #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,7 +58,10 @@ public:
>     static std::unique_ptr<RemoteRenderingBackendProxy> create(GPUConnectionToWebProcess&, RenderingBackendIdentifier);
>     virtual ~RemoteRenderingBackendProxy();
> 
>-    RenderingBackendIdentifier renderingBackendIdentifier() const { return m_renderingBackendIdentifier; }
>+    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);
>@@ -73,14 +75,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&, bool shouldDrawGPUBadge, WebCore::RemoteResourceIdentifier);
>+    void flushImageBufferDrawingContextAndCommit(const WebCore::DisplayList::DisplayList&, bool shouldDrawGPUBadge, 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..d4eec4f9bc13fc4295d4f30c30546d83ed1881b5 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, bool shouldDrawGPUBadge, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
>+    void FlushImageBufferDrawingContextAndCommit(WebCore::DisplayList::DisplayList displayList, bool shouldDrawGPUBadge, 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..31d9fa713dd664c2ec6c62e94f6ff2968e177da8
>--- /dev/null
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteResourceCacheProxy.cpp
>@@ -0,0 +1,150 @@
>+/*
>+ * 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, bool shouldDrawGPUBadge, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    SetForScope<bool> change(m_shouldDrawGPUBadge, shouldDrawGPUBadge);
>+    auto image = m_remoteImageBufferHashMap.get(remoteResourceIdentifier);
>+    if (image)
>+        image->flushDrawingContext(displayList);
>+    return image;
>+}
>+
>+ImageBuffer* RemoteResourceCacheProxy::flushDrawingContextAndCommit(const DisplayList::DisplayList& displayList, bool shouldDrawGPUBadge, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    auto image = flushDrawingContext(displayList, shouldDrawGPUBadge, remoteResourceIdentifier);
>+    if (image)
>+        image->flushContext();
>+    return image;
>+}
>+
>+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);
>+}
>+
>+void RemoteResourceCacheProxy::drawGPUBadge(GraphicsContext& context, const FloatRect& containerRect, const Color& color, const String& text) const
>+{
>+    if (!m_shouldDrawGPUBadge)
>+        return;
>+    context.drawGPUBadge(containerRect, containerRect.maxXMaxYCorner(), color, text);
>+}
>+
>+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(drawItem.remoteResourceIdentifier());
>+    if (!image)
>+        return false;
>+
>+    context.drawNativeImage(image, drawItem.imageSize(), drawItem.destinationRect(), drawItem.source(), drawItem.options());
>+    drawGPUBadge(context, drawItem.destinationRect(), WebCore::Color::red, "IMAGE"_s);
>+    return true;
>+}
>+
>+bool RemoteResourceCacheProxy::drawImageBufferItem(const DisplayList::Item& item, GraphicsContext& context) const
>+{
>+    auto& drawItem = static_cast<const DisplayList::DrawImageBuffer&>(item);
>+    auto image = m_remoteImageBufferHashMap.get(drawItem.remoteResourceIdentifier());
>+    if (!image)
>+        return false;
>+
>+    image->draw(context, drawItem.destinationRect(), drawItem.source(), drawItem.options());
>+    drawGPUBadge(context, drawItem.destinationRect(), WebCore::Color::blue, "CANVAS"_s);
>+    return true;
>+}
>+
>+bool RemoteResourceCacheProxy::applyResourceItem(const DisplayList::Item& item, GraphicsContext& context) const
>+{
>+    if (item.type() == DisplayList::ItemType::DrawNativeImage)
>+        return drawNativeImageItem(item, context);
>+    if (item.type() == DisplayList::ItemType::DrawImageBuffer)
>+        return drawImageBufferItem(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..04fc052c284696eb764dab6dcee7f07fe6afc8f4
>--- /dev/null
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteResourceCacheProxy.h
>@@ -0,0 +1,75 @@
>+/*
>+ * 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&, bool shouldDrawGPUBadge, WebCore::RemoteResourceIdentifier);
>+    WebCore::ImageBuffer* flushDrawingContextAndCommit(const WebCore::DisplayList::DisplayList&, bool shouldDrawGPUBadge, 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>;
>+
>+    void drawGPUBadge(WebCore::GraphicsContext&, const WebCore::FloatRect& containerRect, const WebCore::Color&, const String& text) const;
>+    bool drawNativeImageItem(const WebCore::DisplayList::Item&, WebCore::GraphicsContext&) const;
>+    bool drawImageBufferItem(const WebCore::DisplayList::Item&, WebCore::GraphicsContext&) const;
>+
>+    RemoteImageBufferHashMap m_remoteImageBufferHashMap;
>+    RemoteNativeImageHashMap m_remoteNativeImageHashMap;
>+    RemoteRenderingBackendProxy& m_remoteRenderingBackendProxy;
>+    bool m_shouldDrawGPUBadge { false };
>+};
>+
>+} // namespace WebKit
>+
>+#endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/Scripts/webkit/messages.py b/Source/WebKit/Scripts/webkit/messages.py
>index 70d3d88f2bf4a6f1cfc4f188704ed6770e4977af..a0cfce6c012485cb3fe7cd613cff1961fb2b16af 100644
>--- a/Source/WebKit/Scripts/webkit/messages.py
>+++ b/Source/WebKit/Scripts/webkit/messages.py
>@@ -216,11 +216,13 @@ def types_that_cannot_be_forward_declared():
>         'WebCore::LibWebRTCSocketIdentifier',
>         'WebCore::PlaybackTargetClientContextIdentifier',
>         'WebCore::MediaSessionIdentifier',
>+        'WebCore::NativeImagePtr',
>         'WebCore::PageIdentifier',
>         'WebCore::PluginLoadClientPolicy',
>         'WebCore::PointerID',
>         'WebCore::ProcessIdentifier',
>         'WebCore::RealtimeMediaSourceIdentifier',
>+        'WebCore::RemoteResourceIdentifier',
>         'WebCore::RenderingMode',
>         'WebCore::ServiceWorkerIdentifier',
>         'WebCore::ServiceWorkerJobIdentifier',
>@@ -238,7 +240,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..74f0d25b9cd41e77fe153c753da0d1fb4a06a6e4 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 bc2c4943aebe5ccaf8b947ed71ae030f4f32d983..1f61318928e9d166ca5f02fe797df42697a4e55b 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
>@@ -551,8 +551,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 57213562abc1be3842be31e8617370de2878cd0a..2be77d4c843e5c5ce02c61c633fb523bc57a2b09 100644
>--- a/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>+++ b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>@@ -3863,7 +3863,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>"; };
>@@ -4145,10 +4144,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>"; };
>@@ -4158,6 +4154,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>"; };
>+		72DCA1E9252424CE00C9B20D /* RemoteResourceCache.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteResourceCache.h; sourceTree = "<group>"; };
>+		72DCA1EA252424CE00C9B20D /* RemoteResourceCache.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteResourceCache.cpp; sourceTree = "<group>"; };
>+		72DCA1EB2527145100C9B20D /* RemoteResourceCacheProxy.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteResourceCacheProxy.cpp; sourceTree = "<group>"; };
>+		72DCA1EC2527145100C9B20D /* RemoteResourceCacheProxy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteResourceCacheProxy.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>"; };
>@@ -8021,17 +8021,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 */,
>+				72DCA1EA252424CE00C9B20D /* RemoteResourceCache.cpp */,
>+				72DCA1E9252424CE00C9B20D /* RemoteResourceCache.h */,
> 				5506409F2407196A00AAE045 /* RenderingBackendIdentifier.h */,
> 			);
> 			path = graphics;
>@@ -8041,12 +8041,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 */,
>+				72DCA1EB2527145100C9B20D /* RemoteResourceCacheProxy.cpp */,
>+				72DCA1EC2527145100C9B20D /* 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..342b05e0786876f3f646a48bdbd8be61cd05df3d 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBuffer.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBuffer.h
>@@ -28,6 +28,8 @@
> #if ENABLE(GPU_PROCESS)
> 
> #include "RemoteImageBufferMessageHandler.h"
>+#include "RemoteRenderingBackend.h"
>+#include <WebCore/Color.h>
> #include <WebCore/DisplayListImageBuffer.h>
> #include <WebCore/DisplayListItems.h>
> #include <WebCore/DisplayListRecorder.h>
>@@ -37,10 +39,11 @@ 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;
>+    using BaseDisplayListImageBuffer::context;
> 
> public:
>     static std::unique_ptr<RemoteImageBuffer> create(const WebCore::FloatSize& size, WebCore::RenderingMode renderingMode, float resolutionScale, WebCore::ColorSpace colorSpace, RemoteRenderingBackend& remoteRenderingBackend)
>@@ -53,14 +56,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
>@@ -68,23 +77,52 @@ protected:
>         ASSERT(!m_backend);
>         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_remoteRenderingBackend->drawGPUBadge(context(), WebCore::FloatRect({ }, m_backend->logicalSize()), WebCore::Color::darkGreen, "GPU"_s);
>+        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 +133,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..82460a16cebf349a934bb816441d0095de1123aa 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferMessageHandler.h
>@@ -29,11 +29,9 @@
> 
> #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 ImageData;
>@@ -42,37 +40,20 @@ enum class AlphaPremultiplication : 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..2344996a4104c9c7eb6abc85282d12c6eaca1b71 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.cpp
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.cpp
>@@ -30,6 +30,7 @@
> 
> #include "GPUConnectionToWebProcess.h"
> #include "GPUProcessConnection.h"
>+#include "ImageDataReference.h"
> #include "PlatformRemoteImageBuffer.h"
> #include "RemoteRenderingBackendMessages.h"
> #include "RemoteRenderingBackendProxyMessages.h"
>@@ -39,12 +40,13 @@ namespace WebKit {
> 
> using namespace WebCore;
> 
>-std::unique_ptr<RemoteRenderingBackend> RemoteRenderingBackend::create()
>+std::unique_ptr<RemoteRenderingBackend> RemoteRenderingBackend::create(WebPage& page)
> {
>-    return std::unique_ptr<RemoteRenderingBackend>(new RemoteRenderingBackend());
>+    return std::unique_ptr<RemoteRenderingBackend>(new RemoteRenderingBackend(page));
> }
> 
>-RemoteRenderingBackend::RemoteRenderingBackend()
>+RemoteRenderingBackend::RemoteRenderingBackend(WebPage& page)
>+    : m_remoteResourceCache(*this, page)
> {
>     // Register itself as a MessageReceiver in the GPUProcessConnection.
>     IPC::MessageReceiverMap& messageReceiverMap = WebProcess::singleton().ensureGPUProcessConnection().messageReceiverMap();
>@@ -86,40 +88,82 @@ bool RemoteRenderingBackend::waitForCommitImageBufferFlushContext()
>     return connection->waitForAndDispatchImmediately<Messages::RemoteRenderingBackend::CommitImageBufferFlushContext>(m_renderingBackendIdentifier, 1_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
> }
> 
>+void RemoteRenderingBackend::drawGPUBadge(GraphicsContext& context, const FloatRect& containerRect, const Color& color, const String& text)
>+{
>+    m_remoteResourceCache.drawGPUBadge(context, containerRect, color, text);
>+}
>+
> 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);
>+}
>+
>+void RemoteRenderingBackend::releaseImageBuffer(ImageBuffer& image)
>+{
>+    m_remoteResourceCache.releaseImageBuffer(image);
>+}
>+
>+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;
>+}
>+
>+RemoteResourceIdentifier RemoteRenderingBackend::remoteCacheNativeImage(const NativeImagePtr& image)
>+{
>+    RemoteResourceIdentifier remoteResourceIdentifier = RemoteResourceIdentifier::generate();
>+    send(Messages::RemoteRenderingBackendProxy::CacheNativeImage(image, remoteResourceIdentifier), m_renderingBackendIdentifier);
>+    return remoteResourceIdentifier;
>+}
> 
>-    if (auto imageBuffer = UnacceleratedRemoteImageBuffer::create(size, RenderingMode::RemoteUnaccelerated, resolutionScale, colorSpace, *this)) {
>-        m_imageBufferMessageHandlerMap.add(imageBuffer->imageBufferIdentifier(), imageBuffer.get());
>-        return imageBuffer;
>-    }
>+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();
>+}
> 
>-    return nullptr;
>+void RemoteRenderingBackend::remoteFlushDrawingContext(const DisplayList::DisplayList& displayList, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    send(Messages::RemoteRenderingBackendProxy::FlushImageBufferDrawingContext(displayList, m_remoteResourceCache.shouldDrawGPUBadge(), remoteResourceIdentifier), m_renderingBackendIdentifier);
>+}
>+
>+ImageBufferFlushIdentifier RemoteRenderingBackend::remoteFlushDrawingContextAndCommit(const DisplayList::DisplayList& displayList, RemoteResourceIdentifier remoteResourceIdentifier)
>+{
>+    ImageBufferFlushIdentifier sentFlushIdentifier = ImageBufferFlushIdentifier::generate();
>+    send(Messages::RemoteRenderingBackendProxy::FlushImageBufferDrawingContextAndCommit(displayList, m_remoteResourceCache.shouldDrawGPUBadge(), sentFlushIdentifier, remoteResourceIdentifier), m_renderingBackendIdentifier);
>+    return sentFlushIdentifier;
> }
> 
>-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..bbaf935cdd1215779d9e7feaf812a38b3c68daad 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackend.h
>@@ -29,31 +29,36 @@
> 
> #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 <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 WebPage;
>+
> class RemoteRenderingBackend
>     : public IPC::MessageSender
>     , private IPC::MessageReceiver
>     , public CanMakeWeakPtr<RemoteRenderingBackend> {
> public:
>-    static std::unique_ptr<RemoteRenderingBackend> create();
>+    static std::unique_ptr<RemoteRenderingBackend> create(WebPage&);
> 
>     ~RemoteRenderingBackend();
> 
>-    RenderingBackendIdentifier renderingBackendIdentifier() const { return m_renderingBackendIdentifier; }
>-
>     // IPC::MessageSender.
>     IPC::Connection* messageSenderConnection() const override;
>     uint64_t messageSenderDestinationID() const override;
>@@ -61,21 +66,33 @@ 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.
>+    void drawGPUBadge(WebCore::GraphicsContext&, const WebCore::FloatRect& containerRect, const WebCore::Color&, const String& text);
>+    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);
>+    WebCore::RemoteResourceIdentifier remoteCacheNativeImage(const WebCore::NativeImagePtr&);
>+    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);
>+    void remoteReleaseRemoteResource(WebCore::RemoteResourceIdentifier);
>+
> private:
>-    RemoteRenderingBackend();
>+    RemoteRenderingBackend(WebPage&);
> 
>     // 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;
>     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..d44cd9fe1175a54cef7f9a26073a3b5f28be2916
>--- /dev/null
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCache.cpp
>@@ -0,0 +1,212 @@
>+/*
>+ * 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, WebPage& page)
>+    : m_remoteRenderingBackend(remoteRenderingBackend)
>+    , m_page(page)
>+{
>+}
>+
>+bool RemoteResourceCache::shouldDrawGPUBadge() const
>+{
>+    return m_page.corePage()->settings().showDebugBorders();
>+}
>+
>+void RemoteResourceCache::drawGPUBadge(GraphicsContext& context, const FloatRect& containerRect, const Color& color, const String& text)
>+{
>+    if (!shouldDrawGPUBadge())
>+        return;
>+    FloatRect borderRect = containerRect;
>+    borderRect.inflate(-1);
>+    context.drawGPUBadge(borderRect, borderRect.maxXMinYCorner(), color, text);
>+}
>+
>+std::unique_ptr<ImageBuffer> RemoteResourceCache::createImageBuffer(const FloatSize& size, ShouldAccelerate shouldAccelerate, float resolutionScale, ColorSpace colorSpace)
>+{
>+    if (shouldAccelerate == ShouldAccelerate::Yes) {
>+        if (auto image = AcceleratedRemoteImageBuffer::create(size, RenderingMode::RemoteAccelerated, resolutionScale, colorSpace, m_remoteRenderingBackend)) {
>+            m_remoteImageBufferHashMap.add(image.get(), image->remoteResourceIdentifier());
>+            m_remoteImageBufferMessageHandlerHashMap.add(image->remoteResourceIdentifier(), image.get());
>+            return image;
>+        }
>+    }
>+
>+    if (auto image = UnacceleratedRemoteImageBuffer::create(size, RenderingMode::RemoteUnaccelerated, resolutionScale, colorSpace, m_remoteRenderingBackend)) {
>+        m_remoteImageBufferHashMap.add(image.get(), image->remoteResourceIdentifier());
>+        m_remoteImageBufferMessageHandlerHashMap.add(image->remoteResourceIdentifier(), image.get());
>+        return image;
>+    }
>+
>+    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);
>+}
>+
>+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::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 cached.
>+    if (m_remoteResourceClientsHashMap.contains(remoteResourceIdentifier))
>+        m_remoteResourceClientsPendingReleaseHashMap.add(remoteResourceIdentifier, m_remoteResourceClientsHashMap.take(remoteResourceIdentifier));
>+    else
>+        m_remoteRenderingBackend.remoteReleaseRemoteResource(remoteResourceIdentifier);
>+}
>+
>+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..2bda72e537627188fee0042bdca6c8a040aa7190
>--- /dev/null
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCache.h
>@@ -0,0 +1,100 @@
>+/*
>+ * 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/NativeImagePtr.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 WebPage;
>+
>+class RemoteResourceCache : public WebCore::CachedImageClient {
>+public:
>+    RemoteResourceCache(RemoteRenderingBackend&, WebPage&);
>+
>+    bool shouldDrawGPUBadge() const;
>+    void drawGPUBadge(WebCore::GraphicsContext&, const WebCore::FloatRect& containerRect, const WebCore::Color&, const String& text);
>+
>+    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;
>+    WebPage& m_page;
>+};
>+
>+} // namespace WebKit
>+
>+#endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp b/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp
>index 188bc5e9eb9db74405e08f6e05823ea3c37a82a1..536d6e95e0f864cef59b0cbcba4efe8c58082c24 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp
>@@ -877,7 +877,7 @@ RefPtr<DisplayRefreshMonitor> WebChromeClient::createDisplayRefreshMonitor(Platf
> RemoteRenderingBackend& WebChromeClient::ensureRemoteRenderingBackend() const
> {
>     if (!m_remoteRenderingBackend)
>-        m_remoteRenderingBackend = RemoteRenderingBackend::create();
>+        m_remoteRenderingBackend = RemoteRenderingBackend::create(m_page);
>     return *m_remoteRenderingBackend;
> }
>

Actions: View | Formatted Diff | Diff

Attachments on bug 217342: 410571 | 410597 | 410613 | 410617 | 410738 | 410739 | 410740