[SPV2] Implement the blink-side scroll property tree

third_party/WebKit/Source/core/paint/PaintPropertyTreeBuilderTest.cpp

 // Copyright 2015 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/layout/LayoutTestHelper.h"
 #include "core/layout/LayoutTreeAsText.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintPropertyTreePrinter.h"
 #include "platform/graphics/paint/GeometryMapper.h"
+#include "platform/graphics/paint/ScrollPaintPropertyNode.h"
 #include "platform/graphics/paint/TransformPaintPropertyNode.h"
 #include "platform/testing/RuntimeEnabledFeaturesTestHelpers.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "platform/text/TextStream.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/HashMap.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
@@ skipping 50 matching lines @@
     }
 
     const ClipPaintPropertyNode* frameContentClip()
     {
         FrameView* frameView = document().view();
         if (RuntimeEnabledFeatures::rootLayerScrollingEnabled())
             return frameView->layoutView()->objectPaintProperties()->overflowClip();
         return frameView->contentClip();
     }
 
+    const ScrollPaintPropertyNode* frameScroll()
+    {
+        FrameView* frameView = document().view();
+        if (RuntimeEnabledFeatures::rootLayerScrollingEnabled())
+            return frameView->layoutView()->objectPaintProperties()->scroll();
+        return frameView->scroll();
+    }
+
 private:
     void SetUp() override
     {
         Settings::setMockScrollbarsEnabled(true);
 
         RenderingTest::SetUp();
         enableCompositing();
     }
 
     void TearDown() override
@@ skipping 35 matching lines @@
 } while (0)
 
 #define CHECK_EXACT_VISUAL_RECT(expected, sourceLayoutObject, ancestorLayoutObject) CHECK_VISUAL_RECT(expected, sourceLayoutObject, ancestorLayoutObject, 0)
 
 INSTANTIATE_TEST_CASE_P(All, PaintPropertyTreeBuilderTest, ::testing::Bool());
 
 TEST_P(PaintPropertyTreeBuilderTest, FixedPosition)
 {
     loadTestData("fixed-position.html");
 
+    Element* positionedScroll = document().getElementById("positionedScroll");
+    positionedScroll->setScrollTop(3);
+    Element* transformedScroll = document().getElementById("transformedScroll");
+    transformedScroll->setScrollTop(5);
+
     FrameView* frameView = document().view();
+    frameView->updateAllLifecyclePhases();
 
     // target1 is a fixed-position element inside an absolute-position scrolling element.
     // It should be attached under the viewport to skip scrolling and offset of the parent.
     Element* target1 = document().getElementById("target1");
     const ObjectPaintProperties* target1Properties = target1->layoutObject()->objectPaintProperties();
     EXPECT_EQ(TransformationMatrix().translate(200, 150), target1Properties->paintOffsetTranslation()->matrix());
     EXPECT_EQ(framePreTranslation(), target1Properties->paintOffsetTranslation()->parent());
     EXPECT_EQ(target1Properties->paintOffsetTranslation(), target1Properties->overflowClip()->localTransformSpace());
     EXPECT_EQ(FloatRoundedRect(0, 0, 100, 100), target1Properties->overflowClip()->clipRect());
     // Likewise, it inherits clip from the viewport, skipping overflow clip of the scroller.
     EXPECT_EQ(frameContentClip(), target1Properties->overflowClip()->parent());
+    // target1 should not have it's own scroll node and instead should inherit positionedScroll's.
+    const ObjectPaintProperties* positionedScrollProperties = positionedScroll->layoutObject()->objectPaintProperties();
+    EXPECT_EQ(frameScroll(), positionedScrollProperties->scroll()->parent());
+    EXPECT_EQ(TransformationMatrix().translate(0, -3), positionedScrollProperties->scroll()->scrollOffsetTranslation()->matrix());
+    EXPECT_EQ(nullptr, target1Properties->scroll());
+
     CHECK_EXACT_VISUAL_RECT(LayoutRect(200, 150, 100, 100), target1->layoutObject(), frameView->layoutView());
 
     // target2 is a fixed-position element inside a transformed scrolling element.
     // It should be attached under the scrolled box of the transformed element.
     Element* target2 = document().getElementById("target2");
     const ObjectPaintProperties* target2Properties = target2->layoutObject()->objectPaintProperties();
-    Element* scroller = document().getElementById("scroller");
+    Element* scroller = document().getElementById("transformedScroll");
     const ObjectPaintProperties* scrollerProperties = scroller->layoutObject()->objectPaintProperties();
     EXPECT_EQ(TransformationMatrix().translate(200, 150), target2Properties->paintOffsetTranslation()->matrix());
     EXPECT_EQ(scrollerProperties->scrollTranslation(), target2Properties->paintOffsetTranslation()->parent());
     EXPECT_EQ(target2Properties->paintOffsetTranslation(), target2Properties->overflowClip()->localTransformSpace());
     EXPECT_EQ(FloatRoundedRect(0, 0, 100, 100), target2Properties->overflowClip()->clipRect());
     EXPECT_EQ(scrollerProperties->overflowClip(), target2Properties->overflowClip()->parent());
-    CHECK_EXACT_VISUAL_RECT(LayoutRect(208, 158, 200, 100), target2->layoutObject(), frameView->layoutView());
+    // target2 should not have it's own scroll node and instead should inherit transformedScroll's.
+    const ObjectPaintProperties* transformedScrollProperties = transformedScroll->layoutObject()->objectPaintProperties();
+    EXPECT_EQ(frameScroll(), transformedScrollProperties->scroll()->parent());
+    EXPECT_EQ(TransformationMatrix().translate(0, -5), transformedScrollProperties->scroll()->scrollOffsetTranslation()->matrix());
+    EXPECT_EQ(nullptr, target2Properties->scroll());
+
+    CHECK_EXACT_VISUAL_RECT(LayoutRect(208, 153, 200, 100), target2->layoutObject(), frameView->layoutView());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, PositionAndScroll)
 {
     loadTestData("position-and-scroll.html");
 
     Element* scroller = document().getElementById("scroller");
     scroller->scrollTo(0, 100);
     FrameView* frameView = document().view();
     frameView->updateAllLifecyclePhases();
     const ObjectPaintProperties* scrollerProperties = scroller->layoutObject()->objectPaintProperties();
     EXPECT_EQ(TransformationMatrix().translate(0, -100), scrollerProperties->scrollTranslation()->matrix());
     EXPECT_EQ(frameScrollTranslation(), scrollerProperties->scrollTranslation()->parent());
     EXPECT_EQ(frameScrollTranslation(), scrollerProperties->overflowClip()->localTransformSpace());
-    EXPECT_EQ(FloatRoundedRect(120, 340, 400, 300), scrollerProperties->overflowClip()->clipRect());
+    EXPECT_EQ(frameScroll(), scrollerProperties->scroll()->parent());
+    EXPECT_EQ(FloatSize(413, 317), scrollerProperties->scroll()->clip());
+    EXPECT_EQ(FloatSize(660, 10200), scrollerProperties->scroll()->bounds());
+    EXPECT_FALSE(scrollerProperties->scroll()->userScrollableHorizontal());
+    EXPECT_TRUE(scrollerProperties->scroll()->userScrollableVertical());
+    EXPECT_EQ(FloatRoundedRect(120, 340, 413, 317), scrollerProperties->overflowClip()->clipRect());
     EXPECT_EQ(frameContentClip(), scrollerProperties->overflowClip()->parent());
     // http://crbug.com/638415
     if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
-        CHECK_EXACT_VISUAL_RECT(LayoutRect(120, 340, 400, 300), scroller->layoutObject(), frameView->layoutView());
+        CHECK_EXACT_VISUAL_RECT(LayoutRect(120, 340, 413, 317), scroller->layoutObject(), frameView->layoutView());
     }
 
     // The relative-positioned element should have accumulated box offset (exclude scrolling),
     // and should be affected by ancestor scroll transforms.
     Element* relPos = document().getElementById("rel-pos");
     const ObjectPaintProperties* relPosProperties = relPos->layoutObject()->objectPaintProperties();
     EXPECT_EQ(TransformationMatrix().translate(680, 1120), relPosProperties->paintOffsetTranslation()->matrix());
     EXPECT_EQ(scrollerProperties->scrollTranslation(), relPosProperties->paintOffsetTranslation()->parent());
     EXPECT_EQ(relPosProperties->transform(), relPosProperties->overflowClip()->localTransformSpace());
     EXPECT_EQ(FloatRoundedRect(0, 0, 100, 200), relPosProperties->overflowClip()->clipRect());
@@ skipping 1516 matching lines @@
     LayoutObject& svgWithViewBox = *document().getElementById("svgWithViewBox")->layoutObject();
     const ObjectPaintProperties* svgWithViewBoxProperties = svgWithViewBox.objectPaintProperties();
 
     EXPECT_EQ(frameScrollTranslation(), svgWithViewBoxProperties->localBorderBoxProperties()->propertyTreeState.transform);
 
     PropertyTreeState contentsProperties;
     svgWithViewBoxProperties->getContentsProperties(contentsProperties);
     EXPECT_EQ(svgWithViewBoxProperties->svgLocalToBorderBoxTransform(), contentsProperties.transform);
 }
 
+TEST_P(PaintPropertyTreeBuilderTest, OverflowHiddenScrollProperties)
+{
+    setBodyInnerHTML(
+        "<style>"
+        "  body {"
+        "    margin: 0px;"
+        "  }"
+        "  #overflowHidden {"
+        "    overflow: hidden;"
+        "    width: 5px;"
+        "    height: 3px;"
+        "  }"
+        "  .forceScroll {"
+        "    height: 79px;"
+        "  }"
+        "</style>"
+        "<div id='overflowHidden'>"
+        "  <div class='forceScroll'></div>"
+        "</div>");
+
+    Element* overflowHidden = document().getElementById("overflowHidden");
+    overflowHidden->setScrollTop(37);
+
+    document().view()->updateAllLifecyclePhases();
+
+    const ObjectPaintProperties* overflowHiddenScrollProperties = overflowHidden->layoutObject()->objectPaintProperties();
+    EXPECT_EQ(frameScroll(), overflowHiddenScrollProperties->scroll()->parent());
+    EXPECT_EQ(TransformationMatrix().translate(0, -37), overflowHiddenScrollProperties->scroll()->scrollOffsetTranslation()->matrix());
+    // This should match the overflow's dimensions.
+    EXPECT_EQ(IntSize(5, 3), overflowHiddenScrollProperties->scroll()->clip());
+    // The scrolling content's bounds should include both the overflow's dimensions (5x3) and the
+    // 0x79 "forceScroll" object.
+    EXPECT_EQ(IntSize(5, 79), overflowHiddenScrollProperties->scroll()->bounds());
+    // Although overflow: hidden is programmatically scrollable, it is not user scrollable.
+    EXPECT_FALSE(overflowHiddenScrollProperties->scroll()->userScrollableHorizontal());
+    EXPECT_FALSE(overflowHiddenScrollProperties->scroll()->userScrollableVertical());
+}
+
+TEST_P(PaintPropertyTreeBuilderTest, NestedScrollProperties)
+{
+    setBodyInnerHTML(
+        "<style>"
+        "  * {"
+        "    margin: 0px;"
+        "  }"
+        "  #overflowA {"
+        "    overflow: scroll;"
+        "    width: 5px;"
+        "    height: 3px;"
+        "  }"
+        "  #overflowB {"
+        "    overflow: scroll;"
+        "    width: 9px;"
+        "    height: 7px;"
+        "  }"
+        "  .forceScroll {"
+        "    height: 100px;"
+        "  }"
+        "</style>"
+        "<div id='overflowA'>"
+        "  <div id='overflowB'>"
+        "    <div class='forceScroll'></div>"
+        "  </div>"
+        "  <div class='forceScroll'></div>"
+        "</div>");
+
+    Element* overflowA = document().getElementById("overflowA");
+    overflowA->setScrollTop(37);
+    Element* overflowB = document().getElementById("overflowB");
+    overflowB->setScrollTop(41);
+
+    document().view()->updateAllLifecyclePhases();
+
+    const ObjectPaintProperties* overflowAScrollProperties = overflowA->layoutObject()->objectPaintProperties();
+    EXPECT_EQ(frameScroll(), overflowAScrollProperties->scroll()->parent());
+    EXPECT_EQ(TransformationMatrix().translate(0, -37), overflowAScrollProperties->scroll()->scrollOffsetTranslation()->matrix());
+    EXPECT_EQ(IntSize(5, 3), overflowAScrollProperties->scroll()->clip());
+    // 107 is the forceScroll element plus the height of the overflow scroll child (overflowB).
+    EXPECT_EQ(IntSize(9, 107), overflowAScrollProperties->scroll()->bounds());
+    EXPECT_TRUE(overflowAScrollProperties->scroll()->userScrollableHorizontal());
+    EXPECT_TRUE(overflowAScrollProperties->scroll()->userScrollableVertical());
+
+    const ObjectPaintProperties* overflowBScrollProperties = overflowB->layoutObject()->objectPaintProperties();
+    // The overflow child's scroll node should be a child of the parent's (overflowA) scroll node.
+    EXPECT_EQ(overflowAScrollProperties->scroll(), overflowBScrollProperties->scroll()->parent());
+    EXPECT_EQ(TransformationMatrix().translate(0, -41), overflowBScrollProperties->scroll()->scrollOffsetTranslation()->matrix());
+    EXPECT_EQ(IntSize(9, 7), overflowBScrollProperties->scroll()->clip());
+    EXPECT_EQ(IntSize(9, 100), overflowBScrollProperties->scroll()->bounds());
+    EXPECT_TRUE(overflowBScrollProperties->scroll()->userScrollableHorizontal());
+    EXPECT_TRUE(overflowBScrollProperties->scroll()->userScrollableVertical());
+}
+
+TEST_P(PaintPropertyTreeBuilderTest, PositionedScrollerIsNotNested)
+{
+    setBodyInnerHTML(
+        "<style>"
+        "  * {"
+        "    margin: 0px;"
+        "  }"
+        "  #overflow {"
+        "    overflow: scroll;"
+        "    width: 5px;"
+        "    height: 3px;"
+        "  }"
+        "  #positionedOverflow {"

[chrishtr, 2016/09/08 20:43:59]

s/positionedOverflow/absposOverflow/

+        "    position: absolute;"
+        "    top: 0;"
+        "    left: 0;"
+        "    overflow: scroll;"
+        "    width: 9px;"
+        "    height: 7px;"
+        "  }"
+        "  .forceScroll {"
+        "    height: 100px;"
+        "  }"
+        "</style>"
+        "<div id='overflow'>"
+        "  <div id='positionedOverflow'>"

[chrishtr, 2016/09/08 20:43:59]

Also add a fixed-pos child. And another test that has an overflow:scroll element
that has position:absolute

[pdr., 2016/09/08 23:16:26]

Adding the fixed-pos test revealed a bug where we were creating a scroll node
for all FrameViews but only need to create them if frameView.isScrollable is
true. Fixed the bug and added the test.

I think this test covers the overflow:scroll element with position absolute.

[chrishtr, 2016/09/09 16:27:28]

It only has a child with absolute position. I'm suggesting that the
oveflow:scroll element have it in another test, to verify an
absolutely-positioned child is scrolled.

+        "    <div class='forceScroll'></div>"
+        "  </div>"
+        "  <div class='forceScroll'></div>"
+        "</div>");
+
+    Element* overflow = document().getElementById("overflow");
+    overflow->setScrollTop(37);
+    Element* positionedOverflow = document().getElementById("positionedOverflow");
+    positionedOverflow->setScrollTop(41);
+
+    document().view()->updateAllLifecyclePhases();
+
+    const ObjectPaintProperties* overflowScrollProperties = overflow->layoutObject()->objectPaintProperties();
+    EXPECT_EQ(frameScroll(), overflowScrollProperties->scroll()->parent());
+    EXPECT_EQ(TransformationMatrix().translate(0, -37), overflowScrollProperties->scroll()->scrollOffsetTranslation()->matrix());
+    EXPECT_EQ(IntSize(5, 3), overflowScrollProperties->scroll()->clip());
+    // The height should be 100px because the (dom-order) overflow child is positioned and does not
+    // contribute to the height. Only the 100px "forceScroll" height is present.
+    EXPECT_EQ(IntSize(5, 100), overflowScrollProperties->scroll()->bounds());
+
+    const ObjectPaintProperties* positionedOverflowScrollProperties = positionedOverflow->layoutObject()->objectPaintProperties();
+    // The positioned overflow scroll node is parented under the frame, not the dom-order parent.
+    EXPECT_EQ(frameScroll(), positionedOverflowScrollProperties->scroll()->parent());
+    EXPECT_EQ(TransformationMatrix().translate(0, -41), positionedOverflowScrollProperties->scroll()->scrollOffsetTranslation()->matrix());
+    EXPECT_EQ(IntSize(9, 7), positionedOverflowScrollProperties->scroll()->clip());
+    EXPECT_EQ(IntSize(9, 100), positionedOverflowScrollProperties->scroll()->bounds());
+}
+
 } // namespace blink