Use float for scroll offset.

third_party/WebKit/Source/web/tests/VisualViewportTest.cpp

 // Copyright 2014 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/VisualViewport.h"
 
 #include "core/dom/Document.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 28 matching lines @@
 #include "web/tests/FrameTestHelpers.h"
 
 #include <string>
 
 #define ASSERT_POINT_EQ(expected, actual)    \
   do {                                       \
     ASSERT_EQ((expected).x(), (actual).x()); \
     ASSERT_EQ((expected).y(), (actual).y()); \
   } while (false)
 
+#define ASSERT_SIZE_EQ(expected, actual)               \
+  do {                                                 \
+    ASSERT_EQ((expected).width(), (actual).width());   \
+    ASSERT_EQ((expected).height(), (actual).height()); \
+  } while (false)
+
 #define EXPECT_POINT_EQ(expected, actual)    \
   do {                                       \
     EXPECT_EQ((expected).x(), (actual).x()); \
     EXPECT_EQ((expected).y(), (actual).y()); \
   } while (false)
 
 #define EXPECT_FLOAT_POINT_EQ(expected, actual)    \
   do {                                             \
     EXPECT_FLOAT_EQ((expected).x(), (actual).x()); \
     EXPECT_FLOAT_EQ((expected).y(), (actual).y()); \
@@ skipping 174 matching lines @@
   registerMockedHttpURLLoad("content-width-1000.html");
   navigateTo(m_baseURL + "content-width-1000.html");
 
   FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
 
   visualViewport.setScale(2);
 
   // Fully scroll both viewports.
-  frameView.layoutViewportScrollableArea()->setScrollPosition(
-      DoublePoint(10000, 10000), ProgrammaticScroll);
+  frameView.layoutViewportScrollableArea()->setScrollOffset(
+      ScrollOffset(10000, 10000), ProgrammaticScroll);
   visualViewport.move(FloatSize(10000, 10000));
 
   // Sanity check.
-  ASSERT_POINT_EQ(FloatPoint(400, 300), visualViewport.location());
-  ASSERT_POINT_EQ(
-      DoublePoint(200, 1400),
-      frameView.layoutViewportScrollableArea()->scrollPositionDouble());
+  ASSERT_SIZE_EQ(FloatSize(400, 300), visualViewport.scrollOffset());
+  ASSERT_SIZE_EQ(ScrollOffset(200, 1400),
+                 frameView.layoutViewportScrollableArea()->scrollOffset());
 
-  DoublePoint expectedLocation =
-      frameView.getScrollableArea()->visibleContentRectDouble().location();
+  IntPoint expectedLocation =
+      frameView.getScrollableArea()->visibleContentRect().location();
 
   // Shrink the WebView, this should cause both viewports to shrink and
   // WebView should do whatever it needs to do to preserve the visible
   // location.
   webViewImpl()->resize(IntSize(700, 550));
 
   EXPECT_POINT_EQ(
       expectedLocation,
-      frameView.getScrollableArea()->visibleContentRectDouble().location());
+      frameView.getScrollableArea()->visibleContentRect().location());
 
   webViewImpl()->resize(IntSize(800, 600));
 
   EXPECT_POINT_EQ(
       expectedLocation,
-      frameView.getScrollableArea()->visibleContentRectDouble().location());
+      frameView.getScrollableArea()->visibleContentRect().location());
 }
 
 // Test that the VisualViewport works as expected in case of a scaled
 // and scrolled viewport - scroll down.
 TEST_P(ParameterizedVisualViewportTest, TestResizeAfterVerticalScroll) {
 /*
                  200                                 200
         |                   |               |                   |
         |                   |               |                   |
         |                   | 800           |                   | 800
@@ skipping 25 matching lines @@
 
   initializeWithAndroidSettings();
 
   registerMockedHttpURLLoad("200-by-800-viewport.html");
   navigateTo(m_baseURL + "200-by-800-viewport.html");
 
   webViewImpl()->resize(IntSize(100, 200));
 
   // Scroll main frame to the bottom of the document
   webViewImpl()->mainFrame()->setScrollOffset(WebSize(0, 400));
-  EXPECT_POINT_EQ(
-      IntPoint(0, 400),
-      frame()->view()->layoutViewportScrollableArea()->scrollPosition());
+  EXPECT_SIZE_EQ(
+      ScrollOffset(0, 400),
+      frame()->view()->layoutViewportScrollableArea()->scrollOffset());
 
   webViewImpl()->setPageScaleFactor(2.0);
 
   // Scroll visual viewport to the bottom of the main frame
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
   visualViewport.setLocation(FloatPoint(0, 300));
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 300), visualViewport.location());
+  EXPECT_FLOAT_SIZE_EQ(FloatSize(0, 300), visualViewport.scrollOffset());
 
   // Verify the initial size of the visual viewport in the CSS pixels
   EXPECT_FLOAT_SIZE_EQ(FloatSize(50, 100), visualViewport.visibleRect().size());
 
   // Perform the resizing
   webViewImpl()->resize(IntSize(200, 100));
 
   // After resizing the scale changes 2.0 -> 4.0
   EXPECT_FLOAT_SIZE_EQ(FloatSize(50, 25), visualViewport.visibleRect().size());
 
-  EXPECT_POINT_EQ(
-      IntPoint(0, 625),
-      frame()->view()->layoutViewportScrollableArea()->scrollPosition());
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 75), visualViewport.location());
+  EXPECT_SIZE_EQ(
+      ScrollOffset(0, 625),
+      frame()->view()->layoutViewportScrollableArea()->scrollOffset());
+  EXPECT_FLOAT_SIZE_EQ(FloatSize(0, 75), visualViewport.scrollOffset());
 }
 
 // Test that the VisualViewport works as expected in case if a scaled
 // and scrolled viewport - scroll right.
 TEST_P(ParameterizedVisualViewportTest, TestResizeAfterHorizontalScroll) {
 /*
                  200                                 200
         ---------------o-----               ---------------o-----
         |              |    |               |            25|    |
         |              |    |               |              -----|
@@ skipping 33 matching lines @@
   webViewImpl()->resize(IntSize(100, 200));
 
   // Outer viewport takes the whole width of the document.
 
   webViewImpl()->setPageScaleFactor(2.0);
 
   // Scroll visual viewport to the right edge of the frame
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
   visualViewport.setLocation(FloatPoint(150, 0));
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(150, 0), visualViewport.location());
+  EXPECT_FLOAT_SIZE_EQ(FloatSize(150, 0), visualViewport.scrollOffset());
 
   // Verify the initial size of the visual viewport in the CSS pixels
   EXPECT_FLOAT_SIZE_EQ(FloatSize(50, 100), visualViewport.visibleRect().size());
 
   webViewImpl()->resize(IntSize(200, 100));
 
   // After resizing the scale changes 2.0 -> 4.0
   EXPECT_FLOAT_SIZE_EQ(FloatSize(50, 25), visualViewport.visibleRect().size());
 
-  EXPECT_POINT_EQ(IntPoint(0, 0), frame()->view()->scrollPosition());
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(150, 0), visualViewport.location());
+  EXPECT_SIZE_EQ(ScrollOffset(0, 0), frame()->view()->scrollOffset());
+  EXPECT_FLOAT_SIZE_EQ(FloatSize(150, 0), visualViewport.scrollOffset());
 }
 
 // Test that the container layer gets sized properly if the WebView is resized
 // prior to the VisualViewport being attached to the layer tree.
 TEST_P(ParameterizedVisualViewportTest, TestWebViewResizedBeforeAttachment) {
   initializeWithDesktopSettings();
   FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
   GraphicsLayer* rootGraphicsLayer =
       frameView.layoutViewItem().compositor()->rootGraphicsLayer();
 
@@ skipping 79 matching lines @@
 
   // Scale the viewport to 2X and move it.
   visualViewport.setScale(2);
   visualViewport.setLocation(FloatPoint(10, 15));
   EXPECT_FLOAT_RECT_EQ(FloatRect(10, 15, 50, 200),
                        visualViewport.visibleRectInDocument());
 
   // Scroll the layout viewport. Ensure its offset is reflected in
   // visibleRectInDocument().
   FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
-  frameView.layoutViewportScrollableArea()->setScrollPosition(
-      DoublePoint(40, 100), ProgrammaticScroll);
+  frameView.layoutViewportScrollableArea()->setScrollOffset(
+      ScrollOffset(40, 100), ProgrammaticScroll);
   EXPECT_FLOAT_RECT_EQ(FloatRect(50, 115, 50, 200),
                        visualViewport.visibleRectInDocument());
 }
 
 TEST_P(ParameterizedVisualViewportTest,
        TestFractionalScrollOffsetIsNotOverwritten) {
   bool origFractionalOffsetsEnabled =
       RuntimeEnabledFeatures::fractionalScrollOffsetsEnabled();
   RuntimeEnabledFeatures::setFractionalScrollOffsetsEnabled(true);
 
   initializeWithAndroidSettings();
   webViewImpl()->resize(IntSize(200, 250));
 
   registerMockedHttpURLLoad("200-by-800-viewport.html");
   navigateTo(m_baseURL + "200-by-800-viewport.html");
 
   FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
-  frameView.layoutViewportScrollableArea()->setScrollPosition(
-      DoublePoint(0, 10.5), ProgrammaticScroll);
-  frameView.layoutViewportScrollableArea()->ScrollableArea::setScrollPosition(
-      DoublePoint(10, 30.5), CompositorScroll);
+  frameView.layoutViewportScrollableArea()->setScrollOffset(
+      ScrollOffset(0, 10.5), ProgrammaticScroll);
+  frameView.layoutViewportScrollableArea()->ScrollableArea::setScrollOffset(
+      ScrollOffset(10, 30.5), CompositorScroll);
 
-  EXPECT_EQ(
-      30.5,
-      frameView.layoutViewportScrollableArea()->scrollPositionDouble().y());
+  EXPECT_EQ(30.5,
+            frameView.layoutViewportScrollableArea()->scrollOffset().height());
 
   RuntimeEnabledFeatures::setFractionalScrollOffsetsEnabled(
       origFractionalOffsetsEnabled);
 }
 
 // Test that the viewport's scroll offset is always appropriately bounded such
 // that the visual viewport always stays within the bounds of the main frame.
 TEST_P(ParameterizedVisualViewportTest, TestOffsetClamping) {
   initializeWithDesktopSettings();
   webViewImpl()->resize(IntSize(320, 240));
@@ skipping 218 matching lines @@
 
   // Load a wider page first, the navigation should resize the scroll layer to
   // the smaller size on the second navigation.
   registerMockedHttpURLLoad("content-width-1000.html");
   navigateTo(m_baseURL + "content-width-1000.html");
   webViewImpl()->updateAllLifecyclePhases();
 
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
   visualViewport.setScale(2);
-  visualViewport.move(FloatPoint(50, 60));
+  visualViewport.move(ScrollOffset(50, 60));
 
   // Move and scale the viewport to make sure it gets reset in the navigation.
-  EXPECT_POINT_EQ(FloatPoint(50, 60), visualViewport.location());
+  EXPECT_SIZE_EQ(FloatSize(50, 60), visualViewport.scrollOffset());
   EXPECT_EQ(2, visualViewport.scale());
 
   // Navigate again, this time the FrameView should be smaller.
   registerMockedHttpURLLoad("viewport-device-width.html");
   navigateTo(m_baseURL + "viewport-device-width.html");
 
   // Ensure the scroll layer matches the frame view's size.
   EXPECT_SIZE_EQ(FloatSize(320, 240), visualViewport.scrollLayer()->size());
 
   // Ensure the location and scale were reset.
-  EXPECT_POINT_EQ(FloatPoint(), visualViewport.location());
+  EXPECT_SIZE_EQ(FloatSize(), visualViewport.scrollOffset());
   EXPECT_EQ(1, visualViewport.scale());
 }
 
 // The main FrameView's size should be set such that its the size of the visual
 // viewport at minimum scale. Test that the FrameView is appropriately sized in
 // the presence of a viewport <meta> tag.
 TEST_P(ParameterizedVisualViewportTest,
        TestFrameViewSizedToViewportMetaMinimumScale) {
   initializeWithAndroidSettings();
   webViewImpl()->resize(IntSize(320, 240));
@@ skipping 65 matching lines @@
 // Test that the HistoryItem for the page stores the visual viewport's offset
 // and scale.
 TEST_P(ParameterizedVisualViewportTest, TestSavedToHistoryItem) {
   initializeWithDesktopSettings();
   webViewImpl()->resize(IntSize(200, 300));
   webViewImpl()->updateAllLifecyclePhases();
 
   registerMockedHttpURLLoad("200-by-300.html");
   navigateTo(m_baseURL + "200-by-300.html");
 
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 0),
-                        toLocalFrame(webViewImpl()->page()->mainFrame())
-                            ->loader()
-                            .currentItem()
-                            ->visualViewportScrollPoint());
+  EXPECT_SIZE_EQ(ScrollOffset(0, 0),
+                 toLocalFrame(webViewImpl()->page()->mainFrame())
+                     ->loader()
+                     .currentItem()
+                     ->visualViewportScrollOffset());
 
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
   visualViewport.setScale(2);
 
   EXPECT_EQ(2, toLocalFrame(webViewImpl()->page()->mainFrame())
                    ->loader()
                    .currentItem()
                    ->pageScaleFactor());
 
   visualViewport.setLocation(FloatPoint(10, 20));
 
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(10, 20),
-                        toLocalFrame(webViewImpl()->page()->mainFrame())
-                            ->loader()
-                            .currentItem()
-                            ->visualViewportScrollPoint());
+  EXPECT_SIZE_EQ(ScrollOffset(10, 20),
+                 toLocalFrame(webViewImpl()->page()->mainFrame())
+                     ->loader()
+                     .currentItem()
+                     ->visualViewportScrollOffset());
 }
 
 // Test restoring a HistoryItem properly restores the visual viewport's state.
 TEST_P(ParameterizedVisualViewportTest, TestRestoredFromHistoryItem) {
   initializeWithDesktopSettings();
   webViewImpl()->resize(IntSize(200, 300));
 
   registerMockedHttpURLLoad("200-by-300.html");
 
   WebHistoryItem item;
@@ skipping 35 matching lines @@
   item.setScrollOffset(WebPoint(120, 180));
   item.setPageScaleFactor(2);
 
   FrameTestHelpers::loadHistoryItem(webViewImpl()->mainFrame(), item,
                                     WebHistoryDifferentDocumentLoad,
                                     WebCachePolicy::UseProtocolCachePolicy);
 
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
   EXPECT_EQ(2, visualViewport.scale());
-  EXPECT_POINT_EQ(IntPoint(100, 150), frame()->view()->scrollPosition());
+  EXPECT_SIZE_EQ(ScrollOffset(100, 150), frame()->view()->scrollOffset());
   EXPECT_FLOAT_POINT_EQ(FloatPoint(20, 30),
                         visualViewport.visibleRect().location());
 }
 
 // Test that navigation to a new page with a different sized main frame doesn't
 // clobber the history item's main frame scroll offset. crbug.com/371867
 TEST_P(ParameterizedVisualViewportTest,
        TestNavigateToSmallerFrameViewHistoryItemClobberBug) {
   initializeWithAndroidSettings();
   webViewImpl()->resize(IntSize(400, 400));
   webViewImpl()->updateAllLifecyclePhases();
 
   registerMockedHttpURLLoad("content-width-1000.html");
   navigateTo(m_baseURL + "content-width-1000.html");
 
   FrameView* frameView = webViewImpl()->mainFrameImpl()->frameView();
-  frameView->layoutViewportScrollableArea()->setScrollPosition(
-      IntPoint(0, 1000), ProgrammaticScroll);
+  frameView->layoutViewportScrollableArea()->setScrollOffset(
+      ScrollOffset(0, 1000), ProgrammaticScroll);
 
   EXPECT_SIZE_EQ(IntSize(1000, 1000), frameView->frameRect().size());
 
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
   visualViewport.setScale(2);
   visualViewport.setLocation(FloatPoint(350, 350));
 
   Persistent<HistoryItem> firstItem =
       webViewImpl()->mainFrameImpl()->frame()->loader().currentItem();
-  EXPECT_POINT_EQ(IntPoint(0, 1000), firstItem->scrollPoint());
+  EXPECT_SIZE_EQ(ScrollOffset(0, 1000), firstItem->scrollOffset());
 
   // Now navigate to a page which causes a smaller frameView. Make sure that
   // navigating doesn't cause the history item to set a new scroll offset
   // before the item was replaced.
   navigateTo("about:blank");
   frameView = webViewImpl()->mainFrameImpl()->frameView();
 
   EXPECT_NE(firstItem,
             webViewImpl()->mainFrameImpl()->frame()->loader().currentItem());
   EXPECT_LT(frameView->frameRect().size().width(), 1000);
-  EXPECT_POINT_EQ(IntPoint(0, 1000), firstItem->scrollPoint());
+  EXPECT_SIZE_EQ(ScrollOffset(0, 1000), firstItem->scrollOffset());
 }
 
 // Test that the coordinates sent into moveRangeSelection are offset by the
 // visual viewport's location.
 TEST_P(ParameterizedVisualViewportTest,
        DISABLED_TestWebFrameRangeAccountsForVisualViewportScroll) {
   initializeWithDesktopSettings();
   webViewImpl()->settings()->setDefaultFontSize(12);
   webViewImpl()->resize(WebSize(640, 480));
   registerMockedHttpURLLoad("move_range.html");
@@ skipping 13 matching lines @@
 
   webViewImpl()->selectionBounds(baseRect, extentRect);
   WebPoint initialPoint(baseRect.x, baseRect.y);
   WebPoint endPoint(extentRect.x, extentRect.y);
 
   // Move the visual viewport over and make the selection in the same
   // screen-space location. The selection should change to two characters to the
   // right and down one line.
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
-  visualViewport.move(FloatPoint(60, 25));
+  visualViewport.move(ScrollOffset(60, 25));
   mainFrame->toWebLocalFrame()->moveRangeSelection(initialPoint, endPoint);
   EXPECT_EQ("t ", mainFrame->toWebLocalFrame()->selectionAsText().utf8());
 }
 
 // Test that the scrollFocusedEditableElementIntoRect method works with the
 // visual viewport.
 TEST_P(ParameterizedVisualViewportTest,
        DISABLED_TestScrollFocusedEditableElementIntoRect) {
   initializeWithDesktopSettings();
   webViewImpl()->resize(IntSize(500, 300));
 
   registerMockedHttpURLLoad("pinch-viewport-input-field.html");
   navigateTo(m_baseURL + "pinch-viewport-input-field.html");
 
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
   webViewImpl()->resizeVisualViewport(IntSize(200, 100));
   webViewImpl()->setInitialFocus(false);
   visualViewport.setLocation(FloatPoint());
   webViewImpl()->scrollFocusedEditableElementIntoRect(IntRect(0, 0, 500, 200));
 
-  EXPECT_POINT_EQ(IntPoint(0, frame()->view()->maximumScrollPosition().y()),
-                  frame()->view()->scrollPosition());
+  EXPECT_SIZE_EQ(
+      ScrollOffset(0, frame()->view()->maximumScrollOffset().height()),
+      frame()->view()->scrollOffset());
   EXPECT_FLOAT_POINT_EQ(FloatPoint(150, 200),
                         visualViewport.visibleRect().location());
 
   // Try it again but with the page zoomed in
-  frame()->view()->setScrollPosition(IntPoint(0, 0), ProgrammaticScroll);
+  frame()->view()->setScrollOffset(ScrollOffset(0, 0), ProgrammaticScroll);
   webViewImpl()->resizeVisualViewport(IntSize(500, 300));
   visualViewport.setLocation(FloatPoint(0, 0));
 
   webViewImpl()->setPageScaleFactor(2);
   webViewImpl()->scrollFocusedEditableElementIntoRect(IntRect(0, 0, 500, 200));
-  EXPECT_POINT_EQ(IntPoint(0, frame()->view()->maximumScrollPosition().y()),
-                  frame()->view()->scrollPosition());
+  EXPECT_SIZE_EQ(
+      ScrollOffset(0, frame()->view()->maximumScrollOffset().height()),
+      frame()->view()->scrollOffset());
   EXPECT_FLOAT_POINT_EQ(FloatPoint(125, 150),
                         visualViewport.visibleRect().location());
 
   // Once more but make sure that we don't move the visual viewport unless
   // necessary.
   registerMockedHttpURLLoad("pinch-viewport-input-field-long-and-wide.html");
   navigateTo(m_baseURL + "pinch-viewport-input-field-long-and-wide.html");
   webViewImpl()->setInitialFocus(false);
   visualViewport.setLocation(FloatPoint());
-  frame()->view()->setScrollPosition(IntPoint(0, 0), ProgrammaticScroll);
+  frame()->view()->setScrollOffset(ScrollOffset(0, 0), ProgrammaticScroll);
   webViewImpl()->resizeVisualViewport(IntSize(500, 300));
   visualViewport.setLocation(FloatPoint(30, 50));
 
   webViewImpl()->setPageScaleFactor(2);
   webViewImpl()->scrollFocusedEditableElementIntoRect(IntRect(0, 0, 500, 200));
-  EXPECT_POINT_EQ(IntPoint(200 - 30 - 75, 600 - 50 - 65),
-                  frame()->view()->scrollPosition());
+  EXPECT_SIZE_EQ(ScrollOffset(200 - 30 - 75, 600 - 50 - 65),
+                 frame()->view()->scrollOffset());
   EXPECT_FLOAT_POINT_EQ(FloatPoint(30, 50),
                         visualViewport.visibleRect().location());
 }
 
 // Test that resizing the WebView causes ViewportConstrained objects to
 // relayout.
 TEST_P(ParameterizedVisualViewportTest,
        TestWebViewResizeCausesViewportConstrainedLayout) {
   initializeWithDesktopSettings();
   webViewImpl()->resize(IntSize(500, 300));
@@ skipping 131 matching lines @@
       frameView.layoutViewportScrollableArea();
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
   Element* inputBox = frame()->document()->getElementById("box");
 
   webViewImpl()->setPageScaleFactor(2);
 
   // The element is already in the view so the scrollIntoView shouldn't move
   // the viewport at all.
   webViewImpl()->setVisualViewportOffset(WebFloatPoint(250.25f, 100.25f));
-  layoutViewportScrollableArea->setScrollPosition(DoublePoint(0, 900.75),
-                                                  ProgrammaticScroll);
+  layoutViewportScrollableArea->setScrollOffset(ScrollOffset(0, 900.75),
+                                                ProgrammaticScroll);
   inputBox->scrollIntoViewIfNeeded(false);
 
-  EXPECT_POINT_EQ(DoublePoint(0, 900),
-                  layoutViewportScrollableArea->scrollPositionDouble());
-  EXPECT_POINT_EQ(FloatPoint(250.25f, 100.25f), visualViewport.location());
+  EXPECT_SIZE_EQ(ScrollOffset(0, 900),
+                 layoutViewportScrollableArea->scrollOffset());
+  EXPECT_SIZE_EQ(FloatSize(250.25f, 100.25f), visualViewport.scrollOffset());
 
   // Change the fractional part of the frameview to one that would round down.
-  layoutViewportScrollableArea->setScrollPosition(DoublePoint(0, 900.125),
-                                                  ProgrammaticScroll);
+  layoutViewportScrollableArea->setScrollOffset(ScrollOffset(0, 900.125),
+                                                ProgrammaticScroll);
   inputBox->scrollIntoViewIfNeeded(false);
 
-  EXPECT_POINT_EQ(DoublePoint(0, 900),
-                  layoutViewportScrollableArea->scrollPositionDouble());
-  EXPECT_POINT_EQ(FloatPoint(250.25f, 100.25f), visualViewport.location());
+  EXPECT_SIZE_EQ(ScrollOffset(0, 900),
+                 layoutViewportScrollableArea->scrollOffset());
+  EXPECT_SIZE_EQ(FloatSize(250.25f, 100.25f), visualViewport.scrollOffset());
 
   // Repeat both tests above with the visual viewport at a high fractional.
   webViewImpl()->setVisualViewportOffset(WebFloatPoint(250.875f, 100.875f));
-  layoutViewportScrollableArea->setScrollPosition(DoublePoint(0, 900.75),
-                                                  ProgrammaticScroll);
+  layoutViewportScrollableArea->setScrollOffset(ScrollOffset(0, 900.75),
+                                                ProgrammaticScroll);
   inputBox->scrollIntoViewIfNeeded(false);
 
-  EXPECT_POINT_EQ(DoublePoint(0, 900),
-                  layoutViewportScrollableArea->scrollPositionDouble());
-  EXPECT_POINT_EQ(FloatPoint(250.875f, 100.875f), visualViewport.location());
+  EXPECT_SIZE_EQ(ScrollOffset(0, 900),
+                 layoutViewportScrollableArea->scrollOffset());
+  EXPECT_SIZE_EQ(FloatSize(250.875f, 100.875f), visualViewport.scrollOffset());
 
   // Change the fractional part of the frameview to one that would round down.
-  layoutViewportScrollableArea->setScrollPosition(DoublePoint(0, 900.125),
-                                                  ProgrammaticScroll);
+  layoutViewportScrollableArea->setScrollOffset(ScrollOffset(0, 900.125),
+                                                ProgrammaticScroll);
   inputBox->scrollIntoViewIfNeeded(false);
 
-  EXPECT_POINT_EQ(DoublePoint(0, 900),
-                  layoutViewportScrollableArea->scrollPositionDouble());
-  EXPECT_POINT_EQ(FloatPoint(250.875f, 100.875f), visualViewport.location());
+  EXPECT_SIZE_EQ(ScrollOffset(0, 900),
+                 layoutViewportScrollableArea->scrollOffset());
+  EXPECT_SIZE_EQ(FloatSize(250.875f, 100.875f), visualViewport.scrollOffset());
 
   // Both viewports with a 0.5 fraction.
   webViewImpl()->setVisualViewportOffset(WebFloatPoint(250.5f, 100.5f));
-  layoutViewportScrollableArea->setScrollPosition(DoublePoint(0, 900.5),
-                                                  ProgrammaticScroll);
+  layoutViewportScrollableArea->setScrollOffset(ScrollOffset(0, 900.5),
+                                                ProgrammaticScroll);
   inputBox->scrollIntoViewIfNeeded(false);
 
-  EXPECT_POINT_EQ(DoublePoint(0, 900),
-                  layoutViewportScrollableArea->scrollPositionDouble());
-  EXPECT_POINT_EQ(FloatPoint(250.5f, 100.5f), visualViewport.location());
+  EXPECT_SIZE_EQ(ScrollOffset(0, 900),
+                 layoutViewportScrollableArea->scrollOffset());
+  EXPECT_SIZE_EQ(FloatSize(250.5f, 100.5f), visualViewport.scrollOffset());
 }
 
-static IntPoint expectedMaxFrameViewScrollOffset(VisualViewport& visualViewport,
-                                                 FrameView& frameView) {
+static ScrollOffset expectedMaxFrameViewScrollOffset(
+    VisualViewport& visualViewport,
+    FrameView& frameView) {
   float aspectRatio = visualViewport.visibleRect().width() /
                       visualViewport.visibleRect().height();
   float newHeight = frameView.frameRect().width() / aspectRatio;
-  return IntPoint(
+  return ScrollOffset(
       frameView.contentsSize().width() - frameView.frameRect().width(),
       frameView.contentsSize().height() - newHeight);
 }
 
 TEST_F(VisualViewportTest, TestTopControlsAdjustment) {
   initializeWithAndroidSettings();
   webViewImpl()->resizeWithTopControls(IntSize(500, 450), 20, false);
 
   registerMockedHttpURLLoad("content-width-1000.html");
   navigateTo(m_baseURL + "content-width-1000.html");
 
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
   FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
 
   visualViewport.setScale(1);
   EXPECT_SIZE_EQ(IntSize(500, 450), visualViewport.visibleRect().size());
   EXPECT_SIZE_EQ(IntSize(1000, 900), frameView.frameRect().size());
 
   // Simulate bringing down the top controls by 20px.
   webViewImpl()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                      WebFloatSize(), 1, 1);
   EXPECT_SIZE_EQ(IntSize(500, 430), visualViewport.visibleRect().size());
 
   // Test that the scroll bounds are adjusted appropriately: the visual viewport
   // should be shrunk by 20px to 430px. The outer viewport was shrunk to
-  // maintain the aspect ratio so it's height is 860px.
-  visualViewport.move(FloatPoint(10000, 10000));
-  EXPECT_POINT_EQ(FloatPoint(500, 860 - 430), visualViewport.location());
+  // maintain the
+  // aspect ratio so it's height is 860px.
+  visualViewport.move(ScrollOffset(10000, 10000));
+  EXPECT_SIZE_EQ(FloatSize(500, 860 - 430), visualViewport.scrollOffset());
 
   // The outer viewport (FrameView) should be affected as well.
-  frameView.scrollBy(IntSize(10000, 10000), UserScroll);
-  EXPECT_POINT_EQ(expectedMaxFrameViewScrollOffset(visualViewport, frameView),
-                  frameView.scrollPosition());
+  frameView.scrollBy(ScrollOffset(10000, 10000), UserScroll);
+  EXPECT_SIZE_EQ(expectedMaxFrameViewScrollOffset(visualViewport, frameView),
+                 frameView.scrollOffset());
 
   // Simulate bringing up the top controls by 10.5px.
   webViewImpl()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                      WebFloatSize(), 1, -10.5f / 20);
   EXPECT_FLOAT_SIZE_EQ(FloatSize(500, 440.5f),
                        visualViewport.visibleRect().size());
 
   // maximumScrollPosition |ceil|s the top controls adjustment.
-  visualViewport.move(FloatPoint(10000, 10000));
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(500, 881 - 441), visualViewport.location());
+  visualViewport.move(ScrollOffset(10000, 10000));
+  EXPECT_FLOAT_SIZE_EQ(FloatSize(500, 881 - 441),
+                       visualViewport.scrollOffset());
 
   // The outer viewport (FrameView) should be affected as well.
-  frameView.scrollBy(IntSize(10000, 10000), UserScroll);
-  EXPECT_POINT_EQ(expectedMaxFrameViewScrollOffset(visualViewport, frameView),
-                  frameView.scrollPosition());
+  frameView.scrollBy(ScrollOffset(10000, 10000), UserScroll);
+  EXPECT_SIZE_EQ(expectedMaxFrameViewScrollOffset(visualViewport, frameView),
+                 frameView.scrollOffset());
 }
 
 TEST_F(VisualViewportTest, TestTopControlsAdjustmentWithScale) {
   initializeWithAndroidSettings();
   webViewImpl()->resizeWithTopControls(IntSize(500, 450), 20, false);
 
   registerMockedHttpURLLoad("content-width-1000.html");
   navigateTo(m_baseURL + "content-width-1000.html");
 
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
   FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
 
   visualViewport.setScale(2);
   EXPECT_SIZE_EQ(IntSize(250, 225), visualViewport.visibleRect().size());
   EXPECT_SIZE_EQ(IntSize(1000, 900), frameView.frameRect().size());
 
   // Simulate bringing down the top controls by 20px. Since we're zoomed in, the
   // top controls take up half as much space (in document-space) than they do at
   // an unzoomed level.
   webViewImpl()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                      WebFloatSize(), 1, 1);
   EXPECT_SIZE_EQ(IntSize(250, 215), visualViewport.visibleRect().size());
 
   // Test that the scroll bounds are adjusted appropriately.
-  visualViewport.move(FloatPoint(10000, 10000));
-  EXPECT_POINT_EQ(FloatPoint(750, 860 - 215), visualViewport.location());
+  visualViewport.move(ScrollOffset(10000, 10000));
+  EXPECT_SIZE_EQ(FloatSize(750, 860 - 215), visualViewport.scrollOffset());
 
   // The outer viewport (FrameView) should be affected as well.
-  frameView.scrollBy(IntSize(10000, 10000), UserScroll);
-  IntPoint expected =
+  frameView.scrollBy(ScrollOffset(10000, 10000), UserScroll);
+  ScrollOffset expected =
       expectedMaxFrameViewScrollOffset(visualViewport, frameView);
-  EXPECT_POINT_EQ(expected, frameView.scrollPosition());
+  EXPECT_SIZE_EQ(expected, frameView.scrollOffset());
 
   // Scale back out, FrameView max scroll shouldn't have changed. Visual
   // viewport should be moved up to accomodate larger view.
   webViewImpl()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                      WebFloatSize(), 0.5f, 0);
   EXPECT_EQ(1, visualViewport.scale());
-  EXPECT_POINT_EQ(expected, frameView.scrollPosition());
-  frameView.scrollBy(IntSize(10000, 10000), UserScroll);
-  EXPECT_POINT_EQ(expected, frameView.scrollPosition());
+  EXPECT_SIZE_EQ(expected, frameView.scrollOffset());
+  frameView.scrollBy(ScrollOffset(10000, 10000), UserScroll);
+  EXPECT_SIZE_EQ(expected, frameView.scrollOffset());
 
-  EXPECT_POINT_EQ(FloatPoint(500, 860 - 430), visualViewport.location());
-  visualViewport.move(FloatPoint(10000, 10000));
-  EXPECT_POINT_EQ(FloatPoint(500, 860 - 430), visualViewport.location());
+  EXPECT_SIZE_EQ(FloatSize(500, 860 - 430), visualViewport.scrollOffset());
+  visualViewport.move(ScrollOffset(10000, 10000));
+  EXPECT_SIZE_EQ(FloatSize(500, 860 - 430), visualViewport.scrollOffset());
 
   // Scale out, use a scale that causes fractional rects.
   webViewImpl()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                      WebFloatSize(), 0.8f, -1);
   EXPECT_SIZE_EQ(FloatSize(625, 562.5), visualViewport.visibleRect().size());
 
   // Bring out the top controls by 11
   webViewImpl()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                      WebFloatSize(), 1, 11 / 20.f);
   EXPECT_SIZE_EQ(FloatSize(625, 548.75), visualViewport.visibleRect().size());
 
   // Ensure max scroll offsets are updated properly.
-  visualViewport.move(FloatPoint(10000, 10000));
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(375, 877.5 - 548.75),
-                        visualViewport.location());
+  visualViewport.move(ScrollOffset(10000, 10000));
+  EXPECT_FLOAT_SIZE_EQ(FloatSize(375, 877.5 - 548.75),
+                       visualViewport.scrollOffset());
 
-  frameView.scrollBy(IntSize(10000, 10000), UserScroll);
-  EXPECT_POINT_EQ(expectedMaxFrameViewScrollOffset(visualViewport, frameView),
-                  frameView.scrollPosition());
+  frameView.scrollBy(ScrollOffset(10000, 10000), UserScroll);
+  EXPECT_SIZE_EQ(expectedMaxFrameViewScrollOffset(visualViewport, frameView),
+                 frameView.scrollOffset());
 }
 
 // Tests that a scroll all the way to the bottom of the page, while hiding the
 // top controls doesn't cause a clamp in the viewport scroll offset when the top
 // controls initiated resize occurs.
 TEST_F(VisualViewportTest, TestTopControlsAdjustmentAndResize) {
   int topControlsHeight = 20;
   int visualViewportHeight = 450;
   int layoutViewportHeight = 900;
   float pageScale = 2;
@@ skipping 17 matching lines @@
   EXPECT_SIZE_EQ(
       IntSize(250, (visualViewportHeight - topControlsHeight) / pageScale),
       visualViewport.visibleRect().size());
   EXPECT_SIZE_EQ(
       IntSize(1000, layoutViewportHeight - topControlsHeight / minPageScale),
       frameView.frameRect().size());
   EXPECT_SIZE_EQ(IntSize(500, visualViewportHeight - topControlsHeight),
                  visualViewport.size());
 
   // Scroll all the way to the bottom, hiding the top controls in the process.
-  visualViewport.move(FloatPoint(10000, 10000));
-  frameView.scrollBy(IntSize(10000, 10000), UserScroll);
+  visualViewport.move(ScrollOffset(10000, 10000));
+  frameView.scrollBy(ScrollOffset(10000, 10000), UserScroll);
   webViewImpl()->topControls().setShownRatio(0);
 
   EXPECT_SIZE_EQ(IntSize(250, visualViewportHeight / pageScale),
                  visualViewport.visibleRect().size());
 
-  IntPoint frameViewExpected =
+  ScrollOffset frameViewExpected =
       expectedMaxFrameViewScrollOffset(visualViewport, frameView);
-  FloatPoint visualViewportExpected =
-      FloatPoint(750, layoutViewportHeight - visualViewportHeight / pageScale);
+  ScrollOffset visualViewportExpected = ScrollOffset(
+      750, layoutViewportHeight - visualViewportHeight / pageScale);
 
-  EXPECT_POINT_EQ(visualViewportExpected, visualViewport.location());
-  EXPECT_POINT_EQ(frameViewExpected, frameView.scrollPosition());
+  EXPECT_SIZE_EQ(visualViewportExpected, visualViewport.scrollOffset());
+  EXPECT_SIZE_EQ(frameViewExpected, frameView.scrollOffset());
 
-  FloatPoint totalExpected = visualViewportExpected + frameViewExpected;
+  ScrollOffset totalExpected = visualViewportExpected + frameViewExpected;
 
   // Resize the widget to match the top controls adjustment. Ensure that the
   // total offset (i.e. what the user sees) doesn't change because of clamping
   // the offsets to valid values.
   webViewImpl()->resizeWithTopControls(WebSize(500, visualViewportHeight), 20,
                                        false);
 
   EXPECT_SIZE_EQ(IntSize(500, visualViewportHeight), visualViewport.size());
   EXPECT_SIZE_EQ(IntSize(250, visualViewportHeight / pageScale),
                  visualViewport.visibleRect().size());
   EXPECT_SIZE_EQ(IntSize(1000, layoutViewportHeight),
                  frameView.frameRect().size());
-  EXPECT_POINT_EQ(totalExpected,
-                  frameView.scrollPosition() + visualViewport.location());
+  EXPECT_SIZE_EQ(totalExpected,
+                 visualViewport.scrollOffset() + frameView.scrollOffset());
 }
 
 // Tests that a scroll all the way to the bottom while showing the top controls
 // doesn't cause a clamp to the viewport scroll offset when the top controls
 // initiated resize occurs.
 TEST_F(VisualViewportTest, TestTopControlsShrinkAdjustmentAndResize) {
   int topControlsHeight = 20;
   int visualViewportHeight = 500;
   int layoutViewportHeight = 1000;
   int contentHeight = 2000;
@@ skipping 18 matching lines @@
   EXPECT_SIZE_EQ(IntSize(250, visualViewportHeight / pageScale),
                  visualViewport.visibleRect().size());
   EXPECT_SIZE_EQ(IntSize(1000, layoutViewportHeight),
                  frameView.frameRect().size());
   EXPECT_SIZE_EQ(IntSize(500, visualViewportHeight), visualViewport.size());
 
   // Scroll all the way to the bottom, showing the the top controls in the
   // process. (This could happen via window.scrollTo during a scroll, for
   // example).
   webViewImpl()->topControls().setShownRatio(1);
-  visualViewport.move(FloatPoint(10000, 10000));
-  frameView.scrollBy(IntSize(10000, 10000), UserScroll);
+  visualViewport.move(ScrollOffset(10000, 10000));
+  frameView.scrollBy(ScrollOffset(10000, 10000), UserScroll);
 
   EXPECT_SIZE_EQ(
       IntSize(250, (visualViewportHeight - topControlsHeight) / pageScale),
       visualViewport.visibleRect().size());
 
-  IntPoint frameViewExpected = IntPoint(
+  ScrollOffset frameViewExpected(
       0, contentHeight -
              (layoutViewportHeight - topControlsHeight / minPageScale));
-  FloatPoint visualViewportExpected =
-      FloatPoint(750, (layoutViewportHeight - topControlsHeight / minPageScale -
-                       visualViewport.visibleRect().height()));
+  ScrollOffset visualViewportExpected = ScrollOffset(
+      750, (layoutViewportHeight - topControlsHeight / minPageScale -
+            visualViewport.visibleRect().height()));
 
-  EXPECT_POINT_EQ(visualViewportExpected, visualViewport.location());
-  EXPECT_POINT_EQ(frameViewExpected, frameView.scrollPosition());
+  EXPECT_SIZE_EQ(visualViewportExpected, visualViewport.scrollOffset());
+  EXPECT_SIZE_EQ(frameViewExpected, frameView.scrollOffset());
 
-  FloatPoint totalExpected = visualViewportExpected + frameViewExpected;
+  ScrollOffset totalExpected = visualViewportExpected + frameViewExpected;
 
   // Resize the widget to match the top controls adjustment. Ensure that the
   // total offset (i.e. what the user sees) doesn't change because of clamping
   // the offsets to valid values.
   webViewImpl()->resizeWithTopControls(
       WebSize(500, visualViewportHeight - topControlsHeight), 20, true);
 
   EXPECT_SIZE_EQ(IntSize(500, visualViewportHeight - topControlsHeight),
                  visualViewport.size());
   EXPECT_SIZE_EQ(
       IntSize(250, (visualViewportHeight - topControlsHeight) / pageScale),
       visualViewport.visibleRect().size());
   EXPECT_SIZE_EQ(
       IntSize(1000, layoutViewportHeight - topControlsHeight / minPageScale),
       frameView.frameRect().size());
-  EXPECT_POINT_EQ(totalExpected,
-                  frameView.scrollPosition() + visualViewport.location());
+  EXPECT_SIZE_EQ(totalExpected,
+                 visualViewport.scrollOffset() + frameView.scrollOffset());
 }
 
 // Tests that a resize due to top controls hiding doesn't incorrectly clamp the
 // main frame's scroll offset. crbug.com/428193.
 TEST_F(VisualViewportTest, TestTopControlHidingResizeDoesntClampMainFrame) {
   initializeWithAndroidSettings();
   webViewImpl()->resizeWithTopControls(webViewImpl()->size(), 500, false);
   webViewImpl()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                      WebFloatSize(), 1, 1);
   webViewImpl()->resizeWithTopControls(WebSize(1000, 1000), 500, true);
 
   registerMockedHttpURLLoad("content-width-1000.html");
   navigateTo(m_baseURL + "content-width-1000.html");
 
   // Scroll the FrameView to the bottom of the page but "hide" the top controls
   // on the compositor side so the max scroll position should account for the
   // full viewport height.
   webViewImpl()->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                      WebFloatSize(), 1, -1);
   FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
-  frameView.setScrollPosition(IntPoint(0, 10000), ProgrammaticScroll);
-  EXPECT_EQ(500, frameView.scrollPositionDouble().y());
+  frameView.setScrollOffset(ScrollOffset(0, 10000), ProgrammaticScroll);
+  EXPECT_EQ(500, frameView.scrollOffset().height());
 
   // Now send the resize, make sure the scroll offset doesn't change.
   webViewImpl()->resizeWithTopControls(WebSize(1000, 1500), 500, false);
-  EXPECT_EQ(500, frameView.scrollPositionDouble().y());
+  EXPECT_EQ(500, frameView.scrollOffset().height());
 }
 
 static void configureHiddenScrollbarsSettings(WebSettings* settings) {
   VisualViewportTest::configureAndroidSettings(settings);
   settings->setHideScrollbars(true);
 }
 
 // Tests that scrollbar layers are not attached to the inner viewport container
 // layer when hideScrollbars WebSetting is true.
 TEST_F(VisualViewportTest,
@@ skipping 51 matching lines @@
   initializeWithDesktopSettings();
   webViewImpl()->resize(IntSize(100, 200));
 
   navigateTo("about:blank");
   webViewImpl()->updateAllLifecyclePhases();
 
   webViewImpl()->resizeVisualViewport(IntSize(100, 100));
 
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
-  visualViewport.move(FloatPoint(0, 100));
+  visualViewport.move(ScrollOffset(0, 100));
 
-  EXPECT_EQ(100, visualViewport.location().y());
+  EXPECT_EQ(100, visualViewport.scrollOffset().height());
 
   webViewImpl()->resizeVisualViewport(IntSize(100, 200));
 
-  EXPECT_EQ(0, visualViewport.location().y());
+  EXPECT_EQ(0, visualViewport.scrollOffset().height());
 }
 
 TEST_P(ParameterizedVisualViewportTest,
        ElementBoundsInViewportSpaceAccountsForViewport) {
   initializeWithAndroidSettings();
 
   webViewImpl()->resize(IntSize(500, 800));
 
   registerMockedHttpURLLoad("pinch-viewport-input-field.html");
   navigateTo(m_baseURL + "pinch-viewport-input-field.html");
@@ skipping 53 matching lines @@
 
   // Chrome's quirky behavior regarding viewport scrolling means we treat the
   // body element as the viewport and don't apply scrolling to the HTML element.
   RuntimeEnabledFeatures::setScrollTopLeftInteropEnabled(false);
 
   LocalDOMWindow* window =
       webViewImpl()->mainFrameImpl()->frame()->localDOMWindow();
   window->scrollTo(100, 150);
   EXPECT_EQ(100, window->scrollX());
   EXPECT_EQ(150, window->scrollY());
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(100, 150), visualViewport.location());
+  EXPECT_FLOAT_SIZE_EQ(FloatSize(100, 150), visualViewport.scrollOffset());
 
   HTMLElement* body = toHTMLBodyElement(window->document()->body());
   body->setScrollLeft(50);
   body->setScrollTop(130);
   EXPECT_EQ(50, body->scrollLeft());
   EXPECT_EQ(130, body->scrollTop());
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(50, 130), visualViewport.location());
+  EXPECT_FLOAT_SIZE_EQ(FloatSize(50, 130), visualViewport.scrollOffset());
 
   HTMLElement* documentElement =
       toHTMLElement(window->document()->documentElement());
   documentElement->setScrollLeft(40);
   documentElement->setScrollTop(50);
   EXPECT_EQ(0, documentElement->scrollLeft());
   EXPECT_EQ(0, documentElement->scrollTop());
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(50, 130), visualViewport.location());
+  EXPECT_FLOAT_SIZE_EQ(FloatSize(50, 130), visualViewport.scrollOffset());
 
   visualViewport.setLocation(FloatPoint(10, 20));
   EXPECT_EQ(10, body->scrollLeft());
   EXPECT_EQ(20, body->scrollTop());
   EXPECT_EQ(0, documentElement->scrollLeft());
   EXPECT_EQ(0, documentElement->scrollTop());
   EXPECT_EQ(10, window->scrollX());
   EXPECT_EQ(20, window->scrollY());
 
   // Turning on the standards-compliant viewport scrolling impl should make the
   // document element the viewport and not body.
   RuntimeEnabledFeatures::setScrollTopLeftInteropEnabled(true);
 
   window->scrollTo(100, 150);
   EXPECT_EQ(100, window->scrollX());
   EXPECT_EQ(150, window->scrollY());
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(100, 150), visualViewport.location());
+  EXPECT_FLOAT_SIZE_EQ(FloatSize(100, 150), visualViewport.scrollOffset());
 
   body->setScrollLeft(50);
   body->setScrollTop(130);
   EXPECT_EQ(0, body->scrollLeft());
   EXPECT_EQ(0, body->scrollTop());
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(100, 150), visualViewport.location());
+  EXPECT_FLOAT_SIZE_EQ(FloatSize(100, 150), visualViewport.scrollOffset());
 
   documentElement->setScrollLeft(40);
   documentElement->setScrollTop(50);
   EXPECT_EQ(40, documentElement->scrollLeft());
   EXPECT_EQ(50, documentElement->scrollTop());
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(40, 50), visualViewport.location());
+  EXPECT_FLOAT_SIZE_EQ(FloatSize(40, 50), visualViewport.scrollOffset());
 
   visualViewport.setLocation(FloatPoint(10, 20));
   EXPECT_EQ(0, body->scrollLeft());
   EXPECT_EQ(0, body->scrollTop());
   EXPECT_EQ(10, documentElement->scrollLeft());
   EXPECT_EQ(20, documentElement->scrollTop());
   EXPECT_EQ(10, window->scrollX());
   EXPECT_EQ(20, window->scrollY());
 }
 
@@ skipping 22 matching lines @@
 TEST_P(ParameterizedVisualViewportTest, FractionalMaxScrollOffset) {
   initializeWithDesktopSettings();
   webViewImpl()->resize(IntSize(101, 201));
   navigateTo("about:blank");
 
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
   ScrollableArea* scrollableArea = &visualViewport;
 
   webViewImpl()->setPageScaleFactor(1.0);
-  EXPECT_FLOAT_POINT_EQ(DoublePoint(),
-                        scrollableArea->maximumScrollPositionDouble());
+  EXPECT_SIZE_EQ(ScrollOffset(), scrollableArea->maximumScrollOffset());
 
   webViewImpl()->setPageScaleFactor(2);
-  EXPECT_FLOAT_POINT_EQ(DoublePoint(101. / 2., 201. / 2.),
-                        scrollableArea->maximumScrollPositionDouble());
+  EXPECT_SIZE_EQ(ScrollOffset(101. / 2., 201. / 2.),
+                 scrollableArea->maximumScrollOffset());
 }
 
 // Tests that the slow scrolling after an impl scroll on the visual viewport is
 // continuous. crbug.com/453460 was caused by the impl-path not updating the
 // ScrollAnimatorBase class.
 TEST_P(ParameterizedVisualViewportTest, SlowScrollAfterImplScroll) {
   initializeWithDesktopSettings();
   webViewImpl()->resize(IntSize(800, 600));
   navigateTo("about:blank");
 
   VisualViewport& visualViewport =
       frame()->page()->frameHost().visualViewport();
 
   // Apply some scroll and scale from the impl-side.
   webViewImpl()->applyViewportDeltas(WebFloatSize(300, 200), WebFloatSize(0, 0),
                                      WebFloatSize(0, 0), 2, 0);
 
-  EXPECT_POINT_EQ(FloatPoint(300, 200), visualViewport.location());
+  EXPECT_SIZE_EQ(FloatSize(300, 200), visualViewport.scrollOffset());
 
   // Send a scroll event on the main thread path.
   PlatformGestureEvent gsu(PlatformEvent::GestureScrollUpdate, IntPoint(0, 0),
                            IntPoint(0, 0), IntSize(5, 5), 0,
                            PlatformEvent::NoModifiers,
                            PlatformGestureSourceTouchpad);
   gsu.setScrollGestureData(-50, -60, ScrollByPrecisePixel, 1, 1,
                            ScrollInertialPhaseUnknown, false,
                            -1 /* null plugin id */);
 
   frame()->eventHandler().handleGestureEvent(gsu);
 
   // The scroll sent from the impl-side must not be overwritten.
-  EXPECT_POINT_EQ(FloatPoint(350, 260), visualViewport.location());
+  EXPECT_SIZE_EQ(FloatSize(350, 260), visualViewport.scrollOffset());
 }
 
 static void accessibilitySettings(WebSettings* settings) {
   VisualViewportTest::configureSettings(settings);
   settings->setAccessibilityEnabled(true);
 }
 
 TEST_P(ParameterizedVisualViewportTest, AccessibilityHitTestWhileZoomedIn) {
   initializeWithDesktopSettings(accessibilitySettings);
 
   registerMockedHttpURLLoad("hit-test.html");
   navigateTo(m_baseURL + "hit-test.html");
 
   webViewImpl()->resize(IntSize(500, 500));
   webViewImpl()->updateAllLifecyclePhases();
 
   WebDocument webDoc = webViewImpl()->mainFrame()->document();
   FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
 
   webViewImpl()->setPageScaleFactor(2);
   webViewImpl()->setVisualViewportOffset(WebFloatPoint(200, 230));
-  frameView.layoutViewportScrollableArea()->setScrollPosition(
-      DoublePoint(400, 1100), ProgrammaticScroll);
+  frameView.layoutViewportScrollableArea()->setScrollOffset(
+      ScrollOffset(400, 1100), ProgrammaticScroll);
 
   // FIXME(504057): PaintLayerScrollableArea dirties the compositing state.
   forceFullCompositingUpdate();
 
   // Because of where the visual viewport is located, this should hit the bottom
   // right target (target 4).
   WebAXObject hitNode =
       webDoc.accessibilityObject().hitTest(WebPoint(154, 165));
   WebAXNameFrom nameFrom;
   WebVector<WebAXObject> nameObjects;
@@ skipping 36 matching lines @@
 
   // Test points that will cause non-integer values.
   EXPECT_FLOAT_POINT_EQ(
       FloatPoint(50.5, 62.4),
       visualViewport.viewportToRootFrame(FloatPoint(81, 100.8)));
   EXPECT_FLOAT_POINT_EQ(
       FloatPoint(81, 100.8),
       visualViewport.rootFrameToViewport(FloatPoint(50.5, 62.4)));
 
   // Scrolling the main frame should have no effect.
-  frameView.layoutViewportScrollableArea()->setScrollPosition(
-      DoublePoint(100, 120), ProgrammaticScroll);
+  frameView.layoutViewportScrollableArea()->setScrollOffset(
+      ScrollOffset(100, 120), ProgrammaticScroll);
   EXPECT_FLOAT_POINT_EQ(FloatPoint(50, 62), visualViewport.viewportToRootFrame(
                                                 FloatPoint(80, 100)));
   EXPECT_FLOAT_POINT_EQ(FloatPoint(80, 100),
                         visualViewport.rootFrameToViewport(FloatPoint(50, 62)));
 }
 
 // Tests that the window dimensions are available before a full layout occurs.
 // More specifically, it checks that the innerWidth and innerHeight window
 // properties will trigger a layout which will cause an update to viewport
 // constraints and a refreshed initial scale. crbug.com/466718
@@ skipping 40 matching lines @@
   pinchUpdate.y = 100;
   pinchUpdate.data.pinchUpdate.scale = 2;
   pinchUpdate.data.pinchUpdate.zoomDisabled = false;
 
   webViewImpl()->handleInputEvent(pinchUpdate);
 
   VisualViewport& visualViewport =
       webViewImpl()->page()->frameHost().visualViewport();
   FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
 
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(50, 50), visualViewport.location());
-  EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 0), frameView.scrollPositionDouble());
+  EXPECT_FLOAT_SIZE_EQ(FloatSize(50, 50), visualViewport.scrollOffset());
+  EXPECT_SIZE_EQ(ScrollOffset(0, 0), frameView.scrollOffset());
 }
 
 TEST_P(ParameterizedVisualViewportTest, ResizeWithScrollAnchoring) {
   bool wasScrollAnchoringEnabled =
       RuntimeEnabledFeatures::scrollAnchoringEnabled();
   RuntimeEnabledFeatures::setScrollAnchoringEnabled(true);
 
   initializeWithDesktopSettings();
   webViewImpl()->resize(IntSize(800, 600));
 
   registerMockedHttpURLLoad("icb-relative-content.html");
   navigateTo(m_baseURL + "icb-relative-content.html");
 
   FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
-  frameView.layoutViewportScrollableArea()->setScrollPosition(
-      DoublePoint(700, 500), ProgrammaticScroll);
+  frameView.layoutViewportScrollableArea()->setScrollOffset(
+      ScrollOffset(700, 500), ProgrammaticScroll);
 
   webViewImpl()->resize(IntSize(800, 300));
-  EXPECT_POINT_EQ(
-      DoublePoint(700, 200),
-      frameView.layoutViewportScrollableArea()->scrollPositionDouble());
+  EXPECT_SIZE_EQ(ScrollOffset(700, 200),
+                 frameView.layoutViewportScrollableArea()->scrollOffset());
 
   RuntimeEnabledFeatures::setScrollAnchoringEnabled(wasScrollAnchoringEnabled);
 }
 
 // Ensure that resize anchoring as happens when top controls hide/show affects
 // the scrollable area that's currently set as the root scroller.
 TEST_P(ParameterizedVisualViewportTest, ResizeAnchoringWithRootScroller) {
   bool wasRootScrollerEnabled =
       RuntimeEnabledFeatures::setRootScrollerEnabled();
   RuntimeEnabledFeatures::setSetRootScrollerEnabled(true);
 
   initializeWithAndroidSettings();
   webViewImpl()->resize(IntSize(800, 600));
 
   registerMockedHttpURLLoad("root-scroller-div.html");
   navigateTo(m_baseURL + "root-scroller-div.html");
 
   FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
 
   Element* scroller = frame()->document()->getElementById("rootScroller");
   NonThrowableExceptionState nonThrow;
   frame()->document()->setRootScroller(scroller, nonThrow);
 
   webViewImpl()->setPageScaleFactor(3.f);
-  frameView.getScrollableArea()->setScrollPosition(DoublePoint(0, 400),
-                                                   ProgrammaticScroll);
+  frameView.getScrollableArea()->setScrollOffset(ScrollOffset(0, 400),
+                                                 ProgrammaticScroll);
 
   VisualViewport& visualViewport =
       webViewImpl()->page()->frameHost().visualViewport();
-  visualViewport.setScrollPosition(DoublePoint(0, 400), ProgrammaticScroll);
+  visualViewport.setScrollOffset(ScrollOffset(0, 400), ProgrammaticScroll);
 
   webViewImpl()->resize(IntSize(800, 500));
 
-  EXPECT_POINT_EQ(
-      DoublePoint(),
-      frameView.layoutViewportScrollableArea()->scrollPositionDouble());
+  EXPECT_SIZE_EQ(ScrollOffset(),
+                 frameView.layoutViewportScrollableArea()->scrollOffset());
 
   RuntimeEnabledFeatures::setSetRootScrollerEnabled(wasRootScrollerEnabled);
 }
 
 // Ensure that resize anchoring as happens when the device is rotated affects
 // the scrollable area that's currently set as the root scroller.
 TEST_P(ParameterizedVisualViewportTest, RotationAnchoringWithRootScroller) {
   bool wasRootScrollerEnabled =
       RuntimeEnabledFeatures::setRootScrollerEnabled();
   RuntimeEnabledFeatures::setSetRootScrollerEnabled(true);
 
   initializeWithAndroidSettings();
   webViewImpl()->resize(IntSize(800, 600));
 
   registerMockedHttpURLLoad("root-scroller-div.html");
   navigateTo(m_baseURL + "root-scroller-div.html");
 
   FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
 
   Element* scroller = frame()->document()->getElementById("rootScroller");
   NonThrowableExceptionState nonThrow;
   frame()->document()->setRootScroller(scroller, nonThrow);
   webViewImpl()->updateAllLifecyclePhases();
 
   scroller->setScrollTop(800);
 
   webViewImpl()->resize(IntSize(600, 800));
 
-  EXPECT_POINT_EQ(
-      DoublePoint(),
-      frameView.layoutViewportScrollableArea()->scrollPositionDouble());
+  EXPECT_SIZE_EQ(ScrollOffset(),
+                 frameView.layoutViewportScrollableArea()->scrollOffset());
   EXPECT_EQ(600, scroller->scrollTop());
 
   RuntimeEnabledFeatures::setSetRootScrollerEnabled(wasRootScrollerEnabled);
 }
 
 }  // namespace