Attachment 412811 Details for Bug 218406 – Part 1 WIP

[patch] Part 1 WIP

bug-218406-20201030165412.patch (text/plain), 367.81 KB, created by Wenson Hsieh on 2020-10-30 16:54:14 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Wenson Hsieh

Created: 2020-10-30 16:54:14 PDT

Size: 367.81 KB

patch

obsolete

>Subversion Revision: 269208
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 2682b6a6b686f686c52f0c3706173ea8f0b13dce..540619113a86015d9cccca401d2765412bb47fd9 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,543 @@
>+2020-10-30 Wenson Hsieh <wenson_hsieh@apple.com>
>+
>+ [Concurrent display lists] Encode display list items directly into shared memory
>+ https://bugs.webkit.org/show_bug.cgi?id=218406
>+
>+ Reviewed by NOBODY (OOPS!).
>+
>+ WIP only.
>+
>+ * Sources.txt:
>+ * WebCore.xcodeproj/project.pbxproj:
>+ * html/canvas/CanvasRenderingContext2DBase.cpp:
>+ (WebCore::CanvasRenderingContext2DBase::paintRenderingResultsToCanvas):
>+ * platform/graphics/GraphicsContext.h:
>+ * platform/graphics/displaylists/DisplayList.cpp:
>+ (WebCore::DisplayList::DisplayList::DisplayList):
>+ (WebCore::DisplayList::DisplayList::operator=):
>+ (WebCore::DisplayList::DisplayList::clear):
>+ (WebCore::DisplayList::DisplayList::shouldDumpForFlags):
>+ (WebCore::DisplayList::dumpDrawingItemExtent):
>+ (WebCore::DisplayList::DisplayList::asText const):
>+ (WebCore::DisplayList::DisplayList::dump const):
>+ (WebCore::DisplayList::DisplayList::sizeInBytes const):
>+ (WebCore::DisplayList::DisplayList::isEmpty const):
>+ (WebCore::DisplayList::DisplayList::itemBuffer):
>+ (WebCore::DisplayList::DisplayList::setItemBufferClient):
>+ (WebCore::DisplayList::DisplayList::forEachItemBuffer const):
>+ (WebCore::DisplayList::DisplayList::map const):
>+ (WebCore::DisplayList::DisplayList::setTracksDrawingItemExtents):
>+ (WebCore::DisplayList::DisplayList::append):
>+ * platform/graphics/displaylists/DisplayList.h:
>+ (WebCore::DisplayList::DisplayList::tracksDrawingItemExtents const):
>+ (WebCore::DisplayList::DisplayList::itemBufferIfExists const):
>+ (WebCore::DisplayList::DisplayList::addDrawingItemExtent):
>+ (WebCore::DisplayList::DisplayList::append):
>+ (WebCore::DisplayList::Item::type const): Deleted.
>+ (WebCore::DisplayList::Item::isDrawingItem const): Deleted.
>+ (WebCore::DisplayList::DisplayList::list const): Deleted.
>+ (WebCore::DisplayList::DisplayList::itemAt): Deleted.
>+ (WebCore::DisplayList::DisplayList::itemCount const): Deleted.
>+ (WebCore::DisplayList::DisplayList::appendItem): Deleted.
>+ (WebCore::DisplayList::DisplayList::list): Deleted.
>+ (WebCore::DisplayList::DisplayList::encode const): Deleted.
>+ (WebCore::DisplayList::DisplayList::decode): Deleted.
>+ * platform/graphics/displaylists/DisplayListDrawingContext.cpp:
>+ (WebCore::DisplayList::DrawingContext::replayDisplayList):
>+ * platform/graphics/displaylists/DisplayListDrawingContext.h:
>+ (WebCore::DisplayList::DrawingContext::takeDisplayList):
>+ * platform/graphics/displaylists/DisplayListImageBuffer.h:
>+ * platform/graphics/displaylists/DisplayListItemBuffer.cpp: Added.
>+ (WebCore::DisplayList::ItemHandle::apply):
>+ (WebCore::DisplayList::ItemHandle::destroy):
>+ (WebCore::DisplayList::ItemHandle::isDrawingItem const):
>+ (WebCore::DisplayList::ItemBuffer::ItemBuffer):
>+ (WebCore::DisplayList::ItemBuffer::~ItemBuffer):
>+ (WebCore::DisplayList::m_allocatedBuffers):
>+ (WebCore::DisplayList::m_readOnlyBuffers):
>+ (WebCore::DisplayList::m_writableBuffer):
>+ (WebCore::DisplayList::m_writableSizeInBytes):
>+ (WebCore::DisplayList::ItemBuffer::operator=):
>+ (WebCore::DisplayList::ItemBuffer::createItemBuffer):
>+ (WebCore::DisplayList::ItemBuffer::forEachItemBuffer const):
>+ * platform/graphics/displaylists/DisplayListItemBuffer.h: Added.
>+ (WebCore::DisplayList::ItemBufferHandle::operator bool const):
>+ (WebCore::DisplayList::ItemBufferHandle::operator! const):
>+ (WebCore::DisplayList::ItemBufferHandle::encode const):
>+ (WebCore::DisplayList::ItemBufferHandle::decode):
>+ (WebCore::DisplayList::ItemHandle::type const):
>+ (WebCore::DisplayList::ItemHandle::size const):
>+ (WebCore::DisplayList::ItemHandle::get const):
>+ (WebCore::DisplayList::ItemHandle::is const):
>+ (WebCore::DisplayList::ItemBufferWritingClient::~ItemBufferWritingClient):
>+ (WebCore::DisplayList::ItemBufferReadingClient::~ItemBufferReadingClient):
>+ (WebCore::DisplayList::ItemBuffer::sizeInBytes const):
>+ (WebCore::DisplayList::ItemBuffer::isEmpty const):
>+ (WebCore::DisplayList::ItemBuffer::append):
>+ (WebCore::DisplayList::ItemBuffer::clear):
>+ (WebCore::DisplayList::ItemBuffer::setClient):
>+ (WebCore::DisplayList::ItemBuffer::readOnlyBuffers const):
>+ * platform/graphics/displaylists/DisplayListItemType.cpp: Added.
>+ (WebCore::DisplayList::sizeOfItemInBytes):
>+ (WebCore::DisplayList::isDrawingItem):
>+ (WebCore::DisplayList::isInlineItem):
>+ * platform/graphics/displaylists/DisplayListItemType.h: Added.
>+ * platform/graphics/displaylists/DisplayListItems.cpp:
>+ (WebCore::DisplayList::SetInlineFillGradient::SetInlineFillGradient):
>+ (WebCore::DisplayList::SetState::SetState):
>+ (WebCore::DisplayList::operator<<):
>+ (WebCore::DisplayList::DrawGlyphs::DrawGlyphs):
>+ (WebCore::DisplayList::DrawGlyphs::generateGlyphBuffer const):
>+ (WebCore::DisplayList::DrawGlyphs::apply const):
>+ (WebCore::DisplayList::DrawNativeImage::DrawNativeImage):
>+ (WebCore::DisplayList::DrawPattern::DrawPattern):
>+ (WebCore::DisplayList::DrawLinesForText::DrawLinesForText):
>+ (WebCore::DisplayList::DrawFocusRingRects::DrawFocusRingRects):
>+ (WebCore::DisplayList::FillRectWithGradient::FillRectWithGradient):
>+ (WebCore::DisplayList::PutImageData::PutImageData):
>+ (WebCore::DisplayList::PaintFrameForMedia::PaintFrameForMedia):
>+ (WebCore::DisplayList::Item::Item): Deleted.
>+ (WebCore::DisplayList::Item::sizeInBytes): Deleted.
>+ (WebCore::DisplayList::DrawingItem::DrawingItem): Deleted.
>+ (WebCore::DisplayList::Save::Save): Deleted.
>+ (WebCore::DisplayList::Restore::Restore): Deleted.
>+ (WebCore::DisplayList::Translate::Translate): Deleted.
>+ (WebCore::DisplayList::Rotate::Rotate): Deleted.
>+ (WebCore::DisplayList::Scale::Scale): Deleted.
>+ (WebCore::DisplayList::SetCTM::SetCTM): Deleted.
>+ (WebCore::DisplayList::ConcatenateCTM::ConcatenateCTM): Deleted.
>+ (WebCore::DisplayList::SetInlineFillGradient::create): Deleted.
>+ (WebCore::DisplayList::SetInlineFillColor::create): Deleted.
>+ (WebCore::DisplayList::SetInlineStrokeColor::create): Deleted.
>+ (WebCore::DisplayList::SetStrokeThickness::create): Deleted.
>+ (WebCore::DisplayList::SetLineCap::SetLineCap): Deleted.
>+ (WebCore::DisplayList::SetLineDash::SetLineDash): Deleted.
>+ (WebCore::DisplayList::SetLineJoin::SetLineJoin): Deleted.
>+ (WebCore::DisplayList::SetMiterLimit::SetMiterLimit): Deleted.
>+ (WebCore::DisplayList::ClearShadow::ClearShadow): Deleted.
>+ (WebCore::DisplayList::Clip::Clip): Deleted.
>+ (WebCore::DisplayList::ClipOut::ClipOut): Deleted.
>+ (WebCore::DisplayList::ClipOutToPath::ClipOutToPath): Deleted.
>+ (WebCore::DisplayList::ClipPath::ClipPath): Deleted.
>+ (WebCore::DisplayList::ClipToDrawingCommands::ClipToDrawingCommands): Deleted.
>+ (WebCore::DisplayList::DrawGlyphs::localBounds const): Deleted.
>+ (WebCore::DisplayList::DrawImage::DrawImage): Deleted.
>+ (WebCore::DisplayList::DrawTiledImage::DrawTiledImage): Deleted.
>+ (WebCore::DisplayList::DrawTiledScaledImage::DrawTiledScaledImage): Deleted.
>+ (WebCore::DisplayList::DrawImageBuffer::DrawImageBuffer): Deleted.
>+ (WebCore::DisplayList::DrawRect::DrawRect): Deleted.
>+ (WebCore::DisplayList::DrawLine::DrawLine): Deleted.
>+ (WebCore::DisplayList::DrawDotsForDocumentMarker::DrawDotsForDocumentMarker): Deleted.
>+ (WebCore::DisplayList::DrawEllipse::DrawEllipse): Deleted.
>+ (WebCore::DisplayList::DrawPath::DrawPath): Deleted.
>+ (WebCore::DisplayList::DrawFocusRingPath::DrawFocusRingPath): Deleted.
>+ (WebCore::DisplayList::FillRect::FillRect): Deleted.
>+ (WebCore::DisplayList::FillRectWithColor::FillRectWithColor): Deleted.
>+ (WebCore::DisplayList::FillCompositedRect::FillCompositedRect): Deleted.
>+ (WebCore::DisplayList::FillRoundedRect::FillRoundedRect): Deleted.
>+ (WebCore::DisplayList::FillRectWithRoundedHole::FillRectWithRoundedHole): Deleted.
>+ (WebCore::DisplayList::FillInlinePath::FillInlinePath): Deleted.
>+ (WebCore::DisplayList::FillPath::FillPath): Deleted.
>+ (WebCore::DisplayList::FillEllipse::FillEllipse): Deleted.
>+ (WebCore::DisplayList::PaintFrameForMedia::create): Deleted.
>+ (WebCore::DisplayList::StrokeRect::StrokeRect): Deleted.
>+ (WebCore::DisplayList::StrokeEllipse::StrokeEllipse): Deleted.
>+ (WebCore::DisplayList::StrokeInlinePath::StrokeInlinePath): Deleted.
>+ (WebCore::DisplayList::StrokePath::StrokePath): Deleted.
>+ (WebCore::DisplayList::ClearRect::ClearRect): Deleted.
>+ (WebCore::DisplayList::BeginTransparencyLayer::BeginTransparencyLayer): Deleted.
>+ (WebCore::DisplayList::EndTransparencyLayer::EndTransparencyLayer): Deleted.
>+ (WebCore::DisplayList::ApplyStrokePattern::ApplyStrokePattern): Deleted.
>+ (WebCore::DisplayList::ApplyFillPattern::ApplyFillPattern): Deleted.
>+ (WebCore::DisplayList::ApplyDeviceScaleFactor::ApplyDeviceScaleFactor): Deleted.
>+ * platform/graphics/displaylists/DisplayListItems.h:
>+ (WebCore::DisplayList::Save::localBounds const):
>+ (WebCore::DisplayList::Save::globalBounds const):
>+ (WebCore::DisplayList::Restore::localBounds const):
>+ (WebCore::DisplayList::Restore::globalBounds const):
>+ (WebCore::DisplayList::Translate::Translate):
>+ (WebCore::DisplayList::Translate::localBounds const):
>+ (WebCore::DisplayList::Translate::globalBounds const):
>+ (WebCore::DisplayList::Rotate::Rotate):
>+ (WebCore::DisplayList::Rotate::localBounds const):
>+ (WebCore::DisplayList::Rotate::globalBounds const):
>+ (WebCore::DisplayList::Scale::Scale):
>+ (WebCore::DisplayList::Scale::localBounds const):
>+ (WebCore::DisplayList::Scale::globalBounds const):
>+ (WebCore::DisplayList::SetCTM::SetCTM):
>+ (WebCore::DisplayList::SetCTM::localBounds const):
>+ (WebCore::DisplayList::SetCTM::globalBounds const):
>+ (WebCore::DisplayList::ConcatenateCTM::ConcatenateCTM):
>+ (WebCore::DisplayList::ConcatenateCTM::localBounds const):
>+ (WebCore::DisplayList::ConcatenateCTM::globalBounds const):
>+ (WebCore::DisplayList::SetInlineFillGradient::localBounds const):
>+ (WebCore::DisplayList::SetInlineFillGradient::globalBounds const):
>+ (WebCore::DisplayList::SetInlineFillColor::SetInlineFillColor):
>+ (WebCore::DisplayList::SetInlineFillColor::color const):
>+ (WebCore::DisplayList::SetInlineFillColor::localBounds const):
>+ (WebCore::DisplayList::SetInlineFillColor::globalBounds const):
>+ (WebCore::DisplayList::SetInlineStrokeColor::SetInlineStrokeColor):
>+ (WebCore::DisplayList::SetInlineStrokeColor::color const):
>+ (WebCore::DisplayList::SetInlineStrokeColor::localBounds const):
>+ (WebCore::DisplayList::SetInlineStrokeColor::globalBounds const):
>+ (WebCore::DisplayList::SetStrokeThickness::SetStrokeThickness):
>+ (WebCore::DisplayList::SetStrokeThickness::thickness const):
>+ (WebCore::DisplayList::SetStrokeThickness::localBounds const):
>+ (WebCore::DisplayList::SetStrokeThickness::globalBounds const):
>+ (WebCore::DisplayList::SetState::localBounds const):
>+ (WebCore::DisplayList::SetState::globalBounds const):
>+ (WebCore::DisplayList::SetState::decode):
>+ (WebCore::DisplayList::SetLineCap::SetLineCap):
>+ (WebCore::DisplayList::SetLineCap::localBounds const):
>+ (WebCore::DisplayList::SetLineCap::globalBounds const):
>+ (WebCore::DisplayList::SetLineDash::SetLineDash):
>+ (WebCore::DisplayList::SetLineDash::localBounds const):
>+ (WebCore::DisplayList::SetLineDash::globalBounds const):
>+ (WebCore::DisplayList::SetLineDash::decode):
>+ (WebCore::DisplayList::SetLineJoin::SetLineJoin):
>+ (WebCore::DisplayList::SetLineJoin::localBounds const):
>+ (WebCore::DisplayList::SetLineJoin::globalBounds const):
>+ (WebCore::DisplayList::SetMiterLimit::SetMiterLimit):
>+ (WebCore::DisplayList::SetMiterLimit::localBounds const):
>+ (WebCore::DisplayList::SetMiterLimit::globalBounds const):
>+ (WebCore::DisplayList::ClearShadow::localBounds const):
>+ (WebCore::DisplayList::ClearShadow::globalBounds const):
>+ (WebCore::DisplayList::Clip::Clip):
>+ (WebCore::DisplayList::Clip::rect const):
>+ (WebCore::DisplayList::Clip::localBounds const):
>+ (WebCore::DisplayList::Clip::globalBounds const):
>+ (WebCore::DisplayList::ClipOut::ClipOut):
>+ (WebCore::DisplayList::ClipOut::rect const):
>+ (WebCore::DisplayList::ClipOut::localBounds const):
>+ (WebCore::DisplayList::ClipOut::globalBounds const):
>+ (WebCore::DisplayList::ClipOutToPath::ClipOutToPath):
>+ (WebCore::DisplayList::ClipOutToPath::localBounds const):
>+ (WebCore::DisplayList::ClipOutToPath::globalBounds const):
>+ (WebCore::DisplayList::ClipOutToPath::decode):
>+ (WebCore::DisplayList::ClipPath::ClipPath):
>+ (WebCore::DisplayList::ClipPath::localBounds const):
>+ (WebCore::DisplayList::ClipPath::globalBounds const):
>+ (WebCore::DisplayList::ClipPath::decode):
>+ (WebCore::DisplayList::ClipToDrawingCommands::ClipToDrawingCommands):
>+ (WebCore::DisplayList::ClipToDrawingCommands::localBounds const):
>+ (WebCore::DisplayList::ClipToDrawingCommands::globalBounds const):
>+ (WebCore::DisplayList::ClipToDrawingCommands::encode const):
>+ (WebCore::DisplayList::ClipToDrawingCommands::decode):
>+ (WebCore::DisplayList::DrawGlyphs::globalBounds const):
>+ (WebCore::DisplayList::DrawGlyphs::localBounds const):
>+ (WebCore::DisplayList::DrawGlyphs::encode const):
>+ (WebCore::DisplayList::DrawGlyphs::decode):
>+ (WebCore::DisplayList::DrawImage::DrawImage):
>+ (WebCore::DisplayList::DrawImage::globalBounds const):
>+ (WebCore::DisplayList::DrawImage::localBounds const):
>+ (WebCore::DisplayList::DrawImage::decode):
>+ (WebCore::DisplayList::DrawTiledImage::DrawTiledImage):
>+ (WebCore::DisplayList::DrawTiledImage::globalBounds const):
>+ (WebCore::DisplayList::DrawTiledImage::localBounds const):
>+ (WebCore::DisplayList::DrawTiledImage::decode):
>+ (WebCore::DisplayList::DrawTiledScaledImage::DrawTiledScaledImage):
>+ (WebCore::DisplayList::DrawTiledScaledImage::globalBounds const):
>+ (WebCore::DisplayList::DrawTiledScaledImage::localBounds const):
>+ (WebCore::DisplayList::DrawTiledScaledImage::decode):
>+ (WebCore::DisplayList::DrawImageBuffer::DrawImageBuffer):
>+ (WebCore::DisplayList::DrawImageBuffer::globalBounds const):
>+ (WebCore::DisplayList::DrawImageBuffer::localBounds const):
>+ (WebCore::DisplayList::DrawImageBuffer::decode):
>+ (WebCore::DisplayList::DrawNativeImage::source const):
>+ (WebCore::DisplayList::DrawNativeImage::destinationRect const):
>+ (WebCore::DisplayList::DrawNativeImage::globalBounds const):
>+ (WebCore::DisplayList::DrawNativeImage::localBounds const):
>+ (WebCore::DisplayList::DrawNativeImage::decode):
>+ (WebCore::DisplayList::DrawPattern::DrawPattern):
>+ (WebCore::DisplayList::DrawPattern::globalBounds const):
>+ (WebCore::DisplayList::DrawPattern::localBounds const):
>+ (WebCore::DisplayList::DrawPattern::decode):
>+ (WebCore::DisplayList::BeginTransparencyLayer::BeginTransparencyLayer):
>+ (WebCore::DisplayList::BeginTransparencyLayer::localBounds const):
>+ (WebCore::DisplayList::BeginTransparencyLayer::globalBounds const):
>+ (WebCore::DisplayList::EndTransparencyLayer::localBounds const):
>+ (WebCore::DisplayList::EndTransparencyLayer::globalBounds const):
>+ (WebCore::DisplayList::DrawRect::DrawRect):
>+ (WebCore::DisplayList::DrawRect::globalBounds const):
>+ (WebCore::DisplayList::DrawRect::localBounds const):
>+ (WebCore::DisplayList::DrawLine::DrawLine):
>+ (WebCore::DisplayList::DrawLine::globalBounds const):
>+ (WebCore::DisplayList::DrawLinesForText::globalBounds const):
>+ (WebCore::DisplayList::DrawLinesForText::decode):
>+ (WebCore::DisplayList::DrawDotsForDocumentMarker::DrawDotsForDocumentMarker):
>+ (WebCore::DisplayList::DrawDotsForDocumentMarker::globalBounds const):
>+ (WebCore::DisplayList::DrawEllipse::DrawEllipse):
>+ (WebCore::DisplayList::DrawEllipse::rect const):
>+ (WebCore::DisplayList::DrawEllipse::globalBounds const):
>+ (WebCore::DisplayList::DrawEllipse::localBounds const):
>+ (WebCore::DisplayList::DrawPath::DrawPath):
>+ (WebCore::DisplayList::DrawPath::globalBounds const):
>+ (WebCore::DisplayList::DrawPath::localBounds const):
>+ (WebCore::DisplayList::DrawPath::decode):
>+ (WebCore::DisplayList::DrawFocusRingPath::DrawFocusRingPath):
>+ (WebCore::DisplayList::DrawFocusRingPath::globalBounds const):
>+ (WebCore::DisplayList::DrawFocusRingPath::decode):
>+ (WebCore::DisplayList::DrawFocusRingRects::globalBounds const):
>+ (WebCore::DisplayList::DrawFocusRingRects::decode):
>+ (WebCore::DisplayList::FillRect::FillRect):
>+ (WebCore::DisplayList::FillRect::rect const):
>+ (WebCore::DisplayList::FillRect::globalBounds const):
>+ (WebCore::DisplayList::FillRect::localBounds const):
>+ (WebCore::DisplayList::FillRectWithColor::FillRectWithColor):
>+ (WebCore::DisplayList::FillRectWithColor::globalBounds const):
>+ (WebCore::DisplayList::FillRectWithColor::localBounds const):
>+ (WebCore::DisplayList::FillRectWithColor::decode):
>+ (WebCore::DisplayList::FillRectWithGradient::rect const):
>+ (WebCore::DisplayList::FillRectWithGradient::globalBounds const):
>+ (WebCore::DisplayList::FillRectWithGradient::localBounds const):
>+ (WebCore::DisplayList::FillRectWithGradient::decode):
>+ (WebCore::DisplayList::FillCompositedRect::FillCompositedRect):
>+ (WebCore::DisplayList::FillCompositedRect::globalBounds const):
>+ (WebCore::DisplayList::FillCompositedRect::localBounds const):
>+ (WebCore::DisplayList::FillCompositedRect::decode):
>+ (WebCore::DisplayList::FillRoundedRect::FillRoundedRect):
>+ (WebCore::DisplayList::FillRoundedRect::globalBounds const):
>+ (WebCore::DisplayList::FillRoundedRect::localBounds const):
>+ (WebCore::DisplayList::FillRoundedRect::decode):
>+ (WebCore::DisplayList::FillRectWithRoundedHole::FillRectWithRoundedHole):
>+ (WebCore::DisplayList::FillRectWithRoundedHole::globalBounds const):
>+ (WebCore::DisplayList::FillRectWithRoundedHole::localBounds const):
>+ (WebCore::DisplayList::FillRectWithRoundedHole::decode):
>+ (WebCore::DisplayList::FillInlinePath::FillInlinePath):
>+ (WebCore::DisplayList::FillInlinePath::globalBounds const):
>+ (WebCore::DisplayList::FillInlinePath::localBounds const):
>+ (WebCore::DisplayList::FillPath::FillPath):
>+ (WebCore::DisplayList::FillPath::globalBounds const):
>+ (WebCore::DisplayList::FillPath::localBounds const):
>+ (WebCore::DisplayList::FillPath::decode):
>+ (WebCore::DisplayList::FillEllipse::FillEllipse):
>+ (WebCore::DisplayList::FillEllipse::globalBounds const):
>+ (WebCore::DisplayList::FillEllipse::localBounds const):
>+ (WebCore::DisplayList::PutImageData::imageData const):
>+ (WebCore::DisplayList::PutImageData::localBounds const):
>+ (WebCore::DisplayList::PutImageData::globalBounds const):
>+ (WebCore::DisplayList::PutImageData::encode const):
>+ (WebCore::DisplayList::PutImageData::decode):
>+ (WebCore::DisplayList::PaintFrameForMedia::localBounds const):
>+ (WebCore::DisplayList::PaintFrameForMedia::globalBounds const):
>+ (WebCore::DisplayList::StrokeRect::StrokeRect):
>+ (WebCore::DisplayList::StrokeRect::globalBounds const):
>+ (WebCore::DisplayList::StrokeInlinePath::StrokeInlinePath):
>+ (WebCore::DisplayList::StrokeInlinePath::globalBounds const):
>+ (WebCore::DisplayList::StrokePath::StrokePath):
>+ (WebCore::DisplayList::StrokePath::globalBounds const):
>+ (WebCore::DisplayList::StrokePath::decode):
>+ (WebCore::DisplayList::StrokeEllipse::StrokeEllipse):
>+ (WebCore::DisplayList::StrokeEllipse::rect const):
>+ (WebCore::DisplayList::StrokeEllipse::globalBounds const):
>+ (WebCore::DisplayList::ClearRect::ClearRect):
>+ (WebCore::DisplayList::ClearRect::rect const):
>+ (WebCore::DisplayList::ClearRect::globalBounds const):
>+ (WebCore::DisplayList::ClearRect::localBounds const):
>+ (WebCore::DisplayList::ApplyStrokePattern::localBounds const):
>+ (WebCore::DisplayList::ApplyStrokePattern::globalBounds const):
>+ (WebCore::DisplayList::ApplyFillPattern::localBounds const):
>+ (WebCore::DisplayList::ApplyFillPattern::globalBounds const):
>+ (WebCore::DisplayList::ApplyDeviceScaleFactor::ApplyDeviceScaleFactor):
>+ (WebCore::DisplayList::ApplyDeviceScaleFactor::localBounds const):
>+ (WebCore::DisplayList::ApplyDeviceScaleFactor::globalBounds const):
>+ (WebCore::DisplayList::DrawingItem::setExtent): Deleted.
>+ (WebCore::DisplayList::DrawingItem::extent const): Deleted.
>+ (WebCore::DisplayList::DrawingItem::extentKnown const): Deleted.
>+ (WebCore::DisplayList::DrawingItem::localBounds const): Deleted.
>+ (WebCore::DisplayList::DrawingItem::globalBounds const): Deleted.
>+ (WebCore::DisplayList::Save::create): Deleted.
>+ (WebCore::DisplayList::Save::encode const): Deleted.
>+ (WebCore::DisplayList::Save::decode): Deleted.
>+ (WebCore::DisplayList::Restore::create): Deleted.
>+ (WebCore::DisplayList::Restore::encode const): Deleted.
>+ (WebCore::DisplayList::Restore::decode): Deleted.
>+ (WebCore::DisplayList::Translate::create): Deleted.
>+ (WebCore::DisplayList::Translate::encode const): Deleted.
>+ (WebCore::DisplayList::Translate::decode): Deleted.
>+ (WebCore::DisplayList::Rotate::create): Deleted.
>+ (WebCore::DisplayList::Rotate::encode const): Deleted.
>+ (WebCore::DisplayList::Rotate::decode): Deleted.
>+ (WebCore::DisplayList::Scale::create): Deleted.
>+ (WebCore::DisplayList::Scale::encode const): Deleted.
>+ (WebCore::DisplayList::Scale::decode): Deleted.
>+ (WebCore::DisplayList::SetCTM::create): Deleted.
>+ (WebCore::DisplayList::SetCTM::encode const): Deleted.
>+ (WebCore::DisplayList::SetCTM::decode): Deleted.
>+ (WebCore::DisplayList::ConcatenateCTM::create): Deleted.
>+ (WebCore::DisplayList::ConcatenateCTM::encode const): Deleted.
>+ (WebCore::DisplayList::ConcatenateCTM::decode): Deleted.
>+ (WebCore::DisplayList::SetInlineFillGradient::create): Deleted.
>+ (WebCore::DisplayList::SetInlineFillGradient::encode const): Deleted.
>+ (WebCore::DisplayList::SetInlineFillGradient::decode): Deleted.
>+ (WebCore::DisplayList::SetInlineFillColor::encode const): Deleted.
>+ (WebCore::DisplayList::SetInlineFillColor::decode): Deleted.
>+ (WebCore::DisplayList::SetInlineStrokeColor::encode const): Deleted.
>+ (WebCore::DisplayList::SetInlineStrokeColor::decode): Deleted.
>+ (WebCore::DisplayList::SetStrokeThickness::encode const): Deleted.
>+ (WebCore::DisplayList::SetStrokeThickness::decode): Deleted.
>+ (WebCore::DisplayList::SetState::create): Deleted.
>+ (WebCore::DisplayList::SetLineCap::create): Deleted.
>+ (WebCore::DisplayList::SetLineCap::encode const): Deleted.
>+ (WebCore::DisplayList::SetLineCap::decode): Deleted.
>+ (WebCore::DisplayList::SetLineDash::create): Deleted.
>+ (WebCore::DisplayList::SetLineJoin::create): Deleted.
>+ (WebCore::DisplayList::SetLineJoin::encode const): Deleted.
>+ (WebCore::DisplayList::SetLineJoin::decode): Deleted.
>+ (WebCore::DisplayList::SetMiterLimit::create): Deleted.
>+ (WebCore::DisplayList::SetMiterLimit::encode const): Deleted.
>+ (WebCore::DisplayList::SetMiterLimit::decode): Deleted.
>+ (WebCore::DisplayList::ClearShadow::create): Deleted.
>+ (WebCore::DisplayList::ClearShadow::encode const): Deleted.
>+ (WebCore::DisplayList::ClearShadow::decode): Deleted.
>+ (WebCore::DisplayList::Clip::create): Deleted.
>+ (WebCore::DisplayList::Clip::encode const): Deleted.
>+ (WebCore::DisplayList::Clip::decode): Deleted.
>+ (WebCore::DisplayList::ClipOut::create): Deleted.
>+ (WebCore::DisplayList::ClipOut::encode const): Deleted.
>+ (WebCore::DisplayList::ClipOut::decode): Deleted.
>+ (WebCore::DisplayList::ClipOutToPath::create): Deleted.
>+ (WebCore::DisplayList::ClipPath::create): Deleted.
>+ (WebCore::DisplayList::ClipToDrawingCommands::create): Deleted.
>+ (WebCore::DisplayList::DrawGlyphs::create): Deleted.
>+ (WebCore::DisplayList::DrawImage::create): Deleted.
>+ (WebCore::DisplayList::DrawTiledImage::create): Deleted.
>+ (WebCore::DisplayList::DrawTiledScaledImage::create): Deleted.
>+ (WebCore::DisplayList::DrawImageBuffer::create): Deleted.
>+ (WebCore::DisplayList::DrawNativeImage::create): Deleted.
>+ (WebCore::DisplayList::DrawPattern::create): Deleted.
>+ (WebCore::DisplayList::BeginTransparencyLayer::create): Deleted.
>+ (WebCore::DisplayList::BeginTransparencyLayer::encode const): Deleted.
>+ (WebCore::DisplayList::BeginTransparencyLayer::decode): Deleted.
>+ (WebCore::DisplayList::EndTransparencyLayer::create): Deleted.
>+ (WebCore::DisplayList::EndTransparencyLayer::encode const): Deleted.
>+ (WebCore::DisplayList::EndTransparencyLayer::decode): Deleted.
>+ (WebCore::DisplayList::DrawRect::create): Deleted.
>+ (WebCore::DisplayList::DrawRect::encode const): Deleted.
>+ (WebCore::DisplayList::DrawRect::decode): Deleted.
>+ (WebCore::DisplayList::DrawLine::create): Deleted.
>+ (WebCore::DisplayList::DrawLine::encode const): Deleted.
>+ (WebCore::DisplayList::DrawLine::decode): Deleted.
>+ (WebCore::DisplayList::DrawLinesForText::create): Deleted.
>+ (WebCore::DisplayList::DrawDotsForDocumentMarker::create): Deleted.
>+ (WebCore::DisplayList::DrawDotsForDocumentMarker::encode const): Deleted.
>+ (WebCore::DisplayList::DrawDotsForDocumentMarker::decode): Deleted.
>+ (WebCore::DisplayList::DrawEllipse::create): Deleted.
>+ (WebCore::DisplayList::DrawEllipse::encode const): Deleted.
>+ (WebCore::DisplayList::DrawEllipse::decode): Deleted.
>+ (WebCore::DisplayList::DrawPath::create): Deleted.
>+ (WebCore::DisplayList::DrawFocusRingPath::create): Deleted.
>+ (WebCore::DisplayList::DrawFocusRingRects::create): Deleted.
>+ (WebCore::DisplayList::FillRect::create): Deleted.
>+ (WebCore::DisplayList::FillRect::encode const): Deleted.
>+ (WebCore::DisplayList::FillRect::decode): Deleted.
>+ (WebCore::DisplayList::FillRectWithColor::create): Deleted.
>+ (WebCore::DisplayList::FillRectWithGradient::create): Deleted.
>+ (WebCore::DisplayList::FillCompositedRect::create): Deleted.
>+ (WebCore::DisplayList::FillRoundedRect::create): Deleted.
>+ (WebCore::DisplayList::FillRectWithRoundedHole::create): Deleted.
>+ (WebCore::DisplayList::FillInlinePath::create): Deleted.
>+ (WebCore::DisplayList::FillInlinePath::encode const): Deleted.
>+ (WebCore::DisplayList::FillInlinePath::decode): Deleted.
>+ (WebCore::DisplayList::FillPath::create): Deleted.
>+ (WebCore::DisplayList::FillEllipse::create): Deleted.
>+ (WebCore::DisplayList::FillEllipse::encode const): Deleted.
>+ (WebCore::DisplayList::FillEllipse::decode): Deleted.
>+ (WebCore::DisplayList::PutImageData::create): Deleted.
>+ (WebCore::DisplayList::PaintFrameForMedia::encode const): Deleted.
>+ (WebCore::DisplayList::PaintFrameForMedia::decode): Deleted.
>+ (WebCore::DisplayList::StrokeRect::create): Deleted.
>+ (WebCore::DisplayList::StrokeRect::encode const): Deleted.
>+ (WebCore::DisplayList::StrokeRect::decode): Deleted.
>+ (WebCore::DisplayList::StrokeInlinePath::create): Deleted.
>+ (WebCore::DisplayList::StrokeInlinePath::encode const): Deleted.
>+ (WebCore::DisplayList::StrokeInlinePath::decode): Deleted.
>+ (WebCore::DisplayList::StrokePath::create): Deleted.
>+ (WebCore::DisplayList::StrokeEllipse::create): Deleted.
>+ (WebCore::DisplayList::StrokeEllipse::encode const): Deleted.
>+ (WebCore::DisplayList::StrokeEllipse::decode): Deleted.
>+ (WebCore::DisplayList::ClearRect::create): Deleted.
>+ (WebCore::DisplayList::ClearRect::encode const): Deleted.
>+ (WebCore::DisplayList::ClearRect::decode): Deleted.
>+ (WebCore::DisplayList::ApplyStrokePattern::create): Deleted.
>+ (WebCore::DisplayList::ApplyStrokePattern::encode const): Deleted.
>+ (WebCore::DisplayList::ApplyStrokePattern::decode): Deleted.
>+ (WebCore::DisplayList::ApplyFillPattern::create): Deleted.
>+ (WebCore::DisplayList::ApplyFillPattern::encode const): Deleted.
>+ (WebCore::DisplayList::ApplyFillPattern::decode): Deleted.
>+ (WebCore::DisplayList::ApplyDeviceScaleFactor::create): Deleted.
>+ (WebCore::DisplayList::ApplyDeviceScaleFactor::encode const): Deleted.
>+ (WebCore::DisplayList::ApplyDeviceScaleFactor::decode): Deleted.
>+ (WebCore::DisplayList::Item::encode const): Deleted.
>+ (WebCore::DisplayList::Item::decode): Deleted.
>+ * platform/graphics/displaylists/DisplayListRecorder.cpp:
>+ (WebCore::DisplayList::Recorder::putImageData):
>+ (WebCore::DisplayList::Recorder::appendStateChangeItem):
>+ (WebCore::DisplayList::Recorder::willAppendItemOfType):
>+ (WebCore::DisplayList::Recorder::didAppendItemOfType):
>+ (WebCore::DisplayList::Recorder::clearShadow):
>+ (WebCore::DisplayList::Recorder::setLineCap):
>+ (WebCore::DisplayList::Recorder::setLineDash):
>+ (WebCore::DisplayList::Recorder::setLineJoin):
>+ (WebCore::DisplayList::Recorder::setMiterLimit):
>+ (WebCore::DisplayList::Recorder::drawGlyphs):
>+ (WebCore::DisplayList::Recorder::drawImage):
>+ (WebCore::DisplayList::Recorder::drawTiledImage):
>+ (WebCore::DisplayList::Recorder::drawImageBuffer):
>+ (WebCore::DisplayList::Recorder::drawNativeImage):
>+ (WebCore::DisplayList::Recorder::drawPattern):
>+ (WebCore::DisplayList::Recorder::save):
>+ (WebCore::DisplayList::Recorder::restore):
>+ (WebCore::DisplayList::Recorder::translate):
>+ (WebCore::DisplayList::Recorder::rotate):
>+ (WebCore::DisplayList::Recorder::scale):
>+ (WebCore::DisplayList::Recorder::concatCTM):
>+ (WebCore::DisplayList::Recorder::setCTM):
>+ (WebCore::DisplayList::Recorder::beginTransparencyLayer):
>+ (WebCore::DisplayList::Recorder::endTransparencyLayer):
>+ (WebCore::DisplayList::Recorder::drawRect):
>+ (WebCore::DisplayList::Recorder::drawLine):
>+ (WebCore::DisplayList::Recorder::drawLinesForText):
>+ (WebCore::DisplayList::Recorder::drawDotsForDocumentMarker):
>+ (WebCore::DisplayList::Recorder::drawEllipse):
>+ (WebCore::DisplayList::Recorder::drawPath):
>+ (WebCore::DisplayList::Recorder::drawFocusRing):
>+ (WebCore::DisplayList::Recorder::fillRect):
>+ (WebCore::DisplayList::Recorder::fillRoundedRect):
>+ (WebCore::DisplayList::Recorder::fillRectWithRoundedHole):
>+ (WebCore::DisplayList::Recorder::fillPath):
>+ (WebCore::DisplayList::Recorder::fillEllipse):
>+ (WebCore::DisplayList::Recorder::strokeRect):
>+ (WebCore::DisplayList::Recorder::strokePath):
>+ (WebCore::DisplayList::Recorder::strokeEllipse):
>+ (WebCore::DisplayList::Recorder::clearRect):
>+ (WebCore::DisplayList::Recorder::applyStrokePattern):
>+ (WebCore::DisplayList::Recorder::applyFillPattern):
>+ (WebCore::DisplayList::Recorder::clip):
>+ (WebCore::DisplayList::Recorder::clipOut):
>+ (WebCore::DisplayList::Recorder::clipPath):
>+ (WebCore::DisplayList::Recorder::clipToDrawingCommands):
>+ (WebCore::DisplayList::Recorder::paintFrameForMedia):
>+ (WebCore::DisplayList::Recorder::applyDeviceScaleFactor):
>+ (WebCore::DisplayList::Recorder::extentFromLocalBounds const):
>+ (WebCore::DisplayList::Recorder::willAppendItem): Deleted.
>+ (WebCore::DisplayList::Recorder::didAppendItem): Deleted.
>+ (WebCore::DisplayList::Recorder::appendItemAndUpdateExtent): Deleted.
>+ (WebCore::DisplayList::Recorder::appendItem): Deleted.
>+ (WebCore::DisplayList::Recorder::updateItemExtent const): Deleted.
>+ * platform/graphics/displaylists/DisplayListRecorder.h:
>+ (WebCore::DisplayList::Recorder::isEmpty const):
>+ (WebCore::DisplayList::Recorder::Delegate::willAppendItemOfType):
>+ (WebCore::DisplayList::Recorder::Delegate::didAppendItemOfType):
>+ (WebCore::DisplayList::Recorder::append):
>+ (WebCore::DisplayList::Recorder::itemCount const): Deleted.
>+ (WebCore::DisplayList::Recorder::Delegate::willAppendItem): Deleted.
>+ (WebCore::DisplayList::Recorder::Delegate::didAppendItem): Deleted.
>+ * platform/graphics/displaylists/DisplayListReplayer.cpp:
>+ (WebCore::DisplayList::Replayer::replay):
>+ * platform/graphics/displaylists/DisplayListReplayer.h:
>+ (WebCore::DisplayList::Replayer::Delegate::apply):
>+
> 2020-10-30 Chris Fleizach <cfleizach@apple.com>
> 
> AX: Incorrect list of voices being displayed on iOS
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index ffd4ce6e339f8ce4c2890ec96ceea4cb778b5a70..39e932ce68a15db314616ac914c9d37ce73252d6 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,55 @@
>+2020-10-30 Wenson Hsieh <wenson_hsieh@apple.com>
>+
>+ [Concurrent display lists] Encode display list items directly into shared memory
>+ https://bugs.webkit.org/show_bug.cgi?id=218406
>+
>+ Reviewed by NOBODY (OOPS!).
>+
>+ WIP only.
>+
>+ * GPUProcess/graphics/RemoteImageBuffer.h:
>+ * GPUProcess/graphics/RemoteRenderingBackend.cpp:
>+ (WebKit::RemoteRenderingBackend::applyResourceItem):
>+ (WebKit::RemoteRenderingBackend::applyMediaItem):
>+ (WebKit::RemoteRenderingBackend::applyDisplayList):
>+ (WebKit::RemoteRenderingBackend::flushDisplayList):
>+ (WebKit::RemoteRenderingBackend::flushDisplayListAndCommit):
>+ (WebKit::RemoteRenderingBackend::didCreateSharedItemData):
>+ (WebKit::RemoteRenderingBackend::sharedItemBuffer const):
>+ * GPUProcess/graphics/RemoteRenderingBackend.h:
>+ * GPUProcess/graphics/RemoteRenderingBackend.messages.in:
>+ * Platform/IPC/Decoder.cpp:
>+ (IPC::Decoder::Decoder):
>+ (IPC::m_bufferDeallocator):
>+ * Platform/IPC/Decoder.h:
>+ (IPC::Decoder::decodeObject):
>+ * Platform/IPC/Encoder.cpp:
>+ (IPC::Encoder::Encoder):
>+ (IPC::Encoder::releaseAttachments):
>+ (IPC::Encoder::hasAttachments const):
>+ * Platform/IPC/Encoder.h:
>+ * Scripts/webkit/messages.py:
>+ * Shared/SharedDisplayListHandle.cpp: Added.
>+ (WebKit::SharedDisplayListHandle::SharedDisplayListHandle):
>+ (WebKit::SharedDisplayListHandle::createDisplayList const):
>+ * Shared/SharedDisplayListHandle.h: Added.
>+ (WebKit::SharedDisplayListHandle::SharedDisplayListHandle):
>+ (WebKit::SharedDisplayListHandle::encode const):
>+ (WebKit::SharedDisplayListHandle::decode):
>+ * Sources.txt:
>+ * WebKit.xcodeproj/project.pbxproj:
>+ * WebProcess/GPU/graphics/RemoteImageBufferProxy.h:
>+ (WebKit::RemoteImageBufferProxy::RemoteImageBufferProxy):
>+ (WebKit::RemoteImageBufferProxy::flushDrawingContextAndCommit):
>+ * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:
>+ (WebKit::RemoteRenderingBackendProxy::flushDisplayList):
>+ (WebKit::RemoteRenderingBackendProxy::flushDisplayListAndCommit):
>+ (WebKit::RemoteRenderingBackendProxy::releaseSharedItemBuffers):
>+ (WebKit::RemoteRenderingBackendProxy::createItemBuffer):
>+ * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
>+ * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in:
>+ * WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp:
>+
> 2020-10-30 Brent Fulgham <bfulgham@apple.com>
> 
> Correct sandbox violations in GPU Process
>diff --git a/Source/WebCore/Sources.txt b/Source/WebCore/Sources.txt
>index 76baf09170a8881c989dd40e35a2b754964c04ca..196cd12f4630678e815ceb5ac62b130ddefc820d 100644
>--- a/Source/WebCore/Sources.txt
>+++ b/Source/WebCore/Sources.txt
>@@ -1960,6 +1960,8 @@ platform/graphics/cpu/arm/filters/FELightingNEON.cpp
> platform/graphics/displaylists/DisplayList.cpp
> platform/graphics/displaylists/DisplayListDrawingContext.cpp
> platform/graphics/displaylists/DisplayListItems.cpp
>+platform/graphics/displaylists/DisplayListItemBuffer.cpp
>+platform/graphics/displaylists/DisplayListItemType.cpp
> platform/graphics/displaylists/DisplayListRecorder.cpp
> platform/graphics/displaylists/DisplayListReplayer.cpp
> platform/graphics/filters/DistantLightSource.cpp
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index 6de95a7a269883d52c6b978f7ba5c4d1bd10e00c..c36ea00df7c2edbee5cd438c8d330c45f353f55c 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -5158,6 +5158,7 @@
> 		F3ABFE0C130E9DA000E7F7D1 /* InstrumentingAgents.h in Headers */ = {isa = PBXBuildFile; fileRef = F3ABFE0B130E9DA000E7F7D1 /* InstrumentingAgents.h */; };
> 		F3D461491161D53200CA0D09 /* JSErrorHandler.h in Headers */ = {isa = PBXBuildFile; fileRef = F3D461471161D53200CA0D09 /* JSErrorHandler.h */; };
> 		F403E7872363B58C00044550 /* EnterKeyHint.h in Headers */ = {isa = PBXBuildFile; fileRef = F403E7852363B58C00044550 /* EnterKeyHint.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		F422B8B8253F71FC004E77E8 /* DisplayListItemBuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = F422B8B5253F7065004E77E8 /* DisplayListItemBuffer.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		F429261825264D4400007898 /* MediaPlayerIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = F429261725264D4400007898 /* MediaPlayerIdentifier.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		F433E9031DBBDBA200EF0D14 /* StaticPasteboard.h in Headers */ = {isa = PBXBuildFile; fileRef = F433E9021DBBDBA200EF0D14 /* StaticPasteboard.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		F440E77A233D94D70063F9AB /* NavigatorClipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = F440E76F233D94D30063F9AB /* NavigatorClipboard.h */; };
>@@ -5182,6 +5183,7 @@
> 		F48D2A7E2157182600C6752B /* FontAttributes.h in Headers */ = {isa = PBXBuildFile; fileRef = F48D2A712156DC0A00C6752B /* FontAttributes.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		F48D2AA52159740D00C6752B /* ColorCocoa.h in Headers */ = {isa = PBXBuildFile; fileRef = F48D2AA32159740D00C6752B /* ColorCocoa.h */; };
> 		F49786881FF45FA500E060AB /* PasteboardItemInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = F49786871FF45FA500E060AB /* PasteboardItemInfo.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		F4A6D6A4254C512C00B65FAA /* DisplayListItemType.h in Headers */ = {isa = PBXBuildFile; fileRef = F4A6D6A3254C512C00B65FAA /* DisplayListItemType.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		F4B422C4220C0568009E1E7D /* DOMPasteAccess.h in Headers */ = {isa = PBXBuildFile; fileRef = F4B422C2220C0000009E1E7D /* DOMPasteAccess.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		F4BFB9851E1DDF9B00862C24 /* DumpEditingHistory.js in Copy Scripts */ = {isa = PBXBuildFile; fileRef = F48389831E1DDF2B0076B7EA /* DumpEditingHistory.js */; };
> 		F4BFB9861E1DDF9B00862C24 /* EditingHistoryUtil.js in Copy Scripts */ = {isa = PBXBuildFile; fileRef = F48389841E1DDF2B0076B7EA /* EditingHistoryUtil.js */; };
>@@ -16305,6 +16307,8 @@
> 		F3D461471161D53200CA0D09 /* JSErrorHandler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSErrorHandler.h; sourceTree = "<group>"; };
> 		F403E7852363B58C00044550 /* EnterKeyHint.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = EnterKeyHint.h; sourceTree = "<group>"; };
> 		F403E7862363B58C00044550 /* EnterKeyHint.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = EnterKeyHint.cpp; sourceTree = "<group>"; };
>+		F422B8B5253F7065004E77E8 /* DisplayListItemBuffer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DisplayListItemBuffer.h; sourceTree = "<group>"; };
>+		F422B8B6253F7065004E77E8 /* DisplayListItemBuffer.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = DisplayListItemBuffer.cpp; sourceTree = "<group>"; };
> 		F429261725264D4400007898 /* MediaPlayerIdentifier.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = MediaPlayerIdentifier.h; sourceTree = "<group>"; };
> 		F42CEB54214031EE002DCA72 /* FontAttributeChangesCocoa.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = FontAttributeChangesCocoa.mm; sourceTree = "<group>"; };
> 		F433E9021DBBDBA200EF0D14 /* StaticPasteboard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StaticPasteboard.h; sourceTree = "<group>"; };
>@@ -16358,6 +16362,8 @@
> 		F48D2AA42159740D00C6752B /* ColorCocoa.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = ColorCocoa.mm; sourceTree = "<group>"; };
> 		F49786871FF45FA500E060AB /* PasteboardItemInfo.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PasteboardItemInfo.h; sourceTree = "<group>"; };
> 		F49E98E421DEE6C1009AE55E /* EditAction.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = EditAction.cpp; sourceTree = "<group>"; };
>+		F4A6D6A3254C512C00B65FAA /* DisplayListItemType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DisplayListItemType.h; sourceTree = "<group>"; };
>+		F4A6D6A6254C51E900B65FAA /* DisplayListItemType.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = DisplayListItemType.cpp; sourceTree = "<group>"; };
> 		F4B422C2220C0000009E1E7D /* DOMPasteAccess.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DOMPasteAccess.h; sourceTree = "<group>"; };
> 		F4C5F2052479E7EE00E9B4F5 /* ClipboardImageReader.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ClipboardImageReader.h; sourceTree = "<group>"; };
> 		F4C5F2082479E9C800E9B4F5 /* ClipboardImageReader.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ClipboardImageReader.cpp; sourceTree = "<group>"; };
>@@ -17610,8 +17616,12 @@
> 				55C0A29523FE2CE000F2CB93 /* DisplayListDrawingContext.cpp */,
> 				72EA09F923FCCC6A008504A5 /* DisplayListDrawingContext.h */,
> 				72EA09F723FCCB3D008504A5 /* DisplayListImageBuffer.h */,
>+				F422B8B6253F7065004E77E8 /* DisplayListItemBuffer.cpp */,
>+				F422B8B5253F7065004E77E8 /* DisplayListItemBuffer.h */,
> 				0FE5FBCC1C3DD51E0007A2CA /* DisplayListItems.cpp */,
> 				0FE5FBCD1C3DD51E0007A2CA /* DisplayListItems.h */,
>+				F4A6D6A6254C51E900B65FAA /* DisplayListItemType.cpp */,
>+				F4A6D6A3254C512C00B65FAA /* DisplayListItemType.h */,
> 				0FE5FBCE1C3DD51E0007A2CA /* DisplayListRecorder.cpp */,
> 				0FE5FBCF1C3DD51E0007A2CA /* DisplayListRecorder.h */,
> 				0FE5FBD01C3DD51E0007A2CA /* DisplayListReplayer.cpp */,
>@@ -31431,7 +31441,9 @@
> 				0FE5FBD31C3DD51E0007A2CA /* DisplayList.h in Headers */,
> 				55AD09402408964000DE4D2F /* DisplayListDrawingContext.h in Headers */,
> 				55AD093E2408963500DE4D2F /* DisplayListImageBuffer.h in Headers */,
>+				F422B8B8253F71FC004E77E8 /* DisplayListItemBuffer.h in Headers */,
> 				0FE5FBD51C3DD51E0007A2CA /* DisplayListItems.h in Headers */,
>+				F4A6D6A4254C512C00B65FAA /* DisplayListItemType.h in Headers */,
> 				0FE5FBD71C3DD51E0007A2CA /* DisplayListRecorder.h in Headers */,
> 				0FE5FBD91C3DD51E0007A2CA /* DisplayListReplayer.h in Headers */,
> 				49AF2D6914435D050016A784 /* DisplayRefreshMonitor.h in Headers */,
>diff --git a/Source/WebCore/html/canvas/CanvasRenderingContext2DBase.cpp b/Source/WebCore/html/canvas/CanvasRenderingContext2DBase.cpp
>index 6a80b84600e0a2bb055523955fe9cc60a9aec3cb..f47dbd2d9f8be2e8555ab6d9678a95e665da2858 100644
>--- a/Source/WebCore/html/canvas/CanvasRenderingContext2DBase.cpp
>+++ b/Source/WebCore/html/canvas/CanvasRenderingContext2DBase.cpp
>@@ -2021,7 +2021,7 @@ void CanvasRenderingContext2DBase::paintRenderingResultsToCanvas()
> ASSERT(m_usesDisplayListDrawing);
> 
> auto& displayList = m_recordingContext->displayList();
>- if (displayList.itemCount()) {
>+ if (!displayList.isEmpty()) {
> DisplayList::Replayer replayer(*canvasBase().drawingContext(), displayList);
> replayer.replay({ FloatPoint::zero(), canvasBase().size() });
> displayList.clear();
>diff --git a/Source/WebCore/platform/graphics/GraphicsContext.h b/Source/WebCore/platform/graphics/GraphicsContext.h
>index 0d1ca92d6045eb37a78d3e1897c26f42b9c76f3a..59d3230e0e8f4360d73eb33682534a3e490a683f 100644
>--- a/Source/WebCore/platform/graphics/GraphicsContext.h
>+++ b/Source/WebCore/platform/graphics/GraphicsContext.h
>@@ -163,10 +163,10 @@ struct GraphicsContextState {
> WEBCORE_EXPORT ~GraphicsContextState();
> 
> GraphicsContextState(const GraphicsContextState&);
>- GraphicsContextState(GraphicsContextState&&);
>+ WEBCORE_EXPORT GraphicsContextState(GraphicsContextState&&);
> 
> GraphicsContextState& operator=(const GraphicsContextState&);
>- GraphicsContextState& operator=(GraphicsContextState&&);
>+ WEBCORE_EXPORT GraphicsContextState& operator=(GraphicsContextState&&);
> 
> enum Change : uint32_t {
> StrokeGradientChange = 1 << 0,
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayList.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayList.cpp
>index ffd9d6ddfb60ac1a09722dfadc82f11530e920a1..a16e90818f14c1cc9e3fc4e7f42ce19dadb38225 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayList.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayList.cpp
>@@ -26,6 +26,7 @@
> #include "config.h"
> #include "DisplayList.h"
> 
>+#include "DisplayListItemBuffer.h"
> #include "DisplayListItems.h"
> #include "Logging.h"
> #include <wtf/StdLibExtras.h>
>@@ -48,17 +49,37 @@ void DisplayList::dump() const
> }
> #endif
> 
>+DisplayList::DisplayList(DisplayList&& other)
>+ : m_items(WTFMove(other.m_items))
>+{
>+}
>+
>+DisplayList::DisplayList(ItemBufferHandles&& handles)
>+ : m_items(makeUnique<ItemBuffer>(WTFMove(handles)))
>+{
>+}
>+
>+DisplayList::DisplayList() = default;
>+DisplayList::~DisplayList() = default;
>+
>+DisplayList& DisplayList::operator=(DisplayList&& other)
>+{
>+ m_items = WTFMove(other.m_items);
>+ return *this;
>+}
>+
> void DisplayList::clear()
> {
>- m_list.clear();
>+ if (m_items)
>+ m_items->clear();
> }
> 
>-bool DisplayList::shouldDumpForFlags(AsTextFlags flags, const Item& item)
>+bool DisplayList::shouldDumpForFlags(AsTextFlags flags, ItemHandle item)
> {
> switch (item.type()) {
> case ItemType::SetState:
> if (!(flags & AsTextFlag::IncludesPlatformOperations)) {
>- const auto& stateItem = downcast<SetState>(item);
>+ const auto& stateItem = item.get<SetState>();
> // FIXME: for now, only drop the item if the only state-change flags are platform-specific.
> if (stateItem.state().m_changeFlags == GraphicsContextState::ShouldSubpixelQuantizeFontsChange)
> return false;
>@@ -80,14 +101,27 @@ bool DisplayList::shouldDumpForFlags(AsTextFlags flags, const Item& item)
> return true;
> }
> 
>+static void dumpDrawingItemExtent(TextStream& stream, Optional<FloatRect>&& extent)
>+{
>+ stream << " extent ";
>+ if (extent)
>+ stream << *extent;
>+ else
>+ stream << "unknown";
>+}
>+
> String DisplayList::asText(AsTextFlags flags) const
> {
> TextStream stream(TextStream::LineMode::MultipleLine, TextStream::Formatting::SVGStyleRect);
>- for (auto& item : m_list) {
>+ map([&] (ItemHandle item, Optional<FloatRect>&& extent) {
> if (!shouldDumpForFlags(flags, item))
>- continue;
>+ return;
>+
>+ TextStream::GroupScope group(stream);
> stream << item;
>- }
>+ if (item.isDrawingItem())
>+ dumpDrawingItemExtent(stream, WTFMove(extent));
>+ });
> return stream.release();
> }
> 
>@@ -96,11 +130,12 @@ void DisplayList::dump(TextStream& ts) const
> TextStream::GroupScope group(ts);
> ts << "display list";
> 
>- size_t numItems = m_list.size();
>- for (size_t i = 0; i < numItems; ++i) {
>- TextStream::GroupScope scope(ts);
>- ts <- }
>+ map([&] (ItemHandle item, Optional<FloatRect>&& extent) {
>+ TextStream::GroupScope group(ts);
>+ ts << item;
>+ if (item.isDrawingItem())
>+ dumpDrawingItemExtent(ts, WTFMove(extent));
>+ });
> ts.startGroup();
> ts << "size in bytes: " << sizeInBytes();
> ts.endGroup();
>@@ -108,11 +143,229 @@ void DisplayList::dump(TextStream& ts) const
> 
> size_t DisplayList::sizeInBytes() const
> {
>- size_t result = 0;
>- for (auto& ref : m_list)
>- result += Item::sizeInBytes(ref);
>+ return m_items ? m_items->sizeInBytes() : 0;
>+}
>+
>+bool DisplayList::isEmpty() const
>+{
>+ return !m_items || m_items->isEmpty();
>+}
>+
>+ItemBuffer& DisplayList::itemBuffer()
>+{
>+ if (!m_items)
>+ m_items = makeUnique<ItemBuffer>();
>+ return *m_items;
>+}
> 
>- return result;
>+void DisplayList::setItemBufferClient(ItemBufferReadingClient* client)
>+{
>+ itemBuffer().setClient(client);
>+}
>+
>+void DisplayList::setItemBufferClient(ItemBufferWritingClient* client)
>+{
>+ itemBuffer().setClient(client);
>+}
>+
>+void DisplayList::forEachItemBuffer(Function<void(const ItemBufferHandle&)>&& mapFunction) const
>+{
>+ if (m_items)
>+ m_items->forEachItemBuffer(WTFMove(mapFunction));
>+}
>+
>+void DisplayList::map(Function<void(ItemHandle, Optional<FloatRect>&&)>&& mapFunction) const
>+{
>+ if (!m_items)
>+ return;
>+
>+ constexpr size_t sizeOfBufferForNonInlineItems = 256;
>+ static uint8_t fixedBufferForNonInlineItems[sizeOfBufferForNonInlineItems] { 0 };
>+
>+ size_t drawingItemCount = 0;
>+ auto* client = m_items->m_readingClient;
>+
>+ auto iterateItemsInRange = [&] (uint8_t* initialOffset, size_t length) {
>+ auto* offset = initialOffset;
>+ auto* endOfBuffer = offset + length;
>+ while (offset < endOfBuffer) {
>+ auto itemType = static_cast<ItemType>(offset[0]);
>+ Optional<FloatRect> extent;
>+ if (isDrawingItem(itemType) && !m_drawingItemExtents.isEmpty()) {
>+ extent = m_drawingItemExtents[drawingItemCount];
>+ drawingItemCount++;
>+ }
>+
>+ if (client && client->requiresDecoding(itemType)) {
>+ auto sizeOfTypeAndItem = sizeOfItemInBytes(itemType) + sizeof(ItemType);
>+ auto* startOfTemporaryItem = sizeOfTypeAndItem <= sizeOfBufferForNonInlineItems
>+ ? fixedBufferForNonInlineItems
>+ : reinterpret_cast<uint8_t*>(malloc(sizeOfTypeAndItem));
>+
>+ startOfTemporaryItem[0] = static_cast<uint8_t>(itemType);
>+
>+ ItemHandle item { startOfTemporaryItem };
>+
>+ auto sizeOfData = reinterpret_cast<size_t*>(offset + sizeof(ItemType))[0];
>+ auto* startOfData = offset + sizeof(ItemType) + sizeof(size_t);
>+ offset = startOfData + sizeOfData;
>+ RELEASE_ASSERT(offset <= endOfBuffer);
>+
>+ if (client->decodeItem(startOfData, sizeOfData, item)) {
>+ mapFunction(item, WTFMove(extent));
>+ item.destroy();
>+ }
>+
>+ if (startOfTemporaryItem != fixedBufferForNonInlineItems)
>+ free(startOfTemporaryItem);
>+ } else {
>+ ItemHandle item { offset };
>+ mapFunction(item, WTFMove(extent));
>+ offset += item.size();
>+ }
>+
>+ if (offset == endOfBuffer)
>+ break;
>+
>+ RELEASE_ASSERT(offset < endOfBuffer);
>+ }
>+ };
>+
>+ for (auto& buffer : m_items->readOnlyBuffers())
>+ iterateItemsInRange(buffer.data + buffer.offset, buffer.capacity);
>+
>+ if (m_items->m_writableSizeInBytes) {
>+ auto& writableBuffer = m_items->m_writableBuffer;
>+ iterateItemsInRange(writableBuffer.data + writableBuffer.offset, m_items->m_writableSizeInBytes);
>+ }
>+}
>+
>+void DisplayList::setTracksDrawingItemExtents(bool value)
>+{
>+ RELEASE_ASSERT(!m_items || m_items->isEmpty());
>+ m_tracksDrawingItemExtents = value;
>+}
>+
>+void DisplayList::append(ItemHandle item)
>+{
>+ switch (item.type()) {
>+ case ItemType::Save:
>+ return append<Save>(item.get<Save>());
>+ case ItemType::Restore:
>+ return append<Restore>(item.get<Restore>());
>+ case ItemType::Translate:
>+ return append<Translate>(item.get<Translate>());
>+ case ItemType::Rotate:
>+ return append<Rotate>(item.get<Rotate>());
>+ case ItemType::Scale:
>+ return append<Scale>(item.get<Scale>());
>+ case ItemType::ConcatenateCTM:
>+ return append<ConcatenateCTM>(item.get<ConcatenateCTM>());
>+ case ItemType::SetCTM:
>+ return append<SetCTM>(item.get<SetCTM>());
>+ case ItemType::SetInlineFillGradient:
>+ return append<SetInlineFillGradient>(item.get<SetInlineFillGradient>());
>+ case ItemType::SetInlineFillColor:
>+ return append<SetInlineFillColor>(item.get<SetInlineFillColor>());
>+ case ItemType::SetInlineStrokeColor:
>+ return append<SetInlineStrokeColor>(item.get<SetInlineStrokeColor>());
>+ case ItemType::SetStrokeThickness:
>+ return append<SetStrokeThickness>(item.get<SetStrokeThickness>());
>+ case ItemType::SetState:
>+ return append<SetState>(item.get<SetState>());
>+ case ItemType::SetLineCap:
>+ return append<SetLineCap>(item.get<SetLineCap>());
>+ case ItemType::SetLineDash:
>+ return append<SetLineDash>(item.get<SetLineDash>());
>+ case ItemType::SetLineJoin:
>+ return append<SetLineJoin>(item.get<SetLineJoin>());
>+ case ItemType::SetMiterLimit:
>+ return append<SetMiterLimit>(item.get<SetMiterLimit>());
>+ case ItemType::ClearShadow:
>+ return append<ClearShadow>(item.get<ClearShadow>());
>+ case ItemType::Clip:
>+ return append<Clip>(item.get<Clip>());
>+ case ItemType::ClipOut:
>+ return append<ClipOut>(item.get<ClipOut>());
>+ case ItemType::ClipOutToPath:
>+ return append<ClipOutToPath>(item.get<ClipOutToPath>());
>+ case ItemType::ClipPath:
>+ return append<ClipPath>(item.get<ClipPath>());
>+ case ItemType::ClipToDrawingCommands:
>+ return; // FIXME: Support the ability to clone display lists (this is currently only used for display list tracking).
>+ case ItemType::DrawGlyphs:
>+ return append<DrawGlyphs>(item.get<DrawGlyphs>());
>+ case ItemType::DrawImage:
>+ return append<DrawImage>(item.get<DrawImage>());
>+ case ItemType::DrawTiledImage:
>+ return append<DrawTiledImage>(item.get<DrawTiledImage>());
>+ case ItemType::DrawTiledScaledImage:
>+ return append<DrawTiledScaledImage>(item.get<DrawTiledScaledImage>());
>+ case ItemType::DrawImageBuffer:
>+ return append<DrawImageBuffer>(item.get<DrawImageBuffer>());
>+ case ItemType::DrawNativeImage:
>+ return append<DrawNativeImage>(item.get<DrawNativeImage>());
>+ case ItemType::DrawPattern:
>+ return append<DrawPattern>(item.get<DrawPattern>());
>+ case ItemType::DrawRect:
>+ return append<DrawRect>(item.get<DrawRect>());
>+ case ItemType::DrawLine:
>+ return append<DrawLine>(item.get<DrawLine>());
>+ case ItemType::DrawLinesForText:
>+ return append<DrawLinesForText>(item.get<DrawLinesForText>());
>+ case ItemType::DrawDotsForDocumentMarker:
>+ return append<DrawDotsForDocumentMarker>(item.get<DrawDotsForDocumentMarker>());
>+ case ItemType::DrawEllipse:
>+ return append<DrawEllipse>(item.get<DrawEllipse>());
>+ case ItemType::DrawPath:
>+ return append<DrawPath>(item.get<DrawPath>());
>+ case ItemType::DrawFocusRingPath:
>+ return append<DrawFocusRingPath>(item.get<DrawFocusRingPath>());
>+ case ItemType::DrawFocusRingRects:
>+ return append<DrawFocusRingRects>(item.get<DrawFocusRingRects>());
>+ case ItemType::FillRect:
>+ return append<FillRect>(item.get<FillRect>());
>+ case ItemType::FillRectWithColor:
>+ return append<FillRectWithColor>(item.get<FillRectWithColor>());
>+ case ItemType::FillRectWithGradient:
>+ return append<FillRectWithGradient>(item.get<FillRectWithGradient>());
>+ case ItemType::FillCompositedRect:
>+ return append<FillCompositedRect>(item.get<FillCompositedRect>());
>+ case ItemType::FillRoundedRect:
>+ return append<FillRoundedRect>(item.get<FillRoundedRect>());
>+ case ItemType::FillRectWithRoundedHole:
>+ return append<FillRectWithRoundedHole>(item.get<FillRectWithRoundedHole>());
>+ case ItemType::FillInlinePath:
>+ return append<FillInlinePath>(item.get<FillInlinePath>());
>+ case ItemType::FillPath:
>+ return append<FillPath>(item.get<FillPath>());
>+ case ItemType::FillEllipse:
>+ return append<FillEllipse>(item.get<FillEllipse>());
>+ case ItemType::PutImageData:
>+ return append<PutImageData>(item.get<PutImageData>());
>+ case ItemType::PaintFrameForMedia:
>+ return append<PaintFrameForMedia>(item.get<PaintFrameForMedia>());
>+ case ItemType::StrokeRect:
>+ return append<StrokeRect>(item.get<StrokeRect>());
>+ case ItemType::StrokeInlinePath:
>+ return append<StrokeInlinePath>(item.get<StrokeInlinePath>());
>+ case ItemType::StrokePath:
>+ return append<StrokePath>(item.get<StrokePath>());
>+ case ItemType::StrokeEllipse:
>+ return append<StrokeEllipse>(item.get<StrokeEllipse>());
>+ case ItemType::ClearRect:
>+ return append<ClearRect>(item.get<ClearRect>());
>+ case ItemType::BeginTransparencyLayer:
>+ return append<BeginTransparencyLayer>(item.get<BeginTransparencyLayer>());
>+ case ItemType::EndTransparencyLayer:
>+ return append<EndTransparencyLayer>(item.get<EndTransparencyLayer>());
>+ case ItemType::ApplyStrokePattern:
>+ return append<ApplyStrokePattern>(item.get<ApplyStrokePattern>());
>+ case ItemType::ApplyFillPattern:
>+ return append<ApplyFillPattern>(item.get<ApplyFillPattern>());
>+ case ItemType::ApplyDeviceScaleFactor:
>+ return append<ApplyDeviceScaleFactor>(item.get<ApplyDeviceScaleFactor>());
>+ }
> }
> 
> } // namespace DisplayList
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayList.h b/Source/WebCore/platform/graphics/displaylists/DisplayList.h
>index d6be274c68deefb4c0d5361be6481524032c9f41..50490170c6c4dab72bf910abc7ba51b8ec41d7d9 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayList.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayList.h
>@@ -25,10 +25,13 @@
> 
> #pragma once
> 
>+#include "DisplayListItemBuffer.h"
> #include "FloatRect.h"
> #include "GraphicsContext.h"
> #include <wtf/FastMalloc.h>
> #include <wtf/Noncopyable.h>
>+#include <wtf/ObjectIdentifier.h>
>+#include <wtf/Vector.h>
> #include <wtf/text/WTFString.h>
> 
> namespace WTF {
>@@ -39,101 +42,6 @@ namespace WebCore {
> 
> namespace DisplayList {
> 
>-enum class ItemType : uint8_t {
>- Save,
>- Restore,
>- Translate,
>- Rotate,
>- Scale,
>- ConcatenateCTM,
>- SetCTM,
>- SetInlineFillGradient,
>- SetInlineFillColor,
>- SetInlineStrokeColor,
>- SetStrokeThickness,
>- SetState,
>- SetLineCap,
>- SetLineDash,
>- SetLineJoin,
>- SetMiterLimit,
>- ClearShadow,
>- Clip,
>- ClipOut,
>- ClipOutToPath,
>- ClipPath,
>- ClipToDrawingCommands,
>- DrawGlyphs,
>- DrawImage,
>- DrawTiledImage,
>- DrawTiledScaledImage,
>- DrawImageBuffer,
>- DrawNativeImage,
>- DrawPattern,
>- DrawRect,
>- DrawLine,
>- DrawLinesForText,
>- DrawDotsForDocumentMarker,
>- DrawEllipse,
>- DrawPath,
>- DrawFocusRingPath,
>- DrawFocusRingRects,
>- FillRect,
>- FillRectWithColor,
>- FillRectWithGradient,
>- FillCompositedRect,
>- FillRoundedRect,
>- FillRectWithRoundedHole,
>-#if ENABLE(INLINE_PATH_DATA)
>- FillInlinePath,
>-#endif
>- FillPath,
>- FillEllipse,
>- PutImageData,
>- PaintFrameForMedia,
>- StrokeRect,
>-#if ENABLE(INLINE_PATH_DATA)
>- StrokeInlinePath,
>-#endif
>- StrokePath,
>- StrokeEllipse,
>- ClearRect,
>- BeginTransparencyLayer,
>- EndTransparencyLayer,
>-#if USE(CG)
>- ApplyStrokePattern, // FIXME: should not be a recorded item.
>- ApplyFillPattern, // FIXME: should not be a recorded item.
>-#endif
>- ApplyDeviceScaleFactor,
>-};
>-
>-class Item : public RefCounted<Item> {
>-public:
>- Item() = delete;
>-
>- WEBCORE_EXPORT Item(ItemType);
>- WEBCORE_EXPORT virtual ~Item();
>-
>- ItemType type() const
>- {
>- return m_type;
>- }
>-
>- virtual void apply(GraphicsContext&) const = 0;
>-
>- virtual bool isDrawingItem() const { return false; }
>-
>-#if !defined(NDEBUG) || !LOG_DISABLED
>- WTF::CString description() const;
>-#endif
>- static size_t sizeInBytes(const Item&);
>-
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<Item>> decode(Decoder&);
>-
>-private:
>- ItemType m_type;
>-};
>-
> enum AsTextFlag {
> None = 0,
> IncludesPlatformOperations = 1 << 0,
>@@ -146,86 +54,60 @@ class DisplayList {
> friend class Recorder;
> friend class Replayer;
> public:
>- DisplayList() = default;
>- DisplayList(DisplayList&&) = default;
>+ WEBCORE_EXPORT DisplayList();
>+ WEBCORE_EXPORT DisplayList(DisplayList&&);
>+ WEBCORE_EXPORT DisplayList(ItemBufferHandles&&);
> 
>- DisplayList& operator=(DisplayList&&) = default;
>+ WEBCORE_EXPORT ~DisplayList();
> 
>- void dump(WTF::TextStream&) const;
>+ WEBCORE_EXPORT DisplayList& operator=(DisplayList&&);
> 
>- const Vector<Ref<Item>>& list() const { return m_list; }
>- Item& itemAt(size_t index)
>- {
>- ASSERT(index < m_list.size());
>- return m_list[index].get();
>- }
>+ void dump(WTF::TextStream&) const;
> 
> WEBCORE_EXPORT void clear();
>+ WEBCORE_EXPORT bool isEmpty() const;
>+ WEBCORE_EXPORT size_t sizeInBytes() const;
> 
>- size_t itemCount() const { return m_list.size(); }
>- size_t sizeInBytes() const;
>- 
> String asText(AsTextFlags) const;
> 
>+ WEBCORE_EXPORT void setItemBufferClient(ItemBufferReadingClient*);
>+ WEBCORE_EXPORT void setItemBufferClient(ItemBufferWritingClient*);
>+
> #if !defined(NDEBUG) || !LOG_DISABLED
> WTF::CString description() const;
> WEBCORE_EXPORT void dump() const;
> #endif
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<DisplayList> decode(Decoder&);
>+ WEBCORE_EXPORT void map(Function<void(ItemHandle, Optional<FloatRect>&&)>&&) const;
>+ WEBCORE_EXPORT void forEachItemBuffer(Function<void(const ItemBufferHandle&)>&&) const;
> 
>+ template<typename T, class... Args> void append(Args&&... args);
>+ void append(ItemHandle);
>+
>+ bool tracksDrawingItemExtents() const { return m_tracksDrawingItemExtents; }
>+ WEBCORE_EXPORT void setTracksDrawingItemExtents(bool);
> 
> private:
>- Item& append(Ref<Item>&& item)
>- {
>- m_list.append(WTFMove(item));
>- return m_list.last().get();
>- }
>+ ItemBuffer* itemBufferIfExists() const { return m_items.get(); }
>+ WEBCORE_EXPORT ItemBuffer& itemBuffer();
> 
>- // Less efficient append, only used for tracking replay.
>- void appendItem(Item& item)
>+ void addDrawingItemExtent(Optional<FloatRect>&& extent)
> {
>- m_list.append(item);
>+ ASSERT(m_tracksDrawingItemExtents);
>+ m_drawingItemExtents.append(WTFMove(extent));
> }
> 
>- static bool shouldDumpForFlags(AsTextFlags, const Item&);
>-
>- Vector<Ref<Item>>& list() { return m_list; }
>+ static bool shouldDumpForFlags(AsTextFlags, ItemHandle);
> 
>- Vector<Ref<Item>> m_list;
>+ std::unique_ptr<ItemBuffer> m_items;
>+ Vector<Optional<FloatRect>> m_drawingItemExtents;
>+ bool m_tracksDrawingItemExtents { true };
> };
> 
>-
>-template<class Encoder>
>-void DisplayList::encode(Encoder& encoder) const
>+template<typename T, class... Args>
>+void DisplayList::append(Args&&... args)
> {
>- encoder << static_cast<uint64_t>(m_list.size());
>-
>- for (auto& item : m_list)
>- encoder << item.get();
>-}
>-
>-template<class Decoder>
>-Optional<DisplayList> DisplayList::decode(Decoder& decoder)
>-{
>- Optional<uint64_t> itemCount;
>- decoder >> itemCount;
>- if (!itemCount)
>- return WTF::nullopt;
>-
>- DisplayList displayList;
>-
>- for (uint64_t i = 0; i < *itemCount; i++) {
>- auto item = Item::decode(decoder);
>- // FIXME: Once we can decode all types, failing to decode an item should turn into a decode failure.
>- // For now, we just have to ignore it.
>- if (!item)
>- continue;
>- displayList.append(WTFMove(*item));
>- }
>-
>- return displayList;
>+ itemBuffer().append<T>(std::forward<Args>(args)...);
> }
> 
> } // DisplayList
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.cpp
>index d4617d3516f4f3e51d75d64434a6a39457a0001f..f9b323c74266ed1f61d44b0472ef551853e8c7b5 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.cpp
>@@ -55,7 +55,7 @@ Recorder& DrawingContext::recorder()
> 
> void DrawingContext::replayDisplayList(GraphicsContext& destContext)
> {
>- if (!m_displayList.itemCount())
>+ if (m_displayList.isEmpty())
> return;
> 
> Replayer replayer(destContext, m_displayList);
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.h b/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.h
>index 22ed256e80ad293a052069b743088a1351f47cc0..96e4b1eff981e42279d746dc6bb39c8aa528e145 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListDrawingContext.h
>@@ -39,7 +39,7 @@ public:
> 
> GraphicsContext& context() const { return const_cast<DrawingContext&>(*this).m_context; }
> WEBCORE_EXPORT Recorder& recorder();
>- DisplayList takeDisplayList() { return WTFMove(m_displayList); }
>+ DisplayList takeDisplayList() { return std::exchange(m_displayList, { }); }
> DisplayList& displayList() { return m_displayList; }
> const DisplayList& displayList() const { return m_displayList; }
> const DisplayList* replayedDisplayList() const { return m_replayedDisplayList.get(); }
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListImageBuffer.h b/Source/WebCore/platform/graphics/displaylists/DisplayListImageBuffer.h
>index 32599e062d7cf59d1dc2ead01e760d66e3f7ec3c..ffd94b529c06a7e2cde00ec94b355c85ddafb4c3 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListImageBuffer.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListImageBuffer.h
>@@ -71,7 +71,7 @@ public:
> 
> void flushDrawingContext() override
> {
>- if (m_drawingContext.displayList().itemCount())
>+ if (!m_drawingContext.displayList().isEmpty())
> m_drawingContext.replayDisplayList(BaseConcreteImageBuffer::context());
> }
> 
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..86442cfc946ee5e0ffb362e2f51d4e5a0c95ee26
>--- /dev/null
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.cpp
>@@ -0,0 +1,314 @@
>+/*
>+ * Copyright (C) 2020 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ * notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ * notice, this list of conditions and the following disclaimer in the
>+ * documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "DisplayListItemBuffer.h"
>+
>+#include "DisplayListItems.h"
>+
>+namespace WebCore {
>+namespace DisplayList {
>+
>+void ItemHandle::apply(GraphicsContext& context)
>+{
>+ switch (type()) {
>+ case ItemType::Save:
>+ return get<Save>().apply(context);
>+ case ItemType::Restore:
>+ return get<Restore>().apply(context);
>+ case ItemType::Translate:
>+ return get<Translate>().apply(context);
>+ case ItemType::Rotate:
>+ return get<Rotate>().apply(context);
>+ case ItemType::Scale:
>+ return get<Scale>().apply(context);
>+ case ItemType::ConcatenateCTM:
>+ return get<ConcatenateCTM>().apply(context);
>+ case ItemType::SetCTM:
>+ return get<SetCTM>().apply(context);
>+ case ItemType::SetInlineFillGradient:
>+ return get<SetInlineFillGradient>().apply(context);
>+ case ItemType::SetInlineFillColor:
>+ return get<SetInlineFillColor>().apply(context);
>+ case ItemType::SetInlineStrokeColor:
>+ return get<SetInlineStrokeColor>().apply(context);
>+ case ItemType::SetStrokeThickness:
>+ return get<SetStrokeThickness>().apply(context);
>+ case ItemType::SetState:
>+ return get<SetState>().apply(context);
>+ case ItemType::SetLineCap:
>+ return get<SetLineCap>().apply(context);
>+ case ItemType::SetLineDash:
>+ return get<SetLineDash>().apply(context);
>+ case ItemType::SetLineJoin:
>+ return get<SetLineJoin>().apply(context);
>+ case ItemType::SetMiterLimit:
>+ return get<SetMiterLimit>().apply(context);
>+ case ItemType::ClearShadow:
>+ return get<ClearShadow>().apply(context);
>+ case ItemType::Clip:
>+ return get<Clip>().apply(context);
>+ case ItemType::ClipOut:
>+ return get<ClipOut>().apply(context);
>+ case ItemType::ClipOutToPath:
>+ return get<ClipOutToPath>().apply(context);
>+ case ItemType::ClipPath:
>+ return get<ClipPath>().apply(context);
>+ case ItemType::ClipToDrawingCommands:
>+ return get<ClipToDrawingCommands>().apply(context);
>+ case ItemType::DrawGlyphs:
>+ return get<DrawGlyphs>().apply(context);
>+ case ItemType::DrawImage:
>+ return get<DrawImage>().apply(context);
>+ case ItemType::DrawTiledImage:
>+ return get<DrawTiledImage>().apply(context);
>+ case ItemType::DrawTiledScaledImage:
>+ return get<DrawTiledScaledImage>().apply(context);
>+ case ItemType::DrawImageBuffer:
>+ return get<DrawImageBuffer>().apply(context);
>+ case ItemType::DrawNativeImage:
>+ return get<DrawNativeImage>().apply(context);
>+ case ItemType::DrawPattern:
>+ return get<DrawPattern>().apply(context);
>+ case ItemType::DrawRect:
>+ return get<DrawRect>().apply(context);
>+ case ItemType::DrawLine:
>+ return get<DrawLine>().apply(context);
>+ case ItemType::DrawLinesForText:
>+ return get<DrawLinesForText>().apply(context);
>+ case ItemType::DrawDotsForDocumentMarker:
>+ return get<DrawDotsForDocumentMarker>().apply(context);
>+ case ItemType::DrawEllipse:
>+ return get<DrawEllipse>().apply(context);
>+ case ItemType::DrawPath:
>+ return get<DrawPath>().apply(context);
>+ case ItemType::DrawFocusRingPath:
>+ return get<DrawFocusRingPath>().apply(context);
>+ case ItemType::DrawFocusRingRects:
>+ return get<DrawFocusRingRects>().apply(context);
>+ case ItemType::FillRect:
>+ return get<FillRect>().apply(context);
>+ case ItemType::FillRectWithColor:
>+ return get<FillRectWithColor>().apply(context);
>+ case ItemType::FillRectWithGradient:
>+ return get<FillRectWithGradient>().apply(context);
>+ case ItemType::FillCompositedRect:
>+ return get<FillCompositedRect>().apply(context);
>+ case ItemType::FillRoundedRect:
>+ return get<FillRoundedRect>().apply(context);
>+ case ItemType::FillRectWithRoundedHole:
>+ return get<FillRectWithRoundedHole>().apply(context);
>+ case ItemType::FillInlinePath:
>+ return get<FillInlinePath>().apply(context);
>+ case ItemType::FillPath:
>+ return get<FillPath>().apply(context);
>+ case ItemType::FillEllipse:
>+ return get<FillEllipse>().apply(context);
>+ case ItemType::PutImageData:
>+ return get<PutImageData>().apply(context);
>+ case ItemType::PaintFrameForMedia:
>+ return get<PaintFrameForMedia>().apply(context);
>+ case ItemType::StrokeRect:
>+ return get<StrokeRect>().apply(context);
>+ case ItemType::StrokeInlinePath:
>+ return get<StrokeInlinePath>().apply(context);
>+ case ItemType::StrokePath:
>+ return get<StrokePath>().apply(context);
>+ case ItemType::StrokeEllipse:
>+ return get<StrokeEllipse>().apply(context);
>+ case ItemType::ClearRect:
>+ return get<ClearRect>().apply(context);
>+ case ItemType::BeginTransparencyLayer:
>+ return get<BeginTransparencyLayer>().apply(context);
>+ case ItemType::EndTransparencyLayer:
>+ return get<EndTransparencyLayer>().apply(context);
>+ case ItemType::ApplyStrokePattern:
>+ return get<ApplyStrokePattern>().apply(context);
>+ case ItemType::ApplyFillPattern:
>+ return get<ApplyFillPattern>().apply(context);
>+ case ItemType::ApplyDeviceScaleFactor:
>+ return get<ApplyDeviceScaleFactor>().apply(context);
>+ }
>+}
>+
>+void ItemHandle::destroy()
>+{
>+ switch (type()) {
>+ case ItemType::ClipOutToPath:
>+ return get<ClipOutToPath>().~ClipOutToPath();
>+ case ItemType::ClipPath:
>+ return get<ClipPath>().~ClipPath();
>+ case ItemType::ClipToDrawingCommands:
>+ return get<ClipToDrawingCommands>().~ClipToDrawingCommands();
>+ case ItemType::DrawFocusRingPath:
>+ return get<DrawFocusRingPath>().~DrawFocusRingPath();
>+ case ItemType::DrawFocusRingRects:
>+ return get<DrawFocusRingRects>().~DrawFocusRingRects();
>+ case ItemType::DrawGlyphs:
>+ return get<DrawGlyphs>().~DrawGlyphs();
>+ case ItemType::DrawImage:
>+ return get<DrawImage>().~DrawImage();
>+ case ItemType::DrawImageBuffer:
>+ return get<DrawImageBuffer>().~DrawImageBuffer();
>+ case ItemType::DrawLinesForText:
>+ return get<DrawLinesForText>().~DrawLinesForText();
>+ case ItemType::DrawNativeImage:
>+ return get<DrawNativeImage>().~DrawNativeImage();
>+ case ItemType::DrawPath:
>+ return get<DrawPath>().~DrawPath();
>+ case ItemType::DrawPattern:
>+ return get<DrawPattern>().~DrawPattern();
>+ case ItemType::DrawTiledImage:
>+ return get<DrawTiledImage>().~DrawTiledImage();
>+ case ItemType::DrawTiledScaledImage:
>+ return get<DrawTiledScaledImage>().~DrawTiledScaledImage();
>+ case ItemType::FillCompositedRect:
>+ return get<FillCompositedRect>().~FillCompositedRect();
>+ case ItemType::FillPath:
>+ return get<FillPath>().~FillPath();
>+ case ItemType::FillRectWithColor:
>+ return get<FillRectWithColor>().~FillRectWithColor();
>+ case ItemType::FillRectWithGradient:
>+ return get<FillRectWithGradient>().~FillRectWithGradient();
>+ case ItemType::FillRectWithRoundedHole:
>+ return get<FillRectWithRoundedHole>().~FillRectWithRoundedHole();
>+ case ItemType::FillRoundedRect:
>+ return get<FillRoundedRect>().~FillRoundedRect();
>+ case ItemType::PutImageData:
>+ return get<PutImageData>().~PutImageData();
>+ case ItemType::SetLineDash:
>+ return get<SetLineDash>().~SetLineDash();
>+ case ItemType::SetState:
>+ return get<SetState>().~SetState();
>+ case ItemType::StrokePath:
>+ return get<StrokePath>().~StrokePath();
>+ case ItemType::ApplyDeviceScaleFactor:
>+ case ItemType::ApplyFillPattern:
>+ case ItemType::ApplyStrokePattern:
>+ case ItemType::BeginTransparencyLayer:
>+ case ItemType::ClearRect:
>+ case ItemType::ClearShadow:
>+ case ItemType::Clip:
>+ case ItemType::ClipOut:
>+ case ItemType::ConcatenateCTM:
>+ case ItemType::DrawDotsForDocumentMarker:
>+ case ItemType::DrawEllipse:
>+ case ItemType::DrawLine:
>+ case ItemType::DrawRect:
>+ case ItemType::EndTransparencyLayer:
>+ case ItemType::FillEllipse:
>+ case ItemType::FillInlinePath:
>+ case ItemType::FillRect:
>+ case ItemType::PaintFrameForMedia:
>+ case ItemType::Restore:
>+ case ItemType::Rotate:
>+ case ItemType::Save:
>+ case ItemType::Scale:
>+ case ItemType::SetCTM:
>+ case ItemType::SetInlineFillColor:
>+ case ItemType::SetInlineFillGradient:
>+ case ItemType::SetInlineStrokeColor:
>+ case ItemType::SetLineCap:
>+ case ItemType::SetLineJoin:
>+ case ItemType::SetMiterLimit:
>+ case ItemType::SetStrokeThickness:
>+ case ItemType::StrokeEllipse:
>+ case ItemType::StrokeInlinePath:
>+ case ItemType::StrokeRect:
>+ case ItemType::Translate:
>+ break;
>+ }
>+}
>+
>+bool ItemHandle::isDrawingItem() const
>+{
>+ return WebCore::DisplayList::isDrawingItem(type());
>+}
>+
>+ItemBuffer::ItemBuffer(ItemBufferHandles&& handles)
>+ : m_readOnlyBuffers(WTFMove(handles))
>+{
>+}
>+
>+ItemBuffer::ItemBuffer() = default;
>+
>+ItemBuffer::~ItemBuffer()
>+{
>+ for (auto& item : m_nonInlineItemsInAllocatedBuffers)
>+ item.destroy();
>+
>+ for (auto* buffer : m_allocatedBuffers)
>+ free(buffer);
>+}
>+
>+ItemBuffer::ItemBuffer(ItemBuffer&& other)
>+ : m_readingClient(std::exchange(other.m_readingClient, nullptr))
>+ , m_writingClient(std::exchange(other.m_writingClient, nullptr))
>+ , m_nonInlineItemsInAllocatedBuffers(std::exchange(other.m_nonInlineItemsInAllocatedBuffers, { }))
>+ , m_allocatedBuffers(std::exchange(other.m_allocatedBuffers, { }))
>+ , m_readOnlyBuffers(std::exchange(other.m_readOnlyBuffers, { }))
>+ , m_writableBuffer(std::exchange(other.m_writableBuffer, { }))
>+ , m_writableSizeInBytes(std::exchange(other.m_writableSizeInBytes, 0))
>+{
>+}
>+
>+ItemBuffer& ItemBuffer::operator=(ItemBuffer&& other)
>+{
>+ m_readingClient = std::exchange(other.m_readingClient, nullptr);
>+ m_writingClient = std::exchange(other.m_writingClient, nullptr);
>+ m_nonInlineItemsInAllocatedBuffers = std::exchange(other.m_nonInlineItemsInAllocatedBuffers, { });
>+ m_allocatedBuffers = std::exchange(other.m_allocatedBuffers, { });
>+ m_readOnlyBuffers = std::exchange(other.m_readOnlyBuffers, { });
>+ m_writableBuffer = std::exchange(other.m_writableBuffer, { });
>+ m_writableSizeInBytes = std::exchange(other.m_writableSizeInBytes, 0);
>+ return *this;
>+}
>+
>+ItemBufferHandle ItemBuffer::createItemBuffer(size_t capacity)
>+{
>+ if (m_writingClient) {
>+ if (auto handle = m_writingClient->createItemBuffer(capacity))
>+ return handle;
>+ }
>+
>+ constexpr size_t defaultItemBufferCapacity = 1 << 10;
>+
>+ auto newBufferCapacity = std::max(capacity, defaultItemBufferCapacity);
>+ auto* buffer = reinterpret_cast<uint8_t*>(malloc(newBufferCapacity));
>+ m_allocatedBuffers.append(buffer);
>+ return { ItemBufferIdentifier::generate(), buffer, 0, newBufferCapacity };
>+}
>+
>+void ItemBuffer::forEachItemBuffer(Function<void(const ItemBufferHandle&)>&& mapFunction) const
>+{
>+ for (auto& handle : m_readOnlyBuffers)
>+ mapFunction(handle);
>+
>+ if (m_writableBuffer && m_writableSizeInBytes)
>+ mapFunction({ m_writableBuffer.identifier, m_writableBuffer.data, m_writableBuffer.offset, m_writableSizeInBytes });
>+}
>+
>+} // namespace DisplayList
>+} // namespace WebCore
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.h b/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..6afd46a750fb01b5ab6e6eb980482d1e292a6d89
>--- /dev/null
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.h
>@@ -0,0 +1,241 @@
>+/*
>+ * 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 "DisplayList.h"
>+#include "DisplayListItemType.h"
>+#include "SharedBuffer.h"
>+#include <wtf/FastMalloc.h>
>+#include <wtf/ObjectIdentifier.h>
>+
>+namespace WebCore {
>+
>+class GraphicsContext;
>+
>+namespace DisplayList {
>+
>+enum ItemBufferIdentifierType { };
>+using ItemBufferIdentifier = ObjectIdentifier<ItemBufferIdentifierType>;
>+
>+struct ItemBufferHandle {
>+ ItemBufferIdentifier identifier;
>+ uint8_t* data { nullptr };
>+ size_t offset { 0 };
>+ size_t capacity { 0 };
>+
>+ operator bool() const { return !!(*this); }
>+ bool operator!() const { return !data; }
>+
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<ItemBufferHandle> decode(Decoder&);
>+};
>+
>+using ItemBufferHandles = Vector<ItemBufferHandle, 2>;
>+
>+template<class Encoder>
>+void ItemBufferHandle::encode(Encoder& encoder) const
>+{
>+ encoder << identifier;
>+ encoder << static_cast<uint64_t>(offset);
>+ encoder << static_cast<uint64_t>(capacity);
>+}
>+
>+template<class Decoder>
>+Optional<ItemBufferHandle> ItemBufferHandle::decode(Decoder& decoder)
>+{
>+ Optional<ItemBufferIdentifier> identifier;
>+ decoder >> identifier;
>+ if (!identifier)
>+ return WTF::nullopt;
>+
>+ Optional<uint64_t> offset;
>+ decoder >> offset;
>+ if (!offset)
>+ return WTF::nullopt;
>+
>+ Optional<uint64_t> capacity;
>+ decoder >> capacity;
>+ if (!capacity)
>+ return WTF::nullopt;
>+
>+ // Encode everything except for the buffer's data pointer.
>+ return {{ *identifier, nullptr, static_cast<size_t>(*offset), static_cast<size_t>(*capacity) }};
>+}
>+
>+struct ItemHandle {
>+ uint8_t* data { nullptr };
>+
>+ ItemType type() const
>+ {
>+ return static_cast<ItemType>(data[0]);
>+ }
>+
>+ size_t size() const
>+ {
>+ return sizeof(ItemType) + sizeOfItemInBytes(type());
>+ }
>+
>+ void apply(GraphicsContext&);
>+ void destroy();
>+ bool isDrawingItem() const;
>+
>+ template<typename T> T& get() const
>+ {
>+ ASSERT(is<T>());
>+ return *reinterpret_cast<T*>(&data[sizeof(ItemType)]);
>+ }
>+
>+ template<typename T> bool is() const
>+ {
>+ return type() == T::itemType;
>+ }
>+};
>+
>+class ItemBufferWritingClient {
>+public:
>+ virtual ~ItemBufferWritingClient() = 0;
>+
>+ virtual ItemBufferHandle createItemBuffer(size_t) = 0;
>+ virtual bool requiresEncoding(ItemType) const = 0;
>+ virtual RefPtr<SharedBuffer> encodeItem(ItemHandle) const = 0;
>+};
>+
>+class ItemBufferReadingClient {
>+public:
>+ virtual ~ItemBufferReadingClient() = 0;
>+
>+ virtual bool requiresDecoding(ItemType) const = 0;
>+ virtual bool WARN_UNUSED_RETURN decodeItem(const uint8_t*, size_t, ItemHandle&) = 0;
>+};
>+
>+ItemBufferWritingClient::~ItemBufferWritingClient() { }
>+ItemBufferReadingClient::~ItemBufferReadingClient() { }
>+
>+class ItemBuffer {
>+ WTF_MAKE_NONCOPYABLE(ItemBuffer); WTF_MAKE_FAST_ALLOCATED;
>+public:
>+ friend class DisplayList;
>+
>+ WEBCORE_EXPORT ItemBuffer();
>+ WEBCORE_EXPORT ~ItemBuffer();
>+ ItemBuffer(ItemBufferHandles&&);
>+
>+ WEBCORE_EXPORT ItemBuffer(ItemBuffer&&);
>+ WEBCORE_EXPORT ItemBuffer& operator=(ItemBuffer&&);
>+
>+ size_t sizeInBytes() const
>+ {
>+ size_t result = 0;
>+ for (auto buffer : m_readOnlyBuffers)
>+ result += buffer.capacity;
>+ result += m_writableSizeInBytes;
>+ return result;
>+ }
>+
>+ bool isEmpty() const
>+ {
>+ return !m_writableSizeInBytes && m_readOnlyBuffers.isEmpty();
>+ }
>+
>+ WEBCORE_EXPORT ItemBufferHandle createItemBuffer(size_t);
>+
>+ template<typename T, class... Args> void append(Args&&... args)
>+ {
>+ constexpr auto sizeOfTypeAndItem = sizeof(ItemType) + sizeof(T);
>+
>+ if (m_writingClient && m_writingClient->requiresEncoding(T::itemType)) {
>+ uint8_t itemBuffer[sizeOfTypeAndItem];
>+ itemBuffer[0] = static_cast<uint8_t>(T::itemType);
>+ new (itemBuffer + sizeof(ItemType)) T(std::forward<Args>(args)...);
>+ if (auto sharedBuffer = m_writingClient->encodeItem({ itemBuffer })) {
>+ auto additionalCapacityForItem = sharedBuffer->size() + sizeof(ItemType) + sizeof(size_t);
>+ if (m_writableSizeInBytes + additionalCapacityForItem > m_writableBuffer.capacity) {
>+ auto lastWritableBuffer = std::exchange(m_writableBuffer, { });
>+ lastWritableBuffer.capacity = std::exchange(m_writableSizeInBytes, 0);
>+ if (lastWritableBuffer.capacity)
>+ m_readOnlyBuffers.append(WTFMove(lastWritableBuffer));
>+ m_writableBuffer = createItemBuffer(additionalCapacityForItem);
>+ }
>+
>+ m_writableBuffer.data[m_writableBuffer.offset + m_writableSizeInBytes] = static_cast<uint8_t>(T::itemType);
>+ auto* startOfDataLength = m_writableBuffer.data + m_writableBuffer.offset + m_writableSizeInBytes + sizeof(ItemType);
>+ reinterpret_cast<size_t*>(startOfDataLength)[0] = sharedBuffer->size();
>+ memcpy(startOfDataLength + sizeof(size_t), sharedBuffer->dataAsUInt8Ptr(), sharedBuffer->size());
>+ m_writableSizeInBytes += additionalCapacityForItem;
>+ }
>+ return;
>+ }
>+
>+ if (m_writableSizeInBytes + sizeOfTypeAndItem > m_writableBuffer.capacity) {
>+ auto lastWritableBuffer = std::exchange(m_writableBuffer, { });
>+ lastWritableBuffer.capacity = std::exchange(m_writableSizeInBytes, 0);
>+ if (lastWritableBuffer.capacity)
>+ m_readOnlyBuffers.append(WTFMove(lastWritableBuffer));
>+ m_writableBuffer = createItemBuffer(sizeOfTypeAndItem);
>+ }
>+
>+ auto* startOfItem = &m_writableBuffer.data[m_writableBuffer.offset + m_writableSizeInBytes];
>+ startOfItem[0] = static_cast<uint8_t>(T::itemType);
>+ new (startOfItem + sizeof(ItemType)) T(std::forward<Args>(args)...);
>+ m_writableSizeInBytes += sizeof(ItemType) + sizeOfItemInBytes(T::itemType);
>+
>+ if (!T::isInlineItem)
>+ m_nonInlineItemsInAllocatedBuffers.append({ startOfItem });
>+ }
>+
>+ void clear()
>+ {
>+ for (auto item : std::exchange(m_nonInlineItemsInAllocatedBuffers, { }))
>+ item.destroy();
>+
>+ for (auto* buffer : std::exchange(m_allocatedBuffers, { }))
>+ free(buffer);
>+
>+ m_readOnlyBuffers.clear();
>+ m_writableBuffer = { };
>+ m_writableSizeInBytes = 0;
>+ m_itemCount = 0;
>+ }
>+
>+ void setClient(ItemBufferWritingClient* client) { m_writingClient = client; }
>+ void setClient(ItemBufferReadingClient* client) { m_readingClient = client; }
>+
>+private:
>+ const ItemBufferHandles& readOnlyBuffers() const { return m_readOnlyBuffers; }
>+ void forEachItemBuffer(Function<void(const ItemBufferHandle&)>&&) const;
>+
>+ ItemBufferReadingClient* m_readingClient { nullptr };
>+ ItemBufferWritingClient* m_writingClient { nullptr };
>+ Vector<ItemHandle> m_nonInlineItemsInAllocatedBuffers;
>+ Vector<uint8_t*> m_allocatedBuffers;
>+ ItemBufferHandles m_readOnlyBuffers;
>+ ItemBufferHandle m_writableBuffer;
>+ size_t m_writableSizeInBytes { 0 };
>+ size_t m_itemCount { 0 };
>+};
>+
>+} // namespace DisplayList
>+} // namespace WebCore
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListItemType.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListItemType.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..c29a79873bfc2922428b76f5434d0de587adda0f
>--- /dev/null
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItemType.cpp
>@@ -0,0 +1,287 @@
>+/*
>+ * Copyright (C) 2020 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ * notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ * notice, this list of conditions and the following disclaimer in the
>+ * documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "DisplayListItemType.h"
>+
>+namespace WebCore {
>+namespace DisplayList {
>+
>+size_t sizeOfItemInBytes(ItemType type)
>+{
>+ switch (type) {
>+ case ItemType::Save:
>+ return sizeof(Save);
>+ case ItemType::Restore:
>+ return sizeof(Restore);
>+ case ItemType::Translate:
>+ return sizeof(Translate);
>+ case ItemType::Rotate:
>+ return sizeof(Rotate);
>+ case ItemType::Scale:
>+ return sizeof(Scale);
>+ case ItemType::ConcatenateCTM:
>+ return sizeof(ConcatenateCTM);
>+ case ItemType::SetCTM:
>+ return sizeof(SetCTM);
>+ case ItemType::SetInlineFillGradient:
>+ return sizeof(SetInlineFillGradient);
>+ case ItemType::SetInlineFillColor:
>+ return sizeof(SetInlineFillColor);
>+ case ItemType::SetInlineStrokeColor:
>+ return sizeof(SetInlineStrokeColor);
>+ case ItemType::SetStrokeThickness:
>+ return sizeof(SetStrokeThickness);
>+ case ItemType::SetState:
>+ return sizeof(SetState);
>+ case ItemType::SetLineCap:
>+ return sizeof(SetLineCap);
>+ case ItemType::SetLineDash:
>+ return sizeof(SetLineDash);
>+ case ItemType::SetLineJoin:
>+ return sizeof(SetLineJoin);
>+ case ItemType::SetMiterLimit:
>+ return sizeof(SetMiterLimit);
>+ case ItemType::ClearShadow:
>+ return sizeof(ClearShadow);
>+ case ItemType::Clip:
>+ return sizeof(Clip);
>+ case ItemType::ClipOut:
>+ return sizeof(ClipOut);
>+ case ItemType::ClipOutToPath:
>+ return sizeof(ClipOutToPath);
>+ case ItemType::ClipPath:
>+ return sizeof(ClipPath);
>+ case ItemType::ClipToDrawingCommands:
>+ return sizeof(ClipToDrawingCommands);
>+ case ItemType::DrawGlyphs:
>+ return sizeof(DrawGlyphs);
>+ case ItemType::DrawImage:
>+ return sizeof(DrawImage);
>+ case ItemType::DrawTiledImage:
>+ return sizeof(DrawTiledImage);
>+ case ItemType::DrawTiledScaledImage:
>+ return sizeof(DrawTiledScaledImage);
>+ case ItemType::DrawImageBuffer:
>+ return sizeof(DrawImageBuffer);
>+ case ItemType::DrawNativeImage:
>+ return sizeof(DrawNativeImage);
>+ case ItemType::DrawPattern:
>+ return sizeof(DrawPattern);
>+ case ItemType::DrawRect:
>+ return sizeof(DrawRect);
>+ case ItemType::DrawLine:
>+ return sizeof(DrawLine);
>+ case ItemType::DrawLinesForText:
>+ return sizeof(DrawLinesForText);
>+ case ItemType::DrawDotsForDocumentMarker:
>+ return sizeof(DrawDotsForDocumentMarker);
>+ case ItemType::DrawEllipse:
>+ return sizeof(DrawEllipse);
>+ case ItemType::DrawPath:
>+ return sizeof(DrawPath);
>+ case ItemType::DrawFocusRingPath:
>+ return sizeof(DrawFocusRingPath);
>+ case ItemType::DrawFocusRingRects:
>+ return sizeof(DrawFocusRingRects);
>+ case ItemType::FillRect:
>+ return sizeof(FillRect);
>+ case ItemType::FillRectWithColor:
>+ return sizeof(FillRectWithColor);
>+ case ItemType::FillRectWithGradient:
>+ return sizeof(FillRectWithGradient);
>+ case ItemType::FillCompositedRect:
>+ return sizeof(FillCompositedRect);
>+ case ItemType::FillRoundedRect:
>+ return sizeof(FillRoundedRect);
>+ case ItemType::FillRectWithRoundedHole:
>+ return sizeof(FillRectWithRoundedHole);
>+ case ItemType::FillInlinePath:
>+ return sizeof(FillInlinePath);
>+ case ItemType::FillPath:
>+ return sizeof(FillPath);
>+ case ItemType::FillEllipse:
>+ return sizeof(FillEllipse);
>+ case ItemType::PutImageData:
>+ return sizeof(PutImageData);
>+ case ItemType::PaintFrameForMedia:
>+ return sizeof(PaintFrameForMedia);
>+ case ItemType::StrokeRect:
>+ return sizeof(StrokeRect);
>+ case ItemType::StrokeInlinePath:
>+ return sizeof(StrokeInlinePath);
>+ case ItemType::StrokePath:
>+ return sizeof(StrokePath);
>+ case ItemType::StrokeEllipse:
>+ return sizeof(StrokeEllipse);
>+ case ItemType::ClearRect:
>+ return sizeof(ClearRect);
>+ case ItemType::BeginTransparencyLayer:
>+ return sizeof(BeginTransparencyLayer);
>+ case ItemType::EndTransparencyLayer:
>+ return sizeof(EndTransparencyLayer);
>+ case ItemType::ApplyStrokePattern:
>+ return sizeof(ApplyStrokePattern);
>+ case ItemType::ApplyFillPattern:
>+ return sizeof(ApplyFillPattern);
>+ case ItemType::ApplyDeviceScaleFactor:
>+ return sizeof(ApplyDeviceScaleFactor);
>+ }
>+}
>+
>+bool isDrawingItem(ItemType type)
>+{
>+ switch (type) {
>+ case ItemType::ApplyDeviceScaleFactor:
>+ case ItemType::ApplyFillPattern:
>+ case ItemType::ApplyStrokePattern:
>+ case ItemType::ClearShadow:
>+ case ItemType::Clip:
>+ case ItemType::ClipOut:
>+ case ItemType::ClipOutToPath:
>+ case ItemType::ClipPath:
>+ case ItemType::ClipToDrawingCommands:
>+ case ItemType::ConcatenateCTM:
>+ case ItemType::Restore:
>+ case ItemType::Rotate:
>+ case ItemType::Save:
>+ case ItemType::Scale:
>+ case ItemType::SetCTM:
>+ case ItemType::SetInlineFillColor:
>+ case ItemType::SetInlineFillGradient:
>+ case ItemType::SetInlineStrokeColor:
>+ case ItemType::SetLineCap:
>+ case ItemType::SetLineDash:
>+ case ItemType::SetLineJoin:
>+ case ItemType::SetMiterLimit:
>+ case ItemType::SetState:
>+ case ItemType::SetStrokeThickness:
>+ case ItemType::Translate:
>+ return false;
>+ case ItemType::BeginTransparencyLayer:
>+ case ItemType::ClearRect:
>+ case ItemType::DrawDotsForDocumentMarker:
>+ case ItemType::DrawEllipse:
>+ case ItemType::DrawFocusRingPath:
>+ case ItemType::DrawFocusRingRects:
>+ case ItemType::DrawGlyphs:
>+ case ItemType::DrawImage:
>+ case ItemType::DrawImageBuffer:
>+ case ItemType::DrawLine:
>+ case ItemType::DrawLinesForText:
>+ case ItemType::DrawNativeImage:
>+ case ItemType::DrawPath:
>+ case ItemType::DrawPattern:
>+ case ItemType::DrawRect:
>+ case ItemType::DrawTiledImage:
>+ case ItemType::DrawTiledScaledImage:
>+ case ItemType::EndTransparencyLayer:
>+ case ItemType::FillCompositedRect:
>+ case ItemType::FillEllipse:
>+ case ItemType::FillInlinePath:
>+ case ItemType::FillPath:
>+ case ItemType::FillRect:
>+ case ItemType::FillRectWithColor:
>+ case ItemType::FillRectWithGradient:
>+ case ItemType::FillRectWithRoundedHole:
>+ case ItemType::FillRoundedRect:
>+ case ItemType::PaintFrameForMedia:
>+ case ItemType::PutImageData:
>+ case ItemType::StrokeEllipse:
>+ case ItemType::StrokeInlinePath:
>+ case ItemType::StrokePath:
>+ case ItemType::StrokeRect:
>+ return true;
>+ }
>+}
>+
>+bool isInlineItem(ItemType type)
>+{
>+ switch (type) {
>+ case ItemType::ClipOutToPath:
>+ case ItemType::ClipPath:
>+ case ItemType::ClipToDrawingCommands:
>+ case ItemType::DrawFocusRingPath:
>+ case ItemType::DrawFocusRingRects:
>+ case ItemType::DrawGlyphs:
>+ case ItemType::DrawImage:
>+ case ItemType::DrawImageBuffer:
>+ case ItemType::DrawLinesForText:
>+ case ItemType::DrawNativeImage:
>+ case ItemType::DrawPath:
>+ case ItemType::DrawPattern:
>+ case ItemType::DrawTiledImage:
>+ case ItemType::DrawTiledScaledImage:
>+ case ItemType::FillCompositedRect:
>+ case ItemType::FillPath:
>+ case ItemType::FillRectWithColor:
>+ case ItemType::FillRectWithGradient:
>+ case ItemType::FillRectWithRoundedHole:
>+ case ItemType::FillRoundedRect:
>+ case ItemType::PutImageData:
>+ case ItemType::SetLineDash:
>+ case ItemType::SetState:
>+ case ItemType::StrokePath:
>+ return false;
>+ case ItemType::ApplyDeviceScaleFactor:
>+ case ItemType::ApplyFillPattern:
>+ case ItemType::ApplyStrokePattern:
>+ case ItemType::BeginTransparencyLayer:
>+ case ItemType::ClearRect:
>+ case ItemType::ClearShadow:
>+ case ItemType::Clip:
>+ case ItemType::ClipOut:
>+ case ItemType::ConcatenateCTM:
>+ case ItemType::DrawDotsForDocumentMarker:
>+ case ItemType::DrawEllipse:
>+ case ItemType::DrawLine:
>+ case ItemType::DrawRect:
>+ case ItemType::EndTransparencyLayer:
>+ case ItemType::FillEllipse:
>+ case ItemType::FillInlinePath:
>+ case ItemType::FillRect:
>+ case ItemType::PaintFrameForMedia:
>+ case ItemType::Restore:
>+ case ItemType::Rotate:
>+ case ItemType::Save:
>+ case ItemType::Scale:
>+ case ItemType::SetCTM:
>+ case ItemType::SetInlineFillColor:
>+ case ItemType::SetInlineFillGradient:
>+ case ItemType::SetInlineStrokeColor:
>+ case ItemType::SetLineCap:
>+ case ItemType::SetLineJoin:
>+ case ItemType::SetMiterLimit:
>+ case ItemType::SetStrokeThickness:
>+ case ItemType::StrokeEllipse:
>+ case ItemType::StrokeInlinePath:
>+ case ItemType::StrokeRect:
>+ case ItemType::Translate:
>+ return true;
>+ }
>+}
>+
>+} // namespace DisplayList
>+} // namespace WebCore
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListItemType.h b/Source/WebCore/platform/graphics/displaylists/DisplayListItemType.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..ce4f8579ac877bb883b49633327fa78c23171cc6
>--- /dev/null
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItemType.h
>@@ -0,0 +1,103 @@
>+/*
>+ * 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
>+
>+namespace WebCore {
>+namespace DisplayList {
>+
>+enum class ItemType : uint8_t {
>+ Save,
>+ Restore,
>+ Translate,
>+ Rotate,
>+ Scale,
>+ ConcatenateCTM,
>+ SetCTM,
>+ SetInlineFillGradient,
>+ SetInlineFillColor,
>+ SetInlineStrokeColor,
>+ SetStrokeThickness,
>+ SetState,
>+ SetLineCap,
>+ SetLineDash,
>+ SetLineJoin,
>+ SetMiterLimit,
>+ ClearShadow,
>+ Clip,
>+ ClipOut,
>+ ClipOutToPath,
>+ ClipPath,
>+ ClipToDrawingCommands,
>+ DrawGlyphs,
>+ DrawImage,
>+ DrawTiledImage,
>+ DrawTiledScaledImage,
>+ DrawImageBuffer,
>+ DrawNativeImage,
>+ DrawPattern,
>+ DrawRect,
>+ DrawLine,
>+ DrawLinesForText,
>+ DrawDotsForDocumentMarker,
>+ DrawEllipse,
>+ DrawPath,
>+ DrawFocusRingPath,
>+ DrawFocusRingRects,
>+ FillRect,
>+ FillRectWithColor,
>+ FillRectWithGradient,
>+ FillCompositedRect,
>+ FillRoundedRect,
>+ FillRectWithRoundedHole,
>+#if ENABLE(INLINE_PATH_DATA)
>+ FillInlinePath,
>+#endif
>+ FillPath,
>+ FillEllipse,
>+ PutImageData,
>+ PaintFrameForMedia,
>+ StrokeRect,
>+#if ENABLE(INLINE_PATH_DATA)
>+ StrokeInlinePath,
>+#endif
>+ StrokePath,
>+ StrokeEllipse,
>+ ClearRect,
>+ BeginTransparencyLayer,
>+ EndTransparencyLayer,
>+#if USE(CG)
>+ ApplyStrokePattern, // FIXME: should not be a recorded item.
>+ ApplyFillPattern, // FIXME: should not be a recorded item.
>+#endif
>+ ApplyDeviceScaleFactor,
>+};
>+
>+WEBCORE_EXPORT size_t sizeOfItemInBytes(ItemType);
>+WEBCORE_EXPORT bool isInlineItem(ItemType);
>+WEBCORE_EXPORT bool isDrawingItem(ItemType);
>+
>+} // namespace DisplayList
>+} // namespace WebCore
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp
>index 47c762e1a6197d6c8b8c45fa9cfdc05a03dee51b..60ae6268133f37eeeedcb1b54f51346c534a391a 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp
>@@ -52,195 +52,16 @@ WTF::CString Item::description() const
> }
> #endif
> 
>-Item::Item(ItemType type)
>- : m_type(type)
>-{
>-}
>-
>-Item::~Item() = default;
>-
>-size_t Item::sizeInBytes(const Item& item)
>-{
>- switch (item.type()) {
>- case ItemType::Save:
>- return sizeof(downcast<Save>(item));
>- case ItemType::Restore:
>- return sizeof(downcast<Restore>(item));
>- case ItemType::Translate:
>- return sizeof(downcast<Translate>(item));
>- case ItemType::Rotate:
>- return sizeof(downcast<Rotate>(item));
>- case ItemType::Scale:
>- return sizeof(downcast<Scale>(item));
>- case ItemType::SetCTM:
>- return sizeof(downcast<SetCTM>(item));
>- case ItemType::ConcatenateCTM:
>- return sizeof(downcast<ConcatenateCTM>(item));
>- case ItemType::SetInlineFillGradient:
>- return sizeof(downcast<SetInlineFillGradient>(item));
>- case ItemType::SetInlineFillColor:
>- return sizeof(downcast<SetInlineFillColor>(item));
>- case ItemType::SetInlineStrokeColor:
>- return sizeof(downcast<SetInlineStrokeColor>(item));
>- case ItemType::SetStrokeThickness:
>- return sizeof(downcast<SetStrokeThickness>(item));
>- case ItemType::SetState:
>- return sizeof(downcast<SetState>(item));
>- case ItemType::SetLineCap:
>- return sizeof(downcast<SetLineCap>(item));
>- case ItemType::SetLineDash:
>- return sizeof(downcast<SetLineDash>(item));
>- case ItemType::SetLineJoin:
>- return sizeof(downcast<SetLineJoin>(item));
>- case ItemType::SetMiterLimit:
>- return sizeof(downcast<SetMiterLimit>(item));
>- case ItemType::ClearShadow:
>- return sizeof(downcast<ClearShadow>(item));
>- case ItemType::Clip:
>- return sizeof(downcast<Clip>(item));
>- case ItemType::ClipOut:
>- return sizeof(downcast<ClipOut>(item));
>- case ItemType::ClipOutToPath:
>- return sizeof(downcast<ClipOutToPath>(item));
>- case ItemType::ClipPath:
>- return sizeof(downcast<ClipPath>(item));
>- case ItemType::ClipToDrawingCommands:
>- return sizeof(downcast<ClipToDrawingCommands>(item));
>- case ItemType::DrawGlyphs:
>- return sizeof(downcast<DrawGlyphs>(item));
>- case ItemType::DrawImage:
>- return sizeof(downcast<DrawImage>(item));
>- case ItemType::DrawTiledImage:
>- return sizeof(downcast<DrawTiledImage>(item));
>- case ItemType::DrawTiledScaledImage:
>- return sizeof(downcast<DrawTiledScaledImage>(item));
>- case ItemType::DrawImageBuffer:
>- return sizeof(downcast<DrawImageBuffer>(item));
>- case ItemType::DrawNativeImage:
>- return sizeof(downcast<DrawNativeImage>(item));
>- case ItemType::DrawPattern:
>- return sizeof(downcast<DrawPattern>(item));
>- case ItemType::DrawRect:
>- return sizeof(downcast<DrawRect>(item));
>- case ItemType::DrawLine:
>- return sizeof(downcast<DrawLine>(item));
>- case ItemType::DrawLinesForText:
>- return sizeof(downcast<DrawLinesForText>(item));
>- case ItemType::DrawDotsForDocumentMarker:
>- return sizeof(downcast<DrawDotsForDocumentMarker>(item));
>- case ItemType::DrawEllipse:
>- return sizeof(downcast<DrawEllipse>(item));
>- case ItemType::DrawPath:
>- return sizeof(downcast<DrawPath>(item));
>- case ItemType::DrawFocusRingPath:
>- return sizeof(downcast<DrawFocusRingPath>(item));
>- case ItemType::DrawFocusRingRects:
>- return sizeof(downcast<DrawFocusRingRects>(item));
>- case ItemType::FillRect:
>- return sizeof(downcast<FillRect>(item));
>- case ItemType::FillRectWithColor:
>- return sizeof(downcast<FillRectWithColor>(item));
>- case ItemType::FillRectWithGradient:
>- return sizeof(downcast<FillRectWithGradient>(item));
>- case ItemType::FillCompositedRect:
>- return sizeof(downcast<FillCompositedRect>(item));
>- case ItemType::FillRoundedRect:
>- return sizeof(downcast<FillRoundedRect>(item));
>- case ItemType::FillRectWithRoundedHole:
>- return sizeof(downcast<FillRectWithRoundedHole>(item));
>-#if ENABLE(INLINE_PATH_DATA)
>- case ItemType::FillInlinePath:
>- return sizeof(downcast<FillInlinePath>(item));
>-#endif
>- case ItemType::FillPath:
>- return sizeof(downcast<FillPath>(item));
>- case ItemType::FillEllipse:
>- return sizeof(downcast<FillEllipse>(item));
>- case ItemType::PutImageData:
>- return sizeof(downcast<PutImageData>(item));
>- case ItemType::PaintFrameForMedia:
>- return sizeof(downcast<PaintFrameForMedia>(item));
>- case ItemType::StrokeRect:
>- return sizeof(downcast<StrokeRect>(item));
>-#if ENABLE(INLINE_PATH_DATA)
>- case ItemType::StrokeInlinePath:
>- return sizeof(downcast<StrokeInlinePath>(item));
>-#endif
>- case ItemType::StrokePath:
>- return sizeof(downcast<StrokePath>(item));
>- case ItemType::StrokeEllipse:
>- return sizeof(downcast<StrokeEllipse>(item));
>- case ItemType::ClearRect:
>- return sizeof(downcast<ClearRect>(item));
>- case ItemType::BeginTransparencyLayer:
>- return sizeof(downcast<BeginTransparencyLayer>(item));
>- case ItemType::EndTransparencyLayer:
>- return sizeof(downcast<EndTransparencyLayer>(item));
>-#if USE(CG)
>- case ItemType::ApplyStrokePattern:
>- return sizeof(downcast<ApplyStrokePattern>(item));
>- case ItemType::ApplyFillPattern:
>- return sizeof(downcast<ApplyFillPattern>(item));
>-#endif
>- case ItemType::ApplyDeviceScaleFactor:
>- return sizeof(downcast<ApplyDeviceScaleFactor>(item));
>- }
>- return 0;
>-}
>-
>-static TextStream& operator<<(TextStream& ts, const DrawingItem& item)
>-{
>- ts.startGroup();
>- ts << "extent ";
>- if (item.extentKnown())
>- ts << item.extent();
>- else
>- ts << "unknown";
>- 
>- ts.endGroup();
>- return ts;
>-}
>-
>-DrawingItem::DrawingItem(ItemType type)
>- : Item(type)
>-{
>-}
>-
>-DrawingItem::~DrawingItem() = default;
>-
>-Save::Save()
>- : Item(ItemType::Save)
>-{
>-}
>-
>-Save::~Save() = default;
>-
> void Save::apply(GraphicsContext& context) const
> {
> context.save();
> }
> 
>-Restore::Restore()
>- : Item(ItemType::Restore)
>-{
>-}
>-
>-Restore::~Restore() = default;
>-
> void Restore::apply(GraphicsContext& context) const
> {
> context.restore();
> }
> 
>-Translate::Translate(float x, float y)
>- : Item(ItemType::Translate)
>- , m_x(x)
>- , m_y(y)
>-{
>-}
>-
>-Translate::~Translate() = default;
>-
> void Translate::apply(GraphicsContext& context) const
> {
> context.translate(m_x, m_y);
>@@ -254,14 +75,6 @@ static TextStream& operator<<(TextStream& ts, const Translate& item)
> return ts;
> }
> 
>-Rotate::Rotate(float angle)
>- : Item(ItemType::Rotate)
>- , m_angle(angle)
>-{
>-}
>-
>-Rotate::~Rotate() = default;
>-
> void Rotate::apply(GraphicsContext& context) const
> {
> context.rotate(m_angle);
>@@ -274,14 +87,6 @@ static TextStream& operator<<(TextStream& ts, const Rotate& item)
> return ts;
> }
> 
>-Scale::Scale(const FloatSize& size)
>- : Item(ItemType::Scale)
>- , m_size(size)
>-{
>-}
>-
>-Scale::~Scale() = default;
>-
> void Scale::apply(GraphicsContext& context) const
> {
> context.scale(m_size);
>@@ -294,14 +99,6 @@ static TextStream& operator<<(TextStream& ts, const Scale& item)
> return ts;
> }
> 
>-SetCTM::SetCTM(const AffineTransform& transform)
>- : Item(ItemType::SetCTM)
>- , m_transform(transform)
>-{
>-}
>-
>-SetCTM::~SetCTM() = default;
>-
> void SetCTM::apply(GraphicsContext& context) const
> {
> context.setCTM(m_transform);
>@@ -314,14 +111,6 @@ static TextStream& operator<<(TextStream& ts, const SetCTM& item)
> return ts;
> }
> 
>-ConcatenateCTM::ConcatenateCTM(const AffineTransform& transform)
>- : Item(ItemType::ConcatenateCTM)
>- , m_transform(transform)
>-{
>-}
>-
>-ConcatenateCTM::~ConcatenateCTM() = default;
>-
> void ConcatenateCTM::apply(GraphicsContext& context) const
> {
> context.concatCTM(m_transform);
>@@ -335,8 +124,7 @@ static TextStream& operator<<(TextStream& ts, const ConcatenateCTM& item)
> }
> 
> SetInlineFillGradient::SetInlineFillGradient(const Gradient& gradient)
>- : Item(ItemType::SetInlineFillGradient)
>- , m_data(gradient.data())
>+ : m_data(gradient.data())
> , m_gradientSpaceTransformation(gradient.gradientSpaceTransform())
> , m_spreadMethod(gradient.spreadMethod())
> , m_colorStopCount(static_cast<uint8_t>(gradient.stops().size()))
>@@ -358,14 +146,8 @@ Ref<Gradient> SetInlineFillGradient::gradient() const
> return gradient;
> }
> 
>-Ref<SetInlineFillGradient> SetInlineFillGradient::create(const Gradient& gradient)
>-{
>- return adoptRef(*new SetInlineFillGradient(gradient));
>-}
>-
> SetInlineFillGradient::SetInlineFillGradient(float offsets[maxColorStopCount], SRGBA<uint8_t> colors[maxColorStopCount], const Gradient::Data& data, const AffineTransform& gradientSpaceTransformation, GradientSpreadMethod spreadMethod, uint8_t colorStopCount)
>- : Item(ItemType::SetInlineFillGradient)
>- , m_data(data)
>+ : m_data(data)
> , m_gradientSpaceTransformation(gradientSpaceTransformation)
> , m_spreadMethod(spreadMethod)
> , m_colorStopCount(colorStopCount)
>@@ -377,8 +159,6 @@ SetInlineFillGradient::SetInlineFillGradient(float offsets[maxColorStopCount], S
> }
> }
> 
>-SetInlineFillGradient::~SetInlineFillGradient() = default;
>-
> void SetInlineFillGradient::apply(GraphicsContext& context) const
> {
> if (m_colorStopCount <= maxColorStopCount)
>@@ -404,13 +184,6 @@ static TextStream& operator<<(TextStream& ts, const SetInlineFillGradient&)
> return ts;
> }
> 
>-Ref<SetInlineFillColor> SetInlineFillColor::create(SRGBA<uint8_t> colorData)
>-{
>- return adoptRef(*new SetInlineFillColor(colorData));
>-}
>-
>-SetInlineFillColor::~SetInlineFillColor() = default;
>-
> void SetInlineFillColor::apply(GraphicsContext& context) const
> {
> context.setFillColor(color());
>@@ -422,13 +195,6 @@ static TextStream& operator<<(TextStream& ts, const SetInlineFillColor& state)
> return ts;
> }
> 
>-Ref<SetInlineStrokeColor> SetInlineStrokeColor::create(SRGBA<uint8_t> colorData)
>-{
>- return adoptRef(*new SetInlineStrokeColor(colorData));
>-}
>-
>-SetInlineStrokeColor::~SetInlineStrokeColor() = default;
>-
> void SetInlineStrokeColor::apply(GraphicsContext& context) const
> {
> context.setStrokeColor(color());
>@@ -440,13 +206,6 @@ static TextStream& operator<<(TextStream& ts, const SetInlineStrokeColor& state)
> return ts;
> }
> 
>-Ref<SetStrokeThickness> SetStrokeThickness::create(float thickness)
>-{
>- return adoptRef(*new SetStrokeThickness(thickness));
>-}
>-
>-SetStrokeThickness::~SetStrokeThickness() = default;
>-
> void SetStrokeThickness::apply(GraphicsContext& context) const
> {
> context.setStrokeThickness(m_thickness);
>@@ -459,19 +218,15 @@ static TextStream& operator<<(TextStream& ts, const SetStrokeThickness& state)
> }
> 
> SetState::SetState(const GraphicsContextState& state, GraphicsContextState::StateChangeFlags flags)
>- : Item(ItemType::SetState)
>- , m_state(state, flags)
>+ : m_state(state, flags)
> {
> }
> 
> SetState::SetState(const GraphicsContextStateChange& stateChange)
>- : Item(ItemType::SetState)
>- , m_state(stateChange)
>+ : m_state(stateChange)
> {
> }
> 
>-SetState::~SetState() = default;
>-
> void SetState::apply(GraphicsContext& context) const
> {
> m_state.apply(context);
>@@ -483,14 +238,6 @@ static TextStream& operator<<(TextStream& ts, const SetState& state)
> return ts;
> }
> 
>-SetLineCap::SetLineCap(LineCap lineCap)
>- : Item(ItemType::SetLineCap)
>- , m_lineCap(lineCap)
>-{
>-}
>-
>-SetLineCap::~SetLineCap() = default;
>-
> void SetLineCap::apply(GraphicsContext& context) const
> {
> context.setLineCap(m_lineCap);
>@@ -502,15 +249,6 @@ static TextStream& operator<<(TextStream& ts, const SetLineCap& lineCap)
> return ts;
> }
> 
>-SetLineDash::SetLineDash(const DashArray& dashArray, float dashOffset)
>- : Item(ItemType::SetLineDash)
>- , m_dashArray(dashArray)
>- , m_dashOffset(dashOffset)
>-{
>-}
>-
>-SetLineDash::~SetLineDash() = default;
>-
> void SetLineDash::apply(GraphicsContext& context) const
> {
> context.setLineDash(m_dashArray, m_dashOffset);
>@@ -523,14 +261,6 @@ static TextStream& operator<<(TextStream& ts, const SetLineDash& lineDash)
> return ts;
> }
> 
>-SetLineJoin::SetLineJoin(LineJoin lineJoin)
>- : Item(ItemType::SetLineJoin)
>- , m_lineJoin(lineJoin)
>-{
>-}
>-
>-SetLineJoin::~SetLineJoin() = default;
>-
> void SetLineJoin::apply(GraphicsContext& context) const
> {
> context.setLineJoin(m_lineJoin);
>@@ -542,14 +272,6 @@ static TextStream& operator<<(TextStream& ts, const SetLineJoin& lineJoin)
> return ts;
> }
> 
>-SetMiterLimit::SetMiterLimit(float miterLimit)
>- : Item(ItemType::SetMiterLimit)
>- , m_miterLimit(miterLimit)
>-{
>-}
>-
>-SetMiterLimit::~SetMiterLimit() = default;
>-
> void SetMiterLimit::apply(GraphicsContext& context) const
> {
> context.setMiterLimit(m_miterLimit);
>@@ -561,26 +283,11 @@ static TextStream& operator<<(TextStream& ts, const SetMiterLimit& miterLimit)
> return ts;
> }
> 
>-ClearShadow::ClearShadow()
>- : Item(ItemType::ClearShadow)
>-{
>-}
>-
>-ClearShadow::~ClearShadow() = default;
>-
> void ClearShadow::apply(GraphicsContext& context) const
> {
> context.clearShadow();
> }
> 
>-Clip::Clip(const FloatRect& rect)
>- : Item(ItemType::Clip)
>- , m_rect(rect)
>-{
>-}
>-
>-Clip::~Clip() = default;
>-
> void Clip::apply(GraphicsContext& context) const
> {
> context.clip(m_rect);
>@@ -592,14 +299,6 @@ static TextStream& operator<<(TextStream& ts, const Clip& item)
> return ts;
> }
> 
>-ClipOut::ClipOut(const FloatRect& rect)
>- : Item(ItemType::ClipOut)
>- , m_rect(rect)
>-{
>-}
>-
>-ClipOut::~ClipOut() = default;
>-
> void ClipOut::apply(GraphicsContext& context) const
> {
> context.clipOut(m_rect);
>@@ -611,14 +310,6 @@ static TextStream& operator<<(TextStream& ts, const ClipOut& item)
> return ts;
> }
> 
>-ClipOutToPath::ClipOutToPath(const Path& path)
>- : Item(ItemType::ClipOutToPath)
>- , m_path(path)
>-{
>-}
>-
>-ClipOutToPath::~ClipOutToPath() = default;
>-
> void ClipOutToPath::apply(GraphicsContext& context) const
> {
> context.clipOut(m_path);
>@@ -630,15 +321,6 @@ static TextStream& operator<<(TextStream& ts, const ClipOutToPath& item)
> return ts;
> }
> 
>-ClipPath::ClipPath(const Path& path, WindRule windRule)
>- : Item(ItemType::ClipPath)
>- , m_path(path)
>- , m_windRule(windRule)
>-{
>-}
>-
>-ClipPath::~ClipPath() = default;
>-
> void ClipPath::apply(GraphicsContext& context) const
> {
> context.clipPath(m_path, m_windRule);
>@@ -651,16 +333,6 @@ static TextStream& operator<<(TextStream& ts, const ClipPath& item)
> return ts;
> }
> 
>-ClipToDrawingCommands::ClipToDrawingCommands(const FloatRect& destination, ColorSpace colorSpace, DisplayList&& drawingCommands)
>- : Item(ItemType::ClipToDrawingCommands)
>- , m_destination(destination)
>- , m_colorSpace(colorSpace)
>- , m_drawingCommands(WTFMove(drawingCommands))
>-{
>-}
>-
>-ClipToDrawingCommands::~ClipToDrawingCommands() = default;
>-
> void ClipToDrawingCommands::apply(GraphicsContext& context) const
> {
> context.clipToDrawingCommands(m_destination, m_colorSpace, [&] (GraphicsContext& clippingContext) {
>@@ -673,13 +345,11 @@ static TextStream& operator<<(TextStream& ts, const ClipToDrawingCommands& item)
> {
> ts.dumpProperty("destination", item.destination());
> ts.dumpProperty("color-space", item.colorSpace());
>- ts.dumpProperty("drawing-commands-count", item.drawingCommands().itemCount());
> return ts;
> }
> 
> DrawGlyphs::DrawGlyphs(const Font& font, Vector<GlyphBufferGlyph, 128>&& glyphs, Vector<GlyphBufferAdvance, 128>&& advances, const FloatPoint& localAnchor, FontSmoothingMode smoothingMode)
>- : DrawingItem(ItemType::DrawGlyphs)
>- , m_font(const_cast<Font&>(font))
>+ : m_font(makeRefPtr(const_cast<Font&>(font)))
> , m_glyphs(WTFMove(glyphs))
> , m_advances(WTFMove(advances))
> , m_localAnchor(localAnchor)
>@@ -689,8 +359,7 @@ DrawGlyphs::DrawGlyphs(const Font& font, Vector<GlyphBufferGlyph, 128>&& glyphs,
> }
> 
> DrawGlyphs::DrawGlyphs(const Font& font, const GlyphBufferGlyph* glyphs, const GlyphBufferAdvance* advances, unsigned count, const FloatPoint& localAnchor, FontSmoothingMode smoothingMode)
>- : DrawingItem(ItemType::DrawGlyphs)
>- , m_font(const_cast<Font&>(font))
>+ : m_font(makeRefPtr(const_cast<Font&>(font)))
> , m_localAnchor(localAnchor)
> , m_smoothingMode(smoothingMode)
> {
>@@ -703,19 +372,17 @@ DrawGlyphs::DrawGlyphs(const Font& font, const GlyphBufferGlyph* glyphs, const G
> computeBounds();
> }
> 
>-DrawGlyphs::~DrawGlyphs() = default;
>-
> inline GlyphBuffer DrawGlyphs::generateGlyphBuffer() const
> {
> GlyphBuffer result;
> for (size_t i = 0; i < m_glyphs.size(); ++i)
>- result.add(m_glyphs[i], m_font.get(), m_advances[i], GlyphBuffer::noOffset);
>+ result.add(m_glyphs[i], *m_font, m_advances[i], GlyphBuffer::noOffset);
> return result;
> }
> 
> void DrawGlyphs::apply(GraphicsContext& context) const
> {
>- context.drawGlyphs(m_font, generateGlyphBuffer(), 0, m_glyphs.size(), anchorPoint(), m_smoothingMode);
>+ context.drawGlyphs(*m_font, generateGlyphBuffer(), 0, m_glyphs.size(), anchorPoint(), m_smoothingMode);
> }
> 
> void DrawGlyphs::computeBounds()
>@@ -735,14 +402,8 @@ void DrawGlyphs::computeBounds()
> }
> }
> 
>-Optional<FloatRect> DrawGlyphs::localBounds(const GraphicsContext&) const
>-{
>- return m_bounds;
>-}
>-
> static TextStream& operator<<(TextStream& ts, const DrawGlyphs& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> // FIXME: dump more stuff.
> ts.dumpProperty("local-anchor", item.localAnchor());
> ts.dumpProperty("anchor-point", item.anchorPoint());
>@@ -751,17 +412,6 @@ static TextStream& operator<<(TextStream& ts, const DrawGlyphs& item)
> return ts;
> }
> 
>-DrawImage::DrawImage(Image& image, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& imagePaintingOptions)
>- : DrawingItem(ItemType::DrawImage)
>- , m_image(image)
>- , m_destination(destination)
>- , m_source(source)
>- , m_imagePaintingOptions(imagePaintingOptions)
>-{
>-}
>-
>-DrawImage::~DrawImage() = default;
>-
> void DrawImage::apply(GraphicsContext& context) const
> {
> context.drawImage(m_image.get(), m_destination, m_source, m_imagePaintingOptions);
>@@ -769,26 +419,12 @@ void DrawImage::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const DrawImage& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("image", item.image());
> ts.dumpProperty("source-rect", item.source());
> ts.dumpProperty("dest-rect", item.destination());
> return ts;
> }
> 
>-DrawTiledImage::DrawTiledImage(Image& image, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions& imagePaintingOptions)
>- : DrawingItem(ItemType::DrawTiledImage)
>- , m_image(image)
>- , m_destination(destination)
>- , m_source(source)
>- , m_tileSize(tileSize)
>- , m_spacing(spacing)
>- , m_imagePaintingOptions(imagePaintingOptions)
>-{
>-}
>-
>-DrawTiledImage::~DrawTiledImage() = default;
>-
> void DrawTiledImage::apply(GraphicsContext& context) const
> {
> context.drawTiledImage(m_image.get(), m_destination, m_source, m_tileSize, m_spacing, m_imagePaintingOptions);
>@@ -796,7 +432,6 @@ void DrawTiledImage::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const DrawTiledImage& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("image", item.image());
> ts.dumpProperty("source-point", item.source());
> ts.dumpProperty("dest-rect", item.destination());
>@@ -805,20 +440,6 @@ static TextStream& operator<<(TextStream& ts, const DrawTiledImage& item)
> return ts;
> }
> 
>-DrawTiledScaledImage::DrawTiledScaledImage(Image& image, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions& imagePaintingOptions)
>- : DrawingItem(ItemType::DrawTiledScaledImage)
>- , m_image(image)
>- , m_destination(destination)
>- , m_source(source)
>- , m_tileScaleFactor(tileScaleFactor)
>- , m_hRule(hRule)
>- , m_vRule(vRule)
>- , m_imagePaintingOptions(imagePaintingOptions)
>-{
>-}
>-
>-DrawTiledScaledImage::~DrawTiledScaledImage() = default;
>-
> void DrawTiledScaledImage::apply(GraphicsContext& context) const
> {
> context.drawTiledImage(m_image.get(), m_destination, m_source, m_tileScaleFactor, m_hRule, m_vRule, m_imagePaintingOptions);
>@@ -826,24 +447,12 @@ void DrawTiledScaledImage::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const DrawTiledScaledImage& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("image", item.image());
> ts.dumpProperty("source-rect", item.source());
> ts.dumpProperty("dest-rect", item.destination());
> return ts;
> }
> 
>-DrawImageBuffer::DrawImageBuffer(RenderingResourceIdentifier renderingResourceIdentifier, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>- : DrawingItem(ItemType::DrawImageBuffer)
>- , m_renderingResourceIdentifier(renderingResourceIdentifier)
>- , m_destinationRect(destRect)
>- , m_srcRect(srcRect)
>- , m_options(options)
>-{
>-}
>-
>-DrawImageBuffer::~DrawImageBuffer() = default;
>-
> void DrawImageBuffer::apply(GraphicsContext&) const
> {
> // Should be handled by the delegate.
>@@ -852,7 +461,6 @@ void DrawImageBuffer::apply(GraphicsContext&) const
> 
> static TextStream& operator<<(TextStream& ts, const DrawImageBuffer& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("remote-resource-identifier", item.renderingResourceIdentifier());
> ts.dumpProperty("source-rect", item.source());
> ts.dumpProperty("dest-rect", item.destinationRect());
>@@ -860,8 +468,7 @@ static TextStream& operator<<(TextStream& ts, const DrawImageBuffer& item)
> }
> 
> DrawNativeImage::DrawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>- : DrawingItem(ItemType::DrawNativeImage)
>- , m_image(image)
>+ : m_image(image)
> , m_imageSize(imageSize)
> , m_destinationRect(destRect)
> , m_srcRect(srcRect)
>@@ -869,8 +476,6 @@ DrawNativeImage::DrawNativeImage(const NativeImagePtr& image, const FloatSize& i
> {
> }
> 
>-DrawNativeImage::~DrawNativeImage() = default;
>-
> void DrawNativeImage::apply(GraphicsContext& context) const
> {
> context.drawNativeImage(m_image, m_imageSize, m_destinationRect, m_srcRect, m_options);
>@@ -878,7 +483,6 @@ void DrawNativeImage::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const DrawNativeImage& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> // FIXME: dump more stuff.
> ts.dumpProperty("source-rect", item.source());
> ts.dumpProperty("dest-rect", item.destinationRect());
>@@ -886,8 +490,7 @@ static TextStream& operator<<(TextStream& ts, const DrawNativeImage& item)
> }
> 
> DrawPattern::DrawPattern(Image& image, const FloatRect& destRect, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& options)
>- : DrawingItem(ItemType::DrawPattern)
>- , m_image(image)
>+ : m_image(image)
> , m_patternTransform(patternTransform)
> , m_tileRect(tileRect)
> , m_destination(destRect)
>@@ -897,8 +500,6 @@ DrawPattern::DrawPattern(Image& image, const FloatRect& destRect, const FloatRec
> {
> }
> 
>-DrawPattern::~DrawPattern() = default;
>-
> void DrawPattern::apply(GraphicsContext& context) const
> {
> context.drawPattern(m_image.get(), m_destination, m_tileRect, m_patternTransform, m_phase, m_spacing, m_options);
>@@ -906,7 +507,6 @@ void DrawPattern::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const DrawPattern& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("image", item.image());
> ts.dumpProperty("pattern-transform", item.patternTransform());
> ts.dumpProperty("tile-rect", item.tileRect());
>@@ -916,15 +516,6 @@ static TextStream& operator<<(TextStream& ts, const DrawPattern& item)
> return ts;
> }
> 
>-DrawRect::DrawRect(const FloatRect& rect, float borderThickness)
>- : DrawingItem(ItemType::DrawRect)
>- , m_rect(rect)
>- , m_borderThickness(borderThickness)
>-{
>-}
>-
>-DrawRect::~DrawRect() = default;
>-
> void DrawRect::apply(GraphicsContext& context) const
> {
> context.drawRect(m_rect, m_borderThickness);
>@@ -932,21 +523,11 @@ void DrawRect::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const DrawRect& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("rect", item.rect());
> ts.dumpProperty("border-thickness", item.borderThickness());
> return ts;
> }
> 
>-DrawLine::DrawLine(const FloatPoint& point1, const FloatPoint& point2)
>- : DrawingItem(ItemType::DrawLine)
>- , m_point1(point1)
>- , m_point2(point2)
>-{
>-}
>-
>-DrawLine::~DrawLine() = default;
>-
> Optional<FloatRect> DrawLine::localBounds(const GraphicsContext&) const
> {
> FloatRect bounds;
>@@ -961,15 +542,13 @@ void DrawLine::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const DrawLine& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("point-1", item.point1());
> ts.dumpProperty("point-2", item.point2());
> return ts;
> }
> 
> DrawLinesForText::DrawLinesForText(const FloatPoint& blockLocation, const FloatSize& localAnchor, float thickness, const DashArray& widths, bool printing, bool doubleLines)
>- : DrawingItem(ItemType::DrawLinesForText)
>- , m_blockLocation(blockLocation)
>+ : m_blockLocation(blockLocation)
> , m_localAnchor(localAnchor)
> , m_widths(widths)
> , m_thickness(thickness)
>@@ -978,8 +557,6 @@ DrawLinesForText::DrawLinesForText(const FloatPoint& blockLocation, const FloatS
> {
> }
> 
>-DrawLinesForText::~DrawLinesForText() = default;
>-
> void DrawLinesForText::apply(GraphicsContext& context) const
> {
> context.drawLinesForText(point(), m_thickness, m_widths, m_printing, m_doubleLines);
>@@ -999,7 +576,6 @@ Optional<FloatRect> DrawLinesForText::localBounds(const GraphicsContext&) const
> 
> static TextStream& operator<<(TextStream& ts, const DrawLinesForText& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("block-location", item.blockLocation());
> ts.dumpProperty("local-anchor", item.localAnchor());
> ts.dumpProperty("point", item.point());
>@@ -1011,15 +587,6 @@ static TextStream& operator<<(TextStream& ts, const DrawLinesForText& item)
> return ts;
> }
> 
>-DrawDotsForDocumentMarker::DrawDotsForDocumentMarker(const FloatRect& rect, DocumentMarkerLineStyle style)
>- : DrawingItem(ItemType::DrawDotsForDocumentMarker)
>- , m_rect(rect)
>- , m_style(style)
>-{
>-}
>-
>-DrawDotsForDocumentMarker::~DrawDotsForDocumentMarker() = default;
>-
> void DrawDotsForDocumentMarker::apply(GraphicsContext& context) const
> {
> context.drawDotsForDocumentMarker(m_rect, m_style);
>@@ -1032,19 +599,10 @@ Optional<FloatRect> DrawDotsForDocumentMarker::localBounds(const GraphicsContext
> 
> static TextStream& operator<<(TextStream& ts, const DrawDotsForDocumentMarker& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("rect", item.rect());
> return ts;
> }
> 
>-DrawEllipse::DrawEllipse(const FloatRect& rect)
>- : DrawingItem(ItemType::DrawEllipse)
>- , m_rect(rect)
>-{
>-}
>-
>-DrawEllipse::~DrawEllipse() = default;
>-
> void DrawEllipse::apply(GraphicsContext& context) const
> {
> context.drawEllipse(m_rect);
>@@ -1056,14 +614,6 @@ static TextStream& operator<<(TextStream& ts, const DrawEllipse& item)
> return ts;
> }
> 
>-DrawPath::DrawPath(const Path& path)
>- : DrawingItem(ItemType::DrawPath)
>- , m_path(path)
>-{
>-}
>-
>-DrawPath::~DrawPath() = default;
>-
> void DrawPath::apply(GraphicsContext& context) const
> {
> #if USE(CG)
>@@ -1073,24 +623,12 @@ void DrawPath::apply(GraphicsContext& context) const
> #endif
> }
> 
>-static TextStream& operator<<(TextStream& ts, const DrawPath& item)
>+static TextStream& operator<<(TextStream& ts, const DrawPath&)
> {
>- ts << static_cast<const DrawingItem&>(item);
>-// ts.dumpProperty("path", item.path()); // FIXME: add logging for paths.
>+ // FIXME: add logging for paths.
> return ts;
> }
> 
>-DrawFocusRingPath::DrawFocusRingPath(const Path& path, float width, float offset, const Color& color)
>- : DrawingItem(ItemType::DrawFocusRingPath)
>- , m_path(path)
>- , m_width(width)
>- , m_offset(offset)
>- , m_color(color)
>-{
>-}
>-
>-DrawFocusRingPath::~DrawFocusRingPath() = default;
>-
> void DrawFocusRingPath::apply(GraphicsContext& context) const
> {
> context.drawFocusRing(m_path, m_width, m_offset, m_color);
>@@ -1105,7 +643,6 @@ Optional<FloatRect> DrawFocusRingPath::localBounds(const GraphicsContext&) const
> 
> static TextStream& operator<<(TextStream& ts, const DrawFocusRingPath& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> // ts.dumpProperty("path", item.path()); // FIXME: add logging for paths.
> ts.dumpProperty("width", item.width());
> ts.dumpProperty("offset", item.offset());
>@@ -1114,16 +651,13 @@ static TextStream& operator<<(TextStream& ts, const DrawFocusRingPath& item)
> }
> 
> DrawFocusRingRects::DrawFocusRingRects(const Vector<FloatRect>& rects, float width, float offset, const Color& color)
>- : DrawingItem(ItemType::DrawFocusRingRects)
>- , m_rects(rects)
>+ : m_rects(rects)
> , m_width(width)
> , m_offset(offset)
> , m_color(color)
> {
> }
> 
>-DrawFocusRingRects::~DrawFocusRingRects() = default;
>-
> void DrawFocusRingRects::apply(GraphicsContext& context) const
> {
> context.drawFocusRing(m_rects, m_width, m_offset, m_color);
>@@ -1140,7 +674,6 @@ Optional<FloatRect> DrawFocusRingRects::localBounds(const GraphicsContext&) cons
> 
> static TextStream& operator<<(TextStream& ts, const DrawFocusRingRects& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("rects", item.rects());
> ts.dumpProperty("width", item.width());
> ts.dumpProperty("offset", item.offset());
>@@ -1148,14 +681,6 @@ static TextStream& operator<<(TextStream& ts, const DrawFocusRingRects& item)
> return ts;
> }
> 
>-FillRect::FillRect(const FloatRect& rect)
>- : DrawingItem(ItemType::FillRect)
>- , m_rect(rect)
>-{
>-}
>-
>-FillRect::~FillRect() = default;
>-
> void FillRect::apply(GraphicsContext& context) const
> {
> context.fillRect(m_rect);
>@@ -1163,20 +688,10 @@ void FillRect::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const FillRect& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("rect", item.rect());
> return ts;
> }
> 
>-FillRectWithColor::FillRectWithColor(const FloatRect& rect, const Color& color)
>- : DrawingItem(ItemType::FillRectWithColor)
>- , m_rect(rect)
>- , m_color(color)
>-{
>-}
>-
>-FillRectWithColor::~FillRectWithColor() = default;
>-
> void FillRectWithColor::apply(GraphicsContext& context) const
> {
> context.fillRect(m_rect, m_color);
>@@ -1184,21 +699,17 @@ void FillRectWithColor::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const FillRectWithColor& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("rect", item.rect());
> ts.dumpProperty("color", item.color());
> return ts;
> }
> 
> FillRectWithGradient::FillRectWithGradient(const FloatRect& rect, Gradient& gradient)
>- : DrawingItem(ItemType::FillRectWithGradient)
>- , m_rect(rect)
>+ : m_rect(rect)
> , m_gradient(gradient)
> {
> }
> 
>-FillRectWithGradient::~FillRectWithGradient() = default;
>-
> void FillRectWithGradient::apply(GraphicsContext& context) const
> {
> context.fillRect(m_rect, m_gradient.get());
>@@ -1206,23 +717,11 @@ void FillRectWithGradient::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const FillRectWithGradient& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> // FIXME: log gradient.
> ts.dumpProperty("rect", item.rect());
> return ts;
> }
> 
>-FillCompositedRect::FillCompositedRect(const FloatRect& rect, const Color& color, CompositeOperator op, BlendMode blendMode)
>- : DrawingItem(ItemType::FillCompositedRect)
>- , m_rect(rect)
>- , m_color(color)
>- , m_op(op)
>- , m_blendMode(blendMode)
>-{
>-}
>-
>-FillCompositedRect::~FillCompositedRect() = default;
>-
> void FillCompositedRect::apply(GraphicsContext& context) const
> {
> context.fillRect(m_rect, m_color, m_op, m_blendMode);
>@@ -1230,7 +729,6 @@ void FillCompositedRect::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const FillCompositedRect& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("rect", item.rect());
> ts.dumpProperty("color", item.color());
> ts.dumpProperty("composite-operation", item.compositeOperator());
>@@ -1238,16 +736,6 @@ static TextStream& operator<<(TextStream& ts, const FillCompositedRect& item)
> return ts;
> }
> 
>-FillRoundedRect::FillRoundedRect(const FloatRoundedRect& rect, const Color& color, BlendMode blendMode)
>- : DrawingItem(ItemType::FillRoundedRect)
>- , m_rect(rect)
>- , m_color(color)
>- , m_blendMode(blendMode)
>-{
>-}
>-
>-FillRoundedRect::~FillRoundedRect() = default;
>-
> void FillRoundedRect::apply(GraphicsContext& context) const
> {
> context.fillRoundedRect(m_rect, m_color, m_blendMode);
>@@ -1255,23 +743,12 @@ void FillRoundedRect::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const FillRoundedRect& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("rect", item.roundedRect());
> ts.dumpProperty("color", item.color());
> ts.dumpProperty("blend-mode", item.blendMode());
> return ts;
> }
> 
>-FillRectWithRoundedHole::FillRectWithRoundedHole(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color& color)
>- : DrawingItem(ItemType::FillRectWithRoundedHole)
>- , m_rect(rect)
>- , m_roundedHoleRect(roundedHoleRect)
>- , m_color(color)
>-{
>-}
>-
>-FillRectWithRoundedHole::~FillRectWithRoundedHole() = default;
>-
> void FillRectWithRoundedHole::apply(GraphicsContext& context) const
> {
> context.fillRectWithRoundedHole(m_rect, m_roundedHoleRect, m_color);
>@@ -1279,7 +756,6 @@ void FillRectWithRoundedHole::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const FillRectWithRoundedHole& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("rect", item.rect());
> ts.dumpProperty("rounded-hole-rect", item.roundedHoleRect());
> ts.dumpProperty("color", item.color());
>@@ -1288,14 +764,6 @@ static TextStream& operator<<(TextStream& ts, const FillRectWithRoundedHole& ite
> 
> #if ENABLE(INLINE_PATH_DATA)
> 
>-FillInlinePath::FillInlinePath(const InlinePathData& pathData)
>- : DrawingItem(ItemType::FillInlinePath)
>- , m_pathData(pathData)
>-{
>-}
>-
>-FillInlinePath::~FillInlinePath() = default;
>-
> void FillInlinePath::apply(GraphicsContext& context) const
> {
> context.fillPath(path());
>@@ -1303,21 +771,12 @@ void FillInlinePath::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const FillInlinePath& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("path", item.path());
> return ts;
> }
> 
> #endif // ENABLE(INLINE_PATH_DATA)
> 
>-FillPath::FillPath(const Path& path)
>- : DrawingItem(ItemType::FillPath)
>- , m_path(path)
>-{
>-}
>-
>-FillPath::~FillPath() = default;
>-
> void FillPath::apply(GraphicsContext& context) const
> {
> context.fillPath(m_path);
>@@ -1325,19 +784,10 @@ void FillPath::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const FillPath& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("path", item.path());
> return ts;
> }
> 
>-FillEllipse::FillEllipse(const FloatRect& rect)
>- : DrawingItem(ItemType::FillEllipse)
>- , m_rect(rect)
>-{
>-}
>-
>-FillEllipse::~FillEllipse() = default;
>-
> void FillEllipse::apply(GraphicsContext& context) const
> {
> context.fillEllipse(m_rect);
>@@ -1345,14 +795,12 @@ void FillEllipse::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const FillEllipse& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("rect", item.rect());
> return ts;
> }
> 
> PutImageData::PutImageData(AlphaPremultiplication inputFormat, const ImageData& imageData, const IntRect& srcRect, const IntPoint& destPoint, AlphaPremultiplication destFormat)
>- : DrawingItem(ItemType::PutImageData)
>- , m_srcRect(srcRect)
>+ : m_srcRect(srcRect)
> , m_destPoint(destPoint)
> , m_imageData(imageData.deepClone()) // This copy is actually required to preserve the semantics of putImageData().
> , m_inputFormat(inputFormat)
>@@ -1361,8 +809,7 @@ PutImageData::PutImageData(AlphaPremultiplication inputFormat, const ImageData&
> }
> 
> PutImageData::PutImageData(AlphaPremultiplication inputFormat, Ref<ImageData>&& imageData, const IntRect& srcRect, const IntPoint& destPoint, AlphaPremultiplication destFormat)
>- : DrawingItem(ItemType::PutImageData)
>- , m_srcRect(srcRect)
>+ : m_srcRect(srcRect)
> , m_destPoint(destPoint)
> , m_imageData(WTFMove(imageData))
> , m_inputFormat(inputFormat)
>@@ -1370,8 +817,6 @@ PutImageData::PutImageData(AlphaPremultiplication inputFormat, Ref<ImageData>&&
> {
> }
> 
>-PutImageData::~PutImageData() = default;
>-
> void PutImageData::apply(GraphicsContext&) const
> {
> // Should be handled by the delegate.
>@@ -1380,7 +825,6 @@ void PutImageData::apply(GraphicsContext&) const
> 
> static TextStream& operator<<(TextStream& ts, const PutImageData& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("inputFormat", item.inputFormat());
> ts.dumpProperty("imageDataSize", item.imageData().size());
> ts.dumpProperty("srcRect", item.srcRect());
>@@ -1389,32 +833,12 @@ static TextStream& operator<<(TextStream& ts, const PutImageData& item)
> return ts;
> }
> 
>-Ref<PaintFrameForMedia> PaintFrameForMedia::create(MediaPlayer& player, const FloatRect& destination)
>-{
>- return adoptRef(*new PaintFrameForMedia(player, destination));
>-}
>-
>-Ref<PaintFrameForMedia> PaintFrameForMedia::create(MediaPlayerIdentifier identifier, const FloatRect& destination)
>-{
>- return adoptRef(*new PaintFrameForMedia(identifier, destination));
>-}
>-
> PaintFrameForMedia::PaintFrameForMedia(MediaPlayer& player, const FloatRect& destination)
>- : DrawingItem(ItemType::PaintFrameForMedia)
>- , m_identifier(player.identifier())
>+ : m_identifier(player.identifier())
> , m_destination(destination)
> {
> }
> 
>-PaintFrameForMedia::PaintFrameForMedia(MediaPlayerIdentifier identifier, const FloatRect& destination)
>- : DrawingItem(ItemType::PaintFrameForMedia)
>- , m_identifier(identifier)
>- , m_destination(destination)
>-{
>-}
>-
>-PaintFrameForMedia::~PaintFrameForMedia() = default;
>-
> void PaintFrameForMedia::apply(GraphicsContext&) const
> {
> // Should be handled by the delegate.
>@@ -1423,20 +847,10 @@ void PaintFrameForMedia::apply(GraphicsContext&) const
> 
> static TextStream& operator<<(TextStream& ts, const PaintFrameForMedia& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("destination", item.destination());
> return ts;
> }
> 
>-StrokeRect::StrokeRect(const FloatRect& rect, float lineWidth)
>- : DrawingItem(ItemType::StrokeRect)
>- , m_rect(rect)
>- , m_lineWidth(lineWidth)
>-{
>-}
>-
>-StrokeRect::~StrokeRect() = default;
>-
> Optional<FloatRect> StrokeRect::localBounds(const GraphicsContext&) const
> {
> FloatRect bounds = m_rect;
>@@ -1451,7 +865,6 @@ void StrokeRect::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const StrokeRect& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("rect", item.rect());
> ts.dumpProperty("line-width", item.lineWidth());
> return ts;
>@@ -1474,19 +887,10 @@ void StrokePath::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const StrokePath& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("path", item.path());
> return ts;
> }
> 
>-StrokeEllipse::StrokeEllipse(const FloatRect& rect)
>- : DrawingItem(ItemType::StrokeEllipse)
>- , m_rect(rect)
>-{
>-}
>-
>-StrokeEllipse::~StrokeEllipse() = default;
>-
> Optional<FloatRect> StrokeEllipse::localBounds(const GraphicsContext& context) const
> {
> float strokeThickness = context.strokeThickness();
>@@ -1503,7 +907,6 @@ void StrokeEllipse::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const StrokeEllipse& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("rect", item.rect());
> return ts;
> }
>@@ -1527,37 +930,12 @@ void StrokeInlinePath::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const StrokeInlinePath& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("path", item.path());
> return ts;
> }
> 
>-StrokeInlinePath::StrokeInlinePath(const InlinePathData& pathData)
>- : DrawingItem(ItemType::StrokeInlinePath)
>- , m_pathData(pathData)
>-{
>-}
>-
>-StrokeInlinePath::~StrokeInlinePath() = default;
>-
> #endif // ENABLE(INLINE_PATH_DATA)
> 
>-StrokePath::StrokePath(const Path& path)
>- : DrawingItem(ItemType::StrokePath)
>- , m_path(path)
>-{
>-}
>-
>-StrokePath::~StrokePath() = default;
>-
>-ClearRect::ClearRect(const FloatRect& rect)
>- : DrawingItem(ItemType::ClearRect)
>- , m_rect(rect)
>-{
>-}
>-
>-ClearRect::~ClearRect() = default;
>-
> void ClearRect::apply(GraphicsContext& context) const
> {
> context.clearRect(m_rect);
>@@ -1565,19 +943,10 @@ void ClearRect::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const ClearRect& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("rect", item.rect());
> return ts;
> }
> 
>-BeginTransparencyLayer::BeginTransparencyLayer(float opacity)
>- : DrawingItem(ItemType::BeginTransparencyLayer)
>- , m_opacity(opacity)
>-{
>-}
>-
>-BeginTransparencyLayer::~BeginTransparencyLayer() = default;
>-
> void BeginTransparencyLayer::apply(GraphicsContext& context) const
> {
> context.beginTransparencyLayer(m_opacity);
>@@ -1585,57 +954,28 @@ void BeginTransparencyLayer::apply(GraphicsContext& context) const
> 
> static TextStream& operator<<(TextStream& ts, const BeginTransparencyLayer& item)
> {
>- ts << static_cast<const DrawingItem&>(item);
> ts.dumpProperty("opacity", item.opacity());
> return ts;
> }
> 
>-EndTransparencyLayer::EndTransparencyLayer()
>- : DrawingItem(ItemType::EndTransparencyLayer)
>-{
>-}
>-
>-EndTransparencyLayer::~EndTransparencyLayer() = default;
>-
> void EndTransparencyLayer::apply(GraphicsContext& context) const
> {
> context.endTransparencyLayer();
> }
> 
> #if USE(CG)
>-ApplyStrokePattern::ApplyStrokePattern()
>- : Item(ItemType::ApplyStrokePattern)
>-{
>-}
>-
>-ApplyStrokePattern::~ApplyStrokePattern() = default;
> 
> void ApplyStrokePattern::apply(GraphicsContext& context) const
> {
> context.applyStrokePattern();
> }
> 
>-ApplyFillPattern::ApplyFillPattern()
>- : Item(ItemType::ApplyFillPattern)
>-{
>-}
>-
>-ApplyFillPattern::~ApplyFillPattern() = default;
>-
> void ApplyFillPattern::apply(GraphicsContext& context) const
> {
> context.applyFillPattern();
> }
> #endif
> 
>-ApplyDeviceScaleFactor::ApplyDeviceScaleFactor(float scaleFactor)
>- : Item(ItemType::ApplyDeviceScaleFactor)
>- , m_scaleFactor(scaleFactor)
>-{
>-}
>-
>-ApplyDeviceScaleFactor::~ApplyDeviceScaleFactor() = default;
>-
> void ApplyDeviceScaleFactor::apply(GraphicsContext& context) const
> {
> context.applyDeviceScaleFactor(m_scaleFactor);
>@@ -1647,7 +987,7 @@ static TextStream& operator<<(TextStream& ts, const ApplyDeviceScaleFactor& item
> return ts;
> }
> 
>-static TextStream& operator<<(TextStream& ts, const ItemType& type)
>+static TextStream& operator<<(TextStream& ts, ItemType type)
> {
> switch (type) {
> case ItemType::Save: ts << "save"; break;
>@@ -1718,172 +1058,170 @@ static TextStream& operator<<(TextStream& ts, const ItemType& type)
> return ts;
> }
> 
>-TextStream& operator<<(TextStream& ts, const Item& item)
>+TextStream& operator<<(TextStream& ts, ItemHandle item)
> {
>- TextStream::GroupScope group(ts);
> ts << item.type();
> 
>- // FIXME: Make a macro which takes a macro for all these enumeration switches
> switch (item.type()) {
> case ItemType::Translate:
>- ts << downcast<Translate>(item);
>+ ts << item.get<Translate>();
> break;
> case ItemType::Rotate:
>- ts << downcast<Rotate>(item);
>+ ts << item.get<Rotate>();
> break;
> case ItemType::Scale:
>- ts << downcast<Scale>(item);
>+ ts << item.get<Scale>();
> break;
> case ItemType::SetCTM:
>- ts << downcast<SetCTM>(item);
>+ ts << item.get<SetCTM>();
> break;
> case ItemType::ConcatenateCTM:
>- ts << downcast<ConcatenateCTM>(item);
>+ ts << item.get<ConcatenateCTM>();
> break;
> case ItemType::SetInlineFillGradient:
>- ts << downcast<SetInlineFillGradient>(item);
>+ ts << item.get<SetInlineFillGradient>();
> break;
> case ItemType::SetInlineFillColor:
>- ts << downcast<SetInlineFillColor>(item);
>+ ts << item.get<SetInlineFillColor>();
> break;
> case ItemType::SetInlineStrokeColor:
>- ts << downcast<SetInlineStrokeColor>(item);
>+ ts << item.get<SetInlineStrokeColor>();
> break;
> case ItemType::SetStrokeThickness:
>- ts << downcast<SetStrokeThickness>(item);
>+ ts << item.get<SetStrokeThickness>();
> break;
> case ItemType::SetState:
>- ts << downcast<SetState>(item);
>+ ts << item.get<SetState>();
> break;
> case ItemType::SetLineCap:
>- ts << downcast<SetLineCap>(item);
>+ ts << item.get<SetLineCap>();
> break;
> case ItemType::SetLineDash:
>- ts << downcast<SetLineDash>(item);
>+ ts << item.get<SetLineDash>();
> break;
> case ItemType::SetLineJoin:
>- ts << downcast<SetLineJoin>(item);
>+ ts << item.get<SetLineJoin>();
> break;
> case ItemType::SetMiterLimit:
>- ts << downcast<SetMiterLimit>(item);
>+ ts << item.get<SetMiterLimit>();
> break;
> case ItemType::Clip:
>- ts << downcast<Clip>(item);
>+ ts << item.get<Clip>();
> break;
> case ItemType::ClipOut:
>- ts << downcast<ClipOut>(item);
>+ ts << item.get<ClipOut>();
> break;
> case ItemType::ClipOutToPath:
>- ts << downcast<ClipOutToPath>(item);
>+ ts << item.get<ClipOutToPath>();
> break;
> case ItemType::ClipPath:
>- ts << downcast<ClipPath>(item);
>+ ts << item.get<ClipPath>();
> break;
> case ItemType::ClipToDrawingCommands:
>- ts << downcast<ClipToDrawingCommands>(item);
>+ ts << item.get<ClipToDrawingCommands>();
> break;
> case ItemType::DrawGlyphs:
>- ts << downcast<DrawGlyphs>(item);
>+ ts << item.get<DrawGlyphs>();
> break;
> case ItemType::DrawImage:
>- ts << downcast<DrawImage>(item);
>+ ts << item.get<DrawImage>();
> break;
> case ItemType::DrawTiledImage:
>- ts << downcast<DrawTiledImage>(item);
>+ ts << item.get<DrawTiledImage>();
> break;
> case ItemType::DrawTiledScaledImage:
>- ts << downcast<DrawTiledScaledImage>(item);
>+ ts << item.get<DrawTiledScaledImage>();
> break;
> case ItemType::DrawImageBuffer:
>- ts << downcast<DrawImageBuffer>(item);
>+ ts << item.get<DrawImageBuffer>();
> break;
> case ItemType::DrawNativeImage:
>- ts << downcast<DrawNativeImage>(item);
>+ ts << item.get<DrawNativeImage>();
> break;
> case ItemType::DrawPattern:
>- ts << downcast<DrawPattern>(item);
>+ ts << item.get<DrawPattern>();
> break;
> case ItemType::DrawRect:
>- ts << downcast<DrawRect>(item);
>+ ts << item.get<DrawRect>();
> break;
> case ItemType::DrawLine:
>- ts << downcast<DrawLine>(item);
>+ ts << item.get<DrawLine>();
> break;
> case ItemType::DrawLinesForText:
>- ts << downcast<DrawLinesForText>(item);
>+ ts << item.get<DrawLinesForText>();
> break;
> case ItemType::DrawDotsForDocumentMarker:
>- ts << downcast<DrawDotsForDocumentMarker>(item);
>+ ts << item.get<DrawDotsForDocumentMarker>();
> break;
> case ItemType::DrawEllipse:
>- ts << downcast<DrawEllipse>(item);
>+ ts << item.get<DrawEllipse>();
> break;
> case ItemType::DrawPath:
>- ts << downcast<DrawPath>(item);
>+ ts << item.get<DrawPath>();
> break;
> case ItemType::DrawFocusRingPath:
>- ts << downcast<DrawFocusRingPath>(item);
>+ ts << item.get<DrawFocusRingPath>();
> break;
> case ItemType::DrawFocusRingRects:
>- ts << downcast<DrawFocusRingRects>(item);
>+ ts << item.get<DrawFocusRingRects>();
> break;
> case ItemType::FillRect:
>- ts << downcast<FillRect>(item);
>+ ts << item.get<FillRect>();
> break;
> case ItemType::FillRectWithColor:
>- ts << downcast<FillRectWithColor>(item);
>+ ts << item.get<FillRectWithColor>();
> break;
> case ItemType::FillRectWithGradient:
>- ts << downcast<FillRectWithGradient>(item);
>+ ts << item.get<FillRectWithGradient>();
> break;
> case ItemType::FillCompositedRect:
>- ts << downcast<FillCompositedRect>(item);
>+ ts << item.get<FillCompositedRect>();
> break;
> case ItemType::FillRoundedRect:
>- ts << downcast<FillRoundedRect>(item);
>+ ts << item.get<FillRoundedRect>();
> break;
> case ItemType::FillRectWithRoundedHole:
>- ts << downcast<FillRectWithRoundedHole>(item);
>+ ts << item.get<FillRectWithRoundedHole>();
> break;
> #if ENABLE(INLINE_PATH_DATA)
> case ItemType::FillInlinePath:
>- ts << downcast<FillInlinePath>(item);
>+ ts << item.get<FillInlinePath>();
> break;
> #endif
> case ItemType::FillPath:
>- ts << downcast<FillPath>(item);
>+ ts << item.get<FillPath>();
> break;
> case ItemType::FillEllipse:
>- ts << downcast<FillEllipse>(item);
>+ ts << item.get<FillEllipse>();
> break;
> case ItemType::PutImageData:
>- ts << downcast<PutImageData>(item);
>+ ts << item.get<PutImageData>();
> break;
> case ItemType::PaintFrameForMedia:
>- ts << downcast<PaintFrameForMedia>(item);
>+ ts << item.get<PaintFrameForMedia>();
> break;
> case ItemType::StrokeRect:
>- ts << downcast<StrokeRect>(item);
>+ ts << item.get<StrokeRect>();
> break;
> #if ENABLE(INLINE_PATH_DATA)
> case ItemType::StrokeInlinePath:
>- ts << downcast<StrokeInlinePath>(item);
>+ ts << item.get<StrokeInlinePath>();
> break;
> #endif
> case ItemType::StrokePath:
>- ts << downcast<StrokePath>(item);
>+ ts << item.get<StrokePath>();
> break;
> case ItemType::StrokeEllipse:
>- ts << downcast<StrokeEllipse>(item);
>+ ts << item.get<StrokeEllipse>();
> break;
> case ItemType::ClearRect:
>- ts << downcast<ClearRect>(item);
>+ ts << item.get<ClearRect>();
> break;
> case ItemType::BeginTransparencyLayer:
>- ts << downcast<BeginTransparencyLayer>(item);
>+ ts << item.get<BeginTransparencyLayer>();
> break;
> case ItemType::ApplyDeviceScaleFactor:
>- ts << downcast<ApplyDeviceScaleFactor>(item);
>+ ts << item.get<ApplyDeviceScaleFactor>();
> break;
> 
> // Items with no additional data.
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>index f015be5e86606ecc2f6ce857c1f71167694fe8e3..2a4626e8eb3150d81854cfb2ae2ab63e32c0a749 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>@@ -51,320 +51,163 @@ struct ImagePaintingOptions;
> 
> namespace DisplayList {
> 
>-class DrawingItem : public Item {
>+class Save {
> public:
>- WEBCORE_EXPORT explicit DrawingItem(ItemType);
>+ static constexpr ItemType itemType = ItemType::Save;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
> 
>- WEBCORE_EXPORT virtual ~DrawingItem();
>+ void apply(GraphicsContext&) const;
> 
>- void setExtent(const FloatRect& r) { m_extent = r; }
>- const FloatRect& extent() const { return m_extent.value(); }
>-
>- bool extentKnown() const { return static_cast<bool>(m_extent); }
>-
>- // Return bounds of this drawing operation in local coordinates.
>- // Does not include effets of transform, shadow etc in the state.
>- virtual Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>-
>- // Some operations (e.g. putImageData) operate in global bounds. For these operations, override this method.
>- // If applicable, the return value needs to include the effects of shadows, clipping, etc.
>- virtual Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>-
>-private:
>- bool isDrawingItem() const override { return true; }
>-
>- Optional<FloatRect> m_extent; // In base coordinates, taking shadows and transforms into account.
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> };
> 
>-class Save : public Item {
>+class Restore {
> public:
>- static Ref<Save> create()
>- {
>- return adoptRef(*new Save);
>- }
>+ static constexpr ItemType itemType = ItemType::Restore;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
> 
>- WEBCORE_EXPORT virtual ~Save();
>+ void apply(GraphicsContext&) const;
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<Save>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT Save();
>-
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> };
> 
>-template<class Encoder>
>-void Save::encode(Encoder&) const
>-{
>-}
>-
>-template<class Decoder>
>-Optional<Ref<Save>> Save::decode(Decoder&)
>-{
>- return Save::create();
>-}
>-
>-class Restore : public Item {
>+class Translate {
> public:
>- static Ref<Restore> create()
>- {
>- return adoptRef(*new Restore);
>- }
>-
>- WEBCORE_EXPORT virtual ~Restore();
>-
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<Restore>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT Restore();
>-
>- void apply(GraphicsContext&) const override;
>-};
>-
>-template<class Encoder>
>-void Restore::encode(Encoder&) const
>-{
>-}
>-
>-template<class Decoder>
>-Optional<Ref<Restore>> Restore::decode(Decoder&)
>-{
>- return Restore::create();
>-}
>+ static constexpr ItemType itemType = ItemType::Translate;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
> 
>-class Translate : public Item {
>-public:
>- static Ref<Translate> create(float x, float y)
>+ Translate(float x, float y)
>+ : m_x(x)
>+ , m_y(y)
> {
>- return adoptRef(*new Translate(x, y));
> }
> 
>- WEBCORE_EXPORT virtual ~Translate();
>-
> float x() const { return m_x; }
> float y() const { return m_y; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<Translate>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT Translate(float x, float y);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>- float m_x;
>- float m_y;
>+private:
>+ float m_x { 0 };
>+ float m_y { 0 };
> };
> 
>-template<class Encoder>
>-void Translate::encode(Encoder& encoder) const
>-{
>- encoder << m_x;
>- encoder << m_y;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<Translate>> Translate::decode(Decoder& decoder)
>-{
>- Optional<float> x;
>- decoder >> x;
>- if (!x)
>- return WTF::nullopt;
>-
>- Optional<float> y;
>- decoder >> y;
>- if (!y)
>- return WTF::nullopt;
>-
>- return Translate::create(*x, *y);
>-}
>-
>-class Rotate : public Item {
>+class Rotate {
> public:
>- static Ref<Rotate> create(float angleInRadians)
>+ static constexpr ItemType itemType = ItemType::Rotate;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
>+
>+ Rotate(float angle)
>+ : m_angle(angle)
> {
>- return adoptRef(*new Rotate(angleInRadians));
> }
> 
>- WEBCORE_EXPORT virtual ~Rotate();
>-
> float angle() const { return m_angle; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<Rotate>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT Rotate(float angle);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>- float m_angle; // In radians.
>+private:
>+ float m_angle { 0 }; // In radians.
> };
> 
>-template<class Encoder>
>-void Rotate::encode(Encoder& encoder) const
>-{
>- encoder << m_angle;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<Rotate>> Rotate::decode(Decoder& decoder)
>-{
>- Optional<float> angle;
>- decoder >> angle;
>- if (!angle)
>- return WTF::nullopt;
>-
>- return Rotate::create(*angle);
>-}
>-
>-class Scale : public Item {
>+class Scale {
> public:
>- static Ref<Scale> create(const FloatSize& size)
>+ static constexpr ItemType itemType = ItemType::Scale;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
>+
>+ Scale(const FloatSize& size)
>+ : m_size(size)
> {
>- return adoptRef(*new Scale(size));
> }
> 
>- WEBCORE_EXPORT virtual ~Scale();
>-
> const FloatSize& amount() const { return m_size; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<Scale>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT Scale(const FloatSize&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>+private:
> FloatSize m_size;
> };
> 
>-template<class Encoder>
>-void Scale::encode(Encoder& encoder) const
>-{
>- encoder << m_size;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<Scale>> Scale::decode(Decoder& decoder)
>-{
>- Optional<FloatSize> scale;
>- decoder >> scale;
>- if (!scale)
>- return WTF::nullopt;
>-
>- return Scale::create(*scale);
>-}
>-
>-class SetCTM : public Item {
>+class SetCTM {
> public:
>- static Ref<SetCTM> create(const AffineTransform& matrix)
>+ static constexpr ItemType itemType = ItemType::SetCTM;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
>+
>+ SetCTM(const AffineTransform& transform)
>+ : m_transform(transform)
> {
>- return adoptRef(*new SetCTM(matrix));
> }
> 
>- WEBCORE_EXPORT virtual ~SetCTM();
>-
> const AffineTransform& transform() const { return m_transform; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<SetCTM>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT SetCTM(const AffineTransform&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>+private:
> AffineTransform m_transform;
> };
> 
>-template<class Encoder>
>-void SetCTM::encode(Encoder& encoder) const
>-{
>- encoder << m_transform;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<SetCTM>> SetCTM::decode(Decoder& decoder)
>-{
>- Optional<AffineTransform> transform;
>- decoder >> transform;
>- if (!transform)
>- return WTF::nullopt;
>-
>- return SetCTM::create(*transform);
>-}
>-
>-class ConcatenateCTM : public Item {
>+class ConcatenateCTM {
> public:
>- static Ref<ConcatenateCTM> create(const AffineTransform& matrix)
>+ static constexpr ItemType itemType = ItemType::ConcatenateCTM;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
>+
>+ ConcatenateCTM(const AffineTransform& transform)
>+ : m_transform(transform)
> {
>- return adoptRef(*new ConcatenateCTM(matrix));
> }
> 
>- WEBCORE_EXPORT virtual ~ConcatenateCTM();
>-
> const AffineTransform& transform() const { return m_transform; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<ConcatenateCTM>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT ConcatenateCTM(const AffineTransform&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>+private:
> AffineTransform m_transform;
> };
> 
>-template<class Encoder>
>-void ConcatenateCTM::encode(Encoder& encoder) const
>-{
>- encoder << m_transform;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<ConcatenateCTM>> ConcatenateCTM::decode(Decoder& decoder)
>-{
>- Optional<AffineTransform> transform;
>- decoder >> transform;
>- if (!transform)
>- return WTF::nullopt;
>-
>- return ConcatenateCTM::create(*transform);
>-}
>-
>-class SetInlineFillGradient : public Item {
>+class SetInlineFillGradient {
> public:
>+ static constexpr ItemType itemType = ItemType::SetInlineFillGradient;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
> static constexpr uint8_t maxColorStopCount = 4;
> 
>- static Ref<SetInlineFillGradient> create(const Gradient&);
>- static bool isInline(const Gradient&);
>-
>- virtual ~SetInlineFillGradient();
>-
>- Ref<Gradient> gradient() const;
>-
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<SetInlineFillGradient>> decode(Decoder&);
>-
>-private:
>- static Ref<SetInlineFillGradient> create(float offsets[maxColorStopCount], SRGBA<uint8_t> colors[maxColorStopCount],
>- const Gradient::Data& data, const AffineTransform& gradientSpaceTransformation, GradientSpreadMethod spreadMethod, uint8_t colorStopCount)
>- {
>- return adoptRef(*new SetInlineFillGradient(offsets, colors, data, gradientSpaceTransformation, spreadMethod, colorStopCount));
>- }
>-
>+ SetInlineFillGradient(const Gradient&);
> WEBCORE_EXPORT SetInlineFillGradient(float offsets[maxColorStopCount], SRGBA<uint8_t> colors[maxColorStopCount], const Gradient::Data&,
> const AffineTransform& gradientSpaceTransformation, GradientSpreadMethod, uint8_t colorStopCount);
> 
>- SetInlineFillGradient(const Gradient&);
>+ static bool isInline(const Gradient&);
>+ Ref<Gradient> gradient() const;
> 
>- void apply(GraphicsContext&) const override;
>+ void apply(GraphicsContext&) const;
> 
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+
>+private:
> float m_offsets[maxColorStopCount];
> SRGBA<uint8_t> m_colors[maxColorStopCount];
> Gradient::Data m_data;
>@@ -373,198 +216,79 @@ private:
> uint8_t m_colorStopCount { 0 };
> };
> 
>-template<class Encoder>
>-void SetInlineFillGradient::encode(Encoder& encoder) const
>-{
>- encoder << m_colorStopCount;
>- for (uint8_t i = 0; i < m_colorStopCount; ++i) {
>- encoder << m_offsets[i];
>- encoder << PackedColor::RGBA { m_colors[i] }.value;
>- }
>- encoder << m_data;
>- encoder << m_gradientSpaceTransformation;
>- encoder << m_spreadMethod;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<SetInlineFillGradient>> SetInlineFillGradient::decode(Decoder& decoder)
>-{
>- Optional<uint8_t> colorStopCount;
>- decoder >> colorStopCount;
>- if (!colorStopCount)
>- return WTF::nullopt;
>-
>- if (*colorStopCount > maxColorStopCount)
>- return WTF::nullopt;
>-
>- float offsets[maxColorStopCount];
>- SRGBA<uint8_t> colors[maxColorStopCount];
>- for (uint8_t i = 0; i < *colorStopCount; ++i) {
>- Optional<float> offset;
>- decoder >> offset;
>- if (!offset)
>- return WTF::nullopt;
>-
>- Optional<uint32_t> color;
>- decoder >> color;
>- if (!color)
>- return WTF::nullopt;
>-
>- colors[i] = asSRGBA(PackedColor::RGBA { *color });
>- offsets[i] = *offset;
>- }
>-
>- Optional<Gradient::Data> data;
>- decoder >> data;
>- if (!data)
>- return WTF::nullopt;
>-
>- Optional<AffineTransform> gradientSpaceTransformation;
>- decoder >> gradientSpaceTransformation;
>- if (!gradientSpaceTransformation)
>- return WTF::nullopt;
>-
>- Optional<GradientSpreadMethod> spreadMethod;
>- decoder >> spreadMethod;
>- if (!spreadMethod)
>- return WTF::nullopt;
>-
>- return { SetInlineFillGradient::create(offsets, colors, *data, *gradientSpaceTransformation, *spreadMethod, *colorStopCount) };
>-}
>-
>-class SetInlineFillColor : public Item {
>+class SetInlineFillColor {
> public:
>- WEBCORE_EXPORT static Ref<SetInlineFillColor> create(SRGBA<uint8_t>);
>+ static constexpr ItemType itemType = ItemType::SetInlineFillColor;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
> 
>- WEBCORE_EXPORT virtual ~SetInlineFillColor();
>-
>- Color color() const { return { m_colorData }; }
>-
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<SetInlineFillColor>> decode(Decoder&);
>-
>-private:
> SetInlineFillColor(SRGBA<uint8_t> colorData)
>- : Item(ItemType::SetInlineFillColor)
>- , m_colorData(colorData)
>+ : m_colorData(colorData)
> {
> }
> 
>- void apply(GraphicsContext&) const override;
>+ Color color() const { return { m_colorData }; }
>+ void apply(GraphicsContext&) const;
>+
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>+private:
> SRGBA<uint8_t> m_colorData;
> };
> 
>-template<class Encoder>
>-void SetInlineFillColor::encode(Encoder& encoder) const
>-{
>- encoder << PackedColor::RGBA { m_colorData }.value;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<SetInlineFillColor>> SetInlineFillColor::decode(Decoder& decoder)
>-{
>- Optional<uint32_t> value;
>- decoder >> value;
>- if (!value)
>- return WTF::nullopt;
>-
>- return SetInlineFillColor::create(asSRGBA(PackedColor::RGBA { *value }));
>-}
>-
>-class SetInlineStrokeColor : public Item {
>+class SetInlineStrokeColor {
> public:
>- WEBCORE_EXPORT static Ref<SetInlineStrokeColor> create(SRGBA<uint8_t>);
>-
>- WEBCORE_EXPORT virtual ~SetInlineStrokeColor();
>-
>- Color color() const { return { m_colorData }; }
>-
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<SetInlineStrokeColor>> decode(Decoder&);
>+ static constexpr ItemType itemType = ItemType::SetInlineStrokeColor;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
> 
>-private:
> SetInlineStrokeColor(SRGBA<uint8_t> colorData)
>- : Item(ItemType::SetInlineStrokeColor)
>- , m_colorData(colorData)
>+ : m_colorData(colorData)
> {
> }
> 
>- void apply(GraphicsContext&) const override;
>-
>- SRGBA<uint8_t> m_colorData;
>-};
>+ Color color() const { return { m_colorData }; }
> 
>-template<class Encoder>
>-void SetInlineStrokeColor::encode(Encoder& encoder) const
>-{
>- encoder << PackedColor::RGBA { m_colorData }.value;
>-}
>+ void apply(GraphicsContext&) const;
> 
>-template<class Decoder>
>-Optional<Ref<SetInlineStrokeColor>> SetInlineStrokeColor::decode(Decoder& decoder)
>-{
>- Optional<uint32_t> value;
>- decoder >> value;
>- if (!value)
>- return WTF::nullopt;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>- return SetInlineStrokeColor::create(asSRGBA(PackedColor::RGBA { *value }));
>-}
>+private:
>+ SRGBA<uint8_t> m_colorData;
>+};
> 
>-class SetStrokeThickness : public Item {
>+class SetStrokeThickness {
> public:
>- WEBCORE_EXPORT static Ref<SetStrokeThickness> create(float thickness);
>-
>- WEBCORE_EXPORT virtual ~SetStrokeThickness();
>+ static constexpr ItemType itemType = ItemType::SetStrokeThickness;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
> 
>- float thickness() const { return m_thickness; }
>-
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<SetStrokeThickness>> decode(Decoder&);
>-
>-private:
> SetStrokeThickness(float thickness)
>- : Item(ItemType::SetStrokeThickness)
>- , m_thickness(thickness)
>+ : m_thickness(thickness)
> {
> }
> 
>- void apply(GraphicsContext&) const override;
>-
>- float m_thickness { 0 };
>-};
>+ float thickness() const { return m_thickness; }
> 
>-template<class Encoder>
>-void SetStrokeThickness::encode(Encoder& encoder) const
>-{
>- encoder << m_thickness;
>-}
>+ void apply(GraphicsContext&) const;
> 
>-template<class Decoder>
>-Optional<Ref<SetStrokeThickness>> SetStrokeThickness::decode(Decoder& decoder)
>-{
>- Optional<float> thickness;
>- decoder >> thickness;
>- if (!thickness)
>- return WTF::nullopt;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>- return SetStrokeThickness::create(*thickness);
>-}
>+private:
>+ float m_thickness { 0 };
>+};
> 
>-class SetState : public Item {
>+class SetState {
> public:
>- static Ref<SetState> create(const GraphicsContextState& state, GraphicsContextState::StateChangeFlags flags)
>- {
>- return adoptRef(*new SetState(state, flags));
>- }
>-
>- static Ref<SetState> create(const GraphicsContextStateChange& stateChange)
>- {
>- return adoptRef(*new SetState(stateChange));
>- }
>+ static constexpr ItemType itemType = ItemType::SetState;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = false;
> 
>- WEBCORE_EXPORT virtual ~SetState();
>+ WEBCORE_EXPORT SetState(const GraphicsContextState&, GraphicsContextState::StateChangeFlags);
>+ WEBCORE_EXPORT SetState(const GraphicsContextStateChange&);
> 
> const GraphicsContextStateChange& state() const { return m_state; }
> 
>@@ -573,14 +297,14 @@ public:
> static void dumpStateChanges(WTF::TextStream&, const GraphicsContextState&, GraphicsContextState::StateChangeFlags);
> 
> template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<SetState>> decode(Decoder&);
>+ template<class Decoder> static Optional<SetState> decode(Decoder&);
> 
>-private:
>- WEBCORE_EXPORT SetState(const GraphicsContextState&, GraphicsContextState::StateChangeFlags);
>- WEBCORE_EXPORT SetState(const GraphicsContextStateChange&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>+private:
> GraphicsContextStateChange m_state;
> };
> 
>@@ -669,7 +393,7 @@ void SetState::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<SetState>> SetState::decode(Decoder& decoder)
>+Optional<SetState> SetState::decode(Decoder& decoder)
> {
> Optional<GraphicsContextState::StateChangeFlags> changeFlags;
> decoder >> changeFlags;
>@@ -896,68 +620,55 @@ Optional<Ref<SetState>> SetState::decode(Decoder& decoder)
> stateChange.m_state.shadowsIgnoreTransforms = *shadowsIgnoreTransforms;
> }
> 
>- return SetState::create(stateChange);
>+ return { stateChange };
> }
> 
>-class SetLineCap : public Item {
>+class SetLineCap {
> public:
>- static Ref<SetLineCap> create(LineCap lineCap)
>+ static constexpr ItemType itemType = ItemType::SetLineCap;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
>+
>+ SetLineCap(LineCap lineCap)
>+ : m_lineCap(lineCap)
> {
>- return adoptRef(*new SetLineCap(lineCap));
> }
> 
>- WEBCORE_EXPORT virtual ~SetLineCap();
>- 
> LineCap lineCap() const { return m_lineCap; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<SetLineCap>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT SetLineCap(LineCap);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>+private:
> LineCap m_lineCap;
> };
> 
>-template<class Encoder>
>-void SetLineCap::encode(Encoder& encoder) const
>-{
>- encoder << m_lineCap;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<SetLineCap>> SetLineCap::decode(Decoder& decoder)
>-{
>- Optional<LineCap> lineCap;
>- decoder >> lineCap;
>- if (!lineCap)
>- return WTF::nullopt;
>-
>- return SetLineCap::create(*lineCap);
>-}
>-
>-class SetLineDash : public Item {
>+class SetLineDash {
> public:
>- static Ref<SetLineDash> create(const DashArray& dashArray, float dashOffset)
>+ static constexpr ItemType itemType = ItemType::SetLineDash;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = false;
>+
>+ SetLineDash(const DashArray& dashArray, float dashOffset)
>+ : m_dashArray(dashArray)
>+ , m_dashOffset(dashOffset)
> {
>- return adoptRef(*new SetLineDash(dashArray, dashOffset));
> }
> 
>- WEBCORE_EXPORT virtual ~SetLineDash();
>-
> const DashArray& dashArray() const { return m_dashArray; }
> float dashOffset() const { return m_dashOffset; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<SetLineDash>> decode(Decoder&);
>+ void apply(GraphicsContext&) const;
> 
>-private:
>- WEBCORE_EXPORT SetLineDash(const DashArray&, float dashOffset);
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>- void apply(GraphicsContext&) const override;
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<SetLineDash> decode(Decoder&);
> 
>+private:
> DashArray m_dashArray;
> float m_dashOffset;
> };
>@@ -970,7 +681,7 @@ void SetLineDash::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<SetLineDash>> SetLineDash::decode(Decoder& decoder)
>+Optional<SetLineDash> SetLineDash::decode(Decoder& decoder)
> {
> Optional<DashArray> dashArray;
> decoder >> dashArray;
>@@ -982,215 +693,138 @@ Optional<Ref<SetLineDash>> SetLineDash::decode(Decoder& decoder)
> if (!dashOffset)
> return WTF::nullopt;
> 
>- return SetLineDash::create(*dashArray, *dashOffset);
>+ return {{ *dashArray, *dashOffset }};
> }
> 
>-class SetLineJoin : public Item {
>+class SetLineJoin {
> public:
>- static Ref<SetLineJoin> create(LineJoin lineJoin)
>+ static constexpr ItemType itemType = ItemType::SetLineJoin;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
>+
>+ SetLineJoin(LineJoin lineJoin)
>+ : m_lineJoin(lineJoin)
> {
>- return adoptRef(*new SetLineJoin(lineJoin));
> }
> 
>- WEBCORE_EXPORT virtual ~SetLineJoin();
>- 
> LineJoin lineJoin() const { return m_lineJoin; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<SetLineJoin>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT SetLineJoin(LineJoin);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>+private:
> LineJoin m_lineJoin;
> };
> 
>-template<class Encoder>
>-void SetLineJoin::encode(Encoder& encoder) const
>-{
>- encoder << m_lineJoin;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<SetLineJoin>> SetLineJoin::decode(Decoder& decoder)
>-{
>- Optional<LineJoin> lineJoin;
>- decoder >> lineJoin;
>- if (!lineJoin)
>- return WTF::nullopt;
>-
>- return SetLineJoin::create(*lineJoin);
>-}
>-
>-class SetMiterLimit : public Item {
>+class SetMiterLimit {
> public:
>- static Ref<SetMiterLimit> create(float limit)
>+ static constexpr ItemType itemType = ItemType::SetMiterLimit;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
>+
>+ SetMiterLimit(float miterLimit)
>+ : m_miterLimit(miterLimit)
> {
>- return adoptRef(*new SetMiterLimit(limit));
> }
> 
>- WEBCORE_EXPORT virtual ~SetMiterLimit();
>-
> float miterLimit() const { return m_miterLimit; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<SetMiterLimit>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT SetMiterLimit(float);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>+private:
> float m_miterLimit;
> };
> 
>-template<class Encoder>
>-void SetMiterLimit::encode(Encoder& encoder) const
>-{
>- encoder << m_miterLimit;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<SetMiterLimit>> SetMiterLimit::decode(Decoder& decoder)
>-{
>- Optional<float> miterLimit;
>- decoder >> miterLimit;
>- if (!miterLimit)
>- return WTF::nullopt;
>-
>- return SetMiterLimit::create(*miterLimit);
>-}
>-
>-class ClearShadow : public Item {
>+class ClearShadow {
> public:
>- static Ref<ClearShadow> create()
>- {
>- return adoptRef(*new ClearShadow);
>- }
>-
>- WEBCORE_EXPORT virtual ~ClearShadow();
>-
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<ClearShadow>> decode(Decoder&);
>+ static constexpr ItemType itemType = ItemType::ClearShadow;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
> 
>-private:
>- WEBCORE_EXPORT ClearShadow();
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> };
> 
>-template<class Encoder>
>-void ClearShadow::encode(Encoder&) const
>-{
>-}
>-
>-template<class Decoder>
>-Optional<Ref<ClearShadow>> ClearShadow::decode(Decoder&)
>-{
>- return ClearShadow::create();
>-}
>-
>-// FIXME: treat as DrawingItem?
>-class Clip : public Item {
>+// FIXME: treat as drawing item?
>+class Clip {
> public:
>- static Ref<Clip> create(const FloatRect& rect)
>+ static constexpr ItemType itemType = ItemType::Clip;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
>+
>+ Clip(const FloatRect& rect)
>+ : m_rect(rect)
> {
>- return adoptRef(*new Clip(rect));
> }
> 
>- WEBCORE_EXPORT virtual ~Clip();
>+ const FloatRect& rect() const { return m_rect; }
> 
>- FloatRect rect() const { return m_rect; }
>+ void apply(GraphicsContext&) const;
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<Clip>> decode(Decoder&);
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
> private:
>- WEBCORE_EXPORT Clip(const FloatRect&);
>-
>- void apply(GraphicsContext&) const override;
>-
> FloatRect m_rect;
> };
> 
>-template<class Encoder>
>-void Clip::encode(Encoder& encoder) const
>-{
>- encoder << m_rect;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<Clip>> Clip::decode(Decoder& decoder)
>-{
>- Optional<FloatRect> rect;
>- decoder >> rect;
>- if (!rect)
>- return WTF::nullopt;
>-
>- return Clip::create(*rect);
>-}
>-
>-class ClipOut : public Item {
>+class ClipOut {
> public:
>- static Ref<ClipOut> create(const FloatRect& rect)
>+ static constexpr ItemType itemType = ItemType::ClipOut;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
>+
>+ ClipOut(const FloatRect& rect)
>+ : m_rect(rect)
> {
>- return adoptRef(*new ClipOut(rect));
> }
> 
>- WEBCORE_EXPORT virtual ~ClipOut();
>+ const FloatRect& rect() const { return m_rect; }
> 
>- FloatRect rect() const { return m_rect; }
>+ void apply(GraphicsContext&) const;
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<ClipOut>> decode(Decoder&);
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
> private:
>- WEBCORE_EXPORT ClipOut(const FloatRect&);
>-
>- void apply(GraphicsContext&) const override;
>-
> FloatRect m_rect;
> };
> 
>-template<class Encoder>
>-void ClipOut::encode(Encoder& encoder) const
>-{
>- encoder << m_rect;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<ClipOut>> ClipOut::decode(Decoder& decoder)
>-{
>- Optional<FloatRect> rect;
>- decoder >> rect;
>- if (!rect)
>- return WTF::nullopt;
>-
>- return ClipOut::create(*rect);
>-}
>-
>-class ClipOutToPath : public Item {
>+class ClipOutToPath {
> public:
>- static Ref<ClipOutToPath> create(const Path& path)
>+ static constexpr ItemType itemType = ItemType::ClipOutToPath;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = false;
>+
>+ ClipOutToPath(Path&& path)
>+ : m_path(WTFMove(path))
> {
>- return adoptRef(*new ClipOutToPath(path));
> }
> 
>- WEBCORE_EXPORT virtual ~ClipOutToPath();
>+ ClipOutToPath(const Path& path)
>+ : m_path(path)
>+ {
>+ }
> 
> const Path& path() const { return m_path; }
> 
> template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<ClipOutToPath>> decode(Decoder&);
>+ template<class Decoder> static Optional<ClipOutToPath> decode(Decoder&);
> 
>-private:
>- WEBCORE_EXPORT ClipOutToPath(const Path&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>- const Path m_path;
>+private:
>+ Path m_path;
> };
> 
> template<class Encoder>
>@@ -1200,37 +834,47 @@ void ClipOutToPath::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<ClipOutToPath>> ClipOutToPath::decode(Decoder& decoder)
>+Optional<ClipOutToPath> ClipOutToPath::decode(Decoder& decoder)
> {
> Optional<Path> path;
> decoder >> path;
> if (!path)
> return WTF::nullopt;
> 
>- return ClipOutToPath::create(*path);
>+ return {{ WTFMove(*path) }};
> }
> 
>-class ClipPath : public Item {
>+class ClipPath {
> public:
>- static Ref<ClipPath> create(const Path& path, WindRule windRule)
>+ static constexpr ItemType itemType = ItemType::ClipPath;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = false;
>+
>+ ClipPath(Path&& path, WindRule windRule)
>+ : m_path(WTFMove(path))
>+ , m_windRule(windRule)
> {
>- return adoptRef(*new ClipPath(path, windRule));
> }
> 
>- WEBCORE_EXPORT ~ClipPath();
>+ ClipPath(const Path& path, WindRule windRule)
>+ : m_path(path)
>+ , m_windRule(windRule)
>+ {
>+ }
> 
> const Path& path() const { return m_path; }
> WindRule windRule() const { return m_windRule; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<ClipPath>> decode(Decoder&);
>+ void apply(GraphicsContext&) const;
> 
>-private:
>- WEBCORE_EXPORT ClipPath(const Path&, WindRule);
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>- void apply(GraphicsContext&) const override;
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<ClipPath> decode(Decoder&);
> 
>- const Path m_path;
>+private:
>+ Path m_path;
> WindRule m_windRule;
> };
> 
>@@ -1242,7 +886,7 @@ void ClipPath::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<ClipPath>> ClipPath::decode(Decoder& decoder)
>+Optional<ClipPath> ClipPath::decode(Decoder& decoder)
> {
> Optional<Path> path;
> decoder >> path;
>@@ -1254,30 +898,35 @@ Optional<Ref<ClipPath>> ClipPath::decode(Decoder& decoder)
> if (!windRule)
> return WTF::nullopt;
> 
>- return ClipPath::create(*path, *windRule);
>+ return {{ WTFMove(*path), *windRule }};
> }
> 
>-class ClipToDrawingCommands : public Item {
>+class ClipToDrawingCommands {
> public:
>- static Ref<ClipToDrawingCommands> create(const FloatRect& destination, ColorSpace colorSpace, DisplayList&& drawingCommands)
>+ static constexpr ItemType itemType = ItemType::ClipToDrawingCommands;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = false;
>+
>+ ClipToDrawingCommands(const FloatRect& destination, ColorSpace colorSpace, DisplayList&& drawingCommands)
>+ : m_destination(destination)
>+ , m_colorSpace(colorSpace)
>+ , m_drawingCommands(WTFMove(drawingCommands))
> {
>- return adoptRef(*new ClipToDrawingCommands(destination, colorSpace, WTFMove(drawingCommands)));
> }
> 
>- WEBCORE_EXPORT ~ClipToDrawingCommands();
>-
> const FloatRect& destination() const { return m_destination; }
> ColorSpace colorSpace() const { return m_colorSpace; }
> const DisplayList& drawingCommands() const { return m_drawingCommands; }
> 
> template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<ClipToDrawingCommands>> decode(Decoder&);
>+ template<class Decoder> static Optional<ClipToDrawingCommands> decode(Decoder&);
> 
>-private:
>- WEBCORE_EXPORT ClipToDrawingCommands(const FloatRect& destination, ColorSpace, DisplayList&& drawingCommands);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>+private:
> FloatRect m_destination;
> ColorSpace m_colorSpace;
> DisplayList m_drawingCommands;
>@@ -1288,11 +937,11 @@ void ClipToDrawingCommands::encode(Encoder& encoder) const
> {
> encoder << m_destination;
> encoder << m_colorSpace;
>- encoder << m_drawingCommands;
>+ // FIXME: Implement a way to encode in-memory display lists.
> }
> 
> template<class Decoder>
>-Optional<Ref<ClipToDrawingCommands>> ClipToDrawingCommands::decode(Decoder& decoder)
>+Optional<ClipToDrawingCommands> ClipToDrawingCommands::decode(Decoder& decoder)
> {
> Optional<FloatRect> destination;
> decoder >> destination;
>@@ -1304,27 +953,16 @@ Optional<Ref<ClipToDrawingCommands>> ClipToDrawingCommands::decode(Decoder& deco
> if (!colorSpace)
> return WTF::nullopt;
> 
>- Optional<DisplayList> drawingCommands;
>- decoder >> drawingCommands;
>- if (!drawingCommands)
>- return WTF::nullopt;
>-
>- return ClipToDrawingCommands::create(*destination, *colorSpace, WTFMove(*drawingCommands));
>+ // FIXME: Implement a way to decode in-memory display lists.
>+ DisplayList drawingCommands;
>+ return {{ *destination, *colorSpace, WTFMove(drawingCommands) }};
> }
> 
>-class DrawGlyphs : public DrawingItem {
>+class DrawGlyphs {
> public:
>- static Ref<DrawGlyphs> create(const Font& font, const GlyphBufferGlyph* glyphs, const GlyphBufferAdvance* advances, unsigned count, const FloatPoint& localAnchor, FontSmoothingMode smoothingMode)
>- {
>- return adoptRef(*new DrawGlyphs(font, glyphs, advances, count, localAnchor, smoothingMode));
>- }
>-
>- static Ref<DrawGlyphs> create(const Font& font, Vector<GlyphBufferGlyph, 128>&& glyphs, Vector<GlyphBufferAdvance, 128>&& advances, const FloatPoint& localAnchor, FontSmoothingMode smoothingMode)
>- {
>- return adoptRef(*new DrawGlyphs(font, WTFMove(glyphs), WTFMove(advances), localAnchor, smoothingMode));
>- }
>-
>- WEBCORE_EXPORT virtual ~DrawGlyphs();
>+ static constexpr ItemType itemType = ItemType::DrawGlyphs;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
> 
> const FloatPoint& localAnchor() const { return m_localAnchor; }
> 
>@@ -1333,21 +971,21 @@ public:
> const Vector<GlyphBufferGlyph, 128>& glyphs() const { return m_glyphs; }
> 
> template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawGlyphs>> decode(Decoder&);
>+ template<class Decoder> static Optional<DrawGlyphs> decode(Decoder&);
> 
>-private:
> DrawGlyphs(const Font&, const GlyphBufferGlyph*, const GlyphBufferAdvance*, unsigned count, const FloatPoint& localAnchor, FontSmoothingMode);
> WEBCORE_EXPORT DrawGlyphs(const Font&, Vector<GlyphBufferGlyph, 128>&&, Vector<GlyphBufferAdvance, 128>&&, const FloatPoint& localAnchor, FontSmoothingMode);
> 
>- void computeBounds();
>-
>- void apply(GraphicsContext&) const override;
>+ void apply(GraphicsContext&) const;
> 
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override;
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_bounds; }
> 
>+private:
>+ void computeBounds();
> GlyphBuffer generateGlyphBuffer() const;
> 
>- Ref m_font;
>+ RefPtr m_font;
> Vector<GlyphBufferGlyph, 128> m_glyphs;
> Vector<GlyphBufferAdvance, 128> m_advances;
> FloatRect m_bounds;
>@@ -1358,7 +996,7 @@ private:
> template<class Encoder>
> void DrawGlyphs::encode(Encoder& encoder) const
> {
>- encoder << m_font;
>+ encoder << makeRef(*m_font);
> encoder << m_glyphs;
> encoder << m_advances;
> encoder << m_localAnchor;
>@@ -1366,7 +1004,7 @@ void DrawGlyphs::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<DrawGlyphs>> DrawGlyphs::decode(Decoder& decoder)
>+Optional<DrawGlyphs> DrawGlyphs::decode(Decoder& decoder)
> {
> Optional<Ref> font;
> decoder >> font;
>@@ -1396,32 +1034,35 @@ Optional<Ref<DrawGlyphs>> DrawGlyphs::decode(Decoder& decoder)
> if (!smoothingMode)
> return WTF::nullopt;
> 
>- return DrawGlyphs::create(font->get(), WTFMove(*glyphs), WTFMove(*advances), *localAnchor, *smoothingMode);
>+ return {{ font->get(), WTFMove(*glyphs), WTFMove(*advances), *localAnchor, *smoothingMode }};
> }
>-
>-class DrawImage : public DrawingItem {
>+class DrawImage {
> public:
>- static Ref<DrawImage> create(Image& image, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& imagePaintingOptions)
>+ static constexpr ItemType itemType = ItemType::DrawImage;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
>+
>+ DrawImage(Image& image, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& imagePaintingOptions)
>+ : m_image(image)
>+ , m_destination(destination)
>+ , m_source(source)
>+ , m_imagePaintingOptions(imagePaintingOptions)
> {
>- return adoptRef(*new DrawImage(image, destination, source, imagePaintingOptions));
> }
> 
>- WEBCORE_EXPORT virtual ~DrawImage();
>-
> const Image& image() const { return m_image.get(); }
> FloatRect source() const { return m_source; }
> FloatRect destination() const { return m_destination; }
> 
> template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawImage>> decode(Decoder&);
>+ template<class Decoder> static Optional<DrawImage> decode(Decoder&);
> 
>-private:
>- WEBCORE_EXPORT DrawImage(Image&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&);
>-
>- void apply(GraphicsContext&) const override;
>+ void apply(GraphicsContext&) const;
> 
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_destination; }
> 
>+private:
> mutable Ref<Image> m_image; // FIXME: Drawing images can cause their animations to progress. This shouldn't have to be mutable.
> FloatRect m_destination;
> FloatRect m_source;
>@@ -1441,7 +1082,7 @@ void DrawImage::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<DrawImage>> DrawImage::decode(Decoder& decoder)
>+Optional<DrawImage> DrawImage::decode(Decoder& decoder)
> {
> Optional<ImageHandle> imageHandle;
> decoder >> imageHandle;
>@@ -1463,17 +1104,14 @@ Optional<Ref<DrawImage>> DrawImage::decode(Decoder& decoder)
> if (!imagePaintingOptions)
> return WTF::nullopt;
> 
>- return DrawImage::create(*imageHandle->image, *destination, *source, *imagePaintingOptions);
>+ return {{ *imageHandle->image, *destination, *source, *imagePaintingOptions }};
> }
> 
>-class DrawTiledImage : public DrawingItem {
>+class DrawTiledImage {
> public:
>- static Ref<DrawTiledImage> create(Image& image, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions& imagePaintingOptions)
>- {
>- return adoptRef(*new DrawTiledImage(image, destination, source, tileSize, spacing, imagePaintingOptions));
>- }
>-
>- WEBCORE_EXPORT virtual ~DrawTiledImage();
>+ static constexpr ItemType itemType = ItemType::DrawTiledImage;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
> 
> const Image& image() const { return m_image.get(); }
> FloatPoint source() const { return m_source; }
>@@ -1482,16 +1120,25 @@ public:
> FloatSize tileSize() const { return m_tileSize; }
> FloatSize spacing() const { return m_spacing; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawTiledImage>> decode(Decoder&);
>+ DrawTiledImage(Image& image, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions& imagePaintingOptions)
>+ : m_image(image)
>+ , m_destination(destination)
>+ , m_source(source)
>+ , m_tileSize(tileSize)
>+ , m_spacing(spacing)
>+ , m_imagePaintingOptions(imagePaintingOptions)
>+ {
>+ }
> 
>-private:
>- WEBCORE_EXPORT DrawTiledImage(Image&, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_destination; }
> 
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<DrawTiledImage> decode(Decoder&);
> 
>+private:
> mutable Ref<Image> m_image; // FIXME: Drawing images can cause their animations to progress. This shouldn't have to be mutable.
> FloatRect m_destination;
> FloatPoint m_source;
>@@ -1514,7 +1161,7 @@ void DrawTiledImage::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<DrawTiledImage>> DrawTiledImage::decode(Decoder& decoder)
>+Optional<DrawTiledImage> DrawTiledImage::decode(Decoder& decoder)
> {
> Optional<ImageHandle> imageHandle;
> decoder >> imageHandle;
>@@ -1546,32 +1193,39 @@ Optional<Ref<DrawTiledImage>> DrawTiledImage::decode(Decoder& decoder)
> if (!imagePaintingOptions)
> return WTF::nullopt;
> 
>- return DrawTiledImage::create(*imageHandle->image, *destination, *source, *tileSize, *spacing, *imagePaintingOptions);
>+ return {{ *imageHandle->image, *destination, *source, *tileSize, *spacing, *imagePaintingOptions }};
> }
> 
>-class DrawTiledScaledImage : public DrawingItem {
>+class DrawTiledScaledImage {
> public:
>- static Ref<DrawTiledScaledImage> create(Image& image, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions& imagePaintingOptions)
>+ static constexpr ItemType itemType = ItemType::DrawTiledScaledImage;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
>+
>+ DrawTiledScaledImage(Image& image, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions& imagePaintingOptions)
>+ : m_image(image)
>+ , m_destination(destination)
>+ , m_source(source)
>+ , m_tileScaleFactor(tileScaleFactor)
>+ , m_hRule(hRule)
>+ , m_vRule(vRule)
>+ , m_imagePaintingOptions(imagePaintingOptions)
> {
>- return adoptRef(*new DrawTiledScaledImage(image, destination, source, tileScaleFactor, hRule, vRule, imagePaintingOptions));
> }
> 
>- WEBCORE_EXPORT virtual ~DrawTiledScaledImage();
>-
> const Image& image() const { return m_image.get(); }
> FloatRect source() const { return m_source; }
> FloatRect destination() const { return m_destination; }
> 
> template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawTiledScaledImage>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT DrawTiledScaledImage(Image&, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions&);
>+ template<class Decoder> static Optional<DrawTiledScaledImage> decode(Decoder&);
> 
>- void apply(GraphicsContext&) const override;
>+ void apply(GraphicsContext&) const;
> 
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_destination; }
> 
>+private:
> mutable Ref<Image> m_image; // FIXME: Drawing images can cause their animations to progress. This shouldn't have to be mutable.
> FloatRect m_destination;
> FloatRect m_source;
>@@ -1596,7 +1250,7 @@ void DrawTiledScaledImage::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<DrawTiledScaledImage>> DrawTiledScaledImage::decode(Decoder& decoder)
>+Optional<DrawTiledScaledImage> DrawTiledScaledImage::decode(Decoder& decoder)
> {
> Optional<ImageHandle> imageHandle;
> decoder >> imageHandle;
>@@ -1631,33 +1285,37 @@ Optional<Ref<DrawTiledScaledImage>> DrawTiledScaledImage::decode(Decoder& decode
> if (!imagePaintingOptions)
> return WTF::nullopt;
> 
>- return DrawTiledScaledImage::create(*imageHandle->image, *destination, *source, *tileScaleFactor, hRule, vRule, *imagePaintingOptions);
>+ return {{ *imageHandle->image, *destination, *source, *tileScaleFactor, hRule, vRule, *imagePaintingOptions }};
> }
> 
>-class DrawImageBuffer : public DrawingItem {
>+class DrawImageBuffer {
> public:
>- static Ref<DrawImageBuffer> create(RenderingResourceIdentifier renderingResourceIdentifier, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& options)
>+ static constexpr ItemType itemType = ItemType::DrawImageBuffer;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
>+
>+ DrawImageBuffer(RenderingResourceIdentifier renderingResourceIdentifier, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>+ : m_renderingResourceIdentifier(renderingResourceIdentifier)
>+ , m_destinationRect(destRect)
>+ , m_srcRect(srcRect)
>+ , m_options(options)
> {
>- return adoptRef(*new DrawImageBuffer(renderingResourceIdentifier, destination, source, options));
> }
> 
>- WEBCORE_EXPORT virtual ~DrawImageBuffer();
>-
> RenderingResourceIdentifier renderingResourceIdentifier() const { return m_renderingResourceIdentifier; }
> FloatRect source() const { return m_srcRect; }
> FloatRect destinationRect() const { return m_destinationRect; }
> ImagePaintingOptions options() const { return m_options; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawImageBuffer>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT DrawImageBuffer(RenderingResourceIdentifier, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_destinationRect; }
> 
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destinationRect; }
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<DrawImageBuffer> decode(Decoder&);
> 
>+private:
> RenderingResourceIdentifier m_renderingResourceIdentifier;
> FloatRect m_destinationRect;
> FloatRect m_srcRect;
>@@ -1674,7 +1332,7 @@ void DrawImageBuffer::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<DrawImageBuffer>> DrawImageBuffer::decode(Decoder& decoder)
>+Optional<DrawImageBuffer> DrawImageBuffer::decode(Decoder& decoder)
> {
> Optional<RenderingResourceIdentifier> renderingResourceIdentifier;
> decoder >> renderingResourceIdentifier;
>@@ -1696,31 +1354,29 @@ Optional<Ref<DrawImageBuffer>> DrawImageBuffer::decode(Decoder& decoder)
> if (!options)
> return WTF::nullopt;
> 
>- return DrawImageBuffer::create(*renderingResourceIdentifier, *destination, *source, *options);
>+ return {{ *renderingResourceIdentifier, *destination, *source, *options }};
> }
> 
>-class DrawNativeImage : public DrawingItem {
>+class DrawNativeImage {
> public:
>- static Ref<DrawNativeImage> create(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
>- {
>- return adoptRef(*new DrawNativeImage(image, imageSize, destRect, srcRect, options));
>- }
>+ static constexpr ItemType itemType = ItemType::DrawNativeImage;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
> 
>- WEBCORE_EXPORT virtual ~DrawNativeImage();
>-
>- FloatRect source() const { return m_srcRect; }
>- FloatRect destinationRect() const { return m_destinationRect; }
>+ WEBCORE_EXPORT DrawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&);
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawNativeImage>> decode(Decoder&);
>+ const FloatRect& source() const { return m_srcRect; }
>+ const FloatRect& destinationRect() const { return m_destinationRect; }
> 
>-private:
>- WEBCORE_EXPORT DrawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_destinationRect; }
> 
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destinationRect; }
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<DrawNativeImage> decode(Decoder&);
> 
>+private:
> NativeImagePtr m_image;
> FloatSize m_imageSize;
> FloatRect m_destinationRect;
>@@ -1739,7 +1395,7 @@ void DrawNativeImage::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<DrawNativeImage>> DrawNativeImage::decode(Decoder& decoder)
>+Optional<DrawNativeImage> DrawNativeImage::decode(Decoder& decoder)
> {
> Optional<NativeImagePtr> image;
> decoder >> image;
>@@ -1766,17 +1422,16 @@ Optional<Ref<DrawNativeImage>> DrawNativeImage::decode(Decoder& decoder)
> if (!options)
> return WTF::nullopt;
> 
>- return DrawNativeImage::create(*image, *imageSize, *destinationRect, *srcRect, *options);
>+ return {{ *image, *imageSize, *destinationRect, *srcRect, *options }};
> }
> 
>-class DrawPattern : public DrawingItem {
>+class DrawPattern {
> public:
>- static Ref<DrawPattern> create(Image& image, const FloatRect& destRect, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& options)
>- {
>- return adoptRef(*new DrawPattern(image, destRect, tileRect, patternTransform, phase, spacing, options));
>- }
>+ static constexpr ItemType itemType = ItemType::DrawPattern;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
> 
>- WEBCORE_EXPORT virtual ~DrawPattern();
>+ WEBCORE_EXPORT DrawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& = { });
> 
> const Image& image() const { return m_image.get(); }
> const AffineTransform& patternTransform() const { return m_patternTransform; }
>@@ -1785,16 +1440,15 @@ public:
> FloatPoint phase() const { return m_phase; }
> FloatSize spacing() const { return m_spacing; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawPattern>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT DrawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& = { });
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_destination; }
> 
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<DrawPattern> decode(Decoder&);
> 
>+private:
> mutable Ref<Image> m_image; // FIXME: Drawing images can cause their animations to progress. This shouldn't have to be mutable.
> AffineTransform m_patternTransform;
> FloatRect m_tileRect;
>@@ -1819,7 +1473,7 @@ void DrawPattern::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<DrawPattern>> DrawPattern::decode(Decoder& decoder)
>+Optional<DrawPattern> DrawPattern::decode(Decoder& decoder)
> {
> Optional<ImageHandle> imageHandle;
> decoder >> imageHandle;
>@@ -1856,182 +1510,100 @@ Optional<Ref<DrawPattern>> DrawPattern::decode(Decoder& decoder)
> if (!options)
> return WTF::nullopt;
> 
>- return DrawPattern::create(*imageHandle->image, *destination, *tileRect, *patternTransform, *phase, *spacing, *options);
>+ return {{ *imageHandle->image, *destination, *tileRect, *patternTransform, *phase, *spacing, *options }};
> }
> 
>-// Is DrawingItem because the size of the transparency layer is implicitly the clip bounds.
>-class BeginTransparencyLayer : public DrawingItem {
>+class BeginTransparencyLayer {
> public:
>- static Ref<BeginTransparencyLayer> create(float opacity)
>+ static constexpr ItemType itemType = ItemType::BeginTransparencyLayer;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true; // Is drawing item because the size of the transparency layer is implicitly the clip bounds.
>+
>+ BeginTransparencyLayer(float opacity)
>+ : m_opacity(opacity)
> {
>- return adoptRef(*new BeginTransparencyLayer(opacity));
> }
> 
>- WEBCORE_EXPORT virtual ~BeginTransparencyLayer();
>-
> float opacity() const { return m_opacity; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<BeginTransparencyLayer>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT BeginTransparencyLayer(float opacity);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>+private:
> float m_opacity;
> };
> 
>-template<class Encoder>
>-void BeginTransparencyLayer::encode(Encoder& encoder) const
>-{
>- encoder << m_opacity;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<BeginTransparencyLayer>> BeginTransparencyLayer::decode(Decoder& decoder)
>-{
>- Optional<float> opacity;
>- decoder >> opacity;
>- if (!opacity)
>- return WTF::nullopt;
>-
>- return BeginTransparencyLayer::create(*opacity);
>-}
>-
>-class EndTransparencyLayer : public DrawingItem {
>+class EndTransparencyLayer {
> public:
>- static Ref<EndTransparencyLayer> create()
>- {
>- return adoptRef(*new EndTransparencyLayer);
>- }
>+ static constexpr ItemType itemType = ItemType::EndTransparencyLayer;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true;
> 
>- WEBCORE_EXPORT virtual ~EndTransparencyLayer();
>+ void apply(GraphicsContext&) const;
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<EndTransparencyLayer>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT EndTransparencyLayer();
>-
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> };
> 
>-template<class Encoder>
>-void EndTransparencyLayer::encode(Encoder&) const
>-{
>-}
>-
>-template<class Decoder>
>-Optional<Ref<EndTransparencyLayer>> EndTransparencyLayer::decode(Decoder&)
>-{
>- return EndTransparencyLayer::create();
>-}
>-
>-class DrawRect : public DrawingItem {
>+class DrawRect {
> public:
>- static Ref<DrawRect> create(const FloatRect& rect, float borderThickness)
>+ static constexpr ItemType itemType = ItemType::DrawRect;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true;
>+
>+ DrawRect(FloatRect rect, float borderThickness)
>+ : m_rect(rect)
>+ , m_borderThickness(borderThickness)
> {
>- return adoptRef(*new DrawRect(rect, borderThickness));
> }
> 
>- WEBCORE_EXPORT virtual ~DrawRect();
>-
> FloatRect rect() const { return m_rect; }
> float borderThickness() const { return m_borderThickness; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawRect>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT DrawRect(const FloatRect&, float borderThickness);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_rect; }
> 
>+private:
> FloatRect m_rect;
> float m_borderThickness;
> };
> 
>-template<class Encoder>
>-void DrawRect::encode(Encoder& encoder) const
>-{
>- encoder << m_rect;
>- encoder << m_borderThickness;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<DrawRect>> DrawRect::decode(Decoder& decoder)
>-{
>- Optional<FloatRect> rect;
>- decoder >> rect;
>- if (!rect)
>- return WTF::nullopt;
>-
>- Optional<float> borderThickness;
>- decoder >> borderThickness;
>- if (!borderThickness)
>- return WTF::nullopt;
>-
>- return DrawRect::create(*rect, *borderThickness);
>-}
>-
>-class DrawLine : public DrawingItem {
>+class DrawLine {
> public:
>- static Ref<DrawLine> create(const FloatPoint& point1, const FloatPoint& point2)
>+ static constexpr ItemType itemType = ItemType::DrawLine;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true;
>+
>+ DrawLine(FloatPoint point1, FloatPoint point2)
>+ : m_point1(point1)
>+ , m_point2(point2)
> {
>- return adoptRef(*new DrawLine(point1, point2));
> }
> 
>- WEBCORE_EXPORT virtual ~DrawLine();
>-
> FloatPoint point1() const { return m_point1; }
> FloatPoint point2() const { return m_point2; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawLine>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT DrawLine(const FloatPoint&, const FloatPoint&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override;
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const;
> 
>+private:
> FloatPoint m_point1;
> FloatPoint m_point2;
> };
> 
>-template<class Encoder>
>-void DrawLine::encode(Encoder& encoder) const
>-{
>- encoder << m_point1;
>- encoder << m_point2;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<DrawLine>> DrawLine::decode(Decoder& decoder)
>-{
>- Optional<FloatPoint> point1;
>- decoder >> point1;
>- if (!point1)
>- return WTF::nullopt;
>-
>- Optional<FloatPoint> point2;
>- decoder >> point2;
>- if (!point2)
>- return WTF::nullopt;
>-
>- return DrawLine::create(*point1, *point2);
>-}
>-
>-class DrawLinesForText : public DrawingItem {
>+class DrawLinesForText {
> public:
>- static Ref<DrawLinesForText> create(const FloatPoint& blockLocation, const FloatSize& localAnchor, float thickness, const DashArray& widths, bool printing, bool doubleLines)
>- {
>- return adoptRef(*new DrawLinesForText(blockLocation, localAnchor, thickness, widths, printing, doubleLines));
>- }
>+ static constexpr ItemType itemType = ItemType::DrawLinesForText;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
> 
>- WEBCORE_EXPORT virtual ~DrawLinesForText();
>+ WEBCORE_EXPORT DrawLinesForText(const FloatPoint& blockLocation, const FloatSize& localAnchor, float thickness, const DashArray& widths, bool printing, bool doubleLines);
> 
> void setBlockLocation(const FloatPoint& blockLocation) { m_blockLocation = blockLocation; }
> const FloatPoint& blockLocation() const { return m_blockLocation; }
>@@ -2042,16 +1614,15 @@ public:
> bool isPrinting() const { return m_printing; }
> bool doubleLines() const { return m_doubleLines; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawLinesForText>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT DrawLinesForText(const FloatPoint& blockLocation, const FloatSize& localAnchor, float thickness, const DashArray& widths, bool printing, bool doubleLines);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const;
> 
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override;
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<DrawLinesForText> decode(Decoder&);
> 
>+private:
> FloatPoint m_blockLocation;
> FloatSize m_localAnchor;
> DashArray m_widths;
>@@ -2072,7 +1643,7 @@ void DrawLinesForText::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<DrawLinesForText>> DrawLinesForText::decode(Decoder& decoder)
>+Optional<DrawLinesForText> DrawLinesForText::decode(Decoder& decoder)
> {
> Optional<FloatPoint> blockLocation;
> decoder >> blockLocation;
>@@ -2104,119 +1675,83 @@ Optional<Ref<DrawLinesForText>> DrawLinesForText::decode(Decoder& decoder)
> if (!doubleLines)
> return WTF::nullopt;
> 
>- return DrawLinesForText::create(*blockLocation, *localAnchor, *thickness, *widths, *printing, *doubleLines);
>+ return {{ *blockLocation, *localAnchor, *thickness, *widths, *printing, *doubleLines }};
> }
> 
>-class DrawDotsForDocumentMarker : public DrawingItem {
>+class DrawDotsForDocumentMarker {
> public:
>- static Ref<DrawDotsForDocumentMarker> create(const FloatRect& rect, DocumentMarkerLineStyle style)
>+ static constexpr ItemType itemType = ItemType::DrawDotsForDocumentMarker;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true;
>+
>+ DrawDotsForDocumentMarker(const FloatRect& rect, DocumentMarkerLineStyle style)
>+ : m_rect(rect)
>+ , m_style(style)
> {
>- return adoptRef(*new DrawDotsForDocumentMarker(rect, style));
> }
> 
>- WEBCORE_EXPORT virtual ~DrawDotsForDocumentMarker();
>-
> FloatRect rect() const { return m_rect; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawDotsForDocumentMarker>> decode(Decoder&);
>+ void apply(GraphicsContext&) const;
>+
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const;
> 
> private:
>- WEBCORE_EXPORT DrawDotsForDocumentMarker(const FloatRect&, DocumentMarkerLineStyle);
>+ FloatRect m_rect;
>+ DocumentMarkerLineStyle m_style;
>+};
>+
>+class DrawEllipse {
>+public:
>+ static constexpr ItemType itemType = ItemType::DrawEllipse;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true;
>+
>+ DrawEllipse(const FloatRect& rect)
>+ : m_rect(rect)
>+ {
>+ }
>+
>+ FloatRect rect() const { return m_rect; }
> 
>- void apply(GraphicsContext&) const override;
>+ void apply(GraphicsContext&) const;
> 
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override;
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_rect; }
> 
>+private:
> FloatRect m_rect;
>- DocumentMarkerLineStyle m_style;
> };
> 
>-template<class Encoder>
>-void DrawDotsForDocumentMarker::encode(Encoder& encoder) const
>-{
>- encoder << m_rect;
>- encoder << m_style;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<DrawDotsForDocumentMarker>> DrawDotsForDocumentMarker::decode(Decoder& decoder)
>-{
>- Optional<FloatRect> rect;
>- decoder >> rect;
>- if (!rect)
>- return WTF::nullopt;
>-
>- Optional<DocumentMarkerLineStyle> style;
>- decoder >> style;
>- if (!style)
>- return WTF::nullopt;
>-
>- return DrawDotsForDocumentMarker::create(*rect, *style);
>-}
>-
>-class DrawEllipse : public DrawingItem {
>+class DrawPath {
> public:
>- static Ref<DrawEllipse> create(const FloatRect& rect)
>+ static constexpr ItemType itemType = ItemType::DrawPath;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
>+
>+ DrawPath(const Path& path)
>+ : m_path(path)
> {
>- return adoptRef(*new DrawEllipse(rect));
> }
> 
>- WEBCORE_EXPORT ~DrawEllipse();
>-
>- FloatRect rect() const { return m_rect; }
>-
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawEllipse>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT DrawEllipse(const FloatRect&);
>-
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
>-
>- FloatRect m_rect;
>-};
>-
>-template<class Encoder>
>-void DrawEllipse::encode(Encoder& encoder) const
>-{
>- encoder << m_rect;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<DrawEllipse>> DrawEllipse::decode(Decoder& decoder)
>-{
>- Optional<FloatRect> rect;
>- decoder >> rect;
>- if (!rect)
>- return WTF::nullopt;
>-
>- return DrawEllipse::create(*rect);
>-}
>-
>-class DrawPath : public DrawingItem {
>-public:
>- static Ref<DrawPath> create(const Path& path)
>+ DrawPath(Path&& path)
>+ : m_path(WTFMove(path))
> {
>- return adoptRef(*new DrawPath(path));
> }
> 
>- WEBCORE_EXPORT virtual ~DrawPath();
>-
> const Path& path() const { return m_path; }
> 
> template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawPath>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT DrawPath(const Path&);
>+ template<class Decoder> static Optional<DrawPath> decode(Decoder&);
> 
>- void apply(GraphicsContext&) const override;
>+ void apply(GraphicsContext&) const;
> 
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_path.fastBoundingRect(); }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_path.fastBoundingRect(); }
> 
>- const Path m_path;
>+private:
>+ Path m_path;
> };
> 
> template<class Encoder>
>@@ -2226,24 +1761,37 @@ void DrawPath::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<DrawPath>> DrawPath::decode(Decoder& decoder)
>+Optional<DrawPath> DrawPath::decode(Decoder& decoder)
> {
> Optional<Path> path;
> decoder >> path;
> if (!path)
> return WTF::nullopt;
> 
>- return DrawPath::create(*path);
>+ return {{ WTFMove(*path) }};
> }
> 
>-class DrawFocusRingPath : public DrawingItem {
>+class DrawFocusRingPath {
> public:
>- static Ref<DrawFocusRingPath> create(const Path& path, float width, float offset, const Color& color)
>+ static constexpr ItemType itemType = ItemType::DrawFocusRingPath;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
>+
>+ DrawFocusRingPath(Path&& path, float width, float offset, Color color)
>+ : m_path(WTFMove(path))
>+ , m_width(width)
>+ , m_offset(offset)
>+ , m_color(color)
> {
>- return adoptRef(*new DrawFocusRingPath(path, width, offset, color));
> }
> 
>- WEBCORE_EXPORT virtual ~DrawFocusRingPath();
>+ DrawFocusRingPath(const Path& path, float width, float offset, Color color)
>+ : m_path(path)
>+ , m_width(width)
>+ , m_offset(offset)
>+ , m_color(color)
>+ {
>+ }
> 
> const Path& path() const { return m_path; }
> float width() const { return m_width; }
>@@ -2251,16 +1799,15 @@ public:
> const Color& color() const { return m_color; }
> 
> template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawFocusRingPath>> decode(Decoder&);
>+ template<class Decoder> static Optional<DrawFocusRingPath> decode(Decoder&);
> 
>-private:
>- WEBCORE_EXPORT DrawFocusRingPath(const Path&, float width, float offset, const Color&);
>-
>- void apply(GraphicsContext&) const override;
>+ void apply(GraphicsContext&) const;
> 
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override;
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const;
> 
>- const Path m_path;
>+private:
>+ Path m_path;
> float m_width;
> float m_offset;
> Color m_color;
>@@ -2276,7 +1823,7 @@ void DrawFocusRingPath::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<DrawFocusRingPath>> DrawFocusRingPath::decode(Decoder& decoder)
>+Optional<DrawFocusRingPath> DrawFocusRingPath::decode(Decoder& decoder)
> {
> Optional<Path> path;
> decoder >> path;
>@@ -2298,33 +1845,31 @@ Optional<Ref<DrawFocusRingPath>> DrawFocusRingPath::decode(Decoder& decoder)
> if (!color)
> return WTF::nullopt;
> 
>- return DrawFocusRingPath::create(*path, *width, *offset, *color);
>+ return {{ WTFMove(*path), *width, *offset, *color }};
> }
> 
>-class DrawFocusRingRects : public DrawingItem {
>+class DrawFocusRingRects {
> public:
>- static Ref<DrawFocusRingRects> create(const Vector<FloatRect>& rects, float width, float offset, const Color& color)
>- {
>- return adoptRef(*new DrawFocusRingRects(rects, width, offset, color));
>- }
>+ static constexpr ItemType itemType = ItemType::DrawFocusRingRects;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
> 
>- WEBCORE_EXPORT virtual ~DrawFocusRingRects();
>+ WEBCORE_EXPORT DrawFocusRingRects(const Vector<FloatRect>&, float width, float offset, const Color&);
> 
> const Vector<FloatRect> rects() const { return m_rects; }
> float width() const { return m_width; }
> float offset() const { return m_offset; }
> const Color& color() const { return m_color; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<DrawFocusRingRects>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT DrawFocusRingRects(const Vector<FloatRect>&, float width, float offset, const Color&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const;
> 
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override;
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<DrawFocusRingRects> decode(Decoder&);
> 
>+private:
> Vector<FloatRect> m_rects;
> float m_width;
> float m_offset;
>@@ -2341,7 +1886,7 @@ void DrawFocusRingRects::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<DrawFocusRingRects>> DrawFocusRingRects::decode(Decoder& decoder)
>+Optional<DrawFocusRingRects> DrawFocusRingRects::decode(Decoder& decoder)
> {
> Optional<Vector<FloatRect>> rects;
> decoder >> rects;
>@@ -2363,71 +1908,55 @@ Optional<Ref<DrawFocusRingRects>> DrawFocusRingRects::decode(Decoder& decoder)
> if (!color)
> return WTF::nullopt;
> 
>- return DrawFocusRingRects::create(*rects, *width, *offset, *color);
>+ return {{ *rects, *width, *offset, *color }};
> }
> 
>-class FillRect : public DrawingItem {
>+class FillRect {
> public:
>- static Ref<FillRect> create(const FloatRect& rect)
>+ static constexpr ItemType itemType = ItemType::FillRect;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true;
>+
>+ FillRect(const FloatRect& rect)
>+ : m_rect(rect)
> {
>- return adoptRef(*new FillRect(rect));
> }
> 
>- WEBCORE_EXPORT virtual ~FillRect();
>+ const FloatRect& rect() const { return m_rect; }
> 
>- FloatRect rect() const { return m_rect; }
>+ void apply(GraphicsContext&) const;
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<FillRect>> decode(Decoder&);
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_rect; }
> 
> private:
>- WEBCORE_EXPORT FillRect(const FloatRect&);
>-
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
>-
> FloatRect m_rect;
> };
> 
>-template<class Encoder>
>-void FillRect::encode(Encoder& encoder) const
>-{
>- encoder << m_rect;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<FillRect>> FillRect::decode(Decoder& decoder)
>-{
>- Optional<FloatRect> rect;
>- decoder >> rect;
>- if (!rect)
>- return WTF::nullopt;
>-
>- return FillRect::create(*rect);
>-}
>-
>-// FIXME: Make these inherit from FillRect proper.
>-class FillRectWithColor : public DrawingItem {
>+class FillRectWithColor {
> public:
>- static Ref<FillRectWithColor> create(const FloatRect& rect, const Color& color)
>+ static constexpr ItemType itemType = ItemType::FillRectWithColor;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
>+
>+ FillRectWithColor(const FloatRect& rect, const Color& color)
>+ : m_rect(rect)
>+ , m_color(color)
> {
>- return adoptRef(*new FillRectWithColor(rect, color));
> }
> 
>- WEBCORE_EXPORT virtual ~FillRectWithColor();
>-
> FloatRect rect() const { return m_rect; }
> const Color& color() const { return m_color; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<FillRectWithColor>> decode(Decoder&);
>+ void apply(GraphicsContext&) const;
> 
>-private:
>- WEBCORE_EXPORT FillRectWithColor(const FloatRect&, const Color&);
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_rect; }
> 
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<FillRectWithColor> decode(Decoder&);
> 
>+private:
> FloatRect m_rect;
> Color m_color;
> };
>@@ -2440,7 +1969,7 @@ void FillRectWithColor::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<FillRectWithColor>> FillRectWithColor::decode(Decoder& decoder)
>+Optional<FillRectWithColor> FillRectWithColor::decode(Decoder& decoder)
> {
> Optional<FloatRect> rect;
> decoder >> rect;
>@@ -2452,29 +1981,28 @@ Optional<Ref<FillRectWithColor>> FillRectWithColor::decode(Decoder& decoder)
> if (!color)
> return WTF::nullopt;
> 
>- return FillRectWithColor::create(*rect, *color);
>+ return {{ *rect, *color }};
> }
> 
>-class FillRectWithGradient : public DrawingItem {
>+class FillRectWithGradient {
> public:
>- static Ref<FillRectWithGradient> create(const FloatRect& rect, Gradient& gradient)
>- {
>- return adoptRef(*new FillRectWithGradient(rect, gradient));
>- }
>+ static constexpr ItemType itemType = ItemType::FillRectWithGradient;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
> 
>- WEBCORE_EXPORT virtual ~FillRectWithGradient();
>+ WEBCORE_EXPORT FillRectWithGradient(const FloatRect&, Gradient&);
> 
>- FloatRect rect() const { return m_rect; }
>+ const FloatRect& rect() const { return m_rect; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<FillRectWithGradient>> decode(Decoder&);
>+ void apply(GraphicsContext&) const;
> 
>-private:
>- WEBCORE_EXPORT FillRectWithGradient(const FloatRect&, Gradient&);
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_rect; }
> 
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<FillRectWithGradient> decode(Decoder&);
> 
>+private:
> FloatRect m_rect;
> mutable Ref<Gradient> m_gradient; // FIXME: Make this not mutable
> };
>@@ -2487,7 +2015,7 @@ void FillRectWithGradient::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<FillRectWithGradient>> FillRectWithGradient::decode(Decoder& decoder)
>+Optional<FillRectWithGradient> FillRectWithGradient::decode(Decoder& decoder)
> {
> Optional<FloatRect> rect;
> decoder >> rect;
>@@ -2498,32 +2026,37 @@ Optional<Ref<FillRectWithGradient>> FillRectWithGradient::decode(Decoder& decode
> if (!gradient)
> return WTF::nullopt;
> 
>- return FillRectWithGradient::create(*rect, gradient->get());
>+ return {{ *rect, gradient->get() }};
> }
> 
>-class FillCompositedRect : public DrawingItem {
>+class FillCompositedRect {
> public:
>- static Ref<FillCompositedRect> create(const FloatRect& rect, const Color& color, CompositeOperator op, BlendMode blendMode)
>+ static constexpr ItemType itemType = ItemType::FillCompositedRect;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
>+
>+ FillCompositedRect(const FloatRect& rect, const Color& color, CompositeOperator op, BlendMode blendMode)
>+ : m_rect(rect)
>+ , m_color(color)
>+ , m_op(op)
>+ , m_blendMode(blendMode)
> {
>- return adoptRef(*new FillCompositedRect(rect, color, op, blendMode));
> }
> 
>- WEBCORE_EXPORT virtual ~FillCompositedRect();
>-
> FloatRect rect() const { return m_rect; }
> const Color& color() const { return m_color; }
> CompositeOperator compositeOperator() const { return m_op; }
> BlendMode blendMode() const { return m_blendMode; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<FillCompositedRect>> decode(Decoder&);
>+ void apply(GraphicsContext&) const;
> 
>-private:
>- WEBCORE_EXPORT FillCompositedRect(const FloatRect&, const Color&, CompositeOperator, BlendMode);
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_rect; }
> 
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<FillCompositedRect> decode(Decoder&);
> 
>+private:
> FloatRect m_rect;
> Color m_color;
> CompositeOperator m_op;
>@@ -2540,7 +2073,7 @@ void FillCompositedRect::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<FillCompositedRect>> FillCompositedRect::decode(Decoder& decoder)
>+Optional<FillCompositedRect> FillCompositedRect::decode(Decoder& decoder)
> {
> Optional<FloatRect> rect;
> decoder >> rect;
>@@ -2562,31 +2095,35 @@ Optional<Ref<FillCompositedRect>> FillCompositedRect::decode(Decoder& decoder)
> if (!blendMode)
> return WTF::nullopt;
> 
>- return FillCompositedRect::create(*rect, *color, *op, *blendMode);
>+ return {{ *rect, *color, *op, *blendMode }};
> }
> 
>-class FillRoundedRect : public DrawingItem {
>+class FillRoundedRect {
> public:
>- static Ref<FillRoundedRect> create(const FloatRoundedRect& rect, const Color& color, BlendMode blendMode)
>+ static constexpr ItemType itemType = ItemType::FillRoundedRect;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
>+
>+ FillRoundedRect(const FloatRoundedRect& rect, const Color& color, BlendMode blendMode)
>+ : m_rect(rect)
>+ , m_color(color)
>+ , m_blendMode(blendMode)
> {
>- return adoptRef(*new FillRoundedRect(rect, color, blendMode));
> }
> 
>- WEBCORE_EXPORT virtual ~FillRoundedRect();
>-
> const FloatRoundedRect& roundedRect() const { return m_rect; }
> const Color& color() const { return m_color; }
> BlendMode blendMode() const { return m_blendMode; }
> 
> template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<FillRoundedRect>> decode(Decoder&);
>+ template<class Decoder> static Optional<FillRoundedRect> decode(Decoder&);
> 
>-private:
>- WEBCORE_EXPORT FillRoundedRect(const FloatRoundedRect&, const Color&, BlendMode);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect.rect(); }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_rect.rect(); }
> 
>+private:
> FloatRoundedRect m_rect;
> Color m_color;
> BlendMode m_blendMode;
>@@ -2601,7 +2138,7 @@ void FillRoundedRect::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<FillRoundedRect>> FillRoundedRect::decode(Decoder& decoder)
>+Optional<FillRoundedRect> FillRoundedRect::decode(Decoder& decoder)
> {
> Optional<FloatRoundedRect> rect;
> decoder >> rect;
>@@ -2618,31 +2155,35 @@ Optional<Ref<FillRoundedRect>> FillRoundedRect::decode(Decoder& decoder)
> if (!blendMode)
> return WTF::nullopt;
> 
>- return FillRoundedRect::create(*rect, *color, *blendMode);
>+ return {{ *rect, *color, *blendMode }};
> }
> 
>-class FillRectWithRoundedHole : public DrawingItem {
>+class FillRectWithRoundedHole {
> public:
>- static Ref<FillRectWithRoundedHole> create(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color& color)
>+ static constexpr ItemType itemType = ItemType::FillRectWithRoundedHole;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
>+
>+ FillRectWithRoundedHole(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color& color)
>+ : m_rect(rect)
>+ , m_roundedHoleRect(roundedHoleRect)
>+ , m_color(color)
> {
>- return adoptRef(*new FillRectWithRoundedHole(rect, roundedHoleRect, color));
> }
> 
>- WEBCORE_EXPORT virtual ~FillRectWithRoundedHole();
>-
> const FloatRect& rect() const { return m_rect; }
> const FloatRoundedRect& roundedHoleRect() const { return m_roundedHoleRect; }
> const Color& color() const { return m_color; }
> 
> template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<FillRectWithRoundedHole>> decode(Decoder&);
>+ template<class Decoder> static Optional<FillRectWithRoundedHole> decode(Decoder&);
> 
>-private:
>- WEBCORE_EXPORT FillRectWithRoundedHole(const FloatRect&, const FloatRoundedRect&, const Color&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_rect; }
> 
>+private:
> FloatRect m_rect;
> FloatRoundedRect m_roundedHoleRect;
> Color m_color;
>@@ -2657,7 +2198,7 @@ void FillRectWithRoundedHole::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<FillRectWithRoundedHole>> FillRectWithRoundedHole::decode(Decoder& decoder)
>+Optional<FillRectWithRoundedHole> FillRectWithRoundedHole::decode(Decoder& decoder)
> {
> Optional<FloatRect> rect;
> decoder >> rect;
>@@ -2674,74 +2215,63 @@ Optional<Ref<FillRectWithRoundedHole>> FillRectWithRoundedHole::decode(Decoder&
> if (!color)
> return WTF::nullopt;
> 
>- return FillRectWithRoundedHole::create(*rect, *roundedHoleRect, *color);
>+ return {{ *rect, *roundedHoleRect, *color }};
> }
> 
> #if ENABLE(INLINE_PATH_DATA)
> 
>-class FillInlinePath : public DrawingItem {
>+class FillInlinePath {
> public:
>- static Ref<FillInlinePath> create(const InlinePathData& pathData)
>+ static constexpr ItemType itemType = ItemType::FillInlinePath;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true;
>+
>+ FillInlinePath(const InlinePathData& pathData)
>+ : m_pathData(pathData)
> {
>- return adoptRef(*new FillInlinePath(pathData));
> }
> 
>- WEBCORE_EXPORT virtual ~FillInlinePath();
>-
> Path path() const { return Path::from(m_pathData); }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<FillInlinePath>> decode(Decoder&);
>+ void apply(GraphicsContext&) const;
> 
>-private:
>- WEBCORE_EXPORT FillInlinePath(const InlinePathData&);
>-
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return path().fastBoundingRect(); }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return path().fastBoundingRect(); }
> 
>+private:
> InlinePathData m_pathData;
> };
> 
>-template<class Encoder>
>-void FillInlinePath::encode(Encoder& encoder) const
>-{
>- encoder << m_pathData;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<FillInlinePath>> FillInlinePath::decode(Decoder& decoder)
>-{
>- Optional<InlinePathData> pathData;
>- decoder >> pathData;
>- if (!pathData)
>- return WTF::nullopt;
>-
>- return FillInlinePath::create(WTFMove(*pathData));
>-}
>-
> #endif // ENABLE(INLINE_PATH_DATA)
> 
>-class FillPath : public DrawingItem {
>+class FillPath {
> public:
>- static Ref<FillPath> create(const Path& path)
>+ static constexpr ItemType itemType = ItemType::FillPath;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
>+
>+ FillPath(Path&& path)
>+ : m_path(WTFMove(path))
> {
>- return adoptRef(*new FillPath(path));
> }
> 
>- WEBCORE_EXPORT virtual ~FillPath();
>+ FillPath(const Path& path)
>+ : m_path(path)
>+ {
>+ }
> 
> const Path& path() const { return m_path; }
> 
> template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<FillPath>> decode(Decoder&);
>+ template<class Decoder> static Optional<FillPath> decode(Decoder&);
> 
>-private:
>- WEBCORE_EXPORT FillPath(const Path&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_path.fastBoundingRect(); }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_path.fastBoundingRect(); }
> 
>- const Path m_path;
>+private:
>+ Path m_path;
> };
> 
> template<class Encoder>
>@@ -2751,90 +2281,65 @@ void FillPath::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<FillPath>> FillPath::decode(Decoder& decoder)
>+Optional<FillPath> FillPath::decode(Decoder& decoder)
> {
> Optional<Path> path;
> decoder >> path;
> if (!path)
> return WTF::nullopt;
> 
>- return FillPath::create(*path);
>+ return {{ WTFMove(*path) }};
> }
> 
>-class FillEllipse : public DrawingItem {
>+class FillEllipse {
> public:
>- static Ref<FillEllipse> create(const FloatRect& rect)
>+ static constexpr ItemType itemType = ItemType::FillEllipse;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true;
>+
>+ FillEllipse(const FloatRect& rect)
>+ : m_rect(rect)
> {
>- return adoptRef(*new FillEllipse(rect));
> }
> 
>- WEBCORE_EXPORT virtual ~FillEllipse();
>-
> FloatRect rect() const { return m_rect; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<FillEllipse>> decode(Decoder&);
>+ void apply(GraphicsContext&) const;
> 
>-private:
>- WEBCORE_EXPORT FillEllipse(const FloatRect&);
>-
>- void apply(GraphicsContext&) const override;
>-
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_rect; }
> 
>+private:
> FloatRect m_rect;
> };
> 
>-template<class Encoder>
>-void FillEllipse::encode(Encoder& encoder) const
>-{
>- encoder << m_rect;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<FillEllipse>> FillEllipse::decode(Decoder& decoder)
>-{
>- Optional<FloatRect> rect;
>- decoder >> rect;
>- if (!rect)
>- return WTF::nullopt;
>-
>- return FillEllipse::create(*rect);
>-}
>-
>-class PutImageData : public DrawingItem {
>+class PutImageData {
> public:
>- static Ref<PutImageData> create(AlphaPremultiplication inputFormat, const ImageData& imageData, const IntRect& srcRect, const IntPoint& destPoint, AlphaPremultiplication destFormat)
>- {
>- return adoptRef(*new PutImageData(inputFormat, imageData, srcRect, destPoint, destFormat));
>- }
>- static Ref<PutImageData> create(AlphaPremultiplication inputFormat, Ref<ImageData>&& imageData, const IntRect& srcRect, const IntPoint& destPoint, AlphaPremultiplication destFormat)
>- {
>- return adoptRef(*new PutImageData(inputFormat, WTFMove(imageData), srcRect, destPoint, destFormat));
>- }
>+ static constexpr ItemType itemType = ItemType::PutImageData;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
> 
>- WEBCORE_EXPORT virtual ~PutImageData();
>+ WEBCORE_EXPORT PutImageData(AlphaPremultiplication inputFormat, const ImageData&, const IntRect& srcRect, const IntPoint& destPoint, AlphaPremultiplication destFormat);
>+ WEBCORE_EXPORT PutImageData(AlphaPremultiplication inputFormat, Ref<ImageData>&&, const IntRect& srcRect, const IntPoint& destPoint, AlphaPremultiplication destFormat);
> 
> AlphaPremultiplication inputFormat() const { return m_inputFormat; }
>- ImageData& imageData() const { return m_imageData; }
>+ ImageData& imageData() const { return *m_imageData; }
> IntRect srcRect() const { return m_srcRect; }
> IntPoint destPoint() const { return m_destPoint; }
> AlphaPremultiplication destFormat() const { return m_destFormat; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<PutImageData>> decode(Decoder&);
>+ void apply(GraphicsContext&) const;
> 
>-private:
>- WEBCORE_EXPORT PutImageData(AlphaPremultiplication inputFormat, const ImageData&, const IntRect& srcRect, const IntPoint& destPoint, AlphaPremultiplication destFormat);
>- WEBCORE_EXPORT PutImageData(AlphaPremultiplication inputFormat, Ref<ImageData>&&, const IntRect& srcRect, const IntPoint& destPoint, AlphaPremultiplication destFormat);
>-
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return {{ m_destPoint, m_srcRect.size() }}; }
> 
>- Optional<FloatRect> globalBounds() const override { return FloatRect(m_destPoint, m_srcRect.size()); }
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<PutImageData> decode(Decoder&);
> 
>+private:
> IntRect m_srcRect;
> IntPoint m_destPoint;
>- Ref<ImageData> m_imageData;
>+ RefPtr<ImageData> m_imageData;
> AlphaPremultiplication m_inputFormat;
> AlphaPremultiplication m_destFormat;
> };
>@@ -2843,14 +2348,14 @@ template<class Encoder>
> void PutImageData::encode(Encoder& encoder) const
> {
> encoder << m_inputFormat;
>- encoder << m_imageData;
>+ encoder << makeRef(*m_imageData);
> encoder << m_srcRect;
> encoder << m_destPoint;
> encoder << m_destFormat;
> }
> 
> template<class Decoder>
>-Optional<Ref<PutImageData>> PutImageData::decode(Decoder& decoder)
>+Optional<PutImageData> PutImageData::decode(Decoder& decoder)
> {
> Optional<AlphaPremultiplication> inputFormat;
> Optional<Ref<ImageData>> imageData;
>@@ -2878,169 +2383,109 @@ Optional<Ref<PutImageData>> PutImageData::decode(Decoder& decoder)
> if (!destFormat)
> return WTF::nullopt;
> 
>- return PutImageData::create(*inputFormat, WTFMove(*imageData), *srcRect, *destPoint, *destFormat);
>+ return {{ *inputFormat, WTFMove(*imageData), *srcRect, *destPoint, *destFormat }};
> }
> 
>-class PaintFrameForMedia : public DrawingItem {
>+class PaintFrameForMedia {
> public:
>- static Ref<PaintFrameForMedia> create(MediaPlayer&, const FloatRect& destination);
>+ static constexpr ItemType itemType = ItemType::PaintFrameForMedia;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true;
> 
>- WEBCORE_EXPORT virtual ~PaintFrameForMedia();
>+ PaintFrameForMedia(MediaPlayer&, const FloatRect& destination);
> 
> const FloatRect& destination() const { return m_destination; }
> MediaPlayerIdentifier identifier() const { return m_identifier; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<PaintFrameForMedia>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT static Ref<PaintFrameForMedia> create(MediaPlayerIdentifier, const FloatRect& destination);
>-
>- PaintFrameForMedia(MediaPlayer&, const FloatRect& destination);
>- PaintFrameForMedia(MediaPlayerIdentifier, const FloatRect& destination);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return { m_destination }; }
> 
>+private:
> MediaPlayerIdentifier m_identifier;
> FloatRect m_destination;
> };
> 
>-template<class Encoder>
>-void PaintFrameForMedia::encode(Encoder& encoder) const
>-{
>- encoder << m_identifier;
>- encoder << m_destination;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<PaintFrameForMedia>> PaintFrameForMedia::decode(Decoder& decoder)
>-{
>- Optional<MediaPlayerIdentifier> identifier;
>- decoder >> identifier;
>- if (!identifier)
>- return WTF::nullopt;
>-
>- Optional<FloatRect> destination;
>- decoder >> destination;
>- if (!destination)
>- return WTF::nullopt;
>-
>- return PaintFrameForMedia::create(*identifier, *destination);
>-}
>-
>-class StrokeRect : public DrawingItem {
>+class StrokeRect {
> public:
>- static Ref<StrokeRect> create(const FloatRect& rect, float lineWidth)
>+ static constexpr ItemType itemType = ItemType::StrokeRect;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true;
>+
>+ StrokeRect(const FloatRect& rect, float lineWidth)
>+ : m_rect(rect)
>+ , m_lineWidth(lineWidth)
> {
>- return adoptRef(*new StrokeRect(rect, lineWidth));
> }
> 
>- WEBCORE_EXPORT virtual ~StrokeRect();
>-
> FloatRect rect() const { return m_rect; }
> float lineWidth() const { return m_lineWidth; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<StrokeRect>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT StrokeRect(const FloatRect&, float);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override;
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const;
> 
>+private:
> FloatRect m_rect;
> float m_lineWidth;
> };
> 
>-template<class Encoder>
>-void StrokeRect::encode(Encoder& encoder) const
>-{
>- encoder << m_rect;
>- encoder << m_lineWidth;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<StrokeRect>> StrokeRect::decode(Decoder& decoder)
>-{
>- Optional<FloatRect> rect;
>- decoder >> rect;
>- if (!rect)
>- return WTF::nullopt;
>-
>- Optional<float> lineWidth;
>- decoder >> lineWidth;
>- if (!lineWidth)
>- return WTF::nullopt;
>-
>- return StrokeRect::create(*rect, *lineWidth);
>-}
>-
> #if ENABLE(INLINE_PATH_DATA)
> 
>-class StrokeInlinePath : public DrawingItem {
>+class StrokeInlinePath {
> public:
>- static Ref<StrokeInlinePath> create(const InlinePathData& pathData)
>+ static constexpr ItemType itemType = ItemType::StrokeInlinePath;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true;
>+
>+ StrokeInlinePath(const InlinePathData& pathData)
>+ : m_pathData(pathData)
> {
>- return adoptRef(*new StrokeInlinePath(pathData));
> }
> 
>- WEBCORE_EXPORT virtual ~StrokeInlinePath();
>-
> Path path() const { return Path::from(m_pathData); }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<StrokeInlinePath>> decode(Decoder&);
>-
>-private:
>- WEBCORE_EXPORT StrokeInlinePath(const InlinePathData&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override;
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const;
> 
>+private:
> InlinePathData m_pathData;
> };
> 
>-template<class Encoder>
>-void StrokeInlinePath::encode(Encoder& encoder) const
>-{
>- encoder << m_pathData;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<StrokeInlinePath>> StrokeInlinePath::decode(Decoder& decoder)
>-{
>- Optional<InlinePathData> pathData;
>- decoder >> pathData;
>- if (!pathData)
>- return WTF::nullopt;
>-
>- return StrokeInlinePath::create(WTFMove(*pathData));
>-}
>-
> #endif // ENABLE(INLINE_PATH_DATA)
> 
>-class StrokePath : public DrawingItem {
>+class StrokePath {
> public:
>- static Ref<StrokePath> create(const Path& path)
>+ static constexpr ItemType itemType = ItemType::StrokePath;
>+ static constexpr bool isInlineItem = false;
>+ static constexpr bool isDrawingItem = true;
>+
>+ StrokePath(Path&& path)
>+ : m_path(WTFMove(path))
> {
>- return adoptRef(*new StrokePath(path));
> }
> 
>- WEBCORE_EXPORT virtual ~StrokePath();
>+ StrokePath(const Path& path)
>+ : m_path(path)
>+ {
>+ }
> 
> const Path& path() const { return m_path; }
> 
> template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<StrokePath>> decode(Decoder&);
>+ template<class Decoder> static Optional<StrokePath> decode(Decoder&);
> 
>-private:
>- WEBCORE_EXPORT StrokePath(const Path&);
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override;
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const;
> 
>- const Path m_path;
>+private:
>+ Path m_path;
> };
> 
> template<class Encoder>
>@@ -3050,721 +2495,115 @@ void StrokePath::encode(Encoder& encoder) const
> }
> 
> template<class Decoder>
>-Optional<Ref<StrokePath>> StrokePath::decode(Decoder& decoder)
>+Optional<StrokePath> StrokePath::decode(Decoder& decoder)
> {
> Optional<Path> path;
> decoder >> path;
> if (!path)
> return WTF::nullopt;
> 
>- return StrokePath::create(*path);
>+ return {{ WTFMove(*path) }};
> }
> 
>-class StrokeEllipse : public DrawingItem {
>+class StrokeEllipse {
> public:
>- static Ref<StrokeEllipse> create(const FloatRect& rect)
>+ static constexpr ItemType itemType = ItemType::StrokeEllipse;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true;
>+
>+ StrokeEllipse(const FloatRect& rect)
>+ : m_rect(rect)
> {
>- return adoptRef(*new StrokeEllipse(rect));
> }
> 
>- WEBCORE_EXPORT ~StrokeEllipse();
>+ const FloatRect& rect() const { return m_rect; }
> 
>- FloatRect rect() const { return m_rect; }
>+ void apply(GraphicsContext&) const;
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<StrokeEllipse>> decode(Decoder&);
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const;
> 
> private:
>- WEBCORE_EXPORT StrokeEllipse(const FloatRect&);
>-
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override;
>-
> FloatRect m_rect;
> };
> 
>-template<class Encoder>
>-void StrokeEllipse::encode(Encoder& encoder) const
>-{
>- encoder << m_rect;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<StrokeEllipse>> StrokeEllipse::decode(Decoder& decoder)
>-{
>- Optional<FloatRect> rect;
>- decoder >> rect;
>- if (!rect)
>- return WTF::nullopt;
>-
>- return StrokeEllipse::create(*rect);
>-}
>-
>-class ClearRect : public DrawingItem {
>+class ClearRect {
> public:
>- static Ref<ClearRect> create(const FloatRect& rect)
>+ static constexpr ItemType itemType = ItemType::ClearRect;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = true;
>+
>+ ClearRect(const FloatRect& rect)
>+ : m_rect(rect)
> {
>- return adoptRef(*new ClearRect(rect));
> }
> 
>- WEBCORE_EXPORT virtual ~ClearRect();
>+ const FloatRect& rect() const { return m_rect; }
> 
>- FloatRect rect() const { return m_rect; }
>+ void apply(GraphicsContext&) const;
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<ClearRect>> decode(Decoder&);
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return m_rect; }
> 
> private:
>- WEBCORE_EXPORT ClearRect(const FloatRect&);
>-
>- void apply(GraphicsContext&) const override;
>- Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
>-
> FloatRect m_rect;
> };
> 
>-template<class Encoder>
>-void ClearRect::encode(Encoder& encoder) const
>-{
>- encoder << m_rect;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<ClearRect>> ClearRect::decode(Decoder& decoder)
>-{
>- Optional<FloatRect> rect;
>- decoder >> rect;
>- if (!rect)
>- return WTF::nullopt;
>-
>- return ClearRect::create(*rect);
>-}
>-
> #if USE(CG)
>-class ApplyStrokePattern : public Item {
>-public:
>- static Ref<ApplyStrokePattern> create()
>- {
>- return adoptRef(*new ApplyStrokePattern);
>- }
>-
>- WEBCORE_EXPORT virtual ~ApplyStrokePattern();
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<ApplyStrokePattern>> decode(Decoder&);
>+class ApplyStrokePattern {
>+public:
>+ static constexpr ItemType itemType = ItemType::ApplyStrokePattern;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
> 
>-private:
>- WEBCORE_EXPORT ApplyStrokePattern();
>+ void apply(GraphicsContext&) const;
> 
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> };
> 
>-template<class Encoder>
>-void ApplyStrokePattern::encode(Encoder&) const
>-{
>-}
>-
>-template<class Decoder>
>-Optional<Ref<ApplyStrokePattern>> ApplyStrokePattern::decode(Decoder&)
>-{
>- return ApplyStrokePattern::create();
>-}
>-
>-class ApplyFillPattern : public Item {
>+class ApplyFillPattern {
> public:
>- static Ref<ApplyFillPattern> create()
>- {
>- return adoptRef(*new ApplyFillPattern);
>- }
>-
>- WEBCORE_EXPORT virtual ~ApplyFillPattern();
>+ static constexpr ItemType itemType = ItemType::ApplyFillPattern;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<ApplyFillPattern>> decode(Decoder&);
>+ void apply(GraphicsContext&) const;
> 
>-private:
>- WEBCORE_EXPORT ApplyFillPattern();
>-
>- void apply(GraphicsContext&) const override;
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> };
> 
>-template<class Encoder>
>-void ApplyFillPattern::encode(Encoder&) const
>-{
>-}
>-
>-template<class Decoder>
>-Optional<Ref<ApplyFillPattern>> ApplyFillPattern::decode(Decoder&)
>-{
>- return ApplyFillPattern::create();
>-}
> #endif
> 
>-class ApplyDeviceScaleFactor : public Item {
>+class ApplyDeviceScaleFactor {
> public:
>- static Ref<ApplyDeviceScaleFactor> create(float scaleFactor)
>+ static constexpr ItemType itemType = ItemType::ApplyDeviceScaleFactor;
>+ static constexpr bool isInlineItem = true;
>+ static constexpr bool isDrawingItem = false;
>+
>+ ApplyDeviceScaleFactor(float scaleFactor)
>+ : m_scaleFactor(scaleFactor)
> {
>- return adoptRef(*new ApplyDeviceScaleFactor(scaleFactor));
> }
> 
>- WEBCORE_EXPORT virtual ~ApplyDeviceScaleFactor();
>-
> float scaleFactor() const { return m_scaleFactor; }
> 
>- template<class Encoder> void encode(Encoder&) const;
>- template<class Decoder> static Optional<Ref<ApplyDeviceScaleFactor>> decode(Decoder&);
>+ void apply(GraphicsContext&) const;
> 
>-private:
>- WEBCORE_EXPORT ApplyDeviceScaleFactor(float scaleFactor);
>+ Optional<FloatRect> localBounds(const GraphicsContext&) const { return WTF::nullopt; }
>+ Optional<FloatRect> globalBounds() const { return WTF::nullopt; }
> 
>- void apply(GraphicsContext&) const override;
>-
>- float m_scaleFactor;
>+private:
>+ float m_scaleFactor { 1 };
> };
> 
>-template<class Encoder>
>-void ApplyDeviceScaleFactor::encode(Encoder& encoder) const
>-{
>- encoder << m_scaleFactor;
>-}
>-
>-template<class Decoder>
>-Optional<Ref<ApplyDeviceScaleFactor>> ApplyDeviceScaleFactor::decode(Decoder& decoder)
>-{
>- Optional<float> scaleFactor;
>- decoder >> scaleFactor;
>- if (!scaleFactor)
>- return WTF::nullopt;
>-
>- return ApplyDeviceScaleFactor::create(*scaleFactor);
>-}
>-
>-
>-WTF::TextStream& operator<<(WTF::TextStream&, const Item&);
>-
>-template<class Encoder>
>-void Item::encode(Encoder& encoder) const
>-{
>- encoder << m_type;
>-
>- switch (m_type) {
>- case ItemType::Save:
>- encoder << downcast<Save>(*this);
>- break;
>- case ItemType::Restore:
>- encoder << downcast<Restore>(*this);
>- break;
>- case ItemType::Translate:
>- encoder << downcast<Translate>(*this);
>- break;
>- case ItemType::Rotate:
>- encoder << downcast<Rotate>(*this);
>- break;
>- case ItemType::Scale:
>- encoder << downcast<Scale>(*this);
>- break;
>- case ItemType::SetCTM:
>- encoder << downcast<SetCTM>(*this);
>- break;
>- case ItemType::ConcatenateCTM:
>- encoder << downcast<ConcatenateCTM>(*this);
>- break;
>- case ItemType::SetInlineFillGradient:
>- encoder << downcast<SetInlineFillGradient>(*this);
>- break;
>- case ItemType::SetInlineFillColor:
>- encoder << downcast<SetInlineFillColor>(*this);
>- break;
>- case ItemType::SetInlineStrokeColor:
>- encoder << downcast<SetInlineStrokeColor>(*this);
>- break;
>- case ItemType::SetStrokeThickness:
>- encoder << downcast<SetStrokeThickness>(*this);
>- break;
>- case ItemType::SetState:
>- encoder << downcast<SetState>(*this);
>- break;
>- case ItemType::SetLineCap:
>- encoder << downcast<SetLineCap>(*this);
>- break;
>- case ItemType::SetLineDash:
>- encoder << downcast<SetLineDash>(*this);
>- break;
>- case ItemType::SetLineJoin:
>- encoder << downcast<SetLineJoin>(*this);
>- break;
>- case ItemType::SetMiterLimit:
>- encoder << downcast<SetMiterLimit>(*this);
>- break;
>- case ItemType::ClearShadow:
>- encoder << downcast<ClearShadow>(*this);
>- break;
>- case ItemType::Clip:
>- encoder << downcast<Clip>(*this);
>- break;
>- case ItemType::ClipOut:
>- encoder << downcast<ClipOut>(*this);
>- break;
>- case ItemType::ClipOutToPath:
>- encoder << downcast<ClipOutToPath>(*this);
>- break;
>- case ItemType::ClipPath:
>- encoder << downcast<ClipPath>(*this);
>- break;
>- case ItemType::ClipToDrawingCommands:
>- encoder << downcast<ClipToDrawingCommands>(*this);
>- break;
>- case ItemType::DrawGlyphs:
>- encoder << downcast<DrawGlyphs>(*this);
>- break;
>- case ItemType::DrawImage:
>- encoder << downcast<DrawImage>(*this);
>- break;
>- case ItemType::DrawTiledImage:
>- encoder << downcast<DrawTiledImage>(*this);
>- break;
>- case ItemType::DrawTiledScaledImage:
>- encoder << downcast<DrawTiledScaledImage>(*this);
>- break;
>- case ItemType::DrawImageBuffer:
>- encoder << downcast<DrawImageBuffer>(*this);
>- break;
>- case ItemType::DrawNativeImage:
>- encoder << downcast<DrawNativeImage>(*this);
>- break;
>- case ItemType::DrawPattern:
>- encoder << downcast<DrawPattern>(*this);
>- break;
>- case ItemType::DrawRect:
>- encoder << downcast<DrawRect>(*this);
>- break;
>- case ItemType::DrawLine:
>- encoder << downcast<DrawLine>(*this);
>- break;
>- case ItemType::DrawLinesForText:
>- encoder << downcast<DrawLinesForText>(*this);
>- break;
>- case ItemType::DrawDotsForDocumentMarker:
>- encoder << downcast<DrawDotsForDocumentMarker>(*this);
>- break;
>- case ItemType::DrawEllipse:
>- encoder << downcast<DrawEllipse>(*this);
>- break;
>- case ItemType::DrawPath:
>- encoder << downcast<DrawPath>(*this);
>- break;
>- case ItemType::DrawFocusRingPath:
>- encoder << downcast<DrawFocusRingPath>(*this);
>- break;
>- case ItemType::DrawFocusRingRects:
>- encoder << downcast<DrawFocusRingRects>(*this);
>- break;
>- case ItemType::FillRect:
>- encoder << downcast<FillRect>(*this);
>- break;
>- case ItemType::FillRectWithColor:
>- encoder << downcast<FillRectWithColor>(*this);
>- break;
>- case ItemType::FillRectWithGradient:
>- encoder << downcast<FillRectWithGradient>(*this);
>- break;
>- case ItemType::FillCompositedRect:
>- encoder << downcast<FillCompositedRect>(*this);
>- break;
>- case ItemType::FillRoundedRect:
>- encoder << downcast<FillRoundedRect>(*this);
>- break;
>- case ItemType::FillRectWithRoundedHole:
>- encoder << downcast<FillRectWithRoundedHole>(*this);
>- break;
>-#if ENABLE(INLINE_PATH_DATA)
>- case ItemType::FillInlinePath:
>- encoder << downcast<FillInlinePath>(*this);
>- break;
>-#endif
>- case ItemType::FillPath:
>- encoder << downcast<FillPath>(*this);
>- break;
>- case ItemType::FillEllipse:
>- encoder << downcast<FillEllipse>(*this);
>- break;
>- case ItemType::PutImageData:
>- encoder << downcast<PutImageData>(*this);
>- break;
>- case ItemType::PaintFrameForMedia:
>- encoder << downcast<PaintFrameForMedia>(*this);
>- break;
>- case ItemType::StrokeRect:
>- encoder << downcast<StrokeRect>(*this);
>- break;
>-#if ENABLE(INLINE_PATH_DATA)
>- case ItemType::StrokeInlinePath:
>- encoder << downcast<StrokeInlinePath>(*this);
>- break;
>-#endif
>- case ItemType::StrokePath:
>- encoder << downcast<StrokePath>(*this);
>- break;
>- case ItemType::StrokeEllipse:
>- encoder << downcast<StrokeEllipse>(*this);
>- break;
>- case ItemType::ClearRect:
>- encoder << downcast<ClearRect>(*this);
>- break;
>- case ItemType::BeginTransparencyLayer:
>- encoder << downcast<BeginTransparencyLayer>(*this);
>- break;
>- case ItemType::EndTransparencyLayer:
>- encoder << downcast<EndTransparencyLayer>(*this);
>- break;
>-#if USE(CG)
>- case ItemType::ApplyStrokePattern:
>- encoder << downcast<ApplyStrokePattern>(*this);
>- break;
>- case ItemType::ApplyFillPattern:
>- encoder << downcast<ApplyFillPattern>(*this);
>- break;
>-#endif
>- case ItemType::ApplyDeviceScaleFactor:
>- encoder << downcast<ApplyDeviceScaleFactor>(*this);
>- break;
>- }
>-}
>-
>-template<class Decoder>
>-Optional<Ref<Item>> Item::decode(Decoder& decoder)
>-{
>- Optional<ItemType> itemType;
>- decoder >> itemType;
>- if (!itemType)
>- return WTF::nullopt;
>-
>- switch (*itemType) {
>- case ItemType::Save:
>- if (auto item = Save::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::Restore:
>- if (auto item = Restore::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::Translate:
>- if (auto item = Translate::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::Rotate:
>- if (auto item = Rotate::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::Scale:
>- if (auto item = Scale::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::SetCTM:
>- if (auto item = SetCTM::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::ConcatenateCTM:
>- if (auto item = ConcatenateCTM::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::SetInlineFillGradient: {
>- if (auto item = SetInlineFillGradient::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- }
>- case ItemType::SetInlineFillColor:
>- if (auto item = SetInlineFillColor::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::SetInlineStrokeColor:
>- if (auto item = SetInlineStrokeColor::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::SetStrokeThickness:
>- if (auto item = SetStrokeThickness::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::SetState:
>- if (auto item = SetState::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::SetLineCap:
>- if (auto item = SetLineCap::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::SetLineDash:
>- if (auto item = SetLineDash::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::SetLineJoin:
>- if (auto item = SetLineJoin::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::SetMiterLimit:
>- if (auto item = SetMiterLimit::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::ClearShadow:
>- if (auto item = ClearShadow::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::Clip:
>- if (auto item = Clip::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::ClipOut:
>- if (auto item = ClipOut::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::ClipOutToPath:
>- if (auto item = ClipOutToPath::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::ClipPath:
>- if (auto item = ClipPath::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::ClipToDrawingCommands:
>- if (auto item = ClipToDrawingCommands::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawGlyphs:
>- if (auto item = DrawGlyphs::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawImage:
>- if (auto item = DrawImage::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawTiledImage:
>- if (auto item = DrawTiledImage::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawTiledScaledImage:
>- if (auto item = DrawTiledScaledImage::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawImageBuffer:
>- if (auto item = DrawImageBuffer::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawNativeImage:
>- if (auto item = DrawNativeImage::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawPattern:
>- if (auto item = DrawPattern::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawRect:
>- if (auto item = DrawRect::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawLine:
>- if (auto item = DrawLine::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawLinesForText:
>- if (auto item = DrawLinesForText::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawDotsForDocumentMarker:
>- if (auto item = DrawDotsForDocumentMarker::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawEllipse:
>- if (auto item = DrawEllipse::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawPath:
>- if (auto item = DrawPath::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawFocusRingPath:
>- if (auto item = DrawFocusRingPath::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::DrawFocusRingRects:
>- if (auto item = DrawFocusRingRects::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::FillRect:
>- if (auto item = FillRect::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::FillRectWithColor:
>- if (auto item = FillRectWithColor::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::FillRectWithGradient:
>- if (auto item = FillRectWithGradient::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::FillCompositedRect:
>- if (auto item = FillCompositedRect::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::FillRoundedRect:
>- if (auto item = FillRoundedRect::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::FillRectWithRoundedHole:
>- if (auto item = FillRectWithRoundedHole::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>-#if ENABLE(INLINE_PATH_DATA)
>- case ItemType::FillInlinePath:
>- if (auto item = FillInlinePath::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>-#endif
>- case ItemType::FillPath:
>- if (auto item = FillPath::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::FillEllipse:
>- if (auto item = FillEllipse::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::PutImageData:
>- if (auto item = PutImageData::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::PaintFrameForMedia:
>- if (auto item = PaintFrameForMedia::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::StrokeRect:
>- if (auto item = StrokeRect::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>-#if ENABLE(INLINE_PATH_DATA)
>- case ItemType::StrokeInlinePath:
>- if (auto item = StrokeInlinePath::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>-#endif
>- case ItemType::StrokePath:
>- if (auto item = StrokePath::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::StrokeEllipse:
>- if (auto item = StrokeEllipse::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::ClearRect:
>- if (auto item = ClearRect::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::BeginTransparencyLayer:
>- if (auto item = BeginTransparencyLayer::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::EndTransparencyLayer:
>- if (auto item = EndTransparencyLayer::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>-#if USE(CG)
>- case ItemType::ApplyStrokePattern:
>- if (auto item = ApplyStrokePattern::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- case ItemType::ApplyFillPattern:
>- if (auto item = ApplyFillPattern::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>-#endif
>- case ItemType::ApplyDeviceScaleFactor:
>- if (auto item = ApplyDeviceScaleFactor::decode(decoder))
>- return static_reference_cast<Item>(WTFMove(*item));
>- break;
>- }
>-
>- return WTF::nullopt;
>-}
>+TextStream& operator<<(TextStream&, ItemHandle);
> 
> } // namespace DisplayList
> } // namespace WebCore
> 
>-
>-#define SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_DRAWINGITEM(ToValueTypeName, predicate) \
>-SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::DisplayList::ToValueTypeName) \
>- static bool isType(const WebCore::DisplayList::Item& object) { return object.predicate; } \
>-SPECIALIZE_TYPE_TRAITS_END()
>-
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_DRAWINGITEM(DrawingItem, isDrawingItem())
>-
>-#define SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ToValueTypeName) \
>-SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::DisplayList::ToValueTypeName) \
>- static bool isType(const WebCore::DisplayList::Item& item) { return item.type() == WebCore::DisplayList::ItemType::ToValueTypeName; } \
>-SPECIALIZE_TYPE_TRAITS_END()
>-
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Save)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Restore)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Translate)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Rotate)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Scale)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetCTM)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ConcatenateCTM)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetInlineFillGradient)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetInlineFillColor)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetInlineStrokeColor)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetStrokeThickness)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetState)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetLineCap)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetLineDash)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetLineJoin)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetMiterLimit)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Clip)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClipOut)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClipOutToPath)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClipPath)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClipToDrawingCommands)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawGlyphs)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawImage)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawTiledImage)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawTiledScaledImage)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawImageBuffer)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawNativeImage)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawPattern)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawRect)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawLine)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawLinesForText)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawDotsForDocumentMarker)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawEllipse)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawPath)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawFocusRingPath)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawFocusRingRects)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRect)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRectWithColor)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRectWithGradient)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillCompositedRect)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRoundedRect)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRectWithRoundedHole)
>-#if ENABLE(INLINE_PATH_DATA)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillInlinePath)
>-#endif
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillPath)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillEllipse)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(PutImageData)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(PaintFrameForMedia)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(StrokeRect)
>-#if ENABLE(INLINE_PATH_DATA)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(StrokeInlinePath)
>-#endif
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(StrokePath)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(StrokeEllipse)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClearRect)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(BeginTransparencyLayer)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(EndTransparencyLayer)
>-#if USE(CG)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ApplyStrokePattern)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ApplyFillPattern)
>-#endif
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ApplyDeviceScaleFactor)
>-SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClearShadow)
>-
> namespace WTF {
> 
> template<> struct EnumTraits<WebCore::DisplayList::ItemType> {
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp
>index 8d1b647bdd9f169efefb542544174621f06cb6e5..bf96637e8c5772013048b98c674dd663c56a4f96 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp
>@@ -55,7 +55,7 @@ Recorder::~Recorder()
> 
> void Recorder::putImageData(WebCore::AlphaPremultiplication inputFormat, const WebCore::ImageData& imageData, const WebCore::IntRect& srcRect, const WebCore::IntPoint& destPoint, WebCore::AlphaPremultiplication destFormat)
> {
>- appendItem(WebCore::DisplayList::PutImageData::create(inputFormat, imageData, srcRect, destPoint, destFormat));
>+ append<PutImageData>(inputFormat, imageData, srcRect, destPoint, destFormat);
> }
> 
> static bool containsOnlyInlineStateChanges(const GraphicsContextStateChange& changes, GraphicsContextState::StateChangeFlags changeFlags)
>@@ -86,31 +86,31 @@ static bool containsOnlyInlineStateChanges(const GraphicsContextStateChange& cha
> void Recorder::appendStateChangeItem(const GraphicsContextStateChange& changes, GraphicsContextState::StateChangeFlags changeFlags)
> {
> if (!containsOnlyInlineStateChanges(changes, changeFlags)) {
>- m_displayList.appendItem(SetState::create(changes.m_state, changeFlags));
>+ append<SetState>(changes.m_state, changeFlags);
> return;
> }
> 
> if (changeFlags.contains(GraphicsContextState::StrokeColorChange))
>- m_displayList.appendItem(SetInlineStrokeColor::create(changes.m_state.strokeColor.asInline()));
>+ append<SetInlineStrokeColor>(changes.m_state.strokeColor.asInline());
> 
> if (changeFlags.contains(GraphicsContextState::StrokeThicknessChange))
>- m_displayList.appendItem(SetStrokeThickness::create(changes.m_state.strokeThickness));
>+ append<SetStrokeThickness>(changes.m_state.strokeThickness);
> 
> if (changeFlags.contains(GraphicsContextState::FillColorChange))
>- m_displayList.appendItem(SetInlineFillColor::create(changes.m_state.fillColor.asInline()));
>+ append<SetInlineFillColor>(changes.m_state.fillColor.asInline());
> 
> if (changeFlags.contains(GraphicsContextState::FillGradientChange))
>- m_displayList.appendItem(SetInlineFillGradient::create(*changes.m_state.fillGradient));
>+ append<SetInlineFillGradient>(*changes.m_state.fillGradient);
> }
> 
>-void Recorder::willAppendItem(const Item& item)
>+void Recorder::willAppendItemOfType(ItemType type)
> {
> if (m_delegate)
>- m_delegate->willAppendItem(item);
>+ m_delegate->willAppendItemOfType(type);
> 
>- if (item.isDrawingItem()
>+ if (isDrawingItem(type)
> #if USE(CG)
>- || item.type() == ItemType::ApplyStrokePattern || item.type() == ItemType::ApplyStrokePattern
>+ || type == ItemType::ApplyStrokePattern || type == ItemType::ApplyStrokePattern
> #endif
> ) {
> GraphicsContextStateChange& stateChanges = currentState().stateChange;
>@@ -125,10 +125,10 @@ void Recorder::willAppendItem(const Item& item)
> }
> }
> 
>-void Recorder::didAppendItem(const Item& item)
>+void Recorder::didAppendItemOfType(ItemType type)
> {
> if (m_delegate)
>- m_delegate->didAppendItem(item);
>+ m_delegate->didAppendItemOfType(type);
> }
> 
> void Recorder::updateState(const GraphicsContextState& state, GraphicsContextState::StateChangeFlags flags)
>@@ -138,49 +138,49 @@ void Recorder::updateState(const GraphicsContextState& state, GraphicsContextSta
> 
> void Recorder::clearShadow()
> {
>- appendItem(ClearShadow::create());
>+ append<ClearShadow>();
> }
> 
> void Recorder::setLineCap(LineCap lineCap)
> {
>- appendItem(SetLineCap::create(lineCap));
>+ append<SetLineCap>(lineCap);
> }
> 
> void Recorder::setLineDash(const DashArray& dashArray, float dashOffset)
> {
>- appendItem(SetLineDash::create(dashArray, dashOffset));
>+ append<SetLineDash>(dashArray, dashOffset);
> }
> 
> void Recorder::setLineJoin(LineJoin lineJoin)
> {
>- appendItem(SetLineJoin::create(lineJoin));
>+ append<SetLineJoin>(lineJoin);
> }
> 
> void Recorder::setMiterLimit(float miterLimit)
> {
>- appendItem(SetMiterLimit::create(miterLimit));
>+ append<SetMiterLimit>(miterLimit);
> }
> 
> void Recorder::drawGlyphs(const Font& font, const GlyphBuffer& glyphBuffer, unsigned from, unsigned numGlyphs, const FloatPoint& startPoint, FontSmoothingMode smoothingMode)
> {
>- appendItemAndUpdateExtent(DrawGlyphs::create(font, glyphBuffer.glyphs(from), glyphBuffer.advances(from), numGlyphs, startPoint, smoothingMode));
>+ append<DrawGlyphs>(font, glyphBuffer.glyphs(from), glyphBuffer.advances(from), numGlyphs, startPoint, smoothingMode);
> }
> 
> ImageDrawResult Recorder::drawImage(Image& image, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& imagePaintingOptions)
> {
>- appendItemAndUpdateExtent(DrawImage::create(image, destination, source, imagePaintingOptions));
>+ append<DrawImage>(image, destination, source, imagePaintingOptions);
> return ImageDrawResult::DidRecord;
> }
> 
> ImageDrawResult Recorder::drawTiledImage(Image& image, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions& imagePaintingOptions)
> {
>- appendItemAndUpdateExtent(DrawTiledImage::create(image, destination, source, tileSize, spacing, imagePaintingOptions));
>+ append<DrawTiledImage>(image, destination, source, tileSize, spacing, imagePaintingOptions);
> return ImageDrawResult::DidRecord;
> }
> 
> ImageDrawResult Recorder::drawTiledImage(Image& image, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions& imagePaintingOptions)
> {
>- appendItemAndUpdateExtent(DrawTiledScaledImage::create(image, destination, source, tileScaleFactor, hRule, vRule, imagePaintingOptions));
>+ append<DrawTiledScaledImage>(image, destination, source, tileScaleFactor, hRule, vRule, imagePaintingOptions);
> return ImageDrawResult::DidRecord;
> }
> 
>@@ -189,23 +189,23 @@ bool Recorder::drawImageBuffer(WebCore::ImageBuffer& imageBuffer, const FloatRec
> if (!m_delegate || !m_delegate->lockRemoteImageBuffer(imageBuffer))
> return false;
> 
>- appendItemAndUpdateExtent(DrawImageBuffer::create(imageBuffer.renderingResourceIdentifier(), destRect, srcRect, options));
>+ append<DrawImageBuffer>(imageBuffer.renderingResourceIdentifier(), destRect, srcRect, options);
> return true;
> }
> 
> void Recorder::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
> {
>- appendItemAndUpdateExtent(DrawNativeImage::create(image, imageSize, destRect, srcRect, options));
>+ append<DrawNativeImage>(image, imageSize, destRect, srcRect, options);
> }
> 
> void Recorder::drawPattern(Image& image, const FloatRect& destRect, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& options)
> {
>- appendItemAndUpdateExtent(DrawPattern::create(image, destRect, tileRect, patternTransform, phase, spacing, options));
>+ append<DrawPattern>(image, destRect, tileRect, patternTransform, phase, spacing, options);
> }
> 
> void Recorder::save()
> {
>- appendItem(Save::create());
>+ append<Save>();
> m_stateStack.append(m_stateStack.last().cloneForSave());
> }
> 
>@@ -220,37 +220,37 @@ void Recorder::restore()
> // Have to avoid eliding nested Save/Restore when a descendant state contains drawing items.
> currentState().wasUsedForDrawing |= stateUsedForDrawing;
> 
>- appendItem(Restore::create());
>+ append<Restore>();
> }
> 
> void Recorder::translate(float x, float y)
> {
> currentState().translate(x, y);
>- appendItem(Translate::create(x, y));
>+ append<Translate>(x, y);
> }
> 
> void Recorder::rotate(float angleInRadians)
> {
> currentState().rotate(angleInRadians);
>- appendItem(Rotate::create(angleInRadians));
>+ append<Rotate>(angleInRadians);
> }
> 
> void Recorder::scale(const FloatSize& size)
> {
> currentState().scale(size);
>- appendItem(Scale::create(size));
>+ append<Scale>(size);
> }
> 
> void Recorder::concatCTM(const AffineTransform& transform)
> {
> currentState().concatCTM(transform);
>- appendItem(ConcatenateCTM::create(transform));
>+ append<ConcatenateCTM>(transform);
> }
> 
> void Recorder::setCTM(const AffineTransform& transform)
> {
> currentState().setCTM(transform);
>- appendItem(SetCTM::create(transform));
>+ append<SetCTM>(transform);
> }
> 
> AffineTransform Recorder::getCTM(GraphicsContext::IncludeDeviceScale)
>@@ -261,158 +261,158 @@ AffineTransform Recorder::getCTM(GraphicsContext::IncludeDeviceScale)
> 
> void Recorder::beginTransparencyLayer(float opacity)
> {
>- appendItemAndUpdateExtent(BeginTransparencyLayer::create(opacity));
>+ append<BeginTransparencyLayer>(opacity);
> }
> 
> void Recorder::endTransparencyLayer()
> {
>- appendItem(EndTransparencyLayer::create());
>+ append<EndTransparencyLayer>();
> }
> 
> void Recorder::drawRect(const FloatRect& rect, float borderThickness)
> {
>- appendItemAndUpdateExtent(DrawRect::create(rect, borderThickness));
>+ append<DrawRect>(rect, borderThickness);
> }
> 
> void Recorder::drawLine(const FloatPoint& point1, const FloatPoint& point2)
> {
>- appendItemAndUpdateExtent(DrawLine::create(point1, point2));
>+ append<DrawLine>(point1, point2);
> }
> 
> void Recorder::drawLinesForText(const FloatPoint& point, float thickness, const DashArray& widths, bool printing, bool doubleLines)
> {
>- appendItemAndUpdateExtent(DrawLinesForText::create(FloatPoint(), toFloatSize(point), thickness, widths, printing, doubleLines));
>+ append<DrawLinesForText>(FloatPoint(), toFloatSize(point), thickness, widths, printing, doubleLines);
> }
> 
> void Recorder::drawDotsForDocumentMarker(const FloatRect& rect, DocumentMarkerLineStyle style)
> {
>- appendItemAndUpdateExtent(DrawDotsForDocumentMarker::create(rect, style));
>+ append<DrawDotsForDocumentMarker>(rect, style);
> }
> 
> void Recorder::drawEllipse(const FloatRect& rect)
> {
>- appendItemAndUpdateExtent(DrawEllipse::create(rect));
>+ append<DrawEllipse>(rect);
> }
> 
> void Recorder::drawPath(const Path& path)
> {
>- appendItemAndUpdateExtent(DrawPath::create(path));
>+ append<DrawPath>(path);
> }
> 
> void Recorder::drawFocusRing(const Path& path, float width, float offset, const Color& color)
> {
>- appendItemAndUpdateExtent(DrawFocusRingPath::create(path, width, offset, color));
>+ append<DrawFocusRingPath>(path, width, offset, color);
> }
> 
> void Recorder::drawFocusRing(const Vector<FloatRect>& rects, float width, float offset, const Color& color)
> {
>- appendItemAndUpdateExtent(DrawFocusRingRects::create(rects, width, offset, color));
>+ append<DrawFocusRingRects>(rects, width, offset, color);
> }
> 
> void Recorder::fillRect(const FloatRect& rect)
> {
>- appendItemAndUpdateExtent(FillRect::create(rect));
>+ append<FillRect>(rect);
> }
> 
> void Recorder::fillRect(const FloatRect& rect, const Color& color)
> {
>- appendItemAndUpdateExtent(FillRectWithColor::create(rect, color));
>+ append<FillRectWithColor>(rect, color);
> }
> 
> void Recorder::fillRect(const FloatRect& rect, Gradient& gradient)
> {
>- appendItemAndUpdateExtent(FillRectWithGradient::create(rect, gradient));
>+ append<FillRectWithGradient>(rect, gradient);
> }
> 
> void Recorder::fillRect(const FloatRect& rect, const Color& color, CompositeOperator op, BlendMode blendMode)
> {
>- appendItemAndUpdateExtent(FillCompositedRect::create(rect, color, op, blendMode));
>+ append<FillCompositedRect>(rect, color, op, blendMode);
> }
> 
> void Recorder::fillRoundedRect(const FloatRoundedRect& rect, const Color& color, BlendMode blendMode)
> {
>- appendItemAndUpdateExtent(FillRoundedRect::create(rect, color, blendMode));
>+ append<FillRoundedRect>(rect, color, blendMode);
> }
> 
> void Recorder::fillRectWithRoundedHole(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color& color)
> {
>- appendItemAndUpdateExtent(FillRectWithRoundedHole::create(rect, roundedHoleRect, color));
>+ append<FillRectWithRoundedHole>(rect, roundedHoleRect, color);
> }
> 
> void Recorder::fillPath(const Path& path)
> {
> #if ENABLE(INLINE_PATH_DATA)
> if (path.hasInlineData()) {
>- appendItemAndUpdateExtent(FillInlinePath::create(path.inlineData()));
>+ append<FillInlinePath>(path.inlineData());
> return;
> }
> #endif
>- appendItemAndUpdateExtent(FillPath::create(path));
>+ append<FillPath>(path);
> }
> 
> void Recorder::fillEllipse(const FloatRect& rect)
> {
>- appendItemAndUpdateExtent(FillEllipse::create(rect));
>+ append<FillEllipse>(rect);
> }
> 
> void Recorder::strokeRect(const FloatRect& rect, float lineWidth)
> {
>- appendItemAndUpdateExtent(StrokeRect::create(rect, lineWidth));
>+ append<StrokeRect>(rect, lineWidth);
> }
> 
> void Recorder::strokePath(const Path& path)
> {
> #if ENABLE(INLINE_PATH_DATA)
> if (path.hasInlineData()) {
>- appendItemAndUpdateExtent(StrokeInlinePath::create(path.inlineData()));
>+ append<StrokeInlinePath>(path.inlineData());
> return;
> }
> #endif
>- appendItemAndUpdateExtent(StrokePath::create(path));
>+ append<StrokePath>(path);
> }
> 
> void Recorder::strokeEllipse(const FloatRect& rect)
> {
>- appendItemAndUpdateExtent(StrokeEllipse::create(rect));
>+ append<StrokeEllipse>(rect);
> }
> 
> void Recorder::clearRect(const FloatRect& rect)
> {
>- appendItemAndUpdateExtent(ClearRect::create(rect));
>+ append<ClearRect>(rect);
> }
> 
> #if USE(CG)
> void Recorder::applyStrokePattern()
> {
>- appendItem(ApplyStrokePattern::create());
>+ append<ApplyStrokePattern>();
> }
> 
> void Recorder::applyFillPattern()
> {
>- appendItem(ApplyFillPattern::create());
>+ append<ApplyFillPattern>();
> }
> #endif
> 
> void Recorder::clip(const FloatRect& rect)
> {
> currentState().clipBounds.intersect(rect);
>- appendItem(Clip::create(rect));
>+ append<Clip>(rect);
> }
> 
> void Recorder::clipOut(const FloatRect& rect)
> {
>- appendItem(ClipOut::create(rect));
>+ append<ClipOut>(rect);
> }
> 
> void Recorder::clipOut(const Path& path)
> {
>- appendItem(ClipOutToPath::create(path));
>+ append<ClipOutToPath>(path);
> }
> 
> void Recorder::clipPath(const Path& path, WindRule windRule)
> {
> currentState().clipBounds.intersect(path.fastBoundingRect());
>- appendItem(ClipPath::create(path, windRule));
>+ append<ClipPath>(path, windRule);
> }
> 
> IntRect Recorder::clipBounds()
>@@ -430,19 +430,19 @@ void Recorder::clipToDrawingCommands(const FloatRect& destination, ColorSpace co
> {
> auto recordingContext = makeUnique<DrawingContext>(destination.size());
> drawingFunction(recordingContext->context());
>- appendItem(ClipToDrawingCommands::create(destination, colorSpace, recordingContext->takeDisplayList()));
>+ append<ClipToDrawingCommands>(destination, colorSpace, recordingContext->takeDisplayList());
> }
> 
> void Recorder::paintFrameForMedia(MediaPlayer& player, const FloatRect& destination)
> {
>- appendItem(PaintFrameForMedia::create(player, destination));
>+ append<PaintFrameForMedia>(player, destination);
> }
> 
> void Recorder::applyDeviceScaleFactor(float deviceScaleFactor)
> {
> // FIXME: this changes the baseCTM, which will invalidate all of our cached extents.
> // Assert that it's only called early on?
>- appendItem(ApplyDeviceScaleFactor::create(deviceScaleFactor));
>+ append<ApplyDeviceScaleFactor>(deviceScaleFactor);
> }
> 
> FloatRect Recorder::roundToDevicePixels(const FloatRect& rect, GraphicsContext::RoundingMode)
>@@ -451,29 +451,6 @@ FloatRect Recorder::roundToDevicePixels(const FloatRect& rect, GraphicsContext::
> return rect;
> }
> 
>-void Recorder::appendItemAndUpdateExtent(Ref<DrawingItem>&& item)
>-{
>- DrawingItem& newItem = item.get();
>- appendItem(WTFMove(item));
>- updateItemExtent(newItem);
>-}
>-
>-void Recorder::appendItem(Ref<Item>&& item)
>-{
>- Item& newItem = item.get();
>- willAppendItem(item.get());
>- m_displayList.append(WTFMove(item));
>- didAppendItem(newItem);
>-}
>-
>-void Recorder::updateItemExtent(DrawingItem& item) const
>-{
>- if (Optional<FloatRect> rect = item.localBounds(graphicsContext()))
>- item.setExtent(extentFromLocalBounds(rect.value()));
>- else if (Optional<FloatRect> rect = item.globalBounds())
>- item.setExtent(rect.value());
>-}
>-
> // FIXME: share with ShadowData
> static inline float shadowPaintingExtent(float blurRadius)
> {
>@@ -493,7 +470,7 @@ FloatRect Recorder::extentFromLocalBounds(const FloatRect& rect) const
> float shadowRadius;
> Color shadowColor;
> if (graphicsContext().getShadow(shadowOffset, shadowRadius, shadowColor)) {
>- FloatRect shadowExtent= bounds;
>+ FloatRect shadowExtent = bounds;
> shadowExtent.move(shadowOffset);
> shadowExtent.inflate(shadowPaintingExtent(shadowRadius));
> bounds.unite(shadowExtent);
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h
>index 5b8a44c5180c1feae085c01a88d0854d695f95a9..fbc384a1c72dd7c74c219a460a1490f5c939e350 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h
>@@ -26,6 +26,7 @@
> #pragma once
> 
> #include "DisplayList.h"
>+#include "DisplayListItems.h"
> #include "GraphicsContextImpl.h"
> #include "Image.h" // For Image::TileRule.
> #include "TextFlags.h"
>@@ -47,8 +48,6 @@ struct ImagePaintingOptions;
> 
> namespace DisplayList {
> 
>-class DrawingItem;
>-
> class Recorder : public GraphicsContextImpl {
> WTF_MAKE_FAST_ALLOCATED;
> WTF_MAKE_NONCOPYABLE(Recorder);
>@@ -59,16 +58,14 @@ public:
> 
> WEBCORE_EXPORT void putImageData(AlphaPremultiplication inputFormat, const ImageData&, const IntRect& srcRect, const IntPoint& destPoint, AlphaPremultiplication destFormat);
> 
>- size_t itemCount() const { return m_displayList.itemCount(); }
>-
>- void appendItemAndUpdateExtent(Ref<DrawingItem>&&);
>+ bool isEmpty() const { return m_displayList.isEmpty(); }
> 
> class Delegate {
> public:
> virtual ~Delegate() { }
> virtual bool lockRemoteImageBuffer(WebCore::ImageBuffer&) { return false; }
>- virtual void willAppendItem(const Item&) { };
>- virtual void didAppendItem(const Item&) { };
>+ virtual void willAppendItemOfType(ItemType) { }
>+ virtual void didAppendItemOfType(ItemType) { }
> };
> 
> private:
>@@ -148,14 +145,34 @@ private:
> 
> FloatRect roundToDevicePixels(const FloatRect&, GraphicsContext::RoundingMode) override;
> 
>- void appendItem(Ref<Item>&&);
>- void willAppendItem(const Item&);
>- void didAppendItem(const Item&);
>+ template<typename T, class... Args>
>+ void append(Args&&... args)
>+ {
>+ willAppendItemOfType(T::itemType);
>+ m_displayList.append<T>(std::forward<Args>(args)...);
>+ didAppendItemOfType(T::itemType);
>+
>+ if (!T::isDrawingItem)
>+ return;
>+
>+ if (LIKELY(!m_displayList.tracksDrawingItemExtents()))
>+ return;
>+
>+ auto item = T(std::forward<Args>(args)...);
>+ if (auto rect = item.localBounds(graphicsContext()))
>+ m_displayList.addDrawingItemExtent(extentFromLocalBounds(*rect));
>+ else if (auto rect = item.globalBounds())
>+ m_displayList.addDrawingItemExtent(*rect);
>+ else
>+ m_displayList.addDrawingItemExtent(WTF::nullopt);
>+ }
>+
>+ void willAppendItemOfType(ItemType);
>+ void didAppendItemOfType(ItemType);
> 
> void appendStateChangeItem(const GraphicsContextStateChange&, GraphicsContextState::StateChangeFlags);
> 
> FloatRect extentFromLocalBounds(const FloatRect&) const;
>- void updateItemExtent(DrawingItem&) const;
> 
> const AffineTransform& ctm() const;
> const FloatRect& clipBounds() const;
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.cpp
>index cf4e746e82dfd4b733c3bbf7e8245e5af973540f..d6bebba2e4289c8fd30c3d3965d15d90c30c4491 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.cpp
>@@ -52,15 +52,11 @@ std::unique_ptr<DisplayList> Replayer::replay(const FloatRect& initialClip, bool
> if (UNLIKELY(trackReplayList))
> replayList = makeUnique<DisplayList>();
> 
>- size_t numItems = m_displayList.itemCount();
>- for (size_t i = 0; i < numItems; ++i) {
>- auto& item = m_displayList.list()[i].get();
>-
>- if (!initialClip.isZero() && is<DrawingItem>(item)) {
>- const DrawingItem& drawingItem = downcast<DrawingItem>(item);
>- if (drawingItem.extentKnown() && !drawingItem.extent().intersects(initialClip)) {
>+ m_displayList.map([&] (ItemHandle item, Optional<FloatRect>&& extent) {
>+ if (!initialClip.isZero() && item.isDrawingItem()) {
>+ if (extent && !extent->intersects(initialClip)) {
> LOG_WITH_STREAM(DisplayLists, stream << "skipping " <- continue;
>+ return;
> }
> }
> 
>@@ -68,10 +64,13 @@ std::unique_ptr<DisplayList> Replayer::replay(const FloatRect& initialClip, bool
> if (!m_delegate || !m_delegate->apply(item, m_context))
> item.apply(m_context);
> 
>- if (UNLIKELY(trackReplayList))
>- replayList->appendItem(const_cast<Item&>(item));
>- }
>- 
>+ if (UNLIKELY(trackReplayList)) {
>+ replayList->append(item);
>+ if (item.isDrawingItem())
>+ replayList->addDrawingItemExtent(WTFMove(extent));
>+ }
>+ });
>+
> return replayList;
> }
> 
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.h b/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.h
>index 40cd0ff0d41680cfc73e504decfc3def87753233..045cacce8a01c8d5dcb658c40d63e9a3589b5b66 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.h
>@@ -50,7 +50,7 @@ public:
> class Delegate {
> public:
> virtual ~Delegate() { }
>- virtual bool apply(Item&, GraphicsContext&) { return false; }
>+ virtual bool apply(ItemHandle, GraphicsContext&) { return false; }
> };
> 
> private:
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h b/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h
>index ced1ca90fcb8e2a87fe434bbb977aea506e9c65b..4a12379b1757bbbd2fcc7c688a2562076f685d5f 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h
>@@ -27,14 +27,17 @@
> 
> #if ENABLE(GPU_PROCESS)
> 
>+#include "Decoder.h"
> #include "GPUConnectionToWebProcess.h"
> #include <WebCore/ConcreteImageBuffer.h>
>+#include <WebCore/DisplayList.h>
>+#include <WebCore/DisplayListItems.h>
> #include <WebCore/DisplayListReplayer.h>
> 
> namespace WebKit {
> 
> template<typename BackendType>
>-class RemoteImageBuffer : public WebCore::ConcreteImageBuffer<BackendType>, public WebCore::DisplayList::Replayer::Delegate {
>+class RemoteImageBuffer : public WebCore::ConcreteImageBuffer<BackendType>, public WebCore::DisplayList::Replayer::Delegate, public WebCore::DisplayList::ItemBufferReadingClient {
> using BaseConcreteImageBuffer = WebCore::ConcreteImageBuffer<BackendType>;
> using BaseConcreteImageBuffer::context;
> using BaseConcreteImageBuffer::m_backend;
>@@ -64,16 +67,16 @@ public:
> private:
> void flushDisplayList(const WebCore::DisplayList::DisplayList& displayList) override
> {
>- if (displayList.itemCount()) {
>+ if (!displayList.isEmpty()) {
> WebCore::DisplayList::Replayer replayer(BaseConcreteImageBuffer::context(), displayList, this);
> replayer.replay();
> }
> }
> 
>- bool apply(WebCore::DisplayList::Item& item, WebCore::GraphicsContext& context) override
>+ bool apply(WebCore::DisplayList::ItemHandle item, WebCore::GraphicsContext& context) override
> {
>- if (item.type() == WebCore::DisplayList::ItemType::PutImageData) {
>- auto& putImageDataItem = static_cast<WebCore::DisplayList::PutImageData&>(item);
>+ if (item.is<WebCore::DisplayList::PutImageData>()) {
>+ auto& putImageDataItem = item.get<WebCore::DisplayList::PutImageData>();
> putImageData(putImageDataItem.inputFormat(), putImageDataItem.imageData(), putImageDataItem.srcRect(), putImageDataItem.destPoint(), putImageDataItem.destFormat());
> return true;
> }
>@@ -84,6 +87,187 @@ private:
> return m_remoteRenderingBackend.applyMediaItem(item, context);
> }
> 
>+ bool requiresDecoding(WebCore::DisplayList::ItemType type) const override
>+ {
>+ return !WebCore::DisplayList::isInlineItem(type);
>+ }
>+
>+ bool WARN_UNUSED_RETURN decodeItem(const uint8_t* data, size_t length, WebCore::DisplayList::ItemHandle& handle) override
>+ {
>+ switch (handle.type()) {
>+ case WebCore::DisplayList::ItemType::ClipOutToPath: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::ClipOutToPath>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::ClipOutToPath(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::ClipPath: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::ClipPath>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::ClipPath(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::ClipToDrawingCommands: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::ClipToDrawingCommands>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::ClipToDrawingCommands(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::DrawFocusRingPath: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::DrawFocusRingPath>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::DrawFocusRingPath(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::DrawFocusRingRects: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::DrawFocusRingRects>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::DrawFocusRingRects(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::DrawGlyphs: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::DrawGlyphs>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::DrawGlyphs(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::DrawImage: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::DrawImage>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::DrawImage(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::DrawImageBuffer: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::DrawImageBuffer>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::DrawImageBuffer(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::DrawLinesForText: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::DrawLinesForText>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::DrawLinesForText(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::DrawNativeImage: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::DrawNativeImage>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::DrawNativeImage(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::DrawPath: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::DrawPath>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::DrawPath(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::DrawPattern: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::DrawPattern>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::DrawPattern(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::DrawTiledImage: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::DrawTiledImage>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::DrawTiledImage(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::DrawTiledScaledImage: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::DrawTiledScaledImage>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::DrawTiledScaledImage(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::FillCompositedRect: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::FillCompositedRect>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::FillCompositedRect(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::FillPath: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::FillPath>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::FillPath(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::FillRectWithColor: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::FillRectWithColor>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::FillRectWithColor(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::FillRectWithGradient: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::FillRectWithGradient>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::FillRectWithGradient(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::FillRectWithRoundedHole: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::FillRectWithRoundedHole>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::FillRectWithRoundedHole(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::FillRoundedRect: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::FillRoundedRect>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::FillRoundedRect(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::PutImageData: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::PutImageData>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::PutImageData(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::SetLineDash: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::SetLineDash>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::SetLineDash(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::SetState: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::SetState>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::SetState(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ case WebCore::DisplayList::ItemType::StrokePath: {
>+ if (auto item = IPC::Decoder::decodeObject<WebCore::DisplayList::StrokePath>(data, length)) {
>+ new (handle.data + sizeof(WebCore::DisplayList::ItemType)) WebCore::DisplayList::StrokePath(WTFMove(*item));
>+ return true;
>+ }
>+ return false;
>+ }
>+ default:
>+ RELEASE_ASSERT_NOT_REACHED();
>+ }
>+ }
>+
> RemoteRenderingBackend& m_remoteRenderingBackend;
> };
> 
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>index d5bb0f2d03e6f35a98e419c415d056b294be57ba..465b6f590389c0f0281e45ad464162eca005f3fd 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>@@ -72,10 +72,10 @@ uint64_t RemoteRenderingBackend::messageSenderDestinationID() const
> return m_renderingBackendIdentifier.toUInt64();
> }
> 
>-bool RemoteRenderingBackend::applyResourceItem(const DisplayList::Item& item, GraphicsContext& context)
>+bool RemoteRenderingBackend::applyResourceItem(DisplayList::ItemHandle item, GraphicsContext& context)
> {
>- if (item.type() == DisplayList::ItemType::DrawImageBuffer) {
>- auto& drawItem = static_cast<const DisplayList::DrawImageBuffer&>(item);
>+ if (item.is<DisplayList::DrawImageBuffer>()) {
>+ auto& drawItem = item.get<DisplayList::DrawImageBuffer>();
> auto imageBuffer = m_remoteResourceCache.cachedImageBuffer(drawItem.renderingResourceIdentifier());
> if (!imageBuffer)
> return false;
>@@ -87,13 +87,12 @@ bool RemoteRenderingBackend::applyResourceItem(const DisplayList::Item& item, Gr
> return false;
> }
> 
>-bool RemoteRenderingBackend::applyMediaItem(const DisplayList::Item& item, GraphicsContext& context)
>+bool RemoteRenderingBackend::applyMediaItem(DisplayList::ItemHandle item, GraphicsContext& context)
> {
>- if (item.type() != WebCore::DisplayList::ItemType::PaintFrameForMedia)
>+ if (!item.is<DisplayList::PaintFrameForMedia>())
> return false;
> 
>- auto& mediaItem = static_cast<const DisplayList::PaintFrameForMedia&>(item);
>-
>+ auto& mediaItem = item.get<DisplayList::PaintFrameForMedia>();
> auto process = gpuConnectionToWebProcess();
> if (!process)
> return false;
>@@ -140,19 +139,49 @@ void RemoteRenderingBackend::createImageBuffer(const FloatSize& logicalSize, Ren
> ASSERT_NOT_REACHED();
> }
> 
>-void RemoteRenderingBackend::flushDisplayList(const WebCore::DisplayList::DisplayList& displayList, RenderingResourceIdentifier renderingResourceIdentifier)
>+void RemoteRenderingBackend::applyDisplayList(const SharedDisplayListHandle& handle, RenderingResourceIdentifier renderingResourceIdentifier, ShouldFlushContext flushContext)
> {
>- if (auto imageBuffer = m_remoteResourceCache.cachedImageBuffer(renderingResourceIdentifier))
>- imageBuffer->flushDisplayList(displayList);
>+ Vector<WebCore::DisplayList::ItemBufferIdentifier> bufferIdentifiers;
>+ auto displayList = handle.createDisplayList([&] (WebCore::DisplayList::ItemBufferIdentifier identifier) -> uint8_t* {
>+ bufferIdentifiers.append(identifier);
>+ if (auto sharedMemory = sharedItemBuffer(identifier))
>+ return reinterpret_cast<uint8_t*>(sharedMemory->data());
>+ return nullptr;
>+ });
>+
>+ if (!displayList) {
>+ // FIXME: Add a message check to terminate the web process.
>+ return;
>+ }
>+
>+ auto imageBuffer = m_remoteResourceCache.cachedImageBuffer(renderingResourceIdentifier);
>+ if (!imageBuffer) {
>+ // FIXME: Add a message check to terminate the web process.
>+ return;
>+ }
>+
>+ if (imageBuffer->isAccelerated())
>+ displayList->setItemBufferClient(downcast<AcceleratedRemoteImageBuffer>(imageBuffer));
>+ else
>+ displayList->setItemBufferClient(downcast<UnacceleratedRemoteImageBuffer>(imageBuffer));
>+
>+ imageBuffer->flushDisplayList(*displayList);
>+
>+ if (flushContext == ShouldFlushContext::Yes)
>+ imageBuffer->flushContext();
>+
>+ send(Messages::RemoteRenderingBackendProxy::ReleaseSharedItemBuffers(WTFMove(bufferIdentifiers), renderingResourceIdentifier), m_renderingBackendIdentifier);
> }
> 
>-void RemoteRenderingBackend::flushDisplayListAndCommit(const WebCore::DisplayList::DisplayList& displayList, DisplayListFlushIdentifier flushIdentifier, RenderingResourceIdentifier renderingResourceIdentifier)
>+void RemoteRenderingBackend::flushDisplayList(const SharedDisplayListHandle& handle, RenderingResourceIdentifier renderingResourceIdentifier)
> {
>- if (auto imageBuffer = m_remoteResourceCache.cachedImageBuffer(renderingResourceIdentifier)) {
>- imageBuffer->flushDisplayList(displayList);
>- imageBuffer->flushContext();
>- flushDisplayListWasCommitted(flushIdentifier, renderingResourceIdentifier);
>- }
>+ applyDisplayList(handle, renderingResourceIdentifier, ShouldFlushContext::No);
>+}
>+
>+void RemoteRenderingBackend::flushDisplayListAndCommit(const SharedDisplayListHandle& handle, DisplayListFlushIdentifier flushIdentifier, RenderingResourceIdentifier renderingResourceIdentifier)
>+{
>+ applyDisplayList(handle, renderingResourceIdentifier, ShouldFlushContext::Yes);
>+ flushDisplayListWasCommitted(flushIdentifier, renderingResourceIdentifier);
> }
> 
> void RemoteRenderingBackend::getImageData(WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, RenderingResourceIdentifier renderingResourceIdentifier, CompletionHandler<void(IPC::ImageDataReference&&)>&& completionHandler)
>@@ -168,6 +197,17 @@ void RemoteRenderingBackend::releaseRemoteResource(RenderingResourceIdentifier r
> m_remoteResourceCache.releaseRemoteResource(renderingResourceIdentifier);
> }
> 
>+void RemoteRenderingBackend::didCreateSharedItemData(DisplayList::ItemBufferIdentifier identifier, const SharedMemory::IPCHandle& handle)
>+{
>+ if (auto sharedMemory = SharedMemory::map(handle.handle, SharedMemory::Protection::ReadOnly))
>+ m_sharedItemBuffers.set(identifier, WTFMove(sharedMemory));
>+}
>+
>+RefPtr<SharedMemory> RemoteRenderingBackend::sharedItemBuffer(DisplayList::ItemBufferIdentifier identifier) const
>+{
>+ return m_sharedItemBuffers.get(identifier);
>+}
>+
> } // namespace WebKit
> 
> #endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>index 285e2f74b4d4fd6e6a8c5e91025a1c926f5ffb15..fdaa68635a217a4f2e3294e01aa3dfb4f15b74b0 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>@@ -35,7 +35,9 @@
> #include "MessageSender.h"
> #include "RemoteResourceCache.h"
> #include "RenderingBackendIdentifier.h"
>+#include "SharedDisplayListHandle.h"
> #include <WebCore/ColorSpace.h>
>+#include <WebCore/DisplayList.h>
> #include <WebCore/DisplayListItems.h>
> #include <wtf/WeakPtr.h>
> 
>@@ -63,8 +65,8 @@ public:
> GPUConnectionToWebProcess* gpuConnectionToWebProcess() const;
> 
> // Rendering operations.
>- bool applyResourceItem(const WebCore::DisplayList::Item&, WebCore::GraphicsContext&);
>- bool applyMediaItem(const WebCore::DisplayList::Item&, WebCore::GraphicsContext&);
>+ bool applyResourceItem(WebCore::DisplayList::ItemHandle, WebCore::GraphicsContext&);
>+ 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, ImageBufferBackendHandle, WebCore::RenderingResourceIdentifier);
>@@ -73,6 +75,10 @@ public:
> private:
> RemoteRenderingBackend(GPUConnectionToWebProcess&, RenderingBackendIdentifier);
> 
>+ enum class ShouldFlushContext : bool { No, Yes };
>+ void applyDisplayList(const SharedDisplayListHandle&, WebCore::RenderingResourceIdentifier, ShouldFlushContext);
>+ RefPtr<SharedMemory> sharedItemBuffer(WebCore::DisplayList::ItemBufferIdentifier) const;
>+
> // IPC::MessageSender.
> IPC::Connection* messageSenderConnection() const override;
> uint64_t messageSenderDestinationID() const override;
>@@ -83,14 +89,16 @@ private:
> 
> // Messages to be received.
> void createImageBuffer(const WebCore::FloatSize& logicalSize, WebCore::RenderingMode, float resolutionScale, WebCore::ColorSpace, WebCore::RenderingResourceIdentifier);
>- void flushDisplayList(const WebCore::DisplayList::DisplayList&, WebCore::RenderingResourceIdentifier);
>- void flushDisplayListAndCommit(const WebCore::DisplayList::DisplayList&, DisplayListFlushIdentifier, WebCore::RenderingResourceIdentifier);
>+ void flushDisplayList(const SharedDisplayListHandle&, WebCore::RenderingResourceIdentifier);
>+ void flushDisplayListAndCommit(const SharedDisplayListHandle&, DisplayListFlushIdentifier, WebCore::RenderingResourceIdentifier);
> void getImageData(WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, WebCore::RenderingResourceIdentifier, CompletionHandler<void(IPC::ImageDataReference&&)>&&);
> void releaseRemoteResource(WebCore::RenderingResourceIdentifier);
>+ void didCreateSharedItemData(WebCore::DisplayList::ItemBufferIdentifier, const SharedMemory::IPCHandle&);
> 
> RemoteResourceCache m_remoteResourceCache;
> WeakPtr<GPUConnectionToWebProcess> m_gpuConnectionToWebProcess;
> RenderingBackendIdentifier m_renderingBackendIdentifier;
>+ HashMap<WebCore::DisplayList::ItemBufferIdentifier, RefPtr<SharedMemory>> m_sharedItemBuffers;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in
>index a88e0fb626249189d8f5b3a39b9b66428622cad3..bb915ab195ad377720b69150a3bec0c993c5ac85 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in
>@@ -23,11 +23,12 @@
> #if ENABLE(GPU_PROCESS)
> 
> messages -> RemoteRenderingBackend NotRefCounted {
>- void CreateImageBuffer(WebCore::FloatSize logicalSize, WebCore::RenderingMode renderingMode, float resolutionScale, WebCore::ColorSpace colorSpace, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>- void FlushDisplayList(WebCore::DisplayList::DisplayList displayList, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>- void FlushDisplayListAndCommit(WebCore::DisplayList::DisplayList displayList, WebKit::DisplayListFlushIdentifier flushIdentifier, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>+ CreateImageBuffer(WebCore::FloatSize logicalSize, WebCore::RenderingMode renderingMode, float resolutionScale, WebCore::ColorSpace colorSpace, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>+ FlushDisplayList(WebKit::SharedDisplayListHandle displayList, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>+ FlushDisplayListAndCommit(WebKit::SharedDisplayListHandle displayList, WebKit::DisplayListFlushIdentifier flushIdentifier, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
> GetImageData(enum:uint8_t WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, WebCore::RenderingResourceIdentifier renderingResourceIdentifier) -> (IPC::ImageDataReference imageData) Synchronous
>- void ReleaseRemoteResource(WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>+ DidCreateSharedItemData(WebCore::DisplayList::ItemBufferIdentifier identifier, WebKit::SharedMemory::IPCHandle handle)
>+ ReleaseRemoteResource(WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
> }
> 
> #endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/Platform/IPC/Decoder.cpp b/Source/WebKit/Platform/IPC/Decoder.cpp
>index 5ca2127a346cd2a469ca297f4ab13902f6a06f8a..51b9ffd930340bdff2fb71d0e46cacf409346531 100644
>--- a/Source/WebKit/Platform/IPC/Decoder.cpp
>+++ b/Source/WebKit/Platform/IPC/Decoder.cpp
>@@ -74,6 +74,16 @@ Decoder::Decoder(const uint8_t* buffer, size_t bufferSize, void (*bufferDealloca
> return;
> }
> 
>+Decoder::Decoder(const uint8_t* buffer, size_t bufferSize, ConstructWithoutHeaderTag)
>+ : m_buffer { buffer }
>+ , m_bufferPos { m_buffer }
>+ , m_bufferEnd { m_buffer + bufferSize }
>+ , m_bufferDeallocator([] (const uint8_t*, size_t) { })
>+{
>+ if (reinterpret_cast<uintptr_t>(m_buffer) % alignof(uint64_t))
>+ markInvalid();
>+}
>+
> Decoder::~Decoder()
> {
> ASSERT(m_buffer);
>diff --git a/Source/WebKit/Platform/IPC/Decoder.h b/Source/WebKit/Platform/IPC/Decoder.h
>index 3dd24696ef6ca7dc97d013a0fe875d7bd47de30a..a03ebb1b2837ef6a3873a115c4dbe0fc58cd9914 100644
>--- a/Source/WebKit/Platform/IPC/Decoder.h
>+++ b/Source/WebKit/Platform/IPC/Decoder.h
>@@ -30,6 +30,7 @@
> #include "MessageNames.h"
> #include "StringReference.h"
> #include <WebCore/ContextMenuItem.h>
>+#include <WebCore/SharedBuffer.h>
> #include <wtf/OptionSet.h>
> #include <wtf/Vector.h>
> 
>@@ -173,7 +174,22 @@ public:
> 
> static const bool isIPCDecoder = true;
> 
>+ template <typename T>
>+ static Optional<T> decodeObject(const uint8_t* buffer, size_t bufferSize)
>+ {
>+ Optional<T> result;
>+ Decoder decoder(buffer, bufferSize, ConstructWithoutHeader);
>+ if (!decoder.isValid())
>+ return WTF::nullopt;
>+
>+ decoder >> result;
>+ return result;
>+ }
>+
> private:
>+ enum ConstructWithoutHeaderTag { ConstructWithoutHeader };
>+ Decoder(const uint8_t* buffer, size_t bufferSize, ConstructWithoutHeaderTag);
>+
> bool alignBufferPosition(size_t alignment, size_t);
> bool bufferIsLargeEnoughToContain(size_t alignment, size_t) const;
> 
>diff --git a/Source/WebKit/Platform/IPC/Encoder.cpp b/Source/WebKit/Platform/IPC/Encoder.cpp
>index 87fe95552ac6052dbcd76e490d4ab6a662ec8ad4..b0556657cb06f24a4379bb33d5d7f97e120cd9cc 100644
>--- a/Source/WebKit/Platform/IPC/Encoder.cpp
>+++ b/Source/WebKit/Platform/IPC/Encoder.cpp
>@@ -72,6 +72,16 @@ Encoder::Encoder(MessageName messageName, uint64_t destinationID)
> encodeHeader();
> }
> 
>+Encoder::Encoder(ConstructWithoutHeaderTag)
>+ : m_messageName(static_cast<MessageName>(0))
>+ , m_destinationID(0)
>+ , m_buffer(m_inlineBuffer)
>+ , m_bufferPointer(m_inlineBuffer)
>+ , m_bufferSize(0)
>+ , m_bufferCapacity(sizeof(m_inlineBuffer))
>+{
>+}
>+
> Encoder::~Encoder()
> {
> if (m_buffer != m_inlineBuffer)
>@@ -219,7 +229,12 @@ void Encoder::addAttachment(Attachment&& attachment)
> 
> Vector<Attachment> Encoder::releaseAttachments()
> {
>- return WTFMove(m_attachments);
>+ return std::exchange(m_attachments, { });
>+}
>+
>+bool Encoder::hasAttachments() const
>+{
>+ return !m_attachments.isEmpty();
> }
> 
> } // namespace IPC
>diff --git a/Source/WebKit/Platform/IPC/Encoder.h b/Source/WebKit/Platform/IPC/Encoder.h
>index 3678d4fae29152d990f4d3a4f0b7e0af6cf7472b..efc96d74822395295cb599d6ad6a9594109faa95 100644
>--- a/Source/WebKit/Platform/IPC/Encoder.h
>+++ b/Source/WebKit/Platform/IPC/Encoder.h
>@@ -30,6 +30,7 @@
> #include "MessageNames.h"
> #include "StringReference.h"
> #include <WebCore/ContextMenuItem.h>
>+#include <WebCore/SharedBuffer.h>
> #include <wtf/OptionSet.h>
> #include <wtf/Vector.h>
> 
>@@ -99,7 +100,24 @@ public:
> 
> static const bool isIPCEncoder = true;
> 
>+ template<typename T>
>+ static RefPtr<WebCore::SharedBuffer> encodeObject(const T& object)
>+ {
>+ Encoder encoder(ConstructWithoutHeader);
>+ encoder << object;
>+
>+ if (encoder.hasAttachments()) {
>+ ASSERT_NOT_REACHED();
>+ return nullptr;
>+ }
>+
>+ return WebCore::SharedBuffer::create(encoder.buffer(), encoder.bufferSize());
>+ }
>+
> private:
>+ enum ConstructWithoutHeaderTag { ConstructWithoutHeader };
>+ Encoder(ConstructWithoutHeaderTag);
>+
> uint8_t* grow(size_t alignment, size_t);
> 
> template<typename E, std::enable_if_t<std::is_enum<E>::value>* = nullptr>
>@@ -109,6 +127,8 @@ private:
> encode(WTF::enumToUnderlyingType<E>(enumValue));
> }
> 
>+ bool hasAttachments() const;
>+
> void encodeHeader();
> const OptionSet<MessageFlags>& messageFlags() const;
> OptionSet<MessageFlags>& messageFlags();
>diff --git a/Source/WebKit/Scripts/webkit/messages.py b/Source/WebKit/Scripts/webkit/messages.py
>index 99111a7890b5785f4e1062d688206547d52503bd..9ff948e8be1aaedd093b4be2993460e2cd99b26a 100644
>--- a/Source/WebKit/Scripts/webkit/messages.py
>+++ b/Source/WebKit/Scripts/webkit/messages.py
>@@ -208,6 +208,7 @@ def types_that_cannot_be_forward_declared():
> 'String',
> 'WebCore::ColorSpace',
> 'WebCore::DictationContext',
>+ 'WebCore::DisplayList::ItemBufferIdentifier',
> 'WebCore::DragApplicationFlags',
> 'WebCore::DocumentIdentifier',
> 'WebCore::DocumentOrWorkerIdentifier',
>@@ -585,6 +586,7 @@ def headers_for_type(type):
> 'JSC::MessageSource': ['<JavaScriptCore/ConsoleTypes.h>'],
> 'Inspector::InspectorTargetType': ['<JavaScriptCore/InspectorTarget.h>'],
> 'Inspector::FrontendChannel::ConnectionType': ['<JavaScriptCore/InspectorFrontendChannel.h>'],
>+ 'WebCore::DisplayList::ItemBufferIdentifier': ['<WebCore/DisplayListItemBuffer.h>'],
> 'MediaTime': ['<wtf/MediaTime.h>'],
> 'MonotonicTime': ['<wtf/MonotonicTime.h>'],
> 'Seconds': ['<wtf/Seconds.h>'],
>diff --git a/Source/WebKit/Shared/SharedDisplayListHandle.cpp b/Source/WebKit/Shared/SharedDisplayListHandle.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..67a20d2a3dc6d93ead93feb6cdc7e48e4dcf6022
>--- /dev/null
>+++ b/Source/WebKit/Shared/SharedDisplayListHandle.cpp
>@@ -0,0 +1,53 @@
>+/*
>+ * Copyright (C) 2020 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ * notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ * notice, this list of conditions and the following disclaimer in the
>+ * documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "SharedDisplayListHandle.h"
>+
>+namespace WebKit {
>+using namespace WebCore;
>+
>+SharedDisplayListHandle::SharedDisplayListHandle(const DisplayList::DisplayList& displayList)
>+{
>+ displayList.forEachItemBuffer([&] (auto& handle) {
>+ m_buffers.append({ handle.identifier, handle.capacity });
>+ });
>+}
>+
>+std::unique_ptr<DisplayList::DisplayList> SharedDisplayListHandle::createDisplayList(ItemBufferProvider&& bufferProvider) const
>+{
>+ DisplayList::ItemBufferHandles handles;
>+ handles.reserveInitialCapacity(m_buffers.size());
>+ for (auto& [identifier, capacity] : m_buffers) {
>+ auto* data = bufferProvider(identifier);
>+ if (!data)
>+ return nullptr;
>+
>+ handles.uncheckedAppend({ identifier, data, 0, capacity });
>+ }
>+ return makeUnique<DisplayList::DisplayList>(WTFMove(handles));
>+}
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/Shared/SharedDisplayListHandle.h b/Source/WebKit/Shared/SharedDisplayListHandle.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..d175e114f23bc8fb8e57cd90f64a33be262e1f31
>--- /dev/null
>+++ b/Source/WebKit/Shared/SharedDisplayListHandle.h
>@@ -0,0 +1,66 @@
>+/*
>+ * 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 <WebCore/DisplayList.h>
>+
>+namespace WebKit {
>+
>+class SharedDisplayListHandle {
>+public:
>+ using ItemBufferProvider = Function<uint8_t*(WebCore::DisplayList::ItemBufferIdentifier)>;
>+
>+ SharedDisplayListHandle(const WebCore::DisplayList::DisplayList&);
>+ std::unique_ptr<WebCore::DisplayList::DisplayList> createDisplayList(ItemBufferProvider&&) const;
>+
>+ template<class Encoder> void encode(Encoder&) const;
>+ template<class Decoder> static Optional<SharedDisplayListHandle> decode(Decoder&);
>+
>+private:
>+ SharedDisplayListHandle(Vector<std::pair<WebCore::DisplayList::ItemBufferIdentifier, size_t>>&& buffers)
>+ : m_buffers(WTFMove(buffers))
>+ {
>+ }
>+
>+ Vector<std::pair<WebCore::DisplayList::ItemBufferIdentifier, size_t>> m_buffers;
>+};
>+
>+template<class Encoder> void SharedDisplayListHandle::encode(Encoder& encoder) const
>+{
>+ encoder << m_buffers;
>+}
>+
>+template<class Decoder> Optional<SharedDisplayListHandle> SharedDisplayListHandle::decode(Decoder& decoder)
>+{
>+ Optional<Vector<std::pair<WebCore::DisplayList::ItemBufferIdentifier, size_t>>> buffers;
>+ decoder >> buffers;
>+ if (!buffers)
>+ return WTF::nullopt;
>+
>+ return {{ WTFMove(*buffers) }};
>+}
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/Sources.txt b/Source/WebKit/Sources.txt
>index ffe9787deae547526736e2110042b0b9f8dc0801..8b4c4073fac2710260fa512ac448a66ed052bb66 100644
>--- a/Source/WebKit/Sources.txt
>+++ b/Source/WebKit/Sources.txt
>@@ -173,6 +173,7 @@ Shared/ServiceWorkerInitializationData.cpp
> Shared/SessionState.cpp
> Shared/ShareableBitmap.cpp @no-unify
> Shared/ShareableResource.cpp
>+Shared/SharedDisplayListHandle.cpp
> Shared/SharedStringHashStore.cpp
> Shared/SharedStringHashTableReadOnly.cpp
> Shared/SharedStringHashTable.cpp
>diff --git a/Source/WebKit/WebKit.xcodeproj/project.pbxproj b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>index 4406e9b6e7e6f4a0362e6c56bb849bfebec8c0c7..daaa904a056d222a115a01393a6e188312ff0c61 100644
>--- a/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>+++ b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>@@ -1874,6 +1874,7 @@
> 		F44DFEB21E9E752F0038D196 /* WebIconUtilities.h in Headers */ = {isa = PBXBuildFile; fileRef = F44DFEB01E9E752F0038D196 /* WebIconUtilities.h */; };
> 		F48D2A8521583A7E00C6752B /* AppKitSPI.h in Headers */ = {isa = PBXBuildFile; fileRef = F48D2A8421583A0200C6752B /* AppKitSPI.h */; };
> 		F496A4311F58A272004C1757 /* DragDropInteractionState.h in Headers */ = {isa = PBXBuildFile; fileRef = F496A42F1F58A272004C1757 /* DragDropInteractionState.h */; };
>+		F4A6D6BC254CA3E900B65FAA /* SharedDisplayListHandle.h in Headers */ = {isa = PBXBuildFile; fileRef = F4A6D6BB254CA3E900B65FAA /* SharedDisplayListHandle.h */; };
> 		F4CB09E5225D5A0900891487 /* WebsiteMediaSourcePolicy.h in Headers */ = {isa = PBXBuildFile; fileRef = F4CB09E4225D5A0300891487 /* WebsiteMediaSourcePolicy.h */; };
> 		F4D5F51D206087A10038BBA8 /* WKTextInputListViewController.h in Headers */ = {isa = PBXBuildFile; fileRef = F4D5F519206087A00038BBA8 /* WKTextInputListViewController.h */; };
> 		F4D5F51F206087A10038BBA8 /* WKQuickboardListViewController.h in Headers */ = {isa = PBXBuildFile; fileRef = F4D5F51B206087A10038BBA8 /* WKQuickboardListViewController.h */; };
>@@ -5462,6 +5463,8 @@
> 		F48D2A8421583A0200C6752B /* AppKitSPI.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppKitSPI.h; sourceTree = "<group>"; };
> 		F496A42F1F58A272004C1757 /* DragDropInteractionState.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = DragDropInteractionState.h; path = ios/DragDropInteractionState.h; sourceTree = "<group>"; };
> 		F496A4301F58A272004C1757 /* DragDropInteractionState.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; name = DragDropInteractionState.mm; path = ios/DragDropInteractionState.mm; sourceTree = "<group>"; };
>+		F4A6D6BB254CA3E900B65FAA /* SharedDisplayListHandle.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SharedDisplayListHandle.h; sourceTree = "<group>"; };
>+		F4A6D6BD254CA52200B65FAA /* SharedDisplayListHandle.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = SharedDisplayListHandle.cpp; sourceTree = "<group>"; };
> 		F4AC655E22A3140E00A05607 /* WebPreferencesDefaultValuesIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = WebPreferencesDefaultValuesIOS.mm; path = ios/WebPreferencesDefaultValuesIOS.mm; sourceTree = "<group>"; };
> 		F4B378D021DDBBAB0095A378 /* WebUndoStepID.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebUndoStepID.h; sourceTree = "<group>"; };
> 		F4CB09E4225D5A0300891487 /* WebsiteMediaSourcePolicy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebsiteMediaSourcePolicy.h; sourceTree = "<group>"; };
>@@ -6169,6 +6172,8 @@
> 				1A6420E312DCE2FF00CAAE2C /* ShareableBitmap.h */,
> 				5121745E164C20E30037A5C1 /* ShareableResource.cpp */,
> 				5121745F164C20E30037A5C1 /* ShareableResource.h */,
>+				F4A6D6BD254CA52200B65FAA /* SharedDisplayListHandle.cpp */,
>+				F4A6D6BB254CA3E900B65FAA /* SharedDisplayListHandle.h */,
> 				8313F7EA1F7DAE0400B944EB /* SharedStringHashStore.cpp */,
> 				8313F7E91F7DAE0300B944EB /* SharedStringHashStore.h */,
> 				8313F7E81F7DAE0300B944EB /* SharedStringHashTable.cpp */,
>@@ -11320,6 +11325,7 @@
> 				51217461164C20E30037A5C1 /* ShareableResource.h in Headers */,
> 				A183494224EF467800BDC9A8 /* SharedBufferCopy.h in Headers */,
> 				2DC18FF6EF2A3130C1301767 /* SharedBufferDataReference.h in Headers */,
>+				F4A6D6BC254CA3E900B65FAA /* SharedDisplayListHandle.h in Headers */,
> 				1A24BED5120894D100FBB059 /* SharedMemory.h in Headers */,
> 				CD4B4D9D1E765E0000D27092 /* SharedRingBufferStorage.h in Headers */,
> 				8313F7EC1F7DAE0800B944EB /* SharedStringHashStore.h in Headers */,
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>index 2264ebcb6664d71fff0a40042fb2542ca8066eb4..a72f79a8856345351cf711aba6dcc307cb704a5c 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>@@ -27,6 +27,10 @@
> 
> #if ENABLE(GPU_PROCESS)
> 
>+#include "Encoder.h"
>+#include "RemoteRenderingBackendProxy.h"
>+#include "SharedMemory.h"
>+#include <WebCore/DisplayList.h>
> #include <WebCore/DisplayListImageBuffer.h>
> #include <WebCore/DisplayListItems.h>
> #include <WebCore/DisplayListRecorder.h>
>@@ -36,7 +40,7 @@ namespace WebKit {
> class RemoteRenderingBackend;
> 
> template<typename BackendType>
>-class RemoteImageBufferProxy : public WebCore::DisplayList::ImageBuffer<BackendType>, public WebCore::DisplayList::Recorder::Delegate {
>+class RemoteImageBufferProxy : public WebCore::DisplayList::ImageBuffer<BackendType>, public WebCore::DisplayList::Recorder::Delegate, public WebCore::DisplayList::ItemBufferWritingClient {
> using BaseDisplayListImageBuffer = WebCore::DisplayList::ImageBuffer<BackendType>;
> using BaseDisplayListImageBuffer::m_backend;
> using BaseDisplayListImageBuffer::m_drawingContext;
>@@ -77,6 +81,8 @@ protected:
> , m_remoteRenderingBackendProxy(makeWeakPtr(remoteRenderingBackendProxy))
> {
> ASSERT(m_remoteRenderingBackendProxy);
>+ m_drawingContext.displayList().setItemBufferClient(this);
>+ m_drawingContext.displayList().setTracksDrawingItemExtents(false);
> }
> 
> bool isPendingFlush() const { return m_sentFlushIdentifier != m_receivedFlushIdentifier; }
>@@ -104,10 +110,12 @@ protected:
> if (!m_remoteRenderingBackendProxy)
> return nullptr;
> 
>- auto& displayList = const_cast<RemoteImageBufferProxy*>(this)->m_drawingContext.displayList();
>- if (displayList.itemCount()) {
>- const_cast<RemoteImageBufferProxy&>(*this).flushDisplayList(displayList);
>+ auto& mutableThis = const_cast<RemoteImageBufferProxy&>(*this);
>+ auto& displayList = mutableThis.m_drawingContext.displayList();
>+ if (!displayList.isEmpty()) {
>+ mutableThis.flushDisplayList(displayList);
> displayList.clear();
>+ mutableThis.m_itemCountInCurrentDisplayList = 0;
> }
> 
> // getImageData is synchronous, which means we've already received the CommitImageBufferFlushContext message.
>@@ -141,18 +149,19 @@ protected:
> return;
> 
> auto& displayList = m_drawingContext.displayList();
>- if (!displayList.itemCount())
>+ if (displayList.isEmpty())
> return;
> 
> TraceScope tracingScope(FlushRemoteImageBufferStart, FlushRemoteImageBufferEnd, 1);
> m_sentFlushIdentifier = m_remoteRenderingBackendProxy->flushDisplayListAndCommit(displayList, m_renderingResourceIdentifier);
> m_remoteRenderingBackendProxy->remoteResourceCacheProxy().unlockRemoteResourcesForRemoteClient(m_renderingResourceIdentifier);
> displayList.clear();
>+ m_itemCountInCurrentDisplayList = 0;
> }
> 
> void flushDisplayList(const WebCore::DisplayList::DisplayList& displayList) override
> {
>- if (!m_remoteRenderingBackendProxy || !displayList.itemCount())
>+ if (!m_remoteRenderingBackendProxy || displayList.isEmpty())
> return;
> 
> TraceScope tracingScope(FlushRemoteImageBufferStart, FlushRemoteImageBufferEnd);
>@@ -170,20 +179,91 @@ protected:
> return true;
> }
> 
>- void willAppendItem(const WebCore::DisplayList::Item&) override
>+ void willAppendItemOfType(WebCore::DisplayList::ItemType) override
> {
> constexpr size_t DisplayListBatchSize = 512;
> auto& displayList = m_drawingContext.displayList();
>- if (displayList.itemCount() < DisplayListBatchSize)
>+ if (++m_itemCountInCurrentDisplayList < DisplayListBatchSize)
> return;
> 
> flushDisplayList(displayList);
> displayList.clear();
>+ m_itemCountInCurrentDisplayList = 0;
> }
> 
>- void didAppendItem(const WebCore::DisplayList::Item& item) override
>+ bool requiresEncoding(WebCore::DisplayList::ItemType type) const override
> {
>- if (item.type() == WebCore::DisplayList::ItemType::DrawImageBuffer)
>+ return !WebCore::DisplayList::isInlineItem(type);
>+ }
>+
>+ WebCore::DisplayList::ItemBufferHandle createItemBuffer(size_t capacity) override
>+ {
>+ if (m_remoteRenderingBackendProxy)
>+ return m_remoteRenderingBackendProxy->createItemBuffer(capacity);
>+
>+ ASSERT_NOT_REACHED();
>+ return { };
>+ }
>+
>+ RefPtr<WebCore::SharedBuffer> encodeItem(WebCore::DisplayList::ItemHandle item) const override
>+ {
>+ switch (item.type()) {
>+ case WebCore::DisplayList::ItemType::ClipOutToPath:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::ClipOutToPath>(item.get<WebCore::DisplayList::ClipOutToPath>());
>+ case WebCore::DisplayList::ItemType::ClipPath:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::ClipPath>(item.get<WebCore::DisplayList::ClipPath>());
>+ case WebCore::DisplayList::ItemType::ClipToDrawingCommands:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::ClipToDrawingCommands>(item.get<WebCore::DisplayList::ClipToDrawingCommands>());
>+ case WebCore::DisplayList::ItemType::DrawFocusRingPath:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::DrawFocusRingPath>(item.get<WebCore::DisplayList::DrawFocusRingPath>());
>+ case WebCore::DisplayList::ItemType::DrawFocusRingRects:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::DrawFocusRingRects>(item.get<WebCore::DisplayList::DrawFocusRingRects>());
>+ case WebCore::DisplayList::ItemType::DrawGlyphs:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::DrawGlyphs>(item.get<WebCore::DisplayList::DrawGlyphs>());
>+ case WebCore::DisplayList::ItemType::DrawImage:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::DrawImage>(item.get<WebCore::DisplayList::DrawImage>());
>+ case WebCore::DisplayList::ItemType::DrawImageBuffer:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::DrawImageBuffer>(item.get<WebCore::DisplayList::DrawImageBuffer>());
>+ case WebCore::DisplayList::ItemType::DrawLinesForText:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::DrawLinesForText>(item.get<WebCore::DisplayList::DrawLinesForText>());
>+ case WebCore::DisplayList::ItemType::DrawNativeImage:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::DrawNativeImage>(item.get<WebCore::DisplayList::DrawNativeImage>());
>+ case WebCore::DisplayList::ItemType::DrawPath:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::DrawPath>(item.get<WebCore::DisplayList::DrawPath>());
>+ case WebCore::DisplayList::ItemType::DrawPattern:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::DrawPattern>(item.get<WebCore::DisplayList::DrawPattern>());
>+ case WebCore::DisplayList::ItemType::DrawTiledImage:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::DrawTiledImage>(item.get<WebCore::DisplayList::DrawTiledImage>());
>+ case WebCore::DisplayList::ItemType::DrawTiledScaledImage:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::DrawTiledScaledImage>(item.get<WebCore::DisplayList::DrawTiledScaledImage>());
>+ case WebCore::DisplayList::ItemType::FillCompositedRect:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::FillCompositedRect>(item.get<WebCore::DisplayList::FillCompositedRect>());
>+ case WebCore::DisplayList::ItemType::FillPath:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::FillPath>(item.get<WebCore::DisplayList::FillPath>());
>+ case WebCore::DisplayList::ItemType::FillRectWithColor:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::FillRectWithColor>(item.get<WebCore::DisplayList::FillRectWithColor>());
>+ case WebCore::DisplayList::ItemType::FillRectWithGradient:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::FillRectWithGradient>(item.get<WebCore::DisplayList::FillRectWithGradient>());
>+ case WebCore::DisplayList::ItemType::FillRectWithRoundedHole:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::FillRectWithRoundedHole>(item.get<WebCore::DisplayList::FillRectWithRoundedHole>());
>+ case WebCore::DisplayList::ItemType::FillRoundedRect:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::FillRoundedRect>(item.get<WebCore::DisplayList::FillRoundedRect>());
>+ case WebCore::DisplayList::ItemType::PutImageData:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::PutImageData>(item.get<WebCore::DisplayList::PutImageData>());
>+ case WebCore::DisplayList::ItemType::SetLineDash:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::SetLineDash>(item.get<WebCore::DisplayList::SetLineDash>());
>+ case WebCore::DisplayList::ItemType::SetState:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::SetState>(item.get<WebCore::DisplayList::SetState>());
>+ case WebCore::DisplayList::ItemType::StrokePath:
>+ return IPC::Encoder::encodeObject<WebCore::DisplayList::StrokePath>(item.get<WebCore::DisplayList::StrokePath>());
>+ default:
>+ RELEASE_ASSERT_NOT_REACHED();
>+ }
>+ }
>+
>+ void didAppendItemOfType(WebCore::DisplayList::ItemType type) override
>+ {
>+ if (type == WebCore::DisplayList::ItemType::DrawImageBuffer)
> flushDrawingContext();
> }
> 
>@@ -191,6 +271,7 @@ protected:
> DisplayListFlushIdentifier m_receivedFlushIdentifier;
> WebCore::RenderingResourceIdentifier m_renderingResourceIdentifier { WebCore::RenderingResourceIdentifier::generate() };
> WeakPtr<RemoteRenderingBackendProxy> m_remoteRenderingBackendProxy;
>+ size_t m_itemCountInCurrentDisplayList { 0 };
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>index 7a01930ab66c4473051093034d4f36d2c0e648a2..ef2828316a83161704cee52dba8a1ec011bfc41e 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>@@ -34,6 +34,8 @@
> #include "PlatformRemoteImageBufferProxy.h"
> #include "RemoteRenderingBackendMessages.h"
> #include "RemoteRenderingBackendProxyMessages.h"
>+#include "SharedDisplayListHandle.h"
>+#include "SharedMemory.h"
> #include "WebProcess.h"
> 
> namespace WebKit {
>@@ -116,13 +118,13 @@ RefPtr<ImageData> RemoteRenderingBackendProxy::getImageData(AlphaPremultiplicati
> 
> void RemoteRenderingBackendProxy::flushDisplayList(const DisplayList::DisplayList& displayList, RenderingResourceIdentifier renderingResourceIdentifier)
> {
>- send(Messages::RemoteRenderingBackend::FlushDisplayList(displayList, renderingResourceIdentifier), m_renderingBackendIdentifier);
>+ send(Messages::RemoteRenderingBackend::FlushDisplayList({ displayList }, renderingResourceIdentifier), m_renderingBackendIdentifier);
> }
> 
> DisplayListFlushIdentifier RemoteRenderingBackendProxy::flushDisplayListAndCommit(const DisplayList::DisplayList& displayList, RenderingResourceIdentifier renderingResourceIdentifier)
> {
> DisplayListFlushIdentifier sentFlushIdentifier = DisplayListFlushIdentifier::generate();
>- send(Messages::RemoteRenderingBackend::FlushDisplayListAndCommit(displayList, sentFlushIdentifier, renderingResourceIdentifier), m_renderingBackendIdentifier);
>+ send(Messages::RemoteRenderingBackend::FlushDisplayListAndCommit({ displayList }, sentFlushIdentifier, renderingResourceIdentifier), m_renderingBackendIdentifier);
> return sentFlushIdentifier;
> }
> 
>@@ -155,6 +157,31 @@ void RemoteRenderingBackendProxy::flushDisplayListWasCommitted(DisplayListFlushI
> downcast<UnacceleratedRemoteImageBufferProxy>(*imageBuffer).commitFlushDisplayList(flushIdentifier);
> }
> 
>+void RemoteRenderingBackendProxy::releaseSharedItemBuffers(Vector<DisplayList::ItemBufferIdentifier>&& identifiers, RenderingResourceIdentifier renderingResourceIdentifier)
>+{
>+ for (auto identifier : identifiers) {
>+ if (!m_sharedItemBuffers.remove(identifier))
>+ RELEASE_ASSERT_NOT_REACHED();
>+ }
>+}
>+
>+DisplayList::ItemBufferHandle RemoteRenderingBackendProxy::createItemBuffer(size_t capacity)
>+{
>+ static constexpr size_t defaultSharedItemBufferSize = 1 << 16;
>+
>+ auto sharedMemory = SharedMemory::allocate(std::max(defaultSharedItemBufferSize, capacity));
>+ if (!sharedMemory)
>+ return { };
>+
>+ auto identifier = DisplayList::ItemBufferIdentifier::generate();
>+ SharedMemory::Handle sharedMemoryHandle;
>+ sharedMemory->createHandle(sharedMemoryHandle, SharedMemory::Protection::ReadOnly);
>+ send(Messages::RemoteRenderingBackend::DidCreateSharedItemData(identifier, { WTFMove(sharedMemoryHandle), sharedMemory->size() }), m_renderingBackendIdentifier);
>+ m_sharedItemBuffers.set(identifier, sharedMemory.copyRef());
>+
>+ return { identifier, reinterpret_cast<uint8_t*>(sharedMemory->data()), 0, sharedMemory->size() };
>+}
>+
> } // namespace WebKit
> 
> #endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>index 99565b6f166bb2d80614184972e343706ce7fec9..131e49196dd95a275b8151b856eba53c697f4718 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>@@ -33,6 +33,7 @@
> #include "MessageSender.h"
> #include "RemoteResourceCacheProxy.h"
> #include "RenderingBackendIdentifier.h"
>+#include <WebCore/DisplayList.h>
> #include <WebCore/RenderingResourceIdentifier.h>
> #include <wtf/WeakPtr.h>
> 
>@@ -60,6 +61,7 @@ public:
> ~RemoteRenderingBackendProxy();
> 
> RemoteResourceCacheProxy& remoteResourceCacheProxy() { return m_remoteResourceCacheProxy; }
>+ WebCore::DisplayList::ItemBufferHandle createItemBuffer(size_t);
> 
> // IPC::MessageSender.
> IPC::Connection* messageSenderConnection() const override;
>@@ -72,6 +74,7 @@ public:
> std::unique_ptr<WebCore::ImageBuffer> createImageBuffer(const WebCore::FloatSize&, WebCore::RenderingMode, float resolutionScale, WebCore::ColorSpace);
> RefPtr<WebCore::ImageData> getImageData(WebCore::AlphaPremultiplication outputFormat, const WebCore::IntRect& srcRect, WebCore::RenderingResourceIdentifier);
> void flushDisplayList(const WebCore::DisplayList::DisplayList&, WebCore::RenderingResourceIdentifier);
>+ void didCreateSharedItemData(WebCore::DisplayList::ItemBufferIdentifier, const SharedMemory::IPCHandle&);
> DisplayListFlushIdentifier flushDisplayListAndCommit(const WebCore::DisplayList::DisplayList&, WebCore::RenderingResourceIdentifier);
> void releaseRemoteResource(WebCore::RenderingResourceIdentifier);
> 
>@@ -84,7 +87,9 @@ private:
> // Messages to be received.
> void imageBufferBackendWasCreated(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle, WebCore::RenderingResourceIdentifier);
> void flushDisplayListWasCommitted(DisplayListFlushIdentifier, WebCore::RenderingResourceIdentifier);
>+ void releaseSharedItemBuffers(Vector<WebCore::DisplayList::ItemBufferIdentifier>&&, WebCore::RenderingResourceIdentifier);
> 
>+ HashMap<WebCore::DisplayList::ItemBufferIdentifier, RefPtr<SharedMemory>> m_sharedItemBuffers;
> RemoteResourceCacheProxy m_remoteResourceCacheProxy { *this };
> RenderingBackendIdentifier m_renderingBackendIdentifier { RenderingBackendIdentifier::generate() };
> };
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in
>index 8f24585635f47083d1db27a5b396665f315ebcb0..79a9866506d1c25a096ba514696bd9c8ba92310c 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in
>@@ -23,8 +23,9 @@
> #if ENABLE(GPU_PROCESS)
> 
> messages -> RemoteRenderingBackendProxy NotRefCounted {
>- void ImageBufferBackendWasCreated(WebCore::FloatSize logicalSize, WebCore::IntSize backendSize, float resolutionScale, WebCore::ColorSpace colorSpace, WebKit::ImageBufferBackendHandle handle, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>- void FlushDisplayListWasCommitted(WebKit::DisplayListFlushIdentifier flushIdentifier, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>+ ImageBufferBackendWasCreated(WebCore::FloatSize logicalSize, WebCore::IntSize backendSize, float resolutionScale, WebCore::ColorSpace colorSpace, WebKit::ImageBufferBackendHandle handle, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>+ FlushDisplayListWasCommitted(WebKit::DisplayListFlushIdentifier flushIdentifier, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>+ ReleaseSharedItemBuffers(Vector<WebCore::DisplayList::ItemBufferIdentifier> identifiers, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
> }
> 
> #endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp
>index 3f5a73bec3bf286e52981de48b90c31d019d8c3d..0f9a6e8f19e1d98569fed1bbc41d07683eacf1ad 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp
>@@ -29,6 +29,7 @@
> #if ENABLE(GPU_PROCESS)
> 
> #include "RemoteRenderingBackendProxy.h"
>+#include <WebCore/ImageBuffer.h>
> 
> namespace WebKit {
> using namespace WebCore;
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 648f58b2f69c54d80e2bb1d91efbbf1075dfb8b2..0496dd9ce68b29c42dc4703d629488c65537c9cd 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,18 @@
>+2020-10-30 Wenson Hsieh <wenson_hsieh@apple.com>
>+
>+ [Concurrent display lists] Encode display list items directly into shared memory
>+ https://bugs.webkit.org/show_bug.cgi?id=218406
>+
>+ Reviewed by NOBODY (OOPS!).
>+
>+ WIP only.
>+
>+ * displaylists/canvas-display-list-expected.txt:
>+ * displaylists/extent-includes-shadow-expected.txt:
>+ * displaylists/extent-includes-transforms-expected.txt:
>+ * displaylists/layer-dispay-list-expected.txt:
>+ * displaylists/replay-skip-clipped-rect-expected.txt:
>+
> 2020-10-30 Fujii Hironori <Hironori.Fujii@sony.com>
> 
> [TextureMapper] Replica layers don't blend correctly because computeOverlapRegions doesn't take TextureMapperPaintOptions::transform into account
>diff --git a/LayoutTests/displaylists/canvas-display-list-expected.txt b/LayoutTests/displaylists/canvas-display-list-expected.txt
>index 3288480627019d5402d9425fc4a1313770ecb31a..1451b19253c3238928bbd9f5e5debb9274c50d57 100644
>--- a/LayoutTests/displaylists/canvas-display-list-expected.txt
>+++ b/LayoutTests/displaylists/canvas-display-list-expected.txt
>@@ -6,10 +6,8 @@
> (fill-color #C80000)
> (shadows-ignore-transforms 1))
> (fill-rect
>- (extent at (10,140) size 55x50)
>- (rect at (10,10) size 55x50))
>+ (rect at (10,10) size 55x50) extent at (10,140) size 55x50)
> (set-inline-fill-color
> (color #0000C880))
> (fill-rect
>- (extent at (30,120) size 55x50)
>- (rect at (30,30) size 55x50))
>+ (rect at (30,30) size 55x50) extent at (30,120) size 55x50)
>diff --git a/LayoutTests/displaylists/extent-includes-shadow-expected.txt b/LayoutTests/displaylists/extent-includes-shadow-expected.txt
>index e9f540417bd6e5dc778615e5f3794976e4195f8d..590b93f5c892cae37f424609a8fe48033e668368 100644
>--- a/LayoutTests/displaylists/extent-includes-shadow-expected.txt
>+++ b/LayoutTests/displaylists/extent-includes-shadow-expected.txt
>@@ -9,9 +9,8 @@
> (shadow-offset width=10 height=20)
> (shadows-use-legacy-radius 0))
> (fill-composited-rect
>- (extent at (43,50) size 134x137)
> (rect at (50,50) size 100x100)
> (color #0000FF)
> (composite-operation source-over)
>- (blend-mode normal))
>+ (blend-mode normal) extent at (43,50) size 134x137)
> (restore)
>diff --git a/LayoutTests/displaylists/extent-includes-transforms-expected.txt b/LayoutTests/displaylists/extent-includes-transforms-expected.txt
>index e0452a173a1afe237f728d30bc27ec60eec9623d..28ccf4c01859de190b0a9a27fa2fec0063ed8e1c 100644
>--- a/LayoutTests/displaylists/extent-includes-transforms-expected.txt
>+++ b/LayoutTests/displaylists/extent-includes-transforms-expected.txt
>@@ -11,11 +11,10 @@
> (shadow-offset width=10 height=20)
> (shadows-use-legacy-radius 0))
> (fill-composited-rect
>- (extent at (7.14,0.20) size 184.55x185.65)
> (rect at (0,0) size 100x100)
> (color #0000FF)
> (composite-operation source-over)
>- (blend-mode normal))
>+ (blend-mode normal) extent at (7.14,0.20) size 184.55x185.65)
> (restore)
> (set-ctm
> (set-ctm {m=((1.00,0.00)(0.00,1.00)) t=(0.00,22.00)}))
>diff --git a/LayoutTests/displaylists/layer-dispay-list-expected.txt b/LayoutTests/displaylists/layer-dispay-list-expected.txt
>index bd876df403a4add0bc391f7c62ac2b4c3bcf7da0..bc17b511499f8256c99290dae8614d4894caf9cc 100644
>--- a/LayoutTests/displaylists/layer-dispay-list-expected.txt
>+++ b/LayoutTests/displaylists/layer-dispay-list-expected.txt
>@@ -3,29 +3,24 @@
> (x 0.00)
> (y 0.00))
> (fill-composited-rect
>- (extent at (0,0) size 104x104)
> (rect at (0,0) size 104x104)
> (color #008000)
> (composite-operation source-over)
>- (blend-mode normal))
>+ (blend-mode normal) extent at (0,0) size 104x104)
> (set-state
> (change-flags 32960)
> (fill-color #0000FF)
> (stroke-style 0)
> (should-antialias 0))
> (draw-rect
>- (extent at (0,0) size 104x2)
> (rect at (0,0) size 104x2)
>- (border-thickness 1.00))
>+ (border-thickness 1.00) extent at (0,0) size 104x2)
> (draw-rect
>- (extent at (0,102) size 104x2)
> (rect at (0,102) size 104x2)
>- (border-thickness 1.00))
>+ (border-thickness 1.00) extent at (0,102) size 104x2)
> (draw-rect
>- (extent at (0,0) size 2x104)
> (rect at (0,0) size 2x104)
>- (border-thickness 1.00))
>+ (border-thickness 1.00) extent at (0,0) size 2x104)
> (draw-rect
>- (extent at (102,0) size 2x104)
> (rect at (102,0) size 2x104)
>- (border-thickness 1.00))
>+ (border-thickness 1.00) extent at (102,0) size 2x104)
>diff --git a/LayoutTests/displaylists/replay-skip-clipped-rect-expected.txt b/LayoutTests/displaylists/replay-skip-clipped-rect-expected.txt
>index addd2ca4250c24a0c9ee2255d4275a76f6043eed..bb593d20f6da6486292d36c0220e2a9d872f82b9 100644
>--- a/LayoutTests/displaylists/replay-skip-clipped-rect-expected.txt
>+++ b/LayoutTests/displaylists/replay-skip-clipped-rect-expected.txt
>@@ -3,11 +3,10 @@ recorded:
> (x 0.00)
> (y 0.00))
> (fill-composited-rect
>- (extent at (412,0) size 100x100)
> (rect at (412,0) size 100x100)
> (color #0000FF)
> (composite-operation source-over)
>- (blend-mode normal))
>+ (blend-mode normal) extent at (412,0) size 100x100)
> 
> replayed:
> (

Actions: View | Formatted Diff | Diff

Attachments on bug 218406: 412811 | 412979 | 412985 | 412987 | 412991 | 412993 | 413116 | 413130 | 413131 | 413343 | 413362 | 413436 | 413437