Use float for scroll offset.

third_party/WebKit/Source/core/layout/LayoutBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 239 matching lines @@
         markOrthogonalWritingModeRoot();
       else
         unmarkOrthogonalWritingModeRoot();
     }
 
     clearPercentHeightDescendants();
   }
 
   // If our zoom factor changes and we have a defined scrollLeft/Top, we need to
   // adjust that value into the new zoomed coordinate space.  Note that the new
-  // scroll position may be outside the normal min/max range of the scrollable
+  // scroll offset may be outside the normal min/max range of the scrollable
   // area, which is weird but OK, because the scrollable area will update its
   // min/max in updateAfterLayout().
   if (hasOverflowClip() && oldStyle &&
       oldStyle->effectiveZoom() != newStyle.effectiveZoom()) {
     PaintLayerScrollableArea* scrollableArea = this->getScrollableArea();
     ASSERT(scrollableArea);
-    // We use scrollPosition() rather than adjustedScrollPosition(), because
-    // scrollPosition is the distance from the beginning of flow for the box,
-    // which is the dimension we want to preserve.
-    DoublePoint oldPosition = scrollableArea->scrollPositionDouble();
-    if (oldPosition.x() || oldPosition.y()) {
-      DoublePoint newPosition = oldPosition.scaledBy(newStyle.effectiveZoom() /
-                                                     oldStyle->effectiveZoom());
-      scrollableArea->setScrollPositionUnconditionally(newPosition);
+    // We use scrollOffset() rather than scrollPosition(), because scrollOffset is the distance
+    // from the beginning of flow for the box, which is the dimension we want to preserve.
+    ScrollOffset oldOffset = scrollableArea->scrollOffset();
+    if (oldOffset.width() || oldOffset.height()) {
+      ScrollOffset newOffset = oldOffset.scaledBy(newStyle.effectiveZoom() /
+                                                  oldStyle->effectiveZoom());
+      scrollableArea->setScrollOffsetUnconditionally(newOffset);
     }
   }
 
   // Our opaqueness might have changed without triggering layout.
   if (diff.needsPaintInvalidation()) {
     LayoutObject* parentToInvalidate = parent();
     for (unsigned i = 0;
          i < backgroundObscurationTestMaxDepth && parentToInvalidate; ++i) {
       parentToInvalidate->invalidateBackgroundObscurationStatus();
       parentToInvalidate = parentToInvalidate->parent();
@@ skipping 225 matching lines @@
 LayoutUnit LayoutBox::scrollHeight() const {
   if (hasOverflowClip())
     return getScrollableArea()->scrollHeight();
   // For objects with visible overflow, this matches IE.
   // FIXME: Need to work right with writing modes.
   return std::max(clientHeight(), layoutOverflowRect().maxY() - borderTop());
 }
 
 LayoutUnit LayoutBox::scrollLeft() const {
   return hasOverflowClip()
-             ? LayoutUnit(getScrollableArea()->adjustedScrollOffset().width())
+             ? LayoutUnit(getScrollableArea()->scrollPosition().x())
              : LayoutUnit();
 }
 
 LayoutUnit LayoutBox::scrollTop() const {
   return hasOverflowClip()
-             ? LayoutUnit(getScrollableArea()->adjustedScrollOffset().height())
+             ? LayoutUnit(getScrollableArea()->scrollPosition().y())
              : LayoutUnit();
 }
 
 int LayoutBox::pixelSnappedScrollWidth() const {
   return snapSizeToPixel(scrollWidth(), location().x() + clientLeft());
 }
 
 int LayoutBox::pixelSnappedScrollHeight() const {
   if (hasOverflowClip())
     return snapSizeToPixel(getScrollableArea()->scrollHeight(),
                            location().y() + clientTop());
   // For objects with visible overflow, this matches IE.
   // FIXME: Need to work right with writing modes.
   return snapSizeToPixel(scrollHeight(), location().y() + clientTop());
 }
 
 void LayoutBox::setScrollLeft(LayoutUnit newLeft) {
   // This doesn't hit in any tests, but since the equivalent code in setScrollTop
   // does, presumably this code does as well.
   DisableCompositingQueryAsserts disabler;
 
-  if (hasOverflowClip()) {
-    PaintLayerScrollableArea* scrollableArea = getScrollableArea();
-    scrollableArea->scrollToOffset(
-        DoubleSize(newLeft, scrollableArea->adjustedScrollOffset().height()),
-        ScrollBehaviorAuto);
-  }
+  if (!hasOverflowClip())
+    return;
+
+  PaintLayerScrollableArea* scrollableArea = getScrollableArea();
+  FloatPoint newPosition(newLeft.toFloat(),
+                         scrollableArea->scrollPosition().y());
+  scrollableArea->scrollToAbsolutePosition(newPosition, ScrollBehaviorAuto);
 }
 
 void LayoutBox::setScrollTop(LayoutUnit newTop) {
   // Hits in compositing/overflow/do-not-assert-on-invisible-composited-layers.html
   DisableCompositingQueryAsserts disabler;
 
-  if (hasOverflowClip()) {
-    PaintLayerScrollableArea* scrollableArea = getScrollableArea();
-    scrollableArea->scrollToOffset(
-        DoubleSize(scrollableArea->adjustedScrollOffset().width(), newTop),
-        ScrollBehaviorAuto);
-  }
+  if (!hasOverflowClip())
+    return;
+
+  PaintLayerScrollableArea* scrollableArea = getScrollableArea();
+  FloatPoint newPosition(scrollableArea->scrollPosition().x(),
+                         newTop.toFloat());
+  scrollableArea->scrollToAbsolutePosition(newPosition, ScrollBehaviorAuto);
 }
 
-void LayoutBox::scrollToOffset(const DoubleSize& offset,
-                               ScrollBehavior scrollBehavior) {
+void LayoutBox::scrollToPosition(const FloatPoint& position,
+                                 ScrollBehavior scrollBehavior) {
   // This doesn't hit in any tests, but since the equivalent code in setScrollTop
   // does, presumably this code does as well.
   DisableCompositingQueryAsserts disabler;
 
-  if (hasOverflowClip())
-    getScrollableArea()->scrollToOffset(offset, scrollBehavior);
+  if (!hasOverflowClip())
+    return;
+
+  getScrollableArea()->scrollToAbsolutePosition(position, scrollBehavior);
 }
 
 // Returns true iff we are attempting an autoscroll inside an iframe with scrolling="no".
 static bool isDisallowedAutoscroll(HTMLFrameOwnerElement* ownerElement,
                                    FrameView* frameView) {
   if (ownerElement && isHTMLFrameElementBase(*ownerElement)) {
     HTMLFrameElementBase* frameElementBase =
         toHTMLFrameElementBase(ownerElement);
     if (Page* page = frameView->frame().page()) {
       return page->autoscrollController().autoscrollInProgress() &&
@@ skipping 410 matching lines @@
 IntSize LayoutBox::calculateAutoscrollDirection(
     const IntPoint& pointInRootFrame) const {
   if (!frame())
     return IntSize();
 
   FrameView* frameView = frame()->view();
   if (!frameView)
     return IntSize();
 
   IntRect box(absoluteBoundingBoxRect());
-  box.move(view()->frameView()->scrollOffset());
+  box.move(view()->frameView()->scrollOffsetInt());
   IntRect windowBox = view()->frameView()->contentsToRootFrame(box);
 
   IntPoint windowAutoscrollPoint = pointInRootFrame;
 
   if (windowAutoscrollPoint.x() < windowBox.x() + autoscrollBeltSize)
     windowAutoscrollPoint.move(-autoscrollBeltSize, 0);
   else if (windowAutoscrollPoint.x() > windowBox.maxX() - autoscrollBeltSize)
     windowAutoscrollPoint.move(autoscrollBeltSize, 0);
 
   if (windowAutoscrollPoint.y() < windowBox.y() + autoscrollBeltSize)
@@ skipping 63 matching lines @@
   if (abs(delta.width()) <=
       AutoscrollController::
           noMiddleClickAutoscrollRadius)  // at the center we let the space for the icon
     delta.setWidth(0);
   if (abs(delta.height()) <=
       AutoscrollController::noMiddleClickAutoscrollRadius)
     delta.setHeight(0);
   scroll(ScrollByPixel, FloatSize(adjustedScrollDelta(delta)));
 }
 
-void LayoutBox::scrollByRecursively(const DoubleSize& delta) {
+void LayoutBox::scrollByRecursively(const ScrollOffset& delta) {
   if (delta.isZero())
     return;
 
   bool restrictedByLineClamp = false;
   if (parent())
     restrictedByLineClamp = !parent()->style()->lineClamp().isNone();
 
   if (hasOverflowClip() && !restrictedByLineClamp) {
     PaintLayerScrollableArea* scrollableArea = this->getScrollableArea();
     ASSERT(scrollableArea);
 
-    DoubleSize newScrollOffset = scrollableArea->adjustedScrollOffset() + delta;
-    scrollableArea->scrollToOffset(newScrollOffset);
+    ScrollOffset newScrollOffset = scrollableArea->scrollOffset() + delta;
+    scrollableArea->setScrollOffset(newScrollOffset, ProgrammaticScroll);
 
-    // If this layer can't do the scroll we ask the next layer up that can scroll to try
-    DoubleSize remainingScrollOffset =
-        newScrollOffset - scrollableArea->adjustedScrollOffset();
+    // If this layer can't do the scroll we ask the next layer up that can
+    // scroll to try.
+    ScrollOffset remainingScrollOffset =
+        newScrollOffset - scrollableArea->scrollOffset();
     if (!remainingScrollOffset.isZero() && parent()) {
       if (LayoutBox* scrollableBox = enclosingScrollableBox())
         scrollableBox->scrollByRecursively(remainingScrollOffset);
 
       LocalFrame* frame = this->frame();
       if (frame && frame->page())
         frame->page()->autoscrollController().updateAutoscrollLayoutObject();
     }
   } else if (view()->frameView()) {
     // If we are here, we were called on a layoutObject that can be programmatically scrolled, but doesn't
     // have an overflow clip. Which means that it is a document node that can be scrolled.
     // FIXME: Pass in DoubleSize. crbug.com/414283.
-    view()->frameView()->scrollBy(flooredIntSize(delta), UserScroll);
+    view()->frameView()->scrollBy(delta, UserScroll);
 
     // FIXME: If we didn't scroll the whole way, do we want to try looking at the frames ownerElement?
     // https://bugs.webkit.org/show_bug.cgi?id=28237
   }
 }
 
 bool LayoutBox::needsPreferredWidthsRecalculation() const {
   return style()->paddingStart().isPercentOrCalc() ||
          style()->paddingEnd().isPercentOrCalc();
 }
 
 IntSize LayoutBox::originAdjustmentForScrollbars() const {
   IntSize size;
   int adjustmentWidth = verticalScrollbarWidth();
   if (hasFlippedBlocksWritingMode() ||
       (isHorizontalWritingMode() &&
        shouldPlaceBlockDirectionScrollbarOnLogicalLeft())) {
     size.expand(adjustmentWidth, 0);
   }
   return size;
 }
 
 IntSize LayoutBox::scrolledContentOffset() const {
   ASSERT(hasOverflowClip());
   ASSERT(hasLayer());
   // FIXME: Return DoubleSize here. crbug.com/414283.
   PaintLayerScrollableArea* scrollableArea = getScrollableArea();
-  IntSize result = flooredIntSize(scrollableArea->scrollOffset()) +
-                   originAdjustmentForScrollbars();
+  IntSize result =
+      scrollableArea->scrollOffsetInt() + originAdjustmentForScrollbars();
   if (isHorizontalWritingMode() &&
       shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
     result.expand(-verticalScrollbarWidth(), 0);
   return result;
 }
 
 LayoutRect LayoutBox::clippingRect() const {
   LayoutRect result = LayoutRect(LayoutRect::infiniteIntRect());
   if (hasOverflowClip() || style()->containsPaint())
     result = overflowClipRect(LayoutPoint());
@@ skipping 566 matching lines @@
 }
 
 bool LayoutBox::intersectsVisibleViewport() const {
   LayoutRect rect = visualOverflowRect();
   LayoutView* layoutView = view();
   while (!layoutView->frame()->ownerLayoutItem().isNull())
     layoutView =
         LayoutAPIShim::layoutObjectFrom(layoutView->frame()->ownerLayoutItem())
             ->view();
   mapToVisualRectInAncestorSpace(layoutView, rect);
-  return rect.intersects(LayoutRect(layoutView->frameView()
-                                        ->getScrollableArea()
-                                        ->visibleContentRectDouble()));
+  return rect.intersects(LayoutRect(
+      layoutView->frameView()->getScrollableArea()->visibleContentRect()));
 }
 
 PaintInvalidationReason LayoutBox::invalidatePaintIfNeeded(
     const PaintInvalidationState& paintInvalidationState) {
   if (hasBoxDecorationBackground()
       // We also paint overflow controls in background phase.
       || (hasOverflowClip() && getScrollableArea()->hasOverflowControls())) {
     PaintLayer& layer = paintInvalidationState.paintingLayer();
     if (layer.layoutObject() != this)
       layer.setNeedsPaintPhaseDescendantBlockBackgrounds();
@@ skipping 3738 matching lines @@
   LayoutRect rect = frameRect();
 
   LayoutBlock* block = containingBlock();
   if (block)
     block->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 }  // namespace blink