Use float for scroll offset.

third_party/WebKit/Source/core/frame/RootFrameViewport.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/frame/RootFrameViewport.h"
 
 #include "core/frame/FrameView.h"
 #include "core/layout/ScrollAlignment.h"
 #include "core/layout/ScrollAnchor.h"
 #include "platform/geometry/DoubleRect.h"
@@ skipping 31 matching lines @@
   // If the root FrameView is the layout viewport then coordinates in the
   // root FrameView's content space are already in the layout viewport's
   // content space.
   if (rootFrameView.layoutViewportScrollableArea() == &layoutViewport())
     return ret;
 
   // Make the given rect relative to the top of the layout viewport's content
   // by adding the scroll position.
   // TODO(bokan): This will have to be revisited if we ever remove the
   // restriction that a root scroller must be exactly screen filling.
-  ret.moveBy(LayoutPoint(layoutViewport().scrollPositionDouble()));
+  ret.move(LayoutSize(layoutViewport().scrollOffset()));
 
   return ret;
 }
 
-void RootFrameViewport::restoreToAnchor(const DoublePoint& targetPosition) {
+void RootFrameViewport::restoreToAnchor(const ScrollOffset& targetOffset) {
   // Clamp the scroll offset of each viewport now so that we force any invalid
   // offsets to become valid so we can compute the correct deltas.
-  visualViewport().setScrollPosition(visualViewport().scrollPositionDouble(),
-                                     ProgrammaticScroll);
-  layoutViewport().setScrollPosition(layoutViewport().scrollPositionDouble(),
-                                     ProgrammaticScroll);
+  visualViewport().setScrollOffset(visualViewport().scrollOffset(),
+                                   ProgrammaticScroll);
+  layoutViewport().setScrollOffset(layoutViewport().scrollOffset(),
+                                   ProgrammaticScroll);
 
-  DoubleSize delta = targetPosition - scrollPositionDouble();
+  ScrollOffset delta = targetOffset - scrollOffset();
 
-  visualViewport().setScrollPosition(
-      visualViewport().scrollPositionDouble() + delta, ProgrammaticScroll);
+  visualViewport().setScrollOffset(visualViewport().scrollOffset() + delta,
+                                   ProgrammaticScroll);
 
-  delta = targetPosition - scrollPositionDouble();
+  delta = targetOffset - scrollOffset();
 
   // Since the main thread FrameView has integer scroll offsets, scroll it to
   // the next pixel and then we'll scroll the visual viewport again to
   // compensate for the sub-pixel offset. We need this "overscroll" to ensure
   // the pixel of which we want to be partially in appears fully inside the
   // FrameView since the VisualViewport is bounded by the FrameView.
   IntSize layoutDelta = IntSize(
       delta.width() < 0 ? floor(delta.width()) : ceil(delta.width()),
       delta.height() < 0 ? floor(delta.height()) : ceil(delta.height()));
 
-  layoutViewport().setScrollPosition(
-      layoutViewport().scrollPosition() + layoutDelta, ProgrammaticScroll);
+  layoutViewport().setScrollOffset(
+      ScrollOffset(layoutViewport().scrollOffsetInt() + layoutDelta),
+      ProgrammaticScroll);
 
-  delta = targetPosition - scrollPositionDouble();
-  visualViewport().setScrollPosition(
-      visualViewport().scrollPositionDouble() + delta, ProgrammaticScroll);
+  delta = targetOffset - scrollOffset();
+  visualViewport().setScrollOffset(visualViewport().scrollOffset() + delta,
+                                   ProgrammaticScroll);
 }
 
 void RootFrameViewport::didUpdateVisualViewport() {
   if (RuntimeEnabledFeatures::scrollAnchoringEnabled()) {
     if (ScrollAnchor* anchor = layoutViewport().scrollAnchor())
       anchor->clear();
   }
 }
 
 LayoutBox* RootFrameViewport::layoutBox() const {
   return layoutViewport().layoutBox();
 }
 
 void RootFrameViewport::updateScrollAnimator() {
-  scrollAnimator().setCurrentPosition(
-      toFloatPoint(scrollOffsetFromScrollAnimators()));
+  scrollAnimator().setCurrentOffset(
+      toFloatSize(scrollOffsetFromScrollAnimators()));
 }
 
-DoublePoint RootFrameViewport::scrollOffsetFromScrollAnimators() const {
-  return visualViewport().scrollAnimator().currentPosition() +
-         layoutViewport().scrollAnimator().currentPosition();
-}
-
-DoubleRect RootFrameViewport::visibleContentRectDouble(
-    IncludeScrollbarsInRect scrollbarInclusion) const {
-  return DoubleRect(
-      scrollPositionDouble(),
-      visualViewport().visibleContentRectDouble(scrollbarInclusion).size());
+ScrollOffset RootFrameViewport::scrollOffsetFromScrollAnimators() const {
+  return visualViewport().scrollAnimator().currentOffset() +
+         layoutViewport().scrollAnimator().currentOffset();
 }
 
 IntRect RootFrameViewport::visibleContentRect(
     IncludeScrollbarsInRect scrollbarInclusion) const {
-  return enclosingIntRect(visibleContentRectDouble(scrollbarInclusion));
+  return IntRect(
+      IntPoint(scrollOffsetInt()),
+      visualViewport().visibleContentRect(scrollbarInclusion).size());
 }
 
 bool RootFrameViewport::shouldUseIntegerScrollOffset() const {
   // Fractionals are floored in the ScrollAnimatorBase but it's important that
   // the ScrollAnimators of the visual and layout viewports get the precise
   // fractional number so never use integer scrolling for RootFrameViewport,
   // we'll let the truncation happen in the subviewports.
   return false;
 }
 
 bool RootFrameViewport::isActive() const {
   return layoutViewport().isActive();
 }
 
 int RootFrameViewport::scrollSize(ScrollbarOrientation orientation) const {
-  IntSize scrollDimensions = maximumScrollPosition() - minimumScrollPosition();
+  IntSize scrollDimensions =
+      maximumScrollOffsetInt() - minimumScrollOffsetInt();
   return (orientation == HorizontalScrollbar) ? scrollDimensions.width()
                                               : scrollDimensions.height();
 }
 
 bool RootFrameViewport::isScrollCornerVisible() const {
   return layoutViewport().isScrollCornerVisible();
 }
 
 IntRect RootFrameViewport::scrollCornerRect() const {
   return layoutViewport().scrollCornerRect();
 }
 
-void RootFrameViewport::setScrollPosition(const DoublePoint& position,
-                                          ScrollType scrollType,
-                                          ScrollBehavior scrollBehavior) {
+void RootFrameViewport::setScrollOffset(const ScrollOffset& offset,
+                                        ScrollType scrollType,
+                                        ScrollBehavior scrollBehavior) {
   updateScrollAnimator();
 
   if (scrollBehavior == ScrollBehaviorAuto)
     scrollBehavior = scrollBehaviorStyle();
 
   if (scrollType == ProgrammaticScroll &&
       !layoutViewport().isProgrammaticallyScrollable())
     return;
 
   if (scrollType == AnchoringScroll) {
-    distributeScrollBetweenViewports(position, scrollType, scrollBehavior,
+    distributeScrollBetweenViewports(offset, scrollType, scrollBehavior,
                                      LayoutViewport);
     return;
   }
 
   if (scrollBehavior == ScrollBehaviorSmooth) {
-    distributeScrollBetweenViewports(position, scrollType, scrollBehavior,
+    distributeScrollBetweenViewports(offset, scrollType, scrollBehavior,
                                      VisualViewport);
     return;
   }
 
-  DoublePoint clampedPosition = clampScrollPosition(position);
-  ScrollableArea::setScrollPosition(clampedPosition, scrollType,
-                                    scrollBehavior);
+  ScrollOffset clampedOffset = clampScrollOffset(offset);
+  ScrollableArea::setScrollOffset(clampedOffset, scrollType, scrollBehavior);
 }
 
 ScrollBehavior RootFrameViewport::scrollBehaviorStyle() const {
   return layoutViewport().scrollBehaviorStyle();
 }
 
 LayoutRect RootFrameViewport::scrollIntoView(const LayoutRect& rectInContent,
                                              const ScrollAlignment& alignX,
                                              const ScrollAlignment& alignY,
                                              ScrollType scrollType) {
   // We want to move the rect into the viewport that excludes the scrollbars so
   // we intersect the visual viewport with the scrollbar-excluded frameView
-  // content rect.  However, we don't use visibleContentRect directly since it
-  // floors the scroll position.  Instead, we use
-  // ScrollAnimatorBase::currentPosition and construct a LayoutRect from that.
-
+  // content rect. However, we don't use visibleContentRect directly since it
+  // floors the scroll offset. Instead, we use ScrollAnimatorBase::currentOffset
+  // and construct a LayoutRect from that.
   LayoutRect frameRectInContent =
-      LayoutRect(layoutViewport().scrollAnimator().currentPosition(),
-                 layoutViewport().visibleContentRect().size());
+      LayoutRect(FloatPoint(layoutViewport().scrollAnimator().currentOffset()),
+                 FloatSize(layoutViewport().visibleContentRect().size()));
   LayoutRect visualRectInContent =
-      LayoutRect(scrollOffsetFromScrollAnimators(),
-                 visualViewport().visibleContentRect().size());
+      LayoutRect(FloatPoint(scrollOffsetFromScrollAnimators()),
+                 FloatSize(visualViewport().visibleContentRect().size()));
 
   // Intersect layout and visual rects to exclude the scrollbar from the view
   // rect.
   LayoutRect viewRectInContent =
       intersection(visualRectInContent, frameRectInContent);
   LayoutRect targetViewport = ScrollAlignment::getRectToExpose(
       viewRectInContent, rectInContent, alignX, alignY);
-  if (targetViewport != viewRectInContent)
-    setScrollPosition(DoublePoint(targetViewport.x(), targetViewport.y()),
-                      scrollType);
+  if (targetViewport != viewRectInContent) {
+    setScrollOffset(ScrollOffset(targetViewport.x(), targetViewport.y()),
+                    scrollType);
+  }
 
   // RootFrameViewport only changes the viewport relative to the document so we
   // can't change the input rect's location relative to the document origin.
   return rectInContent;
 }
 
-void RootFrameViewport::setScrollOffset(const DoublePoint& offset,
-                                        ScrollType scrollType) {
-  distributeScrollBetweenViewports(DoublePoint(offset), scrollType,
-                                   ScrollBehaviorInstant, VisualViewport);
+void RootFrameViewport::updateScrollOffset(const ScrollOffset& offset,
+                                           ScrollType scrollType) {
+  distributeScrollBetweenViewports(offset, scrollType, ScrollBehaviorInstant,
+                                   VisualViewport);
 }
 
 void RootFrameViewport::distributeScrollBetweenViewports(
-    const DoublePoint& offset,
+    const ScrollOffset& offset,
     ScrollType scrollType,
     ScrollBehavior behavior,
     ViewportToScrollFirst scrollFirst) {
-  // Make sure we use the scroll positions as reported by each viewport's
-  // ScrollAnimatorBase, since its ScrollableArea's position may have the
+  // Make sure we use the scroll offsets as reported by each viewport's
+  // ScrollAnimatorBase, since its ScrollableArea's offset may have the
   // fractional part truncated off.
-  DoublePoint oldPosition = scrollOffsetFromScrollAnimators();
+  // TODO(szager): Now that scroll offsets are stored as floats, can we take the
+  // scroll offset directly from the ScrollableArea's rather than the animators?
+  ScrollOffset oldOffset = scrollOffsetFromScrollAnimators();
 
-  DoubleSize delta = offset - oldPosition;
+  ScrollOffset delta = offset - oldOffset;
 
   if (delta.isZero())
     return;
 
   ScrollableArea& primary =
       scrollFirst == VisualViewport ? visualViewport() : layoutViewport();
   ScrollableArea& secondary =
       scrollFirst == VisualViewport ? layoutViewport() : visualViewport();
 
-  DoublePoint targetPosition = primary.clampScrollPosition(
-      primary.scrollAnimator().currentPosition() + delta);
+  ScrollOffset targetOffset = primary.clampScrollOffset(
+      primary.scrollAnimator().currentOffset() + delta);
 
-  primary.setScrollPosition(targetPosition, scrollType, behavior);
+  primary.setScrollOffset(targetOffset, scrollType, behavior);
 
   // Scroll the secondary viewport if all of the scroll was not applied to the
   // primary viewport.
-  DoublePoint updatedPosition =
-      secondary.scrollAnimator().currentPosition() + FloatPoint(targetPosition);
-  DoubleSize applied = updatedPosition - oldPosition;
+  ScrollOffset updatedOffset =
+      secondary.scrollAnimator().currentOffset() + FloatSize(targetOffset);
+  ScrollOffset applied = updatedOffset - oldOffset;
   delta -= applied;
 
   if (delta.isZero())
     return;
 
-  targetPosition = secondary.clampScrollPosition(
-      secondary.scrollAnimator().currentPosition() + delta);
-  secondary.setScrollPosition(targetPosition, scrollType, behavior);
+  targetOffset = secondary.clampScrollOffset(
+      secondary.scrollAnimator().currentOffset() + delta);
+  secondary.setScrollOffset(targetOffset, scrollType, behavior);
 }
 
-IntPoint RootFrameViewport::scrollPosition() const {
-  return flooredIntPoint(scrollPositionDouble());
+IntSize RootFrameViewport::scrollOffsetInt() const {
+  return flooredIntSize(scrollOffset());
 }
 
-DoublePoint RootFrameViewport::scrollPositionDouble() const {
-  return layoutViewport().scrollPositionDouble() +
-         toDoubleSize(visualViewport().scrollPositionDouble());
+ScrollOffset RootFrameViewport::scrollOffset() const {
+  return layoutViewport().scrollOffset() + visualViewport().scrollOffset();
 }
 
-IntPoint RootFrameViewport::minimumScrollPosition() const {
-  return IntPoint(layoutViewport().minimumScrollPosition() +
-                  visualViewport().minimumScrollPosition());
+IntSize RootFrameViewport::minimumScrollOffsetInt() const {
+  return IntSize(layoutViewport().minimumScrollOffsetInt() +
+                 visualViewport().minimumScrollOffsetInt());
 }
 
-IntPoint RootFrameViewport::maximumScrollPosition() const {
-  return layoutViewport().maximumScrollPosition() +
-         visualViewport().maximumScrollPosition();
+IntSize RootFrameViewport::maximumScrollOffsetInt() const {
+  return layoutViewport().maximumScrollOffsetInt() +
+         visualViewport().maximumScrollOffsetInt();
 }
 
-DoublePoint RootFrameViewport::maximumScrollPositionDouble() const {
-  return layoutViewport().maximumScrollPositionDouble() +
-         toDoubleSize(visualViewport().maximumScrollPositionDouble());
+ScrollOffset RootFrameViewport::maximumScrollOffset() const {
+  return layoutViewport().maximumScrollOffset() +
+         visualViewport().maximumScrollOffset();
 }
 
 IntSize RootFrameViewport::contentsSize() const {
   return layoutViewport().contentsSize();
 }
 
 bool RootFrameViewport::scrollbarsCanBeActive() const {
   return layoutViewport().scrollbarsCanBeActive();
 }
 
@@ skipping 137 matching lines @@
   visualViewport().clearScrollAnimators();
 }
 
 DEFINE_TRACE(RootFrameViewport) {
   visitor->trace(m_visualViewport);
   visitor->trace(m_layoutViewport);
   ScrollableArea::trace(visitor);
 }
 
 }  // namespace blink