[RootLayerScrolls] Fix ScrollingCoordinatorTest

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

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 20 matching lines @@
 #include "core/frame/VisualViewport.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/page/Page.h"
 #include "platform/geometry/IntPoint.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/graphics/GraphicsLayer.h"
+#include "platform/testing/RuntimeEnabledFeaturesTestHelpers.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebLayer.h"
 #include "public/platform/WebLayerPositionConstraint.h"
 #include "public/platform/WebLayerTreeView.h"
 #include "public/platform/WebURLLoaderMockFactory.h"
 #include "public/web/WebCache.h"
 #include "public/web/WebSettings.h"
 #include "public/web/WebViewClient.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebViewImpl.h"
 #include "web/tests/FrameTestHelpers.h"
 
 namespace blink {
 
-class ScrollingCoordinatorTest : public testing::Test {
+class ScrollingCoordinatorTest : public testing::Test,
+                                 public testing::WithParamInterface<bool>,
+                                 private ScopedRootLayerScrollingForTest {
  public:
-  ScrollingCoordinatorTest() : m_baseURL("http://www.test.com/") {
+  ScrollingCoordinatorTest()
+      : ScopedRootLayerScrollingForTest(GetParam()),
+        m_baseURL("http://www.test.com/") {
     m_helper.initialize(true, nullptr, &m_mockWebViewClient, nullptr,
                         &configureSettings);
     webViewImpl()->resize(IntSize(320, 240));
 
     // macOS attaches main frame scrollbars to the VisualViewport so the
     // VisualViewport layers need to be initialized.
     webViewImpl()->updateAllLifecyclePhases();
     WebFrameWidgetBase* mainFrameWidget =
         webViewImpl()->mainFrameImpl()->frameWidget();
     mainFrameWidget->setRootGraphicsLayer(webViewImpl()
                                               ->mainFrameImpl()
                                               ->frame()
                                               ->view()
                                               ->layoutViewItem()
                                               .compositor()
                                               ->rootGraphicsLayer());
   }
 
   ~ScrollingCoordinatorTest() override {
     Platform::current()->getURLLoaderMockFactory()->unregisterAllURLs();
     WebCache::clear();
   }
 
   void navigateTo(const std::string& url) {
     FrameTestHelpers::loadFrame(webViewImpl()->mainFrame(), url);
   }
 
+  void loadHTML(const std::string& html) {
+    FrameTestHelpers::loadHTMLString(webViewImpl()->mainFrame(), html,
+                                     URLTestHelpers::toKURL("about:blank"));
+  }
+
   void forceFullCompositingUpdate() {
     webViewImpl()->updateAllLifecyclePhases();
   }
 
   void registerMockedHttpURLLoad(const std::string& fileName) {
     URLTestHelpers::registerMockedURLFromBaseURL(
         WebString::fromUTF8(m_baseURL.c_str()),
         WebString::fromUTF8(fileName.c_str()));
   }
 
   WebLayer* getRootScrollLayer() {
-    PaintLayerCompositor* compositor =
-        frame()->contentLayoutItem().compositor();
-    DCHECK(compositor);
-    DCHECK(compositor->scrollLayer());
-
-    WebLayer* webScrollLayer = compositor->scrollLayer()->platformLayer();
-    return webScrollLayer;
+    GraphicsLayer* layer =
+        frame()->view()->layoutViewportScrollableArea()->layerForScrolling();
+    return layer ? layer->platformLayer() : nullptr;
   }
 
   WebViewImpl* webViewImpl() const { return m_helper.webView(); }
   LocalFrame* frame() const {
     return m_helper.webView()->mainFrameImpl()->frame();
   }
 
   WebLayerTreeView* webLayerTreeView() const {
     return webViewImpl()->layerTreeView();
   }
 
-  void styleRelatedMainThreadScrollingReasonTest(const std::string&,
-                                                 const uint32_t);
-
  protected:
   std::string m_baseURL;
   FrameTestHelpers::TestWebViewClient m_mockWebViewClient;
 
  private:
   static void configureSettings(WebSettings* settings) {
     settings->setJavaScriptEnabled(true);
     settings->setAcceleratedCompositingEnabled(true);
     settings->setPreferCompositingToLCDTextEnabled(true);
   }
 
   FrameTestHelpers::WebViewHelper m_helper;
 };
 
-TEST_F(ScrollingCoordinatorTest, fastScrollingByDefault) {
-  navigateTo("about:blank");
+INSTANTIATE_TEST_CASE_P(All, ScrollingCoordinatorTest, ::testing::Bool());
+
+TEST_P(ScrollingCoordinatorTest, fastScrollingByDefault) {
+  webViewImpl()->resize(WebSize(800, 600));
+  loadHTML("<div id='spacer' style='height: 1000px'></div>");
   forceFullCompositingUpdate();
 
   // Make sure the scrolling coordinator is active.
   FrameView* frameView = frame()->view();
   Page* page = frame()->page();
   ASSERT_TRUE(page->scrollingCoordinator());
   ASSERT_TRUE(page->scrollingCoordinator()->coordinatesScrollingForFrameView(
       frameView));
 
   // Fast scrolling should be enabled by default.
   WebLayer* rootScrollLayer = getRootScrollLayer();
+  ASSERT_TRUE(rootScrollLayer);
   ASSERT_TRUE(rootScrollLayer->scrollable());
   ASSERT_FALSE(rootScrollLayer->shouldScrollOnMainThread());
   ASSERT_EQ(WebEventListenerProperties::Nothing,
             webLayerTreeView()->eventListenerProperties(
                 WebEventListenerClass::TouchStartOrMove));
   ASSERT_EQ(WebEventListenerProperties::Nothing,
             webLayerTreeView()->eventListenerProperties(
                 WebEventListenerClass::MouseWheel));
 
   WebLayer* innerViewportScrollLayer =
       page->frameHost().visualViewport().scrollLayer()->platformLayer();
   ASSERT_TRUE(innerViewportScrollLayer->scrollable());
   ASSERT_FALSE(innerViewportScrollLayer->shouldScrollOnMainThread());
 }
 
-TEST_F(ScrollingCoordinatorTest, fastScrollingCanBeDisabledWithSetting) {
-  navigateTo("about:blank");
+TEST_P(ScrollingCoordinatorTest, fastScrollingCanBeDisabledWithSetting) {
+  webViewImpl()->resize(WebSize(800, 600));
+  loadHTML("<div id='spacer' style='height: 1000px'></div>");
   webViewImpl()->settings()->setThreadedScrollingEnabled(false);
   forceFullCompositingUpdate();
 
   // Make sure the scrolling coordinator is active.
   FrameView* frameView = frame()->view();
   Page* page = frame()->page();
   ASSERT_TRUE(page->scrollingCoordinator());
   ASSERT_TRUE(page->scrollingCoordinator()->coordinatesScrollingForFrameView(
       frameView));
 
   // Main scrolling should be enabled with the setting override.
   WebLayer* rootScrollLayer = getRootScrollLayer();
+  ASSERT_TRUE(rootScrollLayer);
   ASSERT_TRUE(rootScrollLayer->scrollable());
   ASSERT_TRUE(rootScrollLayer->shouldScrollOnMainThread());
 
   // Main scrolling should also propagate to inner viewport layer.
   WebLayer* innerViewportScrollLayer =
       page->frameHost().visualViewport().scrollLayer()->platformLayer();
   ASSERT_TRUE(innerViewportScrollLayer->scrollable());
   ASSERT_TRUE(innerViewportScrollLayer->shouldScrollOnMainThread());
 }
 
-TEST_F(ScrollingCoordinatorTest, fastFractionalScrollingDiv) {
+TEST_P(ScrollingCoordinatorTest, fastFractionalScrollingDiv) {
   bool origFractionalOffsetsEnabled =
       RuntimeEnabledFeatures::fractionalScrollOffsetsEnabled();
   RuntimeEnabledFeatures::setFractionalScrollOffsetsEnabled(true);
 
   registerMockedHttpURLLoad("fractional-scroll-div.html");
   navigateTo(m_baseURL + "fractional-scroll-div.html");
   forceFullCompositingUpdate();
 
   Document* document = frame()->document();
   Element* scrollableElement = document->getElementById("scroller");
@@ skipping 39 matching lines @@
   if (!layer->hasCompositedLayerMapping())
     return 0;
   CompositedLayerMapping* compositedLayerMapping =
       layer->compositedLayerMapping();
   GraphicsLayer* graphicsLayer = compositedLayerMapping->mainGraphicsLayer();
   if (!graphicsLayer)
     return 0;
   return graphicsLayer->platformLayer();
 }
 
-TEST_F(ScrollingCoordinatorTest, fastScrollingForFixedPosition) {
+TEST_P(ScrollingCoordinatorTest, fastScrollingForFixedPosition) {
   registerMockedHttpURLLoad("fixed-position.html");
   navigateTo(m_baseURL + "fixed-position.html");
   forceFullCompositingUpdate();
 
   // Fixed position should not fall back to main thread scrolling.
   WebLayer* rootScrollLayer = getRootScrollLayer();
+  ASSERT_TRUE(rootScrollLayer);
   ASSERT_FALSE(rootScrollLayer->shouldScrollOnMainThread());
 
   Document* document = frame()->document();
   {
     Element* element = document->getElementById("div-tl");
     ASSERT_TRUE(element);
     WebLayer* layer = webLayerFromElement(element);
     ASSERT_TRUE(layer);
     WebLayerPositionConstraint constraint = layer->positionConstraint();
     ASSERT_TRUE(constraint.isFixedPosition);
@@ skipping 65 matching lines @@
     ASSERT_TRUE(element);
     WebLayer* layer = webLayerFromElement(element);
     ASSERT_TRUE(layer);
     WebLayerPositionConstraint constraint = layer->positionConstraint();
     ASSERT_TRUE(constraint.isFixedPosition);
     ASSERT_TRUE(constraint.isFixedToRightEdge &&
                 constraint.isFixedToBottomEdge);
   }
 }
 
-TEST_F(ScrollingCoordinatorTest, fastScrollingForStickyPosition) {
+TEST_P(ScrollingCoordinatorTest, fastScrollingForStickyPosition) {
   registerMockedHttpURLLoad("sticky-position.html");
   navigateTo(m_baseURL + "sticky-position.html");
   forceFullCompositingUpdate();
 
   // Sticky position should not fall back to main thread scrolling.
   WebLayer* rootScrollLayer = getRootScrollLayer();
+  ASSERT_TRUE(rootScrollLayer);
   EXPECT_FALSE(rootScrollLayer->shouldScrollOnMainThread());
 
   Document* document = frame()->document();
   {
     Element* element = document->getElementById("div-tl");
     ASSERT_TRUE(element);
     WebLayer* layer = webLayerFromElement(element);
     ASSERT_TRUE(layer);
     WebLayerStickyPositionConstraint constraint =
         layer->stickyPositionConstraint();
@@ skipping 79 matching lines @@
     EXPECT_TRUE(constraint.isAnchoredTop);
     EXPECT_EQ(IntRect(100, 110, 10, 10),
               IntRect(constraint.scrollContainerRelativeStickyBoxRect));
     EXPECT_EQ(IntRect(100, 100, 200, 200),
               IntRect(constraint.scrollContainerRelativeContainingBlockRect));
     EXPECT_EQ(IntPoint(0, 10),
               IntPoint(constraint.parentRelativeStickyBoxOffset));
   }
 }
 
-TEST_F(ScrollingCoordinatorTest, touchEventHandler) {
+TEST_P(ScrollingCoordinatorTest, touchEventHandler) {
   registerMockedHttpURLLoad("touch-event-handler.html");
   navigateTo(m_baseURL + "touch-event-handler.html");
   forceFullCompositingUpdate();
 
   ASSERT_EQ(WebEventListenerProperties::Blocking,
             webLayerTreeView()->eventListenerProperties(
                 WebEventListenerClass::TouchStartOrMove));
 }
 
-TEST_F(ScrollingCoordinatorTest, touchEventHandlerPassive) {
+TEST_P(ScrollingCoordinatorTest, touchEventHandlerPassive) {
   registerMockedHttpURLLoad("touch-event-handler-passive.html");
   navigateTo(m_baseURL + "touch-event-handler-passive.html");
   forceFullCompositingUpdate();
 
   ASSERT_EQ(WebEventListenerProperties::Passive,
             webLayerTreeView()->eventListenerProperties(
                 WebEventListenerClass::TouchStartOrMove));
 }
 
-TEST_F(ScrollingCoordinatorTest, touchEventHandlerBoth) {
+TEST_P(ScrollingCoordinatorTest, touchEventHandlerBoth) {
   registerMockedHttpURLLoad("touch-event-handler-both.html");
   navigateTo(m_baseURL + "touch-event-handler-both.html");
   forceFullCompositingUpdate();
 
   ASSERT_EQ(WebEventListenerProperties::BlockingAndPassive,
             webLayerTreeView()->eventListenerProperties(
                 WebEventListenerClass::TouchStartOrMove));
 }
 
-TEST_F(ScrollingCoordinatorTest, wheelEventHandler) {
+TEST_P(ScrollingCoordinatorTest, wheelEventHandler) {
   registerMockedHttpURLLoad("wheel-event-handler.html");
   navigateTo(m_baseURL + "wheel-event-handler.html");
   forceFullCompositingUpdate();
 
   ASSERT_EQ(WebEventListenerProperties::Blocking,
             webLayerTreeView()->eventListenerProperties(
                 WebEventListenerClass::MouseWheel));
 }
 
-TEST_F(ScrollingCoordinatorTest, wheelEventHandlerPassive) {
+TEST_P(ScrollingCoordinatorTest, wheelEventHandlerPassive) {
   registerMockedHttpURLLoad("wheel-event-handler-passive.html");
   navigateTo(m_baseURL + "wheel-event-handler-passive.html");
   forceFullCompositingUpdate();
 
   ASSERT_EQ(WebEventListenerProperties::Passive,
             webLayerTreeView()->eventListenerProperties(
                 WebEventListenerClass::MouseWheel));
 }
 
-TEST_F(ScrollingCoordinatorTest, wheelEventHandlerBoth) {
+TEST_P(ScrollingCoordinatorTest, wheelEventHandlerBoth) {
   registerMockedHttpURLLoad("wheel-event-handler-both.html");
   navigateTo(m_baseURL + "wheel-event-handler-both.html");
   forceFullCompositingUpdate();
 
   ASSERT_EQ(WebEventListenerProperties::BlockingAndPassive,
             webLayerTreeView()->eventListenerProperties(
                 WebEventListenerClass::MouseWheel));
 }
 
-TEST_F(ScrollingCoordinatorTest, scrollEventHandler) {
+TEST_P(ScrollingCoordinatorTest, scrollEventHandler) {
   registerMockedHttpURLLoad("scroll-event-handler.html");
   navigateTo(m_baseURL + "scroll-event-handler.html");
   forceFullCompositingUpdate();
 
   ASSERT_TRUE(webLayerTreeView()->haveScrollEventHandlers());
 }
 
-TEST_F(ScrollingCoordinatorTest, updateEventHandlersDuringTeardown) {
+TEST_P(ScrollingCoordinatorTest, updateEventHandlersDuringTeardown) {
   registerMockedHttpURLLoad("scroll-event-handler-window.html");
   navigateTo(m_baseURL + "scroll-event-handler-window.html");
   forceFullCompositingUpdate();
 
   // Simulate detaching the document from its DOM window. This should not
   // cause a crash when the WebViewImpl is closed by the test runner.
   frame()->document()->shutdown();
 }
 
-TEST_F(ScrollingCoordinatorTest, clippedBodyTest) {
+TEST_P(ScrollingCoordinatorTest, clippedBodyTest) {
   registerMockedHttpURLLoad("clipped-body.html");
   navigateTo(m_baseURL + "clipped-body.html");
   forceFullCompositingUpdate();
 
   WebLayer* rootScrollLayer = getRootScrollLayer();
+  ASSERT_TRUE(rootScrollLayer);
   ASSERT_EQ(0u, rootScrollLayer->nonFastScrollableRegion().size());
 }
 
-TEST_F(ScrollingCoordinatorTest, overflowScrolling) {
+TEST_P(ScrollingCoordinatorTest, overflowScrolling) {
   registerMockedHttpURLLoad("overflow-scrolling.html");
   navigateTo(m_baseURL + "overflow-scrolling.html");
   forceFullCompositingUpdate();
 
   // Verify the properties of the accelerated scrolling element starting from
   // the LayoutObject all the way to the WebLayer.
   Element* scrollableElement =
       frame()->document()->getElementById("scrollable");
   DCHECK(scrollableElement);
 
@@ skipping 25 matching lines @@
   // Now verify we've attached impl-side scrollbars onto the scrollbar layers
   ASSERT_TRUE(compositedLayerMapping->layerForHorizontalScrollbar());
   ASSERT_TRUE(compositedLayerMapping->layerForHorizontalScrollbar()
                   ->hasContentsLayer());
   ASSERT_TRUE(compositedLayerMapping->layerForVerticalScrollbar());
   ASSERT_TRUE(
       compositedLayerMapping->layerForVerticalScrollbar()->hasContentsLayer());
 #endif
 }
 
-TEST_F(ScrollingCoordinatorTest, overflowHidden) {
+TEST_P(ScrollingCoordinatorTest, overflowHidden) {
   registerMockedHttpURLLoad("overflow-hidden.html");
   navigateTo(m_baseURL + "overflow-hidden.html");
   forceFullCompositingUpdate();
 
   // Verify the properties of the accelerated scrolling element starting from
   // the LayoutObject all the way to the WebLayer.
   Element* overflowElement =
       frame()->document()->getElementById("unscrollable-y");
   DCHECK(overflowElement);
 
@@ skipping 40 matching lines @@
   ASSERT_EQ(box->layer()->getScrollableArea(),
             graphicsLayer->getScrollableArea());
 
   webScrollLayer =
       compositedLayerMapping->scrollingContentsLayer()->platformLayer();
   ASSERT_TRUE(webScrollLayer->scrollable());
   ASSERT_FALSE(webScrollLayer->userScrollableHorizontal());
   ASSERT_TRUE(webScrollLayer->userScrollableVertical());
 }
 
-TEST_F(ScrollingCoordinatorTest, iframeScrolling) {
+TEST_P(ScrollingCoordinatorTest, iframeScrolling) {
   registerMockedHttpURLLoad("iframe-scrolling.html");
   registerMockedHttpURLLoad("iframe-scrolling-inner.html");
   navigateTo(m_baseURL + "iframe-scrolling.html");
   forceFullCompositingUpdate();
 
   // Verify the properties of the accelerated scrolling element starting from
   // the LayoutObject all the way to the WebLayer.
   Element* scrollableFrame = frame()->document()->getElementById("scrollable");
   ASSERT_TRUE(scrollableFrame);
 
   LayoutObject* layoutObject = scrollableFrame->layoutObject();
   ASSERT_TRUE(layoutObject);
   ASSERT_TRUE(layoutObject->isLayoutPart());
 
   LayoutPart* layoutPart = toLayoutPart(layoutObject);
   ASSERT_TRUE(layoutPart);
   ASSERT_TRUE(layoutPart->widget());
   ASSERT_TRUE(layoutPart->widget()->isFrameView());
 
   FrameView* innerFrameView = toFrameView(layoutPart->widget());
   LayoutViewItem innerLayoutViewItem = innerFrameView->layoutViewItem();
   ASSERT_FALSE(innerLayoutViewItem.isNull());
 
   PaintLayerCompositor* innerCompositor = innerLayoutViewItem.compositor();
   ASSERT_TRUE(innerCompositor->inCompositingMode());
-  ASSERT_TRUE(innerCompositor->scrollLayer());
 
-  GraphicsLayer* scrollLayer = innerCompositor->scrollLayer();
-  ASSERT_EQ(innerFrameView, scrollLayer->getScrollableArea());
+  GraphicsLayer* scrollLayer =
+      innerFrameView->layoutViewportScrollableArea()->layerForScrolling();
+  ASSERT_TRUE(scrollLayer);
+  ASSERT_EQ(innerFrameView->layoutViewportScrollableArea(),
+            scrollLayer->getScrollableArea());
 
   WebLayer* webScrollLayer = scrollLayer->platformLayer();
   ASSERT_TRUE(webScrollLayer->scrollable());
 
 #if OS(ANDROID)
   // Now verify we've attached impl-side scrollbars onto the scrollbar layers
   ASSERT_TRUE(innerCompositor->layerForHorizontalScrollbar());
   ASSERT_TRUE(
       innerCompositor->layerForHorizontalScrollbar()->hasContentsLayer());
   ASSERT_TRUE(innerCompositor->layerForVerticalScrollbar());
   ASSERT_TRUE(innerCompositor->layerForVerticalScrollbar()->hasContentsLayer());
 #endif
 }
 
-TEST_F(ScrollingCoordinatorTest, rtlIframe) {
+TEST_P(ScrollingCoordinatorTest, rtlIframe) {
   registerMockedHttpURLLoad("rtl-iframe.html");
   registerMockedHttpURLLoad("rtl-iframe-inner.html");
   navigateTo(m_baseURL + "rtl-iframe.html");
   forceFullCompositingUpdate();
 
   // Verify the properties of the accelerated scrolling element starting from
   // the LayoutObject all the way to the WebLayer.
   Element* scrollableFrame = frame()->document()->getElementById("scrollable");
   ASSERT_TRUE(scrollableFrame);
 
   LayoutObject* layoutObject = scrollableFrame->layoutObject();
   ASSERT_TRUE(layoutObject);
   ASSERT_TRUE(layoutObject->isLayoutPart());
 
   LayoutPart* layoutPart = toLayoutPart(layoutObject);
   ASSERT_TRUE(layoutPart);
   ASSERT_TRUE(layoutPart->widget());
   ASSERT_TRUE(layoutPart->widget()->isFrameView());
 
   FrameView* innerFrameView = toFrameView(layoutPart->widget());
   LayoutViewItem innerLayoutViewItem = innerFrameView->layoutViewItem();
   ASSERT_FALSE(innerLayoutViewItem.isNull());
 
   PaintLayerCompositor* innerCompositor = innerLayoutViewItem.compositor();
   ASSERT_TRUE(innerCompositor->inCompositingMode());
-  ASSERT_TRUE(innerCompositor->scrollLayer());
 
-  GraphicsLayer* scrollLayer = innerCompositor->scrollLayer();
-  ASSERT_EQ(innerFrameView, scrollLayer->getScrollableArea());
+  GraphicsLayer* scrollLayer =
+      innerFrameView->layoutViewportScrollableArea()->layerForScrolling();
+  ASSERT_TRUE(scrollLayer);
+  ASSERT_EQ(innerFrameView->layoutViewportScrollableArea(),
+            scrollLayer->getScrollableArea());
 
   WebLayer* webScrollLayer = scrollLayer->platformLayer();
   ASSERT_TRUE(webScrollLayer->scrollable());
 
   int expectedScrollPosition =
-      958 +
-      (innerFrameView->verticalScrollbar()->isOverlayScrollbar() ? 0 : 15);
+      958 + (innerFrameView->layoutViewportScrollableArea()
+                     ->verticalScrollbar()
+                     ->isOverlayScrollbar()
+                 ? 0
+                 : 15);
   ASSERT_EQ(expectedScrollPosition, webScrollLayer->scrollPositionDouble().x);
 }
 
-TEST_F(ScrollingCoordinatorTest, setupScrollbarLayerShouldNotCrash) {
+TEST_P(ScrollingCoordinatorTest, setupScrollbarLayerShouldNotCrash) {
   registerMockedHttpURLLoad("setup_scrollbar_layer_crash.html");
   navigateTo(m_baseURL + "setup_scrollbar_layer_crash.html");
   forceFullCompositingUpdate();
   // This test document setup an iframe with scrollbars, then switch to
   // an empty document by javascript.
 }
 
-TEST_F(ScrollingCoordinatorTest,
+TEST_P(ScrollingCoordinatorTest,
        scrollbarsForceMainThreadOrHaveWebScrollbarLayer) {
   registerMockedHttpURLLoad("trivial-scroller.html");
   navigateTo(m_baseURL + "trivial-scroller.html");
   forceFullCompositingUpdate();
 
   Document* document = frame()->document();
   Element* scrollableElement = document->getElementById("scroller");
   DCHECK(scrollableElement);
 
   LayoutObject* layoutObject = scrollableElement->layoutObject();
   ASSERT_TRUE(layoutObject->isBox());
   LayoutBox* box = toLayoutBox(layoutObject);
   ASSERT_TRUE(box->usesCompositedScrolling());
   CompositedLayerMapping* compositedLayerMapping =
       box->layer()->compositedLayerMapping();
   GraphicsLayer* scrollbarGraphicsLayer =
       compositedLayerMapping->layerForVerticalScrollbar();
   ASSERT_TRUE(scrollbarGraphicsLayer);
 
   bool hasWebScrollbarLayer = !scrollbarGraphicsLayer->drawsContent();
   ASSERT_TRUE(
       hasWebScrollbarLayer ||
       scrollbarGraphicsLayer->platformLayer()->shouldScrollOnMainThread());
 }
 
 #if OS(MACOSX) || OS(ANDROID)
-TEST_F(ScrollingCoordinatorTest,
+TEST_P(ScrollingCoordinatorTest,
        DISABLED_setupScrollbarLayerShouldSetScrollLayerOpaque)
 #else
-TEST_F(ScrollingCoordinatorTest, setupScrollbarLayerShouldSetScrollLayerOpaque)
+TEST_P(ScrollingCoordinatorTest, setupScrollbarLayerShouldSetScrollLayerOpaque)
 #endif
 {
   registerMockedHttpURLLoad("wide_document.html");
   navigateTo(m_baseURL + "wide_document.html");
   forceFullCompositingUpdate();
 
   FrameView* frameView = frame()->view();
   ASSERT_TRUE(frameView);
 
   GraphicsLayer* scrollbarGraphicsLayer =
-      frameView->layerForHorizontalScrollbar();
+      frameView->layoutViewportScrollableArea()->layerForHorizontalScrollbar();
   ASSERT_TRUE(scrollbarGraphicsLayer);
 
   WebLayer* platformLayer = scrollbarGraphicsLayer->platformLayer();
   ASSERT_TRUE(platformLayer);
 
   WebLayer* contentsLayer = scrollbarGraphicsLayer->contentsLayer();
   ASSERT_TRUE(contentsLayer);
 
   // After scrollableAreaScrollbarLayerDidChange,
   // if the main frame's scrollbarLayer is opaque,
   // contentsLayer should be opaque too.
   ASSERT_EQ(platformLayer->opaque(), contentsLayer->opaque());
 }
 
-TEST_F(ScrollingCoordinatorTest,
+TEST_P(ScrollingCoordinatorTest,
        FixedPositionLosingBackingShouldTriggerMainThreadScroll) {
   webViewImpl()->settings()->setPreferCompositingToLCDTextEnabled(false);
   registerMockedHttpURLLoad("fixed-position-losing-backing.html");
   navigateTo(m_baseURL + "fixed-position-losing-backing.html");
   forceFullCompositingUpdate();
 
-  WebLayer* scrollLayer = frame()
-                              ->page()
-                              ->deprecatedLocalMainFrame()
-                              ->view()
-                              ->layerForScrolling()
-                              ->platformLayer();
+  WebLayer* scrollLayer = getRootScrollLayer();
+  ASSERT_TRUE(scrollLayer);
+
   Document* document = frame()->document();
   Element* fixedPos = document->getElementById("fixed");
 
   EXPECT_TRUE(static_cast<LayoutBoxModelObject*>(fixedPos->layoutObject())
                   ->layer()
                   ->hasCompositedLayerMapping());
   EXPECT_FALSE(scrollLayer->shouldScrollOnMainThread());
 
   fixedPos->setInlineStyleProperty(CSSPropertyTransform, CSSValueNone);
   forceFullCompositingUpdate();
 
   EXPECT_FALSE(static_cast<LayoutBoxModelObject*>(fixedPos->layoutObject())
                    ->layer()
                    ->hasCompositedLayerMapping());
   EXPECT_TRUE(scrollLayer->shouldScrollOnMainThread());
 }
 
-TEST_F(ScrollingCoordinatorTest, CustomScrollbarShouldTriggerMainThreadScroll) {
+TEST_P(ScrollingCoordinatorTest, CustomScrollbarShouldTriggerMainThreadScroll) {
   webViewImpl()->settings()->setPreferCompositingToLCDTextEnabled(true);
   webViewImpl()->setDeviceScaleFactor(2.f);
   registerMockedHttpURLLoad("custom_scrollbar.html");
   navigateTo(m_baseURL + "custom_scrollbar.html");
   forceFullCompositingUpdate();
 
   Document* document = frame()->document();
   Element* container = document->getElementById("container");
   Element* content = document->getElementById("content");
   DCHECK_EQ(container->getAttribute(HTMLNames::classAttr), "custom_scrollbar");
@@ skipping 20 matching lines @@
   container->removeAttribute("class");
   forceFullCompositingUpdate();
   scrollbarGraphicsLayer = compositedLayerMapping->layerForVerticalScrollbar();
   ASSERT_FALSE(
       scrollbarGraphicsLayer->platformLayer()->shouldScrollOnMainThread());
   ASSERT_FALSE(
       scrollbarGraphicsLayer->platformLayer()->mainThreadScrollingReasons() &
       MainThreadScrollingReason::kCustomScrollbarScrolling);
 }
 
-TEST_F(ScrollingCoordinatorTest,
+TEST_P(ScrollingCoordinatorTest,
        BackgroundAttachmentFixedShouldTriggerMainThreadScroll) {
   registerMockedHttpURLLoad("iframe-background-attachment-fixed.html");
   registerMockedHttpURLLoad("iframe-background-attachment-fixed-inner.html");
   registerMockedHttpURLLoad("white-1x1.png");
   navigateTo(m_baseURL + "iframe-background-attachment-fixed.html");
   forceFullCompositingUpdate();
 
   Element* iframe = frame()->document()->getElementById("iframe");
   ASSERT_TRUE(iframe);
 
   LayoutObject* layoutObject = iframe->layoutObject();
   ASSERT_TRUE(layoutObject);
   ASSERT_TRUE(layoutObject->isLayoutPart());
 
   LayoutPart* layoutPart = toLayoutPart(layoutObject);
   ASSERT_TRUE(layoutPart);
   ASSERT_TRUE(layoutPart->widget());
   ASSERT_TRUE(layoutPart->widget()->isFrameView());
 
   FrameView* innerFrameView = toFrameView(layoutPart->widget());
   LayoutViewItem innerLayoutViewItem = innerFrameView->layoutViewItem();
   ASSERT_FALSE(innerLayoutViewItem.isNull());
 
   PaintLayerCompositor* innerCompositor = innerLayoutViewItem.compositor();
   ASSERT_TRUE(innerCompositor->inCompositingMode());
-  ASSERT_TRUE(innerCompositor->scrollLayer());
 
-  GraphicsLayer* scrollLayer = innerCompositor->scrollLayer();
-  ASSERT_EQ(innerFrameView, scrollLayer->getScrollableArea());
+  GraphicsLayer* scrollLayer =
+      innerFrameView->layoutViewportScrollableArea()->layerForScrolling();
+  ASSERT_TRUE(scrollLayer);
+  ASSERT_EQ(innerFrameView->layoutViewportScrollableArea(),
+            scrollLayer->getScrollableArea());
 
   WebLayer* webScrollLayer = scrollLayer->platformLayer();
   ASSERT_TRUE(webScrollLayer->scrollable());
   ASSERT_TRUE(webScrollLayer->mainThreadScrollingReasons() &
               MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
 
   // Remove fixed background-attachment should make the iframe
   // scroll on cc.
   auto* iframeDoc = toHTMLIFrameElement(iframe)->contentDocument();
   iframe = iframeDoc->getElementById("scrollable");
   ASSERT_TRUE(iframe);
 
   iframe->removeAttribute("class");
   forceFullCompositingUpdate();
 
   layoutObject = iframe->layoutObject();
   ASSERT_TRUE(layoutObject);
 
-  scrollLayer = layoutObject->frameView()->layerForScrolling();
+  scrollLayer = layoutObject->frameView()
+                    ->layoutViewportScrollableArea()
+                    ->layerForScrolling();
   ASSERT_TRUE(scrollLayer);
 
   webScrollLayer = scrollLayer->platformLayer();
   ASSERT_TRUE(webScrollLayer->scrollable());
   ASSERT_FALSE(webScrollLayer->mainThreadScrollingReasons() &
                MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
 
   // Force main frame to scroll on main thread. All its descendants
   // should scroll on main thread as well.
   Element* element = frame()->document()->getElementById("scrollable");
   element->setAttribute(
       "style",
       "background-image: url('white-1x1.png'); background-attachment: fixed;",
       ASSERT_NO_EXCEPTION);
 
   forceFullCompositingUpdate();
 
   layoutObject = iframe->layoutObject();
   ASSERT_TRUE(layoutObject);
 
-  scrollLayer = layoutObject->frameView()->layerForScrolling();
+  scrollLayer = layoutObject->frameView()
+                    ->layoutViewportScrollableArea()
+                    ->layerForScrolling();
   ASSERT_TRUE(scrollLayer);
 
   webScrollLayer = scrollLayer->platformLayer();
   ASSERT_TRUE(webScrollLayer->scrollable());
   ASSERT_TRUE(webScrollLayer->mainThreadScrollingReasons() &
               MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
 }
 
 // Upon resizing the content size, the main thread scrolling reason
 // kHasNonLayerViewportConstrainedObject should be updated on all frames
-TEST_F(ScrollingCoordinatorTest,
+TEST_P(ScrollingCoordinatorTest,
        RecalculateMainThreadScrollingReasonsUponResize) {
   webViewImpl()->settings()->setPreferCompositingToLCDTextEnabled(false);
   registerMockedHttpURLLoad("has-non-layer-viewport-constrained-objects.html");
   navigateTo(m_baseURL + "has-non-layer-viewport-constrained-objects.html");
   forceFullCompositingUpdate();
 
   LOG(ERROR) << frame()->view()->mainThreadScrollingReasons();
   Element* element = frame()->document()->getElementById("scrollable");
   ASSERT_TRUE(element);
 
   LayoutObject* layoutObject = element->layoutObject();
   ASSERT_TRUE(layoutObject);
 
-  GraphicsLayer* scrollLayer = layoutObject->frameView()->layerForScrolling();
-  ASSERT_TRUE(scrollLayer);
+  GraphicsLayer* scrollLayer = layoutObject->frameView()
+                                   ->layoutViewportScrollableArea()
+                                   ->layerForScrolling();
+  WebLayer* webScrollLayer;
 
-  WebLayer* webScrollLayer = scrollLayer->platformLayer();
-  ASSERT_TRUE(webScrollLayer->scrollable());
-  ASSERT_FALSE(
-      webScrollLayer->mainThreadScrollingReasons() &
-      MainThreadScrollingReason::kHasNonLayerViewportConstrainedObjects);
-
-  Element* iframe = frame()->document()->getElementById("iframe");
-  ASSERT_TRUE(iframe);
-
-  layoutObject = iframe->layoutObject();
-  ASSERT_TRUE(layoutObject);
-
-  scrollLayer = layoutObject->frameView()->layerForScrolling();
-  ASSERT_TRUE(scrollLayer);
-
-  webScrollLayer = scrollLayer->platformLayer();
-  ASSERT_TRUE(webScrollLayer->scrollable());
-  ASSERT_FALSE(
-      webScrollLayer->mainThreadScrollingReasons() &
-      MainThreadScrollingReason::kHasNonLayerViewportConstrainedObjects);
+  if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
+    // When RLS is enabled, the LayoutView won't have a scrolling contents
+    // because it does not overflow.
+    ASSERT_FALSE(scrollLayer);
+  } else {
+    ASSERT_TRUE(scrollLayer);
+    webScrollLayer = scrollLayer->platformLayer();
+    ASSERT_TRUE(webScrollLayer->scrollable());
+    ASSERT_FALSE(
+        webScrollLayer->mainThreadScrollingReasons() &
+        MainThreadScrollingReason::kHasNonLayerViewportConstrainedObjects);
+  }
 
   // When the div becomes to scrollable it should scroll on main thread
   element->setAttribute("style",
                         "overflow:scroll;height:2000px;will-change:transform;",
                         ASSERT_NO_EXCEPTION);
   forceFullCompositingUpdate();
 
   layoutObject = element->layoutObject();
   ASSERT_TRUE(layoutObject);
 
-  scrollLayer = layoutObject->frameView()->layerForScrolling();
+  scrollLayer = layoutObject->frameView()
+                    ->layoutViewportScrollableArea()
+                    ->layerForScrolling();
   ASSERT_TRUE(scrollLayer);
 
   webScrollLayer = scrollLayer->platformLayer();
-  ASSERT_TRUE(webScrollLayer->scrollable());
-  ASSERT_TRUE(
-      webScrollLayer->mainThreadScrollingReasons() &
-      MainThreadScrollingReason::kHasNonLayerViewportConstrainedObjects);
-
-  layoutObject = iframe->layoutObject();
-  ASSERT_TRUE(layoutObject);
-
-  scrollLayer = layoutObject->frameView()->layerForScrolling();
-  ASSERT_TRUE(scrollLayer);
-
-  webScrollLayer = scrollLayer->platformLayer();
   ASSERT_TRUE(webScrollLayer->scrollable());
   ASSERT_TRUE(
       webScrollLayer->mainThreadScrollingReasons() &
       MainThreadScrollingReason::kHasNonLayerViewportConstrainedObjects);
 
   // The main thread scrolling reason should be reset upon the following change
   element->setAttribute("style",
                         "overflow:scroll;height:200px;will-change:transform;",
                         ASSERT_NO_EXCEPTION);
   forceFullCompositingUpdate();
 
   layoutObject = element->layoutObject();
   ASSERT_TRUE(layoutObject);
 
-  scrollLayer = layoutObject->frameView()->layerForScrolling();
-  ASSERT_TRUE(scrollLayer);
-
-  webScrollLayer = scrollLayer->platformLayer();
-  ASSERT_TRUE(webScrollLayer->scrollable());
-  ASSERT_FALSE(
-      webScrollLayer->mainThreadScrollingReasons() &
-      MainThreadScrollingReason::kHasNonLayerViewportConstrainedObjects);
-
-  layoutObject = iframe->layoutObject();
-  ASSERT_TRUE(layoutObject);
-
-  scrollLayer = layoutObject->frameView()->layerForScrolling();
-  ASSERT_TRUE(scrollLayer);
-
-  webScrollLayer = scrollLayer->platformLayer();
-  ASSERT_TRUE(webScrollLayer->scrollable());
-  ASSERT_FALSE(
-      webScrollLayer->mainThreadScrollingReasons() &
-      MainThreadScrollingReason::kHasNonLayerViewportConstrainedObjects);
+  scrollLayer = layoutObject->frameView()
+                    ->layoutViewportScrollableArea()
+                    ->layerForScrolling();
+  if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
+    // When RLS is enabled, the LayoutView won't have a scrolling contents
+    // because it does not overflow.
+    ASSERT_FALSE(scrollLayer);
+  } else {
+    ASSERT_TRUE(scrollLayer);
+    webScrollLayer = scrollLayer->platformLayer();
+    ASSERT_TRUE(webScrollLayer->scrollable());
+    ASSERT_FALSE(
+        webScrollLayer->mainThreadScrollingReasons() &
+        MainThreadScrollingReason::kHasNonLayerViewportConstrainedObjects);
+  }
 }
 
 class StyleRelatedMainThreadScrollingReasonTest
     : public ScrollingCoordinatorTest {
   static const uint32_t m_LCDTextRelatedReasons =
       MainThreadScrollingReason::kHasOpacityAndLCDText |
       MainThreadScrollingReason::kHasTransformAndLCDText |
       MainThreadScrollingReason::kBackgroundNotOpaqueInRectAndLCDText;
 
  protected:
@@ skipping 42 matching lines @@
 
     if ((reason & m_LCDTextRelatedReasons) &&
         !(reason & ~m_LCDTextRelatedReasons)) {
       webViewImpl()->settings()->setPreferCompositingToLCDTextEnabled(true);
       forceFullCompositingUpdate();
       ASSERT_FALSE(frameView->mainThreadScrollingReasons());
     }
   }
 };
 
-TEST_F(StyleRelatedMainThreadScrollingReasonTest, TransparentTest) {
+INSTANTIATE_TEST_CASE_P(All,
+                        StyleRelatedMainThreadScrollingReasonTest,
+                        ::testing::Bool());
+
+TEST_P(StyleRelatedMainThreadScrollingReasonTest, TransparentTest) {
   testStyle("transparent", MainThreadScrollingReason::kHasOpacityAndLCDText);
 }
 
-TEST_F(StyleRelatedMainThreadScrollingReasonTest, TransformTest) {
+TEST_P(StyleRelatedMainThreadScrollingReasonTest, TransformTest) {
   testStyle("transform", MainThreadScrollingReason::kHasTransformAndLCDText);
 }
 
-TEST_F(StyleRelatedMainThreadScrollingReasonTest, BackgroundNotOpaqueTest) {
+TEST_P(StyleRelatedMainThreadScrollingReasonTest, BackgroundNotOpaqueTest) {
   testStyle("background-not-opaque",
             MainThreadScrollingReason::kBackgroundNotOpaqueInRectAndLCDText);
 }
 
-TEST_F(StyleRelatedMainThreadScrollingReasonTest, BorderRadiusTest) {
+TEST_P(StyleRelatedMainThreadScrollingReasonTest, BorderRadiusTest) {
   testStyle("border-radius", MainThreadScrollingReason::kHasBorderRadius);
 }
 
-TEST_F(StyleRelatedMainThreadScrollingReasonTest, ClipTest) {
+TEST_P(StyleRelatedMainThreadScrollingReasonTest, ClipTest) {
   testStyle("clip", MainThreadScrollingReason::kHasClipRelatedProperty);
 }
 
-TEST_F(StyleRelatedMainThreadScrollingReasonTest, ClipPathTest) {
+TEST_P(StyleRelatedMainThreadScrollingReasonTest, ClipPathTest) {
   uint32_t reason = MainThreadScrollingReason::kHasClipRelatedProperty;
   webViewImpl()->settings()->setPreferCompositingToLCDTextEnabled(false);
   Document* document = frame()->document();
   // Test ancestor with ClipPath
   Element* element = document->body();
   DCHECK(element);
   element->setAttribute(HTMLNames::styleAttr,
                         "clip-path:circle(115px at 20px 20px);");
   forceFullCompositingUpdate();
 
@@ skipping 14 matching lines @@
                         "clip-path:circle(115px at 20px 20px);");
   forceFullCompositingUpdate();
   ASSERT_TRUE(frameView->mainThreadScrollingReasons() & reason);
 
   // Remove clip path from descendant.
   element->removeAttribute(HTMLNames::styleAttr);
   forceFullCompositingUpdate();
   ASSERT_FALSE(frameView->mainThreadScrollingReasons() & reason);
 }
 
-TEST_F(StyleRelatedMainThreadScrollingReasonTest, LCDTextEnabledTest) {
+TEST_P(StyleRelatedMainThreadScrollingReasonTest, LCDTextEnabledTest) {
   testStyle("transparent border-radius",
             MainThreadScrollingReason::kHasOpacityAndLCDText |
                 MainThreadScrollingReason::kHasBorderRadius);
 }
 
-TEST_F(StyleRelatedMainThreadScrollingReasonTest, BoxShadowTest) {
+TEST_P(StyleRelatedMainThreadScrollingReasonTest, BoxShadowTest) {
   testStyle("box-shadow",
             MainThreadScrollingReason::kHasBoxShadowFromNonRootLayer);
 }
 
 }  // namespace blink