Use float for scroll offset.

third_party/WebKit/Source/core/paint/PaintLayerScrollableArea.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@gmail.com>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 78 matching lines @@
 PaintLayerScrollableArea::PaintLayerScrollableArea(PaintLayer& layer)
     : m_layer(layer),
       m_nextTopmostScrollChild(0),
       m_topmostScrollChild(0),
       m_inResizeMode(false),
       m_scrollsOverflow(false),
       m_inOverflowRelayout(false),
       m_needsCompositedScrolling(false),
       m_rebuildHorizontalScrollbarLayer(false),
       m_rebuildVerticalScrollbarLayer(false),
-      m_needsScrollPositionClamp(false),
+      m_needsScrollOffsetClamp(false),
       m_needsRelayout(false),
       m_hadHorizontalScrollbarBeforeRelayout(false),
       m_hadVerticalScrollbarBeforeRelayout(false),
       m_scrollbarManager(*this),
       m_scrollCorner(nullptr),
       m_resizer(nullptr),
       m_scrollAnchor(this)
 #if ENABLE(ASSERT)
       ,
       m_hasBeenDisposed(false)
 #endif
 {
   Node* node = box().node();
   if (node && node->isElementNode()) {
     // We save and restore only the scrollOffset as the other scroll values are recalculated.
     Element* element = toElement(node);
     m_scrollOffset = element->savedLayerScrollOffset();
-    if (!m_scrollOffset.isZero()) {
-      scrollAnimator().setCurrentPosition(
-          FloatPoint(m_scrollOffset.width(), m_scrollOffset.height()));
-    }
-    element->setSavedLayerScrollOffset(IntSize());
+    if (!m_scrollOffset.isZero())
+      scrollAnimator().setCurrentOffset(m_scrollOffset);
+    element->setSavedLayerScrollOffset(ScrollOffset());
   }
   updateResizerAreaSet();
 }
 
 PaintLayerScrollableArea::~PaintLayerScrollableArea() {
   ASSERT(m_hasBeenDisposed);
 }
 
 void PaintLayerScrollableArea::dispose() {
   if (inResizeMode() && !box().documentBeingDestroyed()) {
@@ skipping 10 matching lines @@
 
   if (box().frame() && box().frame()->page()) {
     if (ScrollingCoordinator* scrollingCoordinator =
             box().frame()->page()->scrollingCoordinator())
       scrollingCoordinator->willDestroyScrollableArea(this);
   }
 
   if (!box().documentBeingDestroyed()) {
     Node* node = box().node();
     // FIXME: Make setSavedLayerScrollOffset take DoubleSize. crbug.com/414283.
-    if (node && node->isElementNode()) {
-      toElement(node)->setSavedLayerScrollOffset(
-          flooredIntSize(m_scrollOffset));
-    }
+    if (node && node->isElementNode())
+      toElement(node)->setSavedLayerScrollOffset(m_scrollOffset);
   }
 
   if (LocalFrame* frame = box().frame()) {
     if (FrameView* frameView = frame->view())
       frameView->removeResizerArea(box());
   }
 
   if (RootScrollerController* controller =
           box().document().rootScrollerController())
     controller->didDisposePaintLayerScrollableArea(*this);
@@ skipping 178 matching lines @@
     return parentPoint;
 
   IntPoint point = view->frameView()->convertToLayoutObject(box(), parentPoint);
 
   point.move(-scrollbarOffset(scrollbar));
   return point;
 }
 
 int PaintLayerScrollableArea::scrollSize(
     ScrollbarOrientation orientation) const {
-  IntSize scrollDimensions = maximumScrollPosition() - minimumScrollPosition();
+  IntSize scrollDimensions =
+      maximumScrollOffsetInt() - minimumScrollOffsetInt();
   return (orientation == HorizontalScrollbar) ? scrollDimensions.width()
                                               : scrollDimensions.height();
 }
 
-void PaintLayerScrollableArea::setScrollOffset(
-    const DoublePoint& newScrollOffset,
-    ScrollType scrollType) {
-  if (scrollOffset() == toDoubleSize(newScrollOffset))
+void PaintLayerScrollableArea::updateScrollOffset(const ScrollOffset& newOffset,
+                                                  ScrollType scrollType) {
+  if (scrollOffset() == newOffset)
     return;
 
-  DoubleSize scrollDelta = scrollOffset() - toDoubleSize(newScrollOffset);
-  m_scrollOffset = toDoubleSize(newScrollOffset);
+  ScrollOffset scrollDelta = scrollOffset() - newOffset;
+  m_scrollOffset = newOffset;
 
   LocalFrame* frame = box().frame();
   ASSERT(frame);
 
   FrameView* frameView = box().frameView();
 
   TRACE_EVENT1("devtools.timeline", "ScrollLayer", "data",
                InspectorScrollLayerEvent::data(&box()));
 
   // FIXME(420741): Resolve circular dependency between scroll offset and
@@ skipping 57 matching lines @@
   }
 
   // Schedule the scroll DOM event.
   if (box().node())
     box().node()->document().enqueueScrollEventForNode(box().node());
 
   if (AXObjectCache* cache = box().document().existingAXObjectCache())
     cache->handleScrollPositionChanged(&box());
   box().view()->clearHitTestCache();
 
-  // Inform the FrameLoader of the new scroll position, so it can be restored when navigating back.
+  // Inform the FrameLoader of the new scroll offset, so it can be restored when navigating back.
   if (layer()->isRootLayer()) {
     frameView->frame().loader().saveScrollState();
     frameView->didChangeScrollOffset();
   }
 
   // All scrolls clear the fragment anchor.
   frameView->clearFragmentAnchor();
 
   // Clear the scroll anchor, unless it is the reason for this scroll.
   if (RuntimeEnabledFeatures::scrollAnchoringEnabled() &&
       scrollType != AnchoringScroll)
     scrollAnchor()->clear();
 }
 
-IntPoint PaintLayerScrollableArea::scrollPosition() const {
-  return IntPoint(flooredIntSize(m_scrollOffset));
+IntSize PaintLayerScrollableArea::scrollOffsetInt() const {
+  return flooredIntSize(m_scrollOffset);
 }
 
-DoublePoint PaintLayerScrollableArea::scrollPositionDouble() const {
-  return DoublePoint(m_scrollOffset);
+ScrollOffset PaintLayerScrollableArea::scrollOffset() const {
+  return m_scrollOffset;
 }
 
-IntPoint PaintLayerScrollableArea::minimumScrollPosition() const {
-  return -scrollOrigin();
+IntSize PaintLayerScrollableArea::minimumScrollOffsetInt() const {
+  return toIntSize(-scrollOrigin());
 }
 
-IntPoint PaintLayerScrollableArea::maximumScrollPosition() const {
+IntSize PaintLayerScrollableArea::maximumScrollOffsetInt() const {
   IntSize contentSize;
   IntSize visibleSize;
   if (box().hasOverflowClip()) {
     contentSize =
         IntSize(pixelSnappedScrollWidth(), pixelSnappedScrollHeight());
     visibleSize =
         pixelSnappedIntRect(box().overflowClipRect(box().location())).size();
 
     // TODO(skobes): We should really ASSERT that contentSize >= visibleSize
     // when we are not the root layer, but we can't because contentSize is
     // based on stale layout overflow data (http://crbug.com/576933).
     contentSize = contentSize.expandedTo(visibleSize);
   }
-  return -scrollOrigin() + (contentSize - visibleSize);
+  return toIntSize(-scrollOrigin() + (contentSize - visibleSize));
 }
 
 IntRect PaintLayerScrollableArea::visibleContentRect(
     IncludeScrollbarsInRect scrollbarInclusion) const {
   int verticalScrollbarWidth = 0;
   int horizontalScrollbarHeight = 0;
   if (scrollbarInclusion == IncludeScrollbars) {
     verticalScrollbarWidth =
         (verticalScrollbar() && !verticalScrollbar()->isOverlayScrollbar())
             ? verticalScrollbar()->scrollbarThickness()
             : 0;
     horizontalScrollbarHeight =
         (horizontalScrollbar() && !horizontalScrollbar()->isOverlayScrollbar())
             ? horizontalScrollbar()->scrollbarThickness()
             : 0;
   }
 
   // TODO(szager): Handle fractional scroll offsets correctly.
   return IntRect(
-      IntPoint(flooredIntSize(adjustedScrollOffset())),
+      flooredIntPoint(absolutePosition()),
       IntSize(max(0, layer()->size().width() - verticalScrollbarWidth),
               max(0, layer()->size().height() - horizontalScrollbarHeight)));
 }
 
 int PaintLayerScrollableArea::visibleHeight() const {
   return layer()->size().height();
 }
 
 int PaintLayerScrollableArea::visibleWidth() const {
   return layer()->size().width();
@@ skipping 115 matching lines @@
   setScrollOrigin(flooredIntPoint(-scrollableOverflow) +
                   box().originAdjustmentForScrollbars());
 }
 
 void PaintLayerScrollableArea::updateScrollDimensions() {
   m_overflowRect = box().layoutOverflowRect();
   box().flipForWritingMode(m_overflowRect);
   updateScrollOrigin();
 }
 
-void PaintLayerScrollableArea::setScrollPositionUnconditionally(
-    const DoublePoint& position,
+void PaintLayerScrollableArea::setScrollOffsetUnconditionally(
+    const ScrollOffset& offset,
     ScrollType scrollType) {
   cancelScrollAnimation();
-  scrollPositionChanged(position, scrollType);
+  scrollOffsetChanged(offset, scrollType);
 }
 
 void PaintLayerScrollableArea::updateAfterLayout() {
   ASSERT(box().hasOverflowClip());
 
   bool relayoutIsPrevented = PreventRelayoutScope::relayoutIsPrevented();
   bool scrollbarsAreFrozen =
       m_inOverflowRelayout || FreezeScrollbarsScope::scrollbarsAreFrozen();
 
   if (needsScrollbarReconstruction()) {
@@ skipping 113 matching lines @@
     }
   }
 
   if (!scrollbarsAreFrozen && hasOverlayScrollbars()) {
     if (!scrollSize(HorizontalScrollbar))
       setHasHorizontalScrollbar(false);
     if (!scrollSize(VerticalScrollbar))
       setHasVerticalScrollbar(false);
   }
 
-  clampScrollPositionsAfterLayout();
+  clampScrollOffsetsAfterLayout();
 
   if (!scrollbarsAreFrozen) {
     bool hasOverflow =
         hasScrollableHorizontalOverflow() || hasScrollableVerticalOverflow();
     updateScrollableAreaSet(hasOverflow);
   }
 
   DisableCompositingQueryAsserts disabler;
   positionOverflowControls();
 }
 
-void PaintLayerScrollableArea::clampScrollPositionsAfterLayout() {
-  // If a vertical scrollbar was removed, the min/max scroll positions may have changed,
-  // so the scroll positions needs to be clamped.  If the scroll position did not change,
+void PaintLayerScrollableArea::clampScrollOffsetsAfterLayout() {
+  // If a vertical scrollbar was removed, the min/max scroll offsets may have changed,
+  // so the scroll offsets needs to be clamped.  If the scroll offset did not change,
   // but the scroll origin *did* change, we still need to notify the scrollbars to
   // update their dimensions.
 
-  if (DelayScrollPositionClampScope::clampingIsDelayed()) {
-    DelayScrollPositionClampScope::setNeedsClamp(this);
+  if (DelayScrollOffsetClampScope::clampingIsDelayed()) {
+    DelayScrollOffsetClampScope::setNeedsClamp(this);
     return;
   }
 
   // Restore before clamping because clamping clears the scroll anchor.
   if (shouldPerformScrollAnchoring())
     m_scrollAnchor.restore();
 
-  if (scrollOriginChanged()) {
-    setScrollPositionUnconditionally(
-        clampScrollPosition(scrollPositionDouble()));
-  } else {
-    ScrollableArea::setScrollPosition(scrollPositionDouble(),
-                                      ProgrammaticScroll);
-  }
+  if (scrollOriginChanged())
+    setScrollOffsetUnconditionally(clampScrollOffset(scrollOffset()));
+  else
+    ScrollableArea::setScrollOffset(scrollOffset(), ProgrammaticScroll);
 
-  setNeedsScrollPositionClamp(false);
+  setNeedsScrollOffsetClamp(false);
   resetScrollOriginChanged();
   m_scrollbarManager.destroyDetachedScrollbars();
 }
 
 bool PaintLayerScrollableArea::shouldPerformScrollAnchoring() const {
   return RuntimeEnabledFeatures::scrollAnchoringEnabled() &&
          m_scrollAnchor.hasScroller() &&
          layoutBox()->style()->overflowAnchor() != AnchorNone;
 }
 
@@ skipping 730 matching lines @@
   LayoutRect localExposeRect(
       box()
           .absoluteToLocalQuad(FloatQuad(FloatRect(rect)), UseTransforms)
           .boundingBox());
   localExposeRect.move(-box().borderLeft(), -box().borderTop());
   LayoutRect layerBounds(LayoutPoint(),
                          LayoutSize(box().clientWidth(), box().clientHeight()));
   LayoutRect r = ScrollAlignment::getRectToExpose(layerBounds, localExposeRect,
                                                   alignX, alignY);
 
-  DoublePoint clampedScrollPosition = clampScrollPosition(
-      scrollPositionDouble() + roundedIntSize(r.location()));
-  if (clampedScrollPosition == scrollPositionDouble()) {
+  ScrollOffset oldScrollOffset = scrollOffset();
+  ScrollOffset newScrollOffset(clampScrollOffset(roundedIntSize(
+      toScrollOffset(FloatPoint(r.location()) + oldScrollOffset))));
+
+  if (newScrollOffset == oldScrollOffset) {
     return LayoutRect(
         box()
             .localToAbsoluteQuad(FloatQuad(FloatRect(intersection(
                                      layerBounds, localExposeRect))),
                                  UseTransforms)
             .boundingBox());
   }
 
-  DoubleSize oldScrollOffset = adjustedScrollOffset();
-  setScrollPosition(clampedScrollPosition, scrollType, ScrollBehaviorInstant);
-  DoubleSize scrollOffsetDifference = adjustedScrollOffset() - oldScrollOffset;
+  setScrollOffset(newScrollOffset, scrollType, ScrollBehaviorInstant);
+  ScrollOffset scrollOffsetDifference = scrollOffset() - oldScrollOffset;
   localExposeRect.move(-LayoutSize(scrollOffsetDifference));
   return LayoutRect(
       box()
           .localToAbsoluteQuad(
               FloatQuad(FloatRect(intersection(layerBounds, localExposeRect))),
               UseTransforms)
           .boundingBox());
 }
 
 void PaintLayerScrollableArea::updateScrollableAreaSet(bool hasOverflow) {
@@ skipping 172 matching lines @@
     if (!m_hBar) {
       m_hBar = createScrollbar(HorizontalScrollbar);
       m_hBarIsAttached = 1;
       if (!m_hBar->isCustomScrollbar())
         m_scrollableArea->didAddScrollbar(*m_hBar, HorizontalScrollbar);
     } else {
       m_hBarIsAttached = 1;
     }
   } else {
     m_hBarIsAttached = 0;
-    if (!DelayScrollPositionClampScope::clampingIsDelayed())
+    if (!DelayScrollOffsetClampScope::clampingIsDelayed())
       destroyScrollbar(HorizontalScrollbar);
   }
 }
 
 void PaintLayerScrollableArea::ScrollbarManager::setHasVerticalScrollbar(
     bool hasScrollbar) {
   if (hasScrollbar) {
     DisableCompositingQueryAsserts disabler;
     if (!m_vBar) {
       m_vBar = createScrollbar(VerticalScrollbar);
       m_vBarIsAttached = 1;
       if (!m_vBar->isCustomScrollbar())
         m_scrollableArea->didAddScrollbar(*m_vBar, VerticalScrollbar);
     } else {
       m_vBarIsAttached = 1;
     }
   } else {
     m_vBarIsAttached = 0;
-    if (!DelayScrollPositionClampScope::clampingIsDelayed())
+    if (!DelayScrollOffsetClampScope::clampingIsDelayed())
       destroyScrollbar(VerticalScrollbar);
   }
 }
 
 Scrollbar* PaintLayerScrollableArea::ScrollbarManager::createScrollbar(
     ScrollbarOrientation orientation) {
   ASSERT(orientation == HorizontalScrollbar ? !m_hBarIsAttached
                                             : !m_vBarIsAttached);
   Scrollbar* scrollbar = nullptr;
   const LayoutObject& actualLayoutObject =
@@ skipping 116 matching lines @@
 }
 
 void PaintLayerScrollableArea::PreventRelayoutScope::resetRelayoutNeeded() {
   DCHECK_EQ(s_count, 0);
   DCHECK(!s_needsRelayout || s_needsRelayout->isEmpty());
   s_relayoutNeeded = false;
 }
 
 int PaintLayerScrollableArea::FreezeScrollbarsScope::s_count = 0;
 
-int PaintLayerScrollableArea::DelayScrollPositionClampScope::s_count = 0;
+int PaintLayerScrollableArea::DelayScrollOffsetClampScope::s_count = 0;
 PersistentHeapVector<Member<PaintLayerScrollableArea>>*
-    PaintLayerScrollableArea::DelayScrollPositionClampScope::s_needsClamp =
+    PaintLayerScrollableArea::DelayScrollOffsetClampScope::s_needsClamp =
         nullptr;
 
-PaintLayerScrollableArea::DelayScrollPositionClampScope::
-    DelayScrollPositionClampScope() {
+PaintLayerScrollableArea::DelayScrollOffsetClampScope::
+    DelayScrollOffsetClampScope() {
   if (!s_needsClamp)
     s_needsClamp = new PersistentHeapVector<Member<PaintLayerScrollableArea>>();
   DCHECK(s_count > 0 || s_needsClamp->isEmpty());
   s_count++;
 }
 
-PaintLayerScrollableArea::DelayScrollPositionClampScope::
-    ~DelayScrollPositionClampScope() {
+PaintLayerScrollableArea::DelayScrollOffsetClampScope::
+    ~DelayScrollOffsetClampScope() {
   if (--s_count == 0)
-    DelayScrollPositionClampScope::clampScrollableAreas();
+    DelayScrollOffsetClampScope::clampScrollableAreas();
 }
 
-void PaintLayerScrollableArea::DelayScrollPositionClampScope::setNeedsClamp(
+void PaintLayerScrollableArea::DelayScrollOffsetClampScope::setNeedsClamp(
     PaintLayerScrollableArea* scrollableArea) {
-  if (!scrollableArea->needsScrollPositionClamp()) {
-    scrollableArea->setNeedsScrollPositionClamp(true);
+  if (!scrollableArea->needsScrollOffsetClamp()) {
+    scrollableArea->setNeedsScrollOffsetClamp(true);
     s_needsClamp->append(scrollableArea);
   }
 }
 
-void PaintLayerScrollableArea::DelayScrollPositionClampScope::
+void PaintLayerScrollableArea::DelayScrollOffsetClampScope::
     clampScrollableAreas() {
   for (auto& scrollableArea : *s_needsClamp)
-    scrollableArea->clampScrollPositionsAfterLayout();
+    scrollableArea->clampScrollOffsetsAfterLayout();
   delete s_needsClamp;
   s_needsClamp = nullptr;
 }
 
 }  // namespace blink