Use float for scroll offset.

third_party/WebKit/Source/modules/accessibility/AXObject.cpp

 /*
  * Copyright (C) 2008, 2009, 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
@@ skipping 1195 matching lines @@
 
 bool AXObject::isScrollableContainer() const {
   return !!getScrollableAreaIfScrollable();
 }
 
 IntPoint AXObject::scrollOffset() const {
   ScrollableArea* area = getScrollableAreaIfScrollable();
   if (!area)
     return IntPoint();
 
-  return IntPoint(area->scrollPosition().x(), area->scrollPosition().y());
+  return IntPoint(area->scrollOffsetInt().width(),
+                  area->scrollOffsetInt().height());
 }
 
 IntPoint AXObject::minimumScrollOffset() const {
   ScrollableArea* area = getScrollableAreaIfScrollable();
   if (!area)
     return IntPoint();
 
-  return IntPoint(area->minimumScrollPosition().x(),
-                  area->minimumScrollPosition().y());
+  return IntPoint(area->minimumScrollOffsetInt().width(),
+                  area->minimumScrollOffsetInt().height());
 }
 
 IntPoint AXObject::maximumScrollOffset() const {
   ScrollableArea* area = getScrollableAreaIfScrollable();
   if (!area)
     return IntPoint();
 
-  return IntPoint(area->maximumScrollPosition().x(),
-                  area->maximumScrollPosition().y());
+  return IntPoint(area->maximumScrollOffsetInt().width(),
+                  area->maximumScrollOffsetInt().height());
 }
 
 void AXObject::setScrollOffset(const IntPoint& offset) const {
   ScrollableArea* area = getScrollableAreaIfScrollable();
   if (!area)
     return;
 
   // TODO(bokan): This should potentially be a UserScroll.
-  area->setScrollPosition(DoublePoint(offset.x(), offset.y()),
-                          ProgrammaticScroll);
+  area->setScrollOffset(ScrollOffset(offset.x(), offset.y()),
+                        ProgrammaticScroll);
 }
 
 void AXObject::getRelativeBounds(AXObject** outContainer,
                                  FloatRect& outBoundsInContainer,
                                  SkMatrix44& outContainerTransform) const {
   *outContainer = nullptr;
   outBoundsInContainer = FloatRect();
   outContainerTransform.setIdentity();
 
   // First check if it has explicit bounds, for example if this element is tied
@@ skipping 39 matching lines @@
 
   if (!container)
     return;
   *outContainer = container;
   outBoundsInContainer = layoutObject->localBoundingBoxRectForAccessibility();
 
   // If the container has a scroll offset, subtract that out because we want our
   // bounds to be relative to the *unscrolled* position of the container object.
   ScrollableArea* scrollableArea = container->getScrollableAreaIfScrollable();
   if (scrollableArea && !container->isWebArea()) {
-    IntPoint scrollPosition = scrollableArea->scrollPosition();
-    outBoundsInContainer.move(
-        FloatSize(scrollPosition.x(), scrollPosition.y()));
+    ScrollOffset scrollOffset = scrollableArea->scrollOffset();
+    outBoundsInContainer.move(scrollOffset);
   }
 
   // Compute the transform between the container's coordinate space and this
   // object.  If the transform is just a simple translation, apply that to the
   // bounding box, but if it's a non-trivial transformation like a rotation,
   // scaling, etc. then return the full matrix instead.
   TransformationMatrix transform = layoutObject->localToAncestorTransform(
       toLayoutBoxModelObject(containerLayoutObject));
   if (transform.isIdentityOr2DTranslation()) {
     outBoundsInContainer.move(transform.to2DTranslation());
@@ skipping 145 matching lines @@
   while (scrollParent) {
     scrollableArea = scrollParent->getScrollableAreaIfScrollable();
     if (scrollableArea)
       break;
     scrollParent = scrollParent->parentObject();
   }
   if (!scrollParent || !scrollableArea)
     return;
 
   IntRect objectRect = pixelSnappedIntRect(getBoundsInFrameCoordinates());
-  IntPoint scrollPosition = scrollableArea->scrollPosition();
+  IntSize scrollOffset = scrollableArea->scrollOffsetInt();
   IntRect scrollVisibleRect = scrollableArea->visibleContentRect();
 
   // Convert the object rect into local coordinates.
   if (!scrollParent->isWebArea()) {
-    objectRect.moveBy(scrollPosition);
+    objectRect.moveBy(IntPoint(scrollOffset));
     objectRect.moveBy(
         -pixelSnappedIntRect(scrollParent->getBoundsInFrameCoordinates())
              .location());
   }
 
-  int desiredX =
-      computeBestScrollOffset(scrollPosition.x(), objectRect.x() + subfocus.x(),
-                              objectRect.x() + subfocus.maxX(), objectRect.x(),
-                              objectRect.maxX(), 0, scrollVisibleRect.width());
-  int desiredY =
-      computeBestScrollOffset(scrollPosition.y(), objectRect.y() + subfocus.y(),
-                              objectRect.y() + subfocus.maxY(), objectRect.y(),
-                              objectRect.maxY(), 0, scrollVisibleRect.height());
+  int desiredX = computeBestScrollOffset(
+      scrollOffset.width(), objectRect.x() + subfocus.x(),
+      objectRect.x() + subfocus.maxX(), objectRect.x(), objectRect.maxX(), 0,
+      scrollVisibleRect.width());
+  int desiredY = computeBestScrollOffset(
+      scrollOffset.height(), objectRect.y() + subfocus.y(),
+      objectRect.y() + subfocus.maxY(), objectRect.y(), objectRect.maxY(), 0,
+      scrollVisibleRect.height());
 
   scrollParent->setScrollOffset(IntPoint(desiredX, desiredY));
 
   // Convert the subfocus into the coordinates of the scroll parent.
   IntRect newSubfocus = subfocus;
   IntRect newElementRect = pixelSnappedIntRect(getBoundsInFrameCoordinates());
   IntRect scrollParentRect =
       pixelSnappedIntRect(scrollParent->getBoundsInFrameCoordinates());
   newSubfocus.move(newElementRect.x(), newElementRect.y());
   newSubfocus.move(-scrollParentRect.x(), -scrollParentRect.y());
@@ skipping 24 matching lines @@
     const AXObject* outer = objects[i];
     const AXObject* inner = objects[i + 1];
     ScrollableArea* scrollableArea = outer->getScrollableAreaIfScrollable();
 
     IntRect innerRect =
         inner->isWebArea()
             ? pixelSnappedIntRect(
                   inner->parentObject()->getBoundsInFrameCoordinates())
             : pixelSnappedIntRect(inner->getBoundsInFrameCoordinates());
     IntRect objectRect = innerRect;
-    IntPoint scrollPosition = scrollableArea->scrollPosition();
+    IntSize scrollOffset = scrollableArea->scrollOffsetInt();
 
     // Convert the object rect into local coordinates.
     objectRect.move(offsetX, offsetY);
     if (!outer->isWebArea())
-      objectRect.move(scrollPosition.x(), scrollPosition.y());
+      objectRect.move(scrollOffset.width(), scrollOffset.height());
 
     int desiredX = computeBestScrollOffset(0, objectRect.x(), objectRect.maxX(),
                                            objectRect.x(), objectRect.maxX(),
                                            point.x(), point.x());
     int desiredY = computeBestScrollOffset(0, objectRect.y(), objectRect.maxY(),
                                            objectRect.y(), objectRect.maxY(),
                                            point.y(), point.y());
     outer->setScrollOffset(IntPoint(desiredX, desiredY));
 
     if (outer->isWebArea() && !inner->isWebArea()) {
       // If outer object we just scrolled is a web area (frame) but the inner
       // object is not, keep track of the coordinate transformation to apply to
       // future nested calculations.
-      scrollPosition = scrollableArea->scrollPosition();
-      offsetX -= (scrollPosition.x() + point.x());
-      offsetY -= (scrollPosition.y() + point.y());
-      point.move(scrollPosition.x() - innerRect.x(),
-                 scrollPosition.y() - innerRect.y());
+      scrollOffset = scrollableArea->scrollOffsetInt();
+      offsetX -= (scrollOffset.width() + point.x());
+      offsetY -= (scrollOffset.height() + point.y());
+      point.move(scrollOffset.width() - innerRect.width(),
+                 scrollOffset.height() - innerRect.y());
     } else if (inner->isWebArea()) {
       // Otherwise, if the inner object is a web area, reset the coordinate
       // transformation.
       offsetX = 0;
       offsetY = 0;
     }
   }
 }
 
 void AXObject::notifyIfIgnoredValueChanged() {
@@ skipping 164 matching lines @@
 }
 
 DEFINE_TRACE(AXObject) {
   visitor->trace(m_children);
   visitor->trace(m_parent);
   visitor->trace(m_cachedLiveRegionRoot);
   visitor->trace(m_axObjectCache);
 }
 
 }  // namespace blink