Attachment 413767 Details for Bug 218426 – For EWS

[patch] For EWS

bug-218426-20201110204746.patch (text/plain), 62.14 KB, created by Wenson Hsieh on 2020-11-10 20:47:47 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Wenson Hsieh

Created: 2020-11-10 20:47:47 PST

Size: 62.14 KB

patch

obsolete

>Subversion Revision: 269640
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index c1ad6102d84192d36132721813a1c0e8f0c15a3b..6af326ecfc509a1a57ade218b9415788495a4693 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,153 @@
>+2020-11-10  Wenson Hsieh  <wenson_hsieh@apple.com>
>+
>+        [Concurrent display lists] Add an initial implementation of concurrent display list rendering
>+        https://bugs.webkit.org/show_bug.cgi?id=218426
>+        <rdar://problem/71167220>
>+
>+        Reviewed by Ryosuke Niwa.
>+
>+        This patch adds a first-cut implementation of concurrent display list rendering, which allows the GPU and web
>+        processes to read and write display list data at the same time. To achieve this, we remove the placeholder
>+        shared memory display list encoding mechanism previously added in <webkit.org/b/218406>, and replace it with a
>+        new model in which a writer (i.e. the web process) and a reader (i.e. the GPU process) share a set of reusable
>+        shared memory buffers which contain display list item data. As the writer appends data to shared memory, it
>+        increments a counter in each shared memory buffer that represents the number of bytes that the reader has yet to
>+        read; as the reader reads display list items from shared memory, it decrements this counter.
>+
>+        This patch also implements a simple strategy for reusing these shared item buffers. The web process maintains a
>+        queue of reusable buffers; when display list items are appended and the current writable buffer is out of
>+        capacity, the display list item buffer calls out to WebKit2 via a client method to request more shared memory.
>+        Here, the web process traverses the queue of reusable item buffers in search of a buffer with sufficient
>+        capacity; if found, we hand this back to WebCore as an opaque `ItemBufferHandle`; otherwise, we allocate a new
>+        reusable shared memory buffer. Item buffers that have been used become reusable only after they are (1) no
>+        longer being read from -- i.e., the counter value is 0, and (2) they are not actively being written to.
>+        Buffers that have been used are lazily reintroduced into the reuse queue when a display list requests a handle
>+        to writable item buffer data.
>+
>+        See below for more details.
>+
>+        * GPUProcess/graphics/DisplayListReaderHandle.cpp: Copied from Source/WebKit/Shared/SharedDisplayListHandle.cpp.
>+        (WebKit::DisplayListReaderHandle::advance):
>+        (WebKit::DisplayListReaderHandle::displayListForReading const):
>+        * GPUProcess/graphics/DisplayListReaderHandle.h: Copied from Source/WebKit/Shared/SharedDisplayListHandle.cpp.
>+        (WebKit::DisplayListReaderHandle::create):
>+        (WebKit::DisplayListReaderHandle::DisplayListReaderHandle):
>+
>+        Add a new helper class to represent a shared display list item buffer that the GPU process can use to consume
>+        display list items. Advancing the cursor in `DisplayListReaderHandle` decrements the "remaining bytes" counter;
>+        the class also has a helper method for creating a new `DisplayList` with a given offset into the shared buffer,
>+        as well the number of bytes to read.
>+
>+        * GPUProcess/graphics/RemoteImageBuffer.h:
>+
>+        Handle the `MetaCommandSwitchTo` and `FlushContext` items by (respectively) informing the rendering backend
>+        about the next buffer to read from, and sending a "flush committed" IPC message back to the web process.
>+
>+        (WebKit::RemoteImageBuffer::RemoteImageBuffer):
>+        * GPUProcess/graphics/RemoteRenderingBackend.cpp:
>+        (WebKit::RemoteRenderingBackend::applyDisplayListsFromHandle):
>+        (WebKit::RemoteRenderingBackend::wakeUpAndApplyDisplayList):
>+
>+        This is the main loop in the GPU process that is responsible for applying incoming display list item data. This
>+        IPC endpoint receives information about where to start (i.e. an item buffer ID and an offset into shared memory
>+        in that buffer) and begins reading ranges of display list item data inside that buffer. After it is done
>+        processing all of its unread bytes, it then checks the unread byte count once again, and continues the loop if
>+        the web process has advanced this count.
>+
>+        (WebKit::RemoteRenderingBackend::setNextItemBufferToRead):
>+        (WebKit::RemoteRenderingBackend::didCreateSharedDisplayListHandle):
>+
>+        Add logic to handle the case where we reached the end of an item buffer, but the next buffer identifier is still
>+        unknown to us (since it is still "in transit" via the `DidCreateSharedDisplayListHandle` IPC message). In this
>+        case, we remember the next buffer identifier in `m_nextItemBufferToRead`, and exit the processing loop inside
>+        `wakeUpAndApplyDisplayList`. Upon receiving the shared memory handle in `didCreateSharedDisplayListHandle`, we
>+        then automatically resume display list processing, starting from the beginning of this new buffer.
>+
>+        (WebKit::RemoteRenderingBackend::applyDisplayList): Deleted.
>+        (WebKit::RemoteRenderingBackend::submitDisplayList): Deleted.
>+        (WebKit::RemoteRenderingBackend::flushDisplayListAndCommit): Deleted.
>+        (WebKit::RemoteRenderingBackend::didCreateSharedItemData): Deleted.
>+
>+        We don't need any of these methods anymore, now that there is only one codepath for processing display list
>+        items. See `RemoteRenderingBackend::wakeUpAndApplyDisplayList` above. Also, rename `didCreateSharedItemData`
>+        to `didCreateSharedDisplayListHandle` (also above).
>+
>+        * GPUProcess/graphics/RemoteRenderingBackend.h:
>+        * GPUProcess/graphics/RemoteRenderingBackend.messages.in:
>+        * Shared/SharedDisplayListHandle.h:
>+        (WebKit::SharedDisplayListHandle::sharedMemory):
>+        (WebKit::SharedDisplayListHandle::sharedMemory const):
>+        (WebKit::SharedDisplayListHandle::identifier const):
>+        (WebKit::SharedDisplayListHandle::data const):
>+        (WebKit::SharedDisplayListHandle::unreadBytes):
>+        (WebKit::SharedDisplayListHandle::Lock::Lock):
>+        (WebKit::SharedDisplayListHandle::Lock::~Lock):
>+        (WebKit::SharedDisplayListHandle::SharedDisplayListHandle):
>+        (WebKit::SharedDisplayListHandle::header):
>+        (WebKit::SharedDisplayListHandle::header const):
>+        (WebKit::SharedDisplayListHandle::encode const): Deleted.
>+        (WebKit::SharedDisplayListHandle::decode): Deleted.
>+
>+        Repurpose `SharedDisplayListHandle` to serve as a base class for both `DisplayListReaderHandle` and
>+        `DisplayListWriterHandle`. This base class is aware of the memory layout of the display list item buffer in
>+        shared memory (in particular, the fact that the first 8 bytes are the atomic lock and the next 8 bytes contain
>+        the unread byte counter).
>+
>+        Internally, this uses a protected RAII class, `SharedDisplayListHandle::Lock`, to grab the lock before either
>+        reading or writing the unread bytes count.
>+
>+        * Sources.txt:
>+        * WebKit.xcodeproj/project.pbxproj:
>+        * WebProcess/GPU/graphics/DisplayListWriterHandle.cpp: Added.
>+        (WebKit::DisplayListWriterHandle::advance):
>+        (WebKit::DisplayListWriterHandle::availableCapacity const):
>+        (WebKit::DisplayListWriterHandle::createHandle const):
>+        (WebKit::DisplayListWriterHandle::resetWritableOffsetIfPossible):
>+
>+        This helper method moves the writable offset (see below) back to the start of the buffer if it is not being read
>+        from by the GPU process.
>+
>+        * WebProcess/GPU/graphics/DisplayListWriterHandle.h: Renamed from Source/WebKit/Shared/SharedDisplayListHandle.cpp.
>+        (WebKit::DisplayListWriterHandle::create):
>+        (WebKit::DisplayListWriterHandle::writableOffset const):
>+
>+        Similar to `DisplayListReaderHandle`, except that this contains logic specific to the web process for writing
>+        display list items into shared memory. Advancing the cursor in `DisplayListWriterHandle` increments the counter.
>+        It also increments the `writableOffset` of the handle, which represents the minimum offset into the shared
>+        buffer that may contain newly appended display list items.
>+
>+        (WebKit::DisplayListWriterHandle::DisplayListWriterHandle):
>+        * WebProcess/GPU/graphics/RemoteImageBufferProxy.h:
>+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:
>+        (WebKit::RemoteRenderingBackendProxy::submitDisplayList):
>+        (WebKit::RemoteRenderingBackendProxy::updateReusableHandles):
>+
>+        This private helper iterates the set of buffers that are not currently being written to, and adds each one to
>+        the reusable buffer queue only if its writable offset is at the start.
>+
>+        (WebKit::RemoteRenderingBackendProxy::createItemBuffer):
>+
>+        Implements logic that hands shared item buffer data handles to WebCore for writing display list items. This will
>+        try to reuse an item buffer in the reuse queue, if possible, and fall back to allocating a new chunk of shared
>+        memory if no reusable buffer is found (or the existing buffers have insufficient capacity). The fact that we
>+        iterate through each reusable buffer in order, combined with the above logic in `updateReusableHandles`, ensures
>+        that once we begin writing to a item buffer, we will continue using that item buffer until it exhausts available
>+        capacity.
>+
>+        This property is important because it allows the GPU process to simply start reading item data from a given
>+        offset and buffer ID (specified in the `WakeUpAndApplyDisplayList` IPC message), and seamlessly continue
>+        reading data even after it exhausts all available item data in the current buffer by continuing from the start
>+        of the item buffer that contains the next display list items (which we learn in the GPU process by encountering
>+        a `MetaCommandSwitchTo` item at the end of the previous buffer).
>+
>+        In "steady state" (wherein both processes are concurrently writing and reading items as quickly as possible),
>+        this means that as the web process is busy filling up each item buffer with item data, the GPU process is also
>+        busy applying all the item data in one buffer and automatically moving on to the next buffer with no additional
>+        IPC messages required.
>+
>+        (WebKit::RemoteRenderingBackendProxy::flushDisplayListAndCommit): Deleted.
>+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
>+
> 2020-11-10  Wenson Hsieh  <wenson_hsieh@apple.com>
> 
>         REGRESSION (r269525): Many layout tests crash when run under ASan
>diff --git a/Source/WebKit/GPUProcess/graphics/DisplayListReaderHandle.cpp b/Source/WebKit/GPUProcess/graphics/DisplayListReaderHandle.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..4e4d491f0d095389643b48a270b26aef137b7bfe
>--- /dev/null
>+++ b/Source/WebKit/GPUProcess/graphics/DisplayListReaderHandle.cpp
>@@ -0,0 +1,51 @@
>+/*
>+ * 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 "DisplayListReaderHandle.h"
>+
>+namespace WebKit {
>+using namespace WebCore;
>+
>+size_t DisplayListReaderHandle::advance(size_t amount)
>+{
>+    auto locker = SharedDisplayListHandle::Lock { *this };
>+    if (LIKELY(amount <= header().unreadBytes))
>+        return header().unreadBytes -= amount;
>+
>+    // FIXME: This should result in terminating the web process.
>+    ASSERT_NOT_REACHED();
>+    header().unreadBytes = 0;
>+    return 0;
>+}
>+
>+std::unique_ptr<DisplayList::DisplayList> DisplayListReaderHandle::displayListForReading(size_t offset, size_t capacity, DisplayList::ItemBufferReadingClient& client) const
>+{
>+    auto displayList = makeUnique<DisplayList::DisplayList>(DisplayList::ItemBufferHandles {{ identifier(), data() + offset, capacity }});
>+    displayList->setItemBufferClient(&client);
>+    return displayList;
>+}
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/GPUProcess/graphics/DisplayListReaderHandle.h b/Source/WebKit/GPUProcess/graphics/DisplayListReaderHandle.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..cb722397696dc9e0b06e89cac25ce72cb9a576e1
>--- /dev/null
>+++ b/Source/WebKit/GPUProcess/graphics/DisplayListReaderHandle.h
>@@ -0,0 +1,51 @@
>+/*
>+ * 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 "SharedDisplayListHandle.h"
>+#include <wtf/FastMalloc.h>
>+
>+namespace WebKit {
>+
>+class DisplayListReaderHandle : public SharedDisplayListHandle {
>+    WTF_MAKE_NONCOPYABLE(DisplayListReaderHandle); WTF_MAKE_FAST_ALLOCATED;
>+public:
>+    static Ref<DisplayListReaderHandle> create(WebCore::DisplayList::ItemBufferIdentifier identifier, Ref<SharedMemory>&& sharedMemory)
>+    {
>+        return adoptRef(*new DisplayListReaderHandle(identifier, WTFMove(sharedMemory)));
>+    }
>+
>+    size_t advance(size_t amount) override;
>+    std::unique_ptr<WebCore::DisplayList::DisplayList> displayListForReading(size_t offset, size_t capacity, WebCore::DisplayList::ItemBufferReadingClient&) const;
>+
>+private:
>+    DisplayListReaderHandle(WebCore::DisplayList::ItemBufferIdentifier identifier, Ref<SharedMemory>&& sharedMemory)
>+        : SharedDisplayListHandle(identifier, WTFMove(sharedMemory))
>+    {
>+    }
>+};
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h b/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h
>index 64b1e6bdae5ecbf6308eb7354b31439891371225..3dbaaf9f2ec6bd1127d51c117e0c1c7056cd25d3 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h
>@@ -52,6 +52,7 @@ public:
>     RemoteImageBuffer(std::unique_ptr<BackendType>&& backend, RemoteRenderingBackend& remoteRenderingBackend, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>         : BaseConcreteImageBuffer(WTFMove(backend), renderingResourceIdentifier)
>         , m_remoteRenderingBackend(remoteRenderingBackend)
>+        , m_renderingResourceIdentifier(renderingResourceIdentifier)
>     {
>         m_remoteRenderingBackend.imageBufferBackendWasCreated(m_backend->logicalSize(), m_backend->backendSize(), m_backend->resolutionScale(), m_backend->colorSpace(), m_backend->createImageBufferBackendHandle(), renderingResourceIdentifier);
>     }
>@@ -83,12 +84,15 @@ private:
>         }
> 
>         if (item.is<WebCore::DisplayList::FlushContext>()) {
>-            // FIXME: Not implemented yet.
>+            BaseConcreteImageBuffer::flushContext();
>+            auto identifier = item.get<WebCore::DisplayList::FlushContext>().identifier();
>+            m_remoteRenderingBackend.flushDisplayListWasCommitted(identifier, m_renderingResourceIdentifier);
>             return true;
>         }
> 
>         if (item.is<WebCore::DisplayList::MetaCommandSwitchTo>()) {
>-            // FIXME: Not implemented yet.
>+            auto nextBufferIdentifier = item.get<WebCore::DisplayList::MetaCommandSwitchTo>().identifier();
>+            m_remoteRenderingBackend.setNextItemBufferToRead(nextBufferIdentifier);
>             return true;
>         }
> 
>@@ -96,6 +100,7 @@ private:
>     }
> 
>     RemoteRenderingBackend& m_remoteRenderingBackend;
>+    WebCore::RenderingResourceIdentifier m_renderingResourceIdentifier;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>index d237a63b88696421bb9a257ef9db217cfe9f9cf8..7898f7c14106b29d09a5b9e337c5325057931532 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>@@ -28,10 +28,12 @@
> 
> #if ENABLE(GPU_PROCESS)
> 
>+#include "DisplayListReaderHandle.h"
> #include "GPUConnectionToWebProcess.h"
> #include "PlatformRemoteImageBuffer.h"
> #include "RemoteRenderingBackendMessages.h"
> #include "RemoteRenderingBackendProxyMessages.h"
>+#include <wtf/CheckedArithmetic.h>
> 
> namespace WebKit {
> using namespace WebCore;
>@@ -124,44 +126,84 @@ void RemoteRenderingBackend::createImageBuffer(const FloatSize& logicalSize, Ren
>     m_remoteResourceCache.cacheImageBuffer(makeRef(*imageBuffer));
> }
> 
>-void RemoteRenderingBackend::applyDisplayList(const SharedDisplayListHandle& handle, RenderingResourceIdentifier renderingResourceIdentifier, ShouldFlushContext flushContext)
>+void RemoteRenderingBackend::applyDisplayListsFromHandle(ImageBuffer& destination, DisplayListReaderHandle& handle, size_t initialOffset)
> {
>-    Vector<Ref<SharedMemory>> removedItemBuffers;
>-    auto displayList = handle.createDisplayList([&] (DisplayList::ItemBufferIdentifier identifier) -> uint8_t* {
>-        if (auto sharedMemory = m_sharedItemBuffers.take(identifier)) {
>-            removedItemBuffers.append(*sharedMemory);
>-            return reinterpret_cast<uint8_t*>(sharedMemory->data());
>+    auto handleProtector = makeRef(handle);
>+
>+    size_t offset = initialOffset;
>+    size_t sizeToRead = 0;
>+
>+    sizeToRead = handle.unreadBytes();
>+
>+    while (sizeToRead) {
>+        auto displayList = handle.displayListForReading(offset, sizeToRead, *this);
>+        if (UNLIKELY(!displayList)) {
>+            // FIXME: Add a message check to terminate the web process.
>+            ASSERT_NOT_REACHED();
>+            return;
>+        }
>+
>+        destination.submitDisplayList(*displayList);
>+
>+        CheckedSize checkedOffset = offset;
>+        checkedOffset += sizeToRead;
>+        if (UNLIKELY(checkedOffset.hasOverflowed())) {
>+            // FIXME: Add a message check to terminate the web process.
>+            ASSERT_NOT_REACHED();
>+            return;
>+        }
>+
>+        offset = checkedOffset.unsafeGet();
>+
>+        if (UNLIKELY(offset > handle.sharedMemory().size())) {
>+            // FIXME: Add a message check to terminate the web process.
>+            ASSERT_NOT_REACHED();
>+            return;
>         }
>-        return nullptr;
>-    });
> 
>-    if (!displayList) {
>+        sizeToRead = handle.advance(sizeToRead);
>+    }
>+}
>+
>+void RemoteRenderingBackend::wakeUpAndApplyDisplayList(DisplayList::ItemBufferIdentifier initialIdentifier, uint64_t initialOffset, RenderingResourceIdentifier destinationBufferIdentifier)
>+{
>+    auto imageBuffer = m_remoteResourceCache.cachedImageBuffer(destinationBufferIdentifier);
>+    if (UNLIKELY(!imageBuffer)) {
>         // FIXME: Add a message check to terminate the web process.
>+        ASSERT_NOT_REACHED();
>         return;
>     }
> 
>-    auto imageBuffer = m_remoteResourceCache.cachedImageBuffer(renderingResourceIdentifier);
>-    if (!imageBuffer) {
>+    auto initialHandle = m_sharedDisplayListHandles.get(initialIdentifier);
>+    if (UNLIKELY(!initialHandle)) {
>         // FIXME: Add a message check to terminate the web process.
>+        ASSERT_NOT_REACHED();
>         return;
>     }
> 
>-    displayList->setItemBufferClient(this);
>-    imageBuffer->submitDisplayList(*displayList);
>+    applyDisplayListsFromHandle(*imageBuffer, *initialHandle, initialOffset);
> 
>-    if (flushContext == ShouldFlushContext::Yes)
>-        imageBuffer->flushContext();
>-}
>-
>-void RemoteRenderingBackend::submitDisplayList(const SharedDisplayListHandle& handle, RenderingResourceIdentifier renderingResourceIdentifier)
>-{
>-    applyDisplayList(handle, renderingResourceIdentifier, ShouldFlushContext::No);
>+    while (m_nextItemBufferToRead) {
>+        auto nextHandle = m_sharedDisplayListHandles.get(m_nextItemBufferToRead);
>+        if (!nextHandle) {
>+            // If the handle identifier is currently unknown, wait until the GPU process receives an
>+            // IPC message with a shared memory handle to the next item buffer.
>+            break;
>+        }
>+        // Otherwise, continue reading the next display list item buffer from the start.
>+        m_nextItemBufferToRead = { };
>+        applyDisplayListsFromHandle(*imageBuffer, *nextHandle, SharedDisplayListHandle::reservedCapacityAtStart);
>+    }
> }
> 
>-void RemoteRenderingBackend::flushDisplayListAndCommit(const SharedDisplayListHandle& handle, DisplayList::FlushIdentifier flushIdentifier, RenderingResourceIdentifier renderingResourceIdentifier)
>+void RemoteRenderingBackend::setNextItemBufferToRead(DisplayList::ItemBufferIdentifier identifier)
> {
>-    applyDisplayList(handle, renderingResourceIdentifier, ShouldFlushContext::Yes);
>-    flushDisplayListWasCommitted(flushIdentifier, renderingResourceIdentifier);
>+    if (UNLIKELY(m_nextItemBufferToRead)) {
>+        // FIXME: Add a message check to terminate the web process.
>+        ASSERT_NOT_REACHED();
>+        return;
>+    }
>+    m_nextItemBufferToRead = identifier;
> }
> 
> void RemoteRenderingBackend::getImageData(AlphaPremultiplication outputFormat, IntRect srcRect, RenderingResourceIdentifier renderingResourceIdentifier, CompletionHandler<void(IPC::ImageDataReference&&)>&& completionHandler)
>@@ -177,10 +219,21 @@ void RemoteRenderingBackend::releaseRemoteResource(RenderingResourceIdentifier r
>     m_remoteResourceCache.releaseRemoteResource(renderingResourceIdentifier);
> }
> 
>-void RemoteRenderingBackend::didCreateSharedItemData(DisplayList::ItemBufferIdentifier identifier, const SharedMemory::IPCHandle& handle)
>+void RemoteRenderingBackend::didCreateSharedDisplayListHandle(DisplayList::ItemBufferIdentifier identifier, const SharedMemory::IPCHandle& handle, RenderingResourceIdentifier destinationBufferIdentifier)
> {
>-    if (auto sharedMemory = SharedMemory::map(handle.handle, SharedMemory::Protection::ReadOnly))
>-        m_sharedItemBuffers.set(identifier, WTFMove(sharedMemory));
>+    if (UNLIKELY(m_sharedDisplayListHandles.contains(identifier))) {
>+        // FIXME: Add a message check to terminate the web process.
>+        ASSERT_NOT_REACHED();
>+        return;
>+    }
>+
>+    if (auto sharedMemory = SharedMemory::map(handle.handle, SharedMemory::Protection::ReadWrite))
>+        m_sharedDisplayListHandles.set(identifier, DisplayListReaderHandle::create(identifier, sharedMemory.releaseNonNull()));
>+
>+    if (m_nextItemBufferToRead == identifier) {
>+        m_nextItemBufferToRead = { };
>+        wakeUpAndApplyDisplayList(identifier, SharedDisplayListHandle::reservedCapacityAtStart, destinationBufferIdentifier);
>+    }
> }
> 
> Optional<DisplayList::ItemHandle> WARN_UNUSED_RETURN RemoteRenderingBackend::decodeItem(const uint8_t* data, size_t length, DisplayList::ItemType type, uint8_t* handleLocation)
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>index 7ac9620103e57c07bb2eee33ebefb2c45f007dd1..b36b9dd6064ee5a5163c68e41947631fe0913132 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>@@ -34,7 +34,6 @@
> #include "MessageSender.h"
> #include "RemoteResourceCache.h"
> #include "RenderingBackendIdentifier.h"
>-#include "SharedDisplayListHandle.h"
> #include <WebCore/ColorSpace.h>
> #include <WebCore/DisplayList.h>
> #include <WebCore/DisplayListItems.h>
>@@ -52,6 +51,7 @@ enum class RenderingMode : bool;
> 
> namespace WebKit {
> 
>+class DisplayListReaderHandle;
> class GPUConnectionToWebProcess;
> 
> class RemoteRenderingBackend
>@@ -72,12 +72,11 @@ public:
>     void imageBufferBackendWasCreated(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle, WebCore::RenderingResourceIdentifier);
>     void flushDisplayListWasCommitted(WebCore::DisplayList::FlushIdentifier, WebCore::RenderingResourceIdentifier);
> 
>+    void setNextItemBufferToRead(WebCore::DisplayList::ItemBufferIdentifier);
>+
> private:
>     RemoteRenderingBackend(GPUConnectionToWebProcess&, RenderingBackendIdentifier);
> 
>-    enum class ShouldFlushContext : bool { No, Yes };
>-    void applyDisplayList(const SharedDisplayListHandle&, WebCore::RenderingResourceIdentifier, ShouldFlushContext);
>-
>     Optional<WebCore::DisplayList::ItemHandle> WARN_UNUSED_RETURN decodeItem(const uint8_t* data, size_t length, WebCore::DisplayList::ItemType, uint8_t* handleLocation) override;
> 
>     template<typename T>
>@@ -92,6 +91,8 @@ private:
>         return WTF::nullopt;
>     }
> 
>+    void applyDisplayListsFromHandle(WebCore::ImageBuffer& destination, DisplayListReaderHandle&, size_t offset);
>+
>     // IPC::MessageSender.
>     IPC::Connection* messageSenderConnection() const override;
>     uint64_t messageSenderDestinationID() const override;
>@@ -102,16 +103,16 @@ private:
> 
>     // Messages to be received.
>     void createImageBuffer(const WebCore::FloatSize& logicalSize, WebCore::RenderingMode, float resolutionScale, WebCore::ColorSpace, WebCore::RenderingResourceIdentifier);
>-    void submitDisplayList(const SharedDisplayListHandle&, WebCore::RenderingResourceIdentifier);
>-    void flushDisplayListAndCommit(const SharedDisplayListHandle&, WebCore::DisplayList::FlushIdentifier, WebCore::RenderingResourceIdentifier);
>+    void wakeUpAndApplyDisplayList(WebCore::DisplayList::ItemBufferIdentifier initialIdentifier, uint64_t initialOffset, WebCore::RenderingResourceIdentifier destinationBufferIdentifier);
>     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&);
>+    void didCreateSharedDisplayListHandle(WebCore::DisplayList::ItemBufferIdentifier, const SharedMemory::IPCHandle&, WebCore::RenderingResourceIdentifier destinationBufferIdentifier);
> 
>     RemoteResourceCache m_remoteResourceCache;
>     WeakPtr<GPUConnectionToWebProcess> m_gpuConnectionToWebProcess;
>     RenderingBackendIdentifier m_renderingBackendIdentifier;
>-    HashMap<WebCore::DisplayList::ItemBufferIdentifier, RefPtr<SharedMemory>> m_sharedItemBuffers;
>+    HashMap<WebCore::DisplayList::ItemBufferIdentifier, RefPtr<DisplayListReaderHandle>> m_sharedDisplayListHandles;
>+    WebCore::DisplayList::ItemBufferIdentifier m_nextItemBufferToRead;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in
>index f55b026bdb5e63a14cf36214a83e8bbe88631a1b..6f2e2abdf926bcd4a04c23558e65b996a5a06082 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in
>@@ -24,10 +24,9 @@
> 
> messages -> RemoteRenderingBackend NotRefCounted {
>     CreateImageBuffer(WebCore::FloatSize logicalSize, WebCore::RenderingMode renderingMode, float resolutionScale, WebCore::ColorSpace colorSpace, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>-    SubmitDisplayList(WebKit::SharedDisplayListHandle displayList, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>-    FlushDisplayListAndCommit(WebKit::SharedDisplayListHandle displayList, WebCore::DisplayList::FlushIdentifier flushIdentifier, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>+    WakeUpAndApplyDisplayList(WebCore::DisplayList::ItemBufferIdentifier initialIdentifier, uint64_t initialOffset, WebCore::RenderingResourceIdentifier destinationBufferIdentifier)
>     GetImageData(enum:uint8_t WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, WebCore::RenderingResourceIdentifier renderingResourceIdentifier) -> (IPC::ImageDataReference imageData) Synchronous
>-    DidCreateSharedItemData(WebCore::DisplayList::ItemBufferIdentifier identifier, WebKit::SharedMemory::IPCHandle handle)
>+    DidCreateSharedDisplayListHandle(WebCore::DisplayList::ItemBufferIdentifier identifier, WebKit::SharedMemory::IPCHandle handle, WebCore::RenderingResourceIdentifier destinationBufferIdentifier)
>     ReleaseRemoteResource(WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
> }
> 
>diff --git a/Source/WebKit/Shared/SharedDisplayListHandle.cpp b/Source/WebKit/Shared/SharedDisplayListHandle.cpp
>deleted file mode 100644
>index 1aa74d615abd3f4a3186252ff0fdcb871e70fa50..0000000000000000000000000000000000000000
>--- a/Source/WebKit/Shared/SharedDisplayListHandle.cpp
>+++ /dev/null
>@@ -1,53 +0,0 @@
>-/*
>- * Copyright (C) 2020 Apple Inc. All rights reserved.
>- *
>- * Redistribution and use in source and binary forms, with or without
>- * modification, are permitted provided that the following conditions
>- * are met:
>- * 1. Redistributions of source code must retain the above copyright
>- *    notice, this list of conditions and the following disclaimer.
>- * 2. Redistributions in binary form must reproduce the above copyright
>- *    notice, this list of conditions and the following disclaimer in the
>- *    documentation and/or other materials provided with the distribution.
>- *
>- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>- * THE POSSIBILITY OF SUCH DAMAGE.
>- */
>-
>-#include "config.h"
>-#include "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, capacity });
>-    }
>-    return makeUnique<DisplayList::DisplayList>(WTFMove(handles));
>-}
>-
>-} // namespace WebKit
>diff --git a/Source/WebKit/Shared/SharedDisplayListHandle.h b/Source/WebKit/Shared/SharedDisplayListHandle.h
>index d175e114f23bc8fb8e57cd90f64a33be262e1f31..31dc3e092b05ff447c911cac4d29077d69d2fa55 100644
>--- a/Source/WebKit/Shared/SharedDisplayListHandle.h
>+++ b/Source/WebKit/Shared/SharedDisplayListHandle.h
>@@ -25,42 +25,77 @@
> 
> #pragma once
> 
>+#include "SharedMemory.h"
> #include <WebCore/DisplayList.h>
>+#include <wtf/Atomics.h>
>+#include <wtf/RefCounted.h>
>+#include <wtf/Threading.h>
> 
> namespace WebKit {
> 
>-class SharedDisplayListHandle {
>+class SharedDisplayListHandle : public RefCounted<SharedDisplayListHandle> {
> public:
>-    using ItemBufferProvider = Function<uint8_t*(WebCore::DisplayList::ItemBufferIdentifier)>;
>+    virtual ~SharedDisplayListHandle() = default;
> 
>-    SharedDisplayListHandle(const WebCore::DisplayList::DisplayList&);
>-    std::unique_ptr<WebCore::DisplayList::DisplayList> createDisplayList(ItemBufferProvider&&) const;
>+    static constexpr auto reservedCapacityAtStart = 2 * sizeof(uint64_t);
> 
>-    template<class Encoder> void encode(Encoder&) const;
>-    template<class Decoder> static Optional<SharedDisplayListHandle> decode(Decoder&);
>+    SharedMemory& sharedMemory() { return m_sharedMemory.get(); }
>+    const SharedMemory& sharedMemory() const { return m_sharedMemory.get(); }
> 
>-private:
>-    SharedDisplayListHandle(Vector<std::pair<WebCore::DisplayList::ItemBufferIdentifier, size_t>>&& buffers)
>-        : m_buffers(WTFMove(buffers))
>+    WebCore::DisplayList::ItemBufferIdentifier identifier() const { return m_identifier; }
>+    uint8_t* data() const { return reinterpret_cast<uint8_t*>(sharedMemory().data()); }
>+
>+    uint64_t unreadBytes()
>     {
>+        auto locker = SharedDisplayListHandle::Lock { *this };
>+        return header().unreadBytes;
>     }
> 
>-    Vector<std::pair<WebCore::DisplayList::ItemBufferIdentifier, size_t>> m_buffers;
>-};
>+    virtual size_t advance(size_t amount) = 0;
>+
>+protected:
>+    class Lock {
>+    public:
>+        Lock(SharedDisplayListHandle& handle)
>+            : m_handle(handle)
>+        {
>+            auto& atomicValue = m_handle.header().lock;
>+            while (true) {
>+                // FIXME: We need to avoid waiting forever in the case where the web content process
>+                // holds on to the lock indefinitely (or crashes while holding the lock).
>+                uint64_t unlocked = 0;
>+                if (atomicValue.compareExchangeWeak(unlocked, 1))
>+                    break;
>+                Thread::yield();
>+            }
>+        }
>+
>+        ~Lock()
>+        {
>+            m_handle.header().lock.store(0);
>+        }
>+
>+    private:
>+        SharedDisplayListHandle& m_handle;
>+    };
> 
>-template<class Encoder> void SharedDisplayListHandle::encode(Encoder& encoder) const
>-{
>-    encoder << m_buffers;
>-}
>+    SharedDisplayListHandle(WebCore::DisplayList::ItemBufferIdentifier identifier, Ref<SharedMemory>&& sharedMemory)
>+        : m_identifier(identifier)
>+        , m_sharedMemory(WTFMove(sharedMemory))
>+    {
>+    }
>+
>+    struct DisplayListSharedMemoryHeader {
>+        Atomic<uint64_t> lock;
>+        uint64_t unreadBytes;
>+    };
> 
>-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;
>+    DisplayListSharedMemoryHeader& header() { return *reinterpret_cast<DisplayListSharedMemoryHeader*>(data()); }
> 
>-    return {{ WTFMove(*buffers) }};
>-}
>+private:
>+
>+    WebCore::DisplayList::ItemBufferIdentifier m_identifier;
>+    Ref<SharedMemory> m_sharedMemory;
>+};
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/Sources.txt b/Source/WebKit/Sources.txt
>index 83d280c75ef5f5bb0a2eb6d11aa8c0fa919b74d0..245fdb21f952998a39db8a2192c8c572c891062e 100644
>--- a/Source/WebKit/Sources.txt
>+++ b/Source/WebKit/Sources.txt
>@@ -24,6 +24,7 @@
> GPUProcess/GPUProcess.cpp
> GPUProcess/GPUConnectionToWebProcess.cpp
> GPUProcess/GPUProcessCreationParameters.cpp
>+GPUProcess/graphics/DisplayListReaderHandle.cpp
> GPUProcess/graphics/RemoteRenderingBackend.cpp
> GPUProcess/graphics/RemoteResourceCache.cpp
> GPUProcess/media/RemoteAudioSessionProxy.cpp
>@@ -173,7 +174,6 @@ 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
>@@ -560,6 +560,7 @@ WebProcess/MediaStream/MediaDeviceSandboxExtensions.cpp
> WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp
> 
> WebProcess/GPU/GPUProcessConnection.cpp
>+WebProcess/GPU/graphics/DisplayListWriterHandle.cpp
> WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.cpp
> WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
> WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp
>diff --git a/Source/WebKit/WebKit.xcodeproj/project.pbxproj b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>index c027494b73accec5efd81c694d3a853b4edef0ca..0ee99710196036b3fa1bfe313153b89f28887d39 100644
>--- a/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>+++ b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>@@ -1871,6 +1871,8 @@
> 		E5BEF6822130C48000F31111 /* WebDataListSuggestionsDropdownIOS.h in Headers */ = {isa = PBXBuildFile; fileRef = E5BEF6802130C47F00F31111 /* WebDataListSuggestionsDropdownIOS.h */; };
> 		E5CB07DC20E1678F0022C183 /* WKFormColorControl.h in Headers */ = {isa = PBXBuildFile; fileRef = E5CB07DA20E1678F0022C183 /* WKFormColorControl.h */; };
> 		ED82A7F2128C6FAF004477B3 /* WKBundlePageOverlay.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A22F0FF1289FCD90085E74F /* WKBundlePageOverlay.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		F4094CBD2553053D003D73E3 /* DisplayListReaderHandle.h in Headers */ = {isa = PBXBuildFile; fileRef = F4094CBB255304AF003D73E3 /* DisplayListReaderHandle.h */; };
>+		F4094CBE25530540003D73E3 /* DisplayListWriterHandle.h in Headers */ = {isa = PBXBuildFile; fileRef = F4094CB92553047E003D73E3 /* DisplayListWriterHandle.h */; };
> 		F409BA181E6E64BC009DA28E /* WKDragDestinationAction.h in Headers */ = {isa = PBXBuildFile; fileRef = F409BA171E6E64B3009DA28E /* WKDragDestinationAction.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		F42D634122A0EFDF00D2FB3A /* WebAutocorrectionData.h in Headers */ = {isa = PBXBuildFile; fileRef = F42D633F22A0EFD300D2FB3A /* WebAutocorrectionData.h */; };
> 		F430E9422247335F005FE053 /* WebsiteMetaViewportPolicy.h in Headers */ = {isa = PBXBuildFile; fileRef = F430E941224732A9005FE053 /* WebsiteMetaViewportPolicy.h */; };
>@@ -5470,6 +5472,10 @@
> 		ECA680D31E6904B500731D20 /* ExtraPrivateSymbolsForTAPI.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ExtraPrivateSymbolsForTAPI.h; sourceTree = "<group>"; };
> 		ECBFC1DB1E6A4D66000300C7 /* ExtraPublicSymbolsForTAPI.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ExtraPublicSymbolsForTAPI.h; sourceTree = "<group>"; };
> 		F036978715F4BF0500C3A80E /* WebColorPicker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebColorPicker.cpp; sourceTree = "<group>"; };
>+		F4094CB92553047E003D73E3 /* DisplayListWriterHandle.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DisplayListWriterHandle.h; sourceTree = "<group>"; };
>+		F4094CBA2553047E003D73E3 /* DisplayListWriterHandle.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = DisplayListWriterHandle.cpp; sourceTree = "<group>"; };
>+		F4094CBB255304AF003D73E3 /* DisplayListReaderHandle.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DisplayListReaderHandle.h; sourceTree = "<group>"; };
>+		F4094CBC255304AF003D73E3 /* DisplayListReaderHandle.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = DisplayListReaderHandle.cpp; sourceTree = "<group>"; };
> 		F409BA171E6E64B3009DA28E /* WKDragDestinationAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKDragDestinationAction.h; sourceTree = "<group>"; };
> 		F40D1B68220BDC0F00B49A01 /* WebAutocorrectionContext.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = WebAutocorrectionContext.h; path = ios/WebAutocorrectionContext.h; sourceTree = "<group>"; };
> 		F41056612130699A0092281D /* APIAttachmentCocoa.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = APIAttachmentCocoa.mm; sourceTree = "<group>"; };
>@@ -5492,7 +5498,6 @@
> 		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>"; };
>@@ -6200,7 +6205,6 @@
> 				1A6420E312DCE2FF00CAAE2C /* ShareableBitmap.h */,
> 				5121745E164C20E30037A5C1 /* ShareableResource.cpp */,
> 				5121745F164C20E30037A5C1 /* ShareableResource.h */,
>-				F4A6D6BD254CA52200B65FAA /* SharedDisplayListHandle.cpp */,
> 				F4A6D6BB254CA3E900B65FAA /* SharedDisplayListHandle.h */,
> 				8313F7EA1F7DAE0400B944EB /* SharedStringHashStore.cpp */,
> 				8313F7E91F7DAE0300B944EB /* SharedStringHashStore.h */,
>@@ -8175,6 +8179,8 @@
> 			isa = PBXGroup;
> 			children = (
> 				727A7F3324078527004D2931 /* cocoa */,
>+				F4094CBA2553047E003D73E3 /* DisplayListWriterHandle.cpp */,
>+				F4094CB92553047E003D73E3 /* DisplayListWriterHandle.h */,
> 				727A7F39240788F1004D2931 /* ImageBufferBackendHandle.h */,
> 				727A7F37240788F0004D2931 /* ImageBufferShareableBitmapBackend.cpp */,
> 				727A7F36240788F0004D2931 /* ImageBufferShareableBitmapBackend.h */,
>@@ -8194,6 +8200,8 @@
> 		550640A124071A2900AAE045 /* graphics */ = {
> 			isa = PBXGroup;
> 			children = (
>+				F4094CBC255304AF003D73E3 /* DisplayListReaderHandle.cpp */,
>+				F4094CBB255304AF003D73E3 /* DisplayListReaderHandle.h */,
> 				55AD09432408A0E600DE4D2F /* PlatformRemoteImageBuffer.h */,
> 				55AD09422408A02E00DE4D2F /* RemoteImageBuffer.h */,
> 				550640A224071A6100AAE045 /* RemoteRenderingBackend.cpp */,
>@@ -11035,6 +11043,8 @@
> 				83891B6C1A68C30B0030F386 /* DiagnosticLoggingClient.h in Headers */,
> 				C18173612058424700DFDA65 /* DisplayLink.h in Headers */,
> 				0F189CAC24749F2F00E58D81 /* DisplayLinkObserverID.h in Headers */,
>+				F4094CBD2553053D003D73E3 /* DisplayListReaderHandle.h in Headers */,
>+				F4094CBE25530540003D73E3 /* DisplayListWriterHandle.h in Headers */,
> 				5C1427021C23F84C00D41183 /* Download.h in Headers */,
> 				5C1427051C23F84C00D41183 /* DownloadID.h in Headers */,
> 				5C1427071C23F84C00D41183 /* DownloadManager.h in Headers */,
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/DisplayListWriterHandle.cpp b/Source/WebKit/WebProcess/GPU/graphics/DisplayListWriterHandle.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..b5b7c08023d3578da4654d512a5f8d5ea35b2b90
>--- /dev/null
>+++ b/Source/WebKit/WebProcess/GPU/graphics/DisplayListWriterHandle.cpp
>@@ -0,0 +1,83 @@
>+/*
>+ * 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 "DisplayListWriterHandle.h"
>+
>+#include <wtf/CheckedArithmetic.h>
>+
>+namespace WebKit {
>+using namespace WebCore;
>+
>+size_t DisplayListWriterHandle::advance(size_t amount)
>+{
>+    CheckedSize checkedWritableOffset = m_writableOffset;
>+    checkedWritableOffset += amount;
>+    if (UNLIKELY(checkedWritableOffset.hasOverflowed()))
>+        RELEASE_ASSERT_NOT_REACHED();
>+
>+    auto locker = SharedDisplayListHandle::Lock { *this };
>+    CheckedSize checkedUnreadBytes = header().unreadBytes;
>+    checkedUnreadBytes += amount;
>+    if (UNLIKELY(checkedUnreadBytes.hasOverflowed()))
>+        RELEASE_ASSERT_NOT_REACHED();
>+
>+    m_writableOffset = checkedWritableOffset.unsafeGet();
>+    header().unreadBytes = checkedUnreadBytes.unsafeGet();
>+    return checkedUnreadBytes.unsafeGet();
>+}
>+
>+size_t DisplayListWriterHandle::availableCapacity() const
>+{
>+    if (UNLIKELY(sharedMemory().size() < writableOffset()))
>+        RELEASE_ASSERT_NOT_REACHED();
>+
>+    return sharedMemory().size() - writableOffset();
>+}
>+
>+DisplayList::ItemBufferHandle DisplayListWriterHandle::createHandle() const
>+{
>+    return {
>+        identifier(),
>+        data() + writableOffset(),
>+        availableCapacity()
>+    };
>+}
>+
>+bool DisplayListWriterHandle::resetWritableOffsetIfPossible()
>+{
>+    if (m_writableOffset <= SharedDisplayListHandle::reservedCapacityAtStart) {
>+        RELEASE_ASSERT(m_writableOffset == SharedDisplayListHandle::reservedCapacityAtStart);
>+        return true;
>+    }
>+
>+    if (unreadBytes())
>+        return false;
>+
>+    m_writableOffset = SharedDisplayListHandle::reservedCapacityAtStart;
>+    return true;
>+}
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/DisplayListWriterHandle.h b/Source/WebKit/WebProcess/GPU/graphics/DisplayListWriterHandle.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..75f65084d00f89117d0a1e065024aed9325133ff
>--- /dev/null
>+++ b/Source/WebKit/WebProcess/GPU/graphics/DisplayListWriterHandle.h
>@@ -0,0 +1,59 @@
>+/*
>+ * 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 "SharedDisplayListHandle.h"
>+#include <wtf/FastMalloc.h>
>+
>+namespace WebKit {
>+
>+class DisplayListWriterHandle : public SharedDisplayListHandle {
>+    WTF_MAKE_NONCOPYABLE(DisplayListWriterHandle); WTF_MAKE_FAST_ALLOCATED;
>+public:
>+    static Ref<DisplayListWriterHandle> create(WebCore::DisplayList::ItemBufferIdentifier identifier, Ref<SharedMemory>&& sharedMemory)
>+    {
>+        return adoptRef(*new DisplayListWriterHandle(identifier, WTFMove(sharedMemory)));
>+    }
>+
>+    size_t writableOffset() const { return m_writableOffset; }
>+    size_t availableCapacity() const;
>+
>+    bool resetWritableOffsetIfPossible();
>+
>+    size_t advance(size_t amount) override;
>+    WebCore::DisplayList::ItemBufferHandle createHandle() const;
>+
>+private:
>+    DisplayListWriterHandle(WebCore::DisplayList::ItemBufferIdentifier identifier, Ref<SharedMemory>&& sharedMemory)
>+        : SharedDisplayListHandle(identifier, WTFMove(sharedMemory))
>+        , m_writableOffset(SharedDisplayListHandle::reservedCapacityAtStart)
>+    {
>+    }
>+
>+    size_t m_writableOffset { 0 };
>+};
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>index 59857ff07a5ac2f4b32c56632514b45de10197b8..01e53e15c4b1d1f50afd70bdcc9b1684496e5d63 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>@@ -34,6 +34,7 @@
> #include <WebCore/DisplayListImageBuffer.h>
> #include <WebCore/DisplayListItems.h>
> #include <WebCore/DisplayListRecorder.h>
>+#include <wtf/SystemTracing.h>
> 
> namespace WebKit {
> 
>@@ -139,6 +140,7 @@ protected:
> 
>     void flushDrawingContext() override
>     {
>+        TraceScope tracingScope(FlushRemoteImageBufferStart, FlushRemoteImageBufferEnd);
>         flushDrawingContextAndCommit();
>         timeoutWaitForFlushDisplayListWasCommitted();
>     }
>@@ -152,8 +154,9 @@ protected:
>         if (displayList.isEmpty())
>             return;
> 
>-        TraceScope tracingScope(FlushRemoteImageBufferStart, FlushRemoteImageBufferEnd, 1);
>-        m_sentFlushIdentifier = m_remoteRenderingBackendProxy->flushDisplayListAndCommit(displayList, m_renderingResourceIdentifier);
>+        m_sentFlushIdentifier = WebCore::DisplayList::FlushIdentifier::generate();
>+        displayList.template append<WebCore::DisplayList::FlushContext>(m_sentFlushIdentifier);
>+        m_remoteRenderingBackendProxy->submitDisplayList(displayList, m_renderingResourceIdentifier);
>         m_itemCountInCurrentDisplayList = 0;
>         displayList.clear();
>     }
>@@ -163,7 +166,6 @@ protected:
>         if (!m_remoteRenderingBackendProxy || displayList.isEmpty())
>             return;
> 
>-        TraceScope tracingScope(FlushRemoteImageBufferStart, FlushRemoteImageBufferEnd);
>         m_remoteRenderingBackendProxy->submitDisplayList(displayList, m_renderingResourceIdentifier);
>     }
> 
>@@ -182,7 +184,7 @@ protected:
>     WebCore::DisplayList::ItemBufferHandle createItemBuffer(size_t capacity) override
>     {
>         if (m_remoteRenderingBackendProxy)
>-            return m_remoteRenderingBackendProxy->createItemBuffer(capacity);
>+            return m_remoteRenderingBackendProxy->createItemBuffer(capacity, m_renderingResourceIdentifier);
> 
>         ASSERT_NOT_REACHED();
>         return { };
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>index 8d8615b8a96c74470b09437d8cd7c7a165bc65da..b1c03b3ada874842dc17303dca4199093b0538fa 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>@@ -28,13 +28,13 @@
> 
> #if ENABLE(GPU_PROCESS)
> 
>+#include "DisplayListWriterHandle.h"
> #include "GPUConnectionToWebProcess.h"
> #include "GPUProcessConnection.h"
> #include "ImageDataReference.h"
> #include "PlatformRemoteImageBufferProxy.h"
> #include "RemoteRenderingBackendMessages.h"
> #include "RemoteRenderingBackendProxyMessages.h"
>-#include "SharedDisplayListHandle.h"
> #include "SharedMemory.h"
> #include "WebProcess.h"
> 
>@@ -115,18 +115,28 @@ RefPtr<ImageData> RemoteRenderingBackendProxy::getImageData(AlphaPremultiplicati
>     return imageDataReference.buffer();
> }
> 
>-void RemoteRenderingBackendProxy::submitDisplayList(const DisplayList::DisplayList& displayList, RenderingResourceIdentifier renderingResourceIdentifier)
>+void RemoteRenderingBackendProxy::submitDisplayList(const DisplayList::DisplayList& displayList, RenderingResourceIdentifier destinationBufferIdentifier)
> {
>-    send(Messages::RemoteRenderingBackend::SubmitDisplayList({ displayList }, renderingResourceIdentifier), m_renderingBackendIdentifier);
>-    m_sharedItemBuffers.clear();
>-}
>+    Optional<std::pair<DisplayList::ItemBufferIdentifier, size_t>> identifierAndOffsetForWakeUpMessage;
>+    bool isFirstHandle = true;
> 
>-DisplayList::FlushIdentifier RemoteRenderingBackendProxy::flushDisplayListAndCommit(const DisplayList::DisplayList& displayList, RenderingResourceIdentifier renderingResourceIdentifier)
>-{
>-    auto sentFlushIdentifier = DisplayList::FlushIdentifier::generate();
>-    send(Messages::RemoteRenderingBackend::FlushDisplayListAndCommit({ displayList }, sentFlushIdentifier, renderingResourceIdentifier), m_renderingBackendIdentifier);
>-    m_sharedItemBuffers.clear();
>-    return sentFlushIdentifier;
>+    displayList.forEachItemBuffer([&] (auto& handle) {
>+        m_identifiersOfHandlesAvailableForWriting.add(handle.identifier);
>+
>+        auto* sharedHandle = m_sharedDisplayListHandles.get(handle.identifier);
>+        RELEASE_ASSERT_WITH_MESSAGE(sharedHandle, "%s failed to find shared display list", __PRETTY_FUNCTION__);
>+
>+        bool unreadCountWasEmpty = sharedHandle->advance(handle.capacity) == handle.capacity;
>+        if (isFirstHandle && unreadCountWasEmpty)
>+            identifierAndOffsetForWakeUpMessage = {{ handle.identifier, handle.data - sharedHandle->data() }};
>+
>+        isFirstHandle = false;
>+    });
>+
>+    if (identifierAndOffsetForWakeUpMessage) {
>+        auto [identifier, offset] = *identifierAndOffsetForWakeUpMessage;
>+        send(Messages::RemoteRenderingBackend::WakeUpAndApplyDisplayList(identifier, offset, destinationBufferIdentifier), m_renderingBackendIdentifier);
>+    }
> }
> 
> void RemoteRenderingBackendProxy::releaseRemoteResource(RenderingResourceIdentifier renderingResourceIdentifier)
>@@ -159,21 +169,56 @@ void RemoteRenderingBackendProxy::flushDisplayListWasCommitted(DisplayList::Flus
>         downcast<UnacceleratedRemoteImageBufferProxy>(*imageBuffer).commitFlushDisplayList(flushIdentifier);
> }
> 
>-DisplayList::ItemBufferHandle RemoteRenderingBackendProxy::createItemBuffer(size_t capacity)
>+void RemoteRenderingBackendProxy::updateReusableHandles()
> {
>+    for (auto identifier : m_identifiersOfHandlesAvailableForWriting) {
>+        auto* handle = m_sharedDisplayListHandles.get(identifier);
>+        if (!handle->resetWritableOffsetIfPossible())
>+            continue;
>+
>+        if (m_identifiersOfReusableHandles.contains(identifier))
>+            continue;
>+
>+        m_identifiersOfReusableHandles.append(identifier);
>+    }
>+}
>+
>+DisplayList::ItemBufferHandle RemoteRenderingBackendProxy::createItemBuffer(size_t capacity, RenderingResourceIdentifier destinationBufferIdentifier)
>+{
>+    updateReusableHandles();
>+
>+    while (!m_identifiersOfReusableHandles.isEmpty()) {
>+        auto identifier = m_identifiersOfReusableHandles.first();
>+        auto* reusableHandle = m_sharedDisplayListHandles.get(identifier);
>+        RELEASE_ASSERT_WITH_MESSAGE(reusableHandle, "%s failed to find shared display list", __PRETTY_FUNCTION__);
>+
>+        if (m_identifiersOfHandlesAvailableForWriting.contains(identifier) && reusableHandle->availableCapacity() >= capacity) {
>+            m_identifiersOfHandlesAvailableForWriting.remove(identifier);
>+            return reusableHandle->createHandle();
>+        }
>+
>+        m_identifiersOfReusableHandles.removeFirst();
>+    }
>+
>     static constexpr size_t defaultSharedItemBufferSize = 1 << 16;
> 
>-    auto sharedMemory = SharedMemory::allocate(std::max(defaultSharedItemBufferSize, capacity));
>+    auto sharedMemory = SharedMemory::allocate(std::max(defaultSharedItemBufferSize, capacity + SharedDisplayListHandle::reservedCapacityAtStart));
>     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());
>+    sharedMemory->createHandle(sharedMemoryHandle, SharedMemory::Protection::ReadWrite);
>+
>+    auto identifier = DisplayList::ItemBufferIdentifier::generate();
>+    send(Messages::RemoteRenderingBackend::DidCreateSharedDisplayListHandle(identifier, { WTFMove(sharedMemoryHandle), sharedMemory->size() }, destinationBufferIdentifier), m_renderingBackendIdentifier);
>+
>+    auto newHandle = DisplayListWriterHandle::create(identifier, sharedMemory.releaseNonNull());
>+    auto displayListHandle = newHandle->createHandle();
>+
>+    m_identifiersOfReusableHandles.append(identifier);
>+    m_sharedDisplayListHandles.set(identifier, WTFMove(newHandle));
> 
>-    return { identifier, reinterpret_cast<uint8_t*>(sharedMemory->data()), sharedMemory->size() };
>+    return displayListHandle;
> }
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>index a542c8335e0e533e0513e576426245ebb7641cf9..aba962e408938cf0fb2e34d5ba0803a2e0ca4727 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>@@ -34,6 +34,7 @@
> #include "RenderingBackendIdentifier.h"
> #include <WebCore/DisplayList.h>
> #include <WebCore/RenderingResourceIdentifier.h>
>+#include <wtf/Deque.h>
> #include <wtf/WeakPtr.h>
> 
> namespace WebCore {
>@@ -50,6 +51,8 @@ enum class RenderingMode : bool;
> 
> namespace WebKit {
> 
>+class DisplayListWriterHandle;
>+
> class RemoteRenderingBackendProxy
>     : public IPC::MessageSender
>     , private IPC::MessageReceiver
>@@ -60,7 +63,7 @@ public:
>     ~RemoteRenderingBackendProxy();
> 
>     RemoteResourceCacheProxy& remoteResourceCacheProxy() { return m_remoteResourceCacheProxy; }
>-    WebCore::DisplayList::ItemBufferHandle createItemBuffer(size_t);
>+    WebCore::DisplayList::ItemBufferHandle createItemBuffer(size_t capacity, WebCore::RenderingResourceIdentifier destinationBufferIdentifier);
> 
>     // IPC::MessageSender.
>     IPC::Connection* messageSenderConnection() const override;
>@@ -72,7 +75,7 @@ public:
>     // Messages to be sent.
>     RefPtr<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 submitDisplayList(const WebCore::DisplayList::DisplayList&, WebCore::RenderingResourceIdentifier);
>+    void submitDisplayList(const WebCore::DisplayList::DisplayList&, WebCore::RenderingResourceIdentifier destinationBufferIdentifier);
>     WebCore::DisplayList::FlushIdentifier flushDisplayListAndCommit(const WebCore::DisplayList::DisplayList&, WebCore::RenderingResourceIdentifier);
>     void releaseRemoteResource(WebCore::RenderingResourceIdentifier);
> 
>@@ -82,12 +85,16 @@ public:
> private:
>     RemoteRenderingBackendProxy();
> 
>+    void updateReusableHandles();
>+
>     // Messages to be received.
>     void imageBufferBackendWasCreated(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle, WebCore::RenderingResourceIdentifier);
>     void flushDisplayListWasCommitted(WebCore::DisplayList::FlushIdentifier, WebCore::RenderingResourceIdentifier);
> 
>     RemoteResourceCacheProxy m_remoteResourceCacheProxy;
>-    HashMap<WebCore::DisplayList::ItemBufferIdentifier, RefPtr<SharedMemory>> m_sharedItemBuffers;
>+    HashMap<WebCore::DisplayList::ItemBufferIdentifier, RefPtr<DisplayListWriterHandle>> m_sharedDisplayListHandles;
>+    Deque<WebCore::DisplayList::ItemBufferIdentifier> m_identifiersOfReusableHandles;
>+    HashSet<WebCore::DisplayList::ItemBufferIdentifier> m_identifiersOfHandlesAvailableForWriting;
>     RenderingBackendIdentifier m_renderingBackendIdentifier { RenderingBackendIdentifier::generate() };
> };
>

Actions: View | Formatted Diff | Diff

Attachments on bug 218426: 413231 | 413367 | 413510 | 413525 | 413526 | 413534 | 413701 | 413729 | 413767 | 413775