Use float for scroll offset.

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

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 1624 matching lines @@
   if (!layoutViewItem.isNull() && layoutViewItem.needsLayout())
     layout();
   else
     scrollToFragmentAnchor();
 }
 
 void FrameView::clearFragmentAnchor() {
   m_fragmentAnchor = nullptr;
 }
 
-void FrameView::setScrollPosition(const DoublePoint& scrollPoint,
-                                  ScrollType scrollType,
-                                  ScrollBehavior scrollBehavior) {
-  DoublePoint newScrollPosition = clampScrollPosition(scrollPoint);
-  if (newScrollPosition == scrollPositionDouble())
-    return;
-
-  if (scrollBehavior == ScrollBehaviorAuto)
-    scrollBehavior = scrollBehaviorStyle();
-
-  ScrollableArea::setScrollPosition(newScrollPosition, scrollType,
-                                    scrollBehavior);
-}
-
 void FrameView::didUpdateElasticOverscroll() {
   Page* page = frame().page();
   if (!page)
     return;
   FloatSize elasticOverscroll = page->chromeClient().elasticOverscroll();
   if (m_horizontalScrollbar) {
     float delta =
         elasticOverscroll.width() - m_horizontalScrollbar->elasticOverscroll();
     if (delta != 0) {
       m_horizontalScrollbar->setElasticOverscroll(elasticOverscroll.width());
@@ skipping 24 matching lines @@
 
   setLayoutSizeInternal(size);
 }
 
 void FrameView::didScrollTimerFired(TimerBase*) {
   if (m_frame->document() && !m_frame->document()->layoutViewItem().isNull())
     m_frame->document()->fetcher()->updateAllImageResourcePriorities();
 }
 
 void FrameView::updateLayersAndCompositingAfterScrollIfNeeded(
-    const DoubleSize& scrollDelta) {
+    const ScrollOffset& scrollDelta) {
   // Nothing to do after scrolling if there are no fixed position elements.
   if (!hasViewportConstrainedObjects())
     return;
 
   // Update sticky position objects which are stuck to the viewport.
   for (const auto& viewportConstrainedObject : *m_viewportConstrainedObjects) {
     LayoutObject* layoutObject = viewportConstrainedObject;
     PaintLayer* layer = toLayoutBoxModelObject(layoutObject)->layer();
     if (layoutObject->style()->position() == StickyPosition) {
       // TODO(skobes): Resolve circular dependency between scroll offset and
@@ skipping 1354 matching lines @@
           overflow);  // This is how we clip in case we overflow again.
     }
   }
 
   adjustViewSizeAndLayout();
 }
 
 IntRect FrameView::convertFromLayoutObject(
     const LayoutObject& layoutObject,
     const IntRect& layoutObjectRect) const {
-  IntRect rect = pixelSnappedIntRect(enclosingLayoutRect(
+  // Convert from page ("absolute") to FrameView coordinates.
+  LayoutRect rect = enclosingLayoutRect(
       layoutObject.localToAbsoluteQuad(FloatRect(layoutObjectRect))
-          .boundingBox()));
-
-  // Convert from page ("absolute") to FrameView coordinates.
-  rect.moveBy(-scrollPosition());
-
-  return rect;
+          .boundingBox());
+  rect.move(LayoutSize(-scrollOffset()));
+  return pixelSnappedIntRect(rect);
 }
 
 IntRect FrameView::convertToLayoutObject(const LayoutObject& layoutObject,
                                          const IntRect& frameRect) const {
   IntRect rectInContent = frameToContents(frameRect);
 
   // Convert from FrameView coords into page ("absolute") coordinates.
-  rectInContent.moveBy(scrollPosition());
+  rectInContent.move(scrollOffsetInt());
 
   // FIXME: we don't have a way to map an absolute rect down to a local quad, so just
   // move the rect for now.
   rectInContent.setLocation(roundedIntPoint(
       layoutObject.absoluteToLocal(rectInContent.location(), UseTransforms)));
   return rectInContent;
 }
 
 IntPoint FrameView::convertFromLayoutObject(
     const LayoutObject& layoutObject,
     const IntPoint& layoutObjectPoint) const {
   IntPoint point = roundedIntPoint(
       layoutObject.localToAbsolute(layoutObjectPoint, UseTransforms));
 
   // Convert from page ("absolute") to FrameView coordinates.
-  point.moveBy(-scrollPosition());
+  point.move(-scrollOffsetInt());
   return point;
 }
 
 IntPoint FrameView::convertToLayoutObject(const LayoutObject& layoutObject,
                                           const IntPoint& framePoint) const {
   IntPoint point = framePoint;
 
   // Convert from FrameView coords into page ("absolute") coordinates.
   point += IntSize(scrollX(), scrollY());
 
@@ skipping 260 matching lines @@
 
 void FrameView::didAddScrollbar(Scrollbar& scrollbar,
                                 ScrollbarOrientation orientation) {
   ScrollableArea::didAddScrollbar(scrollbar, orientation);
 }
 
 void FrameView::setTopControlsViewportAdjustment(float adjustment) {
   m_topControlsViewportAdjustment = adjustment;
 }
 
-IntPoint FrameView::maximumScrollPosition() const {
+IntSize FrameView::maximumScrollOffsetInt() const {
   // Make the same calculation as in CC's LayerImpl::MaxScrollOffset()
   // FIXME: We probably shouldn't be storing the bounds in a float. crbug.com/422331.
   IntSize visibleSize =
       visibleContentSize(ExcludeScrollbars) + topControlsSize();
   IntSize contentBounds = contentsSize();
-  IntPoint maximumPosition = -scrollOrigin() + (contentBounds - visibleSize);
-  return maximumPosition.expandedTo(minimumScrollPosition());
+  IntSize maximumOffset =
+      toIntSize(-scrollOrigin() + (contentBounds - visibleSize));
+  return maximumOffset.expandedTo(minimumScrollOffsetInt());
 }
 
 void FrameView::addChild(Widget* child) {
   ASSERT(child != this && !child->parent());
   child->setParent(this);
   m_children.add(child);
 }
 
 void FrameView::setHasHorizontalScrollbar(bool hasBar) {
   if (m_frame->settings() && m_frame->settings()->hideScrollbars())
@@ skipping 96 matching lines @@
 
 IntSize FrameView::visibleContentSize(
     IncludeScrollbarsInRect scrollbarInclusion) const {
   return scrollbarInclusion == ExcludeScrollbars
              ? excludeScrollbars(frameRect().size())
              : frameRect().size();
 }
 
 IntRect FrameView::visibleContentRect(
     IncludeScrollbarsInRect scrollbarInclusion) const {
-  return IntRect(flooredIntPoint(m_scrollPosition),
+  return IntRect(IntPoint(flooredIntSize(m_scrollOffset)),
                  visibleContentSize(scrollbarInclusion));
 }
 
 IntSize FrameView::contentsSize() const {
   return m_contentsSize;
 }
 
 void FrameView::clipPaintRect(FloatRect* paintRect) const {
   // Paint the whole rect if "mainFrameClipsContent" is false, meaning that
   // WebPreferences::record_whole_document is true.
   if (!m_frame->settings()->mainFrameClipsContent())
     return;
 
   paintRect->intersect(
       page()->chromeClient().visibleContentRectForPainting().value_or(
           visibleContentRect()));
 }
 
-IntPoint FrameView::minimumScrollPosition() const {
-  return IntPoint(-scrollOrigin().x(), -scrollOrigin().y());
+IntSize FrameView::minimumScrollOffsetInt() const {
+  return IntSize(-scrollOrigin().x(), -scrollOrigin().y());
 }
 
 void FrameView::adjustScrollbarOpacity() {
   if (m_horizontalScrollbar && layerForHorizontalScrollbar()) {
     bool isOpaqueScrollbar = !m_horizontalScrollbar->isOverlayScrollbar();
     layerForHorizontalScrollbar()->setContentsOpaque(isOpaqueScrollbar);
   }
   if (m_verticalScrollbar && layerForVerticalScrollbar()) {
     bool isOpaqueScrollbar = !m_verticalScrollbar->isOverlayScrollbar();
     layerForVerticalScrollbar()->setContentsOpaque(isOpaqueScrollbar);
@@ skipping 10 matching lines @@
   if (!scrollbar) {
     IntSize scrollSize = m_contentsSize - visibleContentRect().size();
     scrollSize.clampNegativeToZero();
     return orientation == HorizontalScrollbar ? scrollSize.width()
                                               : scrollSize.height();
   }
 
   return scrollbar->totalSize() - scrollbar->visibleSize();
 }
 
-void FrameView::setScrollOffset(const DoublePoint& offset,
-                                ScrollType scrollType) {
-  DoublePoint oldPosition = m_scrollPosition;
-  DoubleSize scrollDelta = offset - oldPosition;
+void FrameView::updateScrollOffset(const ScrollOffset& offset,
+                                   ScrollType scrollType) {
+  ScrollOffset scrollDelta = offset - m_scrollOffset;
   if (scrollDelta.isZero())
     return;
 
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     // Don't scroll the FrameView!
     ASSERT_NOT_REACHED();
   }
 
-  m_scrollPosition = offset;
+  m_scrollOffset = offset;
 
   if (!scrollbarsSuppressed())
     m_pendingScrollDelta += scrollDelta;
 
   clearFragmentAnchor();
   updateLayersAndCompositingAfterScrollIfNeeded(scrollDelta);
 
   Document* document = m_frame->document();
   document->enqueueScrollEventForNode(document);
 
@@ skipping 235 matching lines @@
 void FrameView::updateScrollbars() {
   m_needsScrollbarsUpdate = false;
 
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled())
     return;
 
   // Avoid drawing two sets of scrollbars when visual viewport is enabled.
   if (visualViewportSuppliesScrollbars()) {
     setHasHorizontalScrollbar(false);
     setHasVerticalScrollbar(false);
-    adjustScrollPositionFromUpdateScrollbars();
+    adjustScrollOffsetFromUpdateScrollbars();
     return;
   }
 
   if (m_inUpdateScrollbars)
     return;
   InUpdateScrollbarsScope inUpdateScrollbarsScope(this);
 
   bool scrollbarExistenceChanged = false;
 
   if (needsScrollbarReconstruction()) {
@@ skipping 14 matching lines @@
 
   updateScrollbarGeometry();
 
   if (scrollbarExistenceChanged) {
     // FIXME: Is frameRectsChanged really necessary here? Have any frame rects changed?
     frameRectsChanged();
     positionScrollbarLayers();
     updateScrollCorner();
   }
 
-  adjustScrollPositionFromUpdateScrollbars();
+  adjustScrollOffsetFromUpdateScrollbars();
 }
 
-void FrameView::adjustScrollPositionFromUpdateScrollbars() {
-  DoublePoint clamped = clampScrollPosition(scrollPositionDouble());
+void FrameView::adjustScrollOffsetFromUpdateScrollbars() {
+  ScrollOffset clamped = clampScrollOffset(scrollOffset());
   // Restore before clamping because clamping clears the scroll anchor.
   // TODO(ymalik): This same logic exists in PaintLayerScrollableArea.
   // Remove when root-layer-scrolls is enabled.
-  if (clamped != scrollPositionDouble() && shouldPerformScrollAnchoring()) {
+  if (clamped != scrollOffset() && shouldPerformScrollAnchoring()) {
     m_scrollAnchor.restore();
-    clamped = clampScrollPosition(scrollPositionDouble());
+    clamped = clampScrollOffset(scrollOffset());
   }
-  if (clamped != scrollPositionDouble() || scrollOriginChanged()) {
-    ScrollableArea::setScrollPosition(clamped, ProgrammaticScroll);
+  if (clamped != scrollOffset() || scrollOriginChanged()) {
+    ScrollableArea::setScrollOffset(clamped, ProgrammaticScroll);
     resetScrollOriginChanged();
   }
 }
 
 void FrameView::scrollContentsIfNeeded() {
   if (m_pendingScrollDelta.isZero())
     return;
-  DoubleSize scrollDelta = m_pendingScrollDelta;
-  m_pendingScrollDelta = DoubleSize();
+  ScrollOffset scrollDelta = m_pendingScrollDelta;
+  m_pendingScrollDelta = ScrollOffset();
   // FIXME: Change scrollContents() to take DoubleSize. crbug.com/414283.
   scrollContents(flooredIntSize(scrollDelta));
 }
 
 void FrameView::scrollContents(const IntSize& scrollDelta) {
   HostWindow* window = getHostWindow();
   if (!window)
     return;
 
   TRACE_EVENT0("blink", "FrameView::scrollContents");
 
   if (!scrollContentsFastPath(-scrollDelta))
     scrollContentsSlowPath();
 
   // This call will move children with native widgets (plugins) and invalidate them as well.
   frameRectsChanged();
 }
 
 IntPoint FrameView::contentsToFrame(const IntPoint& pointInContentSpace) const {
-  return pointInContentSpace - scrollOffset();
+  return pointInContentSpace - scrollOffsetInt();
 }
 
 IntRect FrameView::contentsToFrame(const IntRect& rectInContentSpace) const {
   return IntRect(contentsToFrame(rectInContentSpace.location()),
                  rectInContentSpace.size());
 }
 
 FloatPoint FrameView::frameToContents(const FloatPoint& pointInFrame) const {
   return pointInFrame + scrollOffset();
 }
 
 IntPoint FrameView::frameToContents(const IntPoint& pointInFrame) const {
-  return pointInFrame + scrollOffset();
+  return pointInFrame + scrollOffsetInt();
 }
 
 IntRect FrameView::frameToContents(const IntRect& rectInFrame) const {
   return IntRect(frameToContents(rectInFrame.location()), rectInFrame.size());
 }
 
 IntPoint FrameView::rootFrameToContents(const IntPoint& rootFramePoint) const {
   IntPoint framePoint = convertFromRootFrame(rootFramePoint);
   return frameToContents(framePoint);
 }
@@ skipping 166 matching lines @@
   return this;
 }
 
 LayoutRect FrameView::scrollIntoView(const LayoutRect& rectInContent,
                                      const ScrollAlignment& alignX,
                                      const ScrollAlignment& alignY,
                                      ScrollType scrollType) {
   LayoutRect viewRect(visibleContentRect());
   LayoutRect exposeRect =
       ScrollAlignment::getRectToExpose(viewRect, rectInContent, alignX, alignY);
-  if (exposeRect != viewRect)
-    setScrollPosition(DoublePoint(exposeRect.x(), exposeRect.y()), scrollType);
+  if (exposeRect != viewRect) {
+    setScrollOffset(
+        ScrollOffset(exposeRect.x().toFloat(), exposeRect.y().toFloat()),
+        scrollType);
+  }
 
   // Scrolling the FrameView cannot change the input rect's location relative to the document.
   return rectInContent;
 }
 
 IntRect FrameView::scrollCornerRect() const {
   IntRect cornerRect;
 
   if (hasOverlayScrollbars())
     return cornerRect;
@@ skipping 394 matching lines @@
 }
 
 bool FrameView::canThrottleRendering() const {
   if (!RuntimeEnabledFeatures::renderingPipelineThrottlingEnabled())
     return false;
   return m_subtreeThrottled ||
          (m_hiddenForThrottling && m_crossOriginForThrottling);
 }
 
 }  // namespace blink