Use float for scroll offset.

third_party/WebKit/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 14 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/scroll/ScrollableArea.h"
 
 #include "platform/HostWindow.h"
-#include "platform/geometry/DoubleRect.h"
-#include "platform/geometry/FloatPoint.h"
-#include "platform/geometry/LayoutRect.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/scroll/MainThreadScrollingReason.h"
 #include "platform/scroll/ProgrammaticScrollAnimator.h"
 #include "platform/scroll/ScrollbarTheme.h"
 
 #include "platform/TraceEvent.h"
 
 static const int kPixelsPerLineStep = 40;
 static const float kMinFractionToStepWhenPaging = 0.875f;
 
@@ skipping 92 matching lines @@
     case ScrollByPixel:
     case ScrollByPrecisePixel:
       return pixelStep(orientation);
     default:
       ASSERT_NOT_REACHED();
       return 0.0f;
   }
 }
 
 ScrollResult ScrollableArea::userScroll(ScrollGranularity granularity,
-                                        const FloatSize& delta) {
+                                        const ScrollOffset& delta) {
   float stepX = scrollStep(granularity, HorizontalScrollbar);
   float stepY = scrollStep(granularity, VerticalScrollbar);
 
-  FloatSize pixelDelta(delta);
+  ScrollOffset pixelDelta(delta);
   pixelDelta.scale(stepX, stepY);
 
-  FloatSize scrollableAxisDelta(
+  ScrollOffset scrollableAxisDelta(
       userInputScrollable(HorizontalScrollbar) ? pixelDelta.width() : 0,
       userInputScrollable(VerticalScrollbar) ? pixelDelta.height() : 0);
 
   if (scrollableAxisDelta.isZero()) {
     return ScrollResult(false, false, pixelDelta.width(), pixelDelta.height());
   }
 
   cancelProgrammaticScrollAnimation();
 
   ScrollResult result = scrollAnimator().userScroll(granularity, pixelDelta);
 
   // Delta that wasn't scrolled because the axis is !userInputScrollable
   // should count as unusedScrollDelta.
-  FloatSize unscrollableAxisDelta = pixelDelta - scrollableAxisDelta;
+  ScrollOffset unscrollableAxisDelta = pixelDelta - scrollableAxisDelta;
   result.unusedScrollDeltaX += unscrollableAxisDelta.width();
   result.unusedScrollDeltaY += unscrollableAxisDelta.height();
 
   return result;
 }
 
-void ScrollableArea::setScrollPosition(const DoublePoint& position,
-                                       ScrollType scrollType,
-                                       ScrollBehavior behavior) {
-  DoublePoint clampedPosition = clampScrollPosition(position);
-  if (shouldUseIntegerScrollOffset())
-    clampedPosition = flooredIntPoint(clampedPosition);
-  if (clampedPosition == scrollPositionDouble())
+void ScrollableArea::setScrollOffset(const ScrollOffset& offset,
+                                     ScrollType scrollType,
+                                     ScrollBehavior behavior) {
+  ScrollOffset clampedOffset = clampScrollOffset(offset);
+  if (clampedOffset == scrollOffset())
     return;
 
   if (behavior == ScrollBehaviorAuto)
     behavior = scrollBehaviorStyle();
 
   switch (scrollType) {
     case CompositorScroll:
-      scrollPositionChanged(clampedPosition, scrollType);
+      scrollOffsetChanged(clampedOffset, scrollType);
       break;
     case AnchoringScroll:
-      scrollAnimator().adjustAnimationAndSetScrollPosition(clampedPosition,
-                                                           scrollType);
+      scrollAnimator().adjustAnimationAndSetScrollOffset(clampedOffset,
+                                                         scrollType);
       break;
     case ProgrammaticScroll:
-      programmaticScrollHelper(clampedPosition, behavior);
+      programmaticScrollHelper(clampedOffset, behavior);
       break;
     case UserScroll:
-      userScrollHelper(clampedPosition, behavior);
+      userScrollHelper(clampedOffset, behavior);
       break;
     default:
       ASSERT_NOT_REACHED();
   }
 }
 
-void ScrollableArea::scrollBy(const DoubleSize& delta,
+void ScrollableArea::scrollBy(const ScrollOffset& delta,
                               ScrollType type,
                               ScrollBehavior behavior) {
-  setScrollPosition(scrollPositionDouble() + delta, type, behavior);
+  setScrollOffset(scrollOffset() + delta, type, behavior);
 }
 
-void ScrollableArea::setScrollPositionSingleAxis(
-    ScrollbarOrientation orientation,
-    double position,
-    ScrollType scrollType,
-    ScrollBehavior behavior) {
-  DoublePoint newPosition;
+void ScrollableArea::setScrollOffsetSingleAxis(ScrollbarOrientation orientation,
+                                               float offset,
+                                               ScrollType scrollType,
+                                               ScrollBehavior behavior) {
+  ScrollOffset newOffset;
   if (orientation == HorizontalScrollbar)
-    newPosition = DoublePoint(position, scrollAnimator().currentPosition().y());
+    newOffset = ScrollOffset(offset, scrollAnimator().currentOffset().height());
   else
-    newPosition = DoublePoint(scrollAnimator().currentPosition().x(), position);
+    newOffset = ScrollOffset(scrollAnimator().currentOffset().width(), offset);
 
   // 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
+  // exclusively by code that adjusts the offset by the scroll origin and the derived class versions
   // differ on whether they take that into account or not.
-  ScrollableArea::setScrollPosition(newPosition, scrollType, behavior);
+  ScrollableArea::setScrollOffset(newOffset, scrollType, behavior);
 }
 
-void ScrollableArea::programmaticScrollHelper(const DoublePoint& position,
+void ScrollableArea::programmaticScrollHelper(const ScrollOffset& offset,
                                               ScrollBehavior scrollBehavior) {
   cancelScrollAnimation();
 
   if (scrollBehavior == ScrollBehaviorSmooth)
-    programmaticScrollAnimator().animateToOffset(toFloatPoint(position));
+    programmaticScrollAnimator().animateToOffset(offset);
   else
-    programmaticScrollAnimator().scrollToOffsetWithoutAnimation(
-        toFloatPoint(position));
+    programmaticScrollAnimator().scrollToOffsetWithoutAnimation(offset);
 }
 
-void ScrollableArea::userScrollHelper(const DoublePoint& position,
+void ScrollableArea::userScrollHelper(const ScrollOffset& offset,
                                       ScrollBehavior scrollBehavior) {
   cancelProgrammaticScrollAnimation();
 
-  double x = userInputScrollable(HorizontalScrollbar)
-                 ? position.x()
-                 : scrollAnimator().currentPosition().x();
-  double y = userInputScrollable(VerticalScrollbar)
-                 ? position.y()
-                 : scrollAnimator().currentPosition().y();
+  float x = userInputScrollable(HorizontalScrollbar)
+                ? offset.width()
+                : scrollAnimator().currentOffset().width();
+  float y = userInputScrollable(VerticalScrollbar)
+                ? offset.height()
+                : scrollAnimator().currentOffset().height();
 
   // 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 ScrollAnimatorBase to have a simpler animateToOffset method like the
   //              ProgrammaticScrollAnimator.
   ASSERT(scrollBehavior == ScrollBehaviorInstant);
-  scrollAnimator().scrollToOffsetWithoutAnimation(FloatPoint(x, y));
+  scrollAnimator().scrollToOffsetWithoutAnimation(ScrollOffset(x, y));
 }
 
 LayoutRect ScrollableArea::scrollIntoView(const LayoutRect& rectInContent,
                                           const ScrollAlignment& alignX,
                                           const ScrollAlignment& alignY,
                                           ScrollType) {
   // 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::scrollPositionChanged(const DoublePoint& position,
-                                           ScrollType scrollType) {
-  TRACE_EVENT0("blink", "ScrollableArea::scrollPositionChanged");
+void ScrollableArea::scrollOffsetChanged(const ScrollOffset& offset,
+                                         ScrollType scrollType) {
+  TRACE_EVENT0("blink", "ScrollableArea::scrollOffsetChanged");
 
-  DoublePoint oldPosition = scrollPositionDouble();
-  DoublePoint truncatedPosition =
-      shouldUseIntegerScrollOffset() ? flooredIntPoint(position) : position;
+  ScrollOffset oldOffset = scrollOffset();
+  ScrollOffset truncatedOffset = shouldUseIntegerScrollOffset()
+                                     ? ScrollOffset(flooredIntSize(offset))
+                                     : offset;
 
   // Tell the derived class to scroll its contents.
-  updateScrollPosition(truncatedPosition, scrollType);
+  updateScrollOffset(truncatedOffset, scrollType);
 
   // Tell the scrollbars to update their thumb postions.
   // If the scrollbar does not have its own layer, it must always be
-  // invalidated to reflect the new thumb position, even if the theme did not
+  // invalidated to reflect the new thumb offset, even if the theme did not
   // invalidate any individual part.
   if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar())
     horizontalScrollbar->offsetDidChange();
   if (Scrollbar* verticalScrollbar = this->verticalScrollbar())
     verticalScrollbar->offsetDidChange();
 
-  if (scrollPositionDouble() != oldPosition) {
-    // FIXME: Pass in DoubleSize. crbug.com/414283.
-    scrollAnimator().notifyContentAreaScrolled(
-        toFloatSize(scrollPositionDouble() - oldPosition));
-  }
+  if (scrollOffset() != oldOffset)
+    scrollAnimator().notifyContentAreaScrolled(scrollOffset() - oldOffset);
 
-  scrollAnimator().setCurrentPosition(toFloatPoint(position));
+  scrollAnimator().setCurrentOffset(offset);
 }
 
 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;
   else
     return false;
 
   return true;
 }
 
 // NOTE: Only called from Internals for testing.
-void ScrollableArea::updateScrollPositionFromInternals(
-    const IntPoint& position) {
-  scrollPositionChanged(DoublePoint(position), ProgrammaticScroll);
+void ScrollableArea::updateScrollOffsetFromInternals(const IntSize& offset) {
+  scrollOffsetChanged(ScrollOffset(offset), ProgrammaticScroll);
 }
 
 void ScrollableArea::contentAreaWillPaint() const {
   if (ScrollAnimatorBase* scrollAnimator = existingScrollAnimator())
     scrollAnimator->contentAreaWillPaint();
 }
 
 void ScrollableArea::mouseEnteredContentArea() const {
   if (ScrollAnimatorBase* scrollAnimator = existingScrollAnimator())
     scrollAnimator->mouseEnteredContentArea();
@@ skipping 199 matching lines @@
     // scheduled on the compositor.
     // TODO(ymalik): We have a non-transient "main thread scrolling reason"
     // that doesn't actually cause shouldScrollOnMainThread() to be true.
     // This is confusing and should be cleaned up.
     return !!(reasons &
               ~MainThreadScrollingReason::kHandlingScrollFromMainThread);
   }
   return true;
 }
 
-DoubleRect ScrollableArea::visibleContentRectDouble(
-    IncludeScrollbarsInRect scrollbarInclusion) const {
-  return visibleContentRect(scrollbarInclusion);
-}
-
 IntRect ScrollableArea::visibleContentRect(
     IncludeScrollbarsInRect scrollbarInclusion) const {
   int scrollbarWidth =
       scrollbarInclusion == IncludeScrollbars ? verticalScrollbarWidth() : 0;
   int scrollbarHeight =
       scrollbarInclusion == IncludeScrollbars ? horizontalScrollbarHeight() : 0;
 
-  return IntRect(scrollPosition().x(), scrollPosition().y(),
-                 std::max(0, visibleWidth() + scrollbarWidth),
-                 std::max(0, visibleHeight() + scrollbarHeight));
+  return enclosingIntRect(
+      IntRect(scrollOffset().width(), scrollOffset().height(),
+              std::max(0, visibleWidth() + scrollbarWidth),
+              std::max(0, visibleHeight() + scrollbarHeight)));
 }
 
-IntPoint ScrollableArea::clampScrollPosition(
-    const IntPoint& scrollPosition) const {
-  return scrollPosition.shrunkTo(maximumScrollPosition())
-      .expandedTo(minimumScrollPosition());
+IntSize ScrollableArea::clampScrollOffset(const IntSize& scrollOffset) const {
+  return scrollOffset.shrunkTo(maximumScrollOffsetInt())
+      .expandedTo(minimumScrollOffsetInt());
 }
 
-DoublePoint ScrollableArea::clampScrollPosition(
-    const DoublePoint& scrollPosition) const {
-  return scrollPosition.shrunkTo(maximumScrollPositionDouble())
-      .expandedTo(minimumScrollPositionDouble());
+ScrollOffset ScrollableArea::clampScrollOffset(
+    const ScrollOffset& scrollOffset) const {
+  return scrollOffset.shrunkTo(maximumScrollOffset())
+      .expandedTo(minimumScrollOffset());
 }
 
 int ScrollableArea::lineStep(ScrollbarOrientation) const {
   return pixelsPerLineStep(getHostWindow());
 }
 
 int ScrollableArea::pageStep(ScrollbarOrientation orientation) const {
   IntRect visibleRect = visibleContentRect(IncludeScrollbars);
   int length = (orientation == HorizontalScrollbar) ? visibleRect.width()
                                                     : visibleRect.height();
@@ skipping 27 matching lines @@
   return IntSize(std::max(0, size.width() - verticalScrollbarWidth()),
                  std::max(0, size.height() - horizontalScrollbarHeight()));
 }
 
 DEFINE_TRACE(ScrollableArea) {
   visitor->trace(m_scrollAnimator);
   visitor->trace(m_programmaticScrollAnimator);
 }
 
 }  // namespace blink