Parameterize PinchViewportTest for root layer scrolling.

Source/web/tests/PinchViewportTest.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 "config.h"
 
 #include "core/frame/PinchViewport.h"
 
 #include "core/dom/Document.h"
 #include "core/frame/FrameHost.h"
@@ skipping 81 matching lines @@
 ::std::ostream& operator<<(::std::ostream& os, const WebContextMenuData& data)
 {
     return os << "Context menu location: ["
         << data.mousePosition.x << ", " << data.mousePosition.y << "]";
 }
 }
 
 
 namespace {
 
-class PinchViewportTest : public testing::Test {
+class PinchViewportTest
+    : public testing::Test
+    , public FrameTestHelpers::SettingOverrider {
 public:
     PinchViewportTest()
         : m_baseURL("http://www.test.com/")
+        , m_helper(this)
     {
     }
 
+    void overrideSettings(WebSettings *settings) override
+    {
+    }
+
     void initializeWithDesktopSettings(void (*overrideSettingsFunc)(WebSettings*) = 0)
     {
         if (!overrideSettingsFunc)
             overrideSettingsFunc = &configureSettings;
         m_helper.initialize(true, 0, &m_mockWebViewClient, overrideSettingsFunc);
         webViewImpl()->setDefaultPageScaleLimits(1, 4);
     }
 
     void initializeWithAndroidSettings(void (*overrideSettingsFunc)(WebSettings*) = 0)
     {
@@ skipping 59 matching lines @@
 private:
     FrameTestHelpers::WebViewHelper m_helper;
 
     // To prevent platform differneces in content layout, use mock
     // scrollbars. This is especially needed for Mac, where the presence
     // or absence of a mouse will change frame sizes because of different
     // scrollbar themes.
     FrameTestHelpers::UseMockScrollbarSettings m_useMockScrollbars;
 };
 
+typedef void (*SettingOverrideFunction)(WebSettings*);
+
+static void DefaultSettingOverride(WebSettings *)
+{
+}
+
+static void RootLayerScrollsSettingOverride(WebSettings *settings)
+{
+    settings->setRootLayerScrolls(true);
+}
+
+class ParameterizedPinchViewportTest
+    : public PinchViewportTest
+    , public testing::WithParamInterface<SettingOverrideFunction> {
+public:
+    void overrideSettings(WebSettings *settings) override
+    {
+        GetParam()(settings);
+    }
+};
+
+INSTANTIATE_TEST_CASE_P(All, ParameterizedPinchViewportTest, ::testing::Values(
+    DefaultSettingOverride,
+    RootLayerScrollsSettingOverride));
+
 // Test that resizing the PinchViewport works as expected and that resizing the
 // WebView resizes the PinchViewport.
-TEST_F(PinchViewportTest, TestResize)
+TEST_P(ParameterizedPinchViewportTest, TestResize)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(320, 240));
 
     navigateTo("about:blank");
     forceFullCompositingUpdate();
 
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
 
     IntSize webViewSize = webViewImpl()->size();
@@ skipping 12 matching lines @@
     pinchViewport.setSize(newViewportSize);
     EXPECT_SIZE_EQ(webViewSize, IntSize(webViewImpl()->size()));
     EXPECT_SIZE_EQ(newViewportSize, pinchViewport.size());
 }
 
 // This tests that shrinking the WebView while the page is fully scrolled
 // doesn't move the viewport up/left, it should keep the visible viewport
 // unchanged from the user's perspective (shrinking the FrameView will clamp
 // the PinchViewport so we need to counter scroll the FrameView to make it
 // appear to stay still). This caused bugs like crbug.com/453859.
-TEST_F(PinchViewportTest, TestResizeAtFullyScrolledPreservesViewportLocation)
+TEST_P(ParameterizedPinchViewportTest, TestResizeAtFullyScrolledPreservesViewportLocation)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(800, 600));
 
     registerMockedHttpURLLoad("content-width-1000.html");
     navigateTo(m_baseURL + "content-width-1000.html");
 
     FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
 
     pinchViewport.setScale(2);
 
     // Fully scroll both viewports.
-    frameView.setScrollPosition(DoublePoint(10000, 10000), ProgrammaticScroll);
+    frameView.layoutViewportScrollableArea()->setScrollPosition(DoublePoint(10000, 10000), ProgrammaticScroll);
     pinchViewport.move(FloatSize(10000, 10000));
 
     // Sanity check.
     ASSERT_POINT_EQ(FloatPoint(400, 300), pinchViewport.location());
-    ASSERT_POINT_EQ(DoublePoint(200, 1400), frameView.scrollPositionDouble());
+    ASSERT_POINT_EQ(DoublePoint(200, 1400), frameView.layoutViewportScrollableArea()->scrollPositionDouble());
 
     DoublePoint expectedLocation = frameView.scrollableArea()->visibleContentRectDouble().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.scrollableArea()->visibleContentRectDouble().location());
 
@@ skipping 64 matching lines @@
 
     // After resizing the scale changes 2.0 -> 4.0
     EXPECT_FLOAT_SIZE_EQ(FloatSize(50, 25), pinchViewport.visibleRect().size());
 
     EXPECT_POINT_EQ(IntPoint(0, 625), frame()->view()->scrollPosition());
     EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 75), pinchViewport.location());
 }
 
 // Test that the PinchViewport works as expected in case if a scaled
 // and scrolled viewport - scroll right.
-TEST_F(PinchViewportTest, TestResizeAfterHorizontalScroll)
+TEST_P(ParameterizedPinchViewportTest, TestResizeAfterHorizontalScroll)
 {
     /*
                  200                                 200
         ---------------o-----               ---------------o-----
         |              |    |               |            25|    |
         |              |    |               |              -----|
         |           100|    |               |100             50 |
         |              |    |               |                   |
         |              ---- |               |-------------------|
         |                   |               |                   |
@@ skipping 52 matching lines @@
 static void disableAcceleratedCompositing(WebSettings* settings)
 {
     PinchViewportTest::configureSettings(settings);
     // FIXME: This setting is being removed, so this test needs to be rewritten to
     // do something else. crbug.com/173949
     settings->setAcceleratedCompositingEnabled(false);
 }
 
 // Test that the container layer gets sized properly if the WebView is resized
 // prior to the PinchViewport being attached to the layer tree.
-TEST_F(PinchViewportTest, TestWebViewResizedBeforeAttachment)
+TEST_P(ParameterizedPinchViewportTest, TestWebViewResizedBeforeAttachment)
 {
     initializeWithDesktopSettings(disableAcceleratedCompositing);
     webViewImpl()->resize(IntSize(320, 240));
 
     navigateTo("about:blank");
     forceFullCompositingUpdate();
     webViewImpl()->settings()->setAcceleratedCompositingEnabled(true);
     webViewImpl()->layout();
 
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     EXPECT_FLOAT_SIZE_EQ(FloatSize(320, 240), pinchViewport.containerLayer()->size());
 }
 
 // Make sure that the visibleRect method acurately reflects the scale and scroll location
 // of the viewport.
-TEST_F(PinchViewportTest, TestVisibleRect)
+TEST_P(ParameterizedPinchViewportTest, TestVisibleRect)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(320, 240));
 
     navigateTo("about:blank");
     forceFullCompositingUpdate();
 
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
 
     // Initial visible rect should be the whole frame.
@@ skipping 51 matching lines @@
     pinchViewport.setScale(2);
     pinchViewport.setLocation(FloatPoint(10, 15));
     EXPECT_FLOAT_RECT_EQ(FloatRect(10, 15, 50, 200), pinchViewport.visibleRectInDocument());
 
     // Scroll the layout viewport. Ensure its offset is reflected in visibleRectInDocument().
     FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
     frameView.setScrollPosition(DoublePoint(40, 100), ProgrammaticScroll);
     EXPECT_FLOAT_RECT_EQ(FloatRect(50, 115, 50, 200), pinchViewport.visibleRectInDocument());
 }
 
-TEST_F(PinchViewportTest, TestFractionalScrollOffsetIsNotOverwritten)
+TEST_P(ParameterizedPinchViewportTest, TestFractionalScrollOffsetIsNotOverwritten)
 {
     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.scrollTo(DoublePoint(0, 10.5));
+    frameView.layoutViewportScrollableArea()->setScrollPosition(DoublePoint(0, 10.5), ProgrammaticScroll);
     webViewImpl()->applyViewportDeltas(WebFloatSize(), WebFloatSize(10, 20), WebFloatSize(), 1, 0);
 
-    EXPECT_EQ(30.5, frameView.scrollPositionDouble().y());
+    EXPECT_EQ(30.5, frameView.layoutViewportScrollableArea()->scrollPositionDouble().y());
 }
 
 // Test that the viewport's scroll offset is always appropriately bounded such that the
 // pinch viewport always stays within the bounds of the main frame.
-TEST_F(PinchViewportTest, TestOffsetClamping)
+TEST_P(ParameterizedPinchViewportTest, TestOffsetClamping)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(320, 240));
 
     navigateTo("about:blank");
     forceFullCompositingUpdate();
 
     // Pinch viewport should be initialized to same size as frame so no scrolling possible.
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 0), pinchViewport.visibleRect().location());
@@ skipping 24 matching lines @@
     pinchViewport.setScale(1.25);
     EXPECT_FLOAT_POINT_EQ(FloatPoint(64, 48), pinchViewport.visibleRect().location());
 
     // Scale out smaller than 1.
     pinchViewport.setScale(0.25);
     EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 0), pinchViewport.visibleRect().location());
 }
 
 // Test that the viewport can be scrolled around only within the main frame in the presence
 // of viewport resizes, as would be the case if the on screen keyboard came up.
-TEST_F(PinchViewportTest, TestOffsetClampingWithResize)
+TEST_P(ParameterizedPinchViewportTest, TestOffsetClampingWithResize)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(320, 240));
 
     navigateTo("about:blank");
     forceFullCompositingUpdate();
 
     // Pinch viewport should be initialized to same size as frame so no scrolling possible.
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 0), pinchViewport.visibleRect().location());
@@ skipping 31 matching lines @@
     pinchViewport.setLocation(FloatPoint(100, 100));
     EXPECT_FLOAT_POINT_EQ(FloatPoint(40, 40), pinchViewport.visibleRect().location());
     pinchViewport.setLocation(FloatPoint(10, 3));
     EXPECT_FLOAT_POINT_EQ(FloatPoint(10, 3), pinchViewport.visibleRect().location());
     pinchViewport.setLocation(FloatPoint(-10, -4));
     EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 0), pinchViewport.visibleRect().location());
 }
 
 // Test that the viewport is scrollable but bounded appropriately within the main frame
 // when we apply both scaling and resizes.
-TEST_F(PinchViewportTest, TestOffsetClampingWithResizeAndScale)
+TEST_P(ParameterizedPinchViewportTest, TestOffsetClampingWithResizeAndScale)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(320, 240));
 
     navigateTo("about:blank");
     forceFullCompositingUpdate();
 
     // Pinch viewport should be initialized to same size as WebView so no scrolling possible.
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 0), pinchViewport.visibleRect().location());
@@ skipping 25 matching lines @@
     // Make sure resizing the viewport doesn't change its offset if the resize doesn't make
     // the viewport go out of bounds.
     pinchViewport.setLocation(FloatPoint(200, 200));
     pinchViewport.setSize(IntSize(880, 560));
     EXPECT_FLOAT_POINT_EQ(FloatPoint(200, 200), pinchViewport.visibleRect().location());
 }
 
 // The main FrameView's size should be set such that its the size of the pinch viewport
 // at minimum scale. If there's no explicit minimum scale set, the FrameView should be
 // set to the content width and height derived by the aspect ratio.
-TEST_F(PinchViewportTest, TestFrameViewSizedToContent)
+TEST_P(ParameterizedPinchViewportTest, TestFrameViewSizedToContent)
 {
     initializeWithAndroidSettings();
     webViewImpl()->resize(IntSize(320, 240));
 
     registerMockedHttpURLLoad("200-by-300-viewport.html");
     navigateTo(m_baseURL + "200-by-300-viewport.html");
 
     webViewImpl()->resize(IntSize(600, 800));
     webViewImpl()->layout();
 
     // Note: the size is ceiled and should match the behavior in CC's LayerImpl::bounds().
     EXPECT_SIZE_EQ(IntSize(200, 267),
         webViewImpl()->mainFrameImpl()->frameView()->frameRect().size());
 }
 
 // The main FrameView's size should be set such that its the size of the pinch viewport
 // at minimum scale. On Desktop, the minimum scale is set at 1 so make sure the FrameView
 // is sized to the viewport.
-TEST_F(PinchViewportTest, TestFrameViewSizedToMinimumScale)
+TEST_P(ParameterizedPinchViewportTest, TestFrameViewSizedToMinimumScale)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(320, 240));
 
     registerMockedHttpURLLoad("200-by-300.html");
     navigateTo(m_baseURL + "200-by-300.html");
 
     webViewImpl()->resize(IntSize(100, 160));
     webViewImpl()->layout();
 
     EXPECT_SIZE_EQ(IntSize(100, 160),
         webViewImpl()->mainFrameImpl()->frameView()->frameRect().size());
 }
 
 // Test that attaching a new frame view resets the size of the inner viewport scroll
 // layer. crbug.com/423189.
-TEST_F(PinchViewportTest, TestAttachingNewFrameSetsInnerScrollLayerSize)
+TEST_P(ParameterizedPinchViewportTest, TestAttachingNewFrameSetsInnerScrollLayerSize)
 {
     initializeWithAndroidSettings();
     webViewImpl()->resize(IntSize(320, 240));
 
     // 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()->layout();
 
@@ skipping 13 matching lines @@
     EXPECT_SIZE_EQ(FloatSize(320, 240), pinchViewport.scrollLayer()->size());
 
     // Ensure the location and scale were reset.
     EXPECT_POINT_EQ(FloatPoint(), pinchViewport.location());
     EXPECT_EQ(1, pinchViewport.scale());
 }
 
 // The main FrameView's size should be set such that its the size of the pinch viewport
 // at minimum scale. Test that the FrameView is appropriately sized in the presence
 // of a viewport <meta> tag.
-TEST_F(PinchViewportTest, TestFrameViewSizedToViewportMetaMinimumScale)
+TEST_P(ParameterizedPinchViewportTest, TestFrameViewSizedToViewportMetaMinimumScale)
 {
     initializeWithAndroidSettings();
     webViewImpl()->resize(IntSize(320, 240));
 
     registerMockedHttpURLLoad("200-by-300-min-scale-2.html");
     navigateTo(m_baseURL + "200-by-300-min-scale-2.html");
 
     webViewImpl()->resize(IntSize(100, 160));
     webViewImpl()->layout();
 
     EXPECT_SIZE_EQ(IntSize(50, 80),
         webViewImpl()->mainFrameImpl()->frameView()->frameRect().size());
 }
 
 // Test that the pinch viewport still gets sized in AutoSize/AutoResize mode.
-TEST_F(PinchViewportTest, TestPinchViewportGetsSizeInAutoSizeMode)
+TEST_P(ParameterizedPinchViewportTest, TestPinchViewportGetsSizeInAutoSizeMode)
 {
     initializeWithDesktopSettings();
 
     EXPECT_SIZE_EQ(IntSize(0, 0), IntSize(webViewImpl()->size()));
     EXPECT_SIZE_EQ(IntSize(0, 0), frame()->page()->frameHost().pinchViewport().size());
 
     webViewImpl()->enableAutoResizeMode(WebSize(10, 10), WebSize(1000, 1000));
 
     registerMockedHttpURLLoad("200-by-300.html");
     navigateTo(m_baseURL + "200-by-300.html");
 
     EXPECT_SIZE_EQ(IntSize(200, 300), frame()->page()->frameHost().pinchViewport().size());
 }
 
 // Test that the text selection handle's position accounts for the pinch viewport.
-TEST_F(PinchViewportTest, TestTextSelectionHandles)
+TEST_P(ParameterizedPinchViewportTest, TestTextSelectionHandles)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(500, 800));
 
     registerMockedHttpURLLoad("pinch-viewport-input-field.html");
     navigateTo(m_baseURL + "pinch-viewport-input-field.html");
 
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     webViewImpl()->setInitialFocus(false);
 
@@ skipping 13 matching lines @@
     expected.scale(pinchViewport.scale(), pinchViewport.scale());
 
     EXPECT_POINT_EQ(expected, IntRect(anchor).location());
     EXPECT_POINT_EQ(expected, IntRect(focus).location());
 
     // FIXME(bokan) - http://crbug.com/364154 - Figure out how to test text selection
     // as well rather than just carret.
 }
 
 // Test that the HistoryItem for the page stores the pinch viewport's offset and scale.
-TEST_F(PinchViewportTest, TestSavedToHistoryItem)
+TEST_P(ParameterizedPinchViewportTest, TestSavedToHistoryItem)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(200, 300));
     webViewImpl()->layout();
 
     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()->pinchViewportScrollPoint());
 
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     pinchViewport.setScale(2);
 
     EXPECT_EQ(2, toLocalFrame(webViewImpl()->page()->mainFrame())->loader().currentItem()->pageScaleFactor());
 
     pinchViewport.setLocation(FloatPoint(10, 20));
 
     EXPECT_FLOAT_POINT_EQ(FloatPoint(10, 20),
         toLocalFrame(webViewImpl()->page()->mainFrame())->loader().currentItem()->pinchViewportScrollPoint());
 }
 
 // Test restoring a HistoryItem properly restores the pinch viewport's state.
-TEST_F(PinchViewportTest, TestRestoredFromHistoryItem)
+TEST_P(ParameterizedPinchViewportTest, TestRestoredFromHistoryItem)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(200, 300));
 
     registerMockedHttpURLLoad("200-by-300.html");
 
     WebHistoryItem item;
     item.initialize();
     WebURL destinationURL(URLTestHelpers::toKURL(m_baseURL + "200-by-300.html"));
     item.setURLString(destinationURL.string());
@@ skipping 40 matching lines @@
 TEST_F(PinchViewportTest, TestNavigateToSmallerFrameViewHistoryItemClobberBug)
 {
     initializeWithAndroidSettings();
     webViewImpl()->resize(IntSize(400, 400));
     webViewImpl()->layout();
 
     registerMockedHttpURLLoad("content-width-1000.html");
     navigateTo(m_baseURL + "content-width-1000.html");
 
     FrameView* frameView = webViewImpl()->mainFrameImpl()->frameView();
-    frameView->setScrollPosition(IntPoint(0, 1000), ProgrammaticScroll);
+    frameView->layoutViewportScrollableArea()->setScrollPosition(IntPoint(0, 1000), ProgrammaticScroll);
 
     EXPECT_SIZE_EQ(IntSize(1000, 1000), frameView->frameRect().size());
 
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     pinchViewport.setScale(2);
     pinchViewport.setLocation(FloatPoint(350, 350));
 
     RefPtrWillBePersistent<HistoryItem> firstItem = webViewImpl()->mainFrameImpl()->frame()->loader().currentItem();
     EXPECT_POINT_EQ(IntPoint(0, 1000), firstItem->scrollPoint());
 
     // 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());
 }
 
 // Test that the coordinates sent into moveRangeSelection are offset by the
 // pinch viewport's location.
-TEST_F(PinchViewportTest, DISABLED_TestWebFrameRangeAccountsForPinchViewportScroll)
+TEST_P(ParameterizedPinchViewportTest, DISABLED_TestWebFrameRangeAccountsForPinchViewportScroll)
 {
     initializeWithDesktopSettings();
     webViewImpl()->settings()->setDefaultFontSize(12);
     webViewImpl()->resize(WebSize(640, 480));
     registerMockedHttpURLLoad("move_range.html");
     navigateTo(m_baseURL + "move_range.html");
 
     WebRect baseRect;
     WebRect extentRect;
 
@@ skipping 13 matching lines @@
     // Move the pinch 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.
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     pinchViewport.move(FloatPoint(60, 25));
     mainFrame->moveRangeSelection(initialPoint, endPoint);
     EXPECT_EQ("t ", mainFrame->selectionAsText().utf8());
 }
 
 // Test that the scrollFocusedNodeIntoRect method works with the pinch viewport.
-TEST_F(PinchViewportTest, DISABLED_TestScrollFocusedNodeIntoRect)
+TEST_P(ParameterizedPinchViewportTest, DISABLED_TestScrollFocusedNodeIntoRect)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(500, 300));
 
     registerMockedHttpURLLoad("pinch-viewport-input-field.html");
     navigateTo(m_baseURL + "pinch-viewport-input-field.html");
 
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     webViewImpl()->resizePinchViewport(IntSize(200, 100));
     webViewImpl()->setInitialFocus(false);
@@ skipping 24 matching lines @@
     webViewImpl()->resizePinchViewport(IntSize(500, 300));
     pinchViewport.setLocation(FloatPoint(30, 50));
 
     webViewImpl()->setPageScaleFactor(2);
     webViewImpl()->scrollFocusedNodeIntoRect(IntRect(0, 0, 500, 200));
     EXPECT_POINT_EQ(IntPoint(200-30-75, 600-50-65), frame()->view()->scrollPosition());
     EXPECT_FLOAT_POINT_EQ(FloatPoint(30, 50), pinchViewport.visibleRect().location());
 }
 
 // Test that resizing the WebView causes ViewportConstrained objects to relayout.
-TEST_F(PinchViewportTest, TestWebViewResizeCausesViewportConstrainedLayout)
+TEST_P(ParameterizedPinchViewportTest, TestWebViewResizeCausesViewportConstrainedLayout)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(500, 300));
 
     registerMockedHttpURLLoad("pinch-viewport-fixed-pos.html");
     navigateTo(m_baseURL + "pinch-viewport-fixed-pos.html");
 
     LayoutObject* navbar = frame()->document()->getElementById("navbar")->layoutObject();
 
     EXPECT_FALSE(navbar->needsLayout());
@@ skipping 12 matching lines @@
 MATCHER_P2(ContextMenuAtLocation, x, y,
     std::string(negation ? "is" : "isn't")
     + " at expected location ["
     + PrintToString(x) + ", " + PrintToString(y) + "]")
 {
     return arg.mousePosition.x == x && arg.mousePosition.y == y;
 }
 
 // Test that the context menu's location is correct in the presence of pinch
 // viewport offset.
-TEST_F(PinchViewportTest, TestContextMenuShownInCorrectLocation)
+TEST_P(ParameterizedPinchViewportTest, TestContextMenuShownInCorrectLocation)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(200, 300));
 
     registerMockedHttpURLLoad("200-by-300.html");
     navigateTo(m_baseURL + "200-by-300.html");
 
     WebMouseEvent mouseDownEvent;
     mouseDownEvent.type = WebInputEvent::MouseDown;
     mouseDownEvent.x = 10;
@@ skipping 32 matching lines @@
 
     mouseDownEvent.button = WebMouseEvent::ButtonRight;
     webViewImpl()->handleInputEvent(mouseDownEvent);
     webViewImpl()->handleInputEvent(mouseUpEvent);
 
     // Reset the old client so destruction can occur naturally.
     webViewImpl()->mainFrameImpl()->setClient(oldClient);
 }
 
 // Test that the client is notified if page scroll events.
-TEST_F(PinchViewportTest, TestClientNotifiedOfScrollEvents)
+TEST_P(ParameterizedPinchViewportTest, TestClientNotifiedOfScrollEvents)
 {
     initializeWithAndroidSettings();
     webViewImpl()->resize(IntSize(200, 300));
 
     registerMockedHttpURLLoad("200-by-300.html");
     navigateTo(m_baseURL + "200-by-300.html");
 
     WebFrameClient* oldClient = webViewImpl()->mainFrameImpl()->client();
     MockWebFrameClient mockWebFrameClient;
     webViewImpl()->mainFrameImpl()->setClient(&mockWebFrameClient);
@@ skipping 13 matching lines @@
     // Scroll horizontally.
     EXPECT_CALL(mockWebFrameClient, didChangeScrollOffset(_));
     pinchViewport.setLocation(FloatPoint(70, 90));
 
     // Reset the old client so destruction can occur naturally.
     webViewImpl()->mainFrameImpl()->setClient(oldClient);
 }
 
 // Tests that calling scroll into view on a visible element doesn cause
 // a scroll due to a fractional offset. Bug crbug.com/463356.
-TEST_F(PinchViewportTest, ScrollIntoViewFractionalOffset)
+TEST_P(ParameterizedPinchViewportTest, ScrollIntoViewFractionalOffset)
 {
     initializeWithAndroidSettings();
 
     webViewImpl()->resize(IntSize(1000, 1000));
 
     registerMockedHttpURLLoad("scroll-into-view.html");
     navigateTo(m_baseURL + "scroll-into-view.html");
 
     FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
+    ScrollableArea* layoutViewportScrollableArea = frameView.layoutViewportScrollableArea();
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     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()->setPinchViewportOffset(WebFloatPoint(250.25f, 100.25f));
-    frameView.setScrollPosition(DoublePoint(0, 900.75), ProgrammaticScroll);
+    layoutViewportScrollableArea->setScrollPosition(DoublePoint(0, 900.75), ProgrammaticScroll);
     inputBox->scrollIntoViewIfNeeded(false);
 
-    EXPECT_POINT_EQ(DoublePoint(0, 900.75), frameView.scrollPositionDouble());
+    EXPECT_POINT_EQ(DoublePoint(0, 900.75), layoutViewportScrollableArea->scrollPositionDouble());
     EXPECT_POINT_EQ(FloatPoint(250.25f, 100.25f), pinchViewport.location());
 
     // Change the fractional part of the frameview to one that would round down.
-    frameView.setScrollPosition(DoublePoint(0, 900.125), ProgrammaticScroll);
+    layoutViewportScrollableArea->setScrollPosition(DoublePoint(0, 900.125), ProgrammaticScroll);
     inputBox->scrollIntoViewIfNeeded(false);
 
-    EXPECT_POINT_EQ(DoublePoint(0, 900.125), frameView.scrollPositionDouble());
+    EXPECT_POINT_EQ(DoublePoint(0, 900.125), layoutViewportScrollableArea->scrollPositionDouble());
     EXPECT_POINT_EQ(FloatPoint(250.25f, 100.25f), pinchViewport.location());
 
     // Repeat both tests above with the pinch viewport at a high fractional.
     webViewImpl()->setPinchViewportOffset(WebFloatPoint(250.875f, 100.875f));
-    frameView.setScrollPosition(DoublePoint(0, 900.75), ProgrammaticScroll);
+    layoutViewportScrollableArea->setScrollPosition(DoublePoint(0, 900.75), ProgrammaticScroll);
     inputBox->scrollIntoViewIfNeeded(false);
 
-    EXPECT_POINT_EQ(DoublePoint(0, 900.75), frameView.scrollPositionDouble());
+    EXPECT_POINT_EQ(DoublePoint(0, 900.75), layoutViewportScrollableArea->scrollPositionDouble());
     EXPECT_POINT_EQ(FloatPoint(250.875f, 100.875f), pinchViewport.location());
 
     // Change the fractional part of the frameview to one that would round down.
-    frameView.setScrollPosition(DoublePoint(0, 900.125), ProgrammaticScroll);
+    layoutViewportScrollableArea->setScrollPosition(DoublePoint(0, 900.125), ProgrammaticScroll);
     inputBox->scrollIntoViewIfNeeded(false);
 
-    EXPECT_POINT_EQ(DoublePoint(0, 900.125), frameView.scrollPositionDouble());
+    EXPECT_POINT_EQ(DoublePoint(0, 900.125), layoutViewportScrollableArea->scrollPositionDouble());
     EXPECT_POINT_EQ(FloatPoint(250.875f, 100.875f), pinchViewport.location());
 
     // Both viewports with a 0.5 fraction.
     webViewImpl()->setPinchViewportOffset(WebFloatPoint(250.5f, 100.5f));
-    frameView.setScrollPosition(DoublePoint(0, 900.5), ProgrammaticScroll);
+    layoutViewportScrollableArea->setScrollPosition(DoublePoint(0, 900.5), ProgrammaticScroll);
     inputBox->scrollIntoViewIfNeeded(false);
 
-    EXPECT_POINT_EQ(DoublePoint(0, 900.5), frameView.scrollPositionDouble());
+    EXPECT_POINT_EQ(DoublePoint(0, 900.5), layoutViewportScrollableArea->scrollPositionDouble());
     EXPECT_POINT_EQ(FloatPoint(250.5f, 100.5f), pinchViewport.location());
 }
 
 // Top controls can make an unscrollable page temporarily scrollable, causing
 // a scroll clamp when the page is resized. Make sure this bug is fixed.
 // crbug.com/437620
 TEST_F(PinchViewportTest, TestResizeDoesntChangeScrollOffset)
 {
     initializeWithAndroidSettings();
     webViewImpl()->resize(IntSize(980, 650));
 
     navigateTo("about:blank");
 
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
 
     webViewImpl()->setTopControlsHeight(20, false);
 
     // Outer viewport isn't scrollable
     EXPECT_SIZE_EQ(IntSize(980, 650), frameView.visibleContentRect().size());
 
     pinchViewport.setScale(2);
     pinchViewport.move(FloatPoint(0, 40));
 
     // Simulate bringing down the top controls by 20px but counterscrolling the outer viewport.
     webViewImpl()->applyViewportDeltas(WebFloatSize(), WebFloatSize(0, 20), WebFloatSize(), 1, 1);
 
-    EXPECT_EQ(20, frameView.scrollPosition().y());
+    EXPECT_EQ(20, frameView.layoutViewportScrollableArea()->scrollPosition().y());
 
     webViewImpl()->setTopControlsHeight(20, true);
     webViewImpl()->resize(WebSize(980, 630));
 
-    EXPECT_EQ(0, frameView.scrollPosition().y());
+    EXPECT_EQ(0, frameView.layoutViewportScrollableArea()->scrollPosition().y());
     EXPECT_EQ(60, pinchViewport.location().y());
 }
 
 static IntPoint expectedMaxFrameViewScrollOffset(PinchViewport& pinchViewport, FrameView& frameView)
 {
     float aspectRatio = pinchViewport.visibleRect().width() / pinchViewport.visibleRect().height();
     float newHeight = frameView.frameRect().width() / aspectRatio;
     return IntPoint(
         frameView.contentsSize().width() - frameView.frameRect().width(),
         frameView.contentsSize().height() - newHeight);
@@ skipping 174 matching lines @@
     EXPECT_EQ(500, frameView.scrollPositionDouble().y());
 
     // Now send the resize, make sure the scroll offset doesn't change.
     webViewImpl()->setTopControlsHeight(500, false);
     webViewImpl()->resize(IntSize(1000, 1500));
     EXPECT_EQ(500, frameView.scrollPositionDouble().y());
 }
 
 // Tests that the layout viewport's scroll layer bounds are updated in a compositing
 // change update. crbug.com/423188.
-TEST_F(PinchViewportTest, TestChangingContentSizeAffectsScrollBounds)
+TEST_P(ParameterizedPinchViewportTest, TestChangingContentSizeAffectsScrollBounds)
 {
     initializeWithAndroidSettings();
     webViewImpl()->resize(IntSize(100, 150));
 
     registerMockedHttpURLLoad("content-width-1000.html");
     navigateTo(m_baseURL + "content-width-1000.html");
 
     FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
     WebLayer* scrollLayer = frameView.layerForScrolling()->platformLayer();
 
     webViewImpl()->mainFrame()->executeScript(WebScriptSource(
         "var content = document.getElementById(\"content\");"
         "content.style.width = \"1500px\";"
         "content.style.height = \"2400px\";"));
     frameView.updateLayoutAndStyleForPainting();
 
     EXPECT_SIZE_EQ(IntSize(1500, 2400), IntSize(scrollLayer->bounds()));
 }
 
 // Tests that resizing the pinch viepwort keeps its bounds within the outer
 // viewport.
-TEST_F(PinchViewportTest, ResizePinchViewportStaysWithinOuterViewport)
+TEST_P(ParameterizedPinchViewportTest, ResizePinchViewportStaysWithinOuterViewport)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(100, 200));
 
     navigateTo("about:blank");
     webViewImpl()->layout();
 
     webViewImpl()->resizePinchViewport(IntSize(100, 100));
 
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     pinchViewport.move(FloatPoint(0, 100));
 
     EXPECT_EQ(100, pinchViewport.location().y());
 
     webViewImpl()->resizePinchViewport(IntSize(100, 200));
 
     EXPECT_EQ(0, pinchViewport.location().y());
 }
 
-TEST_F(PinchViewportTest, ElementBoundsInViewportSpaceAccountsForViewport)
+TEST_P(ParameterizedPinchViewportTest, ElementBoundsInViewportSpaceAccountsForViewport)
 {
     initializeWithAndroidSettings();
 
     webViewImpl()->resize(IntSize(500, 800));
 
     registerMockedHttpURLLoad("pinch-viewport-input-field.html");
     navigateTo(m_baseURL + "pinch-viewport-input-field.html");
 
     webViewImpl()->setInitialFocus(false);
     Element* inputElement = webViewImpl()->focusedElement();
 
     IntRect bounds = inputElement->layoutObject()->absoluteBoundingBoxRect();
 
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     IntPoint scrollDelta(250, 400);
     pinchViewport.setScale(2);
     pinchViewport.setLocation(scrollDelta);
 
     IntRect boundsInViewport = inputElement->boundsInViewportSpace();
 
     EXPECT_POINT_EQ(IntPoint(bounds.location() - scrollDelta),
         boundsInViewport.location());
     EXPECT_SIZE_EQ(bounds.size(), boundsInViewport.size());
 }
 
 // Test that the various window.scroll and document.body.scroll properties and
 // methods work unchanged from the pre-virtual viewport mode.
-TEST_F(PinchViewportTest, bodyAndWindowScrollPropertiesAccountForViewport)
+TEST_P(ParameterizedPinchViewportTest, bodyAndWindowScrollPropertiesAccountForViewport)
 {
     initializeWithAndroidSettings();
 
     webViewImpl()->resize(IntSize(200, 300));
 
     // Load page with no main frame scrolling.
     registerMockedHttpURLLoad("200-by-300-viewport.html");
     navigateTo(m_baseURL + "200-by-300-viewport.html");
 
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
@@ skipping 57 matching lines @@
     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());
 }
 
 // Tests that when a new frame is created, it is created with the intended
 // size (i.e. viewport at minimum scale, 100x200 / 0.5).
-TEST_F(PinchViewportTest, TestMainFrameInitializationSizing)
+TEST_P(ParameterizedPinchViewportTest, TestMainFrameInitializationSizing)
 {
     initializeWithAndroidSettings();
 
     webViewImpl()->resize(IntSize(100, 200));
 
     registerMockedHttpURLLoad("content-width-1000-min-scale.html");
     navigateTo(m_baseURL + "content-width-1000-min-scale.html");
 
     WebLocalFrameImpl* localFrame = webViewImpl()->mainFrameImpl();
     // The detach() and dispose() calls are a hack to prevent this test
     // from violating invariants about frame state during navigation/detach.
     localFrame->frame()->document()->detach();
     localFrame->createFrameView();
 
     FrameView& frameView = *localFrame->frameView();
     EXPECT_SIZE_EQ(IntSize(200, 400), frameView.frameRect().size());
     frameView.dispose();
 }
 
 // Tests that the maximum scroll offset of the viewport can be fractional.
-TEST_F(PinchViewportTest, FractionalMaxScrollOffset)
+TEST_P(ParameterizedPinchViewportTest, FractionalMaxScrollOffset)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(101, 201));
     navigateTo("about:blank");
 
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
     ScrollableArea* scrollableArea = &pinchViewport;
 
     webViewImpl()->setPageScaleFactor(1.0);
     EXPECT_FLOAT_POINT_EQ(DoublePoint(), scrollableArea->maximumScrollPositionDouble());
 
     webViewImpl()->setPageScaleFactor(2);
     EXPECT_FLOAT_POINT_EQ(DoublePoint(101. / 2., 201. / 2.), scrollableArea->maximumScrollPositionDouble());
 }
 
 // Tests that the slow scrolling after an impl scroll on the pinch viewport
 // is continuous. crbug.com/453460 was caused by the impl-path not updating the
 // ScrollAnimator class.
-TEST_F(PinchViewportTest, SlowScrollAfterImplScroll)
+TEST_P(ParameterizedPinchViewportTest, SlowScrollAfterImplScroll)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(800, 600));
     navigateTo("about:blank");
 
     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
 
     // Apply some scroll and scale from the impl-side.
     webViewImpl()->applyViewportDeltas(
         WebFloatSize(300, 200),
@@ skipping 18 matching lines @@
     // The scroll sent from the impl-side must not be overwritten.
     EXPECT_POINT_EQ(FloatPoint(350, 260), pinchViewport.location());
 }
 
 static void accessibilitySettings(WebSettings* settings)
 {
     PinchViewportTest::configureSettings(settings);
     settings->setAccessibilityEnabled(true);
 }
 
-TEST_F(PinchViewportTest, AccessibilityHitTestWhileZoomedIn)
+TEST_P(ParameterizedPinchViewportTest, AccessibilityHitTestWhileZoomedIn)
 {
     initializeWithDesktopSettings(accessibilitySettings);
 
     registerMockedHttpURLLoad("hit-test.html");
     navigateTo(m_baseURL + "hit-test.html");
 
     webViewImpl()->resize(IntSize(500, 500));
     webViewImpl()->layout();
 
     WebDocument webDoc = webViewImpl()->mainFrame()->document();
     FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
 
     webViewImpl()->setPageScaleFactor(2);
     webViewImpl()->setPinchViewportOffset(WebFloatPoint(200, 230));
-    frameView.setScrollPosition(DoublePoint(400, 1100), ProgrammaticScroll);
+    frameView.layoutViewportScrollableArea()->setScrollPosition(DoublePoint(400, 1100), ProgrammaticScroll);
+
+    // FIXME(504057): DeprecatedPaintLayerScrollableArea dirties the compositing state.
+    forceFullCompositingUpdate();
 
     // Because of where the pinch viewport is located, this should hit the bottom right
     // target (target 4).
     WebAXObject hitNode = webDoc.accessibilityObject().hitTest(WebPoint(154, 165));
     EXPECT_EQ(std::string("Target4"), hitNode.title().utf8());
 }
 
 // Tests that the maximum scroll offset of the viewport can be fractional.
-TEST_F(PinchViewportTest, TestCoordinateTransforms)
+TEST_P(ParameterizedPinchViewportTest, TestCoordinateTransforms)
 {
     initializeWithAndroidSettings();
     webViewImpl()->resize(IntSize(800, 600));
     registerMockedHttpURLLoad("content-width-1000.html");
     navigateTo(m_baseURL + "content-width-1000.html");
 
     PinchViewport& pinchViewport = webViewImpl()->page()->frameHost().pinchViewport();
     FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
 
     // At scale = 1 the transform should be a no-op.
@@ skipping 10 matching lines @@
     pinchViewport.setLocation(FloatPoint(10, 12));
     EXPECT_FLOAT_POINT_EQ(FloatPoint(50, 62), pinchViewport.viewportToRootFrame(FloatPoint(80, 100)));
     EXPECT_FLOAT_POINT_EQ(FloatPoint(80, 100), pinchViewport.rootFrameToViewport(FloatPoint(50, 62)));
 
     // Test points that will cause non-integer values.
     EXPECT_FLOAT_POINT_EQ(FloatPoint(50.5, 62.4), pinchViewport.viewportToRootFrame(FloatPoint(81, 100.8)));
     EXPECT_FLOAT_POINT_EQ(FloatPoint(81, 100.8), pinchViewport.rootFrameToViewport(FloatPoint(50.5, 62.4)));
 
 
     // Scrolling the main frame should have no effect.
-    frameView.scrollTo(DoublePoint(100, 120));
+    frameView.layoutViewportScrollableArea()->setScrollPosition(DoublePoint(100, 120), ProgrammaticScroll);
     EXPECT_FLOAT_POINT_EQ(FloatPoint(50, 62), pinchViewport.viewportToRootFrame(FloatPoint(80, 100)));
     EXPECT_FLOAT_POINT_EQ(FloatPoint(80, 100), pinchViewport.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
-TEST_F(PinchViewportTest, WindowDimensionsOnLoad)
+TEST_P(ParameterizedPinchViewportTest, WindowDimensionsOnLoad)
 {
     initializeWithAndroidSettings();
     registerMockedHttpURLLoad("window_dimensions.html");
     webViewImpl()->resize(IntSize(800, 600));
     navigateTo(m_baseURL + "window_dimensions.html");
 
     Element* output = frame()->document()->getElementById("output");
     ASSERT(output);
     EXPECT_EQ(std::string("1600x1200"), std::string(output->innerHTML().ascii().data()));
 }
 
 // Similar to above but make sure the initial scale is updated with the content
 // width for a very wide page. That is, make that innerWidth/Height actually
 // trigger a layout of the content, and not just an update of the viepwort.
 // crbug.com/466718
-TEST_F(PinchViewportTest, WindowDimensionsOnLoadWideContent)
+TEST_P(ParameterizedPinchViewportTest, WindowDimensionsOnLoadWideContent)
 {
     initializeWithAndroidSettings();
     registerMockedHttpURLLoad("window_dimensions_wide_div.html");
     webViewImpl()->resize(IntSize(800, 600));
     navigateTo(m_baseURL + "window_dimensions_wide_div.html");
 
     Element* output = frame()->document()->getElementById("output");
     ASSERT(output);
     EXPECT_EQ(std::string("2000x1500"), std::string(output->innerHTML().ascii().data()));
 }
 
 } // namespace