Use float for scroll offset.

third_party/WebKit/Source/platform/scroll/Scrollbar.cpp

 /*
  * Copyright (C) 2004, 2006, 2008 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 235 matching lines @@
 void Scrollbar::moveThumb(int pos, bool draggingDocument) {
   if (!m_scrollableArea)
     return;
 
   int delta = pos - m_pressedPos;
 
   if (draggingDocument) {
     if (m_draggingDocument)
       delta = pos - m_documentDragPos;
     m_draggingDocument = true;
-    FloatPoint currentPosition =
-        m_scrollableArea->scrollAnimator().currentPosition();
+    ScrollOffset currentPosition =
+        m_scrollableArea->scrollAnimator().currentOffset();
     float destinationPosition =
-        (m_orientation == HorizontalScrollbar ? currentPosition.x()
-                                              : currentPosition.y()) +
+        (m_orientation == HorizontalScrollbar ? currentPosition.width()
+                                              : currentPosition.height()) +
         delta;
-    destinationPosition = m_scrollableArea->clampScrollPosition(
-        m_orientation, destinationPosition);
-    m_scrollableArea->setScrollPositionSingleAxis(
+    destinationPosition =
+        m_scrollableArea->clampScrollOffset(m_orientation, destinationPosition);
+    m_scrollableArea->setScrollOffsetSingleAxis(
         m_orientation, destinationPosition, UserScroll);
     m_documentDragPos = pos;
     return;
   }
 
   if (m_draggingDocument) {
     delta += m_pressedPos - m_documentDragPos;
     m_draggingDocument = false;
   }
 
   // Drag the thumb.
   int thumbPos = theme().thumbPosition(*this);
   int thumbLen = theme().thumbLength(*this);
   int trackLen = theme().trackLength(*this);
   ASSERT(thumbLen <= trackLen);
   if (thumbLen == trackLen)
     return;
 
   if (delta > 0)
     delta = std::min(trackLen - thumbLen - thumbPos, delta);
   else if (delta < 0)
     delta = std::max(-thumbPos, delta);
 
-  float minPos = m_scrollableArea->minimumScrollPosition(m_orientation);
-  float maxPos = m_scrollableArea->maximumScrollPosition(m_orientation);
+  float minOffset = m_scrollableArea->minimumScrollOffset(m_orientation);
+  float maxOffset = m_scrollableArea->maximumScrollOffset(m_orientation);
   if (delta) {
-    float newPosition = static_cast<float>(thumbPos + delta) *
-                            (maxPos - minPos) / (trackLen - thumbLen) +
-                        minPos;
-    m_scrollableArea->setScrollPositionSingleAxis(m_orientation, newPosition,
-                                                  UserScroll);
+    float newOffset = static_cast<float>(thumbPos + delta) *
+                          (maxOffset - minOffset) / (trackLen - thumbLen) +
+                      minOffset;
+    m_scrollableArea->setScrollOffsetSingleAxis(m_orientation, newOffset,
+                                                UserScroll);
   }
 }
 
 void Scrollbar::setHoveredPart(ScrollbarPart part) {
   if (part == m_hoveredPart)
     return;
 
   if (((m_hoveredPart == NoPart || part == NoPart) &&
        theme().invalidateOnMouseEnterExit())
       // When there's a pressed part, we don't draw a hovered state, so there's no reason to invalidate.
@@ skipping 96 matching lines @@
     default:
       // By default, we assume that gestures don't deselect the scrollbar.
       return true;
   }
 }
 
 void Scrollbar::mouseMoved(const PlatformMouseEvent& evt) {
   if (m_pressedPart == ThumbPart) {
     if (theme().shouldSnapBackToDragOrigin(*this, evt)) {
       if (m_scrollableArea) {
-        m_scrollableArea->setScrollPositionSingleAxis(
+        m_scrollableArea->setScrollOffsetSingleAxis(
             m_orientation,
-            m_dragOrigin +
-                m_scrollableArea->minimumScrollPosition(m_orientation),
+            m_dragOrigin + m_scrollableArea->minimumScrollOffset(m_orientation),
             UserScroll);
       }
     } else {
       moveThumb(m_orientation == HorizontalScrollbar
                     ? convertFromRootFrame(evt.position()).x()
                     : convertFromRootFrame(evt.position()).y(),
                 theme().shouldDragDocumentInsteadOfThumb(*this, evt));
     }
     return;
   }
@@ skipping 150 matching lines @@
     return m_scrollableArea->convertFromContainingWidgetToScrollbar(
         *this, parentPoint);
 
   return Widget::convertFromContainingWidget(parentPoint);
 }
 
 float Scrollbar::scrollableAreaCurrentPos() const {
   if (!m_scrollableArea)
     return 0;
 
-  if (m_orientation == HorizontalScrollbar)
-    return m_scrollableArea->scrollPosition().x() -
-           m_scrollableArea->minimumScrollPosition().x();
+  if (m_orientation == HorizontalScrollbar) {
+    return m_scrollableArea->scrollOffset().width() -
+           m_scrollableArea->minimumScrollOffset().width();
+  }
 
-  return m_scrollableArea->scrollPosition().y() -
-         m_scrollableArea->minimumScrollPosition().y();
+  return m_scrollableArea->scrollOffset().height() -
+         m_scrollableArea->minimumScrollOffset().height();
 }
 
 float Scrollbar::scrollableAreaTargetPos() const {
   if (!m_scrollableArea)
     return 0;
 
-  if (m_orientation == HorizontalScrollbar)
-    return m_scrollableArea->scrollAnimator().desiredTargetPosition().x() -
-           m_scrollableArea->minimumScrollPosition().x();
+  if (m_orientation == HorizontalScrollbar) {
+    return m_scrollableArea->scrollAnimator().desiredTargetOffset().width() -
+           m_scrollableArea->minimumScrollOffset().width();
+  }
 
-  return m_scrollableArea->scrollAnimator().desiredTargetPosition().y() -
-         m_scrollableArea->minimumScrollPosition().y();
+  return m_scrollableArea->scrollAnimator().desiredTargetOffset().height() -
+         m_scrollableArea->minimumScrollOffset().height();
 }
 
 LayoutRect Scrollbar::visualRect() const {
   return m_scrollableArea ? m_scrollableArea->visualRectForScrollbarParts()
                           : LayoutRect();
 }
 
 void Scrollbar::setNeedsPaintInvalidation(ScrollbarPart invalidParts) {
   if (m_theme.shouldRepaintAllPartsOnInvalidation())
     invalidParts = AllParts;
   if (invalidParts & ~ThumbPart)
     m_trackNeedsRepaint = true;
   if (invalidParts & ThumbPart)
     m_thumbNeedsRepaint = true;
   if (m_scrollableArea)
     m_scrollableArea->setScrollbarNeedsPaintInvalidation(orientation());
 }
 
 }  // namespace blink