Replace various ScrollableArea scroll methods with setScrollPosition

Source/core/frame/RootFrameViewportTest.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "core/frame/RootFrameViewport.h"
 
 #include "core/layout/ScrollAlignment.h"
 #include "platform/geometry/DoubleRect.h"
@@ skipping 38 matching lines @@
         IntSize scrollDimensions = maximumScrollPosition() - minimumScrollPosition();
         return (orientation == HorizontalScrollbar) ? scrollDimensions.width() : scrollDimensions.height();
     }
 
     void setUserInputScrollable(bool x, bool y)
     {
         m_userInputScrollableX = x;
         m_userInputScrollableY = y;
     }
 
-    void setScrollPosition(const DoublePoint& pos, ScrollBehavior = ScrollBehaviorInstant) override { scrollToOffsetWithoutAnimation(toFloatPoint(pos)); }
     IntPoint scrollPosition() const override { return flooredIntPoint(m_scrollPosition); }
     DoublePoint scrollPositionDouble() const override { return m_scrollPosition; }
     IntPoint minimumScrollPosition() const override { return IntPoint(); }
     DoublePoint minimumScrollPositionDouble() const override { return DoublePoint(); }
     IntPoint maximumScrollPosition() const override { return flooredIntPoint(maximumScrollPositionDouble()); }
 
     IntSize contentsSize() const override { return m_contentsSize; }
     void setContentSize(const IntSize& contentsSize)
     {
         m_contentsSize = contentsSize;
     }
 
 protected:
-    void setScrollOffset(const IntPoint& offset) override { m_scrollPosition = offset; }
-    void setScrollOffset(const DoublePoint& offset) override { m_scrollPosition = offset; }
+    void setScrollOffset(const IntPoint& offset, ScrollType) override { m_scrollPosition = offset; }
+    void setScrollOffset(const DoublePoint& offset, ScrollType) override { m_scrollPosition = offset; }
     bool shouldUseIntegerScrollOffset() const override { return true; }
     bool isActive() const override { return true; }
     bool isScrollCornerVisible() const override { return true; }
     IntRect scrollCornerRect() const override { return IntRect(); }
     bool scrollbarsCanBeActive() const override { return true; }
     IntRect scrollableAreaBoundingBox() const override { return IntRect(); }
     bool shouldPlaceVerticalScrollbarOnLeft() const override { return true; }
     void invalidateScrollbarRect(Scrollbar*, const IntRect&) override { }
     void invalidateScrollCornerRect(const IntRect&) override { }
     GraphicsLayer* layerForContainer() const override { return nullptr; }
@@ skipping 106 matching lines @@
 
     // Layout viewport shouldn't scroll since it's not horizontally scrollable,
     // but visual viewport should.
     rootFrameViewport->userScroll(ScrollRight, ScrollByPixel, 300);
     EXPECT_POINT_EQ(DoublePoint(0, 0), layoutViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(50, 0), visualViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(50, 0), rootFrameViewport->scrollPositionDouble());
 
     // Disable just the visual viewport's horizontal scrolling, only the layout
     // viewport should scroll.
-    rootFrameViewport->setScrollPosition(DoublePoint());
+    rootFrameViewport->setScrollPosition(DoublePoint(), ProgrammaticScroll);
     layoutViewport.setUserInputScrollable(true, true);
     visualViewport.setUserInputScrollable(false, true);
 
     rootFrameViewport->userScroll(ScrollRight, ScrollByPixel, 300);
     EXPECT_POINT_EQ(DoublePoint(100, 0), layoutViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 0), visualViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(100, 0), rootFrameViewport->scrollPositionDouble());
 
     // Disable both viewports' horizontal scrolling, all horizontal scrolling
     // should now be blocked.
-    rootFrameViewport->setScrollPosition(DoublePoint());
+    rootFrameViewport->setScrollPosition(DoublePoint(), ProgrammaticScroll);
     layoutViewport.setUserInputScrollable(false, true);
     visualViewport.setUserInputScrollable(false, true);
 
     rootFrameViewport->userScroll(ScrollRight, ScrollByPixel, 300);
     EXPECT_POINT_EQ(DoublePoint(0, 0), layoutViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 0), visualViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 0), rootFrameViewport->scrollPositionDouble());
 
     EXPECT_FALSE(rootFrameViewport->userInputScrollable(HorizontalScrollbar));
     EXPECT_TRUE(rootFrameViewport->userInputScrollable(VerticalScrollbar));
 
     // Vertical scrolling should be unaffected.
     rootFrameViewport->userScroll(ScrollDown, ScrollByPixel, 300);
     EXPECT_POINT_EQ(DoublePoint(0, 150), layoutViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 75), visualViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 225), rootFrameViewport->scrollPositionDouble());
 
     // Try the same checks as above but for the vertical direction.
     // ===============================================
 
-    rootFrameViewport->setScrollPosition(DoublePoint());
+    rootFrameViewport->setScrollPosition(DoublePoint(), ProgrammaticScroll);
 
     // Disable just the layout viewport's vertical scrolling, the
     // RootFrameViewport should remain scrollable overall.
     layoutViewport.setUserInputScrollable(true, false);
     visualViewport.setUserInputScrollable(true, true);
 
     EXPECT_TRUE(rootFrameViewport->userInputScrollable(HorizontalScrollbar));
     EXPECT_TRUE(rootFrameViewport->userInputScrollable(VerticalScrollbar));
 
     // Layout viewport shouldn't scroll since it's not vertically scrollable,
     // but visual viewport should.
     rootFrameViewport->userScroll(ScrollDown, ScrollByPixel, 300);
     EXPECT_POINT_EQ(DoublePoint(0, 0), layoutViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 75), visualViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 75), rootFrameViewport->scrollPositionDouble());
 
     // Disable just the visual viewport's vertical scrolling, only the layout
     // viewport should scroll.
-    rootFrameViewport->setScrollPosition(DoublePoint());
+    rootFrameViewport->setScrollPosition(DoublePoint(), ProgrammaticScroll);
     layoutViewport.setUserInputScrollable(true, true);
     visualViewport.setUserInputScrollable(true, false);
 
     rootFrameViewport->userScroll(ScrollDown, ScrollByPixel, 300);
     EXPECT_POINT_EQ(DoublePoint(0, 150), layoutViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 0), visualViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 150), rootFrameViewport->scrollPositionDouble());
 
     // Disable both viewports' horizontal scrolling, all vertical scrolling
     // should now be blocked.
-    rootFrameViewport->setScrollPosition(DoublePoint());
+    rootFrameViewport->setScrollPosition(DoublePoint(), ProgrammaticScroll);
     layoutViewport.setUserInputScrollable(true, false);
     visualViewport.setUserInputScrollable(true, false);
 
     rootFrameViewport->userScroll(ScrollDown, ScrollByPixel, 300);
     EXPECT_POINT_EQ(DoublePoint(0, 0), layoutViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 0), visualViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 0), rootFrameViewport->scrollPositionDouble());
 
     EXPECT_TRUE(rootFrameViewport->userInputScrollable(HorizontalScrollbar));
     EXPECT_FALSE(rootFrameViewport->userInputScrollable(VerticalScrollbar));
@@ skipping 12 matching lines @@
 {
     IntSize viewportSize(100, 150);
     RootFrameViewStub layoutViewport(viewportSize, IntSize(200, 300));
     VisualViewportStub visualViewport(viewportSize, viewportSize);
 
     OwnPtr<ScrollableArea> rootFrameViewport =
         RootFrameViewport::create(visualViewport, layoutViewport);
 
     visualViewport.setScale(2);
 
-    visualViewport.setScrollPosition(DoublePoint(50, 75));
+    visualViewport.setScrollPosition(DoublePoint(50, 75), ProgrammaticScroll);
     EXPECT_POINT_EQ(DoublePoint(50, 75), rootFrameViewport->scrollPositionDouble());
 
     // If the scroll animator doesn't update, it will still think it's at (0, 0) and so it
     // may early exit.
-    rootFrameViewport->setScrollPosition(DoublePoint(0, 0));
+    rootFrameViewport->setScrollPosition(DoublePoint(0, 0), ProgrammaticScroll);
     EXPECT_POINT_EQ(DoublePoint(0, 0), rootFrameViewport->scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 0), visualViewport.scrollPositionDouble());
 
     // Try again for scroll()
-    visualViewport.setScrollPosition(DoublePoint(50, 75));
+    visualViewport.setScrollPosition(DoublePoint(50, 75), ProgrammaticScroll);
     EXPECT_POINT_EQ(DoublePoint(50, 75), rootFrameViewport->scrollPositionDouble());
 
     rootFrameViewport->userScroll(ScrollLeft, ScrollByPixel, 50);
     EXPECT_POINT_EQ(DoublePoint(0, 75), rootFrameViewport->scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 75), visualViewport.scrollPositionDouble());
 
     // Try again for handleWheel.
-    visualViewport.setScrollPosition(DoublePoint(50, 75));
+    visualViewport.setScrollPosition(DoublePoint(50, 75), ProgrammaticScroll);
     EXPECT_POINT_EQ(DoublePoint(50, 75), rootFrameViewport->scrollPositionDouble());
 
     PlatformWheelEvent wheelEvent(
         IntPoint(10, 10), IntPoint(10, 10),
         50, 75,
         0, 0,
         ScrollByPixelWheelEvent,
         false, false, false, false);
     rootFrameViewport->handleWheel(wheelEvent);
     EXPECT_POINT_EQ(DoublePoint(0, 0), rootFrameViewport->scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 0), visualViewport.scrollPositionDouble());
 
     // Make sure the layout viewport is also accounted for.
-    layoutViewport.setScrollPosition(DoublePoint(100, 150));
+    layoutViewport.setScrollPosition(DoublePoint(100, 150), ProgrammaticScroll);
     EXPECT_POINT_EQ(DoublePoint(100, 150), rootFrameViewport->scrollPositionDouble());
 
     rootFrameViewport->userScroll(ScrollLeft, ScrollByPixel, 100);
     EXPECT_POINT_EQ(DoublePoint(0, 150), rootFrameViewport->scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 150), layoutViewport.scrollPositionDouble());
 }
 
 // Test that the scrollIntoView correctly scrolls the main frame
 // and pinch viewports such that the given rect is centered in the viewport.
 TEST_F(RootFrameViewportTest, ScrollIntoView)
@@ skipping 19 matching lines @@
     rootFrameViewport->scrollIntoView(
         LayoutRect(25, 75, 50, 50),
         ScrollAlignment::alignToEdgeIfNeeded,
         ScrollAlignment::alignToEdgeIfNeeded);
     EXPECT_POINT_EQ(DoublePoint(25, 25), layoutViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 50), visualViewport.scrollPositionDouble());
 
     // Reset the pinch viewport's size, scale the page and repeat the test
     visualViewport.setViewportSize(IntSize(100, 150));
     visualViewport.setScale(2);
-    rootFrameViewport->setScrollPosition(DoublePoint());
+    rootFrameViewport->setScrollPosition(DoublePoint(), ProgrammaticScroll);
 
     rootFrameViewport->scrollIntoView(
         LayoutRect(50, 75, 50, 75),
         ScrollAlignment::alignToEdgeIfNeeded,
         ScrollAlignment::alignToEdgeIfNeeded);
     EXPECT_POINT_EQ(DoublePoint(50, 75), layoutViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 0), visualViewport.scrollPositionDouble());
 
     rootFrameViewport->scrollIntoView(
         LayoutRect(190, 290, 10, 10),
         ScrollAlignment::alignToEdgeIfNeeded,
         ScrollAlignment::alignToEdgeIfNeeded);
     EXPECT_POINT_EQ(DoublePoint(100, 150), layoutViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(50, 75), visualViewport.scrollPositionDouble());
 
     // Scrolling into view the viewport rect itself should be a no-op.
     visualViewport.setViewportSize(IntSize(100, 100));
     visualViewport.setScale(1.5f);
-    visualViewport.setScrollPosition(DoublePoint(0, 10));
-    layoutViewport.setScrollPosition(DoublePoint(50, 50));
+    visualViewport.setScrollPosition(DoublePoint(0, 10), ProgrammaticScroll);
+    layoutViewport.setScrollPosition(DoublePoint(50, 50), ProgrammaticScroll);
     rootFrameViewport->notifyScrollPositionChanged(rootFrameViewport->scrollPositionDouble());
 
     rootFrameViewport->scrollIntoView(
         LayoutRect(rootFrameViewport->visibleContentRectDouble(ExcludeScrollbars)),
         ScrollAlignment::alignToEdgeIfNeeded,
         ScrollAlignment::alignToEdgeIfNeeded);
     EXPECT_POINT_EQ(DoublePoint(50, 50), layoutViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 10), visualViewport.scrollPositionDouble());
 
     rootFrameViewport->scrollIntoView(
@@ skipping 17 matching lines @@
     IntSize viewportSize(500, 500);
     RootFrameViewStub layoutViewport(viewportSize, IntSize(1000, 2000));
     VisualViewportStub visualViewport(viewportSize, viewportSize);
 
     OwnPtr<ScrollableArea> rootFrameViewport =
         RootFrameViewport::create(visualViewport, layoutViewport);
 
     visualViewport.setScale(2);
 
     // Ensure that the layout viewport scrolls first.
-    rootFrameViewport->setScrollPosition(DoublePoint(100, 100));
+    rootFrameViewport->setScrollPosition(DoublePoint(100, 100), ProgrammaticScroll);
     EXPECT_POINT_EQ(DoublePoint(0, 0), visualViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(100, 100), layoutViewport.scrollPositionDouble());
 
     // Scroll to the layout viewport's extent, the visual viewport should scroll the
     // remainder.
-    rootFrameViewport->setScrollPosition(DoublePoint(700, 1700));
+    rootFrameViewport->setScrollPosition(DoublePoint(700, 1700), ProgrammaticScroll);
     EXPECT_POINT_EQ(DoublePoint(200, 200), visualViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(500, 1500), layoutViewport.scrollPositionDouble());
 
     // Only the visual viewport should scroll further. Make sure it doesn't scroll
     // out of bounds.
-    rootFrameViewport->setScrollPosition(DoublePoint(780, 1780));
+    rootFrameViewport->setScrollPosition(DoublePoint(780, 1780), ProgrammaticScroll);
     EXPECT_POINT_EQ(DoublePoint(250, 250), visualViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(500, 1500), layoutViewport.scrollPositionDouble());
 
     // Scroll all the way back.
-    rootFrameViewport->setScrollPosition(DoublePoint(0, 0));
+    rootFrameViewport->setScrollPosition(DoublePoint(0, 0), ProgrammaticScroll);
     EXPECT_POINT_EQ(DoublePoint(0, 0), visualViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(0, 0), layoutViewport.scrollPositionDouble());
 }
 
 // Tests that the visible rect (i.e. visual viewport rect) is correctly
 // calculated, taking into account both viewports and page scale.
 TEST_F(RootFrameViewportTest, VisibleContentRect)
 {
     IntSize viewportSize(500, 401);
     RootFrameViewStub layoutViewport(viewportSize, IntSize(1000, 2000));
     VisualViewportStub visualViewport(viewportSize, viewportSize);
 
     OwnPtr<ScrollableArea> rootFrameViewport =
         RootFrameViewport::create(visualViewport, layoutViewport);
 
-    rootFrameViewport->setScrollPosition(DoublePoint(100, 75));
+    rootFrameViewport->setScrollPosition(DoublePoint(100, 75), ProgrammaticScroll);
 
     EXPECT_POINT_EQ(DoublePoint(100, 75), rootFrameViewport->visibleContentRect().location());
     EXPECT_POINT_EQ(DoublePoint(100, 75), rootFrameViewport->visibleContentRectDouble().location());
     EXPECT_SIZE_EQ(DoubleSize(500, 401), rootFrameViewport->visibleContentRect().size());
     EXPECT_SIZE_EQ(DoubleSize(500, 401), rootFrameViewport->visibleContentRectDouble().size());
 
     visualViewport.setScale(2);
 
     EXPECT_POINT_EQ(DoublePoint(100, 75), rootFrameViewport->visibleContentRect().location());
     EXPECT_POINT_EQ(DoublePoint(100, 75), rootFrameViewport->visibleContentRectDouble().location());
@@ skipping 24 matching lines @@
     ScrollResult result = rootFrameViewport->handleWheel(wheelEvent);
 
     EXPECT_TRUE(result.didScroll());
     EXPECT_POINT_EQ(DoublePoint(50, 50), visualViewport.scrollPositionDouble());
     EXPECT_POINT_EQ(DoublePoint(100, 200), layoutViewport.scrollPositionDouble());
     EXPECT_EQ(-350, result.unusedScrollDeltaX);
     EXPECT_EQ(-250, result.unusedScrollDeltaY);
 }
 
 } // namespace blink