Revert of Make ScrollbarThemeAura selectively invalidate scrollbar parts....

Revert of Make ScrollbarThemeAura selectively invalidate scrollbar parts. (patchset #10 id:180001 of https://codereview.chromium.org/1525803002/ )

Reason for revert:
Oilpan unit test failure: http://build.chromium.org/p/chromium.webkit/builders/WebKit%20Mac%20Oilpan/builds/28217

Original issue's description:
> Make ScrollbarThemeAura selectively invalidate scrollbar parts.
>
> In particular:
> - when hovering or pressing the thumb, repaint only the thumb
> - when thumb position changes, repaint the track only if it changes
>   (e.g. due to a button being disabled upon reaching the end)
>
> BUG=549277
>
> Committed: https://crrev.com/0e8396ada46f085c23343450d850d81751053c94
> Cr-Commit-Position: refs/heads/master@{#367082}

TBR=ccameron@chromium.org,skobes@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=549277

Review URL: https://codereview.chromium.org/1550983002

Cr-Commit-Position: refs/heads/master@{#367096}

third_party/WebKit/LayoutTests/TestExpectations

@@ -307,10 +307,6 @@ crbug.com/571478 [ Win10 XP ] svg/custom/text-match-highlight.html [ Failure Pas
 
 crbug.com/248938 [ Win Debug ] virtual/threaded/animations/transition-and-animation-2.html [ Timeout ]
 
-crbug.com/549277 fast/repaint/overflow-move-after-scroll.html [ NeedsRebaseline ]
-crbug.com/549277 fast/repaint/overflow-scroll-after-move.html [ NeedsRebaseline ]
-crbug.com/549277 paint/invalidation/invalidate-after-composited-scroll.html [ NeedsRebaseline ]
-
 crbug.com/487281 [ Mac ] fast/forms/select/menulist-narrow-width.html [ Failure ]
 
 crbug.com/572094 [ Win Mac Debug ] fast/forms/suggestion-picker/date-suggestion-picker-appearance-zoom200.html [ Timeout Failure Pass ]

third_party/WebKit/Source/core/frame/FrameView.cpp

@@ -2084,8 +2084,10 @@ void FrameView::scrollTo(const DoublePoint& newPosition)
 
 void FrameView::invalidatePaintForTickmarks()
 {
-    if (Scrollbar* scrollbar = verticalScrollbar())
-        scrollbar->setNeedsPaintInvalidation(static_cast<ScrollbarPart>(~ThumbPart));
+    if (Scrollbar* scrollbar = verticalScrollbar()) {
+        scrollbar->setTrackNeedsRepaint(true);
+        setScrollbarNeedsPaintInvalidation(VerticalScrollbar);
+    }
 }
 
 void FrameView::getTickmarks(Vector<IntRect>& tickmarks) const

third_party/WebKit/Source/platform/exported/WebScrollbarThemePainter.cpp

@@ -66,7 +66,8 @@ void WebScrollbarThemePainter::paintTrackBackground(WebCanvas* canvas, const Web
     pictureBuilder.context().setDeviceScaleFactor(m_deviceScaleFactor);
     m_theme->paintTrackBackground(pictureBuilder.context(), *m_scrollbar, intRect);
     pictureBuilder.endRecording()->playback(canvas);
-    m_scrollbar->setTrackNeedsRepaint(false);
+    if (!m_theme->shouldRepaintAllPartsOnInvalidation())
+        m_scrollbar->setTrackNeedsRepaint(false);
 }
 
 void WebScrollbarThemePainter::paintBackTrackPart(WebCanvas* canvas, const WebRect& rect)
@@ -139,7 +140,8 @@ void WebScrollbarThemePainter::paintThumb(WebCanvas* canvas, const WebRect& rect
     pictureBuilder.context().setDeviceScaleFactor(m_deviceScaleFactor);
     m_theme->paintThumb(pictureBuilder.context(), *m_scrollbar, intRect);
     pictureBuilder.endRecording()->playback(canvas);
-    m_scrollbar->setThumbNeedsRepaint(false);
+    if (!m_theme->shouldRepaintAllPartsOnInvalidation())
+        m_scrollbar->setThumbNeedsRepaint(false);
 }
 
 WebScrollbarThemePainter::WebScrollbarThemePainter(ScrollbarTheme& theme, Scrollbar& scrollbar, float deviceScaleFactor)

third_party/WebKit/Source/platform/mac/ScrollAnimatorMac.mm

@@ -428,17 +428,20 @@ private:
         break;
     case TrackAlpha:
         [_scrollbarPainter.get() setTrackAlpha:currentValue];
-        _scrollbar->setNeedsPaintInvalidation(static_cast<ScrollbarPart>(~ThumbPart));
+        _scrollbar->setTrackNeedsRepaint(true);
         break;
     case UIStateTransition:
         [_scrollbarPainter.get() setUiStateTransitionProgress:currentValue];
-        _scrollbar->setNeedsPaintInvalidation();
+        _scrollbar->setThumbNeedsRepaint(true);
+        _scrollbar->setTrackNeedsRepaint(true);
         break;
     case ExpansionTransition:
         [_scrollbarPainter.get() setExpansionTransitionProgress:currentValue];
-        _scrollbar->setNeedsPaintInvalidation(ThumbPart);
+        _scrollbar->setThumbNeedsRepaint(true);
         break;
     }
+
+    _scrollbar->setNeedsPaintInvalidation();
 }
 
 - (void)invalidate

third_party/WebKit/Source/platform/scroll/ScrollableArea.cpp

@@ -244,18 +244,17 @@ void ScrollableArea::scrollPositionChanged(const DoublePoint& position, ScrollTy
     // Tell the derived class to scroll its contents.
     setScrollOffset(truncatedPosition, scrollType);
 
+    Scrollbar* verticalScrollbar = this->verticalScrollbar();
+
     // Tell the scrollbars to update their thumb postions.
-    // If a scrollbar does not have its own layer, it must always be invalidated
-    // to reflect the new thumb position, even if the theme would not otherwise
-    // require invalidation of any part.
     if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
-        bool offsetChanged = horizontalScrollbar->offsetDidChange();
-        if (offsetChanged && !hasLayerForHorizontalScrollbar())
+        horizontalScrollbar->offsetDidChange();
+        if (horizontalScrollbar->isOverlayScrollbar() && !hasLayerForHorizontalScrollbar())
             setScrollbarNeedsPaintInvalidation(HorizontalScrollbar);
     }
-    if (Scrollbar* verticalScrollbar = this->verticalScrollbar()) {
-        bool offsetChanged = verticalScrollbar->offsetDidChange();
-        if (offsetChanged && !hasLayerForVerticalScrollbar())
+    if (verticalScrollbar) {
+        verticalScrollbar->offsetDidChange();
+        if (verticalScrollbar->isOverlayScrollbar() && !hasLayerForVerticalScrollbar())
             setScrollbarNeedsPaintInvalidation(VerticalScrollbar);
     }
 

third_party/WebKit/Source/platform/scroll/ScrollableAreaTest.cpp

@@ -18,7 +18,6 @@ namespace blink {
 
 namespace {
 
-using testing::_;
 using testing::Return;
 
 class MockScrollableArea : public NoBaseWillBeGarbageCollectedFinalized<MockScrollableArea>, public ScrollableArea {
@@ -33,15 +32,12 @@ public:
     MOCK_CONST_METHOD1(scrollSize, int(ScrollbarOrientation));
     MOCK_CONST_METHOD0(isScrollCornerVisible, bool());
     MOCK_CONST_METHOD0(scrollCornerRect, IntRect());
-    MOCK_CONST_METHOD0(horizontalScrollbar, Scrollbar*());
-    MOCK_CONST_METHOD0(verticalScrollbar, Scrollbar*());
     MOCK_METHOD0(scrollControlWasSetNeedsPaintInvalidation, void());
     MOCK_CONST_METHOD0(enclosingScrollableArea, ScrollableArea*());
     MOCK_CONST_METHOD1(visibleContentRect, IntRect(IncludeScrollbarsInRect));
     MOCK_CONST_METHOD0(contentsSize, IntSize());
     MOCK_CONST_METHOD0(scrollableAreaBoundingBox, IntRect());
     MOCK_CONST_METHOD0(layerForHorizontalScrollbar, GraphicsLayer*());
-    MOCK_CONST_METHOD0(layerForVerticalScrollbar, GraphicsLayer*());
 
     bool userInputScrollable(ScrollbarOrientation) const override { return true; }
     bool scrollbarsCanBeActive () const override { return true; }
@@ -55,10 +51,6 @@ public:
     bool scrollAnimatorEnabled() const override { return false; }
     int pageStep(ScrollbarOrientation) const override { return 0; }
 
-    using ScrollableArea::horizontalScrollbarNeedsPaintInvalidation;
-    using ScrollableArea::verticalScrollbarNeedsPaintInvalidation;
-    using ScrollableArea::clearNeedsPaintInvalidationForScrollControls;
-
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         ScrollableArea::trace(visitor);
@@ -150,7 +142,6 @@ namespace {
 class ScrollbarThemeWithMockInvalidation : public ScrollbarThemeMock {
 public:
     MOCK_CONST_METHOD0(shouldRepaintAllPartsOnInvalidation, bool());
-    MOCK_CONST_METHOD3(invalidateOnThumbPositionChange, ScrollbarPart(const ScrollbarThemeClient&, float, float));
 };
 
 } // namespace
@@ -172,20 +163,18 @@ TEST_F(ScrollableAreaTest, ScrollbarTrackAndThumbRepaint)
     scrollbar->setThumbNeedsRepaint(false);
     EXPECT_FALSE(scrollbar->trackNeedsRepaint());
     EXPECT_FALSE(scrollbar->thumbNeedsRepaint());
-    scrollbar->setNeedsPaintInvalidation(ThumbPart);
+    scrollbar->setNeedsPaintInvalidation();
     EXPECT_TRUE(scrollbar->trackNeedsRepaint());
     EXPECT_TRUE(scrollbar->thumbNeedsRepaint());
 
-    // When not all parts are repainted on invalidation,
-    // setNeedsPaintInvalidation sets repaint bits only on the requested parts.
     EXPECT_CALL(theme, shouldRepaintAllPartsOnInvalidation()).WillRepeatedly(Return(false));
     scrollbar->setTrackNeedsRepaint(false);
     scrollbar->setThumbNeedsRepaint(false);
     EXPECT_FALSE(scrollbar->trackNeedsRepaint());
     EXPECT_FALSE(scrollbar->thumbNeedsRepaint());
-    scrollbar->setNeedsPaintInvalidation(ThumbPart);
+    scrollbar->setNeedsPaintInvalidation();
     EXPECT_FALSE(scrollbar->trackNeedsRepaint());
-    EXPECT_TRUE(scrollbar->thumbNeedsRepaint());
+    EXPECT_FALSE(scrollbar->thumbNeedsRepaint());
 
     // Forced GC in order to finalize objects depending on the mock object.
     Heap::collectAllGarbage();
@@ -221,98 +210,4 @@ TEST_F(ScrollableAreaTest, ScrollbarGraphicsLayerInvalidation)
     EXPECT_TRUE(graphicsLayer.hasTrackedPaintInvalidations());
 }
 
-TEST_F(ScrollableAreaTest, InvalidatesNonCompositedScrollbarsWhenThumbMoves)
-{
-    ScrollbarThemeWithMockInvalidation theme;
-    OwnPtrWillBeRawPtr<MockScrollableArea> scrollableArea = MockScrollableArea::create(IntPoint(100, 100));
-    RefPtrWillBeRawPtr<Scrollbar> horizontalScrollbar = Scrollbar::createForTesting(scrollableArea.get(), HorizontalScrollbar, RegularScrollbar, &theme);
-    RefPtrWillBeRawPtr<Scrollbar> verticalScrollbar = Scrollbar::createForTesting(scrollableArea.get(), VerticalScrollbar, RegularScrollbar, &theme);
-    EXPECT_CALL(*scrollableArea, horizontalScrollbar()).WillRepeatedly(Return(horizontalScrollbar.get()));
-    EXPECT_CALL(*scrollableArea, verticalScrollbar()).WillRepeatedly(Return(verticalScrollbar.get()));
-
-    // Regardless of whether the theme invalidates any parts, non-composited
-    // scrollbars have to be repainted if the thumb moves.
-    EXPECT_CALL(*scrollableArea, layerForHorizontalScrollbar()).WillRepeatedly(Return(nullptr));
-    EXPECT_CALL(*scrollableArea, layerForVerticalScrollbar()).WillRepeatedly(Return(nullptr));
-    ASSERT_FALSE(scrollableArea->hasLayerForVerticalScrollbar());
-    ASSERT_FALSE(scrollableArea->hasLayerForHorizontalScrollbar());
-    EXPECT_CALL(theme, shouldRepaintAllPartsOnInvalidation()).WillRepeatedly(Return(false));
-    EXPECT_CALL(theme, invalidateOnThumbPositionChange(_, _, _)).WillRepeatedly(Return(NoPart));
-
-    // A scroll in each direction should only invalidate one scrollbar.
-    scrollableArea->setScrollPosition(DoublePoint(0, 50), ProgrammaticScroll);
-    EXPECT_FALSE(scrollableArea->horizontalScrollbarNeedsPaintInvalidation());
-    EXPECT_TRUE(scrollableArea->verticalScrollbarNeedsPaintInvalidation());
-    scrollableArea->clearNeedsPaintInvalidationForScrollControls();
-    scrollableArea->setScrollPosition(DoublePoint(50, 50), ProgrammaticScroll);
-    EXPECT_TRUE(scrollableArea->horizontalScrollbarNeedsPaintInvalidation());
-    EXPECT_FALSE(scrollableArea->verticalScrollbarNeedsPaintInvalidation());
-    scrollableArea->clearNeedsPaintInvalidationForScrollControls();
-
-    // Forced GC in order to finalize objects depending on the mock object.
-    Heap::collectAllGarbage();
-}
-
-
-TEST_F(ScrollableAreaTest, InvalidatesCompositedScrollbarsIfPartsNeedRepaint)
-{
-    ScrollbarThemeWithMockInvalidation theme;
-    OwnPtrWillBeRawPtr<MockScrollableArea> scrollableArea = MockScrollableArea::create(IntPoint(100, 100));
-    RefPtrWillBeRawPtr<Scrollbar> horizontalScrollbar = Scrollbar::createForTesting(scrollableArea.get(), HorizontalScrollbar, RegularScrollbar, &theme);
-    horizontalScrollbar->setTrackNeedsRepaint(false);
-    horizontalScrollbar->setThumbNeedsRepaint(false);
-    RefPtrWillBeRawPtr<Scrollbar> verticalScrollbar = Scrollbar::createForTesting(scrollableArea.get(), VerticalScrollbar, RegularScrollbar, &theme);
-    verticalScrollbar->setTrackNeedsRepaint(false);
-    verticalScrollbar->setThumbNeedsRepaint(false);
-    EXPECT_CALL(*scrollableArea, horizontalScrollbar()).WillRepeatedly(Return(horizontalScrollbar.get()));
-    EXPECT_CALL(*scrollableArea, verticalScrollbar()).WillRepeatedly(Return(verticalScrollbar.get()));
-
-    // Composited scrollbars only need repainting when parts become invalid
-    // (e.g. if the track changes appearance when the thumb reaches the end).
-    MockGraphicsLayerClient graphicsLayerClient;
-    MockGraphicsLayer layerForHorizontalScrollbar(&graphicsLayerClient);
-    layerForHorizontalScrollbar.setDrawsContent(true);
-    layerForHorizontalScrollbar.setSize(FloatSize(10, 10));
-    MockGraphicsLayer layerForVerticalScrollbar(&graphicsLayerClient);
-    layerForVerticalScrollbar.setDrawsContent(true);
-    layerForVerticalScrollbar.setSize(FloatSize(10, 10));
-    EXPECT_CALL(*scrollableArea, layerForHorizontalScrollbar()).WillRepeatedly(Return(&layerForHorizontalScrollbar));
-    EXPECT_CALL(*scrollableArea, layerForVerticalScrollbar()).WillRepeatedly(Return(&layerForVerticalScrollbar));
-    ASSERT_TRUE(scrollableArea->hasLayerForHorizontalScrollbar());
-    ASSERT_TRUE(scrollableArea->hasLayerForVerticalScrollbar());
-    EXPECT_CALL(theme, shouldRepaintAllPartsOnInvalidation()).WillRepeatedly(Return(false));
-
-    // First, we'll scroll horizontally, and the theme will require repainting
-    // the back button (i.e. the track).
-    EXPECT_CALL(theme, invalidateOnThumbPositionChange(_, _, _)).WillOnce(Return(BackButtonStartPart));
-    scrollableArea->setScrollPosition(DoublePoint(50, 0), ProgrammaticScroll);
-    EXPECT_TRUE(layerForHorizontalScrollbar.hasTrackedPaintInvalidations());
-    EXPECT_FALSE(layerForVerticalScrollbar.hasTrackedPaintInvalidations());
-    EXPECT_TRUE(horizontalScrollbar->trackNeedsRepaint());
-    EXPECT_FALSE(horizontalScrollbar->thumbNeedsRepaint());
-    layerForHorizontalScrollbar.resetTrackedPaintInvalidations();
-    horizontalScrollbar->setTrackNeedsRepaint(false);
-
-    // Next, we'll scroll vertically, but invalidate the thumb.
-    EXPECT_CALL(theme, invalidateOnThumbPositionChange(_, _, _)).WillOnce(Return(ThumbPart));
-    scrollableArea->setScrollPosition(DoublePoint(50, 50), ProgrammaticScroll);
-    EXPECT_FALSE(layerForHorizontalScrollbar.hasTrackedPaintInvalidations());
-    EXPECT_TRUE(layerForVerticalScrollbar.hasTrackedPaintInvalidations());
-    EXPECT_FALSE(verticalScrollbar->trackNeedsRepaint());
-    EXPECT_TRUE(verticalScrollbar->thumbNeedsRepaint());
-    layerForVerticalScrollbar.resetTrackedPaintInvalidations();
-    verticalScrollbar->setThumbNeedsRepaint(false);
-
-    // Next we'll scroll in both, but the thumb position moving requires no
-    // invalidations.
-    EXPECT_CALL(theme, invalidateOnThumbPositionChange(_, _, _)).Times(2).WillRepeatedly(Return(NoPart));
-    scrollableArea->setScrollPosition(DoublePoint(70, 70), ProgrammaticScroll);
-    EXPECT_FALSE(layerForHorizontalScrollbar.hasTrackedPaintInvalidations());
-    EXPECT_FALSE(layerForVerticalScrollbar.hasTrackedPaintInvalidations());
-    EXPECT_FALSE(horizontalScrollbar->trackNeedsRepaint());
-    EXPECT_FALSE(horizontalScrollbar->thumbNeedsRepaint());
-    EXPECT_FALSE(verticalScrollbar->trackNeedsRepaint());
-    EXPECT_FALSE(verticalScrollbar->thumbNeedsRepaint());
-}
-
 } // namespace blink

third_party/WebKit/Source/platform/scroll/Scrollbar.cpp

@@ -126,27 +126,19 @@ bool Scrollbar::isLeftSideVerticalScrollbar() const
     return false;
 }
 
-bool Scrollbar::offsetDidChange()
+void Scrollbar::offsetDidChange()
 {
     ASSERT(m_scrollableArea);
 
     float position = scrollableAreaCurrentPos();
     if (position == m_currentPos)
-        return false;
+        return;
 
-    float oldPosition = m_currentPos;
     int oldThumbPosition = theme().thumbPosition(*this);
     m_currentPos = position;
-
-    ScrollbarPart invalidParts = theme().invalidateOnThumbPositionChange(
-        *this, oldPosition, position);
-    if (invalidParts != NoPart)
-        setNeedsPaintInvalidation(invalidParts);
-
+    updateThumbPosition();
     if (m_pressedPart == ThumbPart)
         setPressedPos(m_pressedPos + theme().thumbPosition(*this) - oldThumbPosition);
-
-    return true;
 }
 
 void Scrollbar::disconnectFromScrollableArea()
@@ -162,9 +154,24 @@ void Scrollbar::setProportion(int visibleSize, int totalSize)
     m_visibleSize = visibleSize;
     m_totalSize = totalSize;
 
+    updateThumbProportion();
+}
+
+void Scrollbar::updateThumb()
+{
     setNeedsPaintInvalidation();
 }
 
+void Scrollbar::updateThumbPosition()
+{
+    updateThumb();
+}
+
+void Scrollbar::updateThumbProportion()
+{
+    updateThumb();
+}
+
 void Scrollbar::paint(GraphicsContext& context, const CullRect& cullRect) const
 {
     if (!cullRect.intersectsCullRect(frameRect()))
@@ -310,7 +317,7 @@ void Scrollbar::setHoveredPart(ScrollbarPart part)
     if (((m_hoveredPart == NoPart || part == NoPart) && theme().invalidateOnMouseEnterExit())
         // When there's a pressed part, we don't draw a hovered state, so there's no reason to invalidate.
         || m_pressedPart == NoPart)
-        setNeedsPaintInvalidation(static_cast<ScrollbarPart>(m_hoveredPart | part));
+        setNeedsPaintInvalidation();
 
     m_hoveredPart = part;
 }
@@ -320,7 +327,7 @@ void Scrollbar::setPressedPart(ScrollbarPart part)
     if (m_pressedPart != NoPart
         // When we no longer have a pressed part, we can start drawing a hovered state on the hovered part.
         || m_hoveredPart != NoPart)
-        setNeedsPaintInvalidation(static_cast<ScrollbarPart>(m_pressedPart | m_hoveredPart | part));
+        setNeedsPaintInvalidation();
     m_pressedPart = part;
 }
 
@@ -555,14 +562,12 @@ float Scrollbar::scrollableAreaCurrentPos() const
     return m_scrollableArea->scrollPosition().y() - m_scrollableArea->minimumScrollPosition().y();
 }
 
-void Scrollbar::setNeedsPaintInvalidation(ScrollbarPart parts)
+void Scrollbar::setNeedsPaintInvalidation()
 {
-    if (m_theme.shouldRepaintAllPartsOnInvalidation())
-        parts = AllParts;
-    if (parts & ~ThumbPart)
+    if (m_theme.shouldRepaintAllPartsOnInvalidation()) {
         m_trackNeedsRepaint = true;
-    if (parts & ThumbPart)
         m_thumbNeedsRepaint = true;
+    }
     if (m_scrollableArea)
         m_scrollableArea->setScrollbarNeedsPaintInvalidation(orientation());
 }

third_party/WebKit/Source/platform/scroll/Scrollbar.h

@@ -94,15 +94,7 @@ public:
     void setEnabled(bool) override;
 
     // Called by the ScrollableArea when the scroll offset changes.
-    //
-    // Will invalidate the scrollbar if either the track or the thumb is
-    // invalidated. The caller is responsible for issuing paint invalidations
-    // when only the thumb position changes, as the scrollbar is unaware of
-    // whether the thumb can be moved without repainting.
-    //
-    // Returns true if the scrollbar's offset was actually updated, so that the
-    // caller can issue additional invalidations as needed.
-    bool offsetDidChange();
+    void offsetDidChange();
 
     void disconnectFromScrollableArea();
     ScrollableArea* scrollableArea() const { return m_scrollableArea; }
@@ -149,7 +141,6 @@ public:
     float elasticOverscroll() const override { return m_elasticOverscroll; }
     void setElasticOverscroll(float elasticOverscroll) override { m_elasticOverscroll = elasticOverscroll; }
 
-    // Use setNeedsPaintInvalidation to cause scrollbar parts to repaint.
     bool trackNeedsRepaint() const { return m_trackNeedsRepaint; }
     void setTrackNeedsRepaint(bool trackNeedsRepaint) { m_trackNeedsRepaint = trackNeedsRepaint; }
     bool thumbNeedsRepaint() const { return m_thumbNeedsRepaint; }
@@ -163,9 +154,7 @@ public:
     // TODO(chrishtr): fix this.
     IntRect visualRect() const override { return IntRect(); }
 
-    // Marks the specified parts of the scrollbar as needing paint invalidation.
-    // Uses the associated ScrollableArea to cause invalidation.
-    void setNeedsPaintInvalidation(ScrollbarPart = AllParts);
+    void setNeedsPaintInvalidation();
 
     // Promptly unregister from the theme manager + run finalizers of derived Scrollbars.
     EAGERLY_FINALIZE();
@@ -177,6 +166,7 @@ public:
 protected:
     Scrollbar(ScrollableArea*, ScrollbarOrientation, ScrollbarControlSize, ScrollbarTheme* = 0);
 
+    void updateThumb();
 
     void autoscrollTimerFired(Timer<Scrollbar>*);
     void startTimerIfNeeded(double delay);
@@ -217,6 +207,9 @@ private:
 
     float scrollableAreaCurrentPos() const;
 
+    void updateThumbPosition();
+    void updateThumbProportion();
+
     bool m_trackNeedsRepaint;
     bool m_thumbNeedsRepaint;
 };

third_party/WebKit/Source/platform/scroll/ScrollbarTheme.h

@@ -70,7 +70,6 @@ public:
 
     virtual bool invalidateOnMouseEnterExit() { return false; }
     virtual bool invalidateOnWindowActiveChange() const { return false; }
-    virtual ScrollbarPart invalidateOnThumbPositionChange(const ScrollbarThemeClient&, float oldPosition, float newPosition) const { return AllParts; }
 
     virtual void paintScrollCorner(GraphicsContext&, const DisplayItemClient&, const IntRect& cornerRect);
     virtual void paintTickmarks(GraphicsContext&, const ScrollbarThemeClient&, const IntRect&) { }

third_party/WebKit/Source/platform/scroll/ScrollbarThemeAura.cpp

@@ -43,89 +43,11 @@
 
 namespace blink {
 
-namespace {
-
 static bool useMockTheme()
 {
     return LayoutTestSupport::isRunningLayoutTest();
 }
 
-// Contains a flag indicating whether WebThemeEngine should paint a UI widget
-// for a scrollbar part, and if so, what part and state apply.
-//
-// If the PartPaintingParams are not affected by a change in the scrollbar
-// state, then the corresponding scrollbar part does not need to be repainted.
-struct PartPaintingParams {
-    PartPaintingParams()
-        : shouldPaint(false)
-        , part(WebThemeEngine::PartScrollbarDownArrow)
-        , state(WebThemeEngine::StateNormal) {}
-    PartPaintingParams(WebThemeEngine::Part part, WebThemeEngine::State state)
-        : shouldPaint(true)
-        , part(part)
-        , state(state) {}
-
-    bool shouldPaint;
-    WebThemeEngine::Part part;
-    WebThemeEngine::State state;
-};
-
-bool operator==(const PartPaintingParams& a, const PartPaintingParams& b)
-{
-    return (!a.shouldPaint && !b.shouldPaint) || std::tie(a.shouldPaint, a.part, a.state) == std::tie(b.shouldPaint, b.part, b.state);
-}
-
-bool operator!=(const PartPaintingParams& a, const PartPaintingParams& b)
-{
-    return !(a == b);
-}
-
-PartPaintingParams buttonPartPaintingParams(const ScrollbarThemeClient& scrollbar, float position, ScrollbarPart part)
-{
-    WebThemeEngine::Part paintPart;
-    WebThemeEngine::State state = WebThemeEngine::StateNormal;
-    bool checkMin = false;
-    bool checkMax = false;
-
-    if (scrollbar.orientation() == HorizontalScrollbar) {
-        if (part == BackButtonStartPart) {
-            paintPart = WebThemeEngine::PartScrollbarLeftArrow;
-            checkMin = true;
-        } else if (useMockTheme() && part != ForwardButtonEndPart) {
-            return PartPaintingParams();
-        } else {
-            paintPart = WebThemeEngine::PartScrollbarRightArrow;
-            checkMax = true;
-        }
-    } else {
-        if (part == BackButtonStartPart) {
-            paintPart = WebThemeEngine::PartScrollbarUpArrow;
-            checkMin = true;
-        } else if (useMockTheme() && part != ForwardButtonEndPart) {
-            return PartPaintingParams();
-        } else {
-            paintPart = WebThemeEngine::PartScrollbarDownArrow;
-            checkMax = true;
-        }
-    }
-
-    if (useMockTheme() && !scrollbar.enabled()) {
-        state = WebThemeEngine::StateDisabled;
-    } else if (!useMockTheme() && ((checkMin && (position <= 0))
-        || (checkMax && position >= scrollbar.maximum()))) {
-        state = WebThemeEngine::StateDisabled;
-    } else {
-        if (part == scrollbar.pressedPart())
-            state = WebThemeEngine::StatePressed;
-        else if (part == scrollbar.hoveredPart())
-            state = WebThemeEngine::StateHover;
-    }
-
-    return PartPaintingParams(paintPart, state);
-}
-
-} // namespace
-
 ScrollbarTheme& ScrollbarTheme::nativeTheme()
 {
     if (RuntimeEnabledFeatures::overlayScrollbarsEnabled()) {
@@ -147,24 +69,6 @@ int ScrollbarThemeAura::scrollbarThickness(ScrollbarControlSize controlSize)
     return scrollbarSize.width();
 }
 
-bool ScrollbarThemeAura::shouldRepaintAllPartsOnInvalidation() const
-{
-    // This theme can separately handle thumb invalidation.
-    return false;
-}
-
-ScrollbarPart ScrollbarThemeAura::invalidateOnThumbPositionChange(const ScrollbarThemeClient& scrollbar, float oldPosition, float newPosition) const
-{
-    ScrollbarPart invalidParts = NoPart;
-    ASSERT(buttonsPlacement() == WebScrollbarButtonsPlacementSingle);
-    static const ScrollbarPart kButtonParts[] = {BackButtonStartPart, ForwardButtonEndPart};
-    for (ScrollbarPart part : kButtonParts) {
-        if (buttonPartPaintingParams(scrollbar, oldPosition, part) != buttonPartPaintingParams(scrollbar, newPosition, part))
-            invalidParts = static_cast<ScrollbarPart>(invalidParts | part);
-    }
-    return invalidParts;
-}
-
 void ScrollbarThemeAura::paintTrackPiece(GraphicsContext& gc, const ScrollbarThemeClient& scrollbar, const IntRect& rect, ScrollbarPart partType)
 {
     DisplayItem::Type displayItemType = trackPiecePartToDisplayItemType(partType);
@@ -190,14 +94,51 @@ void ScrollbarThemeAura::paintTrackPiece(GraphicsContext& gc, const ScrollbarThe
 
 void ScrollbarThemeAura::paintButton(GraphicsContext& gc, const ScrollbarThemeClient& scrollbar, const IntRect& rect, ScrollbarPart part)
 {
+    WebThemeEngine::Part paintPart;
+    WebThemeEngine::State state = WebThemeEngine::StateNormal;
+    bool checkMin = false;
+    bool checkMax = false;
+
+    if (scrollbar.orientation() == HorizontalScrollbar) {
+        if (part == BackButtonStartPart) {
+            paintPart = WebThemeEngine::PartScrollbarLeftArrow;
+            checkMin = true;
+        } else if (useMockTheme() && part != ForwardButtonEndPart) {
+            return;
+        } else {
+            paintPart = WebThemeEngine::PartScrollbarRightArrow;
+            checkMax = true;
+        }
+    } else {
+        if (part == BackButtonStartPart) {
+            paintPart = WebThemeEngine::PartScrollbarUpArrow;
+            checkMin = true;
+        } else if (useMockTheme() && part != ForwardButtonEndPart) {
+            return;
+        } else {
+            paintPart = WebThemeEngine::PartScrollbarDownArrow;
+            checkMax = true;
+        }
+    }
+
     DisplayItem::Type displayItemType = buttonPartToDisplayItemType(part);
     if (DrawingRecorder::useCachedDrawingIfPossible(gc, scrollbar, displayItemType))
         return;
-    PartPaintingParams params = buttonPartPaintingParams(scrollbar, scrollbar.currentPos(), part);
-    if (!params.shouldPaint)
-        return;
+
     DrawingRecorder recorder(gc, scrollbar, displayItemType, rect);
-    Platform::current()->themeEngine()->paint(gc.canvas(), params.part, params.state, WebRect(rect), 0);
+
+    if (useMockTheme() && !scrollbar.enabled()) {
+        state = WebThemeEngine::StateDisabled;
+    } else if (!useMockTheme() && ((checkMin && (scrollbar.currentPos() <= 0))
+        || (checkMax && scrollbar.currentPos() >= scrollbar.maximum()))) {
+        state = WebThemeEngine::StateDisabled;
+    } else {
+        if (part == scrollbar.pressedPart())
+            state = WebThemeEngine::StatePressed;
+        else if (part == scrollbar.hoveredPart())
+            state = WebThemeEngine::StateHover;
+    }
+    Platform::current()->themeEngine()->paint(gc.canvas(), paintPart, state, WebRect(rect), 0);
 }
 
 void ScrollbarThemeAura::paintThumb(GraphicsContext& gc, const ScrollbarThemeClient& scrollbar, const IntRect& rect)

third_party/WebKit/Source/platform/scroll/ScrollbarThemeAura.h

@@ -40,8 +40,6 @@ public:
     int scrollbarThickness(ScrollbarControlSize) override;
 
 protected:
-    bool shouldRepaintAllPartsOnInvalidation() const override;
-    ScrollbarPart invalidateOnThumbPositionChange(const ScrollbarThemeClient&, float oldPosition, float newPosition) const override;
     void paintTrackPiece(GraphicsContext&, const ScrollbarThemeClient&, const IntRect&, ScrollbarPart) override;
     void paintButton(GraphicsContext&, const ScrollbarThemeClient&, const IntRect&, ScrollbarPart) override;
     void paintThumb(GraphicsContext&, const ScrollbarThemeClient&, const IntRect&) override;

third_party/WebKit/Source/platform/scroll/ScrollbarThemeMacOverlayAPI.h

@@ -40,7 +40,6 @@ namespace blink {
 class PLATFORM_EXPORT ScrollbarThemeMacOverlayAPI : public ScrollbarThemeMacCommon {
 public:
     bool shouldRepaintAllPartsOnInvalidation() const override { return false; }
-    ScrollbarPart invalidateOnThumbPositionChange(const ScrollbarThemeClient&, float oldPosiiton, float newPosition) const override;
     void updateEnabledState(const ScrollbarThemeClient&) override;
     int scrollbarThickness(ScrollbarControlSize = RegularScrollbar) override;
     bool usesOverlayScrollbars() const override;

third_party/WebKit/Source/platform/scroll/ScrollbarThemeMacOverlayAPI.mm

@@ -274,11 +274,5 @@ float ScrollbarThemeMacOverlayAPI::thumbOpacity(const ScrollbarThemeClient& scro
     return [scrollbarPainter knobAlpha];
 }
 
-ScrollbarPart ScrollbarThemeMacOverlayAPI::invalidateOnThumbPositionChange(const ScrollbarThemeClient& scrollbar, float oldPosition, float newPosition) const
-{
-    // ScrollAnimatorMac will invalidate the thumb when appropriate.
-    return NoPart;
-}
-
 } // namespace blink