Use float for scroll offset.

third_party/WebKit/Source/platform/mac/ScrollAnimatorMac.mm

 /*
  * Copyright (C) 2010, 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 104 matching lines @@
 }
 
 - (void)invalidate {
   _animator = 0;
 }
 
 - (NSRect)bounds {
   if (!_animator)
     return NSZeroRect;
 
-  blink::FloatPoint currentPosition = _animator->currentPosition();
-  return NSMakeRect(currentPosition.x(), currentPosition.y(), 0, 0);
+  blink::ScrollOffset currentOffset = _animator->currentOffset();
+  return NSMakeRect(currentOffset.width(), currentOffset.height(), 0, 0);
 }
 
 - (void)_immediateScrollToPoint:(NSPoint)newPosition {
   if (!_animator)
     return;
-  _animator->immediateScrollToPointForScrollAnimation(newPosition);
+  _animator->immediateScrollToOffsetForScrollAnimation(
+      toScrollOffset(newPosition));
 }
 
 - (NSPoint)_pixelAlignProposedScrollPosition:(NSPoint)newOrigin {
   return newOrigin;
 }
 
 - (NSSize)convertSizeToBase:(NSSize)size {
   return abs(size);
 }
 
@@ skipping 575 matching lines @@
   [m_horizontalScrollbarPainterDelegate.get() invalidate];
   [m_verticalScrollbarPainterDelegate.get() invalidate];
   [m_scrollAnimationHelperDelegate.get() invalidate];
   END_BLOCK_OBJC_EXCEPTIONS;
 
   m_initialScrollbarPaintTaskFactory->cancel();
   m_sendContentAreaScrolledTaskFactory->cancel();
 }
 
 ScrollResult ScrollAnimatorMac::userScroll(ScrollGranularity granularity,
-                                           const FloatSize& delta) {
+                                           const ScrollOffset& delta) {
   m_haveScrolledSincePageLoad = true;
 
   if (!m_scrollableArea->scrollAnimatorEnabled())
     return ScrollAnimatorBase::userScroll(granularity, delta);
 
   if (granularity == ScrollByPixel || granularity == ScrollByPrecisePixel)
     return ScrollAnimatorBase::userScroll(granularity, delta);
 
-  FloatSize consumedDelta = computeDeltaToConsume(delta);
-  FloatPoint newPos = m_currentPos + consumedDelta;
-  if (m_currentPos == newPos)
+  ScrollOffset consumedDelta = computeDeltaToConsume(delta);
+  ScrollOffset newOffset = m_currentOffset + consumedDelta;
+  if (m_currentOffset == newOffset)
     return ScrollResult();
 
   // Prevent clobbering an existing animation on an unscrolled axis.
   if ([m_scrollAnimationHelper.get() _isAnimating]) {
     NSPoint targetOrigin = [m_scrollAnimationHelper.get() targetOrigin];
     if (!delta.width())
-      newPos.setX(targetOrigin.x);
+      newOffset.setWidth(targetOrigin.x);
     if (!delta.height())
-      newPos.setY(targetOrigin.y);
+      newOffset.setHeight(targetOrigin.y);
   }
 
-  NSPoint newPoint = NSMakePoint(newPos.x(), newPos.y());
+  NSPoint newPoint = NSMakePoint(newOffset.width(), newOffset.height());
   [m_scrollAnimationHelper.get() scrollToPoint:newPoint];
 
   // TODO(bokan): This has different semantics on ScrollResult than ScrollAnimator,
   // which only returns unused delta if there's no animation and we don't start one.
   return ScrollResult(consumedDelta.width(), consumedDelta.height(),
                       delta.width() - consumedDelta.width(),
                       delta.height() - consumedDelta.height());
 }
 
 void ScrollAnimatorMac::scrollToOffsetWithoutAnimation(
-    const FloatPoint& offset) {
+    const ScrollOffset& offset) {
   [m_scrollAnimationHelper.get() _stopRun];
   immediateScrollTo(offset);
 }
 
-FloatPoint ScrollAnimatorMac::adjustScrollPositionIfNecessary(
-    const FloatPoint& position) const {
-  IntPoint minPos = m_scrollableArea->minimumScrollPosition();
-  IntPoint maxPos = m_scrollableArea->maximumScrollPosition();
+ScrollOffset ScrollAnimatorMac::adjustScrollOffsetIfNecessary(
+    const ScrollOffset& offset) const {
+  ScrollOffset minOffset = m_scrollableArea->minimumScrollOffset();
+  ScrollOffset maxOffset = m_scrollableArea->maximumScrollOffset();
 
-  float newX = clampTo<float, float>(position.x(), minPos.x(), maxPos.x());
-  float newY = clampTo<float, float>(position.y(), minPos.y(), maxPos.y());
+  float newX = clampTo<float, float>(offset.width(), minOffset.width(),
+                                     maxOffset.width());
+  float newY = clampTo<float, float>(offset.height(), minOffset.height(),
+                                     maxOffset.height());
 
-  return FloatPoint(newX, newY);
+  return ScrollOffset(newX, newY);
 }
 
-void ScrollAnimatorMac::immediateScrollTo(const FloatPoint& newPosition) {
-  FloatPoint adjustedPosition = adjustScrollPositionIfNecessary(newPosition);
+void ScrollAnimatorMac::immediateScrollTo(const ScrollOffset& newOffset) {
+  ScrollOffset adjustedOffset = adjustScrollOffsetIfNecessary(newOffset);
 
-  bool positionChanged = adjustedPosition != m_currentPos;
-  if (!positionChanged && !getScrollableArea()->scrollOriginChanged())
+  bool offsetChanged = adjustedOffset != m_currentOffset;
+  if (!offsetChanged && !getScrollableArea()->scrollOriginChanged())
     return;
 
-  FloatSize delta = adjustedPosition - m_currentPos;
+  ScrollOffset delta = adjustedOffset - m_currentOffset;
 
-  m_currentPos = adjustedPosition;
+  m_currentOffset = adjustedOffset;
   notifyContentAreaScrolled(delta);
-  notifyPositionChanged();
+  notifyOffsetChanged();
 }
 
-void ScrollAnimatorMac::immediateScrollToPointForScrollAnimation(
-    const FloatPoint& newPosition) {
+void ScrollAnimatorMac::immediateScrollToOffsetForScrollAnimation(
+    const ScrollOffset& newOffset) {
   ASSERT(m_scrollAnimationHelper);
-  immediateScrollTo(newPosition);
+  immediateScrollTo(newOffset);
 }
 
 void ScrollAnimatorMac::contentAreaWillPaint() const {
   if (!getScrollableArea()->scrollbarsCanBeActive())
     return;
   [m_scrollbarPainterController.get() contentAreaWillDraw];
 }
 
 void ScrollAnimatorMac::mouseEnteredContentArea() const {
   if (!getScrollableArea()->scrollbarsCanBeActive())
@@ skipping 132 matching lines @@
   if (ScrollbarThemeMac::recommendedScrollerStyle() != NSScrollerStyleOverlay)
     return true;
 
   // Overlay scrollbars should participate in hit testing whenever they are at all visible.
   ScrollbarPainter painter = scrollbarPainterForScrollbar(scrollbar);
   if (!painter)
     return false;
   return [painter knobAlpha] > 0;
 }
 
-void ScrollAnimatorMac::notifyContentAreaScrolled(const FloatSize& delta) {
+void ScrollAnimatorMac::notifyContentAreaScrolled(const ScrollOffset& delta) {
   // This function is called when a page is going into the page cache, but the page
   // isn't really scrolling in that case. We should only pass the message on to the
   // ScrollbarPainterController when we're really scrolling on an active page.
   if (getScrollableArea()->scrollbarsCanBeActive())
     sendContentAreaScrolledSoon(delta);
 }
 
 bool ScrollAnimatorMac::setScrollbarsVisibleForTesting(bool show) {
   if (show)
     [m_scrollbarPainterController.get() flashScrollers];
@@ skipping 46 matching lines @@
     ScrollbarPainter newVerticalPainter = [NSClassFromString(@"NSScrollerImp")
         scrollerImpWithStyle:newStyle
                  controlSize:(NSControlSize)verticalScrollbar->controlSize()
                   horizontal:NO
         replacingScrollerImp:oldVerticalPainter];
     [m_scrollbarPainterController.get()
         setVerticalScrollerImp:newVerticalPainter];
     macTheme->setNewPainterForScrollbar(*verticalScrollbar, newVerticalPainter);
 
     // The different scrollbar styles have different thicknesses, so we must re-set the
-    // frameRect to the new thickness, and the re-layout below will ensure the position
+    // frameRect to the new thickness, and the re-layout below will ensure the offset
     // and length are properly updated.
     int thickness =
         macTheme->scrollbarThickness(verticalScrollbar->controlSize());
     verticalScrollbar->setFrameRect(IntRect(0, 0, thickness, thickness));
   }
 
   if (Scrollbar* horizontalScrollbar =
           getScrollableArea()->horizontalScrollbar()) {
     horizontalScrollbar->setNeedsPaintInvalidation(AllParts);
 
     ScrollbarPainter oldHorizontalPainter =
         [m_scrollbarPainterController.get() horizontalScrollerImp];
     ScrollbarPainter newHorizontalPainter = [NSClassFromString(@"NSScrollerImp")
         scrollerImpWithStyle:newStyle
                  controlSize:(NSControlSize)horizontalScrollbar->controlSize()
                   horizontal:YES
         replacingScrollerImp:oldHorizontalPainter];
     [m_scrollbarPainterController.get()
         setHorizontalScrollerImp:newHorizontalPainter];
     macTheme->setNewPainterForScrollbar(*horizontalScrollbar,
                                         newHorizontalPainter);
 
     // The different scrollbar styles have different thicknesses, so we must re-set the
-    // frameRect to the new thickness, and the re-layout below will ensure the position
+    // frameRect to the new thickness, and the re-layout below will ensure the offset
     // and length are properly updated.
     int thickness =
         macTheme->scrollbarThickness(horizontalScrollbar->controlSize());
     horizontalScrollbar->setFrameRect(IntRect(0, 0, thickness, thickness));
   }
 
   // If m_needsScrollerStyleUpdate is true, then the page is restoring from the page cache, and
   // a relayout will happen on its own. Otherwise, we must initiate a re-layout ourselves.
   if (!m_needsScrollerStyleUpdate)
     getScrollableArea()->scrollbarStyleChanged();
@@ skipping 15 matching lines @@
   m_initialScrollbarPaintTaskFactory->cancel();
 }
 
 void ScrollAnimatorMac::initialScrollbarPaintTask() {
   // To force the scrollbars to flash, we have to call hide first. Otherwise, the ScrollbarPainterController
   // might think that the scrollbars are already showing and bail early.
   [m_scrollbarPainterController.get() hideOverlayScrollers];
   [m_scrollbarPainterController.get() flashScrollers];
 }
 
-void ScrollAnimatorMac::sendContentAreaScrolledSoon(const FloatSize& delta) {
+void ScrollAnimatorMac::sendContentAreaScrolledSoon(const ScrollOffset& delta) {
   m_contentAreaScrolledTimerScrollDelta = delta;
 
   if (!m_sendContentAreaScrolledTaskFactory->isPending())
     m_taskRunner->postTask(
         BLINK_FROM_HERE,
         m_sendContentAreaScrolledTaskFactory->cancelAndCreate());
 }
 
 void ScrollAnimatorMac::sendContentAreaScrolledTask() {
   if (supportsContentAreaScrolledInDirection()) {
     [m_scrollbarPainterController.get()
         contentAreaScrolledInDirection:NSMakePoint(
                                            m_contentAreaScrolledTimerScrollDelta
                                                .width(),
                                            m_contentAreaScrolledTimerScrollDelta
                                                .height())];
-    m_contentAreaScrolledTimerScrollDelta = FloatSize();
+    m_contentAreaScrolledTimerScrollDelta = ScrollOffset();
   } else
     [m_scrollbarPainterController.get() contentAreaScrolled];
 }
 
 void ScrollAnimatorMac::setVisibleScrollerThumbRect(
     const IntRect& scrollerThumb) {
   IntRect rectInViewCoordinates = scrollerThumb;
   if (Scrollbar* verticalScrollbar = m_scrollableArea->verticalScrollbar())
     rectInViewCoordinates =
         verticalScrollbar->convertToContainingWidget(scrollerThumb);
 
   if (rectInViewCoordinates == m_visibleScrollerThumbRect)
     return;
 
   m_visibleScrollerThumbRect = rectInViewCoordinates;
 }
 
 }  // namespace blink