Replace various ScrollableArea scroll methods with setScrollPosition

Source/platform/scroll/ScrollableArea.cpp

 /*
  * Copyright (c) 2010, Google Inc. All rights reserved.
  * 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 140 matching lines @@
         step = pixelStep(orientation);
         break;
     }
 
     if (direction == ScrollUp || direction == ScrollLeft)
         delta = -delta;
 
     return scrollAnimator()->userScroll(orientation, granularity, step, delta).didScroll;
 }
 
-void ScrollableArea::setScrollPosition(const DoublePoint& position, ScrollBehavior behavior)
+void ScrollableArea::setScrollPosition(const DoublePoint& position, ScrollType scrollType, ScrollBehavior behavior)
 {
-    // FIXME(417782): This should be unified with LayerScrollableArea::scrollToOffset.
-    ASSERT_NOT_REACHED();
+    if (behavior == ScrollBehaviorAuto)
+        behavior = scrollBehaviorStyle();
+
+    if (scrollType == CompositorScroll)
+        scrollAnimator()->scrollToOffsetWithoutAnimation(toFloatPoint(position), CompositorScroll);
+    else if (scrollType == ProgrammaticScroll)
+        programmaticScrollHelper(position, behavior);
+    else if (scrollType == UserScroll)
+        userScrollHelper(position, behavior);
+    else
+        ASSERT_NOT_REACHED();
 }
 
-void ScrollableArea::scrollToOffsetWithoutAnimation(const FloatPoint& offset, bool cancelProgrammaticAnimations)
+void ScrollableArea::scrollBy(const DoubleSize& delta, ScrollType type, ScrollBehavior behavior)
 {
-    if (cancelProgrammaticAnimations)
-        cancelProgrammaticScrollAnimation();
-    scrollAnimator()->scrollToOffsetWithoutAnimation(offset);
+    setScrollPosition(scrollPositionDouble() + delta, type, behavior);
 }
 
-void ScrollableArea::scrollToOffsetWithoutAnimation(ScrollbarOrientation orientation, float offset)
+void ScrollableArea::setScrollPositionSingleAxis(ScrollbarOrientation orientation, double position, ScrollType scrollType, ScrollBehavior behavior)
 {
+    DoublePoint newPosition;
     if (orientation == HorizontalScrollbar)
-        scrollToOffsetWithoutAnimation(FloatPoint(offset, scrollAnimator()->currentPosition().y()));
+        newPosition = DoublePoint(position, scrollAnimator()->currentPosition().y());
     else
-        scrollToOffsetWithoutAnimation(FloatPoint(scrollAnimator()->currentPosition().x(), offset));
+        newPosition = DoublePoint(scrollAnimator()->currentPosition().x(), position);
+
+    // TODO(bokan): Note, this doesn't use the derived class versions since this method is currently used
+    // exclusively by code that adjusts the position by the scroll origin and the derived class versions
+    // differ on whether they take that into account or not.
+    ScrollableArea::setScrollPosition(newPosition, scrollType, behavior);
+}
+
+void ScrollableArea::programmaticScrollHelper(const DoublePoint& position, ScrollBehavior scrollBehavior)
+{
+    if (scrollBehavior == ScrollBehaviorSmooth) {
+        if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
+            scrollAnimator->cancelAnimations();
+        programmaticScrollAnimator()->animateToOffset(toFloatPoint(position));
+    } else {
+        // TODO(bokan): This should probably use programmaticScrollAnimator.
+        cancelProgrammaticScrollAnimation();
+        scrollAnimator()->scrollToOffsetWithoutAnimation(toFloatPoint(position), ProgrammaticScroll);
+    }
+}
+
+void ScrollableArea::userScrollHelper(const DoublePoint& position, ScrollBehavior scrollBehavior)
+{
+    if (scrollBehavior == ScrollBehaviorSmooth) {
+        // TODO(bokan)

[skobes, 2015/06/04 23:35:47]

Is ScrollableArea::userScroll eventually going to use this path?

[bokan, 2015/06/05 15:15:24]

That's my hope. It can't right now since it doesn't work on just a simple delta.
Untangling that will be a CL in its own right.

+    } else {
+        cancelProgrammaticScrollAnimation();
+        scrollAnimator()->scrollToOffsetWithoutAnimation(toFloatPoint(position), UserScroll);
+    }
 }
 
 void ScrollableArea::scrollIntoRect(const LayoutRect& rectInContent, const FloatRect& targetRectInFrame)
 {
     // Use |pixelSnappedIntRect| for rounding to pixel as opposed to |enclosingIntRect|. It gives a better
     // combined (location and size) rounding error resulting in a more accurate scroll offset.
     // FIXME: It would probably be best to do the whole calculation in LayoutUnits but contentsToRootFrame
     // and friends don't have LayoutRect/Point versions yet.
     IntRect boundsInContent = pixelSnappedIntRect(rectInContent);
     IntRect boundsInFrame(boundsInContent.location() - toIntSize(scrollPosition()), boundsInContent.size());
 
     int centeringOffsetX = (targetRectInFrame.width() - boundsInFrame.width()) / 2;
     int centeringOffsetY = (targetRectInFrame.height() - boundsInFrame.height()) / 2;
 
     IntSize scrollDelta(
         boundsInFrame.x() - centeringOffsetX - targetRectInFrame.x(),
         boundsInFrame.y() - centeringOffsetY - targetRectInFrame.y());
 
     DoublePoint targetOffset = DoublePoint(scrollPosition() + scrollDelta);
 
-    setScrollPosition(targetOffset);
+    setScrollPosition(targetOffset, ProgrammaticScroll);
 }
 
 LayoutRect ScrollableArea::scrollIntoView(const LayoutRect& rectInContent, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
 {
     // TODO(bokan): This should really be implemented here but ScrollAlignment is in Core which is a dependency violation.
     ASSERT_NOT_REACHED();
     return LayoutRect();
 }
 
-void ScrollableArea::programmaticallyScrollSmoothlyToOffset(const FloatPoint& offset)
-{
-    if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
-        scrollAnimator->cancelAnimations();
-    programmaticScrollAnimator()->animateToOffset(offset);
-}
-
 void ScrollableArea::notifyScrollPositionChanged(const DoublePoint& position)
 {
-    scrollPositionChanged(position);
+    // TODO(bokan): This should probably be something other than CompositorScroll.
+    scrollPositionChanged(position, CompositorScroll);
     scrollAnimator()->setCurrentPosition(toFloatPoint(scrollPositionDouble()));
 }
 
-void ScrollableArea::scrollPositionChanged(const DoublePoint& position)
+void ScrollableArea::scrollPositionChanged(const DoublePoint& position, ScrollType scrollType)
 {
     TRACE_EVENT0("blink", "ScrollableArea::scrollPositionChanged");
 
     DoublePoint oldPosition = scrollPositionDouble();
     // Tell the derived class to scroll its contents.
-    setScrollOffset(position);
+    setScrollOffset(position, scrollType);
 
     Scrollbar* verticalScrollbar = this->verticalScrollbar();
 
     // Tell the scrollbars to update their thumb postions.
     if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
         horizontalScrollbar->offsetDidChange();
         if (horizontalScrollbar->isOverlayScrollbar() && !hasLayerForHorizontalScrollbar()) {
             if (!verticalScrollbar)
                 horizontalScrollbar->invalidate();
             else {
@@ skipping 56 matching lines @@
     if (!constrainsScrollingToContentEdge())
         return scrollPoint;
     DoublePoint newScrollPosition = scrollPoint.shrunkTo(maximumScrollPositionDouble());
     newScrollPosition = newScrollPosition.expandedTo(minimumScrollPositionDouble());
     return newScrollPosition;
 }
 
 // NOTE: Only called from Internals for testing.
 void ScrollableArea::setScrollOffsetFromInternals(const IntPoint& offset)
 {
-    setScrollOffsetFromAnimation(DoublePoint(offset));
+    setScrollOffsetFromAnimation(DoublePoint(offset), ProgrammaticScroll);
 }
 
-void ScrollableArea::setScrollOffsetFromAnimation(const DoublePoint& offset)
+void ScrollableArea::setScrollOffsetFromAnimation(const DoublePoint& offset, ScrollType scrollType)
 {
-    scrollPositionChanged(offset);
+    scrollPositionChanged(offset, scrollType);
 }
 
 void ScrollableArea::willStartLiveResize()
 {
     if (m_inLiveResize)
         return;
     m_inLiveResize = true;
     if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
         scrollAnimator->willStartLiveResize();
 }
@@ skipping 273 matching lines @@
         verticalScrollbarWidth = !verticalBar->isOverlayScrollbar() ? verticalBar->width() : 0;
     if (Scrollbar* horizontalBar = horizontalScrollbar())
         horizontalScrollbarHeight = !horizontalBar->isOverlayScrollbar() ? horizontalBar->height() : 0;
 
     return IntSize(std::max(0, size.width() - verticalScrollbarWidth),
         std::max(0, size.height() - horizontalScrollbarHeight));
 
 }
 
 } // namespace blink