| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "core/layout/compositing/CompositedLayerMapping.h" |
| |
| #include "core/frame/FrameView.h" |
| #include "core/layout/LayoutBoxModelObject.h" |
| #include "core/layout/LayoutTestHelper.h" |
| #include "core/layout/api/LayoutViewItem.h" |
| #include "core/page/scrolling/TopDocumentRootScrollerController.h" |
| #include "core/paint/PaintLayer.h" |
| #include "platform/testing/RuntimeEnabledFeaturesTestHelpers.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace blink { |
| |
| typedef bool TestParamRootLayerScrolling; |
| class CompositedLayerMappingTest |
| : public testing::WithParamInterface<TestParamRootLayerScrolling>, |
| private ScopedRootLayerScrollingForTest, |
| public RenderingTest { |
| public: |
| CompositedLayerMappingTest() |
| : ScopedRootLayerScrollingForTest(GetParam()), |
| RenderingTest(SingleChildFrameLoaderClient::create()) {} |
| |
| protected: |
| IntRect recomputeInterestRect(const GraphicsLayer* graphicsLayer) { |
| return static_cast<CompositedLayerMapping*>(graphicsLayer->client()) |
| ->recomputeInterestRect(graphicsLayer); |
| } |
| |
| IntRect computeInterestRect( |
| const CompositedLayerMapping* compositedLayerMapping, |
| GraphicsLayer* graphicsLayer, |
| IntRect previousInterestRect) { |
| return compositedLayerMapping->computeInterestRect(graphicsLayer, |
| previousInterestRect); |
| } |
| |
| bool shouldFlattenTransform(const GraphicsLayer& layer) const { |
| return layer.shouldFlattenTransform(); |
| } |
| |
| bool interestRectChangedEnoughToRepaint(const IntRect& previousInterestRect, |
| const IntRect& newInterestRect, |
| const IntSize& layerSize) { |
| return CompositedLayerMapping::interestRectChangedEnoughToRepaint( |
| previousInterestRect, newInterestRect, layerSize); |
| } |
| |
| IntRect previousInterestRect(const GraphicsLayer* graphicsLayer) { |
| return graphicsLayer->m_previousInterestRect; |
| } |
| |
| private: |
| void SetUp() override { |
| RenderingTest::SetUp(); |
| enableCompositing(); |
| } |
| |
| void TearDown() override { RenderingTest::TearDown(); } |
| }; |
| |
| #define EXPECT_RECT_EQ(expected, actual) \ |
| do { \ |
| const IntRect& actualRect = actual; \ |
| EXPECT_EQ(expected.x(), actualRect.x()); \ |
| EXPECT_EQ(expected.y(), actualRect.y()); \ |
| EXPECT_EQ(expected.width(), actualRect.width()); \ |
| EXPECT_EQ(expected.height(), actualRect.height()); \ |
| } while (false) |
| |
| INSTANTIATE_TEST_CASE_P(All, CompositedLayerMappingTest, ::testing::Bool()); |
| |
| TEST_P(CompositedLayerMappingTest, SimpleInterestRect) { |
| setBodyInnerHTML( |
| "<div id='target' style='width: 200px; height: 200px; will-change: " |
| "transform'></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(!!paintLayer->graphicsLayerBacking()); |
| EXPECT_RECT_EQ(IntRect(0, 0, 200, 200), |
| recomputeInterestRect(paintLayer->graphicsLayerBacking())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, TallLayerInterestRect) { |
| setBodyInnerHTML( |
| "<div id='target' style='width: 200px; height: 10000px; will-change: " |
| "transform'></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(paintLayer->graphicsLayerBacking()); |
| // Screen-space visible content rect is [8, 8, 200, 600]. Mapping back to |
| // local, adding 4000px in all directions, then clipping, yields this rect. |
| EXPECT_RECT_EQ(IntRect(0, 0, 200, 4592), |
| recomputeInterestRect(paintLayer->graphicsLayerBacking())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, TallLayerWholeDocumentInterestRect) { |
| setBodyInnerHTML( |
| "<div id='target' style='width: 200px; height: 10000px; will-change: " |
| "transform'></div>"); |
| |
| document().settings()->setMainFrameClipsContent(false); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(paintLayer->graphicsLayerBacking()); |
| ASSERT_TRUE(paintLayer->compositedLayerMapping()); |
| // Clipping is disabled in recomputeInterestRect. |
| EXPECT_RECT_EQ(IntRect(0, 0, 200, 10000), |
| recomputeInterestRect(paintLayer->graphicsLayerBacking())); |
| EXPECT_RECT_EQ( |
| IntRect(0, 0, 200, 10000), |
| computeInterestRect(paintLayer->compositedLayerMapping(), |
| paintLayer->graphicsLayerBacking(), IntRect())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, VerticalRightLeftWritingModeDocument) { |
| setBodyInnerHTML( |
| "<style>html,body { margin: 0px } html { -webkit-writing-mode: " |
| "vertical-rl}</style> <div id='target' style='width: 10000px; height: " |
| "200px;'></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| document().view()->layoutViewportScrollableArea()->setScrollOffset( |
| ScrollOffset(-5000, 0), ProgrammaticScroll); |
| document().view()->updateAllLifecyclePhases(); |
| |
| PaintLayer* paintLayer = document().layoutViewItem().layer(); |
| ASSERT_TRUE(paintLayer->graphicsLayerBacking()); |
| ASSERT_TRUE(paintLayer->compositedLayerMapping()); |
| // A scroll by -5000px is equivalent to a scroll by (10000 - 5000 - 800)px = |
| // 4200px in non-RTL mode. Expanding the resulting rect by 4000px in each |
| // direction yields this result. |
| EXPECT_RECT_EQ( |
| IntRect(200, 0, 8800, 600), |
| recomputeInterestRect(paintLayer->graphicsLayerBackingForScrolling())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, RotatedInterestRect) { |
| setBodyInnerHTML( |
| "<div id='target' style='width: 200px; height: 200px; will-change: " |
| "transform; transform: rotateZ(45deg)'></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(!!paintLayer->graphicsLayerBacking()); |
| EXPECT_RECT_EQ(IntRect(0, 0, 200, 200), |
| recomputeInterestRect(paintLayer->graphicsLayerBacking())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, RotatedInterestRectNear90Degrees) { |
| setBodyInnerHTML( |
| "<div id='target' style='width: 10000px; height: 200px; will-change: " |
| "transform; transform: rotateY(89.9999deg)'></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(!!paintLayer->graphicsLayerBacking()); |
| // Because the layer is rotated to almost 90 degrees, floating-point error |
| // leads to a reverse-projected rect that is much much larger than the |
| // original layer size in certain dimensions. In such cases, we often fall |
| // back to the 4000px interest rect padding amount. |
| EXPECT_RECT_EQ(IntRect(0, 0, 4000, 200), |
| recomputeInterestRect(paintLayer->graphicsLayerBacking())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, 3D90DegRotatedTallInterestRect) { |
| // It's rotated 90 degrees about the X axis, which means its visual content |
| // rect is empty, and so the interest rect is the default (0, 0, 4000, 4000) |
| // intersected with the layer bounds. |
| setBodyInnerHTML( |
| "<div id='target' style='width: 200px; height: 10000px; will-change: " |
| "transform; transform: rotateY(90deg)'></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(!!paintLayer->graphicsLayerBacking()); |
| EXPECT_RECT_EQ(IntRect(0, 0, 200, 4000), |
| recomputeInterestRect(paintLayer->graphicsLayerBacking())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, 3D45DegRotatedTallInterestRect) { |
| setBodyInnerHTML( |
| "<div id='target' style='width: 200px; height: 10000px; will-change: " |
| "transform; transform: rotateY(45deg)'></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(!!paintLayer->graphicsLayerBacking()); |
| EXPECT_RECT_EQ(IntRect(0, 0, 200, 4592), |
| recomputeInterestRect(paintLayer->graphicsLayerBacking())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, RotatedTallInterestRect) { |
| setBodyInnerHTML( |
| "<div id='target' style='width: 200px; height: 10000px; will-change: " |
| "transform; transform: rotateZ(45deg)'></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(!!paintLayer->graphicsLayerBacking()); |
| EXPECT_RECT_EQ(IntRect(0, 0, 200, 4000), |
| recomputeInterestRect(paintLayer->graphicsLayerBacking())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, WideLayerInterestRect) { |
| setBodyInnerHTML( |
| "<div id='target' style='width: 10000px; height: 200px; will-change: " |
| "transform'></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(!!paintLayer->graphicsLayerBacking()); |
| // Screen-space visible content rect is [8, 8, 800, 200] (the screen is |
| // 800x600). Mapping back to local, adding 4000px in all directions, then |
| // clipping, yields this rect. |
| EXPECT_RECT_EQ(IntRect(0, 0, 4792, 200), |
| recomputeInterestRect(paintLayer->graphicsLayerBacking())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, FixedPositionInterestRect) { |
| setBodyInnerHTML( |
| "<div id='target' style='width: 300px; height: 400px; will-change: " |
| "transform; position: fixed; top: 100px; left: 200px;'></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(!!paintLayer->graphicsLayerBacking()); |
| EXPECT_RECT_EQ(IntRect(0, 0, 300, 400), |
| recomputeInterestRect(paintLayer->graphicsLayerBacking())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, LayerOffscreenInterestRect) { |
| setBodyInnerHTML( |
| "<div id='target' style='width: 200px; height: 200px; will-change: " |
| "transform; position: absolute; top: 9000px; left: 0px;'>" |
| "</div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(!!paintLayer->graphicsLayerBacking()); |
| // Offscreen layers are painted as usual. |
| EXPECT_RECT_EQ(IntRect(0, 0, 200, 200), |
| recomputeInterestRect(paintLayer->graphicsLayerBacking())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, ScrollingLayerInterestRect) { |
| setBodyInnerHTML( |
| "<style>div::-webkit-scrollbar{ width: 5px; }</style>" |
| "<div id='target' style='width: 200px; height: 200px; will-change: " |
| "transform; overflow: scroll'>" |
| "<div style='width: 100px; height: 10000px'></div></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(paintLayer->graphicsLayerBacking()); |
| // Offscreen layers are painted as usual. |
| ASSERT_TRUE(paintLayer->compositedLayerMapping()->scrollingLayer()); |
| EXPECT_RECT_EQ( |
| IntRect(0, 0, 195, 4592), |
| recomputeInterestRect(paintLayer->graphicsLayerBackingForScrolling())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, ClippedBigLayer) { |
| setBodyInnerHTML( |
| "<div style='width: 1px; height: 1px; overflow: hidden'>" |
| "<div id='target' style='width: 10000px; height: 10000px; will-change: " |
| "transform'></div></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(paintLayer->graphicsLayerBacking()); |
| // Offscreen layers are painted as usual. |
| EXPECT_RECT_EQ(IntRect(0, 0, 4001, 4001), |
| recomputeInterestRect(paintLayer->graphicsLayerBacking())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, ClippingMaskLayer) { |
| if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) |
| return; |
| |
| const AtomicString styleWithoutClipping = |
| "backface-visibility: hidden; width: 200px; height: 200px"; |
| const AtomicString styleWithBorderRadius = |
| styleWithoutClipping + "; border-radius: 10px"; |
| const AtomicString styleWithClipPath = |
| styleWithoutClipping + "; -webkit-clip-path: inset(10px)"; |
| |
| setBodyInnerHTML("<video id='video' src='x' style='" + styleWithoutClipping + |
| "'></video>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* videoElement = document().getElementById("video"); |
| GraphicsLayer* graphicsLayer = |
| toLayoutBoxModelObject(videoElement->layoutObject()) |
| ->layer() |
| ->graphicsLayerBacking(); |
| EXPECT_FALSE(graphicsLayer->maskLayer()); |
| EXPECT_FALSE(graphicsLayer->contentsClippingMaskLayer()); |
| |
| videoElement->setAttribute(HTMLNames::styleAttr, styleWithBorderRadius); |
| document().view()->updateAllLifecyclePhases(); |
| EXPECT_FALSE(graphicsLayer->maskLayer()); |
| EXPECT_TRUE(graphicsLayer->contentsClippingMaskLayer()); |
| |
| videoElement->setAttribute(HTMLNames::styleAttr, styleWithClipPath); |
| document().view()->updateAllLifecyclePhases(); |
| EXPECT_TRUE(graphicsLayer->maskLayer()); |
| EXPECT_FALSE(graphicsLayer->contentsClippingMaskLayer()); |
| |
| videoElement->setAttribute(HTMLNames::styleAttr, styleWithoutClipping); |
| document().view()->updateAllLifecyclePhases(); |
| EXPECT_FALSE(graphicsLayer->maskLayer()); |
| EXPECT_FALSE(graphicsLayer->contentsClippingMaskLayer()); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, ScrollContentsFlattenForScroller) { |
| setBodyInnerHTML( |
| "<style>div::-webkit-scrollbar{ width: 5px; }</style>" |
| "<div id='scroller' style='width: 100px; height: 100px; overflow: " |
| "scroll; will-change: transform'>" |
| "<div style='width: 1000px; height: 1000px;'>Foo</div>Foo</div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* element = document().getElementById("scroller"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| CompositedLayerMapping* compositedLayerMapping = |
| paintLayer->compositedLayerMapping(); |
| |
| ASSERT_TRUE(compositedLayerMapping); |
| |
| EXPECT_FALSE( |
| shouldFlattenTransform(*compositedLayerMapping->mainGraphicsLayer())); |
| EXPECT_FALSE( |
| shouldFlattenTransform(*compositedLayerMapping->scrollingLayer())); |
| EXPECT_TRUE(shouldFlattenTransform( |
| *compositedLayerMapping->scrollingContentsLayer())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, InterestRectChangedEnoughToRepaintEmpty) { |
| IntSize layerSize(1000, 1000); |
| // Both empty means there is nothing to do. |
| EXPECT_FALSE( |
| interestRectChangedEnoughToRepaint(IntRect(), IntRect(), layerSize)); |
| // Going from empty to non-empty means we must re-record because it could be |
| // the first frame after construction or Clear. |
| EXPECT_TRUE(interestRectChangedEnoughToRepaint(IntRect(), IntRect(0, 0, 1, 1), |
| layerSize)); |
| // Going from non-empty to empty is not special-cased. |
| EXPECT_FALSE(interestRectChangedEnoughToRepaint(IntRect(0, 0, 1, 1), |
| IntRect(), layerSize)); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, |
| InterestRectChangedEnoughToRepaintNotBigEnough) { |
| IntSize layerSize(1000, 1000); |
| IntRect previousInterestRect(100, 100, 100, 100); |
| EXPECT_FALSE(interestRectChangedEnoughToRepaint( |
| previousInterestRect, IntRect(100, 100, 90, 90), layerSize)); |
| EXPECT_FALSE(interestRectChangedEnoughToRepaint( |
| previousInterestRect, IntRect(100, 100, 100, 100), layerSize)); |
| EXPECT_FALSE(interestRectChangedEnoughToRepaint( |
| previousInterestRect, IntRect(1, 1, 200, 200), layerSize)); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, |
| InterestRectChangedEnoughToRepaintNotBigEnoughButNewAreaTouchesEdge) { |
| IntSize layerSize(500, 500); |
| IntRect previousInterestRect(100, 100, 100, 100); |
| // Top edge. |
| EXPECT_TRUE(interestRectChangedEnoughToRepaint( |
| previousInterestRect, IntRect(100, 0, 100, 200), layerSize)); |
| // Left edge. |
| EXPECT_TRUE(interestRectChangedEnoughToRepaint( |
| previousInterestRect, IntRect(0, 100, 200, 100), layerSize)); |
| // Bottom edge. |
| EXPECT_TRUE(interestRectChangedEnoughToRepaint( |
| previousInterestRect, IntRect(100, 100, 100, 400), layerSize)); |
| // Right edge. |
| EXPECT_TRUE(interestRectChangedEnoughToRepaint( |
| previousInterestRect, IntRect(100, 100, 400, 100), layerSize)); |
| } |
| |
| // Verifies that having a current viewport that touches a layer edge does not |
| // force re-recording. |
| TEST_P(CompositedLayerMappingTest, |
| InterestRectChangedEnoughToRepaintCurrentViewportTouchesEdge) { |
| IntSize layerSize(500, 500); |
| IntRect newInterestRect(100, 100, 300, 300); |
| // Top edge. |
| EXPECT_FALSE(interestRectChangedEnoughToRepaint(IntRect(100, 0, 100, 100), |
| newInterestRect, layerSize)); |
| // Left edge. |
| EXPECT_FALSE(interestRectChangedEnoughToRepaint(IntRect(0, 100, 100, 100), |
| newInterestRect, layerSize)); |
| // Bottom edge. |
| EXPECT_FALSE(interestRectChangedEnoughToRepaint(IntRect(300, 400, 100, 100), |
| newInterestRect, layerSize)); |
| // Right edge. |
| EXPECT_FALSE(interestRectChangedEnoughToRepaint(IntRect(400, 300, 100, 100), |
| newInterestRect, layerSize)); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, |
| InterestRectChangedEnoughToRepaintScrollScenarios) { |
| IntSize layerSize(1000, 1000); |
| IntRect previousInterestRect(100, 100, 100, 100); |
| IntRect newInterestRect(previousInterestRect); |
| newInterestRect.move(512, 0); |
| EXPECT_FALSE(interestRectChangedEnoughToRepaint(previousInterestRect, |
| newInterestRect, layerSize)); |
| newInterestRect.move(0, 512); |
| EXPECT_FALSE(interestRectChangedEnoughToRepaint(previousInterestRect, |
| newInterestRect, layerSize)); |
| newInterestRect.move(1, 0); |
| EXPECT_TRUE(interestRectChangedEnoughToRepaint(previousInterestRect, |
| newInterestRect, layerSize)); |
| newInterestRect.move(-1, 1); |
| EXPECT_TRUE(interestRectChangedEnoughToRepaint(previousInterestRect, |
| newInterestRect, layerSize)); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, InterestRectChangeOnViewportScroll) { |
| setBodyInnerHTML( |
| "<style>" |
| " ::-webkit-scrollbar { width: 0; height: 0; }" |
| " body { margin: 0; }" |
| "</style>" |
| "<div id='div' style='width: 100px; height: 10000px'>Text</div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| GraphicsLayer* rootScrollingLayer = |
| document().layoutViewItem().layer()->graphicsLayerBackingForScrolling(); |
| EXPECT_RECT_EQ(IntRect(0, 0, 800, 4600), |
| previousInterestRect(rootScrollingLayer)); |
| |
| document().view()->layoutViewportScrollableArea()->setScrollOffset( |
| ScrollOffset(0, 300), ProgrammaticScroll); |
| document().view()->updateAllLifecyclePhases(); |
| // Still use the previous interest rect because the recomputed rect hasn't |
| // changed enough. |
| EXPECT_RECT_EQ(IntRect(0, 0, 800, 4900), |
| recomputeInterestRect(rootScrollingLayer)); |
| EXPECT_RECT_EQ(IntRect(0, 0, 800, 4600), |
| previousInterestRect(rootScrollingLayer)); |
| |
| document().view()->layoutViewportScrollableArea()->setScrollOffset( |
| ScrollOffset(0, 600), ProgrammaticScroll); |
| document().view()->updateAllLifecyclePhases(); |
| // Use recomputed interest rect because it changed enough. |
| EXPECT_RECT_EQ(IntRect(0, 0, 800, 5200), |
| recomputeInterestRect(rootScrollingLayer)); |
| EXPECT_RECT_EQ(IntRect(0, 0, 800, 5200), |
| previousInterestRect(rootScrollingLayer)); |
| |
| document().view()->layoutViewportScrollableArea()->setScrollOffset( |
| ScrollOffset(0, 5400), ProgrammaticScroll); |
| document().view()->updateAllLifecyclePhases(); |
| EXPECT_RECT_EQ(IntRect(0, 1400, 800, 8600), |
| recomputeInterestRect(rootScrollingLayer)); |
| EXPECT_RECT_EQ(IntRect(0, 1400, 800, 8600), |
| previousInterestRect(rootScrollingLayer)); |
| |
| document().view()->layoutViewportScrollableArea()->setScrollOffset( |
| ScrollOffset(0, 9000), ProgrammaticScroll); |
| document().view()->updateAllLifecyclePhases(); |
| // Still use the previous interest rect because it contains the recomputed |
| // interest rect. |
| EXPECT_RECT_EQ(IntRect(0, 5000, 800, 5000), |
| recomputeInterestRect(rootScrollingLayer)); |
| EXPECT_RECT_EQ(IntRect(0, 1400, 800, 8600), |
| previousInterestRect(rootScrollingLayer)); |
| |
| document().view()->layoutViewportScrollableArea()->setScrollOffset( |
| ScrollOffset(0, 2000), ProgrammaticScroll); |
| // Use recomputed interest rect because it changed enough. |
| document().view()->updateAllLifecyclePhases(); |
| EXPECT_RECT_EQ(IntRect(0, 0, 800, 6600), |
| recomputeInterestRect(rootScrollingLayer)); |
| EXPECT_RECT_EQ(IntRect(0, 0, 800, 6600), |
| previousInterestRect(rootScrollingLayer)); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, InterestRectChangeOnShrunkenViewport) { |
| setBodyInnerHTML( |
| "<style>" |
| " ::-webkit-scrollbar { width: 0; height: 0; }" |
| " body { margin: 0; }" |
| "</style>" |
| "<div id='div' style='width: 100px; height: 10000px'>Text</div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| GraphicsLayer* rootScrollingLayer = |
| document().layoutViewItem().layer()->graphicsLayerBackingForScrolling(); |
| EXPECT_RECT_EQ(IntRect(0, 0, 800, 4600), |
| previousInterestRect(rootScrollingLayer)); |
| |
| document().view()->setFrameRect(IntRect(0, 0, 800, 60)); |
| document().view()->updateAllLifecyclePhases(); |
| // Repaint required, so interest rect should be updated to shrunken size. |
| EXPECT_RECT_EQ(IntRect(0, 0, 800, 4060), |
| recomputeInterestRect(rootScrollingLayer)); |
| EXPECT_RECT_EQ(IntRect(0, 0, 800, 4060), |
| previousInterestRect(rootScrollingLayer)); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, InterestRectChangeOnScroll) { |
| document().frame()->settings()->setPreferCompositingToLCDTextEnabled(true); |
| |
| setBodyInnerHTML( |
| "<style>" |
| " ::-webkit-scrollbar { width: 0; height: 0; }" |
| " body { margin: 0; }" |
| "</style>" |
| "<div id='scroller' style='width: 400px; height: 400px; overflow: " |
| "scroll'>" |
| " <div id='content' style='width: 100px; height: 10000px'>Text</div>" |
| "</div"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* scroller = document().getElementById("scroller"); |
| GraphicsLayer* scrollingLayer = |
| scroller->layoutBox()->layer()->graphicsLayerBackingForScrolling(); |
| EXPECT_RECT_EQ(IntRect(0, 0, 400, 4600), |
| previousInterestRect(scrollingLayer)); |
| |
| scroller->setScrollTop(300); |
| document().view()->updateAllLifecyclePhases(); |
| // Still use the previous interest rect because the recomputed rect hasn't |
| // changed enough. |
| EXPECT_RECT_EQ(IntRect(0, 0, 400, 4900), |
| recomputeInterestRect(scrollingLayer)); |
| EXPECT_RECT_EQ(IntRect(0, 0, 400, 4600), |
| previousInterestRect(scrollingLayer)); |
| |
| scroller->setScrollTop(600); |
| document().view()->updateAllLifecyclePhases(); |
| // Use recomputed interest rect because it changed enough. |
| EXPECT_RECT_EQ(IntRect(0, 0, 400, 5200), |
| recomputeInterestRect(scrollingLayer)); |
| EXPECT_RECT_EQ(IntRect(0, 0, 400, 5200), |
| previousInterestRect(scrollingLayer)); |
| |
| scroller->setScrollTop(5400); |
| document().view()->updateAllLifecyclePhases(); |
| EXPECT_RECT_EQ(IntRect(0, 1400, 400, 8600), |
| recomputeInterestRect(scrollingLayer)); |
| EXPECT_RECT_EQ(IntRect(0, 1400, 400, 8600), |
| previousInterestRect(scrollingLayer)); |
| |
| scroller->setScrollTop(9000); |
| document().view()->updateAllLifecyclePhases(); |
| // Still use the previous interest rect because it contains the recomputed |
| // interest rect. |
| EXPECT_RECT_EQ(IntRect(0, 5000, 400, 5000), |
| recomputeInterestRect(scrollingLayer)); |
| EXPECT_RECT_EQ(IntRect(0, 1400, 400, 8600), |
| previousInterestRect(scrollingLayer)); |
| |
| scroller->setScrollTop(2000); |
| // Use recomputed interest rect because it changed enough. |
| document().view()->updateAllLifecyclePhases(); |
| EXPECT_RECT_EQ(IntRect(0, 0, 400, 6600), |
| recomputeInterestRect(scrollingLayer)); |
| EXPECT_RECT_EQ(IntRect(0, 0, 400, 6600), |
| previousInterestRect(scrollingLayer)); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, |
| InterestRectShouldChangeOnPaintInvalidation) { |
| document().frame()->settings()->setPreferCompositingToLCDTextEnabled(true); |
| |
| setBodyInnerHTML( |
| "<style>" |
| " ::-webkit-scrollbar { width: 0; height: 0; }" |
| " body { margin: 0; }" |
| "</style>" |
| "<div id='scroller' style='width: 400px; height: 400px; overflow: " |
| "scroll'>" |
| " <div id='content' style='width: 100px; height: 10000px'>Text</div>" |
| "</div"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| Element* scroller = document().getElementById("scroller"); |
| GraphicsLayer* scrollingLayer = |
| scroller->layoutBox()->layer()->graphicsLayerBackingForScrolling(); |
| |
| scroller->setScrollTop(5400); |
| document().view()->updateAllLifecyclePhases(); |
| scroller->setScrollTop(9400); |
| // The above code creates an interest rect bigger than the interest rect if |
| // recomputed now. |
| document().view()->updateAllLifecyclePhases(); |
| EXPECT_RECT_EQ(IntRect(0, 5400, 400, 4600), |
| recomputeInterestRect(scrollingLayer)); |
| EXPECT_RECT_EQ(IntRect(0, 1400, 400, 8600), |
| previousInterestRect(scrollingLayer)); |
| |
| // Paint invalidation and repaint should change previous paint interest rect. |
| document().getElementById("content")->setTextContent("Change"); |
| document().view()->updateAllLifecyclePhases(); |
| EXPECT_RECT_EQ(IntRect(0, 5400, 400, 4600), |
| recomputeInterestRect(scrollingLayer)); |
| EXPECT_RECT_EQ(IntRect(0, 5400, 400, 4600), |
| previousInterestRect(scrollingLayer)); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, |
| InterestRectOfSquashingLayerWithNegativeOverflow) { |
| setBodyInnerHTML( |
| "<style>body { margin: 0; font-size: 16px; }</style>" |
| "<div style='position: absolute; top: -500px; width: 200px; height: " |
| "700px; will-change: transform'></div>" |
| "<div id='squashed' style='position: absolute; top: 190px;'>" |
| " <div id='inside' style='width: 100px; height: 100px; text-indent: " |
| "-10000px'>text</div>" |
| "</div>"); |
| |
| EXPECT_EQ(document() |
| .getElementById("inside") |
| ->layoutBox() |
| ->visualOverflowRect() |
| .size() |
| .height(), |
| 100); |
| |
| CompositedLayerMapping* groupedMapping = document() |
| .getElementById("squashed") |
| ->layoutBox() |
| ->layer() |
| ->groupedMapping(); |
| // The squashing layer is at (-10000, 190, 10100, 100) in viewport |
| // coordinates. |
| // The following rect is at (-4000, 190, 4100, 100) in viewport coordinates. |
| EXPECT_RECT_EQ(IntRect(6000, 0, 4100, 100), |
| groupedMapping->computeInterestRect( |
| groupedMapping->squashingLayer(), IntRect())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, |
| InterestRectOfSquashingLayerWithAncestorClip) { |
| setBodyInnerHTML( |
| "<style>body { margin: 0; }</style>" |
| "<div style='overflow: hidden; width: 400px; height: 400px'>" |
| " <div style='position: relative; backface-visibility: hidden'>" |
| " <div style='position: absolute; top: -500px; width: 200px; height: " |
| "700px; backface-visibility: hidden'></div>" |
| // Above overflow:hidden div and two composited layers make the squashing |
| // layer a child of an ancestor clipping layer. |
| " <div id='squashed' style='height: 1000px; width: 10000px; right: 0; " |
| "position: absolute'></div>" |
| " </div>" |
| "</div>"); |
| |
| CompositedLayerMapping* groupedMapping = document() |
| .getElementById("squashed") |
| ->layoutBox() |
| ->layer() |
| ->groupedMapping(); |
| // The squashing layer is at (-9600, 0, 10000, 1000) in viewport coordinates. |
| // The following rect is at (-4000, 0, 4400, 1000) in viewport coordinates. |
| EXPECT_RECT_EQ(IntRect(5600, 0, 4400, 1000), |
| groupedMapping->computeInterestRect( |
| groupedMapping->squashingLayer(), IntRect())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, InterestRectOfIframeInScrolledDiv) { |
| document().setBaseURLOverride(KURL(ParsedURLString, "http://test.com")); |
| setBodyInnerHTML( |
| "<style>body { margin: 0; }</style>" |
| "<div style='width: 200; height: 8000px'></div>" |
| "<iframe src='http://test.com' width='500' height='500' " |
| "frameBorder='0'>" |
| "</iframe>"); |
| setChildFrameHTML( |
| "<style>body { margin: 0; } #target { width: 200px; height: 200px; " |
| "will-change: transform}</style><div id=target></div>"); |
| |
| // Scroll 8000 pixels down to move the iframe into view. |
| document().view()->layoutViewportScrollableArea()->setScrollOffset( |
| ScrollOffset(0.0, 8000.0), ProgrammaticScroll); |
| document().view()->updateAllLifecyclePhases(); |
| |
| Element* target = childDocument().getElementById("target"); |
| ASSERT_TRUE(target); |
| |
| EXPECT_RECT_EQ( |
| IntRect(0, 0, 200, 200), |
| recomputeInterestRect( |
| target->layoutObject()->enclosingLayer()->graphicsLayerBacking())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, InterestRectOfScrolledIframe) { |
| document().setBaseURLOverride(KURL(ParsedURLString, "http://test.com")); |
| document().frame()->settings()->setPreferCompositingToLCDTextEnabled(true); |
| setBodyInnerHTML( |
| "<style>body { margin: 0; } ::-webkit-scrollbar { display: none; " |
| "}</style>" |
| "<iframe src='http://test.com' width='500' height='500' " |
| "frameBorder='0'>" |
| "</iframe>"); |
| setChildFrameHTML( |
| "<style>body { margin: 0; } #target { width: 200px; " |
| "height: 8000px;}</style><div id=target></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| |
| // Scroll 7500 pixels down to bring the scrollable area to the bottom. |
| childDocument().view()->layoutViewportScrollableArea()->setScrollOffset( |
| ScrollOffset(0.0, 7500.0), ProgrammaticScroll); |
| document().view()->updateAllLifecyclePhases(); |
| |
| ASSERT_TRUE(childDocument().view()->layoutViewItem().hasLayer()); |
| EXPECT_RECT_EQ( |
| IntRect(0, 3500, 500, 4500), |
| recomputeInterestRect(childDocument() |
| .view() |
| ->layoutViewItem() |
| .enclosingLayer() |
| ->graphicsLayerBackingForScrolling())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, InterestRectOfIframeWithContentBoxOffset) { |
| document().setBaseURLOverride(KURL(ParsedURLString, "http://test.com")); |
| document().frame()->settings()->setPreferCompositingToLCDTextEnabled(true); |
| // Set a 10px border in order to have a contentBoxOffset for the iframe |
| // element. |
| setBodyInnerHTML( |
| "<style>body { margin: 0; } #frame { border: 10px solid black; } " |
| "::-webkit-scrollbar { display: none; }</style>" |
| "<iframe src='http://test.com' width='500' height='500' " |
| "frameBorder='0'>" |
| "</iframe>"); |
| setChildFrameHTML( |
| "<style>body { margin: 0; } #target { width: 200px; " |
| "height: 8000px;}</style> <div id=target></div>"); |
| |
| document().view()->updateAllLifecyclePhases(); |
| |
| // Scroll 3000 pixels down to bring the scrollable area to somewhere in the |
| // middle. |
| childDocument().view()->layoutViewportScrollableArea()->setScrollOffset( |
| ScrollOffset(0.0, 3000.0), ProgrammaticScroll); |
| document().view()->updateAllLifecyclePhases(); |
| |
| ASSERT_TRUE(childDocument().view()->layoutViewItem().hasLayer()); |
| // The width is 485 pixels due to the size of the scrollbar. |
| EXPECT_RECT_EQ( |
| IntRect(0, 0, 500, 7500), |
| recomputeInterestRect(childDocument() |
| .view() |
| ->layoutViewItem() |
| .enclosingLayer() |
| ->graphicsLayerBackingForScrolling())); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, |
| ScrollingContentsAndForegroundLayerPaintingPhase) { |
| document().frame()->settings()->setPreferCompositingToLCDTextEnabled(true); |
| setBodyInnerHTML( |
| "<div id='container' style='position: relative; z-index: 1; overflow: " |
| "scroll; width: 300px; height: 300px'>" |
| " <div id='negative-composited-child' style='background-color: red; " |
| "width: 1px; height: 1px; position: absolute; backface-visibility: " |
| "hidden; z-index: -1'></div>" |
| " <div style='background-color: blue; width: 2000px; height: 2000px; " |
| "position: relative; top: 10px'></div>" |
| "</div>"); |
| |
| CompositedLayerMapping* mapping = |
| toLayoutBlock(getLayoutObjectByElementId("container")) |
| ->layer() |
| ->compositedLayerMapping(); |
| ASSERT_TRUE(mapping->scrollingContentsLayer()); |
| EXPECT_EQ(static_cast<GraphicsLayerPaintingPhase>( |
| GraphicsLayerPaintOverflowContents | |
| GraphicsLayerPaintCompositedScroll), |
| mapping->scrollingContentsLayer()->paintingPhase()); |
| ASSERT_TRUE(mapping->foregroundLayer()); |
| EXPECT_EQ( |
| static_cast<GraphicsLayerPaintingPhase>( |
| GraphicsLayerPaintForeground | GraphicsLayerPaintOverflowContents), |
| mapping->foregroundLayer()->paintingPhase()); |
| |
| Element* negativeCompositedChild = |
| document().getElementById("negative-composited-child"); |
| negativeCompositedChild->parentNode()->removeChild(negativeCompositedChild); |
| document().view()->updateAllLifecyclePhases(); |
| |
| mapping = toLayoutBlock(getLayoutObjectByElementId("container")) |
| ->layer() |
| ->compositedLayerMapping(); |
| ASSERT_TRUE(mapping->scrollingContentsLayer()); |
| EXPECT_EQ( |
| static_cast<GraphicsLayerPaintingPhase>( |
| GraphicsLayerPaintOverflowContents | |
| GraphicsLayerPaintCompositedScroll | GraphicsLayerPaintForeground), |
| mapping->scrollingContentsLayer()->paintingPhase()); |
| EXPECT_FALSE(mapping->foregroundLayer()); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, |
| DecorationOutlineLayerOnlyCreatedInCompositedScrolling) { |
| setBodyInnerHTML( |
| "<style>" |
| "#target { overflow: scroll; height: 200px; width: 200px; will-change: " |
| "transform; background: white local content-box; " |
| "outline: 1px solid blue; outline-offset: -2px;}" |
| "#scrolled { height: 300px; }" |
| "</style>" |
| "<div id=\"parent\">" |
| " <div id=\"target\"><div id=\"scrolled\"></div></div>" |
| "</div>"); |
| document().view()->updateAllLifecyclePhases(); |
| |
| Element* element = document().getElementById("target"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(paintLayer); |
| |
| // Decoration outline layer is created when composited scrolling. |
| EXPECT_TRUE(paintLayer->hasCompositedLayerMapping()); |
| EXPECT_TRUE(paintLayer->needsCompositedScrolling()); |
| |
| CompositedLayerMapping* mapping = paintLayer->compositedLayerMapping(); |
| EXPECT_TRUE(mapping->decorationOutlineLayer()); |
| |
| // No decoration outline layer is created when not composited scrolling. |
| element->setAttribute(HTMLNames::styleAttr, "overflow: visible;"); |
| document().view()->updateAllLifecyclePhases(); |
| paintLayer = toLayoutBoxModelObject(element->layoutObject())->layer(); |
| ASSERT_TRUE(paintLayer); |
| |
| mapping = paintLayer->compositedLayerMapping(); |
| EXPECT_FALSE(paintLayer->needsCompositedScrolling()); |
| EXPECT_FALSE(mapping->decorationOutlineLayer()); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, |
| DecorationOutlineLayerCreatedAndDestroyedInCompositedScrolling) { |
| setBodyInnerHTML( |
| "<style>" |
| "#scroller { overflow: scroll; height: 200px; width: 200px; background: " |
| "white local content-box; outline: 1px solid blue; contain: paint; }" |
| "#scrolled { height: 300px; }" |
| "</style>" |
| "<div id=\"parent\">" |
| " <div id=\"scroller\"><div id=\"scrolled\"></div></div>" |
| "</div>"); |
| document().view()->updateAllLifecyclePhases(); |
| |
| Element* scroller = document().getElementById("scroller"); |
| PaintLayer* paintLayer = |
| toLayoutBoxModelObject(scroller->layoutObject())->layer(); |
| ASSERT_TRUE(paintLayer); |
| |
| CompositedLayerMapping* mapping = paintLayer->compositedLayerMapping(); |
| EXPECT_FALSE(mapping->decorationOutlineLayer()); |
| |
| // The decoration outline layer is created when composited scrolling |
| // with an outline drawn over the composited scrolling region. |
| scroller->setAttribute(HTMLNames::styleAttr, "outline-offset: -2px;"); |
| document().view()->updateAllLifecyclePhases(); |
| paintLayer = toLayoutBoxModelObject(scroller->layoutObject())->layer(); |
| ASSERT_TRUE(paintLayer); |
| |
| mapping = paintLayer->compositedLayerMapping(); |
| EXPECT_TRUE(paintLayer->needsCompositedScrolling()); |
| EXPECT_TRUE(mapping->decorationOutlineLayer()); |
| |
| // The decoration outline layer is destroyed when the scrolling region |
| // will not be covered up by the outline. |
| scroller->removeAttribute(HTMLNames::styleAttr); |
| document().view()->updateAllLifecyclePhases(); |
| paintLayer = toLayoutBoxModelObject(scroller->layoutObject())->layer(); |
| ASSERT_TRUE(paintLayer); |
| |
| mapping = paintLayer->compositedLayerMapping(); |
| EXPECT_FALSE(mapping->decorationOutlineLayer()); |
| } |
| |
| TEST_P(CompositedLayerMappingTest, |
| BackgroundPaintedIntoGraphicsLayerIfNotCompositedScrolling) { |
| document().frame()->settings()->setPreferCompositingToLCDTextEnabled(true); |
| setBodyInnerHTML( |
| "<div id='container' style='overflow: scroll; width: 300px; height: " |
| "300px; border-radius: 5px; background: white; will-change: transform;'>" |
| " <div style='background-color: blue; width: 2000px; height: " |
| "2000px;'></div>" |
| "</div>"); |
| |
| PaintLayer* layer = |
| toLayoutBlock(getLayoutObjectByElementId("container"))->layer(); |
| EXPECT_EQ(BackgroundPaintInScrollingContents, |
| layer->backgroundPaintLocation()); |
| |
| // We currently don't use composited scrolling when the container has a |
| // border-radius so even though we can paint the background onto the scrolling |
| // contents layer we don't have a scrolling contents layer to paint into in |
| // this case. |
| CompositedLayerMapping* mapping = layer->compositedLayerMapping(); |
| EXPECT_FALSE(mapping->hasScrollingLayer()); |
| EXPECT_FALSE(mapping->backgroundPaintsOntoScrollingContentsLayer()); |
| } |
| |
| // Make sure that clipping layers are removed or their masking bit turned off |
| // when they're an ancestor of the root scroller element. |
| TEST_P(CompositedLayerMappingTest, RootScrollerAncestorsNotClipped) { |
| NonThrowableExceptionState nonThrow; |
| |
| TopDocumentRootScrollerController& rootScrollerController = |
| document().frameHost()->globalRootScrollerController(); |
| |
| setBodyInnerHTML( |
| // The container DIV is composited with scrolling contents and a |
| // non-composited parent that clips it. |
| "<div id='clip' style='overflow: hidden; width: 200px; height: 200px; " |
| "position: absolute; left: 0px; top: 0px;'>" |
| " <div id='container' style='transform: translateZ(0); overflow: " |
| "scroll; width: 300px; height: 300px'>" |
| " <div style='width: 2000px; height: 2000px;'>lorem ipsum</div>" |
| " <div id='innerScroller' style='width: 800px; height: 600px; " |
| "left: 0px; top: 0px; position: absolute; overflow: scroll'>" |
| " <div style='height: 2000px; width: 2000px'></div>" |
| " </div>" |
| " </div>" |
| "</div>" |
| |
| // The container DIV is composited with scrolling contents and a |
| // composited parent that clips it. |
| "<div id='clip2' style='transform: translateZ(0); position: absolute; " |
| "left: 0px; top: 0px; overflow: hidden; width: 200px; height: 200px'>" |
| " <div id='container2' style='transform: translateZ(0); overflow: " |
| "scroll; width: 300px; height: 300px'>" |
| " <div style='width: 2000px; height: 2000px;'>lorem ipsum</div>" |
| " <div id='innerScroller2' style='width: 800px; height: 600px; " |
| "left: 0px; top: 0px; position: absolute; overflow: scroll'>" |
| " <div style='height: 2000px; width: 2000px'></div>" |
| " </div>" |
| " </div>" |
| "</div>" |
| |
| // The container DIV is composited without scrolling contents but |
| // composited children that it clips. |
| "<div id='container3' style='translateZ(0); position: absolute; left: " |
| "0px; top: 0px; z-index: 1; overflow: hidden; width: 300px; height: " |
| "300px'>" |
| " <div style='transform: translateZ(0); z-index: -1; width: 2000px; " |
| "height: 2000px;'>lorem ipsum</div>" |
| " <div id='innerScroller3' style='width: 800px; height: 600px; " |
| "left: 0px; top: 0px; position: absolute; overflow: scroll'>" |
| " <div style='height: 2000px; width: 2000px'></div>" |
| " </div>" |
| "</div>"); |
| |
| CompositedLayerMapping* mapping = |
| toLayoutBlock(getLayoutObjectByElementId("container")) |
| ->layer() |
| ->compositedLayerMapping(); |
| CompositedLayerMapping* mapping2 = |
| toLayoutBlock(getLayoutObjectByElementId("container2")) |
| ->layer() |
| ->compositedLayerMapping(); |
| CompositedLayerMapping* mapping3 = |
| toLayoutBlock(getLayoutObjectByElementId("container3")) |
| ->layer() |
| ->compositedLayerMapping(); |
| Element* innerScroller = document().getElementById("innerScroller"); |
| Element* innerScroller2 = document().getElementById("innerScroller2"); |
| Element* innerScroller3 = document().getElementById("innerScroller3"); |
| |
| ASSERT_TRUE(mapping); |
| ASSERT_TRUE(mapping2); |
| ASSERT_TRUE(mapping3); |
| ASSERT_TRUE(innerScroller); |
| ASSERT_TRUE(innerScroller2); |
| ASSERT_TRUE(innerScroller3); |
| |
| // Since there's no need to composite the clip and we prefer LCD text, the |
| // mapping should create an ancestorClippingLayer. |
| ASSERT_TRUE(mapping->scrollingLayer()); |
| ASSERT_TRUE(mapping->ancestorClippingLayer()); |
| |
| // Since the clip has a transform it should be composited so there's no |
| // need for an ancestor clipping layer. |
| ASSERT_TRUE(mapping2->scrollingLayer()); |
| |
| // The third <div> should have a clipping layer since it's composited and |
| // clips composited children. |
| ASSERT_TRUE(mapping3->clippingLayer()); |
| |
| // All scrolling and clipping layers should have masksToBounds set on them. |
| { |
| EXPECT_TRUE(mapping->scrollingLayer()->platformLayer()->masksToBounds()); |
| EXPECT_TRUE( |
| mapping->ancestorClippingLayer()->platformLayer()->masksToBounds()); |
| EXPECT_TRUE(mapping2->scrollingLayer()->platformLayer()->masksToBounds()); |
| EXPECT_TRUE(mapping3->clippingLayer()->platformLayer()->masksToBounds()); |
| } |
| |
| // Set the inner scroller in the first container as the root scroller. Its |
| // clipping layer should be removed and the scrolling layer should not |
| // mask. |
| { |
| document().setRootScroller(innerScroller, nonThrow); |
| document().view()->updateAllLifecyclePhases(); |
| ASSERT_EQ(innerScroller, rootScrollerController.globalRootScroller()); |
| |
| EXPECT_FALSE(mapping->ancestorClippingLayer()); |
| EXPECT_FALSE(mapping->scrollingLayer()->platformLayer()->masksToBounds()); |
| } |
| |
| // Set the inner scroller in the second container as the root scroller. Its |
| // scrolling layer should no longer mask. The clipping and scrolling layers |
| // on the first container should now reset back. |
| { |
| document().setRootScroller(innerScroller2, nonThrow); |
| document().view()->updateAllLifecyclePhases(); |
| ASSERT_EQ(innerScroller2, rootScrollerController.globalRootScroller()); |
| |
| EXPECT_TRUE(mapping->ancestorClippingLayer()); |
| EXPECT_TRUE( |
| mapping->ancestorClippingLayer()->platformLayer()->masksToBounds()); |
| EXPECT_TRUE(mapping->scrollingLayer()->platformLayer()->masksToBounds()); |
| |
| EXPECT_FALSE(mapping2->scrollingLayer()->platformLayer()->masksToBounds()); |
| } |
| |
| // Set the inner scroller in the third container as the root scroller. Its |
| // clipping layer should be removed. |
| { |
| document().setRootScroller(innerScroller3, nonThrow); |
| document().view()->updateAllLifecyclePhases(); |
| ASSERT_EQ(innerScroller3, rootScrollerController.globalRootScroller()); |
| |
| EXPECT_TRUE(mapping2->scrollingLayer()->platformLayer()->masksToBounds()); |
| |
| EXPECT_FALSE(mapping3->clippingLayer()); |
| } |
| |
| // Unset the root scroller. The clipping layer on the third container should |
| // be restored. |
| { |
| document().setRootScroller(nullptr, nonThrow); |
| document().view()->updateAllLifecyclePhases(); |
| ASSERT_EQ(document().documentElement(), |
| rootScrollerController.globalRootScroller()); |
| |
| EXPECT_TRUE(mapping3->clippingLayer()); |
| EXPECT_TRUE(mapping3->clippingLayer()->platformLayer()->masksToBounds()); |
| } |
| } |
| |
| TEST_P(CompositedLayerMappingTest, AncestorClippingMaskLayerUpdates) { |
| setBodyInnerHTML( |
| "<style>" |
| "#ancestor { width: 100px; height: 100px; overflow: hidden; }" |
| "#child { width: 120px; height: 120px; background-color: green; }" |
| "</style>" |
| "<div id='ancestor'><div id='child'></div></div>"); |
| document().view()->updateAllLifecyclePhases(); |
| |
| Element* ancestor = document().getElementById("ancestor"); |
| ASSERT_TRUE(ancestor); |
| PaintLayer* ancestorPaintLayer = |
| toLayoutBoxModelObject(ancestor->layoutObject())->layer(); |
| ASSERT_TRUE(ancestorPaintLayer); |
| |
| CompositedLayerMapping* ancestorMapping = |
| ancestorPaintLayer->compositedLayerMapping(); |
| ASSERT_FALSE(ancestorMapping); |
| |
| Element* child = document().getElementById("child"); |
| ASSERT_TRUE(child); |
| PaintLayer* childPaintLayer = |
| toLayoutBoxModelObject(child->layoutObject())->layer(); |
| ASSERT_FALSE(childPaintLayer); |
| |
| // Making the child conposited causes creation of an AncestorClippingLayer. |
| child->setAttribute(HTMLNames::styleAttr, "will-change: transform"); |
| document().view()->updateAllLifecyclePhases(); |
| |
| childPaintLayer = toLayoutBoxModelObject(child->layoutObject())->layer(); |
| ASSERT_TRUE(childPaintLayer); |
| CompositedLayerMapping* childMapping = |
| childPaintLayer->compositedLayerMapping(); |
| ASSERT_TRUE(childMapping); |
| EXPECT_TRUE(childMapping->ancestorClippingLayer()); |
| EXPECT_FALSE(childMapping->ancestorClippingLayer()->maskLayer()); |
| EXPECT_FALSE(childMapping->ancestorClippingMaskLayer()); |
| |
| // Adding border radius to the ancestor requires an |
| // ancestorClippingMaskLayer for the child |
| ancestor->setAttribute(HTMLNames::styleAttr, "border-radius: 40px;"); |
| document().view()->updateAllLifecyclePhases(); |
| |
| childPaintLayer = toLayoutBoxModelObject(child->layoutObject())->layer(); |
| ASSERT_TRUE(childPaintLayer); |
| childMapping = childPaintLayer->compositedLayerMapping(); |
| ASSERT_TRUE(childMapping); |
| EXPECT_TRUE(childMapping->ancestorClippingLayer()); |
| EXPECT_TRUE(childMapping->ancestorClippingLayer()->maskLayer()); |
| EXPECT_TRUE(childMapping->ancestorClippingMaskLayer()); |
| |
| // Removing the border radius should remove the ancestorClippingMaskLayer |
| // for the child |
| ancestor->setAttribute(HTMLNames::styleAttr, "border-radius: 0px;"); |
| document().view()->updateAllLifecyclePhases(); |
| |
| childPaintLayer = toLayoutBoxModelObject(child->layoutObject())->layer(); |
| ASSERT_TRUE(childPaintLayer); |
| childMapping = childPaintLayer->compositedLayerMapping(); |
| ASSERT_TRUE(childMapping); |
| EXPECT_TRUE(childMapping->ancestorClippingLayer()); |
| EXPECT_FALSE(childMapping->ancestorClippingLayer()->maskLayer()); |
| EXPECT_FALSE(childMapping->ancestorClippingMaskLayer()); |
| |
| // Add border radius back so we can test one more case |
| ancestor->setAttribute(HTMLNames::styleAttr, "border-radius: 40px;"); |
| document().view()->updateAllLifecyclePhases(); |
| |
| // Now change the overflow to remove the need for an ancestor clip |
| // on the child |
| ancestor->setAttribute(HTMLNames::styleAttr, "overflow: visible"); |
| document().view()->updateAllLifecyclePhases(); |
| |
| childPaintLayer = toLayoutBoxModelObject(child->layoutObject())->layer(); |
| ASSERT_TRUE(childPaintLayer); |
| childMapping = childPaintLayer->compositedLayerMapping(); |
| ASSERT_TRUE(childMapping); |
| EXPECT_FALSE(childMapping->ancestorClippingLayer()); |
| EXPECT_FALSE(childMapping->ancestorClippingMaskLayer()); |
| } |
| |
| } // namespace blink |
