Use float for scroll offset.

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

 /*
  * Copyright (C) 2013 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 139 matching lines @@
 }
 
 FloatSize VisualViewport::visibleSize() const {
   FloatSize scaledSize(m_size);
   scaledSize.expand(0, m_topControlsAdjustment);
   scaledSize.scale(1 / m_scale);
   return scaledSize;
 }
 
 FloatRect VisualViewport::visibleRect() const {
-  return FloatRect(location(), visibleSize());
+  return FloatRect(FloatPoint(scrollOffset()), visibleSize());
 }
 
 FloatRect VisualViewport::visibleRectInDocument() const {
   if (!mainFrame() || !mainFrame()->view())
     return FloatRect();
 
-  FloatPoint viewLocation = FloatPoint(
-      mainFrame()->view()->getScrollableArea()->scrollPositionDouble());
+  FloatPoint viewLocation =
+      FloatPoint(mainFrame()->view()->getScrollableArea()->scrollOffset());
   return FloatRect(viewLocation, visibleSize());
 }
 
 FloatRect VisualViewport::mainViewToViewportCSSPixels(
     const FloatRect& rect) const {
   // Note, this is in CSS Pixels so we don't apply scale.
   FloatRect rectInViewport = rect;
-  rectInViewport.moveBy(-location());
+  rectInViewport.move(-scrollOffset());
   return rectInViewport;
 }
 
 FloatPoint VisualViewport::viewportCSSPixelsToRootFrame(
     const FloatPoint& point) const {
   // Note, this is in CSS Pixels so we don't apply scale.
   FloatPoint pointInRootFrame = point;
-  pointInRootFrame.moveBy(location());
+  pointInRootFrame.move(scrollOffset());
   return pointInRootFrame;
 }
 
 void VisualViewport::setLocation(const FloatPoint& newLocation) {
   setScaleAndLocation(m_scale, newLocation);
 }
 
-void VisualViewport::move(const FloatPoint& delta) {
-  setLocation(m_offset + delta);
-}
-
-void VisualViewport::move(const FloatSize& delta) {
-  setLocation(m_offset + delta);
+void VisualViewport::move(const ScrollOffset& delta) {
+  setLocation(FloatPoint(m_offset + delta));
 }
 
 void VisualViewport::setScale(float scale) {
-  setScaleAndLocation(scale, m_offset);
+  setScaleAndLocation(scale, FloatPoint(m_offset));
 }
 
 double VisualViewport::scrollLeft() {
   if (!mainFrame())
     return 0;
 
   updateStyleAndLayoutIgnorePendingStylesheets();
 
   return adjustScrollForAbsoluteZoom(visibleRect().x(),
                                      mainFrame()->pageZoomFactor());
 }
 
 double VisualViewport::scrollTop() {
   if (!mainFrame())
     return 0;
 
   updateStyleAndLayoutIgnorePendingStylesheets();
 
   return adjustScrollForAbsoluteZoom(visibleRect().y(),
                                      mainFrame()->pageZoomFactor());
 }
 
 double VisualViewport::clientWidth() {
   if (!mainFrame())
     return 0;
 
   updateStyleAndLayoutIgnorePendingStylesheets();
 
-  double width = adjustScrollForAbsoluteZoom(visibleSize().width(),
-                                             mainFrame()->pageZoomFactor());
+  float width = adjustScrollForAbsoluteZoom(visibleSize().width(),
+                                            mainFrame()->pageZoomFactor());
   return width - mainFrame()->view()->verticalScrollbarWidth() / m_scale;
 }
 
 double VisualViewport::clientHeight() {
   if (!mainFrame())
     return 0;
 
   updateStyleAndLayoutIgnorePendingStylesheets();
 
-  double height = adjustScrollForAbsoluteZoom(visibleSize().height(),
-                                              mainFrame()->pageZoomFactor());
+  float height = adjustScrollForAbsoluteZoom(visibleSize().height(),
+                                             mainFrame()->pageZoomFactor());
   return height - mainFrame()->view()->horizontalScrollbarHeight() / m_scale;
 }
 
 double VisualViewport::pageScale() {
   updateStyleAndLayoutIgnorePendingStylesheets();
 
   return m_scale;
 }
 
 void VisualViewport::setScaleAndLocation(float scale,
                                          const FloatPoint& location) {
   if (didSetScaleOrLocation(scale, location))
     notifyRootFrameViewport();
 }
 
 bool VisualViewport::didSetScaleOrLocation(float scale,
                                            const FloatPoint& location) {
   if (!mainFrame())
     return false;
 
   bool valuesChanged = false;
 
   if (scale != m_scale) {
     m_scale = scale;
     valuesChanged = true;
     frameHost().chromeClient().pageScaleFactorChanged();
     enqueueResizeEvent();
   }
 
-  FloatPoint clampedOffset(clampOffsetToBoundaries(location));
+  ScrollOffset clampedOffset = clampScrollOffset(toScrollOffset(location));
 
   if (clampedOffset != m_offset) {
     m_offset = clampedOffset;
-    scrollAnimator().setCurrentPosition(m_offset);
+    scrollAnimator().setCurrentOffset(m_offset);
 
     // SVG runs with accelerated compositing disabled so no
     // ScrollingCoordinator.
     if (ScrollingCoordinator* coordinator =
             frameHost().page().scrollingCoordinator())
       coordinator->scrollableAreaScrollLayerDidChange(this);
 
     if (!frameHost().settings().inertVisualViewport()) {
       if (Document* document = mainFrame()->document())
         document->enqueueScrollEventForNode(document);
@@ skipping 30 matching lines @@
   // Keep the center-of-pinch anchor in a stable position over the course
   // of the magnify.
   FloatPoint anchorAtOldScale = anchor.scaledBy(1.f / oldPageScale);
   FloatPoint anchorAtNewScale = anchor.scaledBy(1.f / newPageScale);
   FloatSize anchorDelta = anchorAtOldScale - anchorAtNewScale;
 
   // First try to use the anchor's delta to scroll the FrameView.
   FloatSize anchorDeltaUnusedByScroll = anchorDelta;
 
   // Manually bubble any remaining anchor delta up to the visual viewport.
-  FloatPoint newLocation(location() + anchorDeltaUnusedByScroll);
+  FloatPoint newLocation(FloatPoint(scrollOffset()) +
+                         anchorDeltaUnusedByScroll);
   setScaleAndLocation(newPageScale, newLocation);
   return true;
 }
 
 // Modifies the top of the graphics layer tree to add layers needed to support
 // the inner/outer viewport fixed-position model for pinch zoom. When finished,
 // the tree will look like this (with * denoting added layers):
 //
 // *rootTransformLayer
 //  +- *innerViewportContainerLayer (fixed pos container)
@@ skipping 162 matching lines @@
 }
 
 bool VisualViewport::scrollAnimatorEnabled() const {
   return frameHost().settings().scrollAnimatorEnabled();
 }
 
 HostWindow* VisualViewport::getHostWindow() const {
   return &frameHost().chromeClient();
 }
 
-DoubleRect VisualViewport::visibleContentRectDouble(
-    IncludeScrollbarsInRect) const {
-  return visibleRect();
-}
-
-IntRect VisualViewport::visibleContentRect(
-    IncludeScrollbarsInRect scrollbarInclusion) const {
-  return enclosingIntRect(visibleContentRectDouble(scrollbarInclusion));
-}
-
 bool VisualViewport::shouldUseIntegerScrollOffset() const {
   LocalFrame* frame = mainFrame();
   if (frame && frame->settings() &&
       !frame->settings()->preferCompositingToLCDTextEnabled())
     return true;
 
   return ScrollableArea::shouldUseIntegerScrollOffset();
 }
 
-void VisualViewport::setScrollPosition(const DoublePoint& scrollPoint,
-                                       ScrollType scrollType,
-                                       ScrollBehavior scrollBehavior) {
-  // We clamp the position here, because the ScrollAnimator may otherwise be
-  // set to a non-clamped position by ScrollableArea::setScrollPosition,
+void VisualViewport::setScrollOffset(const ScrollOffset& offset,
+                                     ScrollType scrollType,
+                                     ScrollBehavior scrollBehavior) {
+  // We clamp the offset here, because the ScrollAnimator may otherwise be
+  // set to a non-clamped offset by ScrollableArea::setScrollOffset,
   // which may lead to incorrect scrolling behavior in RootFrameViewport down
   // the line.
   // TODO(eseckler): Solve this instead by ensuring that ScrollableArea and
   // ScrollAnimator are kept in sync. This requires that ScrollableArea always
   // stores fractional offsets and that truncation happens elsewhere, see
   // crbug.com/626315.
-  DoublePoint newScrollPosition = clampScrollPosition(scrollPoint);
-  ScrollableArea::setScrollPosition(newScrollPosition, scrollType,
-                                    scrollBehavior);
+  ScrollOffset newScrollOffset = clampScrollOffset(offset);
+  ScrollableArea::setScrollOffset(newScrollOffset, scrollType, scrollBehavior);
 }
 
 int VisualViewport::scrollSize(ScrollbarOrientation orientation) const {
-  IntSize scrollDimensions = maximumScrollPosition() - minimumScrollPosition();
+  IntSize scrollDimensions =
+      maximumScrollOffsetInt() - minimumScrollOffsetInt();
   return (orientation == HorizontalScrollbar) ? scrollDimensions.width()
                                               : scrollDimensions.height();
 }
 
-IntPoint VisualViewport::minimumScrollPosition() const {
-  return IntPoint();
+IntSize VisualViewport::minimumScrollOffsetInt() const {
+  return IntSize();
 }
 
-IntPoint VisualViewport::maximumScrollPosition() const {
-  return flooredIntPoint(maximumScrollPositionDouble());
+IntSize VisualViewport::maximumScrollOffsetInt() const {
+  return flooredIntSize(maximumScrollOffset());
 }
 
-DoublePoint VisualViewport::maximumScrollPositionDouble() const {
+ScrollOffset VisualViewport::maximumScrollOffset() const {
   if (!mainFrame())
-    return IntPoint();
+    return ScrollOffset();
 
   // TODO(bokan): We probably shouldn't be storing the bounds in a float.
   // crbug.com/470718.
   FloatSize frameViewSize(contentsSize());
 
   if (m_topControlsAdjustment) {
     float minScale =
         frameHost().pageScaleConstraintsSet().finalConstraints().minimumScale;
     frameViewSize.expand(0, m_topControlsAdjustment / minScale);
   }
 
   frameViewSize.scale(m_scale);
   frameViewSize = FloatSize(flooredIntSize(frameViewSize));
 
   FloatSize viewportSize(m_size);
   viewportSize.expand(0, ceilf(m_topControlsAdjustment));
 
   FloatSize maxPosition = frameViewSize - viewportSize;
   maxPosition.scale(1 / m_scale);
-  return DoublePoint(maxPosition);
+  return ScrollOffset(maxPosition);
 }
 
 IntPoint VisualViewport::clampDocumentOffsetAtScale(const IntPoint& offset,
                                                     float scale) {
   if (!mainFrame() || !mainFrame()->view())
     return IntPoint();
 
   FrameView* view = mainFrame()->view();
 
   FloatSize scaledSize(m_size);
   scaledSize.scale(1 / scale);
 
-  IntPoint visualViewportMax =
-      flooredIntPoint(FloatSize(contentsSize()) - scaledSize);
-  IntPoint max = view->maximumScrollPosition() + visualViewportMax;
-  IntPoint min =
-      view->minimumScrollPosition();  // VisualViewportMin should be (0, 0)
+  IntSize visualViewportMax =
+      flooredIntSize(FloatSize(contentsSize()) - scaledSize);
+  IntSize max = view->maximumScrollOffsetInt() + visualViewportMax;
+  IntSize min =
+      view->minimumScrollOffsetInt();  // VisualViewportMin should be (0, 0)
 
-  IntPoint clamped = offset;
+  IntSize clamped = toIntSize(offset);
   clamped = clamped.shrunkTo(max);
   clamped = clamped.expandedTo(min);
-  return clamped;
+  return IntPoint(clamped);
 }
 
 void VisualViewport::setTopControlsAdjustment(float adjustment) {
   m_topControlsAdjustment = adjustment;
 }
 
 IntRect VisualViewport::scrollableAreaBoundingBox() const {
   // This method should return the bounding box in the parent view's coordinate
   // space; however, VisualViewport technically isn't a child of any Frames.
   // Nonetheless, the VisualViewport always occupies the entire main frame so
   // just return that.
   LocalFrame* frame = mainFrame();
 
   if (!frame || !frame->view())
     return IntRect();
 
   return frame->view()->frameRect();
 }
 
 IntSize VisualViewport::contentsSize() const {
   LocalFrame* frame = mainFrame();
 
   if (!frame || !frame->view())
     return IntSize();
 
   return frame->view()->visibleContentRect(IncludeScrollbars).size();
 }
 
-void VisualViewport::setScrollOffset(const DoublePoint& offset,
-                                     ScrollType scrollType) {
-  if (didSetScaleOrLocation(m_scale, toFloatPoint(offset)) &&
+void VisualViewport::updateScrollOffset(const ScrollOffset& position,
+                                        ScrollType scrollType) {
+  if (didSetScaleOrLocation(m_scale, FloatPoint(position)) &&
       scrollType != AnchoringScroll)
     notifyRootFrameViewport();
 }
 
 GraphicsLayer* VisualViewport::layerForContainer() const {
   return m_innerViewportContainerLayer.get();
 }
 
 GraphicsLayer* VisualViewport::layerForScrolling() const {
   return m_innerViewportScrollLayer.get();
@@ skipping 21 matching lines @@
   return frameHost().page().mainFrame() &&
                  frameHost().page().mainFrame()->isLocalFrame()
              ? frameHost().page().deprecatedLocalMainFrame()
              : 0;
 }
 
 Widget* VisualViewport::getWidget() {
   return mainFrame()->view();
 }
 
-FloatPoint VisualViewport::clampOffsetToBoundaries(const FloatPoint& offset) {
-  FloatPoint clampedOffset(offset);
-  clampedOffset =
-      clampedOffset.shrunkTo(FloatPoint(maximumScrollPositionDouble()));
-  clampedOffset =
-      clampedOffset.expandedTo(FloatPoint(minimumScrollPositionDouble()));
-  return clampedOffset;
-}
-
 void VisualViewport::clampToBoundaries() {
-  setLocation(m_offset);
+  setLocation(FloatPoint(m_offset));
 }
 
 FloatRect VisualViewport::viewportToRootFrame(
     const FloatRect& rectInViewport) const {
   FloatRect rectInRootFrame = rectInViewport;
   rectInRootFrame.scale(1 / scale());
-  rectInRootFrame.moveBy(location());
+  rectInRootFrame.move(scrollOffset());
   return rectInRootFrame;
 }
 
 IntRect VisualViewport::viewportToRootFrame(
     const IntRect& rectInViewport) const {
   // FIXME: How to snap to pixels?
   return enclosingIntRect(viewportToRootFrame(FloatRect(rectInViewport)));
 }
 
 FloatRect VisualViewport::rootFrameToViewport(
     const FloatRect& rectInRootFrame) const {
   FloatRect rectInViewport = rectInRootFrame;
-  rectInViewport.moveBy(-location());
+  rectInViewport.move(-scrollOffset());
   rectInViewport.scale(scale());
   return rectInViewport;
 }
 
 IntRect VisualViewport::rootFrameToViewport(
     const IntRect& rectInRootFrame) const {
   // FIXME: How to snap to pixels?
   return enclosingIntRect(rootFrameToViewport(FloatRect(rectInRootFrame)));
 }
 
 FloatPoint VisualViewport::viewportToRootFrame(
     const FloatPoint& pointInViewport) const {
   FloatPoint pointInRootFrame = pointInViewport;
   pointInRootFrame.scale(1 / scale(), 1 / scale());
-  pointInRootFrame.moveBy(location());
+  pointInRootFrame.move(scrollOffset());
   return pointInRootFrame;
 }
 
 FloatPoint VisualViewport::rootFrameToViewport(
     const FloatPoint& pointInRootFrame) const {
   FloatPoint pointInViewport = pointInRootFrame;
-  pointInViewport.moveBy(-location());
+  pointInViewport.move(-scrollOffset());
   pointInViewport.scale(scale(), scale());
   return pointInViewport;
 }
 
 IntPoint VisualViewport::viewportToRootFrame(
     const IntPoint& pointInViewport) const {
   // FIXME: How to snap to pixels?
   return flooredIntPoint(
       FloatPoint(viewportToRootFrame(FloatPoint(pointInViewport))));
 }
@@ skipping 106 matching lines @@
   } else if (graphicsLayer == m_rootTransformLayer.get()) {
     name = "Root Transform Layer";
   } else {
     ASSERT_NOT_REACHED();
   }
 
   return name;
 }
 
 }  // namespace blink