Title: [289146] trunk/Source/WebKit
Revision
289146
Author
simon.fra...@apple.com
Date
2022-02-04 18:54:56 -0800 (Fri, 04 Feb 2022)

Log Message

Lay the groundwork for markLayersVolatileImmediatelyIfPossible() being an asynchronous operation
https://bugs.webkit.org/show_bug.cgi?id=236034

Reviewed by Tim Horton.

With DOM rendering in the GPU Process, markLayersVolatileImmediatelyIfPossible() will need
to do IPC to mark surfaces volatile, and we want that to be async IPC. So change the plumbing from
WebPage to RemoteLayerBackingStoreCollection to be callback-based, with a completion handler.

* Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.h:
* Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.mm:
(WebKit::RemoteLayerBackingStoreCollection::tryMarkAllBackingStoreVolatile):
(WebKit::RemoteLayerBackingStoreCollection::markAllBackingStoreVolatileImmediatelyIfPossible): Deleted.
* WebProcess/WebPage/DrawingArea.cpp:
(WebKit::DrawingArea::tryMarkLayersVolatile):
* WebProcess/WebPage/DrawingArea.h:
(WebKit::DrawingArea::markLayersVolatileImmediatelyIfPossible): Deleted.
* WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h:
* WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm:
(WebKit::RemoteLayerTreeDrawingArea::tryMarkLayersVolatile):
(WebKit::RemoteLayerTreeDrawingArea::markLayersVolatileImmediatelyIfPossible): Deleted.
* WebProcess/WebPage/WebPage.cpp:
(WebKit::WebPage::tryMarkLayersVolatile):
(WebKit::WebPage::layerVolatilityTimerFired):
(WebKit::WebPage::markLayersVolatile):
(WebKit::WebPage::markLayersVolatileOrRetry):
(WebKit::WebPage::tryMarkLayersVolatileCompletionHandler):
(WebKit::WebPage::markLayersVolatileImmediatelyIfPossible): Deleted.
* WebProcess/WebPage/WebPage.h:

Modified Paths

Diff

Modified: trunk/Source/WebKit/ChangeLog (289145 => 289146)


--- trunk/Source/WebKit/ChangeLog	2022-02-05 01:55:11 UTC (rev 289145)
+++ trunk/Source/WebKit/ChangeLog	2022-02-05 02:54:56 UTC (rev 289146)
@@ -1,3 +1,35 @@
+2022-02-02  Simon Fraser  <simon.fra...@apple.com>
+
+        Lay the groundwork for markLayersVolatileImmediatelyIfPossible() being an asynchronous operation
+        https://bugs.webkit.org/show_bug.cgi?id=236034
+
+        Reviewed by Tim Horton.
+
+        With DOM rendering in the GPU Process, markLayersVolatileImmediatelyIfPossible() will need
+        to do IPC to mark surfaces volatile, and we want that to be async IPC. So change the plumbing from
+        WebPage to RemoteLayerBackingStoreCollection to be callback-based, with a completion handler.
+
+        * Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.h:
+        * Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.mm:
+        (WebKit::RemoteLayerBackingStoreCollection::tryMarkAllBackingStoreVolatile):
+        (WebKit::RemoteLayerBackingStoreCollection::markAllBackingStoreVolatileImmediatelyIfPossible): Deleted.
+        * WebProcess/WebPage/DrawingArea.cpp:
+        (WebKit::DrawingArea::tryMarkLayersVolatile):
+        * WebProcess/WebPage/DrawingArea.h:
+        (WebKit::DrawingArea::markLayersVolatileImmediatelyIfPossible): Deleted.
+        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h:
+        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm:
+        (WebKit::RemoteLayerTreeDrawingArea::tryMarkLayersVolatile):
+        (WebKit::RemoteLayerTreeDrawingArea::markLayersVolatileImmediatelyIfPossible): Deleted.
+        * WebProcess/WebPage/WebPage.cpp:
+        (WebKit::WebPage::tryMarkLayersVolatile):
+        (WebKit::WebPage::layerVolatilityTimerFired):
+        (WebKit::WebPage::markLayersVolatile):
+        (WebKit::WebPage::markLayersVolatileOrRetry):
+        (WebKit::WebPage::tryMarkLayersVolatileCompletionHandler):
+        (WebKit::WebPage::markLayersVolatileImmediatelyIfPossible): Deleted.
+        * WebProcess/WebPage/WebPage.h:
+
 2022-02-04  Arcady Goldmints-Orlov  <agoldmi...@igalia.com>
 
         REGRESSION(r280077): [GTK] It caused 155 new test failures

Modified: trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.h (289145 => 289146)


--- trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.h	2022-02-05 01:55:11 UTC (rev 289145)
+++ trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.h	2022-02-05 02:54:56 UTC (rev 289146)
@@ -52,8 +52,7 @@
     void willCommitLayerTree(RemoteLayerTreeTransaction&);
     void didFlushLayers();
 
-    void volatilityTimerFired();
-    bool markAllBackingStoreVolatileImmediatelyIfPossible();
+    void tryMarkAllBackingStoreVolatile(CompletionHandler<void(bool)>&&);
 
     void scheduleVolatilityTimer();
 
@@ -65,6 +64,8 @@
     bool markBackingStoreVolatileImmediately(RemoteLayerBackingStore&, VolatilityMarkingFlags = 0);
     bool markBackingStoreVolatile(RemoteLayerBackingStore&, MonotonicTime now);
 
+    void volatilityTimerFired();
+
     HashSet<RemoteLayerBackingStore*> m_liveBackingStore;
     HashSet<RemoteLayerBackingStore*> m_unparentedBackingStore;
 

Modified: trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.mm (289145 => 289146)


--- trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.mm	2022-02-05 01:55:11 UTC (rev 289145)
+++ trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.mm	2022-02-05 02:54:56 UTC (rev 289146)
@@ -149,7 +149,7 @@
     markBackingStoreVolatileImmediately(backingStore);
 }
 
-bool RemoteLayerBackingStoreCollection::markAllBackingStoreVolatileImmediatelyIfPossible()
+void RemoteLayerBackingStoreCollection::tryMarkAllBackingStoreVolatile(CompletionHandler<void(bool)>&& completionHandler)
 {
     bool successfullyMadeBackingStoreVolatile = true;
 
@@ -159,7 +159,7 @@
     for (const auto& backingStore : m_unparentedBackingStore)
         successfullyMadeBackingStoreVolatile &= markBackingStoreVolatileImmediately(*backingStore, MarkBuffersIgnoringReachability);
 
-    return successfullyMadeBackingStoreVolatile;
+    completionHandler(successfullyMadeBackingStoreVolatile);
 }
 
 void RemoteLayerBackingStoreCollection::volatilityTimerFired()

Modified: trunk/Source/WebKit/WebProcess/WebPage/DrawingArea.cpp (289145 => 289146)


--- trunk/Source/WebKit/WebProcess/WebPage/DrawingArea.cpp	2022-02-05 01:55:11 UTC (rev 289145)
+++ trunk/Source/WebKit/WebProcess/WebPage/DrawingArea.cpp	2022-02-05 02:54:56 UTC (rev 289146)
@@ -89,6 +89,11 @@
     function();
 }
 
+void DrawingArea::tryMarkLayersVolatile(CompletionHandler<void(bool)>&& completionFunction)
+{
+    completionFunction(true);
+}
+
 void DrawingArea::removeMessageReceiverIfNeeded()
 {
     if (m_hasRemovedMessageReceiver)

Modified: trunk/Source/WebKit/WebProcess/WebPage/DrawingArea.h (289145 => 289146)


--- trunk/Source/WebKit/WebProcess/WebPage/DrawingArea.h	2022-02-05 01:55:11 UTC (rev 289145)
+++ trunk/Source/WebKit/WebProcess/WebPage/DrawingArea.h	2022-02-05 02:54:56 UTC (rev 289146)
@@ -123,7 +123,7 @@
     virtual void activityStateDidChange(OptionSet<WebCore::ActivityState::Flag>, ActivityStateChangeID, CompletionHandler<void()>&& completionHandler) { completionHandler(); };
     virtual void setLayerHostingMode(LayerHostingMode) { }
 
-    virtual bool markLayersVolatileImmediatelyIfPossible() { return true; }
+    virtual void tryMarkLayersVolatile(CompletionHandler<void(bool)>&&);
 
     virtual void attachViewOverlayGraphicsLayer(WebCore::GraphicsLayer*) { }
 

Modified: trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h (289145 => 289146)


--- trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h	2022-02-05 01:55:11 UTC (rev 289145)
+++ trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h	2022-02-05 02:54:56 UTC (rev 289146)
@@ -121,9 +121,9 @@
 
     TransactionID takeNextTransactionID() { return m_currentTransactionID.increment(); }
 
-    bool markLayersVolatileImmediatelyIfPossible() override;
+    void tryMarkLayersVolatile(CompletionHandler<void(bool succeeded)>&&) final;
 
-    void adoptLayersFromDrawingArea(DrawingArea&) override;
+    void adoptLayersFromDrawingArea(DrawingArea&) final;
 
     class BackingStoreFlusher : public ThreadSafeRefCounted<BackingStoreFlusher> {
     public:

Modified: trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm (289145 => 289146)


--- trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm	2022-02-05 01:55:11 UTC (rev 289145)
+++ trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm	2022-02-05 02:54:56 UTC (rev 289146)
@@ -443,9 +443,9 @@
     m_rootLayer->setSize(contentsSize);
 }
 
-bool RemoteLayerTreeDrawingArea::markLayersVolatileImmediatelyIfPossible()
+void RemoteLayerTreeDrawingArea::tryMarkLayersVolatile(CompletionHandler<void(bool)>&& completionFunction)
 {
-    return m_remoteLayerTreeContext->backingStoreCollection().markAllBackingStoreVolatileImmediatelyIfPossible();
+    m_remoteLayerTreeContext->backingStoreCollection().tryMarkAllBackingStoreVolatile(WTFMove(completionFunction));
 }
 
 Ref<RemoteLayerTreeDrawingArea::BackingStoreFlusher> RemoteLayerTreeDrawingArea::BackingStoreFlusher::create(IPC::Connection* connection, UniqueRef<IPC::Encoder>&& encoder, Vector<std::unique_ptr<WebCore::ThreadSafeImageBufferFlusher>> flushers)

Modified: trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp (289145 => 289146)


--- trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp	2022-02-05 01:55:11 UTC (rev 289145)
+++ trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp	2022-02-05 02:54:56 UTC (rev 289146)
@@ -2810,9 +2810,14 @@
     m_drawingArea->setLayerTreeStateIsFrozen(!!m_layerTreeFreezeReasons);
 }
 
-bool WebPage::markLayersVolatileImmediatelyIfPossible()
+void WebPage::tryMarkLayersVolatile(CompletionHandler<void(bool)>&& completionHandler)
 {
-    return !drawingArea() || drawingArea()->markLayersVolatileImmediatelyIfPossible();
+    if (!drawingArea()) {
+        completionHandler(false);
+        return;
+    }
+    
+    drawingArea()->tryMarkLayersVolatile(WTFMove(completionHandler));
 }
 
 void WebPage::callVolatilityCompletionHandlers(bool succeeded)
@@ -2824,8 +2829,8 @@
 
 void WebPage::layerVolatilityTimerFired()
 {
-    Seconds newInterval = m_layerVolatilityTimer.repeatInterval() * 2.;
-    markLayersVolatileOrRetry(newInterval > maximumLayerVolatilityTimerInterval ? MarkLayersVolatileDontRetryReason::TimedOut : MarkLayersVolatileDontRetryReason::None, newInterval);
+    m_layerVolatilityTimerInterval *= 2;
+    markLayersVolatileOrRetry(m_layerVolatilityTimerInterval > maximumLayerVolatilityTimerInterval ? MarkLayersVolatileDontRetryReason::TimedOut : MarkLayersVolatileDontRetryReason::None);
 }
 
 void WebPage::markLayersVolatile(CompletionHandler<void(bool)>&& completionHandler)
@@ -2838,12 +2843,22 @@
     if (completionHandler)
         m_markLayersAsVolatileCompletionHandlers.append(WTFMove(completionHandler));
 
-    markLayersVolatileOrRetry(m_isSuspendedUnderLock ? MarkLayersVolatileDontRetryReason::SuspendedUnderLock : MarkLayersVolatileDontRetryReason::None, initialLayerVolatilityTimerInterval);
+    m_layerVolatilityTimerInterval = initialLayerVolatilityTimerInterval;
+    markLayersVolatileOrRetry(m_isSuspendedUnderLock ? MarkLayersVolatileDontRetryReason::SuspendedUnderLock : MarkLayersVolatileDontRetryReason::None);
 }
 
-void WebPage::markLayersVolatileOrRetry(MarkLayersVolatileDontRetryReason dontRetryReason, Seconds timerInterval)
+void WebPage::markLayersVolatileOrRetry(MarkLayersVolatileDontRetryReason dontRetryReason)
 {
-    bool didSucceed = markLayersVolatileImmediatelyIfPossible();
+    tryMarkLayersVolatile([dontRetryReason, strongThis = Ref { *this }](bool didSucceed) {
+        strongThis->tryMarkLayersVolatileCompletionHandler(dontRetryReason, didSucceed);
+    });
+}
+
+void WebPage::tryMarkLayersVolatileCompletionHandler(MarkLayersVolatileDontRetryReason dontRetryReason, bool didSucceed)
+{
+    if (m_isClosed)
+        return;
+
     if (didSucceed || dontRetryReason != MarkLayersVolatileDontRetryReason::None) {
         m_layerVolatilityTimer.stop();
         if (didSucceed)
@@ -2864,8 +2879,8 @@
         return;
     }
 
-    WEBPAGE_RELEASE_LOG(Layers, "markLayersVolatile: Failed to mark all layers as volatile, will retry in %g ms", timerInterval.milliseconds());
-    m_layerVolatilityTimer.startRepeating(timerInterval);
+    WEBPAGE_RELEASE_LOG(Layers, "markLayersVolatile: Failed to mark all layers as volatile, will retry in %g ms", m_layerVolatilityTimerInterval.milliseconds());
+    m_layerVolatilityTimer.startOneShot(m_layerVolatilityTimerInterval);
 }
 
 void WebPage::cancelMarkLayersVolatile()

Modified: trunk/Source/WebKit/WebProcess/WebPage/WebPage.h (289145 => 289146)


--- trunk/Source/WebKit/WebProcess/WebPage/WebPage.h	2022-02-05 01:55:11 UTC (rev 289145)
+++ trunk/Source/WebKit/WebProcess/WebPage/WebPage.h	2022-02-05 02:54:56 UTC (rev 289146)
@@ -1589,12 +1589,14 @@
 
     void updateDrawingAreaLayerTreeFreezeState();
 
-    bool markLayersVolatileImmediatelyIfPossible();
     enum class MarkLayersVolatileDontRetryReason : uint8_t { None, SuspendedUnderLock, TimedOut };
-    void markLayersVolatileOrRetry(MarkLayersVolatileDontRetryReason, Seconds timerInterval);
+    void markLayersVolatileOrRetry(MarkLayersVolatileDontRetryReason);
     void layerVolatilityTimerFired();
     void callVolatilityCompletionHandlers(bool succeeded);
 
+    void tryMarkLayersVolatile(CompletionHandler<void(bool)>&&);
+    void tryMarkLayersVolatileCompletionHandler(MarkLayersVolatileDontRetryReason, bool didSucceed);
+
     String sourceForFrame(WebFrame*);
 
     void loadDataImpl(uint64_t navigationID, WebCore::ShouldTreatAsContinuingLoad, std::optional<WebsitePoliciesData>&&, Ref<WebCore::FragmentedSharedBuffer>&&, WebCore::ResourceRequest&&, WebCore::ResourceResponse&&, const URL& failingURL, const UserData&, std::optional<NavigatingToAppBoundDomain>, WebCore::SubstituteData::SessionHistoryVisibility, WebCore::ShouldOpenExternalURLsPolicy = WebCore::ShouldOpenExternalURLsPolicy::ShouldNotAllow);
@@ -2289,6 +2291,7 @@
 #endif
 
     WebCore::Timer m_layerVolatilityTimer;
+    Seconds m_layerVolatilityTimerInterval;
     Vector<CompletionHandler<void(bool)>> m_markLayersAsVolatileCompletionHandlers;
     bool m_isSuspendedUnderLock { false };
 
_______________________________________________
webkit-changes mailing list
webkit-changes@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to