Attachment 415050 Details for Bug 219007 – Patch

[patch] Patch

bug-219007-20201130133028.patch (text/plain), 99.65 KB, created by Said Abou-Hallawa on 2020-11-30 13:30:29 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Said Abou-Hallawa

Created: 2020-11-30 13:30:29 PST

Size: 99.65 KB

patch

obsolete

>Subversion Revision: 270257
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index f4c0cf1abab324a4290c953f1e481884030a94a5..93608d584d41707da63c7fd7aceb5f2bbabb374f 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,119 @@
>+2020-11-30  Said Abou-Hallawa  <said@apple.com>
>+
>+        [GPU Process] Clean up recreating the ImageBufferBackend because of GPU crashing
>+        https://bugs.webkit.org/show_bug.cgi?id=219007
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        To allow answering questions about the backend creation parameters without
>+        having the backend created, the new structure ImageBufferBackend::Parameters
>+        is introduced.
>+
>+        This structure contains the parameters which were passed by the caller in
>+        the WebProcess and which are sufficient to recreate RemoteImageBuffer if
>+        the GPU Process crashes even before the backend of RemoteImageBufferProxy
>+        is created.
>+
>+        ConcreteImageBuffer and ImageBufferBackend will hold an instance of the
>+        new structure ImageBufferBackend::Parameters.
>+
>+        Also replace all the instances of 'isAccelerated' by 'renderingMode'. So
>+        no need to convert one type to the other.
>+
>+        * Headers.cmake:
>+        * WebCore.xcodeproj/project.pbxproj:
>+        * html/canvas/CanvasRenderingContext2DBase.cpp:
>+        (WebCore::CanvasRenderingContext2DBase::prepareForDisplay):
>+
>+        * platform/graphics/ConcreteImageBuffer.h:
>+        (WebCore::ConcreteImageBuffer::create):
>+        (WebCore::ConcreteImageBuffer::ConcreteImageBuffer):
>+        -- Make ConcreteImageBuffer own an instance of ImageBufferBackend::Parameters.
>+        -- Add methods to set and clear the backend of an ImageBuffer.
>+
>+        * platform/graphics/ImageBuffer.h:
>+        (WebCore::ImageBuffer::submitDisplayList):
>+        (WebCore::ImageBuffer::didFlush):
>+        -- Expose the ImageBufferBackend creation parameters through methods.
>+        -- Expose submitDisplayList() and didFlush() so no casting is needed when
>+           calling these functions through RemoteImageBuferProxy.
>+
>+        * platform/graphics/ImageBufferBackend.cpp:
>+        (WebCore::ImageBufferBackend::ImageBufferBackend):
>+        (WebCore::ImageBufferBackend::toBGRAData const):
>+        * platform/graphics/ImageBufferBackend.h:
>+        (WebCore::ImageBufferBackend::memoryCost const):
>+        (WebCore::ImageBufferBackend::bytesPerRow const):
>+        (WebCore::ImageBufferBackend::toBackendCoordinates const):
>+        (WebCore::ImageBufferBackend::logicalSize const):
>+        (WebCore::ImageBufferBackend::resolutionScale const):
>+        (WebCore::ImageBufferBackend::colorSpace const):
>+        (WebCore::ImageBufferBackend::pixelFormat const):
>+        (WebCore::ImageBufferBackend::logicalRect const):
>+        (WebCore::ImageBufferBackend::backendRect const):
>+        (WebCore::ImageBufferBackend::backendSize const): Deleted.
>+        (WebCore::ImageBufferBackend::baseTransform const): Deleted.
>+        -- Add the structure ImageBufferBackend::Parameters. 
>+        -- Make ImageBufferBackend own an instance of this structure.
>+        -- Make backendSize() a pure virtual method.
>+        -- Delete baseTransform() since it is implemented in ConcreteImageBuffer.
>+
>+        * platform/graphics/PlatformImageBuffer.h:
>+        (isType):
>+        * platform/graphics/cairo/ImageBufferCairoBackend.cpp:
>+        (WebCore::ImageBufferCairoBackend::drawPattern):
>+        * platform/graphics/cairo/ImageBufferCairoImageSurfaceBackend.cpp:
>+        (WebCore::ImageBufferCairoImageSurfaceBackend::create):
>+        (WebCore::ImageBufferCairoImageSurfaceBackend::ImageBufferCairoImageSurfaceBackend):
>+        (WebCore::ImageBufferCairoImageSurfaceBackend::platformTransformColorSpace):
>+        * platform/graphics/cairo/ImageBufferCairoImageSurfaceBackend.h:
>+        * platform/graphics/cairo/ImageBufferCairoSurfaceBackend.cpp:
>+        (WebCore::ImageBufferCairoSurfaceBackend::ImageBufferCairoSurfaceBackend):
>+        (WebCore::ImageBufferCairoSurfaceBackend::backendSize const):
>+        * platform/graphics/cairo/ImageBufferCairoSurfaceBackend.h:
>+        * platform/graphics/cg/ImageBufferCGBackend.cpp:
>+        (WebCore::ImageBufferCGBackend::setupContext const):
>+        (WebCore::ImageBufferCGBackend::copyImage const):
>+        (WebCore::ImageBufferCGBackend::sinkIntoImage):
>+        (WebCore::ImageBufferCGBackend::draw):
>+        (WebCore::ImageBufferCGBackend::drawPattern):
>+        (WebCore::ImageBufferCGBackend::toCFData const):
>+        (WebCore::ImageBufferCGBackend::baseTransform const): Deleted.
>+        * platform/graphics/cg/ImageBufferCGBackend.h:
>+        * platform/graphics/cg/ImageBufferCGBitmapBackend.cpp:
>+        (WebCore::ImageBufferCGBitmapBackend::create):
>+        (WebCore::ImageBufferCGBitmapBackend::ImageBufferCGBitmapBackend):
>+        (WebCore::ImageBufferCGBitmapBackend::copyNativeImage const):
>+        * platform/graphics/cg/ImageBufferCGBitmapBackend.h:
>+        * platform/graphics/cg/ImageBufferIOSurfaceBackend.cpp:
>+        (WebCore::ImageBufferIOSurfaceBackend::create):
>+        (WebCore::ImageBufferIOSurfaceBackend::ImageBufferIOSurfaceBackend):
>+        (WebCore::ImageBufferIOSurfaceBackend::backendSize const):
>+        (WebCore::ImageBufferIOSurfaceBackend::drawConsuming):
>+        * platform/graphics/cg/ImageBufferIOSurfaceBackend.h:
>+        -- Change the create() methods to take a "Parameters" argument.
>+        -- Use the backend method to access the "Parameters" structure.
>+
>+        * platform/graphics/displaylists/DisplayList.h:
>+        * platform/graphics/displaylists/DisplayListFlushIdentifier.h: Added.
>+        Move DisplayListFlushIdentifier to a separate file so it can be included
>+        in ImageBuffer.h without having to include DisplayList.h.
>+
>+        * platform/graphics/displaylists/DisplayListImageBuffer.h:
>+        (WebCore::DisplayList::ImageBuffer::create):
>+        (WebCore::DisplayList::ImageBuffer::ImageBuffer):
>+        (WebCore::DisplayList::ImageBuffer::initialDrawingContextCTM): Deleted.
>+        -- No need to pass the 'size' argument twice in the 'create' methods. The
>+           structure Parameters has to be passed to the constructor anyway.
>+        -- No need for initialDrawingContextCTM() since it is equivalent to 
>+           baseTransform().
>+
>+        * platform/graphics/win/ImageBufferDirect2DBackend.cpp:
>+        (WebCore::ImageBufferDirect2DBackend::copyImage const):
>+        (WebCore::ImageBufferDirect2DBackend::draw):
>+        (WebCore::ImageBufferDirect2DBackend::drawPattern):
>+        -- Use the backend method to access the "Parameters" structure.
>+
> 2020-11-30  James Darpinian  <jdarpinian@chromium.org>
> 
>         Support KHR_parallel_shader_compile
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index ad78c00585c2b1f8872fac95f59ccaec4964d723..c2ada0caed9ff0ec503cdeddcceded92f09a0ee1 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,99 @@
>+2020-11-30  Said Abou-Hallawa  <said@apple.com>
>+
>+        [GPU Process] Clean up recreating the ImageBufferBackend because of GPU crashing
>+        https://bugs.webkit.org/show_bug.cgi?id=219007
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        There is no need to store the backend parameters in RemoteImageBufferProxy.
>+        These parameters are now stored in the base class ImageBuffer before the
>+        backend is created.
>+
>+        Remove the traits definition for RemoteImageBufferProxy types because
>+        they are wrong. All ImageBuffers have valid renderingResourceIdentifier()
>+        regardless whether they are remote or not. ImageBuffer::setBackend and
>+        ImageBuffer::submitDisplayList() are now implemented in WebCore. So no
>+        casting is needed.
>+
>+        * GPUProcess/graphics/RemoteImageBuffer.h:
>+        (WebKit::RemoteImageBuffer::RemoteImageBuffer):
>+        (WebKit::RemoteImageBuffer::submitDisplayList): Deleted.
>+        submitDisplayList() is now a virtual method of ImageBuffer. So make it
>+        private and ignore the return of DisplayList::Replayer::replay() since 
>+        the caller does not use it.
>+
>+        * GPUProcess/graphics/RemoteRenderingBackend.cpp:
>+        (WebKit::RemoteRenderingBackend::didCreateImageBufferBackend):
>+        (WebKit::RemoteRenderingBackend::applyDisplayListsFromHandle):
>+        (WebKit::RemoteRenderingBackend::imageBufferBackendWasCreated): Deleted.
>+        * GPUProcess/graphics/RemoteRenderingBackend.h:
>+        Rename 'imageBufferBackendWasCreated()' to 'didCreateImageBufferBackend()'
>+        to be consistent with 'didFlush()'.
>+
>+        * Shared/RemoteLayerTree/RemoteLayerBackingStore.mm:
>+        (WebKit::RemoteLayerBackingStore::display):
>+        Call the function with the new name and delete the FIXME comment.
>+
>+        * WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.cpp:
>+        (WebKit::ImageBufferShareableBitmapBackend::create):
>+        (WebKit::ImageBufferShareableBitmapBackend::ImageBufferShareableBitmapBackend):
>+        (WebKit::ImageBufferShareableBitmapBackend::backendSize const):
>+        * WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.h:
>+        Use the new structure 'ImageBufferBackend::Parameters'. Implement the
>+        virtual method 'backendSize()'.
>+
>+        * WebProcess/GPU/graphics/PlatformRemoteImageBufferProxy.h:
>+        (isType): Deleted.
>+        Delete the wrong traits.
>+
>+        * WebProcess/GPU/graphics/RemoteImageBufferProxy.h:
>+        (WebKit::RemoteImageBufferProxy::create):
>+        (WebKit::RemoteImageBufferProxy::RemoteImageBufferProxy):
>+        Use the new structure 'ImageBufferBackend::Parameters'.
>+
>+        (WebKit::RemoteImageBufferProxy::clearBackend): Deleted.
>+        This is now implemented in ConcreteImageBuffer::clearBackend().
>+
>+        (WebKit::RemoteImageBufferProxy::createBackend): Deleted.
>+        RemoteRenderingBackendProxy::didCreateImageBufferBackend() creates the
>+        backend and ConcreteImageBuffer::setBackend() sets it.
>+
>+        (WebKit::RemoteImageBufferProxy::didFlush): Deleted.
>+        didFlush() is now virtual so it can be private.
>+
>+        (WebKit::RemoteImageBufferProxy::size const): Deleted.
>+        (WebKit::RemoteImageBufferProxy::renderingMode const): Deleted.
>+        (WebKit::RemoteImageBufferProxy::colorSpace const): Deleted.
>+        (WebKit::RemoteImageBufferProxy::pixelFormat const): Deleted.
>+        These functions are now implemented in ConcreteImageBuffer.
>+
>+        (WebKit::RemoteImageBufferProxy::submitDisplayList): Deleted.
>+        submitDisplayList() is now virtual.
>+
>+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:
>+        (WebKit::RemoteRenderingBackendProxy::reestablishGPUProcessConnection):
>+        (WebKit::RemoteRenderingBackendProxy::waitForDidCreateImageBufferBackend):
>+        (WebKit::RemoteRenderingBackendProxy::createImageBuffer):
>+        (WebKit::RemoteRenderingBackendProxy::didCreateImageBufferBackend):
>+        (WebKit::RemoteRenderingBackendProxy::didFlush):
>+        (WebKit::recreateImageBuffer): Deleted.
>+        (WebKit::RemoteRenderingBackendProxy::waitForImageBufferBackendWasCreated): Deleted.
>+        (WebKit::RemoteRenderingBackendProxy::imageBufferBackendWasCreated): Deleted.
>+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
>+        No need to cast the ImageBuffer to RemoteImageBufferProxy since all what
>+        RemoteRenderingBackendProxy needs can be accessed through the base class.
>+
>+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in:
>+        Rename 'ImageBufferBackendWasCreated' to 'DidCreateImageBufferBackend'
>+        to be consistent with 'DidFlush'. No need to pass the creation parameters
>+        since they set in the ConcreteImageBuffer. No need to pass the backendSize
>+        since it can be retrieved through the backend itself.
>+
>+        * WebProcess/GPU/graphics/cocoa/ImageBufferShareableIOSurfaceBackend.cpp:
>+        (WebKit::ImageBufferShareableIOSurfaceBackend::create):
>+        * WebProcess/GPU/graphics/cocoa/ImageBufferShareableIOSurfaceBackend.h:
>+        Use the new structure 'ImageBufferBackend::Parameters'.
>+
> 2020-11-30  Youenn Fablet  <youenn@apple.com>
> 
>         Introduce an experimental flag specific to VP9 profile 2
>diff --git a/Source/WebCore/Headers.cmake b/Source/WebCore/Headers.cmake
>index 3789aa383940d2574124bc2ff43e7eec4ae950d5..dfa244fdcd9d733d7c9589273e069c7c004fe7a4 100644
>--- a/Source/WebCore/Headers.cmake
>+++ b/Source/WebCore/Headers.cmake
>@@ -1270,6 +1270,7 @@ set(WebCore_PRIVATE_FRAMEWORK_HEADERS
>     platform/graphics/displaylists/DisplayList.h
>     platform/graphics/displaylists/DisplayListDrawGlyphsRecorder.h
>     platform/graphics/displaylists/DisplayListDrawingContext.h
>+    platform/graphics/displaylists/DisplayListFlushIdentifier.h
>     platform/graphics/displaylists/DisplayListImageBuffer.h
>     platform/graphics/displaylists/DisplayListItemBuffer.h
>     platform/graphics/displaylists/DisplayListItemType.h
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index 8a239507ebbd85990225fbeb185050104886112d..be70ab0370f35c28069a5b48f4a10539b904d6cd 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -2179,6 +2179,7 @@
> 		72144334223EC91600F12FF7 /* SVGPropertyOwner.h in Headers */ = {isa = PBXBuildFile; fileRef = 55EE5360223B2A2100FBA944 /* SVGPropertyOwner.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		721B49742512BA3B00FE9D3B /* ImageBitmapBacking.h in Headers */ = {isa = PBXBuildFile; fileRef = 721B49702512AC0400FE9D3B /* ImageBitmapBacking.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		72283F0E230B268C00F5D828 /* ImagePaintingOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 72C18A3F230B04B7006847C7 /* ImagePaintingOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		7242AC9725758FE1005A9CF1 /* DisplayListFlushIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 7242AC9525758FE0005A9CF1 /* DisplayListFlushIdentifier.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		724ED3321A3A8B2300F5F13C /* JSEXTBlendMinMax.h in Headers */ = {isa = PBXBuildFile; fileRef = 724ED3301A3A8B2300F5F13C /* JSEXTBlendMinMax.h */; };
> 		724EE5501DC80D7F00A91FFB /* ActivityState.h in Headers */ = {isa = PBXBuildFile; fileRef = 724EE54E1DC7F25B00A91FFB /* ActivityState.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		724EE5511DC80D8400A91FFB /* ActivityStateChangeObserver.h in Headers */ = {isa = PBXBuildFile; fileRef = 724EE54F1DC7F25B00A91FFB /* ActivityStateChangeObserver.h */; settings = {ATTRIBUTES = (Private, ); }; };
>@@ -10053,6 +10054,7 @@
> 		721B496F2512AC0400FE9D3B /* ImageBitmapBacking.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ImageBitmapBacking.cpp; sourceTree = "<group>"; };
> 		721B49702512AC0400FE9D3B /* ImageBitmapBacking.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ImageBitmapBacking.h; sourceTree = "<group>"; };
> 		722A815C238FD50500C00583 /* AnimationFrameRate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AnimationFrameRate.h; sourceTree = "<group>"; };
>+		7242AC9525758FE0005A9CF1 /* DisplayListFlushIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DisplayListFlushIdentifier.h; sourceTree = "<group>"; };
> 		724ED3291A3A7E5400F5F13C /* EXTBlendMinMax.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = EXTBlendMinMax.cpp; sourceTree = "<group>"; };
> 		724ED32A1A3A7E5400F5F13C /* EXTBlendMinMax.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EXTBlendMinMax.h; sourceTree = "<group>"; };
> 		724ED32B1A3A7E5400F5F13C /* EXTBlendMinMax.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = EXTBlendMinMax.idl; sourceTree = "<group>"; };
>@@ -17800,6 +17802,7 @@
> 				1CAF56DE2530245A0017B472 /* DisplayListDrawGlyphsRecorderCoreText.cpp */,
> 				55C0A29523FE2CE000F2CB93 /* DisplayListDrawingContext.cpp */,
> 				72EA09F923FCCC6A008504A5 /* DisplayListDrawingContext.h */,
>+				7242AC9525758FE0005A9CF1 /* DisplayListFlushIdentifier.h */,
> 				72EA09F723FCCB3D008504A5 /* DisplayListImageBuffer.h */,
> 				F422B8B6253F7065004E77E8 /* DisplayListItemBuffer.cpp */,
> 				F422B8B5253F7065004E77E8 /* DisplayListItemBuffer.h */,
>@@ -31693,6 +31696,7 @@
> 				0FE5FBD31C3DD51E0007A2CA /* DisplayList.h in Headers */,
> 				1CAF56DB25301AC80017B472 /* DisplayListDrawGlyphsRecorder.h in Headers */,
> 				55AD09402408964000DE4D2F /* DisplayListDrawingContext.h in Headers */,
>+				7242AC9725758FE1005A9CF1 /* DisplayListFlushIdentifier.h in Headers */,
> 				55AD093E2408963500DE4D2F /* DisplayListImageBuffer.h in Headers */,
> 				F4D40BC9255463BF00721349 /* DisplayListItemBuffer.h in Headers */,
> 				0FE5FBD51C3DD51E0007A2CA /* DisplayListItems.h in Headers */,
>diff --git a/Source/WebCore/platform/graphics/ConcreteImageBuffer.h b/Source/WebCore/platform/graphics/ConcreteImageBuffer.h
>index 824299002ee660f0bae3f163ad1c89b03d4dda79..f310a62b463c0b58c9dedb3065fb271c0ac82ede 100644
>--- a/Source/WebCore/platform/graphics/ConcreteImageBuffer.h
>+++ b/Source/WebCore/platform/graphics/ConcreteImageBuffer.h
>@@ -36,30 +36,41 @@ public:
>     template<typename ImageBufferType = ConcreteImageBuffer, typename... Arguments>
>     static RefPtr<ImageBufferType> create(const FloatSize& size, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, const HostWindow* hostWindow, Arguments&&... arguments)
>     {
>-        auto backend = BackendType::create(size, resolutionScale, colorSpace, pixelFormat, hostWindow);
>+        auto parameters = ImageBufferBackend::Parameters { size, resolutionScale, colorSpace, pixelFormat };
>+        auto backend = BackendType::create(parameters, hostWindow);
>         if (!backend)
>             return nullptr;
>-        return adoptRef(new ImageBufferType(WTFMove(backend), std::forward<Arguments>(arguments)...));
>+        return adoptRef(new ImageBufferType(parameters, WTFMove(backend), std::forward<Arguments>(arguments)...));
>     }
> 
>     template<typename ImageBufferType = ConcreteImageBuffer, typename... Arguments>
>     static RefPtr<ImageBufferType> create(const FloatSize& size, const GraphicsContext& context, Arguments&&... arguments)
>     {
>-        auto backend = BackendType::create(size, context);
>+        auto parameters = ImageBufferBackend::Parameters { size, 1, ColorSpace::SRGB, PixelFormat::BGRA8 };
>+        auto backend = BackendType::create(parameters, context);
>         if (!backend)
>             return nullptr;
>-        return adoptRef(new ImageBufferType(WTFMove(backend), std::forward<Arguments>(arguments)...));
>+        return adoptRef(new ImageBufferType(parameters, WTFMove(backend), std::forward<Arguments>(arguments)...));
>     }
> 
>-    bool isAccelerated() const override { return BackendType::isAccelerated; }
>+    RenderingMode renderingMode() const override { return BackendType::renderingMode; }
> 
> protected:
>-    ConcreteImageBuffer(std::unique_ptr<BackendType>&& backend = nullptr, RenderingResourceIdentifier renderingResourceIdentifier = RenderingResourceIdentifier::generate())
>-        : m_backend(WTFMove(backend))
>+    ConcreteImageBuffer(const ImageBufferBackend::Parameters& parameters, std::unique_ptr<BackendType>&& backend = nullptr, RenderingResourceIdentifier renderingResourceIdentifier = RenderingResourceIdentifier::generate())
>+        : m_parameters(parameters)
>+        , m_backend(WTFMove(backend))
>         , m_renderingResourceIdentifier(renderingResourceIdentifier)
>     {
>     }
> 
>+    void setBackend(std::unique_ptr<ImageBufferBackend>&& backend) override
>+    {
>+        ASSERT(!m_backend);
>+        m_backend = std::unique_ptr<BackendType> { static_cast<BackendType*>(backend.release()) };
>+    }
>+
>+    void clearBackend() override { m_backend = nullptr; }
>+
>     virtual BackendType* ensureBackendCreated() const { return m_backend.get(); }
> 
>     RenderingResourceIdentifier renderingResourceIdentifier() const override { return m_renderingResourceIdentifier; }
>@@ -78,19 +89,11 @@ protected:
>         }
>     }
> 
>-    AffineTransform baseTransform() const override
>-    {
>-        if (auto* backend = ensureBackendCreated())
>-            return backend->baseTransform();
>-        return { };
>-    }
>-
>-    IntSize logicalSize() const override
>-    {
>-        if (auto* backend = ensureBackendCreated())
>-            return backend->logicalSize();
>-        return { };
>-    }
>+    IntSize logicalSize() const override { return IntSize(m_parameters.logicalSize); }
>+    float resolutionScale() const override { return m_parameters.resolutionScale; }
>+    ColorSpace colorSpace() const override { return m_parameters.colorSpace; }
>+    PixelFormat pixelFormat() const override { return m_parameters.pixelFormat; }
>+    const ImageBufferBackend::Parameters& parameters() const override { return m_parameters; }
> 
>     IntSize backendSize() const override
>     {
>@@ -99,11 +102,11 @@ protected:
>         return { };
>     }
> 
>-    float resolutionScale() const override
>+    AffineTransform baseTransform() const override
>     {
>-        if (auto* backend = ensureBackendCreated())
>-            return backend->resolutionScale();
>-        return 1;
>+        if (BackendType::isOriginAtUpperLeftCorner)
>+            return AffineTransform(1, 0, 0, -1, 0, logicalSize().height());
>+        return { };
>     }
> 
>     size_t memoryCost() const override
>@@ -291,6 +294,7 @@ protected:
>             backend->releaseBufferToPool();
>     }
> 
>+    ImageBufferBackend::Parameters m_parameters;
>     std::unique_ptr<BackendType> m_backend;
>     RenderingResourceIdentifier m_renderingResourceIdentifier;
> };
>diff --git a/Source/WebCore/platform/graphics/ImageBuffer.h b/Source/WebCore/platform/graphics/ImageBuffer.h
>index 62a3f7ffa3778a8c01390162543753aa7bd2c21d..e7d2e82c1661b3fb0cd906d476742dfe79c4a5c2 100644
>--- a/Source/WebCore/platform/graphics/ImageBuffer.h
>+++ b/Source/WebCore/platform/graphics/ImageBuffer.h
>@@ -27,6 +27,7 @@
> 
> #pragma once
> 
>+#include "DisplayListFlushIdentifier.h"
> #include "ImageBufferBackend.h"
> #include "RenderingMode.h"
> #include "RenderingResourceIdentifier.h"
>@@ -60,10 +61,13 @@ public:
>     static FloatRect clampedRect(const FloatRect&);
> 
>     static IntSize compatibleBufferSize(const FloatSize&, const GraphicsContext&);
>-    
>+
>     WEBCORE_EXPORT virtual ~ImageBuffer() = default;
> 
>-    virtual bool isAccelerated() const = 0;
>+    virtual void setBackend(std::unique_ptr<ImageBufferBackend>&&) = 0;
>+    virtual void clearBackend() = 0;
>+
>+    virtual RenderingMode renderingMode() const = 0;
>     virtual RenderingResourceIdentifier renderingResourceIdentifier() const { return { }; }
>     
>     virtual GraphicsContext& context() const = 0;
>@@ -73,11 +77,17 @@ public:
>     virtual bool prefersPreparationForDisplay() { return false; }
>     virtual void flushDrawingContext() { }
>     virtual void flushDrawingContextAndCommit() { }
>+    virtual void submitDisplayList(const DisplayList::DisplayList&) { }
>+    virtual void didFlush(DisplayList::FlushIdentifier) { }
> 
>-    virtual AffineTransform baseTransform() const = 0;
>     virtual IntSize logicalSize() const = 0;
>-    virtual IntSize backendSize() const = 0;
>     virtual float resolutionScale() const = 0;
>+    virtual ColorSpace colorSpace() const = 0;
>+    virtual PixelFormat pixelFormat() const = 0;
>+    virtual const ImageBufferBackend::Parameters& parameters() const = 0;
>+
>+    virtual IntSize backendSize() const = 0;
>+    virtual AffineTransform baseTransform() const = 0;
> 
>     virtual size_t memoryCost() const = 0;
>     virtual size_t externalMemoryCost() const = 0;
>diff --git a/Source/WebCore/platform/graphics/ImageBufferBackend.cpp b/Source/WebCore/platform/graphics/ImageBufferBackend.cpp
>index 7f0fe9e6d966e74b45f85aad0e3b2fb84d9450b9..9394e7bff429bc21efcdf3b140111f1ae2ca944d 100644
>--- a/Source/WebCore/platform/graphics/ImageBufferBackend.cpp
>+++ b/Source/WebCore/platform/graphics/ImageBufferBackend.cpp
>@@ -31,12 +31,8 @@
> 
> namespace WebCore {
> 
>-ImageBufferBackend::ImageBufferBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat)
>-    : m_logicalSize(logicalSize)
>-    , m_backendSize(backendSize)
>-    , m_resolutionScale(resolutionScale)
>-    , m_colorSpace(colorSpace)
>-    , m_pixelFormat(pixelFormat)
>+ImageBufferBackend::ImageBufferBackend(const Parameters& parameters)
>+    : m_parameters(parameters)
> {
> }
> 
>@@ -99,15 +95,15 @@ void ImageBufferBackend::convertToLuminanceMask()
> 
> Vector<uint8_t> ImageBufferBackend::toBGRAData(void* data) const
> {
>-    Vector<uint8_t> result(4 * m_logicalSize.area().unsafeGet());
>-    size_t destBytesPerRow = m_logicalSize.width() * 4;
>+    Vector<uint8_t> result(4 * logicalSize().area().unsafeGet());
>+    size_t destBytesPerRow = logicalSize().width() * 4;
>     size_t srcBytesPerRow = bytesPerRow();
> 
>     uint8_t* srcRows = reinterpret_cast<uint8_t*>(data);
> 
>     copyImagePixels(
>         AlphaPremultiplication::Premultiplied, pixelFormat(), srcBytesPerRow, srcRows,
>-        AlphaPremultiplication::Unpremultiplied, PixelFormat::BGRA8, destBytesPerRow, result.data(), m_logicalSize);
>+        AlphaPremultiplication::Unpremultiplied, PixelFormat::BGRA8, destBytesPerRow, result.data(), logicalSize());
> 
>     return result;
> }
>diff --git a/Source/WebCore/platform/graphics/ImageBufferBackend.h b/Source/WebCore/platform/graphics/ImageBufferBackend.h
>index 5806715a7b2c87576902a773584df1805825100f..e280b17a6419a6bbb0f297b32eb6745ae41ed2be 100644
>--- a/Source/WebCore/platform/graphics/ImageBufferBackend.h
>+++ b/Source/WebCore/platform/graphics/ImageBufferBackend.h
>@@ -32,6 +32,7 @@
> #include "ImagePaintingOptions.h"
> #include "IntRect.h"
> #include "PlatformLayer.h"
>+#include "RenderingMode.h"
> #include <wtf/RefPtr.h>
> #include <wtf/Vector.h>
> 
>@@ -77,6 +78,13 @@ public:
> 
> class ImageBufferBackend {
> public:
>+    struct Parameters {
>+        FloatSize logicalSize;
>+        float resolutionScale;
>+        ColorSpace colorSpace;
>+        PixelFormat pixelFormat;
>+    };
>+
>     WEBCORE_EXPORT virtual ~ImageBufferBackend() = default;
> 
>     WEBCORE_EXPORT static IntSize calculateBackendSize(const FloatSize&, float resolutionScale);
>@@ -84,14 +92,9 @@ public:
>     virtual GraphicsContext& context() const = 0;
>     virtual void flushContext() { }
> 
>-    IntSize logicalSize() const { return m_logicalSize; }
>-    IntSize backendSize() const { return m_backendSize; }
>-    float resolutionScale() const { return m_resolutionScale; }
>-    ColorSpace colorSpace() const { return m_colorSpace; }
>-    PixelFormat pixelFormat() const { return m_pixelFormat; }
>+    virtual IntSize backendSize() const = 0;
> 
>-    virtual AffineTransform baseTransform() const { return AffineTransform(); }
>-    virtual size_t memoryCost() const { return 4 * m_backendSize.area().unsafeGet(); }
>+    virtual size_t memoryCost() const { return 4 * backendSize().area().unsafeGet(); }
>     virtual size_t externalMemoryCost() const { return 0; }
> 
>     virtual RefPtr<NativeImage> copyNativeImage(BackingStoreCopy) const = 0;
>@@ -127,24 +130,29 @@ public:
>     virtual std::unique_ptr<ThreadSafeImageBufferFlusher> createFlusher() { return nullptr; }
>     
>     static constexpr bool isOriginAtUpperLeftCorner = false;
>-    static constexpr bool isAccelerated = false;
>+    static constexpr RenderingMode renderingMode = RenderingMode::Unaccelerated;
> 
> protected:
>-    WEBCORE_EXPORT ImageBufferBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace, PixelFormat);
>+    WEBCORE_EXPORT ImageBufferBackend(const Parameters&);
> 
>-    virtual unsigned bytesPerRow() const { return 4 * m_backendSize.width(); }
>+    virtual unsigned bytesPerRow() const { return 4 * backendSize().width(); }
> 
>     template<typename T>
>     T toBackendCoordinates(T t) const
>     {
>         static_assert(std::is_same<T, IntPoint>::value || std::is_same<T, IntSize>::value || std::is_same<T, IntRect>::value);
>-        if (m_resolutionScale != 1)
>-            t.scale(m_resolutionScale);
>+        if (resolutionScale() != 1)
>+            t.scale(resolutionScale());
>         return t;
>     }
> 
>-    IntRect logicalRect() const { return IntRect(IntPoint::zero(), m_logicalSize); };
>-    IntRect backendRect() const { return IntRect(IntPoint::zero(), m_backendSize); };
>+    IntSize logicalSize() const { return IntSize(m_parameters.logicalSize); }
>+    float resolutionScale() const { return m_parameters.resolutionScale; }
>+    ColorSpace colorSpace() const { return m_parameters.colorSpace; }
>+    PixelFormat pixelFormat() const { return m_parameters.pixelFormat; }
>+
>+    IntRect logicalRect() const { return IntRect(IntPoint::zero(), logicalSize()); };
>+    IntRect backendRect() const { return IntRect(IntPoint::zero(), backendSize()); };
> 
>     WEBCORE_EXPORT virtual void copyImagePixels(
>         AlphaPremultiplication srcAlphaFormat, PixelFormat srcPixelFormat, unsigned srcBytesPerRow, uint8_t* srcRows,
>@@ -155,11 +163,7 @@ protected:
>     WEBCORE_EXPORT RefPtr<ImageData> getImageData(AlphaPremultiplication outputFormat, const IntRect& srcRect, void* data) const;
>     WEBCORE_EXPORT void putImageData(AlphaPremultiplication inputFormat, const ImageData&, const IntRect& srcRect, const IntPoint& destPoint, AlphaPremultiplication destFormat, void* data);
> 
>-    IntSize m_logicalSize;
>-    IntSize m_backendSize;
>-    float m_resolutionScale;
>-    ColorSpace m_colorSpace;
>-    PixelFormat m_pixelFormat;
>+    Parameters m_parameters;
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/platform/graphics/PlatformImageBuffer.h b/Source/WebCore/platform/graphics/PlatformImageBuffer.h
>index b05fa6516971d1767131d56a4639353ef94e4925..52dd83cc93d5553b379e587d4385d4f7805944bb 100644
>--- a/Source/WebCore/platform/graphics/PlatformImageBuffer.h
>+++ b/Source/WebCore/platform/graphics/PlatformImageBuffer.h
>@@ -75,5 +75,5 @@ using DisplayListAcceleratedImageBuffer = DisplayList::ImageBuffer<AcceleratedIm
> } // namespace WebCore
> 
> SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::AcceleratedImageBuffer)
>-    static bool isType(const WebCore::ImageBuffer& buffer) { return buffer.isAccelerated(); }
>+    static bool isType(const WebCore::ImageBuffer& buffer) { return buffer.renderingMode() == WebCore::RenderingMode::Accelerated; }
> SPECIALIZE_TYPE_TRAITS_END()
>diff --git a/Source/WebCore/platform/graphics/cairo/ImageBufferCairoBackend.cpp b/Source/WebCore/platform/graphics/cairo/ImageBufferCairoBackend.cpp
>index 12a5b60a2e9046a195892baf5dd7ed49633b3e74..b3bfd8127b87d1688eabb5cf4b2a71c3359cd2d0 100644
>--- a/Source/WebCore/platform/graphics/cairo/ImageBufferCairoBackend.cpp
>+++ b/Source/WebCore/platform/graphics/cairo/ImageBufferCairoBackend.cpp
>@@ -80,7 +80,7 @@ void ImageBufferCairoBackend::drawPattern(GraphicsContext& destContext, const Fl
>     }
> 
>     if (auto image = copyNativeImage(&destContext == &context() ? CopyBackingStore : DontCopyBackingStore))
>-        Cairo::drawPattern(*destContext.platformContext(), image->platformImage().get(), m_logicalSize, destRect, srcRect, patternTransform, phase, options);
>+        Cairo::drawPattern(*destContext.platformContext(), image->platformImage().get(), logicalSize(), destRect, srcRect, patternTransform, phase, options);
> }
> 
> void ImageBufferCairoBackend::clipToMask(GraphicsContext& destContext, const FloatRect& destRect)
>diff --git a/Source/WebCore/platform/graphics/cairo/ImageBufferCairoImageSurfaceBackend.cpp b/Source/WebCore/platform/graphics/cairo/ImageBufferCairoImageSurfaceBackend.cpp
>index 1cd0754b39143af429b46d5d78e451f0d1e074c3..3da1455eba06d6794e3327017daafd79bc5472dc 100644
>--- a/Source/WebCore/platform/graphics/cairo/ImageBufferCairoImageSurfaceBackend.cpp
>+++ b/Source/WebCore/platform/graphics/cairo/ImageBufferCairoImageSurfaceBackend.cpp
>@@ -41,13 +41,13 @@ namespace WebCore {
> 
> WTF_MAKE_ISO_ALLOCATED_IMPL(ImageBufferCairoImageSurfaceBackend);
> 
>-std::unique_ptr<ImageBufferCairoImageSurfaceBackend> ImageBufferCairoImageSurfaceBackend::create(const FloatSize& size, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, const HostWindow*)
>+std::unique_ptr<ImageBufferCairoImageSurfaceBackend> ImageBufferCairoImageSurfaceBackend::create(const Parameters& parameters, const HostWindow*)
> {
>-    ASSERT(pixelFormat == PixelFormat::BGRA8);
>+    ASSERT(parameters.pixelFormat == PixelFormat::BGRA8);
> 
>     static cairo_user_data_key_t s_surfaceDataKey;
> 
>-    IntSize backendSize = calculateBackendSize(size, resolutionScale);
>+    IntSize backendSize = calculateBackendSize(parameters.logicalSize, parameters.resolutionScale);
>     if (backendSize.isEmpty() || backendSize.width() > cairoMaxImageSize || backendSize.height() > cairoMaxImageSize)
>         return nullptr;
> 
>@@ -61,16 +61,16 @@ std::unique_ptr<ImageBufferCairoImageSurfaceBackend> ImageBufferCairoImageSurfac
>         fastFree(data);
>     });
> 
>-    return std::unique_ptr<ImageBufferCairoImageSurfaceBackend>(new ImageBufferCairoImageSurfaceBackend(size, backendSize, resolutionScale, colorSpace, pixelFormat, WTFMove(surface)));
>+    return std::unique_ptr<ImageBufferCairoImageSurfaceBackend>(new ImageBufferCairoImageSurfaceBackend(parameters, WTFMove(surface)));
> }
> 
>-std::unique_ptr<ImageBufferCairoImageSurfaceBackend> ImageBufferCairoImageSurfaceBackend::create(const FloatSize& size, const GraphicsContext&)
>+std::unique_ptr<ImageBufferCairoImageSurfaceBackend> ImageBufferCairoImageSurfaceBackend::create(const Parameters& parameters, const GraphicsContext&)
> {
>-    return ImageBufferCairoImageSurfaceBackend::create(size, 1, ColorSpace::SRGB, PixelFormat::BGRA8, nullptr);
>+    return ImageBufferCairoImageSurfaceBackend::create(parameters, nullptr);
> }
> 
>-ImageBufferCairoImageSurfaceBackend::ImageBufferCairoImageSurfaceBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, RefPtr<cairo_surface_t>&& surface)
>-    : ImageBufferCairoSurfaceBackend(logicalSize, backendSize, resolutionScale, colorSpace, pixelFormat, WTFMove(surface))
>+ImageBufferCairoImageSurfaceBackend::ImageBufferCairoImageSurfaceBackend(const Parameters& parameters, RefPtr<cairo_surface_t>&& surface)
>+    : ImageBufferCairoSurfaceBackend(parameters, WTFMove(surface))
> {
>     ASSERT(cairo_surface_get_type(m_surface.get()) == CAIRO_SURFACE_TYPE_IMAGE);
> }
>@@ -79,16 +79,16 @@ void ImageBufferCairoImageSurfaceBackend::platformTransformColorSpace(const std:
> {
>     unsigned char* dataSrc = cairo_image_surface_get_data(m_surface.get());
>     int stride = cairo_image_surface_get_stride(m_surface.get());
>-    for (int y = 0; y < m_logicalSize.height(); ++y) {
>+    for (int y = 0; y < logicalSize().height(); ++y) {
>         unsigned* row = reinterpret_cast_ptr<unsigned*>(dataSrc + stride * y);
>-        for (int x = 0; x < m_logicalSize.width(); x++) {
>+        for (int x = 0; x < logicalSize().width(); x++) {
>             unsigned* pixel = row + x;
>             auto pixelComponents = unpremultiplied(asSRGBA(PackedColor::ARGB { *pixel }));
>             pixelComponents = { lookUpTable[pixelComponents.red], lookUpTable[pixelComponents.green], lookUpTable[pixelComponents.blue], pixelComponents.alpha };
>             *pixel = PackedColor::ARGB { premultipliedCeiling(pixelComponents) }.value;
>         }
>     }
>-    cairo_surface_mark_dirty_rectangle(m_surface.get(), 0, 0, m_logicalSize.width(), m_logicalSize.height());
>+    cairo_surface_mark_dirty_rectangle(m_surface.get(), 0, 0, logicalSize().width(), logicalSize().height());
> }
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/platform/graphics/cairo/ImageBufferCairoImageSurfaceBackend.h b/Source/WebCore/platform/graphics/cairo/ImageBufferCairoImageSurfaceBackend.h
>index d16d33eac46c5df66fb8fa2d954910e2f9115a03..865cc69b2d5338545f37e4193cb94f1980be73a4 100644
>--- a/Source/WebCore/platform/graphics/cairo/ImageBufferCairoImageSurfaceBackend.h
>+++ b/Source/WebCore/platform/graphics/cairo/ImageBufferCairoImageSurfaceBackend.h
>@@ -40,11 +40,11 @@ class ImageBufferCairoImageSurfaceBackend : public ImageBufferCairoSurfaceBacken
>     WTF_MAKE_ISO_ALLOCATED(ImageBufferCairoImageSurfaceBackend);
>     WTF_MAKE_NONCOPYABLE(ImageBufferCairoImageSurfaceBackend);
> public:
>-    static std::unique_ptr<ImageBufferCairoImageSurfaceBackend> create(const FloatSize&, float resolutionScale, ColorSpace, PixelFormat, const HostWindow*);
>-    static std::unique_ptr<ImageBufferCairoImageSurfaceBackend> create(const FloatSize&, const GraphicsContext&);
>+    static std::unique_ptr<ImageBufferCairoImageSurfaceBackend> create(const Parameters&, const HostWindow*);
>+    static std::unique_ptr<ImageBufferCairoImageSurfaceBackend> create(const Parameters&, const GraphicsContext&);
> 
> private:
>-    ImageBufferCairoImageSurfaceBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace, PixelFormat, RefPtr<cairo_surface_t>&&);
>+    ImageBufferCairoImageSurfaceBackend(const Parameters&, RefPtr<cairo_surface_t>&&);
> 
>     void platformTransformColorSpace(const std::array<uint8_t, 256>& lookUpTable) override;
> };
>diff --git a/Source/WebCore/platform/graphics/cairo/ImageBufferCairoSurfaceBackend.cpp b/Source/WebCore/platform/graphics/cairo/ImageBufferCairoSurfaceBackend.cpp
>index 9b82164aea33071e5361c6fe39b1b827c9b6b150..0b73f14ba7005e52050ed582164a11638054971f 100644
>--- a/Source/WebCore/platform/graphics/cairo/ImageBufferCairoSurfaceBackend.cpp
>+++ b/Source/WebCore/platform/graphics/cairo/ImageBufferCairoSurfaceBackend.cpp
>@@ -43,8 +43,8 @@
> 
> namespace WebCore {
> 
>-ImageBufferCairoSurfaceBackend::ImageBufferCairoSurfaceBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, RefPtr<cairo_surface_t>&& surface)
>-    : ImageBufferCairoBackend(logicalSize, backendSize, resolutionScale, colorSpace, pixelFormat)
>+ImageBufferCairoSurfaceBackend::ImageBufferCairoSurfaceBackend(const Parameters& parameters, RefPtr<cairo_surface_t>&& surface)
>+    : ImageBufferCairoBackend(parameters)
>     , m_surface(WTFMove(surface))
> {
>     ASSERT(cairo_surface_status(m_surface.get()) == CAIRO_STATUS_SUCCESS);
>@@ -59,6 +59,11 @@ GraphicsContext& ImageBufferCairoSurfaceBackend::context() const
>     return *m_context;
> }
> 
>+IntSize ImageBufferCairoSurfaceBackend::backendSize() const
>+{
>+    return { cairo_image_surface_get_width(m_surface.get()), cairo_image_surface_get_height(m_surface.get()) };
>+}
>+
> unsigned ImageBufferCairoSurfaceBackend::bytesPerRow() const
> {
>     return cairo_image_surface_get_stride(m_surface.get());
>diff --git a/Source/WebCore/platform/graphics/cairo/ImageBufferCairoSurfaceBackend.h b/Source/WebCore/platform/graphics/cairo/ImageBufferCairoSurfaceBackend.h
>index 12aa2b1ce88ee42645fa772e679f5d4195a26747..9e93dde858ef43b282d438ca5a767febcbbddbcd 100644
>--- a/Source/WebCore/platform/graphics/cairo/ImageBufferCairoSurfaceBackend.h
>+++ b/Source/WebCore/platform/graphics/cairo/ImageBufferCairoSurfaceBackend.h
>@@ -40,6 +40,8 @@ class ImageBufferCairoSurfaceBackend : public ImageBufferCairoBackend {
> public:
>     GraphicsContext& context() const override;
> 
>+    IntSize backendSize() const override;
>+
>     RefPtr<NativeImage> copyNativeImage(BackingStoreCopy) const override;
> 
>     Vector<uint8_t> toBGRAData() const override;
>@@ -47,7 +49,7 @@ public:
>     void putImageData(AlphaPremultiplication inputFormat, const ImageData&, const IntRect& srcRect, const IntPoint& destPoint, AlphaPremultiplication destFormat) override;
> 
> protected:
>-    ImageBufferCairoSurfaceBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace, PixelFormat, RefPtr<cairo_surface_t>&&);
>+    ImageBufferCairoSurfaceBackend(const Parameters&, RefPtr<cairo_surface_t>&&);
> 
>     RefPtr<NativeImage> cairoSurfaceCoerceToImage() const;
>     unsigned bytesPerRow() const override;
>diff --git a/Source/WebCore/platform/graphics/cg/ImageBufferCGBackend.cpp b/Source/WebCore/platform/graphics/cg/ImageBufferCGBackend.cpp
>index 5017ba12c8b487b0ca06e543b1296365d6dd2b2b..abbd368878267d8cf778c6606fdb2803dd4a1d79 100644
>--- a/Source/WebCore/platform/graphics/cg/ImageBufferCGBackend.cpp
>+++ b/Source/WebCore/platform/graphics/cg/ImageBufferCGBackend.cpp
>@@ -79,8 +79,8 @@ void ImageBufferCGBackend::setupContext() const
> {
>     // The initial CTM matches DisplayList::Recorder::clipToDrawingCommands()'s initial CTM.
>     context().scale(FloatSize(1, -1));
>-    context().translate(0, -m_backendSize.height());
>-    context().applyDeviceScaleFactor(m_resolutionScale);
>+    context().translate(0, -backendSize().height());
>+    context().applyDeviceScaleFactor(resolutionScale());
> }
> 
> static RetainPtr<CGImageRef> createCroppedImageIfNecessary(CGImageRef image, const IntSize& backendSize)
>@@ -112,31 +112,32 @@ static RefPtr<Image> createBitmapImageAfterScalingIfNeeded(RefPtr<NativeImage>&&
> RefPtr<Image> ImageBufferCGBackend::copyImage(BackingStoreCopy copyBehavior, PreserveResolution preserveResolution) const
> {
>     RefPtr<NativeImage> image;
>-    if (m_resolutionScale == 1 || preserveResolution == PreserveResolution::Yes)
>+    if (resolutionScale() == 1 || preserveResolution == PreserveResolution::Yes)
>         image = copyNativeImage(copyBehavior);
>     else
>         image = copyNativeImage(DontCopyBackingStore);
>-    return createBitmapImageAfterScalingIfNeeded(WTFMove(image), m_logicalSize, m_backendSize, m_resolutionScale, preserveResolution);
>+    return createBitmapImageAfterScalingIfNeeded(WTFMove(image), logicalSize(), backendSize(), resolutionScale(), preserveResolution);
> }
> 
> RefPtr<Image> ImageBufferCGBackend::sinkIntoImage(PreserveResolution preserveResolution)
> {
>-    return createBitmapImageAfterScalingIfNeeded(sinkIntoNativeImage(), m_logicalSize, m_backendSize, m_resolutionScale, preserveResolution);
>+    auto backendSize = this->backendSize();
>+    return createBitmapImageAfterScalingIfNeeded(sinkIntoNativeImage(), logicalSize(), backendSize, resolutionScale(), preserveResolution);
> }
> 
> void ImageBufferCGBackend::draw(GraphicsContext& destContext, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
> {
>     FloatRect srcRectScaled = srcRect;
>-    srcRectScaled.scale(m_resolutionScale);
>+    srcRectScaled.scale(resolutionScale());
> 
>     if (auto image = copyNativeImage(&destContext == &context() ? CopyBackingStore : DontCopyBackingStore))
>-        destContext.drawNativeImage(*image, m_backendSize, destRect, srcRectScaled, options);
>+        destContext.drawNativeImage(*image, backendSize(), destRect, srcRectScaled, options);
> }
> 
> void ImageBufferCGBackend::drawPattern(GraphicsContext& destContext, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& options)
> {
>     FloatRect adjustedSrcRect = srcRect;
>-    adjustedSrcRect.scale(m_resolutionScale);
>+    adjustedSrcRect.scale(resolutionScale());
> 
>     if (auto image = copyImage(&destContext == &context() ? CopyBackingStore : DontCopyBackingStore))
>         image->drawPattern(destContext, destRect, adjustedSrcRect, patternTransform, phase, spacing, options);
>@@ -159,11 +160,6 @@ void ImageBufferCGBackend::clipToMask(GraphicsContext& destContext, const FloatR
>     CGContextTranslateCTM(cgContext, -destRect.x(), -destRect.maxY());
> }
> 
>-AffineTransform ImageBufferCGBackend::baseTransform() const
>-{
>-    return AffineTransform(1, 0, 0, -1, 0, m_logicalSize.height());
>-}
>-
> RetainPtr<CFDataRef> ImageBufferCGBackend::toCFData(const String& mimeType, Optional<double> quality, PreserveResolution preserveResolution) const
> {
>     ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
>@@ -190,7 +186,7 @@ RetainPtr<CFDataRef> ImageBufferCGBackend::toCFData(const String& mimeType, Opti
>             return nullptr;
> 
>         image = adoptCF(CGImageCreate(pixelArrayDimensions.width(), pixelArrayDimensions.height(), 8, 32, 4 * pixelArrayDimensions.width(), sRGBColorSpaceRef(), kCGBitmapByteOrderDefault | kCGImageAlphaNoneSkipLast, dataProvider.get(), 0, false, kCGRenderingIntentDefault));
>-    } else if (m_resolutionScale == 1 || preserveResolution == PreserveResolution::Yes) {
>+    } else if (resolutionScale() == 1 || preserveResolution == PreserveResolution::Yes) {
>         image = copyNativeImage(CopyBackingStore)->platformImage();
>         image = createCroppedImageIfNecessary(image.get(), backendSize());
>     } else {
>diff --git a/Source/WebCore/platform/graphics/cg/ImageBufferCGBackend.h b/Source/WebCore/platform/graphics/cg/ImageBufferCGBackend.h
>index 1e07fdc6443fdc08f6af63e0883eb32053e4d597..b26ae084347b9e233404600c2ea4a4a28b1e1ba7 100644
>--- a/Source/WebCore/platform/graphics/cg/ImageBufferCGBackend.h
>+++ b/Source/WebCore/platform/graphics/cg/ImageBufferCGBackend.h
>@@ -41,8 +41,6 @@ public:
>     
>     void clipToMask(GraphicsContext&, const FloatRect& destRect) override;
> 
>-    AffineTransform baseTransform() const override;
>-
>     String toDataURL(const String& mimeType, Optional<double> quality, PreserveResolution) const override;
>     Vector<uint8_t> toData(const String& mimeType, Optional<double> quality) const override;
> 
>diff --git a/Source/WebCore/platform/graphics/cg/ImageBufferCGBitmapBackend.cpp b/Source/WebCore/platform/graphics/cg/ImageBufferCGBitmapBackend.cpp
>index f218f27f2f53c5a4adbb6a5aedc3c49e48cd63a4..e365955d73fb9407777f98dd5a1584ac256dde3c 100644
>--- a/Source/WebCore/platform/graphics/cg/ImageBufferCGBitmapBackend.cpp
>+++ b/Source/WebCore/platform/graphics/cg/ImageBufferCGBitmapBackend.cpp
>@@ -39,11 +39,11 @@ namespace WebCore {
> 
> WTF_MAKE_ISO_ALLOCATED_IMPL(ImageBufferCGBitmapBackend);
> 
>-std::unique_ptr<ImageBufferCGBitmapBackend> ImageBufferCGBitmapBackend::create(const FloatSize& size, float resolutionScale, ColorSpace colorSpace, CGColorSpaceRef cgColorSpace, PixelFormat pixelFormat, const HostWindow*)
>+std::unique_ptr<ImageBufferCGBitmapBackend> ImageBufferCGBitmapBackend::create(const Parameters& parameters, CGColorSpaceRef cgColorSpace, const HostWindow*)
> {
>-    ASSERT(pixelFormat == PixelFormat::BGRA8);
>+    ASSERT(parameters.pixelFormat == PixelFormat::BGRA8);
> 
>-    IntSize backendSize = calculateBackendSize(size, resolutionScale);
>+    IntSize backendSize = calculateBackendSize(parameters.logicalSize, parameters.resolutionScale);
>     if (backendSize.isEmpty())
>         return nullptr;
> 
>@@ -70,24 +70,24 @@ std::unique_ptr<ImageBufferCGBitmapBackend> ImageBufferCGBitmapBackend::create(c
> 
>     auto dataProvider = adoptCF(CGDataProviderCreateWithData(0, data, numBytes, releaseImageData));
> 
>-    return std::unique_ptr<ImageBufferCGBitmapBackend>(new ImageBufferCGBitmapBackend(size, backendSize, resolutionScale, colorSpace, pixelFormat, data, WTFMove(dataProvider), WTFMove(context)));
>+    return std::unique_ptr<ImageBufferCGBitmapBackend>(new ImageBufferCGBitmapBackend(parameters, data, WTFMove(dataProvider), WTFMove(context)));
> }
> 
>-std::unique_ptr<ImageBufferCGBitmapBackend> ImageBufferCGBitmapBackend::create(const FloatSize& size, const GraphicsContext& context)
>+std::unique_ptr<ImageBufferCGBitmapBackend> ImageBufferCGBitmapBackend::create(const Parameters& parameters, const GraphicsContext& context)
> {
>-    if (auto cgColorSpace = contextColorSpace(context))
>-        return ImageBufferCGBitmapBackend::create(size, 1, ColorSpace::SRGB, cgColorSpace.get(), PixelFormat::BGRA8, nullptr);
>-    
>-    return ImageBufferCGBitmapBackend::create(size, 1, ColorSpace::SRGB, PixelFormat::BGRA8, nullptr);
>+    if (auto cgColorSpace = context.hasPlatformContext() ? contextColorSpace(context) : nullptr)
>+        return ImageBufferCGBitmapBackend::create(parameters, cgColorSpace.get(), nullptr);
>+
>+    return ImageBufferCGBitmapBackend::create(parameters, nullptr);
> }
> 
>-std::unique_ptr<ImageBufferCGBitmapBackend> ImageBufferCGBitmapBackend::create(const FloatSize& size, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, const HostWindow* hostWindow)
>+std::unique_ptr<ImageBufferCGBitmapBackend> ImageBufferCGBitmapBackend::create(const Parameters& parameters, const HostWindow* hostWindow)
> {
>-    return ImageBufferCGBitmapBackend::create(size, resolutionScale, colorSpace, cachedCGColorSpace(colorSpace), pixelFormat, hostWindow);
>+    return ImageBufferCGBitmapBackend::create(parameters, cachedCGColorSpace(parameters.colorSpace), hostWindow);
> }
> 
>-ImageBufferCGBitmapBackend::ImageBufferCGBitmapBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, void* data, RetainPtr<CGDataProviderRef>&& dataProvider, std::unique_ptr<GraphicsContext>&& context)
>-    : ImageBufferCGBackend(logicalSize, backendSize, resolutionScale, colorSpace, pixelFormat)
>+ImageBufferCGBitmapBackend::ImageBufferCGBitmapBackend(const Parameters& parameters, void* data, RetainPtr<CGDataProviderRef>&& dataProvider, std::unique_ptr<GraphicsContext>&& context)
>+    : ImageBufferCGBackend(parameters)
>     , m_data(data)
>     , m_dataProvider(WTFMove(dataProvider))
>     , m_context(WTFMove(context))
>@@ -103,6 +103,11 @@ GraphicsContext& ImageBufferCGBitmapBackend::context() const
>     return *m_context;
> }
> 
>+IntSize ImageBufferCGBitmapBackend::backendSize() const
>+{
>+    return { static_cast<int>(CGBitmapContextGetWidth(context().platformContext())), static_cast<int>(CGBitmapContextGetHeight(context().platformContext())) };
>+}
>+
> RefPtr<NativeImage> ImageBufferCGBitmapBackend::copyNativeImage(BackingStoreCopy copyBehavior) const
> {
>     switch (copyBehavior) {
>@@ -110,9 +115,10 @@ RefPtr<NativeImage> ImageBufferCGBitmapBackend::copyNativeImage(BackingStoreCopy
>         return NativeImage::create(adoptCF(CGBitmapContextCreateImage(context().platformContext())));
> 
>     case DontCopyBackingStore:
>+        auto backendSize = this->backendSize();
>         return NativeImage::create(adoptCF(CGImageCreate(
>-            m_backendSize.width(), m_backendSize.height(), 8, 32, bytesPerRow(),
>-            cachedCGColorSpace(m_colorSpace), kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, m_dataProvider.get(),
>+            backendSize.width(), backendSize.height(), 8, 32, bytesPerRow(),
>+            cachedCGColorSpace(colorSpace()), kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, m_dataProvider.get(),
>             0, true, kCGRenderingIntentDefault)));
>     }
> 
>diff --git a/Source/WebCore/platform/graphics/cg/ImageBufferCGBitmapBackend.h b/Source/WebCore/platform/graphics/cg/ImageBufferCGBitmapBackend.h
>index e92c92f5d50fde57aaa3ca5c2ff29df08b864d29..8f3323e7dcec6355acb7d5b99c20787715c86ba8 100644
>--- a/Source/WebCore/platform/graphics/cg/ImageBufferCGBitmapBackend.h
>+++ b/Source/WebCore/platform/graphics/cg/ImageBufferCGBitmapBackend.h
>@@ -36,12 +36,14 @@ class ImageBufferCGBitmapBackend : public ImageBufferCGBackend {
>     WTF_MAKE_ISO_ALLOCATED(ImageBufferCGBitmapBackend);
>     WTF_MAKE_NONCOPYABLE(ImageBufferCGBitmapBackend);
> public:
>-    static std::unique_ptr<ImageBufferCGBitmapBackend> create(const FloatSize&, float resolutionScale, ColorSpace, CGColorSpaceRef, PixelFormat, const HostWindow*);
>-    static std::unique_ptr<ImageBufferCGBitmapBackend> create(const FloatSize&, float resolutionScale, ColorSpace, PixelFormat, const HostWindow*);
>-    static std::unique_ptr<ImageBufferCGBitmapBackend> create(const FloatSize&, const GraphicsContext&);
>+    static std::unique_ptr<ImageBufferCGBitmapBackend> create(const Parameters&, CGColorSpaceRef, const HostWindow*);
>+    static std::unique_ptr<ImageBufferCGBitmapBackend> create(const Parameters&, const HostWindow*);
>+    static std::unique_ptr<ImageBufferCGBitmapBackend> create(const Parameters&, const GraphicsContext&);
> 
>     GraphicsContext& context() const override;
> 
>+    IntSize backendSize() const override;
>+
>     RefPtr<NativeImage> copyNativeImage(BackingStoreCopy = CopyBackingStore) const override;
> 
>     Vector<uint8_t> toBGRAData() const override;
>@@ -52,7 +54,7 @@ public:
>     static constexpr bool isOriginAtUpperLeftCorner = true;
> 
> private:
>-    ImageBufferCGBitmapBackend(const FloatSize& logicalSize, const IntSize& physicalSize, float resolutionScale, ColorSpace, PixelFormat, void* data, RetainPtr<CGDataProviderRef>&&, std::unique_ptr<GraphicsContext>&&);
>+    ImageBufferCGBitmapBackend(const Parameters&, void* data, RetainPtr<CGDataProviderRef>&&, std::unique_ptr<GraphicsContext>&&);
> 
>     void* m_data;
>     RetainPtr<CGDataProviderRef> m_dataProvider;
>diff --git a/Source/WebCore/platform/graphics/cg/ImageBufferIOSurfaceBackend.cpp b/Source/WebCore/platform/graphics/cg/ImageBufferIOSurfaceBackend.cpp
>index ad3ff1d79772037640e2d69954128860b7748c36..d3f431076b8ef2bb71d1289d1cb76d87337b6d82 100644
>--- a/Source/WebCore/platform/graphics/cg/ImageBufferIOSurfaceBackend.cpp
>+++ b/Source/WebCore/platform/graphics/cg/ImageBufferIOSurfaceBackend.cpp
>@@ -64,13 +64,13 @@ RetainPtr<CGColorSpaceRef> ImageBufferIOSurfaceBackend::contextColorSpace(const
>     return ImageBufferCGBackend::contextColorSpace(context);
> }
> 
>-std::unique_ptr<ImageBufferIOSurfaceBackend> ImageBufferIOSurfaceBackend::create(const FloatSize& size, float resolutionScale, ColorSpace colorSpace, CGColorSpaceRef cgColorSpace, PixelFormat pixelFormat, const HostWindow* hostWindow)
>+std::unique_ptr<ImageBufferIOSurfaceBackend> ImageBufferIOSurfaceBackend::create(const Parameters& parameters, CGColorSpaceRef cgColorSpace, const HostWindow* hostWindow)
> {
>-    IntSize backendSize = calculateBackendSize(size, resolutionScale);
>+    IntSize backendSize = calculateBackendSize(parameters.logicalSize, parameters.resolutionScale);
>     if (backendSize.isEmpty())
>         return nullptr;
> 
>-    auto surface = IOSurface::create(backendSize, backendSize, cgColorSpace, IOSurface::formatForPixelFormat(pixelFormat));
>+    auto surface = IOSurface::create(backendSize, backendSize, cgColorSpace, IOSurface::formatForPixelFormat(parameters.pixelFormat));
>     if (!surface)
>         return nullptr;
> 
>@@ -80,24 +80,24 @@ std::unique_ptr<ImageBufferIOSurfaceBackend> ImageBufferIOSurfaceBackend::create
> 
>     CGContextClearRect(cgContext.get(), FloatRect(FloatPoint::zero(), backendSize));
> 
>-    return makeUnique<ImageBufferIOSurfaceBackend>(size, backendSize, resolutionScale, colorSpace, pixelFormat, WTFMove(surface));
>+    return makeUnique<ImageBufferIOSurfaceBackend>(parameters, WTFMove(surface));
> }
> 
>-std::unique_ptr<ImageBufferIOSurfaceBackend> ImageBufferIOSurfaceBackend::create(const FloatSize& size, const GraphicsContext& context)
>+std::unique_ptr<ImageBufferIOSurfaceBackend> ImageBufferIOSurfaceBackend::create(const Parameters& parameters, const GraphicsContext& context)
> {
>-    if (auto cgColorSpace = contextColorSpace(context))
>-        return ImageBufferIOSurfaceBackend::create(size, 1, ColorSpace::SRGB, cgColorSpace.get(), PixelFormat::BGRA8, nullptr);
>-    
>-    return ImageBufferIOSurfaceBackend::create(size, 1, ColorSpace::SRGB, PixelFormat::BGRA8, nullptr);
>+    if (auto cgColorSpace = context.hasPlatformContext() ? contextColorSpace(context) : nullptr)
>+        return ImageBufferIOSurfaceBackend::create(parameters, cgColorSpace.get(), nullptr);
>+
>+    return ImageBufferIOSurfaceBackend::create(parameters, nullptr);
> }
> 
>-std::unique_ptr<ImageBufferIOSurfaceBackend> ImageBufferIOSurfaceBackend::create(const FloatSize& size, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, const HostWindow* hostWindow)
>+std::unique_ptr<ImageBufferIOSurfaceBackend> ImageBufferIOSurfaceBackend::create(const Parameters& parameters, const HostWindow* hostWindow)
> {
>-    return ImageBufferIOSurfaceBackend::create(size, resolutionScale, colorSpace, cachedCGColorSpace(colorSpace), pixelFormat, hostWindow);
>+    return ImageBufferIOSurfaceBackend::create(parameters, cachedCGColorSpace(parameters.colorSpace), hostWindow);
> }
> 
>-ImageBufferIOSurfaceBackend::ImageBufferIOSurfaceBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, std::unique_ptr<IOSurface>&& surface)
>-    : ImageBufferCGBackend(logicalSize, backendSize, resolutionScale, colorSpace, pixelFormat)
>+ImageBufferIOSurfaceBackend::ImageBufferIOSurfaceBackend(const Parameters& parameters, std::unique_ptr<IOSurface>&& surface)
>+    : ImageBufferCGBackend(parameters)
>     , m_surface(WTFMove(surface))
> {
>     ASSERT(m_surface);
>@@ -120,6 +120,11 @@ void ImageBufferIOSurfaceBackend::flushContext()
>     CGContextFlush(context().platformContext());
> }
> 
>+IntSize ImageBufferIOSurfaceBackend::backendSize() const
>+{
>+    return m_surface->size();
>+}
>+
> size_t ImageBufferIOSurfaceBackend::memoryCost() const
> {
>     return m_surface->totalBytes();
>@@ -148,10 +153,10 @@ RefPtr<NativeImage> ImageBufferIOSurfaceBackend::sinkIntoNativeImage()
> void ImageBufferIOSurfaceBackend::drawConsuming(GraphicsContext& destContext, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
> {
>     FloatRect adjustedSrcRect = srcRect;
>-    adjustedSrcRect.scale(m_resolutionScale);
>+    adjustedSrcRect.scale(resolutionScale());
> 
>     if (auto image = sinkIntoNativeImage())
>-        destContext.drawNativeImage(*image, m_backendSize, destRect, adjustedSrcRect, options);
>+        destContext.drawNativeImage(*image, backendSize(), destRect, adjustedSrcRect, options);
> }
> 
> RetainPtr<CFDataRef> ImageBufferIOSurfaceBackend::toCFData(const String& mimeType, Optional<double> quality, PreserveResolution preserveResolution) const
>diff --git a/Source/WebCore/platform/graphics/cg/ImageBufferIOSurfaceBackend.h b/Source/WebCore/platform/graphics/cg/ImageBufferIOSurfaceBackend.h
>index de982111e52c12edb08dc788b50ecefb36507650..4859df6fc525d85c328c145f079178356909e25d 100644
>--- a/Source/WebCore/platform/graphics/cg/ImageBufferIOSurfaceBackend.h
>+++ b/Source/WebCore/platform/graphics/cg/ImageBufferIOSurfaceBackend.h
>@@ -39,15 +39,17 @@ class WEBCORE_EXPORT ImageBufferIOSurfaceBackend : public ImageBufferCGBackend {
> public:
>     static IntSize calculateBackendSize(const FloatSize& logicalSize, float resolutionScale);
> 
>-    static std::unique_ptr<ImageBufferIOSurfaceBackend> create(const FloatSize&, float resolutionScale, ColorSpace, CGColorSpaceRef, PixelFormat, const HostWindow*);
>-    static std::unique_ptr<ImageBufferIOSurfaceBackend> create(const FloatSize&, float resolutionScale, ColorSpace, PixelFormat, const HostWindow*);
>-    static std::unique_ptr<ImageBufferIOSurfaceBackend> create(const FloatSize&, const GraphicsContext&);
>+    static std::unique_ptr<ImageBufferIOSurfaceBackend> create(const Parameters&, CGColorSpaceRef, const HostWindow*);
>+    static std::unique_ptr<ImageBufferIOSurfaceBackend> create(const Parameters&, const HostWindow*);
>+    static std::unique_ptr<ImageBufferIOSurfaceBackend> create(const Parameters&, const GraphicsContext&);
> 
>-    ImageBufferIOSurfaceBackend(const FloatSize& logicalSize, const IntSize& physicalSize, float resolutionScale, ColorSpace, PixelFormat, std::unique_ptr<IOSurface>&&);
>+    ImageBufferIOSurfaceBackend(const Parameters&, std::unique_ptr<IOSurface>&&);
> 
>     GraphicsContext& context() const override;
>     void flushContext() override;
> 
>+    IntSize backendSize() const override;
>+    
>     size_t memoryCost() const override;
>     size_t externalMemoryCost() const override;
> 
>@@ -69,7 +71,7 @@ public:
>     void releaseBufferToPool() override;
> 
>     static constexpr bool isOriginAtUpperLeftCorner = true;
>-    static constexpr bool isAccelerated = true;
>+    static constexpr RenderingMode renderingMode = RenderingMode::Accelerated;
> 
> protected:
>     static RetainPtr<CGColorSpaceRef> contextColorSpace(const GraphicsContext&);
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayList.h b/Source/WebCore/platform/graphics/displaylists/DisplayList.h
>index 26fc973072112730393e2dcbc87d0c6b9ca54258..16b197f9ee2d28dbe921d930943d430461dfcd86 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayList.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayList.h
>@@ -33,7 +33,6 @@
> #include <wtf/FastMalloc.h>
> #include <wtf/HashSet.h>
> #include <wtf/Noncopyable.h>
>-#include <wtf/ObjectIdentifier.h>
> #include <wtf/Vector.h>
> #include <wtf/text/WTFString.h>
> 
>@@ -45,9 +44,6 @@ namespace WebCore {
> 
> namespace DisplayList {
> 
>-enum FlushIdentifierType { };
>-using FlushIdentifier = ObjectIdentifier<FlushIdentifierType>;
>-
> enum AsTextFlag {
>     None                            = 0,
>     IncludesPlatformOperations      = 1 << 0,
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListFlushIdentifier.h b/Source/WebCore/platform/graphics/displaylists/DisplayListFlushIdentifier.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..9cf78168ebb7fc737b9b4a6cf8d53729f5a060ec
>--- /dev/null
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListFlushIdentifier.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
>+
>+#include <wtf/ObjectIdentifier.h>
>+
>+namespace WebCore {
>+
>+namespace DisplayList {
>+
>+enum FlushIdentifierType { };
>+using FlushIdentifier = ObjectIdentifier<FlushIdentifierType>;
>+
>+} // DisplayList
>+
>+} // namespace WebCore
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListImageBuffer.h b/Source/WebCore/platform/graphics/displaylists/DisplayListImageBuffer.h
>index f5b223402aeb37728b7301fb667118a3b2e8b040..a65fca559a165fc6b2d8623f353e11647293776c 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListImageBuffer.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListImageBuffer.h
>@@ -34,26 +34,29 @@ namespace DisplayList {
> template<typename BackendType>
> class ImageBuffer : public ConcreteImageBuffer<BackendType> {
>     using BaseConcreteImageBuffer = ConcreteImageBuffer<BackendType>;
>+    using BaseConcreteImageBuffer::logicalSize;
>+    using BaseConcreteImageBuffer::baseTransform;
> 
> public:
>     static auto create(const FloatSize& size, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, const HostWindow* hostWindow)
>     {
>-        return BaseConcreteImageBuffer::template create<ImageBuffer>(size, resolutionScale, colorSpace, pixelFormat, hostWindow, size);
>+        return BaseConcreteImageBuffer::template create<ImageBuffer>(size, resolutionScale, colorSpace, pixelFormat, hostWindow);
>     }
> 
>     static auto create(const FloatSize& size, const GraphicsContext& context)
>     {
>-        return BaseConcreteImageBuffer::template create<ImageBuffer>(size, context, size);
>+        return BaseConcreteImageBuffer::template create<ImageBuffer>(size, context);
>     }
> 
>-    ImageBuffer(std::unique_ptr<BackendType>&& dataBackend, const FloatSize& size)
>-        : BaseConcreteImageBuffer(WTFMove(dataBackend))
>-        , m_drawingContext(size, initialDrawingContextCTM(size))
>+    ImageBuffer(const ImageBufferBackend::Parameters& parameters, std::unique_ptr<BackendType>&& backend)
>+        : BaseConcreteImageBuffer(parameters, WTFMove(backend))
>+        , m_drawingContext(logicalSize(), baseTransform())
>     {
>     }
> 
>-    ImageBuffer(const FloatSize& size, Recorder::Delegate* delegate = nullptr)
>-        : m_drawingContext(size, initialDrawingContextCTM(size), delegate)
>+    ImageBuffer(const ImageBufferBackend::Parameters& parameters, Recorder::Delegate* delegate = nullptr)
>+        : BaseConcreteImageBuffer(parameters)
>+        , m_drawingContext(logicalSize(), baseTransform(), delegate)
>     {
>     }
> 
>@@ -77,15 +80,6 @@ public:
> 
> protected:
>     DrawingContext m_drawingContext;
>-
>-private:
>-    static AffineTransform initialDrawingContextCTM(const FloatSize& logicalSize)
>-    {
>-        AffineTransform initialCTM;
>-        if (BackendType::isOriginAtUpperLeftCorner)
>-            initialCTM = initialCTM.scale(1, -1).translate(0, -logicalSize.height());
>-        return initialCTM;
>-    }
> };
> 
> } // DisplayList
>diff --git a/Source/WebCore/platform/graphics/win/ImageBufferDirect2DBackend.cpp b/Source/WebCore/platform/graphics/win/ImageBufferDirect2DBackend.cpp
>index 378aaf4c40c4e122acbe069432c7ad7ec209ed73..01d2e780285b11fec39b4cd26bf4cfff08073377 100644
>--- a/Source/WebCore/platform/graphics/win/ImageBufferDirect2DBackend.cpp
>+++ b/Source/WebCore/platform/graphics/win/ImageBufferDirect2DBackend.cpp
>@@ -171,7 +171,7 @@ static RefPtr<Image> createBitmapImageAfterScalingIfNeeded(ID2D1BitmapRenderTarg
> RefPtr<Image> ImageBufferDirect2DBackend::copyImage(BackingStoreCopy copyBehavior, PreserveResolution preserveResolution) const
> {
>     PlatformImagePtr image;
>-    if (m_resolutionScale == 1 || preserveResolution == PreserveResolution::Yes)
>+    if (resolutionScale() == 1 || preserveResolution == PreserveResolution::Yes)
>         image = copyNativeImage(copyBehavior)->platformImage();
>     else
>         image = copyNativeImage(DontCopyBackingStore)->platformImage();
>@@ -269,7 +269,7 @@ PlatformImagePtr ImageBufferDirect2DBackend::compatibleBitmap(ID2D1RenderTarget*
> void ImageBufferDirect2DBackend::draw(GraphicsContext& destContext, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
> {
>     FloatRect adjustedSrcRect = srcRect;
>-    adjustedSrcRect.scale(m_resolutionScale, m_resolutionScale);
>+    adjustedSrcRect.scale(resolutionScale());
> 
>     auto compatibleBitmap = compatibleBitmap(destContext.platformContext()->renderTarget());
> 
>@@ -283,7 +283,7 @@ void ImageBufferDirect2DBackend::draw(GraphicsContext& destContext, const FloatR
> void ImageBufferDirect2DBackend::drawPattern(GraphicsContext& destContext, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& options)
> {
>     FloatRect adjustedSrcRect = srcRect;
>-    adjustedSrcRect.scale(m_resolutionScale);
>+    adjustedSrcRect.scale(resolutionScale());
> 
>     if (auto image = copyImage(&destContext == &context() ? CopyBackingStore : DontCopyBackingStore))
>         image->drawPattern(destContext, destRect, adjustedSrcRect, patternTransform, phase, spacing, options);
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h b/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h
>index 4d5d0253baa36e5457e481645382437e319a8578..e613ad004c463ae33c3895d048312d3e42e577e8 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h
>@@ -49,12 +49,12 @@ public:
>         return BaseConcreteImageBuffer::template create<RemoteImageBuffer>(size, resolutionScale, colorSpace, pixelFormat, nullptr, remoteRenderingBackend, renderingResourceIdentifier);
>     }
> 
>-    RemoteImageBuffer(std::unique_ptr<BackendType>&& backend, RemoteRenderingBackend& remoteRenderingBackend, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>-        : BaseConcreteImageBuffer(WTFMove(backend), renderingResourceIdentifier)
>+    RemoteImageBuffer(const WebCore::ImageBufferBackend::Parameters& parameters, std::unique_ptr<BackendType>&& backend, RemoteRenderingBackend& remoteRenderingBackend, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>+        : BaseConcreteImageBuffer(parameters, WTFMove(backend), renderingResourceIdentifier)
>         , m_remoteRenderingBackend(remoteRenderingBackend)
>         , m_renderingResourceIdentifier(renderingResourceIdentifier)
>     {
>-        m_remoteRenderingBackend.imageBufferBackendWasCreated(m_backend->logicalSize(), m_backend->backendSize(), m_backend->resolutionScale(), m_backend->colorSpace(), m_backend->pixelFormat(), m_backend->createImageBufferBackendHandle(), renderingResourceIdentifier);
>+        m_remoteRenderingBackend.didCreateImageBufferBackend(m_backend->createImageBufferBackendHandle(), renderingResourceIdentifier);
>     }
> 
>     ~RemoteImageBuffer()
>@@ -65,17 +65,6 @@ public:
>             context().restore();
>     }
> 
>-    WebCore::DisplayList::ReplayResult submitDisplayList(const WebCore::DisplayList::DisplayList& displayList)
>-    {
>-        if (displayList.isEmpty())
>-            return { };
>-
>-        const auto& imageBuffers = m_remoteRenderingBackend.remoteResourceCache().imageBuffers();
>-        const auto& nativeImages = m_remoteRenderingBackend.remoteResourceCache().nativeImages();
>-        WebCore::DisplayList::Replayer replayer { BaseConcreteImageBuffer::context(), displayList, &imageBuffers, &nativeImages, this };
>-        return replayer.replay();
>-    }
>-
> private:
>     bool apply(WebCore::DisplayList::ItemHandle item, WebCore::GraphicsContext& context) override
>     {
>@@ -101,6 +90,17 @@ private:
>         return m_remoteRenderingBackend.applyMediaItem(item, context);
>     }
> 
>+    void submitDisplayList(const WebCore::DisplayList::DisplayList& displayList) override
>+    {
>+        if (displayList.isEmpty())
>+            return;
>+
>+        const auto& imageBuffers = m_remoteRenderingBackend.remoteResourceCache().imageBuffers();
>+        const auto& nativeImages = m_remoteRenderingBackend.remoteResourceCache().nativeImages();
>+        WebCore::DisplayList::Replayer replayer { BaseConcreteImageBuffer::context(), displayList, &imageBuffers, &nativeImages, this };
>+        replayer.replay();
>+    }
>+
>     RemoteRenderingBackend& m_remoteRenderingBackend;
>     WebCore::RenderingResourceIdentifier m_renderingResourceIdentifier;
> };
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>index 6ddeb027929e504f83b0a186c7eeab8e5b9d6872..22da998bf99022b6c51ce23819e9ecfdeed2a37d 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>@@ -99,9 +99,9 @@ bool RemoteRenderingBackend::applyMediaItem(DisplayList::ItemHandle item, Graphi
>     return true;
> }
> 
>-void RemoteRenderingBackend::imageBufferBackendWasCreated(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, ImageBufferBackendHandle handle, RenderingResourceIdentifier renderingResourceIdentifier)
>+void RemoteRenderingBackend::didCreateImageBufferBackend(ImageBufferBackendHandle handle, RenderingResourceIdentifier renderingResourceIdentifier)
> {
>-    send(Messages::RemoteRenderingBackendProxy::ImageBufferBackendWasCreated(logicalSize, backendSize, resolutionScale, colorSpace, pixelFormat, WTFMove(handle), renderingResourceIdentifier), m_renderingBackendIdentifier);
>+    send(Messages::RemoteRenderingBackendProxy::DidCreateImageBufferBackend(WTFMove(handle), renderingResourceIdentifier), m_renderingBackendIdentifier);
> }
> 
> void RemoteRenderingBackend::didFlush(DisplayList::FlushIdentifier flushIdentifier, RenderingResourceIdentifier renderingResourceIdentifier)
>@@ -148,10 +148,7 @@ void RemoteRenderingBackend::applyDisplayListsFromHandle(ImageBuffer& destinatio
>             return;
>         }
> 
>-        if (destination.isAccelerated())
>-            static_cast<AcceleratedRemoteImageBuffer&>(destination).submitDisplayList(*displayList);
>-        else
>-            static_cast<UnacceleratedRemoteImageBuffer&>(destination).submitDisplayList(*displayList);
>+        destination.submitDisplayList(*displayList);
> 
>         CheckedSize checkedOffset = offset;
>         checkedOffset += sizeToRead;
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>index 6406668fae05057e9df3264f575249489d705c78..5919e9564f663df39ffb3c15b15a3b8c3230f5ff 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>@@ -70,7 +70,7 @@ public:
>     bool applyMediaItem(WebCore::DisplayList::ItemHandle, WebCore::GraphicsContext&);
> 
>     // Messages to be sent.
>-    void imageBufferBackendWasCreated(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, WebCore::PixelFormat, ImageBufferBackendHandle, WebCore::RenderingResourceIdentifier);
>+    void didCreateImageBufferBackend(ImageBufferBackendHandle, WebCore::RenderingResourceIdentifier);
>     void didFlush(WebCore::DisplayList::FlushIdentifier, WebCore::RenderingResourceIdentifier);
> 
>     void setNextItemBufferToRead(WebCore::DisplayList::ItemBufferIdentifier);
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.cpp b/Source/WebKit/WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.cpp
>index 855c894966c587bb0e6aec5119de4b9445087d4b..4c9642c31d73971bd7af45bf5552ebf1fe3c4711 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.cpp
>+++ b/Source/WebKit/WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.cpp
>@@ -43,17 +43,17 @@ using namespace WebCore;
> 
> WTF_MAKE_ISO_ALLOCATED_IMPL(ImageBufferShareableBitmapBackend);
> 
>-std::unique_ptr<ImageBufferShareableBitmapBackend> ImageBufferShareableBitmapBackend::create(const FloatSize& size, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, const HostWindow*)
>+std::unique_ptr<ImageBufferShareableBitmapBackend> ImageBufferShareableBitmapBackend::create(const Parameters& parameters, const HostWindow*)
> {
>-    ASSERT(pixelFormat == PixelFormat::BGRA8);
>+    ASSERT(parameters.pixelFormat == PixelFormat::BGRA8);
> 
>-    IntSize backendSize = calculateBackendSize(size, resolutionScale);
>+    IntSize backendSize = calculateBackendSize(parameters.logicalSize, parameters.resolutionScale);
>     if (backendSize.isEmpty())
>         return nullptr;
> 
>     ShareableBitmap::Configuration configuration;
> #if PLATFORM(COCOA)
>-    configuration.colorSpace = { cachedCGColorSpace(colorSpace) };
>+    configuration.colorSpace = { cachedCGColorSpace(parameters.colorSpace) };
> #endif
>     auto bitmap = ShareableBitmap::createShareable(backendSize, configuration);
>     if (!bitmap)
>@@ -63,10 +63,10 @@ std::unique_ptr<ImageBufferShareableBitmapBackend> ImageBufferShareableBitmapBac
>     if (!context)
>         return nullptr;
> 
>-    return makeUnique<ImageBufferShareableBitmapBackend>(size, backendSize, resolutionScale, colorSpace, pixelFormat, WTFMove(bitmap), WTFMove(context));
>+    return makeUnique<ImageBufferShareableBitmapBackend>(parameters, WTFMove(bitmap), WTFMove(context));
> }
> 
>-std::unique_ptr<ImageBufferShareableBitmapBackend> ImageBufferShareableBitmapBackend::create(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, ImageBufferBackendHandle handle)
>+std::unique_ptr<ImageBufferShareableBitmapBackend> ImageBufferShareableBitmapBackend::create(const Parameters& parameters, ImageBufferBackendHandle handle)
> {
>     if (!WTF::holds_alternative<ShareableBitmap::Handle>(handle)) {
>         ASSERT_NOT_REACHED();
>@@ -81,11 +81,11 @@ std::unique_ptr<ImageBufferShareableBitmapBackend> ImageBufferShareableBitmapBac
>     if (!context)
>         return nullptr;
> 
>-    return makeUnique<ImageBufferShareableBitmapBackend>(logicalSize, backendSize, resolutionScale, colorSpace, pixelFormat, WTFMove(bitmap), WTFMove(context));
>+    return makeUnique<ImageBufferShareableBitmapBackend>(parameters, WTFMove(bitmap), WTFMove(context));
> }
> 
>-ImageBufferShareableBitmapBackend::ImageBufferShareableBitmapBackend(const FloatSize& logicalSize, const IntSize& physicalSize, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, RefPtr<ShareableBitmap>&& bitmap, std::unique_ptr<GraphicsContext>&& context)
>-    : PlatformImageBufferBackend(logicalSize, physicalSize, resolutionScale, colorSpace, pixelFormat)
>+ImageBufferShareableBitmapBackend::ImageBufferShareableBitmapBackend(const Parameters& parameters, RefPtr<ShareableBitmap>&& bitmap, std::unique_ptr<GraphicsContext>&& context)
>+    : PlatformImageBufferBackend(parameters)
>     , m_bitmap(WTFMove(bitmap))
>     , m_context(WTFMove(context))
> {
>@@ -98,6 +98,11 @@ ImageBufferBackendHandle ImageBufferShareableBitmapBackend::createImageBufferBac
>     return ImageBufferBackendHandle(WTFMove(handle));
> }
> 
>+IntSize ImageBufferShareableBitmapBackend::backendSize() const
>+{
>+    return m_bitmap->size();
>+}
>+
> RefPtr<NativeImage> ImageBufferShareableBitmapBackend::copyNativeImage(BackingStoreCopy) const
> {
> #if USE(CG)
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.h b/Source/WebKit/WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.h
>index 0c7f047f8835e4b8d63c15f41ec92102e4585399..55506a49d03e39e88e0361e49155f131d799010f 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.h
>@@ -43,14 +43,16 @@ class ImageBufferShareableBitmapBackend : public WebCore::PlatformImageBufferBac
>     WTF_MAKE_ISO_ALLOCATED(ImageBufferShareableBitmapBackend);
>     WTF_MAKE_NONCOPYABLE(ImageBufferShareableBitmapBackend);
> public:
>-    static std::unique_ptr<ImageBufferShareableBitmapBackend> create(const WebCore::FloatSize& logicalSize, const float resolutionScale, WebCore::ColorSpace, WebCore::PixelFormat, const WebCore::HostWindow*);
>-    static std::unique_ptr<ImageBufferShareableBitmapBackend> create(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& internalSize, float resolutionScale, WebCore::ColorSpace, WebCore::PixelFormat, ImageBufferBackendHandle);
>+    static std::unique_ptr<ImageBufferShareableBitmapBackend> create(const Parameters&, const WebCore::HostWindow*);
>+    static std::unique_ptr<ImageBufferShareableBitmapBackend> create(const Parameters&, ImageBufferBackendHandle);
> 
>-    ImageBufferShareableBitmapBackend(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& physicalSize, float resolutionScale, WebCore::ColorSpace, WebCore::PixelFormat, RefPtr<ShareableBitmap>&&, std::unique_ptr<WebCore::GraphicsContext>&&);
>+    ImageBufferShareableBitmapBackend(const Parameters&, RefPtr<ShareableBitmap>&&, std::unique_ptr<WebCore::GraphicsContext>&&);
> 
>     ImageBufferBackendHandle createImageBufferBackendHandle() const;
> 
>     WebCore::GraphicsContext& context() const override { return *m_context; }
>+    
>+    WebCore::IntSize backendSize() const override;
> 
>     RefPtr<WebCore::NativeImage> copyNativeImage(WebCore::BackingStoreCopy = WebCore::CopyBackingStore) const override;
>     RefPtr<WebCore::Image> copyImage(WebCore::BackingStoreCopy = WebCore::CopyBackingStore, WebCore::PreserveResolution = WebCore::PreserveResolution::No) const override;
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/PlatformRemoteImageBufferProxy.h b/Source/WebKit/WebProcess/GPU/graphics/PlatformRemoteImageBufferProxy.h
>index 05176783d5531bfe70f850bf2c149f78822d0e39..9aff088e37ca76a7f864ae7e42bbb7004f1f1523 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/PlatformRemoteImageBufferProxy.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/PlatformRemoteImageBufferProxy.h
>@@ -37,14 +37,4 @@ using AcceleratedRemoteImageBufferProxy = RemoteImageBufferProxy<AcceleratedImag
> 
> } // namespace WebKit
> 
>-SPECIALIZE_TYPE_TRAITS_BEGIN(WebKit::UnacceleratedRemoteImageBufferProxy)
>-    static bool isType(const WebCore::ImageBuffer& imageBuffer) { return imageBuffer.renderingResourceIdentifier() && !imageBuffer.isAccelerated(); }
>-SPECIALIZE_TYPE_TRAITS_END()
>-
>-#if HAVE(IOSURFACE)
>-SPECIALIZE_TYPE_TRAITS_BEGIN(WebKit::AcceleratedRemoteImageBufferProxy)
>-    static bool isType(const WebCore::ImageBuffer& imageBuffer) { return imageBuffer.renderingResourceIdentifier() && imageBuffer.isAccelerated(); }
>-SPECIALIZE_TYPE_TRAITS_END()
>-#endif
>-
> #endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>index 51bd5712958af12a2315d41ba3d2d6b9ed57f2ba..2282e13aabf53d642e844d42701e0665c1d54383 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>@@ -50,14 +50,16 @@ class RemoteImageBufferProxy : public WebCore::DisplayList::ImageBuffer<BackendT
>     using BaseDisplayListImageBuffer::m_backend;
>     using BaseDisplayListImageBuffer::m_drawingContext;
>     using BaseDisplayListImageBuffer::m_renderingResourceIdentifier;
>+    using BaseDisplayListImageBuffer::resolutionScale;
> 
> public:
>-    static RefPtr<RemoteImageBufferProxy> create(const WebCore::FloatSize& size, WebCore::RenderingMode renderingMode, float resolutionScale, WebCore::ColorSpace colorSpace, WebCore::PixelFormat pixelFormat, RemoteRenderingBackendProxy& remoteRenderingBackendProxy)
>+    static RefPtr<RemoteImageBufferProxy> create(const WebCore::FloatSize& size, float resolutionScale, WebCore::ColorSpace colorSpace, WebCore::PixelFormat pixelFormat, RemoteRenderingBackendProxy& remoteRenderingBackendProxy)
>     {
>         if (BackendType::calculateBackendSize(size, resolutionScale).isEmpty())
>             return nullptr;
> 
>-        return adoptRef(new RemoteImageBufferProxy(size, renderingMode, resolutionScale, colorSpace, pixelFormat, remoteRenderingBackendProxy));
>+        auto parameters = WebCore::ImageBufferBackend::Parameters { size, resolutionScale, colorSpace, pixelFormat };
>+        return adoptRef(new RemoteImageBufferProxy(parameters, remoteRenderingBackendProxy));
>     }
> 
>     ~RemoteImageBufferProxy()
>@@ -69,27 +71,6 @@ public:
>         m_remoteRenderingBackendProxy->releaseRemoteResource(m_renderingResourceIdentifier);
>     }
> 
>-    void clearBackend() { m_backend = nullptr; }
>-
>-    void createBackend(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace colorSpace, WebCore::PixelFormat pixelFormat, ImageBufferBackendHandle handle)
>-    {
>-        ASSERT(!m_backend);
>-        m_backend = BackendType::create(logicalSize, backendSize, resolutionScale, colorSpace, pixelFormat, WTFMove(handle));
>-    }
>-
>-    void didFlush(WebCore::DisplayList::FlushIdentifier flushIdentifier)
>-    {
>-        auto locker = holdLock(m_receivedFlushIdentifierLock);
>-        m_receivedFlushIdentifier = flushIdentifier;
>-        m_receivedFlushIdentifierChangedCondition.notifyAll();
>-    }
>-
>-    const WebCore::FloatSize& size() const { return m_size; }
>-    WebCore::RenderingMode renderingMode() const { return m_renderingMode; }
>-    float resolutionScale() const final { return m_resolutionScale; }
>-    WebCore::ColorSpace colorSpace() const { return m_colorSpace; }
>-    WebCore::PixelFormat pixelFormat() const { return m_pixelFormat; }
>-
>     ImageBufferBackendHandle createImageBufferBackendHandle()
>     {
>         ensureBackendCreated();
>@@ -112,15 +93,9 @@ public:
>     }
> 
> protected:
>-    friend class RemoteRenderingBackend;
>-    RemoteImageBufferProxy(const WebCore::FloatSize& size, WebCore::RenderingMode renderingMode, float resolutionScale, WebCore::ColorSpace colorSpace, WebCore::PixelFormat pixelFormat, RemoteRenderingBackendProxy& remoteRenderingBackendProxy)
>-        : BaseDisplayListImageBuffer(size, this)
>+    RemoteImageBufferProxy(const WebCore::ImageBufferBackend::Parameters& parameters, RemoteRenderingBackendProxy& remoteRenderingBackendProxy)
>+        : BaseDisplayListImageBuffer(parameters, this)
>         , m_remoteRenderingBackendProxy(makeWeakPtr(remoteRenderingBackendProxy))
>-        , m_size(size)
>-        , m_renderingMode(renderingMode)
>-        , m_resolutionScale(resolutionScale)
>-        , m_colorSpace(colorSpace)
>-        , m_pixelFormat(pixelFormat)
>     {
>         ASSERT(m_remoteRenderingBackendProxy);
>         m_remoteRenderingBackendProxy->remoteResourceCacheProxy().cacheImageBuffer(*this);
>@@ -131,6 +106,13 @@ protected:
> 
>     bool hasPendingFlush() const { return m_sentFlushIdentifier != m_receivedFlushIdentifier; }
> 
>+    void didFlush(WebCore::DisplayList::FlushIdentifier flushIdentifier) override
>+    {
>+        auto locker = holdLock(m_receivedFlushIdentifierLock);
>+        m_receivedFlushIdentifier = flushIdentifier;
>+        m_receivedFlushIdentifierChangedCondition.notifyAll();
>+    }
>+
>     void waitForDidFlushWithTimeout()
>     {
>         if (!m_remoteRenderingBackendProxy)
>@@ -145,7 +127,7 @@ protected:
>     BackendType* ensureBackendCreated() const override
>     {
>         if (!m_backend && m_remoteRenderingBackendProxy)
>-            m_remoteRenderingBackendProxy->waitForImageBufferBackendWasCreated();
>+            m_remoteRenderingBackendProxy->waitForDidCreateImageBufferBackend();
>         return m_backend.get();
>     }
> 
>@@ -169,8 +151,8 @@ protected:
>     void putImageData(WebCore::AlphaPremultiplication inputFormat, const WebCore::ImageData& imageData, const WebCore::IntRect& srcRect, const WebCore::IntPoint& destPoint = { }, WebCore::AlphaPremultiplication destFormat = WebCore::AlphaPremultiplication::Premultiplied) override
>     {
>         // The math inside ImageData::create() doesn't agree with the math inside ImageBufferBackend::putImageData() about how m_resolutionScale interacts with the data in the ImageBuffer.
>-        // This means that putImageData() is only called when m_resolutionScale == 1.
>-        ASSERT_IMPLIES(m_backend, m_backend->resolutionScale() == 1);
>+        // This means that putImageData() is only called when resolutionScale() == 1.
>+        ASSERT(resolutionScale() == 1);
>         m_drawingContext.recorder().putImageData(inputFormat, imageData, srcRect, destPoint, destFormat);
>     }
> 
>@@ -200,12 +182,12 @@ protected:
> 
>         m_sentFlushIdentifier = WebCore::DisplayList::FlushIdentifier::generate();
>         displayList.template append<WebCore::DisplayList::FlushContext>(m_sentFlushIdentifier);
>-        m_remoteRenderingBackendProxy->submitDisplayList(displayList, m_renderingResourceIdentifier);
>-        m_itemCountInCurrentDisplayList = 0;
>+        submitDisplayList(displayList);
>         displayList.clear();
>+        m_itemCountInCurrentDisplayList = 0;
>     }
> 
>-    void submitDisplayList(const WebCore::DisplayList::DisplayList& displayList)
>+    void submitDisplayList(const WebCore::DisplayList::DisplayList& displayList) override
>     {
>         if (!m_remoteRenderingBackendProxy || displayList.isEmpty())
>             return;
>@@ -353,11 +335,6 @@ protected:
>     WebCore::DisplayList::FlushIdentifier m_receivedFlushIdentifier;
>     WeakPtr<RemoteRenderingBackendProxy> m_remoteRenderingBackendProxy;
>     size_t m_itemCountInCurrentDisplayList { 0 };
>-    WebCore::FloatSize m_size;
>-    WebCore::RenderingMode m_renderingMode;
>-    float m_resolutionScale;
>-    WebCore::ColorSpace m_colorSpace;
>-    WebCore::PixelFormat m_pixelFormat;
> };
> 
> template<typename BackendType>
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>index c07b23fb2b0e58e0e1dff5a14ee0a85d9a5b645d..3d6ffc48012f32c976f7f992148005035c0068d9 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>@@ -70,24 +70,15 @@ void RemoteRenderingBackendProxy::connectToGPUProcess()
>     send(Messages::GPUConnectionToWebProcess::CreateRenderingBackend(m_renderingBackendIdentifier), 0);
> }
> 
>-template<typename T>
>-static void recreateImageBuffer(RemoteRenderingBackendProxy& proxy, T& imageBuffer, RenderingResourceIdentifier resourceIdentifier, RenderingBackendIdentifier renderingBackendIdentifier)
>-{
>-    imageBuffer.clearBackend();
>-    proxy.send(Messages::RemoteRenderingBackend::CreateImageBuffer(imageBuffer.size(), imageBuffer.renderingMode(), imageBuffer.resolutionScale(), imageBuffer.colorSpace(), imageBuffer.pixelFormat(), resourceIdentifier), renderingBackendIdentifier);
>-}
>-
> void RemoteRenderingBackendProxy::reestablishGPUProcessConnection()
> {
>     connectToGPUProcess();
> 
>-    for (auto& pair : m_remoteResourceCacheProxy.imageBuffers()) {
>-        if (auto& baseImageBuffer = pair.value) {
>-            if (is<AcceleratedRemoteImageBufferProxy>(*baseImageBuffer))
>-                recreateImageBuffer(*this, downcast<AcceleratedRemoteImageBufferProxy>(*baseImageBuffer), pair.key, m_renderingBackendIdentifier);
>-            else
>-                recreateImageBuffer(*this, downcast<UnacceleratedRemoteImageBufferProxy>(*baseImageBuffer), pair.key, m_renderingBackendIdentifier);
>-        }
>+    for (auto& imageBuffer : m_remoteResourceCacheProxy.imageBuffers().values()) {
>+        if (!imageBuffer)
>+            continue;
>+        send(Messages::RemoteRenderingBackend::CreateImageBuffer(imageBuffer->logicalSize(), imageBuffer->renderingMode(), imageBuffer->resolutionScale(), imageBuffer->colorSpace(), imageBuffer->pixelFormat(), imageBuffer->renderingResourceIdentifier()), m_renderingBackendIdentifier);
>+        imageBuffer->clearBackend();
>     }
> }
> 
>@@ -112,10 +103,10 @@ uint64_t RemoteRenderingBackendProxy::messageSenderDestinationID() const
>     return m_renderingBackendIdentifier.toUInt64();
> }
> 
>-bool RemoteRenderingBackendProxy::waitForImageBufferBackendWasCreated()
>+bool RemoteRenderingBackendProxy::waitForDidCreateImageBufferBackend()
> {
>     Ref<IPC::Connection> connection = WebProcess::singleton().ensureGPUProcessConnection().connection();
>-    return connection->waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::ImageBufferBackendWasCreated>(m_renderingBackendIdentifier, 1_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
>+    return connection->waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::DidCreateImageBufferBackend>(m_renderingBackendIdentifier, 1_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
> }
> 
> bool RemoteRenderingBackendProxy::waitForDidFlush()
>@@ -129,10 +120,10 @@ RefPtr<ImageBuffer> RemoteRenderingBackendProxy::createImageBuffer(const FloatSi
>     RefPtr<ImageBuffer> imageBuffer;
> 
>     if (renderingMode == RenderingMode::Accelerated)
>-        imageBuffer = AcceleratedRemoteImageBufferProxy::create(size, renderingMode, resolutionScale, colorSpace, pixelFormat, *this);
>+        imageBuffer = AcceleratedRemoteImageBufferProxy::create(size, resolutionScale, colorSpace, pixelFormat, *this);
> 
>     if (!imageBuffer)
>-        imageBuffer = UnacceleratedRemoteImageBufferProxy::create(size, renderingMode, resolutionScale, colorSpace, pixelFormat, *this);
>+        imageBuffer = UnacceleratedRemoteImageBufferProxy::create(size, resolutionScale, colorSpace, pixelFormat, *this);
> 
>     if (imageBuffer) {
>         send(Messages::RemoteRenderingBackend::CreateImageBuffer(size, renderingMode, resolutionScale, colorSpace, pixelFormat, imageBuffer->renderingResourceIdentifier()), m_renderingBackendIdentifier);
>@@ -183,28 +174,22 @@ void RemoteRenderingBackendProxy::releaseRemoteResource(RenderingResourceIdentif
>     send(Messages::RemoteRenderingBackend::ReleaseRemoteResource(renderingResourceIdentifier), m_renderingBackendIdentifier);
> }
> 
>-void RemoteRenderingBackendProxy::imageBufferBackendWasCreated(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, ImageBufferBackendHandle handle, RenderingResourceIdentifier renderingResourceIdentifier)
>+void RemoteRenderingBackendProxy::didCreateImageBufferBackend(ImageBufferBackendHandle handle, RenderingResourceIdentifier renderingResourceIdentifier)
> {
>     auto imageBuffer = m_remoteResourceCacheProxy.cachedImageBuffer(renderingResourceIdentifier);
>     if (!imageBuffer)
>         return;
>-    
>-    if (imageBuffer->isAccelerated())
>-        downcast<AcceleratedRemoteImageBufferProxy>(*imageBuffer).createBackend(logicalSize, backendSize, resolutionScale, colorSpace, pixelFormat, WTFMove(handle));
>+
>+    if (imageBuffer->renderingMode() == RenderingMode::Accelerated)
>+        imageBuffer->setBackend(AcceleratedImageBufferShareableBackend::create(imageBuffer->parameters(), WTFMove(handle)));
>     else
>-        downcast<UnacceleratedRemoteImageBufferProxy>(*imageBuffer).createBackend(logicalSize, backendSize, resolutionScale, colorSpace, pixelFormat, WTFMove(handle));
>+        imageBuffer->setBackend(UnacceleratedImageBufferShareableBackend::create(imageBuffer->parameters(), WTFMove(handle)));
> }
> 
> void RemoteRenderingBackendProxy::didFlush(DisplayList::FlushIdentifier flushIdentifier, RenderingResourceIdentifier renderingResourceIdentifier)
> {
>-    auto imageBuffer = m_remoteResourceCacheProxy.cachedImageBuffer(renderingResourceIdentifier);
>-    if (!imageBuffer)
>-        return;
>-
>-    if (imageBuffer->isAccelerated())
>-        downcast<AcceleratedRemoteImageBufferProxy>(*imageBuffer).didFlush(flushIdentifier);
>-    else
>-        downcast<UnacceleratedRemoteImageBufferProxy>(*imageBuffer).didFlush(flushIdentifier);
>+    if (auto imageBuffer = m_remoteResourceCacheProxy.cachedImageBuffer(renderingResourceIdentifier))
>+        imageBuffer->didFlush(flushIdentifier);
> }
> 
> void RemoteRenderingBackendProxy::updateReusableHandles()
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>index 95f8d2b412fb91df77c68f136b00786f024d7e26..f805fc1eff9ca5145359ca292b52ddfeef8da81e 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>@@ -81,7 +81,7 @@ public:
>     void cacheNativeImage(WebCore::NativeImage&);
>     void releaseRemoteResource(WebCore::RenderingResourceIdentifier);
> 
>-    bool waitForImageBufferBackendWasCreated();
>+    bool waitForDidCreateImageBufferBackend();
>     bool waitForDidFlush();
> 
> private:
>@@ -95,7 +95,7 @@ private:
>     void updateReusableHandles();
> 
>     // Messages to be received.
>-    void imageBufferBackendWasCreated(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, WebCore::PixelFormat, ImageBufferBackendHandle, WebCore::RenderingResourceIdentifier);
>+    void didCreateImageBufferBackend(ImageBufferBackendHandle, WebCore::RenderingResourceIdentifier);
>     void didFlush(WebCore::DisplayList::FlushIdentifier, WebCore::RenderingResourceIdentifier);
> 
>     RemoteResourceCacheProxy m_remoteResourceCacheProxy { *this };
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in
>index 920de3f777540164051ff51cd21b50559854f844..3a532d5e4ff616bdb07ede7a9a83e93137e73bf1 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in
>@@ -23,7 +23,7 @@
> #if ENABLE(GPU_PROCESS)
> 
> messages -> RemoteRenderingBackendProxy NotRefCounted {
>-    ImageBufferBackendWasCreated(WebCore::FloatSize logicalSize, WebCore::IntSize backendSize, float resolutionScale, WebCore::ColorSpace colorSpace, enum:uint8_t WebCore::PixelFormat pixelFormat, WebKit::ImageBufferBackendHandle handle, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>+    DidCreateImageBufferBackend(WebKit::ImageBufferBackendHandle handle, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>     DidFlush(WebCore::DisplayList::FlushIdentifier flushIdentifier, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
> }
> 
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/cocoa/ImageBufferShareableIOSurfaceBackend.cpp b/Source/WebKit/WebProcess/GPU/graphics/cocoa/ImageBufferShareableIOSurfaceBackend.cpp
>index 51627c5edd891b94f36391c0ab4c2808c680beff..e412e7f63f4087f217724682e9358fb8588fc5c3 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/cocoa/ImageBufferShareableIOSurfaceBackend.cpp
>+++ b/Source/WebKit/WebProcess/GPU/graphics/cocoa/ImageBufferShareableIOSurfaceBackend.cpp
>@@ -37,13 +37,13 @@ using namespace WebCore;
> 
> WTF_MAKE_ISO_ALLOCATED_IMPL(ImageBufferShareableIOSurfaceBackend);
> 
>-std::unique_ptr<ImageBufferShareableIOSurfaceBackend> ImageBufferShareableIOSurfaceBackend::create(const FloatSize& size, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, const HostWindow*)
>+std::unique_ptr<ImageBufferShareableIOSurfaceBackend> ImageBufferShareableIOSurfaceBackend::create(const Parameters& parameters, const HostWindow*)
> {
>-    IntSize backendSize = calculateBackendSize(size, resolutionScale);
>+    IntSize backendSize = calculateBackendSize(parameters.logicalSize, parameters.resolutionScale);
>     if (backendSize.isEmpty())
>         return nullptr;
> 
>-    auto surface = IOSurface::create(backendSize, backendSize, cachedCGColorSpace(colorSpace), IOSurface::formatForPixelFormat(pixelFormat));
>+    auto surface = IOSurface::create(backendSize, backendSize, cachedCGColorSpace(parameters.colorSpace), IOSurface::formatForPixelFormat(parameters.pixelFormat));
>     if (!surface)
>         return nullptr;
> 
>@@ -53,21 +53,21 @@ std::unique_ptr<ImageBufferShareableIOSurfaceBackend> ImageBufferShareableIOSurf
> 
>     CGContextClearRect(cgContext.get(), FloatRect(FloatPoint::zero(), backendSize));
> 
>-    return makeUnique<ImageBufferShareableIOSurfaceBackend>(size, backendSize, resolutionScale, colorSpace, pixelFormat, WTFMove(surface));
>+    return makeUnique<ImageBufferShareableIOSurfaceBackend>(parameters, WTFMove(surface));
> }
> 
>-std::unique_ptr<ImageBufferShareableIOSurfaceBackend> ImageBufferShareableIOSurfaceBackend::create(const FloatSize& logicalSize, const IntSize& internalSize, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat, ImageBufferBackendHandle handle)
>+std::unique_ptr<ImageBufferShareableIOSurfaceBackend> ImageBufferShareableIOSurfaceBackend::create(const Parameters& parameters, ImageBufferBackendHandle handle)
> {
>     if (!WTF::holds_alternative<MachSendRight>(handle)) {
>         ASSERT_NOT_REACHED();
>         return nullptr;
>     }
> 
>-    auto surface = IOSurface::createFromSendRight(WTFMove(WTF::get<MachSendRight>(handle)), cachedCGColorSpace(colorSpace));
>+    auto surface = IOSurface::createFromSendRight(WTFMove(WTF::get<MachSendRight>(handle)), cachedCGColorSpace(parameters.colorSpace));
>     if (!surface)
>         return nullptr;
> 
>-    return makeUnique<ImageBufferShareableIOSurfaceBackend>(logicalSize, internalSize, resolutionScale, colorSpace, pixelFormat, WTFMove(surface));
>+    return makeUnique<ImageBufferShareableIOSurfaceBackend>(parameters, WTFMove(surface));
> }
> 
> ImageBufferBackendHandle ImageBufferShareableIOSurfaceBackend::createImageBufferBackendHandle() const
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/cocoa/ImageBufferShareableIOSurfaceBackend.h b/Source/WebKit/WebProcess/GPU/graphics/cocoa/ImageBufferShareableIOSurfaceBackend.h
>index ed51624eb0aa1050e13bfa17ea34f0fe3c1fff6d..3189215f33acab7901facb505f2a5c1399a0de70 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/cocoa/ImageBufferShareableIOSurfaceBackend.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/cocoa/ImageBufferShareableIOSurfaceBackend.h
>@@ -39,8 +39,8 @@ class ImageBufferShareableIOSurfaceBackend : public WebCore::ImageBufferIOSurfac
>     WTF_MAKE_ISO_ALLOCATED(ImageBufferShareableIOSurfaceBackend);
>     WTF_MAKE_NONCOPYABLE(ImageBufferShareableIOSurfaceBackend);
> public:
>-    static std::unique_ptr<ImageBufferShareableIOSurfaceBackend> create(const WebCore::FloatSize& logicalSize, const float resolutionScale, WebCore::ColorSpace, WebCore::PixelFormat, const WebCore::HostWindow*);
>-    static std::unique_ptr<ImageBufferShareableIOSurfaceBackend> create(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& internalSize, float resolutionScale, WebCore::ColorSpace, WebCore::PixelFormat, ImageBufferBackendHandle);
>+    static std::unique_ptr<ImageBufferShareableIOSurfaceBackend> create(const Parameters&, const WebCore::HostWindow*);
>+    static std::unique_ptr<ImageBufferShareableIOSurfaceBackend> create(const Parameters&, ImageBufferBackendHandle);
> 
>     using WebCore::ImageBufferIOSurfaceBackend::ImageBufferIOSurfaceBackend;
>

Actions: View | Formatted Diff | Diff

Attachments on bug 219007: 414293 | 414861 | 414879 | 414880 | 414885 | 414912 | 414935 | 415043 | 415045 | 415046 | 415050 | 415395 | 415434 | 415445