Changeset 291733 in webkit

Timestamp:

Mar 22, 2022, 7:06:04 PM (5 years ago)

Author:

Simon Fraser

Message:

Swap all RemoteLayerBackingStore buffers in a single IPC
​https://bugs.webkit.org/show_bug.cgi?id=238210

Reviewed by Tim Horton.

PrepareBuffersForDisplay is a sync IPC (since we need the result before painting), and sync
IPC per-layer has performance impact. So group all the swapping into a single IPC with the
GPU Process.

The PrepareBuffersForDisplay message now takes a vector of
PrepareBackingStoreBuffersInputData, and returns a vector of
PrepareBackingStoreBuffersOutputData. Swapped buffers are applied to the
RemoteLayerBackingStore as before, with a minor change in the place that setNeedsDisplay()
is called in the case where we need a full display.

• GPUProcess/graphics/RemoteRenderingBackend.cpp:

(WebKit::RemoteRenderingBackend::prepareBuffersForDisplay):
(WebKit::RemoteRenderingBackend::prepareLayerBuffersForDisplay):

• GPUProcess/graphics/RemoteRenderingBackend.h:
• GPUProcess/graphics/RemoteRenderingBackend.messages.in:
• Scripts/webkit/messages.py:

(headers_for_type):

• Shared/RemoteLayerTree/RemoteLayerBackingStore.h:
• Shared/RemoteLayerTree/RemoteLayerBackingStore.mm:

(WebKit::RemoteLayerBackingStore::applySwappedBuffers):
(WebKit::RemoteLayerBackingStore::performDelegatedLayerDisplay):
(WebKit::RemoteLayerBackingStore::prepareToDisplay):
(WebKit::RemoteLayerBackingStore::ensureFrontBuffer):
(WebKit::RemoteLayerBackingStore::prepareBuffers):
(WebKit::operator<<): Deleted.

• Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.h:
• Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.mm:

(WebKit::RemoteLayerBackingStoreCollection::prepareBackingStoreBuffers): Deleted.

• Shared/RemoteLayerTree/RemoteLayerWithRemoteRenderingBackingStoreCollection.h:
• Shared/RemoteLayerTree/RemoteLayerWithRemoteRenderingBackingStoreCollection.mm:

(WebKit::RemoteLayerWithRemoteRenderingBackingStoreCollection::prepareBackingStoresForDisplay):
(WebKit::RemoteLayerWithRemoteRenderingBackingStoreCollection::prepareBackingStoreBuffers): Deleted.

• WebKit.xcodeproj/project.pbxproj:
• WebProcess/GPU/graphics/PrepareBackingStoreBuffersData.h: Added.

(WebKit::PrepareBackingStoreBuffersInputData::encode const):
(WebKit::PrepareBackingStoreBuffersInputData::decode):
(WebKit::PrepareBackingStoreBuffersOutputData::encode const):
(WebKit::PrepareBackingStoreBuffersOutputData::decode):

• WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:

(WebKit::RemoteRenderingBackendProxy::prepareBuffersForDisplay):

• WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:

Location:

trunk/Source/WebKit

Files:

• ChangeLog (modified) (1 diff)
• GPUProcess/graphics/RemoteRenderingBackend.cpp (modified) (5 diffs)
• GPUProcess/graphics/RemoteRenderingBackend.h (modified) (3 diffs)
• GPUProcess/graphics/RemoteRenderingBackend.messages.in (modified) (1 diff)
• Scripts/webkit/messages.py (modified) (1 diff)
• Shared/RemoteLayerTree/RemoteLayerBackingStore.h (modified) (3 diffs)
• Shared/RemoteLayerTree/RemoteLayerBackingStore.mm (modified) (4 diffs)
• Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.h (modified) (1 diff)
• Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.mm (modified) (1 diff)
• Shared/RemoteLayerTree/RemoteLayerWithRemoteRenderingBackingStoreCollection.h (modified) (1 diff)
• Shared/RemoteLayerTree/RemoteLayerWithRemoteRenderingBackingStoreCollection.mm (modified) (1 diff)
• WebKit.xcodeproj/project.pbxproj (modified) (2 diffs)
• WebProcess/GPU/graphics/PrepareBackingStoreBuffersData.h (added)
• WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp (modified) (3 diffs)
• WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h (modified) (1 diff)

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2022-03-22  Simon Fraser  <simon.fraser@apple.com>
+
+        Swap all RemoteLayerBackingStore buffers in a single IPC
+        https://bugs.webkit.org/show_bug.cgi?id=238210
+
+        Reviewed by Tim Horton.
+
+        PrepareBuffersForDisplay is a sync IPC (since we need the result before painting), and sync
+        IPC per-layer has performance impact. So group all the swapping into a single IPC with the
+        GPU Process.
+
+        The PrepareBuffersForDisplay message now takes a vector of
+        PrepareBackingStoreBuffersInputData, and returns a vector of
+        PrepareBackingStoreBuffersOutputData. Swapped buffers are applied to the
+        RemoteLayerBackingStore as before, with a minor change in the place that setNeedsDisplay()
+        is called in the case where we need a full display.
+
+        * GPUProcess/graphics/RemoteRenderingBackend.cpp:
+        (WebKit::RemoteRenderingBackend::prepareBuffersForDisplay):
+        (WebKit::RemoteRenderingBackend::prepareLayerBuffersForDisplay):
+        * GPUProcess/graphics/RemoteRenderingBackend.h:
+        * GPUProcess/graphics/RemoteRenderingBackend.messages.in:
+        * Scripts/webkit/messages.py:
+        (headers_for_type):
+        * Shared/RemoteLayerTree/RemoteLayerBackingStore.h:
+        * Shared/RemoteLayerTree/RemoteLayerBackingStore.mm:
+        (WebKit::RemoteLayerBackingStore::applySwappedBuffers):
+        (WebKit::RemoteLayerBackingStore::performDelegatedLayerDisplay):
+        (WebKit::RemoteLayerBackingStore::prepareToDisplay):
+        (WebKit::RemoteLayerBackingStore::ensureFrontBuffer):
+        (WebKit::RemoteLayerBackingStore::prepareBuffers):
+        (WebKit::operator<<): Deleted.
+        * Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.h:
+        * Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.mm:
+        (WebKit::RemoteLayerBackingStoreCollection::prepareBackingStoreBuffers): Deleted.
+        * Shared/RemoteLayerTree/RemoteLayerWithRemoteRenderingBackingStoreCollection.h:
+        * Shared/RemoteLayerTree/RemoteLayerWithRemoteRenderingBackingStoreCollection.mm:
+        (WebKit::RemoteLayerWithRemoteRenderingBackingStoreCollection::prepareBackingStoresForDisplay):
+        (WebKit::RemoteLayerWithRemoteRenderingBackingStoreCollection::prepareBackingStoreBuffers): Deleted.
+        * WebKit.xcodeproj/project.pbxproj:
+        * WebProcess/GPU/graphics/PrepareBackingStoreBuffersData.h: Added.
+        (WebKit::PrepareBackingStoreBuffersInputData::encode const):
+        (WebKit::PrepareBackingStoreBuffersInputData::decode):
+        (WebKit::PrepareBackingStoreBuffersOutputData::encode const):
+        (WebKit::PrepareBackingStoreBuffersOutputData::decode):
+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:
+        (WebKit::RemoteRenderingBackendProxy::prepareBuffersForDisplay):
+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
+
 2022-03-22  Sihui Liu  <sihui_liu@apple.com>
 

trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp

@@ -400 +400 @@
 }
 
+void RemoteRenderingBackend::prepareBuffersForDisplay(Vector<PrepareBackingStoreBuffersInputData> swapBuffersInput, CompletionHandler<void(const Vector<PrepareBackingStoreBuffersOutputData>&)>&& completionHandler)
+{
+    Vector<PrepareBackingStoreBuffersOutputData> outputData;
+    outputData.resizeToFit(swapBuffersInput.size());
+
+    for (unsigned i = 0; i < swapBuffersInput.size(); ++i)
+        prepareLayerBuffersForDisplay(swapBuffersInput[i], outputData[i]);
+
+    completionHandler(outputData);
+}
+
 // This is the GPU Process version of RemoteLayerBackingStore::prepareBuffers().
-void RemoteRenderingBackend::prepareBuffersForDisplay(const BufferIdentifierSet& bufferSet, bool supportsPartialRepaint, bool hasEmptyDirtyRegion, CompletionHandler<void(const BufferIdentifierSet& swappedBufferSet, std::optional<ImageBufferBackendHandle>&& frontBufferHandle, SwapBuffersDisplayRequirement prepareResult)>&& completionHandler)
+void RemoteRenderingBackend::prepareLayerBuffersForDisplay(const PrepareBackingStoreBuffersInputData& inputData, PrepareBackingStoreBuffersOutputData& outputData)
 {
     auto fetchBuffer = [&](std::optional<RenderingResourceIdentifier> identifier) -> ImageBuffer* {
@@ -413 +424 @@
     };
 
-    auto frontBuffer = fetchBuffer(bufferSet.front);
-    auto backBuffer = fetchBuffer(bufferSet.back);
-    auto secondaryBackBuffer = fetchBuffer(bufferSet.secondaryBack);
+    auto frontBuffer = fetchBuffer(inputData.bufferSet.front);
+    auto backBuffer = fetchBuffer(inputData.bufferSet.back);
+    auto secondaryBackBuffer = fetchBuffer(inputData.bufferSet.secondaryBack);
 
     LOG_WITH_STREAM(RemoteRenderingBufferVolatility, stream << "GPU Process: RemoteRenderingBackend::prepareBuffersForDisplay - front "
-        << bufferSet.front << " (in-use " << (frontBuffer && frontBuffer->isInUse()) << ") "
-        << bufferSet.back << " (in-use " << (backBuffer && backBuffer->isInUse()) << ") "
-        << bufferSet.secondaryBack << " (in-use " << (secondaryBackBuffer && secondaryBackBuffer->isInUse()) << ") ");
+        << inputData.bufferSet.front << " (in-use " << (frontBuffer && frontBuffer->isInUse()) << ") "
+        << inputData.bufferSet.back << " (in-use " << (backBuffer && backBuffer->isInUse()) << ") "
+        << inputData.bufferSet.secondaryBack << " (in-use " << (secondaryBackBuffer && secondaryBackBuffer->isInUse()) << ") ");
 
     bool needsFullDisplay = false;
@@ -430 +441 @@
     }
 
-    if (frontBuffer && !needsFullDisplay && hasEmptyDirtyRegion) {
+    if (frontBuffer && !needsFullDisplay && inputData.hasEmptyDirtyRegion) {
         // No swap necessary, but we do need to return the front buffer handle.
-        auto frontBufferHandle = handleFromBuffer(*frontBuffer);
-        auto resultBufferSet = BufferIdentifierSet { bufferIdentifer(frontBuffer), bufferIdentifer(backBuffer), bufferIdentifer(secondaryBackBuffer) };
-        completionHandler(resultBufferSet, WTFMove(frontBufferHandle), SwapBuffersDisplayRequirement::NeedsNoDisplay);
+        outputData.frontBufferHandle = handleFromBuffer(*frontBuffer);
+        outputData.bufferSet = BufferIdentifierSet { bufferIdentifer(frontBuffer), bufferIdentifer(backBuffer), bufferIdentifer(secondaryBackBuffer) };
+        outputData.displayRequirement = SwapBuffersDisplayRequirement::NeedsNoDisplay;
         return;
     }
     
-    if (!frontBuffer || !supportsPartialRepaint)
+    if (!frontBuffer || !inputData.supportsPartialRepaint)
         needsFullDisplay = true;
 
@@ -453 +464 @@
     std::swap(frontBuffer, backBuffer);
 
-    std::optional<ImageBufferBackendHandle> frontBufferHandle;
+    outputData.bufferSet = BufferIdentifierSet { bufferIdentifer(frontBuffer), bufferIdentifer(backBuffer), bufferIdentifer(secondaryBackBuffer) };
     if (frontBuffer) {
         auto previousState = frontBuffer->setNonVolatile();
@@ -459 +470 @@
             needsFullDisplay = true;
 
-        frontBufferHandle = handleFromBuffer(*frontBuffer);
-    }
-
-    auto resultBufferSet = BufferIdentifierSet { bufferIdentifer(frontBuffer), bufferIdentifer(backBuffer), bufferIdentifer(secondaryBackBuffer) };
+        outputData.frontBufferHandle = handleFromBuffer(*frontBuffer);
+    } else
+        needsFullDisplay = true;
 
     LOG_WITH_STREAM(RemoteRenderingBufferVolatility, stream << "GPU Process: prepareBuffersForDisplay - swapped from ["
-        << bufferSet.front << ", " << bufferSet.back << ", " << bufferSet.secondaryBack << "] to ["
-        << resultBufferSet.front << ", " << resultBufferSet.back << ", " << resultBufferSet.secondaryBack << "]");
-
-    auto displayRequirement = needsFullDisplay ? SwapBuffersDisplayRequirement::NeedsFullDisplay : SwapBuffersDisplayRequirement::NeedsNormalDisplay;
-    completionHandler(resultBufferSet, WTFMove(frontBufferHandle), displayRequirement);
+        << inputData.bufferSet.front << ", " << inputData.bufferSet.back << ", " << inputData.bufferSet.secondaryBack << "] to ["
+        << outputData.bufferSet.front << ", " << outputData.bufferSet.back << ", " << outputData.bufferSet.secondaryBack << "]");
+
+    outputData.displayRequirement = needsFullDisplay ? SwapBuffersDisplayRequirement::NeedsFullDisplay : SwapBuffersDisplayRequirement::NeedsNormalDisplay;
 }
 

trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h

@@ -69 +69 @@
 class RemoteDisplayListRecorder;
 struct BufferIdentifierSet;
+struct PrepareBackingStoreBuffersInputData;
+struct PrepareBackingStoreBuffersOutputData;
 struct RemoteRenderingBackendCreationParameters;
 enum class SwapBuffersDisplayRequirement : uint8_t;
@@ -121 +123 @@
     void finalizeRenderingUpdate(RenderingUpdateID);
     void markSurfacesVolatile(const Vector<WebCore::RenderingResourceIdentifier>&, CompletionHandler<void(const Vector<WebCore::RenderingResourceIdentifier>& markedVolatileBufferIdentifiers)>&&);
-
-    void prepareBuffersForDisplay(const BufferIdentifierSet& bufferSet, bool supportsPartialRepaint, bool hasEmptyDirtyRegion, CompletionHandler<void(const BufferIdentifierSet& swappedBufferSet, std::optional<ImageBufferBackendHandle>&& frontBufferHandle, SwapBuffersDisplayRequirement prepareResult)>&&);
+    void prepareBuffersForDisplay(Vector<PrepareBackingStoreBuffersInputData> swapBuffersInput, CompletionHandler<void(const Vector<PrepareBackingStoreBuffersOutputData>&)>&&);
 
     // Received messages translated to use QualifiedRenderingResourceIdentifier.
@@ -133 +134 @@
     void releaseRemoteResourceWithQualifiedIdentifier(QualifiedRenderingResourceIdentifier);
     void cacheFontWithQualifiedIdentifier(Ref<WebCore::Font>&&, QualifiedRenderingResourceIdentifier);
+
+    void prepareLayerBuffersForDisplay(const PrepareBackingStoreBuffersInputData&, PrepareBackingStoreBuffersOutputData&);
 
     Ref<IPC::StreamConnectionWorkQueue> m_workQueue;

trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in

@@ -38 +38 @@
     ReleaseRemoteResource(WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
 
-    PrepareBuffersForDisplay(struct WebKit::BufferIdentifierSet bufferSet, bool supportsPartialRepaint, bool hasEmptyDirtyRegion) -> (struct WebKit::BufferIdentifierSet swappedBufferSet, std::optional<WebKit::ImageBufferBackendHandle> frontBufferHandle, enum:uint8_t WebKit::SwapBuffersDisplayRequirement prepareResult) Synchronous NotStreamEncodable NotStreamEncodableReply
+    PrepareBuffersForDisplay(Vector<WebKit::PrepareBackingStoreBuffersInputData> swapBuffersInput) -> (Vector<WebKit::PrepareBackingStoreBuffersOutputData> swapBuffersOutput) Synchronous NotStreamEncodable NotStreamEncodableReply
 
     MarkSurfacesVolatile(Vector<WebCore::RenderingResourceIdentifier> renderingResourceIdentifiers) -> (Vector<WebCore::RenderingResourceIdentifier> markedVolatileBufferIdentifiers) Synchronous

trunk/Source/WebKit/Scripts/webkit/messages.py

@@ -890 +890 @@
         'WebKit::PaymentSetupConfiguration': ['"PaymentSetupConfigurationWebKit.h"'],
         'WebKit::PaymentSetupFeatures': ['"ApplePayPaymentSetupFeaturesWebKit.h"'],
+        'WebKit::PrepareBackingStoreBuffersInputData': ['"PrepareBackingStoreBuffersData.h"'],
+        'WebKit::PrepareBackingStoreBuffersOutputData': ['"PrepareBackingStoreBuffersData.h"'],
         'WebKit::RespectSelectionAnchor': ['"GestureTypes.h"'],
         'WebKit::RemoteVideoFrameReadReference': ['"RemoteVideoFrameIdentifier.h"'],

trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerBackingStore.h

@@ -68 +68 @@
     void setContents(WTF::MachSendRight&& surfaceHandle);
 
-    SwapBuffersDisplayRequirement prepareBuffers(bool hasEmptyDirtyRegion);
-
     // Returns true if we need encode the buffer.
     bool layerWillBeDisplayed();
     bool needsDisplay() const;
 
+    bool performDelegatedLayerDisplay();
     void prepareToDisplay();
     void paintContents();
@@ -100 +99 @@
 
     // Just for RemoteBackingStoreCollection.
-    void applySwappedBuffers(RefPtr<WebCore::ImageBuffer>&& front, RefPtr<WebCore::ImageBuffer>&& back, RefPtr<WebCore::ImageBuffer>&& secondaryBack);
+    void applySwappedBuffers(RefPtr<WebCore::ImageBuffer>&& front, RefPtr<WebCore::ImageBuffer>&& back, RefPtr<WebCore::ImageBuffer>&& secondaryBack, SwapBuffersDisplayRequirement);
     WebCore::SetNonVolatileResult swapToValidFrontBuffer();
 
@@ -144 +143 @@
     bool setBufferVolatile(Buffer&);
     WebCore::SetNonVolatileResult setBufferNonVolatile(Buffer&);
+    
+    SwapBuffersDisplayRequirement prepareBuffers();
+    void ensureFrontBuffer();
+    void dirtyRepaintCounterIfNecessary();
 
     PlatformCALayerRemote* m_layer;

trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerBackingStore.mm

@@ -250 +250 @@
 
 // Called after buffer swapping in the GPU process.
-void RemoteLayerBackingStore::applySwappedBuffers(RefPtr<WebCore::ImageBuffer>&& front, RefPtr<WebCore::ImageBuffer>&& back, RefPtr<WebCore::ImageBuffer>&& secondaryBack)
+void RemoteLayerBackingStore::applySwappedBuffers(RefPtr<WebCore::ImageBuffer>&& front, RefPtr<WebCore::ImageBuffer>&& back, RefPtr<WebCore::ImageBuffer>&& secondaryBack, SwapBuffersDisplayRequirement displayRequirement)
 {
     ASSERT(WebProcess::singleton().shouldUseRemoteRenderingFor(WebCore::RenderingPurpose::DOM));
+    m_contentsBufferHandle = std::nullopt;
 
     m_frontBuffer.imageBuffer = WTFMove(front);
     m_backBuffer.imageBuffer = WTFMove(back);
     m_secondaryBackBuffer.imageBuffer = WTFMove(secondaryBack);
+
+    if (displayRequirement == SwapBuffersDisplayRequirement::NeedsNoDisplay)
+        return;
+
+    if (displayRequirement == SwapBuffersDisplayRequirement::NeedsFullDisplay)
+        setNeedsDisplay();
+
+    dirtyRepaintCounterIfNecessary();
+    ensureFrontBuffer();
 }
 
@@ -273 +283 @@
 }
 
-#if !LOG_DISABLED
-static TextStream& operator<<(TextStream& ts, SwapBuffersDisplayRequirement result)
-{
-    switch (result) {
-    case SwapBuffersDisplayRequirement::NeedsFullDisplay: ts << "full display"; break;
-    case SwapBuffersDisplayRequirement::NeedsNormalDisplay: ts << "normal display"; break;
-    case SwapBuffersDisplayRequirement::NeedsNoDisplay: ts << "no display"; break;
-    }
-    return ts;
-}
-#endif
-
 bool RemoteLayerBackingStore::needsDisplay() const
 {
@@ -303 +301 @@
 }
 
-void RemoteLayerBackingStore::prepareToDisplay()
-{
-    ASSERT(!m_frontBufferFlushers.size());
-
-    auto* collection = backingStoreCollection();
-    if (!collection) {
-        ASSERT_NOT_REACHED();
-        return;
-    }
-
-    ASSERT(collection->backingStoreNeedsDisplay(*this));
-
-    LOG_WITH_STREAM(RemoteRenderingBufferVolatility, stream << "RemoteLayerBackingStore " << m_layer->layerID() << " prepareToDisplay()");
-
+bool RemoteLayerBackingStore::performDelegatedLayerDisplay()
+{
     auto& layerOwner = *m_layer->owner();
     if (layerOwner.platformCALayerDelegatesDisplay(m_layer)) {
@@ -322 +308 @@
         layerOwner.platformCALayerLayerDisplay(m_layer);
         layerOwner.platformCALayerLayerDidDisplay(m_layer);
-        return;
-    }
-
-    m_contentsBufferHandle = std::nullopt;
-
-    auto displayRequirement = collection->prepareBackingStoreBuffers(*this);
-
-    LOG_WITH_STREAM(RemoteRenderingBufferVolatility, stream << "RemoteLayerBackingStore " << m_layer->layerID() << " prepareToDisplay() - " << displayRequirement);
-
-    ASSERT(displayRequirement != SwapBuffersDisplayRequirement::NeedsNoDisplay);
+        return true;
+    }
+    
+    return false;
+}
+
+void RemoteLayerBackingStore::prepareToDisplay()
+{
+    ASSERT(!WebProcess::singleton().shouldUseRemoteRenderingFor(WebCore::RenderingPurpose::DOM));
+    ASSERT(!m_frontBufferFlushers.size());
+
+    auto* collection = backingStoreCollection();
+    if (!collection) {
+        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    ASSERT(collection->backingStoreNeedsDisplay(*this));
+
+    LOG_WITH_STREAM(RemoteRenderingBufferVolatility, stream << "RemoteLayerBackingStore " << m_layer->layerID() << " prepareToDisplay()");
+
+    if (performDelegatedLayerDisplay())
+        return;
+
+    auto displayRequirement = prepareBuffers();
+    if (displayRequirement == SwapBuffersDisplayRequirement::NeedsNoDisplay)
+        return;
 
     if (displayRequirement == SwapBuffersDisplayRequirement::NeedsFullDisplay)
         setNeedsDisplay();
 
-    if (layerOwner.platformCALayerShowRepaintCounter(m_layer)) {
+    dirtyRepaintCounterIfNecessary();
+    ensureFrontBuffer();
+}
+
+void RemoteLayerBackingStore::dirtyRepaintCounterIfNecessary()
+{
+    if (m_layer->owner()->platformCALayerShowRepaintCounter(m_layer)) {
         WebCore::IntRect indicatorRect(0, 0, 52, 27);
         m_dirtyRegion.unite(indicatorRect);
     }
-
+}
+
+void RemoteLayerBackingStore::ensureFrontBuffer()
+{
+    if (m_frontBuffer.imageBuffer)
+        return;
+
+    auto* collection = backingStoreCollection();
+    if (!collection) {
+        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    m_frontBuffer.imageBuffer = collection->allocateBufferForBackingStore(*this);
+
+#if ENABLE(CG_DISPLAY_LIST_BACKED_IMAGE_BUFFER)
+    if (m_includeDisplayList == IncludeDisplayList::Yes)
+        m_frontBuffer.displayListImageBuffer = WebCore::ConcreteImageBuffer<CGDisplayListImageBufferBackend>::create(m_size, m_scale, WebCore::DestinationColorSpace::SRGB(), pixelFormat(), nullptr);
+#endif
+}
+
+#if !LOG_DISABLED
+static TextStream& operator<<(TextStream& ts, SwapBuffersDisplayRequirement result)
+{
+    switch (result) {
+    case SwapBuffersDisplayRequirement::NeedsFullDisplay: ts << "full display"; break;
+    case SwapBuffersDisplayRequirement::NeedsNormalDisplay: ts << "normal display"; break;
+    case SwapBuffersDisplayRequirement::NeedsNoDisplay: ts << "no display"; break;
+    }
+    return ts;
+}
+#endif
+
+SwapBuffersDisplayRequirement RemoteLayerBackingStore::prepareBuffers()
+{
+    ASSERT(!WebProcess::singleton().shouldUseRemoteRenderingFor(WebCore::RenderingPurpose::DOM));
+    m_contentsBufferHandle = std::nullopt;
+
+    auto displayRequirement = SwapBuffersDisplayRequirement::NeedsNoDisplay;
+
+    // Make the previous front buffer non-volatile early, so that we can dirty the whole layer if it comes back empty.
+    if (!hasFrontBuffer() || setFrontBufferNonVolatile() == WebCore::SetNonVolatileResult::Empty)
+        displayRequirement = SwapBuffersDisplayRequirement::NeedsFullDisplay;
+    else if (!hasEmptyDirtyRegion())
+        displayRequirement = SwapBuffersDisplayRequirement::NeedsNormalDisplay;
+
+    if (displayRequirement == SwapBuffersDisplayRequirement::NeedsNoDisplay)
+        return displayRequirement;
+
+    if (!supportsPartialRepaint())
+        displayRequirement = SwapBuffersDisplayRequirement::NeedsFullDisplay;
+
+    auto result = swapToValidFrontBuffer();
+    if (!hasFrontBuffer() || result == WebCore::SetNonVolatileResult::Empty)
+        displayRequirement = SwapBuffersDisplayRequirement::NeedsFullDisplay;
+
+    LOG_WITH_STREAM(RemoteRenderingBufferVolatility, stream << "RemoteLayerBackingStore " << m_layer->layerID() << " prepareBuffers() - " << displayRequirement);
+    return displayRequirement;
+}
+
+void RemoteLayerBackingStore::paintContents()
+{
     if (!m_frontBuffer.imageBuffer) {
-        m_frontBuffer.imageBuffer = collection->allocateBufferForBackingStore(*this);
-
-#if ENABLE(CG_DISPLAY_LIST_BACKED_IMAGE_BUFFER)
-        if (m_includeDisplayList == IncludeDisplayList::Yes)
-            m_frontBuffer.displayListImageBuffer = WebCore::ConcreteImageBuffer<CGDisplayListImageBufferBackend>::create(m_size, m_scale, WebCore::DestinationColorSpace::SRGB(), pixelFormat(), nullptr);
-#endif
-    }
-}
-
-SwapBuffersDisplayRequirement RemoteLayerBackingStore::prepareBuffers(bool hasEmptyDirtyRegion)
-{
-    ASSERT(!WebProcess::singleton().shouldUseRemoteRenderingFor(WebCore::RenderingPurpose::DOM));
-
-    bool needsFullDisplay = false;
-
-    // Make the previous front buffer non-volatile early, so that we can dirty the whole layer if it comes back empty.
-    if (setFrontBufferNonVolatile() == WebCore::SetNonVolatileResult::Empty)
-        needsFullDisplay = true;
-
-    if (!needsFullDisplay && hasEmptyDirtyRegion)
-        return SwapBuffersDisplayRequirement::NeedsNoDisplay;
-
-    if (!hasFrontBuffer() || !supportsPartialRepaint())
-        needsFullDisplay = true;
-
-    auto result = swapToValidFrontBuffer();
-    if (result == WebCore::SetNonVolatileResult::Empty)
-        needsFullDisplay = true;
-
-    return needsFullDisplay ? SwapBuffersDisplayRequirement::NeedsFullDisplay : SwapBuffersDisplayRequirement::NeedsNormalDisplay;
-}
-
-void RemoteLayerBackingStore::paintContents()
-{
-    if (!m_frontBuffer.imageBuffer)
-        return;
+        ASSERT(m_layer->owner()->platformCALayerDelegatesDisplay(m_layer));
+        return;
+    }
 
     LOG_WITH_STREAM(RemoteRenderingBufferVolatility, stream << "RemoteLayerBackingStore " << m_layer->layerID() << " paintContents() - has dirty region " << !hasEmptyDirtyRegion());

trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.h

@@ -62 +62 @@
     virtual bool backingStoreNeedsDisplay(const RemoteLayerBackingStore&);
 
-    virtual SwapBuffersDisplayRequirement prepareBackingStoreBuffers(RemoteLayerBackingStore&);
-
-    void prepareBackingStoresForDisplay(RemoteLayerTreeTransaction&);
+    virtual void prepareBackingStoresForDisplay(RemoteLayerTreeTransaction&);
     void paintReachableBackingStoreContents();
 

trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.mm

@@ -164 +164 @@
 }
 
-SwapBuffersDisplayRequirement RemoteLayerBackingStoreCollection::prepareBackingStoreBuffers(RemoteLayerBackingStore& backingStore)
-{
-    return backingStore.prepareBuffers(backingStore.hasEmptyDirtyRegion());
-}
-
 bool RemoteLayerBackingStoreCollection::markBackingStoreVolatile(RemoteLayerBackingStore& backingStore, OptionSet<VolatilityMarkingBehavior> markingBehavior, MonotonicTime now)
 {

trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerWithRemoteRenderingBackingStoreCollection.h

@@ -45 +45 @@
 
     bool backingStoreNeedsDisplay(const RemoteLayerBackingStore&) final;
-    SwapBuffersDisplayRequirement prepareBackingStoreBuffers(RemoteLayerBackingStore&) final;
+    void prepareBackingStoresForDisplay(RemoteLayerTreeTransaction&) final;
 
     bool collectBackingStoreBufferIdentifiersToMarkVolatile(RemoteLayerBackingStore&, OptionSet<VolatilityMarkingBehavior>, MonotonicTime now, Vector<WebCore::RenderingResourceIdentifier>&);

trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerWithRemoteRenderingBackingStoreCollection.mm

@@ -65 +65 @@
 }
 
-SwapBuffersDisplayRequirement RemoteLayerWithRemoteRenderingBackingStoreCollection::prepareBackingStoreBuffers(RemoteLayerBackingStore& backingStore)
-{
+void RemoteLayerWithRemoteRenderingBackingStoreCollection::prepareBackingStoresForDisplay(RemoteLayerTreeTransaction& transaction)
+{
+    Vector<RemoteRenderingBackendProxy::LayerPrepareBuffersData> prepareBuffersData;
+    prepareBuffersData.reserveInitialCapacity(m_backingStoresNeedingDisplay.size());
+
+    Vector<RemoteLayerBackingStore*> backingStoreList;
+    backingStoreList.reserveInitialCapacity(m_backingStoresNeedingDisplay.size());
+
+    for (auto* backingStore : m_backingStoresNeedingDisplay) {
+        backingStore->layer()->properties().notePropertiesChanged(RemoteLayerTreeTransaction::BackingStoreChanged);
+        transaction.layerPropertiesChanged(*backingStore->layer());
+
+        if (backingStore->performDelegatedLayerDisplay())
+            continue;
+
+        prepareBuffersData.uncheckedAppend({
+            {
+                backingStore->bufferForType(RemoteLayerBackingStore::BufferType::Front),
+                backingStore->bufferForType(RemoteLayerBackingStore::BufferType::Back),
+                backingStore->bufferForType(RemoteLayerBackingStore::BufferType::SecondaryBack)
+            },
+            backingStore->supportsPartialRepaint(),
+            backingStore->hasEmptyDirtyRegion(),
+        });
+        
+        backingStoreList.uncheckedAppend(backingStore);
+    }
+
     auto& remoteRenderingBackend = layerTreeContext().ensureRemoteRenderingBackendProxy();
-
-    auto identifiers = RemoteRenderingBackendProxy::BufferSet {
-        backingStore.bufferForType(RemoteLayerBackingStore::BufferType::Front),
-        backingStore.bufferForType(RemoteLayerBackingStore::BufferType::Back),
-        backingStore.bufferForType(RemoteLayerBackingStore::BufferType::SecondaryBack)
-    };
-
-    auto swapResult = remoteRenderingBackend.prepareBuffersForDisplay(WTFMove(identifiers), backingStore.supportsPartialRepaint(), backingStore.hasEmptyDirtyRegion());
-
-    backingStore.applySwappedBuffers(WTFMove(swapResult.buffers.front), WTFMove(swapResult.buffers.back), WTFMove(swapResult.buffers.secondaryBack));
-    return swapResult.displayRequirement;
+    auto swapResult = remoteRenderingBackend.prepareBuffersForDisplay(WTFMove(prepareBuffersData));
+
+    RELEASE_ASSERT(swapResult.size() == backingStoreList.size());
+    for (unsigned i = 0; i < swapResult.size(); ++i) {
+        auto& backingStoreSwapResult = swapResult[i];
+        auto* backingStore = backingStoreList[i];
+        backingStore->applySwappedBuffers(WTFMove(backingStoreSwapResult.buffers.front), WTFMove(backingStoreSwapResult.buffers.back), WTFMove(backingStoreSwapResult.buffers.secondaryBack), backingStoreSwapResult.displayRequirement);
+    }
 }
 

trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj

@@ -2622 +2622 @@
                 0F5E200218E77051003EC3E5 /* PlatformCAAnimationRemote.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlatformCAAnimationRemote.h; sourceTree = "<group>"; };
                 0F65956727DB1D5800EE874B /* SwapBuffersDisplayRequirement.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SwapBuffersDisplayRequirement.h; sourceTree = "<group>"; };
+                0F65956C27E10C2C00EE874B /* PrepareBackingStoreBuffersData.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PrepareBackingStoreBuffersData.h; sourceTree = "<group>"; };
                 0F707C771A1FEE8300DA7A45 /* RemoteLayerTreeScrollingPerformanceData.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = RemoteLayerTreeScrollingPerformanceData.mm; sourceTree = "<group>"; };
                 0F707C791A1FEEA300DA7A45 /* RemoteLayerTreeScrollingPerformanceData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RemoteLayerTreeScrollingPerformanceData.h; sourceTree = "<group>"; };
@@ -9901 +9902 @@
                                 727A7F38240788F0004D2931 /* PlatformImageBufferShareableBackend.h */,
                                 7227800B2408BD7D007D376B /* PlatformRemoteImageBufferProxy.h */,
+                                0F65956C27E10C2C00EE874B /* PrepareBackingStoreBuffersData.h */,
                                 F48BB8DE26F9635D001C1C40 /* RemoteDisplayListRecorderProxy.cpp */,
                                 F48BB8DD26F9635D001C1C40 /* RemoteDisplayListRecorderProxy.h */,

trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp

@@ -268 +268 @@
 }
 
-auto RemoteRenderingBackendProxy::prepareBuffersForDisplay(const BufferSet& buffers, bool supportsPartialRepaint, bool hasEmptyDirtyRegion) -> SwapBuffersResult
+auto RemoteRenderingBackendProxy::prepareBuffersForDisplay(const Vector<LayerPrepareBuffersData>& prepareBuffersInput) -> Vector<SwapBuffersResult>
 {
     auto bufferIdentifier = [](ImageBuffer* buffer) -> std::optional<RenderingResourceIdentifier> {
@@ -287 +287 @@
     };
 
-    // Clear all the buffer's MachSendRights to avoid all the surfaces appearing to be in-use.
-    // We get back the new front buffer's MachSendRight in the reply.
-    clearBackendHandle(buffers.front.get());
-    clearBackendHandle(buffers.back.get());
-    clearBackendHandle(buffers.secondaryBack.get());
-
-    auto bufferSet = BufferIdentifierSet {
-        bufferIdentifier(buffers.front.get()),
-        bufferIdentifier(buffers.back.get()),
-        bufferIdentifier(buffers.secondaryBack.get())
-    };
-
-    BufferIdentifierSet swappedBufferSet;
-    std::optional<ImageBufferBackendHandle> frontBufferHandle;
-    auto displayRequirement = SwapBuffersDisplayRequirement::NeedsNoDisplay;
-
-    sendSyncToStream(Messages::RemoteRenderingBackend::PrepareBuffersForDisplay(bufferSet, supportsPartialRepaint, hasEmptyDirtyRegion),
-        Messages::RemoteRenderingBackend::PrepareBuffersForDisplay::Reply(swappedBufferSet, frontBufferHandle, displayRequirement));
-
-    LOG_WITH_STREAM(RemoteRenderingBufferVolatility, stream << "RemoteRenderingBackendProxy::prepareBuffersForDisplay swapped to " << swappedBufferSet.front << " " << swappedBufferSet.back << " " << swappedBufferSet.secondaryBack);
+    Vector<PrepareBackingStoreBuffersInputData> inputData;
+    inputData.reserveInitialCapacity(prepareBuffersInput.size());
+
+    for (const auto& perLayerData : prepareBuffersInput) {
+        // Clear all the buffer's MachSendRights to avoid all the surfaces appearing to be in-use.
+        // We get back the new front buffer's MachSendRight in the reply.
+        clearBackendHandle(perLayerData.buffers.front.get());
+        clearBackendHandle(perLayerData.buffers.back.get());
+        clearBackendHandle(perLayerData.buffers.secondaryBack.get());
+
+        inputData.uncheckedAppend({
+            {
+                bufferIdentifier(perLayerData.buffers.front.get()),
+                bufferIdentifier(perLayerData.buffers.back.get()),
+                bufferIdentifier(perLayerData.buffers.secondaryBack.get())
+            },
+            perLayerData.supportsPartialRepaint,
+            perLayerData.hasEmptyDirtyRegion
+        });
+    }
+
+    Vector<PrepareBackingStoreBuffersOutputData> outputData;
+    sendSyncToStream(Messages::RemoteRenderingBackend::PrepareBuffersForDisplay(inputData), Messages::RemoteRenderingBackend::PrepareBuffersForDisplay::Reply(outputData));
+    RELEASE_ASSERT(inputData.size() == outputData.size());
 
     auto fetchBufferWithIdentifier = [&](std::optional<RenderingResourceIdentifier> identifier, std::optional<ImageBufferBackendHandle>&& handle = std::nullopt, bool isFrontBuffer = false) -> RefPtr<ImageBuffer> {
@@ -332 +336 @@
     };
 
-    return {
-        {
-            fetchBufferWithIdentifier(swappedBufferSet.front, WTFMove(frontBufferHandle), true),
-            fetchBufferWithIdentifier(swappedBufferSet.back),
-            fetchBufferWithIdentifier(swappedBufferSet.secondaryBack)
-        },
-        displayRequirement
-    };
+    Vector<SwapBuffersResult> result;
+    result.reserveInitialCapacity(outputData.size());
+
+    for (auto& perLayerOutputData : outputData) {
+        result.uncheckedAppend({
+            {
+                fetchBufferWithIdentifier(perLayerOutputData.bufferSet.front, WTFMove(perLayerOutputData.frontBufferHandle), true),
+                fetchBufferWithIdentifier(perLayerOutputData.bufferSet.back),
+                fetchBufferWithIdentifier(perLayerOutputData.bufferSet.secondaryBack)
+            },
+            perLayerOutputData.displayRequirement
+        });
+    }
+
+    return result;
 }
 

trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h

@@ -102 +102 @@
     };
     
+    struct LayerPrepareBuffersData {
+        BufferSet buffers;
+        bool supportsPartialRepaint { true };
+        bool hasEmptyDirtyRegion { false };
+    };
+    
     struct SwapBuffersResult {
         BufferSet buffers;
         SwapBuffersDisplayRequirement displayRequirement;
     };
-    SwapBuffersResult prepareBuffersForDisplay(const BufferSet&, bool supportsPartialRepaint, bool hasEmptyDirtyRegion);
+
+    Vector<SwapBuffersResult> prepareBuffersForDisplay(const Vector<LayerPrepareBuffersData>&);
 
     void finalizeRenderingUpdate();