Replace various ScrollableArea scroll methods with setScrollPosition

Source/core/frame/RootFrameViewport.cpp

 // Copyright 2015 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/frame/FrameView.h"
 #include "core/layout/ScrollAlignment.h"
 #include "platform/geometry/DoubleRect.h"
@@ skipping 50 matching lines @@
 bool RootFrameViewport::isScrollCornerVisible() const
 {
     return layoutViewport().isScrollCornerVisible();
 }
 
 IntRect RootFrameViewport::scrollCornerRect() const
 {
     return layoutViewport().scrollCornerRect();
 }
 
-void RootFrameViewport::setScrollPosition(const DoublePoint& position, ScrollBehavior scrollBehavior)
+void RootFrameViewport::setScrollPosition(const DoublePoint& position, ScrollType scrollType, ScrollBehavior scrollBehavior)
 {
     updateScrollAnimator();
 
     // TODO(bokan): Support smooth scrolling the visual viewport.
     if (scrollBehavior == ScrollBehaviorAuto)
-        scrollBehavior = layoutViewport().scrollBehaviorStyle();
+        scrollBehavior = scrollBehaviorStyle();
     if (scrollBehavior == ScrollBehaviorSmooth) {
-        layoutViewport().setScrollPosition(position, scrollBehavior);
+        layoutViewport().setScrollPosition(position, scrollType, scrollBehavior);
         return;
     }
 
-    if (!layoutViewport().isProgrammaticallyScrollable())
+    if (scrollType == ProgrammaticScroll && !layoutViewport().isProgrammaticallyScrollable())
         return;
 
     DoublePoint clampedPosition = clampScrollPosition(position);
-    scrollToOffsetWithoutAnimation(toFloatPoint(clampedPosition));
+    ScrollableArea::setScrollPosition(clampedPosition, scrollType, scrollBehavior);
+}
+
+ScrollBehavior RootFrameViewport::scrollBehaviorStyle() const
+{
+    return layoutViewport().scrollBehaviorStyle();
 }
 
 ScrollResult RootFrameViewport::handleWheel(const PlatformWheelEvent& event)
 {
     updateScrollAnimator();
 
     ScrollResult viewScrollResult(false);
     if (layoutViewport().isScrollable())
         viewScrollResult = layoutViewport().handleWheel(event);
 
     // The visual viewport will only accept pixel scrolls.
     if (!event.canScroll() || event.granularity() == ScrollByPageWheelEvent)
         return viewScrollResult;
 
     // Move the location by the negative of the remaining scroll delta.
     DoublePoint oldOffset = visualViewport().scrollPositionDouble();
     DoublePoint locationDelta;
     if (viewScrollResult.didScroll) {
         locationDelta = -DoublePoint(viewScrollResult.unusedScrollDeltaX, viewScrollResult.unusedScrollDeltaY);
     } else {
         if (event.railsMode() != PlatformEvent::RailsModeVertical)
             locationDelta.setX(-event.deltaX());
         if (event.railsMode() != PlatformEvent::RailsModeHorizontal)
             locationDelta.setY(-event.deltaY());
     }
 
     DoublePoint targetPosition = visualViewport().adjustScrollPositionWithinRange(
         visualViewport().scrollPositionDouble() + toDoubleSize(locationDelta));
-    visualViewport().scrollToOffsetWithoutAnimation(FloatPoint(targetPosition));
+    visualViewport().setScrollPosition(targetPosition, UserScroll);
 
     DoublePoint usedLocationDelta(visualViewport().scrollPositionDouble() - oldOffset);
     if (!viewScrollResult.didScroll && usedLocationDelta == DoublePoint::zero())
         return ScrollResult(false);
 
     DoubleSize unusedLocationDelta(locationDelta - usedLocationDelta);
     return ScrollResult(true, -unusedLocationDelta.width(), -unusedLocationDelta.height());
 }
 
 LayoutRect RootFrameViewport::scrollIntoView(const LayoutRect& rectInContent, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
@@ skipping 26 matching lines @@
     FloatRect visible =
         LayoutRect(visualViewport().scrollPositionDouble(), visualViewport().visibleContentRect().size());
 
     float centeringOffsetX = (visible.width() - targetViewport.width()) / 2;
     float centeringOffsetY = (visible.height() - targetViewport.height()) / 2;
 
     DoublePoint targetOffset(
         targetViewport.x() - centeringOffsetX,
         targetViewport.y() - centeringOffsetY);
 
-    setScrollPosition(targetOffset);
+    setScrollPosition(targetOffset, ProgrammaticScroll);
 
     // RootFrameViewport only changes the viewport relative to the document so we can't change the input
     // rect's location relative to the document origin.
     return rectInContent;
 }
 
-void RootFrameViewport::setScrollOffset(const IntPoint& offset)
+void RootFrameViewport::setScrollOffset(const IntPoint& offset, ScrollType scrollType)
 {
-    setScrollOffset(DoublePoint(offset));
+    setScrollOffset(DoublePoint(offset), scrollType);
 }
 
-void RootFrameViewport::setScrollOffset(const DoublePoint& offset)
+void RootFrameViewport::setScrollOffset(const DoublePoint& offset, ScrollType scrollType)
 {
     // Make sure we use the scroll positions as reported by each viewport's ScrollAnimator, since its
     // ScrollableArea's position may have the fractional part truncated off.
     DoublePoint oldPosition = scrollOffsetFromScrollAnimators();
 
     DoubleSize delta = offset - oldPosition;
 
     if (delta.isZero())
         return;
 
     DoublePoint targetPosition = layoutViewport().adjustScrollPositionWithinRange(layoutViewport().scrollAnimator()->currentPosition() + delta);
-    layoutViewport().scrollToOffsetWithoutAnimation(toFloatPoint(targetPosition));
+    layoutViewport().setScrollPosition(targetPosition, scrollType);
 
     DoubleSize applied = scrollOffsetFromScrollAnimators() - oldPosition;
     delta -= applied;
 
     if (delta.isZero())
         return;
 
     targetPosition = visualViewport().adjustScrollPositionWithinRange(visualViewport().scrollAnimator()->currentPosition() + delta);
-    visualViewport().scrollToOffsetWithoutAnimation(toFloatPoint(targetPosition));
+    visualViewport().setScrollPosition(targetPosition, scrollType);
 }
 
 IntPoint RootFrameViewport::scrollPosition() const
 {
     return flooredIntPoint(scrollPositionDouble());
 }
 
 DoublePoint RootFrameViewport::scrollPositionDouble() const
 {
     return layoutViewport().scrollPositionDouble() + toDoubleSize(visualViewport().scrollPositionDouble());
@@ skipping 102 matching lines @@
     return layoutViewport().hostWindow();
 }
 
 void RootFrameViewport::serviceScrollAnimations(double monotonicTime)
 {
     ScrollableArea::serviceScrollAnimations(monotonicTime);
     layoutViewport().serviceScrollAnimations(monotonicTime);
 }
 
 } // namespace blink