Changeset 107335 in webkit

Timestamp:

Feb 9, 2012, 6:10:13 PM (15 years ago)

Author:

andersca@apple.com

Message:

Update the scroll layer position on the main thread when we have slow repaint objects
​https://bugs.webkit.org/show_bug.cgi?id=78300
<rdar://problem/10710754>

Reviewed by Dan Bernstein.

When we have slow repaint objects (background-attachment: fixed), we need to update the
scroll layer position on the main thread, otherwise the web page will appear to jiggle.

• page/FrameView.cpp:

(WebCore::FrameView::addSlowRepaintObject):
(WebCore::FrameView::removeSlowRepaintObject):
Call ScrollingCoordinator::frameViewHasSlowRepaintObjectsDidChange if needed.

• page/FrameView.h:

(WebCore::FrameView::hasSlowRepaintObjects):
Add new getter.

• page/scrolling/ScrollingCoordinator.cpp:

(WebCore::ScrollingCoordinator::frameViewHasSlowRepaintObjectsDidChange):
Call ScrollingTreeNode::shouldUpdateScrollLayerPositionOnMainThread.

(WebCore::ScrollingCoordinator::updateMainFrameScrollPositionAndScrollLayerPosition):
New function that will update both the main frame scroll position and the scroll layer position.

• page/scrolling/ScrollingTree.cpp:

(WebCore::ScrollingTree::updateMainFrameScrollPositionAndScrollLayerPosition):
Dispatch a call to ScrollingCoordinator::updateMainFrameScrollPositionAndScrollLayerPosition on the main thread.

• page/scrolling/ScrollingTreeNode.cpp:

(WebCore::ScrollingTreeNode::ScrollingTreeNode):
Initialize m_shouldUpdateScrollLayerPositionOnMainThread.

(WebCore::ScrollingTreeNode::update):
Set m_shouldUpdateScrollLayerPositionOnMainThread.

• page/scrolling/ScrollingTreeState.cpp:

(WebCore::ScrollingTreeState::ScrollingTreeState):
Initialize m_shouldUpdateScrollLayerPositionOnMainThread.

(WebCore::ScrollingTreeState::setShouldUpdateScrollLayerPositionOnMainThread):
Update m_shouldUpdateScrollLayerPositionOnMainThread if needed.

• page/scrolling/mac/ScrollingTreeNodeMac.mm:

(WebCore::ScrollingTreeNodeMac::setScrollPosition):
Assert that we're not supposed to update the scroll layer position on the main thread.

(WebCore::ScrollingTreeNodeMac::scrollBy):
If we're supposed to update the scroll layer position on the main thread,
call ScrollingTree::updateMainFrameScrollPositionAndScrollLayerPosition.

• rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::frameViewDidScroll):
If the frame view has its scrolling coordinated by a scrolling coordinator, don't update the scroll layer position.

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• page/FrameView.cpp (modified) (2 diffs)
• page/FrameView.h (modified) (1 diff)
• page/scrolling/ScrollingCoordinator.cpp (modified) (3 diffs)
• page/scrolling/ScrollingCoordinator.h (modified) (2 diffs)
• page/scrolling/ScrollingTree.cpp (modified) (1 diff)
• page/scrolling/ScrollingTree.h (modified) (1 diff)
• page/scrolling/ScrollingTreeNode.cpp (modified) (2 diffs)
• page/scrolling/ScrollingTreeNode.h (modified) (2 diffs)
• page/scrolling/ScrollingTreeState.cpp (modified) (2 diffs)
• page/scrolling/ScrollingTreeState.h (modified) (3 diffs)
• page/scrolling/mac/ScrollingTreeNodeMac.mm (modified) (1 diff)
• rendering/RenderLayerCompositor.cpp (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-02-09  Anders Carlsson  <andersca@apple.com>
+
+        Update the scroll layer position on the main thread when we have slow repaint objects
+        https://bugs.webkit.org/show_bug.cgi?id=78300
+        <rdar://problem/10710754>
+
+        Reviewed by Dan Bernstein.
+
+        When we have slow repaint objects (background-attachment: fixed), we need to update the
+        scroll layer position on the main thread, otherwise the web page will appear to jiggle.
+    
+        * page/FrameView.cpp:
+        (WebCore::FrameView::addSlowRepaintObject):
+        (WebCore::FrameView::removeSlowRepaintObject):
+        Call ScrollingCoordinator::frameViewHasSlowRepaintObjectsDidChange if needed.
+
+        * page/FrameView.h:
+        (WebCore::FrameView::hasSlowRepaintObjects):
+        Add new getter.
+
+        * page/scrolling/ScrollingCoordinator.cpp:
+        (WebCore::ScrollingCoordinator::frameViewHasSlowRepaintObjectsDidChange):
+        Call ScrollingTreeNode::shouldUpdateScrollLayerPositionOnMainThread.
+
+        (WebCore::ScrollingCoordinator::updateMainFrameScrollPositionAndScrollLayerPosition):
+        New function that will update both the main frame scroll position and the scroll layer position.
+
+        * page/scrolling/ScrollingTree.cpp:
+        (WebCore::ScrollingTree::updateMainFrameScrollPositionAndScrollLayerPosition):
+        Dispatch a call to ScrollingCoordinator::updateMainFrameScrollPositionAndScrollLayerPosition on the main thread.
+
+        * page/scrolling/ScrollingTreeNode.cpp:
+        (WebCore::ScrollingTreeNode::ScrollingTreeNode):
+        Initialize m_shouldUpdateScrollLayerPositionOnMainThread.
+
+        (WebCore::ScrollingTreeNode::update):
+        Set m_shouldUpdateScrollLayerPositionOnMainThread.
+
+        * page/scrolling/ScrollingTreeState.cpp:
+        (WebCore::ScrollingTreeState::ScrollingTreeState):
+        Initialize m_shouldUpdateScrollLayerPositionOnMainThread.
+
+        (WebCore::ScrollingTreeState::setShouldUpdateScrollLayerPositionOnMainThread):
+        Update m_shouldUpdateScrollLayerPositionOnMainThread if needed.
+
+        * page/scrolling/mac/ScrollingTreeNodeMac.mm:
+        (WebCore::ScrollingTreeNodeMac::setScrollPosition):
+        Assert that we're not supposed to update the scroll layer position on the main thread.
+
+        (WebCore::ScrollingTreeNodeMac::scrollBy):
+        If we're supposed to update the scroll layer position on the main thread, 
+        call ScrollingTree::updateMainFrameScrollPositionAndScrollLayerPosition.
+
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::frameViewDidScroll):
+        If the frame view has its scrolling coordinated by a scrolling coordinator, don't update the scroll layer position.
+
 2012-02-09  Anders Carlsson  <andersca@apple.com>
 

trunk/Source/WebCore/page/FrameView.cpp

@@ -1329 +1329 @@
 void FrameView::addSlowRepaintObject()
 {
-    if (!m_slowRepaintObjectCount++)
+    if (!m_slowRepaintObjectCount++) {
         updateCanBlitOnScrollRecursively();
+
+#if ENABLE(THREADED_SCROLLING)
+        if (Page* page = m_frame->page()) {
+            if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator())
+                scrollingCoordinator->frameViewHasSlowRepaintObjectsDidChange(this);
+        }
+#endif
+    }
 }
 
@@ -1337 +1345 @@
     ASSERT(m_slowRepaintObjectCount > 0);
     m_slowRepaintObjectCount--;
-    if (!m_slowRepaintObjectCount)
+    if (!m_slowRepaintObjectCount) {
         updateCanBlitOnScrollRecursively();
+
+#if ENABLE(THREADED_SCROLLING)
+        if (Page* page = m_frame->page()) {
+            if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator())
+                scrollingCoordinator->frameViewHasSlowRepaintObjectsDidChange(this);
+        }
+#endif
+    }
 }
 

trunk/Source/WebCore/page/FrameView.h

@@ -185 +185 @@
     void addSlowRepaintObject();
     void removeSlowRepaintObject();
+    bool hasSlowRepaintObjects() const { return m_slowRepaintObjectCount; }
 
     void addFixedObject();

trunk/Source/WebCore/page/scrolling/ScrollingCoordinator.cpp

@@ -36 +36 @@
 #include "PlatformWheelEvent.h"
 #include "Region.h"
+#include "RenderLayerCompositor.h"
+#include "RenderView.h"
 #include "ScrollAnimator.h"
 #include "ScrollingThread.h"
@@ -135 +137 @@
 }
 
+void ScrollingCoordinator::frameViewHasSlowRepaintObjectsDidChange(FrameView* frameView)
+{
+    ASSERT(isMainThread());
+    ASSERT(m_page);
+
+    if (!coordinatesScrollingForFrameView(frameView))
+        return;
+
+    m_scrollingTreeState->setShouldUpdateScrollLayerPositionOnMainThread(frameView->hasSlowRepaintObjects());
+    scheduleTreeStateCommit();
+}
+
 void ScrollingCoordinator::updateMainFrameScrollPosition(const IntPoint& scrollPosition)
 {
@@ -149 +163 @@
     frameView->scrollToOffsetWithoutAnimation(scrollPosition);
     frameView->setConstrainsScrollingToContentEdge(true);
+}
+
+void ScrollingCoordinator::updateMainFrameScrollPositionAndScrollLayerPosition(const IntPoint& scrollPosition)
+{
+    FrameView* frameView = m_page->mainFrame()->view();
+
+    RenderView* renderView = m_page->mainFrame()->contentRenderer();
+    if (!renderView)
+        return;
+
+    GraphicsLayer* scrollLayer = renderView->compositor()->scrollLayer();
+    if (!scrollLayer)
+        return;
+
+    frameView->setConstrainsScrollingToContentEdge(false);
+    frameView->scrollToOffsetWithoutAnimation(scrollPosition);
+    frameView->setConstrainsScrollingToContentEdge(true);
+
+    scrollLayer->setPosition(-frameView->scrollPosition());
 }
 

trunk/Source/WebCore/page/scrolling/ScrollingCoordinator.h

@@ -72 +72 @@
     void frameViewWheelEventHandlerCountChanged(FrameView*);
 
+    // Should be called whenever the slow repaint objects counter changes between zero and one.
+    void frameViewHasSlowRepaintObjectsDidChange(FrameView*);
+
     // Should be called whenever the scroll layer for the given frame view changes.
     void frameViewScrollLayerDidChange(FrameView*, const GraphicsLayer*);
@@ -83 +86 @@
     // Dispatched by the scrolling tree whenever the main frame scroll position changes.
     void updateMainFrameScrollPosition(const IntPoint&);
+
+    // Dispatched by the scrolling tree whenever the main frame scroll position changes and the scroll layer position needs to be updated as well.
+    void updateMainFrameScrollPositionAndScrollLayerPosition(const IntPoint&);
 
 private:

trunk/Source/WebCore/page/scrolling/ScrollingTree.cpp

@@ -121 +121 @@
 }
 
+void ScrollingTree::updateMainFrameScrollPositionAndScrollLayerPosition(const IntPoint& scrollPosition)
+{
+    if (!m_scrollingCoordinator)
+        return;
+
+    {
+        MutexLocker lock(m_mutex);
+        m_mainFrameScrollPosition = scrollPosition;
+    }
+
+    callOnMainThread(bind(&ScrollingCoordinator::updateMainFrameScrollPositionAndScrollLayerPosition, m_scrollingCoordinator.get(), scrollPosition));
+}
+
 } // namespace WebCore
 

trunk/Source/WebCore/page/scrolling/ScrollingTree.h

@@ -65 +65 @@
 
     void updateMainFrameScrollPosition(const IntPoint& scrollPosition);
+    void updateMainFrameScrollPositionAndScrollLayerPosition(const IntPoint& scrollPosition);
 
 private:

trunk/Source/WebCore/page/scrolling/ScrollingTreeNode.cpp

@@ -35 +35 @@
 ScrollingTreeNode::ScrollingTreeNode(ScrollingTree* scrollingTree)
     : m_scrollingTree(scrollingTree)
+    , m_shouldUpdateScrollLayerPositionOnMainThread(false)
     , m_horizontalScrollElasticity(ScrollElasticityNone)
     , m_verticalScrollElasticity(ScrollElasticityNone)
@@ -54 +55 @@
         m_contentsSize = state->contentsSize();
 
+    if (state->changedProperties() & ScrollingTreeState::ShouldUpdateScrollLayerPositionOnMainThread)
+        m_shouldUpdateScrollLayerPositionOnMainThread = state->shouldUpdateScrollLayerPositionOnMainThread();
+
     if (state->changedProperties() & ScrollingTreeState::HorizontalScrollElasticity)
         m_horizontalScrollElasticity = state->horizontalScrollElasticity();

trunk/Source/WebCore/page/scrolling/ScrollingTreeNode.h

@@ -53 +53 @@
     const IntRect& viewportRect() const { return m_viewportRect; }
     const IntSize& contentsSize() const { return m_contentsSize; }
+    bool shouldUpdateScrollLayerPositionOnMainThread() const { return m_shouldUpdateScrollLayerPositionOnMainThread; }
 
 private:
@@ -59 +60 @@
     IntRect m_viewportRect;
     IntSize m_contentsSize;
+
+    bool m_shouldUpdateScrollLayerPositionOnMainThread;
 
     ScrollElasticity m_horizontalScrollElasticity;

trunk/Source/WebCore/page/scrolling/ScrollingTreeState.cpp

@@ -39 +39 @@
     : m_changedProperties(0)
     , m_wheelEventHandlerCount(0)
+    , m_shouldUpdateScrollLayerPositionOnMainThread(false)
     , m_horizontalScrollElasticity(ScrollElasticityNone)
     , m_verticalScrollElasticity(ScrollElasticityNone)
@@ -84 +85 @@
     m_wheelEventHandlerCount = wheelEventHandlerCount;
     m_changedProperties |= WheelEventHandlerCount;
+}
+
+void ScrollingTreeState::setShouldUpdateScrollLayerPositionOnMainThread(bool shouldUpdateScrollLayerPositionOnMainThread)
+{
+    if (m_shouldUpdateScrollLayerPositionOnMainThread == shouldUpdateScrollLayerPositionOnMainThread)
+        return;
+
+    m_shouldUpdateScrollLayerPositionOnMainThread = shouldUpdateScrollLayerPositionOnMainThread;
+    m_changedProperties |= ShouldUpdateScrollLayerPositionOnMainThread;
 }
 

trunk/Source/WebCore/page/scrolling/ScrollingTreeState.h

@@ -55 +55 @@
         NonFastScrollableRegion = 1 << 2,
         WheelEventHandlerCount = 1 << 3,
-        HorizontalScrollElasticity = 1 << 4,
-        VerticalScrollElasticity = 1 << 5,
-        HasEnabledHorizontalScrollbar = 1 << 6,
-        HasEnabledVerticalScrollbar = 1 << 7,
-        ScrollLayer = 1 << 8,
+        ShouldUpdateScrollLayerPositionOnMainThread = 1 << 4,
+        HorizontalScrollElasticity = 1 << 5,
+        VerticalScrollElasticity = 1 << 6,
+        HasEnabledHorizontalScrollbar = 1 << 7,
+        HasEnabledVerticalScrollbar = 1 << 8,
+        ScrollLayer = 1 << 9,
     };
 
@@ -76 +77 @@
     unsigned wheelEventHandlerCount() const { return m_wheelEventHandlerCount; }
     void setWheelEventHandlerCount(unsigned);
+
+    bool shouldUpdateScrollLayerPositionOnMainThread() const { return m_shouldUpdateScrollLayerPositionOnMainThread; }
+    void setShouldUpdateScrollLayerPositionOnMainThread(bool);
 
     ScrollElasticity horizontalScrollElasticity() const { return m_horizontalScrollElasticity; }
@@ -107 +111 @@
     unsigned m_wheelEventHandlerCount;
 
+    bool m_shouldUpdateScrollLayerPositionOnMainThread;
+
     ScrollElasticity m_horizontalScrollElasticity;
     ScrollElasticity m_verticalScrollElasticity;

trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeNodeMac.mm

@@ -135 +135 @@
 void ScrollingTreeNodeMac::setScrollPosition(const IntPoint& position)
 {
+    ASSERT(!shouldUpdateScrollLayerPositionOnMainThread());
+
     m_scrollLayer.get().position = CGPointMake(-position.x(), -position.y());
 }
 
-void ScrollingTreeNodeMac::scrollBy(const IntSize &offset)
+void ScrollingTreeNodeMac::scrollBy(const IntSize& offset)
 {
-    setScrollPosition(scrollPosition() + offset);
+    IntPoint newScrollPosition = scrollPosition() + offset;
 
-    scrollingTree()->updateMainFrameScrollPosition(scrollPosition());
+    if (shouldUpdateScrollLayerPositionOnMainThread()) {
+        scrollingTree()->updateMainFrameScrollPositionAndScrollLayerPosition(newScrollPosition);
+        return;
+    }
+
+    setScrollPosition(newScrollPosition);
+    scrollingTree()->updateMainFrameScrollPosition(newScrollPosition);
 }
 

trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

@@ -984 +984 @@
         backing->graphicsLayer()->visibleRectChanged();
 
-    if (m_scrollLayer)
-        m_scrollLayer->setPosition(FloatPoint(-scrollPosition.x(), -scrollPosition.y()));
+    if (!m_scrollLayer)
+        return;
+
+#if ENABLE(THREADED_SCROLLING)
+    // If there's a scrolling coordinator that manages scrolling for this frame view,
+    // it will also manage updating the scroll layer position.
+    if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator()) {
+        if (scrollingCoordinator->coordinatesScrollingForFrameView(frameView))
+            return;
+    }
+#endif
+
+    m_scrollLayer->setPosition(FloatPoint(-scrollPosition.x(), -scrollPosition.y()));
 }