Scrollbars are updated on the main thread rather than the scrolling t…

…hread

(causing scroll bars not to appear/update quickly in some cases)
https://bugs.webkit.org/show_bug.cgi?id=122585
-and corresponding-
<rdar://problem/10710775>

Reviewed by Simon Fraser.

Source/WebCore: 

This patch does a few things in order to allow scrollbars to be updated on the 
scrolling thread:

1. This patch adds the ability to know if the lower-level APIs necessary to get 
this to work right are available, AND if the content is actually capable of taking 
advantage of this feature. This is currently implemented as 
Scrollbar::supportsUpdateOnSecondaryThread() which makes use of a new 
ScrollableArea function called updatesScrollLayerPositionOnMainThread()
        
2. To update on the scrolling thread, the scrolling tree needs to know about the 
ScrollbarPainters.
        
3. Once it knows about them, it should update the presentation value whenever the 
layer position changes.
        
4. Presentation value is basically the same thing as double value. There is a bit 
of code we maintain currently to compute that. This patch moves that code to a 
static function on ScrollableArea that can be called from both the main thread and 
the scrolling thread.
        
5. ScrollbarPainter API needs to know about the layers we have created for the 
vertical and horizontal scrollbars, then they will use those layers and the 
presentation value that we set on the scrolling thread to move the layers around.

This is part of #1 above. 
* page/FrameView.cpp:
(WebCore::FrameView::updatesScrollLayerPositionOnMainThread):
* page/FrameView.h:

This is part of #2. ScrollingStateScrollingNodes now have vertical and horizontal 
ScrollbarPainters for Mac only.
* page/scrolling/ScrollingStateScrollingNode.cpp:
(WebCore::ScrollingStateScrollingNode::ScrollingStateScrollingNode):
* page/scrolling/ScrollingStateScrollingNode.h:
(WebCore::ScrollingStateScrollingNode::verticalScrollbarPainter):
(WebCore::ScrollingStateScrollingNode::horizontalScrollbarPainter):

Also part of #2. Make sure to set the ScrollbarPainters for scrolling nodes when 
appropriate.
* page/scrolling/mac/ScrollingCoordinatorMac.h:
* page/scrolling/mac/ScrollingCoordinatorMac.mm:
(WebCore::ScrollingCoordinatorMac::frameViewLayoutUpdated):

Implement this function that was just stubbed out before. This is part of #5 in 
that is will allow the ScrollbarPainter API to know about any layer changes. 
(WebCore::ScrollingCoordinatorMac::scrollableAreaScrollbarLayerDidChange):

Back to #2, making sure we properly set the ScrollbarPainters to send over to the 
scrolling thread.
(WebCore::ScrollingCoordinatorMac::setScrollbarPaintersForNode):
* page/scrolling/mac/ScrollingStateScrollingNodeMac.mm:
(WebCore::ScrollingStateScrollingNode::setScrollbarPainters):

This code achieves #3. It uses new ScrollbarPainter API to adjust the position of 
the scrollbars from the scrolling thread.
* page/scrolling/mac/ScrollingTreeScrollingNodeMac.h:
* page/scrolling/mac/ScrollingTreeScrollingNodeMac.mm:
(WebCore::ScrollingTreeScrollingNodeMac::ScrollingTreeScrollingNodeMac):
(WebCore::ScrollingTreeScrollingNodeMac::updateBeforeChildren):
(WebCore::ScrollingTreeScrollingNodeMac::setScrollLayerPosition):

This is for #5. ScrollbarPainter needs to know about our scrollbar layers.
* platform/ScrollAnimator.h:
(WebCore::ScrollAnimator::verticalScrollbarLayerDidChange):
(WebCore::ScrollAnimator::horizontalScrollbarLayerDidChange):
* platform/ScrollableArea.cpp:
(WebCore::ScrollableArea::verticalScrollbarLayerDidChange):
(WebCore::ScrollableArea::horizontalScrollbarLayerDidChange):

This is for #4. This code computes the scrollbar’s value and current overhang 
amount.
(WebCore::ScrollableArea::computeScrollbarValueAndOverhang):
* platform/ScrollableArea.h:
(WebCore::ScrollableArea::layerForHorizontalScrollbar):
(WebCore::ScrollableArea::layerForVerticalScrollbar):
(WebCore::ScrollableArea::layerForScrolling):

This is for #1. We need to know if we have the ability to update scrollbars on a 
different thread. We can do that only on certain versions of the OS, only when 
threaded scrolling is enabled, and only when the current page is actually using 
the scrolling thread to scroll.
* platform/Scrollbar.cpp:
(WebCore::Scrollbar::supportsUpdateOnSecondaryThread):
* platform/Scrollbar.h:
* platform/ScrollbarThemeClient.h:

New ScrollbarPainter APIs.
* platform/mac/NSScrollerImpDetails.h:

This is for #5, letting the ScrollbarPainter API  know about the layers.
* platform/mac/ScrollAnimatorMac.h:
* platform/mac/ScrollAnimatorMac.mm:
(-[WebScrollbarPainterDelegate layer]):
(-[WebScrollbarPainterDelegate convertRectToLayer:]):
(-[WebScrollbarPainterDelegate shouldUseLayerPerPartForScrollerImp:]):

Before we kick off a scroll animation, set the current painting characteristics so 
they are up-to-date in case we are scrolling on the scrolling thread.
(-[WebScrollbarPainterDelegate setUpAlphaAnimation:scrollerPainter:part:WebCore::animateAlphaTo:duration:]):
(-[WebScrollbarPainterDelegate scrollerImp:animateKnobAlphaTo:duration:]):
(-[WebScrollbarPainterDelegate scrollerImp:animateTrackAlphaTo:duration:]):
(WebCore::ScrollAnimatorMac::didAddVerticalScrollbar):
(WebCore::ScrollAnimatorMac::didAddHorizontalScrollbar):
(WebCore::ScrollAnimatorMac::verticalScrollbarLayerDidChange):
(WebCore::ScrollAnimatorMac::horizontalScrollbarLayerDidChange):

Only paint the scrollbars through ScrollbarThemeMac if they are NOT being updated 
by the scrolling thread.
* platform/mac/ScrollbarThemeMac.h:
* platform/mac/ScrollbarThemeMac.mm:
(WebCore::ScrollbarThemeMac::setCurrentPaintCharacteristics):
(WebCore::scrollbarPainterPaint):
(WebCore::ScrollbarThemeMac::paint):

Back to #1.
* rendering/RenderLayer.cpp:
(WebCore::RenderLayer::updatesScrollLayerPositionOnMainThread):
* rendering/RenderLayer.h:
* rendering/RenderLayerCompositor.cpp:
(WebCore::RenderLayerCompositor::updateOverflowControlsLayers):
* rendering/RenderListBox.h:

Source/WebKit2: 

New pure virtual function.
* WebProcess/Plugins/PDF/PDFPlugin.h:



git-svn-id: http://svn.webkit.org/repository/webkit/trunk@157253 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebCore/ChangeLog

@@ -1,3 +1,135 @@
+2013-10-10  Beth Dakin  <[email protected]>
+
+        Scrollbars are updated on the main thread rather than the scrolling thread 
+        (causing scroll bars not to appear/update quickly in some cases)
+        https://bugs.webkit.org/show_bug.cgi?id=122585
+        -and corresponding-
+        <rdar://problem/10710775>
+
+        Reviewed by Simon Fraser.
+
+        This patch does a few things in order to allow scrollbars to be updated on the 
+        scrolling thread:
+
+        1. This patch adds the ability to know if the lower-level APIs necessary to get 
+        this to work right are available, AND if the content is actually capable of taking 
+        advantage of this feature. This is currently implemented as 
+        Scrollbar::supportsUpdateOnSecondaryThread() which makes use of a new 
+        ScrollableArea function called updatesScrollLayerPositionOnMainThread()
+
+        2. To update on the scrolling thread, the scrolling tree needs to know about the 
+        ScrollbarPainters.
+
+        3. Once it knows about them, it should update the presentation value whenever the 
+        layer position changes.
+
+        4. Presentation value is basically the same thing as double value. There is a bit 
+        of code we maintain currently to compute that. This patch moves that code to a 
+        static function on ScrollableArea that can be called from both the main thread and 
+        the scrolling thread.
+
+        5. ScrollbarPainter API needs to know about the layers we have created for the 
+        vertical and horizontal scrollbars, then they will use those layers and the 
+        presentation value that we set on the scrolling thread to move the layers around.
+
+        This is part of #1 above. 
+        * page/FrameView.cpp:
+        (WebCore::FrameView::updatesScrollLayerPositionOnMainThread):
+        * page/FrameView.h:
+
+        This is part of #2. ScrollingStateScrollingNodes now have vertical and horizontal 
+        ScrollbarPainters for Mac only.
+        * page/scrolling/ScrollingStateScrollingNode.cpp:
+        (WebCore::ScrollingStateScrollingNode::ScrollingStateScrollingNode):
+        * page/scrolling/ScrollingStateScrollingNode.h:
+        (WebCore::ScrollingStateScrollingNode::verticalScrollbarPainter):
+        (WebCore::ScrollingStateScrollingNode::horizontalScrollbarPainter):
+
+        Also part of #2. Make sure to set the ScrollbarPainters for scrolling nodes when 
+        appropriate.
+        * page/scrolling/mac/ScrollingCoordinatorMac.h:
+        * page/scrolling/mac/ScrollingCoordinatorMac.mm:
+        (WebCore::ScrollingCoordinatorMac::frameViewLayoutUpdated):
+
+        Implement this function that was just stubbed out before. This is part of #5 in 
+        that is will allow the ScrollbarPainter API to know about any layer changes. 
+        (WebCore::ScrollingCoordinatorMac::scrollableAreaScrollbarLayerDidChange):
+
+        Back to #2, making sure we properly set the ScrollbarPainters to send over to the 
+        scrolling thread.
+        (WebCore::ScrollingCoordinatorMac::setScrollbarPaintersForNode):
+        * page/scrolling/mac/ScrollingStateScrollingNodeMac.mm:
+        (WebCore::ScrollingStateScrollingNode::setScrollbarPainters):
+
+        This code achieves #3. It uses new ScrollbarPainter API to adjust the position of 
+        the scrollbars from the scrolling thread.
+        * page/scrolling/mac/ScrollingTreeScrollingNodeMac.h:
+        * page/scrolling/mac/ScrollingTreeScrollingNodeMac.mm:
+        (WebCore::ScrollingTreeScrollingNodeMac::ScrollingTreeScrollingNodeMac):
+        (WebCore::ScrollingTreeScrollingNodeMac::updateBeforeChildren):
+        (WebCore::ScrollingTreeScrollingNodeMac::setScrollLayerPosition):
+
+        This is for #5. ScrollbarPainter needs to know about our scrollbar layers.
+        * platform/ScrollAnimator.h:
+        (WebCore::ScrollAnimator::verticalScrollbarLayerDidChange):
+        (WebCore::ScrollAnimator::horizontalScrollbarLayerDidChange):
+        * platform/ScrollableArea.cpp:
+        (WebCore::ScrollableArea::verticalScrollbarLayerDidChange):
+        (WebCore::ScrollableArea::horizontalScrollbarLayerDidChange):
+
+        This is for #4. This code computes the scrollbar’s value and current overhang 
+        amount.
+        (WebCore::ScrollableArea::computeScrollbarValueAndOverhang):
+        * platform/ScrollableArea.h:
+        (WebCore::ScrollableArea::layerForHorizontalScrollbar):
+        (WebCore::ScrollableArea::layerForVerticalScrollbar):
+        (WebCore::ScrollableArea::layerForScrolling):
+
+        This is for #1. We need to know if we have the ability to update scrollbars on a 
+        different thread. We can do that only on certain versions of the OS, only when 
+        threaded scrolling is enabled, and only when the current page is actually using 
+        the scrolling thread to scroll.
+        * platform/Scrollbar.cpp:
+        (WebCore::Scrollbar::supportsUpdateOnSecondaryThread):
+        * platform/Scrollbar.h:
+        * platform/ScrollbarThemeClient.h:
+
+        New ScrollbarPainter APIs.
+        * platform/mac/NSScrollerImpDetails.h:
+
+        This is for #5, letting the ScrollbarPainter API  know about the layers.
+        * platform/mac/ScrollAnimatorMac.h:
+        * platform/mac/ScrollAnimatorMac.mm:
+        (-[WebScrollbarPainterDelegate layer]):
+        (-[WebScrollbarPainterDelegate convertRectToLayer:]):
+        (-[WebScrollbarPainterDelegate shouldUseLayerPerPartForScrollerImp:]):
+
+        Before we kick off a scroll animation, set the current painting characteristics so 
+        they are up-to-date in case we are scrolling on the scrolling thread.
+        (-[WebScrollbarPainterDelegate setUpAlphaAnimation:scrollerPainter:part:WebCore::animateAlphaTo:duration:]):
+        (-[WebScrollbarPainterDelegate scrollerImp:animateKnobAlphaTo:duration:]):
+        (-[WebScrollbarPainterDelegate scrollerImp:animateTrackAlphaTo:duration:]):
+        (WebCore::ScrollAnimatorMac::didAddVerticalScrollbar):
+        (WebCore::ScrollAnimatorMac::didAddHorizontalScrollbar):
+        (WebCore::ScrollAnimatorMac::verticalScrollbarLayerDidChange):
+        (WebCore::ScrollAnimatorMac::horizontalScrollbarLayerDidChange):
+
+        Only paint the scrollbars through ScrollbarThemeMac if they are NOT being updated 
+        by the scrolling thread.
+        * platform/mac/ScrollbarThemeMac.h:
+        * platform/mac/ScrollbarThemeMac.mm:
+        (WebCore::ScrollbarThemeMac::setCurrentPaintCharacteristics):
+        (WebCore::scrollbarPainterPaint):
+        (WebCore::ScrollbarThemeMac::paint):
+
+        Back to #1.
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::updatesScrollLayerPositionOnMainThread):
+        * rendering/RenderLayer.h:
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::updateOverflowControlsLayers):
+        * rendering/RenderListBox.h:
+
 2013-10-10  Brent Fulgham  <[email protected]>
 
         [Win] Unreviewed build fix after r157228

Source/WebCore/page/FrameView.cpp

@@ -3014,6 +3014,16 @@ bool FrameView::isActive() const
     return page && page->focusController().isActive();
 }
 
+bool FrameView::updatesScrollLayerPositionOnMainThread() const
+{
+    if (Page* page = frame().page()) {
+        if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator())
+            return scrollingCoordinator->shouldUpdateScrollLayerPositionOnMainThread();
+    }
+
+    return true;
+}
+
 void FrameView::scrollTo(const IntSize& newOffset)
 {
     LayoutSize offset = scrollOffset();

Source/WebCore/page/FrameView.h

@@ -401,6 +401,7 @@ class FrameView FINAL : public ScrollView {
 #endif
 
     virtual bool isActive() const OVERRIDE;
+    virtual bool updatesScrollLayerPositionOnMainThread() const OVERRIDE;
 
 #if ENABLE(RUBBER_BANDING)
     GraphicsLayer* setWantsLayerForTopOverHangArea(bool) const;

Source/WebCore/page/scrolling/ScrollingStateScrollingNode.cpp

@@ -44,6 +44,10 @@ ScrollingStateScrollingNode::ScrollingStateScrollingNode(ScrollingStateTree* sta
     , m_counterScrollingLayer(0)
     , m_headerLayer(0)
     , m_footerLayer(0)
+#if PLATFORM(MAC)
+    , m_verticalScrollbarPainter(0)
+    , m_horizontalScrollbarPainter(0)
+#endif
     , m_frameScaleFactor(1)
     , m_wheelEventHandlerCount(0)
     , m_shouldUpdateScrollLayerPositionOnMainThread(0)
@@ -61,6 +65,10 @@ ScrollingStateScrollingNode::ScrollingStateScrollingNode(ScrollingStateTree* sta
 
 ScrollingStateScrollingNode::ScrollingStateScrollingNode(const ScrollingStateScrollingNode& stateNode)
     : ScrollingStateNode(stateNode)
+#if PLATFORM(MAC)
+    , m_verticalScrollbarPainter(stateNode.verticalScrollbarPainter())
+    , m_horizontalScrollbarPainter(stateNode.horizontalScrollbarPainter())
+#endif
     , m_viewportRect(stateNode.viewportRect())
     , m_totalContentsSize(stateNode.totalContentsSize())
     , m_frameScaleFactor(stateNode.frameScaleFactor())

Source/WebCore/page/scrolling/ScrollingStateScrollingNode.h

@@ -31,12 +31,15 @@
 #include "IntRect.h"
 #include "Region.h"
 #include "ScrollTypes.h"
+#include "ScrollbarThemeComposite.h"
 #include "ScrollingCoordinator.h"
 #include "ScrollingStateNode.h"
 #include <wtf/PassOwnPtr.h>
 
 namespace WebCore {
 
+class Scrollbar;
+
 class ScrollingStateScrollingNode : public ScrollingStateNode {
 public:
     static PassOwnPtr<ScrollingStateScrollingNode> create(ScrollingStateTree*, ScrollingNodeID);
@@ -64,7 +67,8 @@ class ScrollingStateScrollingNode : public ScrollingStateNode {
         HeaderHeight,
         FooterHeight,
         HeaderLayer,
-        FooterLayer
+        FooterLayer,
+        PainterForScrollbar
     };
 
     virtual bool isScrollingNode() OVERRIDE { return true; }
@@ -132,6 +136,12 @@ class ScrollingStateScrollingNode : public ScrollingStateNode {
     void setFooterLayer(GraphicsLayer*);
     PlatformLayer* footerPlatformLayer() const;
 
+#if PLATFORM(MAC)
+    ScrollbarPainter verticalScrollbarPainter() const { return m_verticalScrollbarPainter; }
+    ScrollbarPainter horizontalScrollbarPainter() const { return m_horizontalScrollbarPainter; }
+#endif
+    void setScrollbarPaintersFromScrollbars(Scrollbar* verticalScrollbar, Scrollbar* horizontalScrollbar);
+
     bool requestedScrollPositionRepresentsProgrammaticScroll() const { return m_requestedScrollPositionRepresentsProgrammaticScroll; }
 
     virtual void dumpProperties(TextStream&, int indent) const OVERRIDE;
@@ -147,6 +157,8 @@ class ScrollingStateScrollingNode : public ScrollingStateNode {
     RetainPtr<PlatformLayer> m_counterScrollingPlatformLayer;
     RetainPtr<PlatformLayer> m_headerPlatformLayer;
     RetainPtr<PlatformLayer> m_footerPlatformLayer;
+    ScrollbarPainter m_verticalScrollbarPainter;
+    ScrollbarPainter m_horizontalScrollbarPainter;
 #endif
 
     IntRect m_viewportRect;

Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.h

@@ -32,6 +32,7 @@
 
 namespace WebCore {
 
+class Scrollbar;
 class ScrollingStateNode;
 class ScrollingStateScrollingNode;
 class ScrollingStateTree;
@@ -122,6 +123,7 @@ class ScrollingCoordinatorMac : public ScrollingCoordinator {
     void setCounterScrollingLayerForNode(GraphicsLayer*, ScrollingStateScrollingNode*);
     void setHeaderLayerForNode(GraphicsLayer*, ScrollingStateScrollingNode*);
     void setFooterLayerForNode(GraphicsLayer*, ScrollingStateScrollingNode*);
+    void setScrollbarPaintersFromScrollbarsForNode(Scrollbar* verticalScrollbar, Scrollbar* horizontalScrollbar, ScrollingStateScrollingNode*);
     void setNonFastScrollableRegionForNode(const Region&, ScrollingStateScrollingNode*);
     void setWheelEventHandlerCountForNode(unsigned, ScrollingStateScrollingNode*);
 

Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.mm

@@ -131,11 +131,17 @@
     if (!node)
         return;
 
+    Scrollbar* verticalScrollbar = frameView->verticalScrollbar();
+    Scrollbar* horizontalScrollbar = frameView->horizontalScrollbar();
+    if ((verticalScrollbar && verticalScrollbar->supportsUpdateOnSecondaryThread())
+        || (horizontalScrollbar && horizontalScrollbar->supportsUpdateOnSecondaryThread()))
+        setScrollbarPaintersFromScrollbarsForNode(verticalScrollbar, horizontalScrollbar, node);
+
     ScrollParameters scrollParameters;
     scrollParameters.horizontalScrollElasticity = frameView->horizontalScrollElasticity();
     scrollParameters.verticalScrollElasticity = frameView->verticalScrollElasticity();
-    scrollParameters.hasEnabledHorizontalScrollbar = frameView->horizontalScrollbar() && frameView->horizontalScrollbar()->enabled();
-    scrollParameters.hasEnabledVerticalScrollbar = frameView->verticalScrollbar() && frameView->verticalScrollbar()->enabled();
+    scrollParameters.hasEnabledHorizontalScrollbar = horizontalScrollbar && horizontalScrollbar->enabled();
+    scrollParameters.hasEnabledVerticalScrollbar = verticalScrollbar && verticalScrollbar->enabled();
     scrollParameters.horizontalScrollbarMode = frameView->horizontalScrollbarMode();
     scrollParameters.verticalScrollbarMode = frameView->verticalScrollbarMode();
 
@@ -178,15 +184,18 @@
     setFooterLayerForNode(footerLayerForFrameView(frameView), node);
 }
 
-void ScrollingCoordinatorMac::scrollableAreaScrollbarLayerDidChange(ScrollableArea* scrollableArea, ScrollbarOrientation)
+void ScrollingCoordinatorMac::scrollableAreaScrollbarLayerDidChange(ScrollableArea* scrollableArea, ScrollbarOrientation orientation)
 {
     ASSERT(isMainThread());
     ASSERT(m_page);
 
     if (scrollableArea != static_cast<ScrollableArea*>(m_page->mainFrame().view()))
         return;
 
-    // FIXME: Implement.
+    if (orientation == VerticalScrollbar)
+        scrollableArea->verticalScrollbarLayerDidChange();
+    else
+        scrollableArea->horizontalScrollbarLayerDidChange();
 }
 
 bool ScrollingCoordinatorMac::requestScrollPositionUpdate(FrameView* frameView, const IntPoint& scrollPosition)
@@ -278,6 +287,12 @@
     scheduleTreeStateCommit();
 }
 
+void ScrollingCoordinatorMac::setScrollbarPaintersFromScrollbarsForNode(Scrollbar* verticalScrollbar, Scrollbar* horizontalScrollbar, ScrollingStateScrollingNode* node)
+{
+    node->setScrollbarPaintersFromScrollbars(verticalScrollbar, horizontalScrollbar);
+    scheduleTreeStateCommit();
+}
+
 void ScrollingCoordinatorMac::setNonFastScrollableRegionForNode(const Region& region, ScrollingStateScrollingNode* node)
 {
     node->setNonFastScrollableRegion(region);

Source/WebCore/page/scrolling/mac/ScrollingStateScrollingNodeMac.mm

@@ -27,6 +27,8 @@
 #include "ScrollingStateScrollingNode.h"
 
 #include "GraphicsLayer.h"
+#include "Scrollbar.h"
+#include "ScrollbarThemeMac.h"
 #include "ScrollingStateTree.h"
 
 #if ENABLE(THREADED_SCROLLING)
@@ -90,6 +92,27 @@
         m_scrollingStateTree->setHasChangedProperties(true);
 }
 
+void ScrollingStateScrollingNode::setScrollbarPaintersFromScrollbars(Scrollbar* verticalScrollbar, Scrollbar* horizontalScrollbar)
+{
+    ScrollbarTheme* scrollbarTheme = ScrollbarTheme::theme();
+    if (scrollbarTheme->isMockTheme())
+        return;
+    ScrollbarThemeMac* macTheme = static_cast<ScrollbarThemeMac*>(scrollbarTheme);
+
+    ScrollbarPainter verticalPainter = verticalScrollbar ? macTheme->painterForScrollbar(verticalScrollbar) : 0;
+    ScrollbarPainter horizontalPainter = horizontalScrollbar ? macTheme->painterForScrollbar(horizontalScrollbar) : 0;
+
+    if (m_verticalScrollbarPainter == verticalPainter && m_horizontalScrollbarPainter == horizontalPainter)
+        return;
+
+    m_verticalScrollbarPainter = verticalPainter;
+    m_horizontalScrollbarPainter = horizontalPainter;
+
+    setPropertyChanged(PainterForScrollbar);
+    if (m_scrollingStateTree)
+        m_scrollingStateTree->setHasChangedProperties(true);
+}
+
 } // namespace WebCore
 
 #endif // ENABLE(THREADED_SCROLLING)

Source/WebCore/page/scrolling/mac/ScrollingTreeScrollingNodeMac.h

@@ -29,6 +29,7 @@
 #if ENABLE(THREADED_SCROLLING)
 
 #include "ScrollElasticityController.h"
+#include "ScrollbarThemeMac.h"
 #include "ScrollingTreeScrollingNode.h"
 #include <wtf/RetainPtr.h>
 
@@ -84,6 +85,8 @@ class ScrollingTreeScrollingNodeMac : public ScrollingTreeScrollingNode, private
     RetainPtr<CALayer> m_counterScrollingLayer;
     RetainPtr<CALayer> m_headerLayer;
     RetainPtr<CALayer> m_footerLayer;
+    ScrollbarPainter m_verticalScrollbarPainter;
+    ScrollbarPainter m_horizontalScrollbarPainter;
     IntPoint m_probableMainThreadScrollPosition;
     bool m_lastScrollHadUnfilledPixels;
 };