Changeset 286975 in webkit

Timestamp:

Dec 13, 2021, 12:56:57 PM (5 years ago)

Author:

Alan Coon

Message:

Cherry-pick r286932. rdar://problem/86385697

Ensure that the scrolling thread always commits layer position changes to reduce scrolling stutters
​https://bugs.webkit.org/show_bug.cgi?id=234213

Reviewed by Tim Horton.

On a page where CA commits on the main thread take a long time (e.g. because of expensive
painting), it's possible that the main thread has updated the scrolling layer position, and
then the scrolling thread detects that the commit is taking a long time and attempts to
trigger its own commit, but because the layer position property doesn't change, no commit
occurs.

Work around this by setting the layer position to 0,0 and back when we're on the scrolling
thread. Only do this if the scroll position changed since the last display refresh to avoid
triggering redundant commits.

Ideally we'd traverse the scrolling tree and do this for every scrolling node, but scrolling
trees can get large so for now just apply this to the root node.

• page/scrolling/ScrollingTreeScrollingNode.cpp: (WebCore::ScrollingTreeScrollingNode::updateScrollPositionAtLastDisplayRefresh):
• page/scrolling/ScrollingTreeScrollingNode.h:
• page/scrolling/ThreadedScrollingTree.cpp: (WebCore::ThreadedScrollingTree::displayDidRefreshOnScrollingThread): (WebCore::ThreadedScrollingTree::storeScrollPositionsAtLastDisplayRefresh):
• page/scrolling/ThreadedScrollingTree.h:
• page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm: (WebCore::ScrollingTreeFrameScrollingNodeMac::repositionScrollingLayers):

git-svn-id: ​https://svn.webkit.org/repository/webkit/trunk@286932 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Location:

branches/safari-612-branch/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• page/scrolling/ScrollingTreeScrollingNode.cpp (modified) (1 diff)
• page/scrolling/ScrollingTreeScrollingNode.h (modified) (2 diffs)
• page/scrolling/ThreadedScrollingTree.cpp (modified) (2 diffs)
• page/scrolling/ThreadedScrollingTree.h (modified) (1 diff)
• page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm (modified) (2 diffs)

branches/safari-612-branch/Source/WebCore/ChangeLog

@@ +1 @@
+2021-12-13  Alan Coon  <alancoon@apple.com>
+
+        Cherry-pick r286932. rdar://problem/86385697
+
+    Ensure that the scrolling thread always commits layer position changes to reduce scrolling stutters
+    https://bugs.webkit.org/show_bug.cgi?id=234213
+    
+    Reviewed by Tim Horton.
+    
+    On a page where CA commits on the main thread take a long time (e.g. because of expensive
+    painting), it's possible that the main thread has updated the scrolling layer position, and
+    then the scrolling thread detects that the commit is taking a long time and attempts to
+    trigger its own commit, but because the layer position property doesn't change, no commit
+    occurs.
+    
+    Work around this by setting the layer position to 0,0 and back when we're on the scrolling
+    thread. Only do this if the scroll position changed since the last display refresh to avoid
+    triggering redundant commits.
+    
+    Ideally we'd traverse the scrolling tree and do this for every scrolling node, but scrolling
+    trees can get large so for now just apply this to the root node.
+    
+    * page/scrolling/ScrollingTreeScrollingNode.cpp:
+    (WebCore::ScrollingTreeScrollingNode::updateScrollPositionAtLastDisplayRefresh):
+    * page/scrolling/ScrollingTreeScrollingNode.h:
+    * page/scrolling/ThreadedScrollingTree.cpp:
+    (WebCore::ThreadedScrollingTree::displayDidRefreshOnScrollingThread):
+    (WebCore::ThreadedScrollingTree::storeScrollPositionsAtLastDisplayRefresh):
+    * page/scrolling/ThreadedScrollingTree.h:
+    * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm:
+    (WebCore::ScrollingTreeFrameScrollingNodeMac::repositionScrollingLayers):
+    
+    git-svn-id: https://svn.webkit.org/repository/webkit/trunk@286932 268f45cc-cd09-0410-ab3c-d52691b4dbfc
+
+    2021-12-12  Simon Fraser  <simon.fraser@apple.com>
+
+            Ensure that the scrolling thread always commits layer position changes to reduce scrolling stutters
+            https://bugs.webkit.org/show_bug.cgi?id=234213
+
+            Reviewed by Tim Horton.
+
+            On a page where CA commits on the main thread take a long time (e.g. because of expensive
+            painting), it's possible that the main thread has updated the scrolling layer position, and
+            then the scrolling thread detects that the commit is taking a long time and attempts to
+            trigger its own commit, but because the layer position property doesn't change, no commit
+            occurs.
+
+            Work around this by setting the layer position to 0,0 and back when we're on the scrolling
+            thread. Only do this if the scroll position changed since the last display refresh to avoid
+            triggering redundant commits.
+
+            Ideally we'd traverse the scrolling tree and do this for every scrolling node, but scrolling
+            trees can get large so for now just apply this to the root node.
+
+            * page/scrolling/ScrollingTreeScrollingNode.cpp:
+            (WebCore::ScrollingTreeScrollingNode::updateScrollPositionAtLastDisplayRefresh):
+            * page/scrolling/ScrollingTreeScrollingNode.h:
+            * page/scrolling/ThreadedScrollingTree.cpp:
+            (WebCore::ThreadedScrollingTree::displayDidRefreshOnScrollingThread):
+            (WebCore::ThreadedScrollingTree::storeScrollPositionsAtLastDisplayRefresh):
+            * page/scrolling/ThreadedScrollingTree.h:
+            * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm:
+            (WebCore::ScrollingTreeFrameScrollingNodeMac::repositionScrollingLayers):
+
 2021-12-13  Alan Coon  <alancoon@apple.com>
 

branches/safari-612-branch/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.cpp

@@ -274 +274 @@
 }
 
+void ScrollingTreeScrollingNode::updateScrollPositionAtLastDisplayRefresh()
+{
+    m_scrollPositionAtLastDisplayRefresh = m_currentScrollPosition;
+}
+
 bool ScrollingTreeScrollingNode::scrollPositionAndLayoutViewportMatch(const FloatPoint& position, std::optional<FloatRect>)
 {

branches/safari-612-branch/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.h

@@ -129 +129 @@
     virtual void repositionScrollingLayers() { }
     virtual void repositionRelatedLayers() { }
+    
+    void updateScrollPositionAtLastDisplayRefresh();
+    std::optional<FloatPoint> scrollPositionAtLastDisplayRefresh() { return m_scrollPositionAtLastDisplayRefresh; };
 
     void applyLayerPositions() override;
@@ -162 +165 @@
     std::optional<unsigned> m_currentVerticalSnapPointIndex;
     ScrollableAreaParameters m_scrollableAreaParameters;
+    std::optional<FloatPoint> m_scrollPositionAtLastDisplayRefresh;
 #if ENABLE(SCROLLING_THREAD)
     OptionSet<SynchronousScrollingReason> m_synchronousScrollingReasons;

branches/safari-612-branch/Source/WebCore/page/scrolling/ThreadedScrollingTree.cpp

@@ -407 +407 @@
         break;
     }
+    
+    storeScrollPositionsAtLastDisplayRefresh();
 }
 
@@ -429 +431 @@
 }
 
+void ThreadedScrollingTree::storeScrollPositionsAtLastDisplayRefresh()
+{
+    // Ideally this would be a tree walk for every scrolling node, but scrolling trees can get big so for now just do this for the root;
+    // ScrollingTreeFrameScrollingNodeMac::repositionScrollingLayers() uses the state to know whether it should force a commit.
+    if (auto* rootNode = this->rootNode())
+        rootNode->updateScrollPositionAtLastDisplayRefresh();
+}
+
 } // namespace WebCore
 

branches/safari-612-branch/Source/WebCore/page/scrolling/ThreadedScrollingTree.h

@@ -95 +95 @@
     void delayedRenderingUpdateDetectionTimerFired();
 
+    void storeScrollPositionsAtLastDisplayRefresh() WTF_REQUIRES_LOCK(m_treeLock);
+    
     Seconds frameDuration();
     Seconds maxAllowableRenderingUpdateDurationForSynchronization();

branches/safari-612-branch/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm

@@ -36 +36 @@
 #import "ScrollingCoordinator.h"
 #import "ScrollingStateTree.h"
+#import "ScrollingThread.h"
 #import "ScrollingTree.h"
 #import "TileController.h"
@@ -167 +168 @@
 {
     BEGIN_BLOCK_OBJC_EXCEPTIONS
+
+    auto* layer = static_cast<CALayer*>(scrolledContentsLayer());
+    if (ScrollingThread::isCurrentThread()) {
+        // If we're committing on the scrolling thread, it means that ThreadedScrollingTree is in "desynchronized" mode.
+        // The main thread may already have set the same layer position, but here we need to trigger a scrolling thread commit to
+        // ensure that the scroll happens even when the main thread commit is taking a long time. So make sure the layer property changes
+        // when there has been a scroll position change.
+        if (scrollPositionAtLastDisplayRefresh() && scrollPositionAtLastDisplayRefresh().value() != currentScrollPosition())
+            layer.position = CGPointZero;
+    }
+
     // We use scroll position here because the root content layer is offset to account for scrollOrigin (see FrameView::positionForRootContentLayer).
-    static_cast<CALayer*>(scrolledContentsLayer()).position = -currentScrollPosition();
+    layer.position = -currentScrollPosition();
     END_BLOCK_OBJC_EXCEPTIONS
 }