Replace various ScrollableArea scroll methods with setScrollPosition

Source/platform/scroll/ScrollableArea.h

 /*
  * Copyright (C) 2008, 2011 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 55 matching lines @@
 
     // Convert a non-finite scroll value (Infinity, -Infinity, NaN) to 0 as
     // per http://dev.w3.org/csswg/cssom-view/#normalize-non_finite-values.
     static double normalizeNonFiniteScroll(double value) { return std::isfinite(value) ? value : 0.0; }
 
     // The window that hosts the ScrollableArea. The ScrollableArea will communicate scrolls and repaints to the
     // host window in the window's coordinate space.
     virtual HostWindow* hostWindow() const { return 0; };
 
     virtual ScrollResultOneDimensional userScroll(ScrollDirectionPhysical, ScrollGranularity, float delta = 1);
-    virtual void setScrollPosition(const DoublePoint&, ScrollBehavior = ScrollBehaviorInstant);
 
-    void scrollToOffsetWithoutAnimation(const FloatPoint&, bool cancelProgrammaticAnimations = true);
-    void scrollToOffsetWithoutAnimation(ScrollbarOrientation, float offset);
+    virtual void setScrollPosition(const DoublePoint&, ScrollType, ScrollBehavior = ScrollBehaviorInstant);
+    virtual void scrollBy(const DoubleSize&, ScrollType, ScrollBehavior = ScrollBehaviorInstant);
+    void setScrollPositionSingleAxis(ScrollbarOrientation, double, ScrollType, ScrollBehavior = ScrollBehaviorInstant);
 
     // Scrolls the area so that the given rect, given in the document's content coordinates, such that it's
     // visible in the area. Returns the new location of the input rect relative once again to the document.
     // Note, in the case of a Document container, such as FrameView, the output will always be the input rect
     // since scrolling it can't change the location of content relative to the document, unlike an overflowing
     // element.
     virtual LayoutRect scrollIntoView(const LayoutRect& rectInContent, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
 
     // Scrolls the area so that the given rect, given in the area's content coordinates, such that it's
     // cenetered in the second rect, which is given relative to the area's origin.
     void scrollIntoRect(const LayoutRect& rectInContent, const FloatRect& targetRectInFrame);
 
-    void programmaticallyScrollSmoothlyToOffset(const FloatPoint&);
-
     // Should be called when the scroll position changes externally, for example if the scroll layer position
     // is updated on the scrolling thread and we need to notify the main thread.
     void notifyScrollPositionChanged(const DoublePoint&);
 
     static bool scrollBehaviorFromString(const String&, ScrollBehavior&);
 
     virtual ScrollResult handleWheel(const PlatformWheelEvent&);
 
     // Functions for controlling if you can scroll past the end of the document.
     bool constrainsScrollingToContentEdge() const { return m_constrainsScrollingToContentEdge; }
@@ skipping 43 matching lines @@
     bool scrollOriginChanged() const { return m_scrollOriginChanged; }
 
 
     // This is used to determine whether the incoming fractional scroll offset should
     // be truncated to integer. Current rule is that if preferCompositingToLCDTextEnabled()
     // is disabled (which is true on low-dpi device by default) we should do the truncation.
     // The justification is that non-composited elements using fractional scroll offsets
     // is causing too much nasty bugs but does not add too benefit on low-dpi devices.
     virtual bool shouldUseIntegerScrollOffset() const { return !RuntimeEnabledFeatures::fractionalScrollOffsetsEnabled(); }
 
-    // FIXME(bokan): Meaningless name, rename to isActiveFocus
     virtual bool isActive() const = 0;
     virtual int scrollSize(ScrollbarOrientation) const = 0;
     virtual void invalidateScrollbar(Scrollbar*, const IntRect&);
     virtual bool isScrollCornerVisible() const = 0;
     virtual IntRect scrollCornerRect() const = 0;
     virtual void invalidateScrollCorner(const IntRect&);
     virtual void getTickmarks(Vector<IntRect>&) const { }
 
     // Convert points and rects between the scrollbar and its containing view.
     // The client needs to implement these in order to be aware of layout effects
@@ skipping 128 matching lines @@
     // TODO(bokan): FrameView::setScrollPosition uses updateScrollbars to scroll
     // which bails out early if its already in updateScrollbars, the effect being
     // that programmatic scrolls (i.e. setScrollPosition) are disabled when in
     // updateScrollbars. Expose this here to allow RootFrameViewport to match the
     // semantics for now but it should be cleaned up at the source.
     virtual bool isProgrammaticallyScrollable() { return true; }
 
     // Subtracts space occupied by this ScrollableArea's scrollbars.
     // Does nothing if overlay scrollbars are enabled.
     IntSize excludeScrollbars(const IntSize&) const;
-
 protected:
     ScrollableArea();
 
     void setScrollOrigin(const IntPoint&);
     void resetScrollOriginChanged() { m_scrollOriginChanged = false; }
 
 private:
-    void scrollPositionChanged(const DoublePoint&);
+    void scrollPositionChanged(const DoublePoint&, ScrollType);
 
     // NOTE: Only called from the ScrollAnimator.
     friend class ScrollAnimator;
-    void setScrollOffsetFromAnimation(const DoublePoint&);
+    void setScrollOffsetFromAnimation(const DoublePoint&, ScrollType);
+
+    void programmaticScrollHelper(const DoublePoint&, ScrollBehavior);
+    void userScrollHelper(const DoublePoint&, ScrollBehavior);
 
     // This function should be overriden by subclasses to perform the actual
     // scroll of the content. By default the DoublePoint version will just
     // call into the IntPoint version. If fractional scroll is needed, one
     // can override the DoublePoint version to take advantage of the double
     // precision scroll offset.
     // FIXME: Remove the IntPoint version. And change the function to
     // take DoubleSize. crbug.com/414283.
-    virtual void setScrollOffset(const IntPoint&) = 0;
-    virtual void setScrollOffset(const DoublePoint& offset)
+    virtual void setScrollOffset(const IntPoint&, ScrollType) = 0;
+    virtual void setScrollOffset(const DoublePoint& offset, ScrollType scrollType)
     {
-        setScrollOffset(flooredIntPoint(offset));
+        setScrollOffset(flooredIntPoint(offset), scrollType);
     }
 
     virtual int lineStep(ScrollbarOrientation) const;
     virtual int pageStep(ScrollbarOrientation) const;
     virtual int documentStep(ScrollbarOrientation) const;
     virtual float pixelStep(ScrollbarOrientation) const;
 
     // Stores the paint invalidations for the scrollbars during layout.
     IntRect m_horizontalBarDamage;
     IntRect m_verticalBarDamage;
@@ skipping 22 matching lines @@
     // vertical-lr / ltr            NO                      NO
     // vertical-lr / rtl            NO                      YES
     // vertical-rl / ltr            YES                     NO
     // vertical-rl / rtl            YES                     YES
     IntPoint m_scrollOrigin;
 };
 
 } // namespace blink
 
 #endif // ScrollableArea_h