Remove ScrollableArea::notifyScrollPositionChanged and cleanup scroll animators.

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 146 matching lines @@
 
     return scrollAnimator()->userScroll(orientation, granularity, step, delta);
 }
 
 void ScrollableArea::setScrollPosition(const DoublePoint& position, ScrollType scrollType, ScrollBehavior behavior)
 {
     if (behavior == ScrollBehaviorAuto)
         behavior = scrollBehaviorStyle();
 
     if (scrollType == CompositorScroll)
-        scrollAnimator()->scrollToOffsetWithoutAnimation(toFloatPoint(position), CompositorScroll);
+        scrollPositionChanged(adjustScrollPositionWithinRange(position), CompositorScroll);
     else if (scrollType == ProgrammaticScroll)
         programmaticScrollHelper(position, behavior);
     else if (scrollType == UserScroll)
         userScrollHelper(position, behavior);
     else
         ASSERT_NOT_REACHED();
 }
 
 void ScrollableArea::scrollBy(const DoubleSize& delta, ScrollType type, ScrollBehavior behavior)
 {
     setScrollPosition(scrollPositionDouble() + delta, type, behavior);
 }
 
 void ScrollableArea::setScrollPositionSingleAxis(ScrollbarOrientation orientation, double position, ScrollType scrollType, ScrollBehavior behavior)
 {
     DoublePoint newPosition;
     if (orientation == HorizontalScrollbar)
         newPosition = DoublePoint(position, scrollAnimator()->currentPosition().y());
     else
         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();
+    cancelScrollAnimation();
+
+    if (scrollBehavior == ScrollBehaviorSmooth)
         programmaticScrollAnimator()->animateToOffset(toFloatPoint(position));
-    } else {
-        // TODO(bokan): This should probably use programmaticScrollAnimator.
-        cancelProgrammaticScrollAnimation();
-        scrollAnimator()->scrollToOffsetWithoutAnimation(toFloatPoint(position), ProgrammaticScroll);
-    }
+    else
+        programmaticScrollAnimator()->scrollToOffsetWithoutAnimation(toFloatPoint(position));
 }
 
 void ScrollableArea::userScrollHelper(const DoublePoint& position, ScrollBehavior scrollBehavior)
 {
-    if (scrollBehavior == ScrollBehaviorSmooth) {
-        // TODO(bokan)
-    } else {
-        cancelProgrammaticScrollAnimation();
-        scrollAnimator()->scrollToOffsetWithoutAnimation(toFloatPoint(position), UserScroll);
-    }
+    cancelProgrammaticScrollAnimation();
+
+    // Smooth user scrolls (keyboard, wheel clicks) are handled via the userScroll method.
+    // TODO(bokan): The userScroll method should probably be modified to call this method
+    //              and ScrollAnimator to have a simpler animateToOffset method like the
+    //              ProgrammaticScrollAnimator.
+    ASSERT(scrollBehavior == ScrollBehaviorInstant);
+    scrollAnimator()->scrollToOffsetWithoutAnimation(toFloatPoint(position));
 }
 
 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());
@@ skipping 10 matching lines @@
     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::notifyScrollPositionChanged(const DoublePoint& position)
-{
-    // TODO(bokan): This should probably be something other than CompositorScroll.
-    scrollPositionChanged(position, CompositorScroll);
-    scrollAnimator()->setCurrentPosition(toFloatPoint(scrollPositionDouble()));
-}
-
 void ScrollableArea::scrollPositionChanged(const DoublePoint& position, ScrollType scrollType)
 {
     TRACE_EVENT0("blink", "ScrollableArea::scrollPositionChanged");
 
     DoublePoint oldPosition = scrollPositionDouble();
+    DoublePoint truncatedPosition = shouldUseIntegerScrollOffset() ? flooredIntPoint(position) : position;
+
     // Tell the derived class to scroll its contents.
-    setScrollOffset(position, scrollType);
+    setScrollOffset(truncatedPosition, 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 {
                 // If there is both a horizontalScrollbar and a verticalScrollbar,
                 // then we must also invalidate the corner between them.
                 IntRect boundsAndCorner = horizontalScrollbar->boundsRect();
                 boundsAndCorner.setWidth(boundsAndCorner.width() + verticalScrollbar->width());
                 horizontalScrollbar->invalidateRect(boundsAndCorner);
             }
         }
     }
     if (verticalScrollbar) {
         verticalScrollbar->offsetDidChange();
         if (verticalScrollbar->isOverlayScrollbar() && !hasLayerForVerticalScrollbar())
             verticalScrollbar->invalidate();
     }
 
     if (scrollPositionDouble() != oldPosition) {
         // FIXME: Pass in DoubleSize. crbug.com/414283.
         scrollAnimator()->notifyContentAreaScrolled(toFloatSize(scrollPositionDouble() - oldPosition));
     }
+
+    scrollAnimator()->setCurrentPosition(toFloatPoint(position));
 }
 
 bool ScrollableArea::scrollBehaviorFromString(const String& behaviorString, ScrollBehavior& behavior)
 {
     if (behaviorString == "auto")
         behavior = ScrollBehaviorAuto;
     else if (behaviorString == "instant")
         behavior = ScrollBehaviorInstant;
     else if (behaviorString == "smooth")
         behavior = ScrollBehaviorSmooth;
@@ skipping 28 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), ProgrammaticScroll);
-}
-
-void ScrollableArea::setScrollOffsetFromAnimation(const DoublePoint& offset, ScrollType scrollType)
-{
-    scrollPositionChanged(offset, scrollType);
+    scrollPositionChanged(DoublePoint(offset), ProgrammaticScroll);
 }
 
 void ScrollableArea::willStartLiveResize()
 {
     if (m_inLiveResize)
         return;
     m_inLiveResize = true;
     if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
         scrollAnimator->willStartLiveResize();
 }
@@ skipping 193 matching lines @@
     if (ProgrammaticScrollAnimator* programmaticScrollAnimator = existingProgrammaticScrollAnimator())
         programmaticScrollAnimator->updateCompositorAnimations();
 }
 
 void ScrollableArea::notifyCompositorAnimationFinished(int groupId)
 {
     if (ProgrammaticScrollAnimator* programmaticScrollAnimator = existingProgrammaticScrollAnimator())
         programmaticScrollAnimator->notifyCompositorAnimationFinished(groupId);
 }
 
+void ScrollableArea::cancelScrollAnimation()
+{
+    if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
+        scrollAnimator->cancelAnimations();
+}
+
 void ScrollableArea::cancelProgrammaticScrollAnimation()
 {
     if (ProgrammaticScrollAnimator* programmaticScrollAnimator = existingProgrammaticScrollAnimator())
         programmaticScrollAnimator->cancelAnimation();
 }
 
 DoubleRect ScrollableArea::visibleContentRectDouble(IncludeScrollbarsInRect scrollbarInclusion) const
 {
     return visibleContentRect(scrollbarInclusion);
 }
@@ skipping 60 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