| // Copyright 2016 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/LayoutInline.h" |
| #include "core/layout/LayoutTestHelper.h" |
| #include "core/layout/LayoutView.h" |
| #include "platform/geometry/TransformState.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace blink { |
| |
| class MapCoordinatesTest : public RenderingTest { |
| public: |
| MapCoordinatesTest() |
| : RenderingTest(SingleChildFrameLoaderClient::create()) {} |
| FloatPoint mapLocalToAncestor(const LayoutObject*, const LayoutBoxModelObject* ancestor, FloatPoint, MapCoordinatesFlags = 0) const; |
| FloatQuad mapLocalToAncestor(const LayoutObject*, const LayoutBoxModelObject* ancestor, FloatQuad, MapCoordinatesFlags = 0) const; |
| FloatPoint mapAncestorToLocal(const LayoutObject*, const LayoutBoxModelObject* ancestor, FloatPoint, MapCoordinatesFlags = 0) const; |
| FloatQuad mapAncestorToLocal(const LayoutObject*, const LayoutBoxModelObject* ancestor, FloatQuad, MapCoordinatesFlags = 0) const; |
| }; |
| |
| // One note about tests here that operate on LayoutInline and LayoutText objects: |
| // mapLocalToAncestor() expects such objects to pass their static location and size (relatively to |
| // the border edge of their container) to mapLocalToAncestor() via the TransformState |
| // argument. mapLocalToAncestor() is then only expected to make adjustments for |
| // relative-positioning, container-specific characteristics (such as writing mode roots, multicol), |
| // and so on. This in contrast to LayoutBox objects, where the TransformState passed is relative to |
| // the box itself, not the container. |
| |
| FloatPoint MapCoordinatesTest::mapLocalToAncestor(const LayoutObject* object, const LayoutBoxModelObject* ancestor, FloatPoint point, MapCoordinatesFlags mode) const |
| { |
| TransformState transformState(TransformState::ApplyTransformDirection, point); |
| object->mapLocalToAncestor(ancestor, transformState, mode); |
| transformState.flatten(); |
| return transformState.lastPlanarPoint(); |
| } |
| |
| FloatQuad MapCoordinatesTest::mapLocalToAncestor(const LayoutObject* object, const LayoutBoxModelObject* ancestor, FloatQuad quad, MapCoordinatesFlags mode) const |
| { |
| TransformState transformState(TransformState::ApplyTransformDirection, quad.boundingBox().center(), quad); |
| object->mapLocalToAncestor(ancestor, transformState, mode); |
| transformState.flatten(); |
| return transformState.lastPlanarQuad(); |
| } |
| |
| FloatPoint MapCoordinatesTest::mapAncestorToLocal(const LayoutObject* object, const LayoutBoxModelObject* ancestor, FloatPoint point, MapCoordinatesFlags mode) const |
| { |
| TransformState transformState(TransformState::UnapplyInverseTransformDirection, point); |
| object->mapAncestorToLocal(ancestor, transformState, mode); |
| transformState.flatten(); |
| return transformState.lastPlanarPoint(); |
| } |
| |
| FloatQuad MapCoordinatesTest::mapAncestorToLocal(const LayoutObject* object, const LayoutBoxModelObject* ancestor, FloatQuad quad, MapCoordinatesFlags mode) const |
| { |
| TransformState transformState(TransformState::UnapplyInverseTransformDirection, quad.boundingBox().center(), quad); |
| object->mapAncestorToLocal(ancestor, transformState, mode); |
| transformState.flatten(); |
| return transformState.lastPlanarQuad(); |
| } |
| |
| TEST_F(MapCoordinatesTest, SimpleText) |
| { |
| setBodyInnerHTML("<div id='container'><br>text</div>"); |
| |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| LayoutObject* text = toLayoutBlockFlow(container)->lastChild(); |
| ASSERT_TRUE(text->isText()); |
| FloatPoint mappedPoint = mapLocalToAncestor(text, container, FloatPoint(10, 30)); |
| EXPECT_EQ(FloatPoint(10, 30), mappedPoint); |
| mappedPoint = mapAncestorToLocal(text, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(10, 30), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, SimpleInline) |
| { |
| setBodyInnerHTML("<div><span id='target'>text</span></div>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| FloatPoint mappedPoint = mapLocalToAncestor(target, toLayoutBoxModelObject(target->parent()), FloatPoint(10, 10)); |
| EXPECT_EQ(FloatPoint(10, 10), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, toLayoutBoxModelObject(target->parent()), mappedPoint); |
| EXPECT_EQ(FloatPoint(10, 10), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, SimpleBlock) |
| { |
| setBodyInnerHTML( |
| "<div style='margin:666px; border:8px solid; padding:7px;'>" |
| " <div id='target' style='margin:10px; border:666px; padding:666px;'></div>" |
| "</div>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| FloatPoint mappedPoint = mapLocalToAncestor(target, toLayoutBoxModelObject(target->parent()), FloatPoint(100, 100)); |
| EXPECT_EQ(FloatPoint(125, 125), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, toLayoutBoxModelObject(target->parent()), mappedPoint); |
| EXPECT_EQ(FloatPoint(100, 100), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, OverflowClip) |
| { |
| setBodyInnerHTML( |
| "<div id='overflow' style='height: 100px; width: 100px; border:8px solid; padding:7px; overflow:scroll'>" |
| " <div style='height:200px; width:200px'></div>" |
| " <div id='target' style='margin:10px; border:666px; padding:666px;'></div>" |
| "</div>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| LayoutObject* overflow = getLayoutObjectByElementId("overflow"); |
| toLayoutBox(overflow)->scrollToOffset(DoubleSize(32, 54)); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, toLayoutBoxModelObject(target->parent()), FloatPoint(100, 100)); |
| EXPECT_EQ(FloatPoint(93, 271), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, toLayoutBoxModelObject(target->parent()), mappedPoint); |
| EXPECT_EQ(FloatPoint(100, 100), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, TextInRelPosInline) |
| { |
| setBodyInnerHTML("<div><span style='position:relative; left:7px; top:4px;'><br id='sibling'>text</span></div>"); |
| |
| LayoutObject* br = getLayoutObjectByElementId("sibling"); |
| LayoutObject* text = br->nextSibling(); |
| ASSERT_TRUE(text->isText()); |
| FloatPoint mappedPoint = mapLocalToAncestor(text, text->containingBlock(), FloatPoint(10, 30)); |
| EXPECT_EQ(FloatPoint(17, 34), mappedPoint); |
| mappedPoint = mapAncestorToLocal(text, text->containingBlock(), mappedPoint); |
| EXPECT_EQ(FloatPoint(10, 30), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, RelposInline) |
| { |
| setBodyInnerHTML("<span id='target' style='position:relative; left:50px; top:100px;'>text</span>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| FloatPoint mappedPoint = mapLocalToAncestor(target, toLayoutBoxModelObject(target->parent()), FloatPoint(10, 10)); |
| EXPECT_EQ(FloatPoint(60, 110), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, toLayoutBoxModelObject(target->parent()), mappedPoint); |
| EXPECT_EQ(FloatPoint(10, 10), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, RelposInlineInRelposInline) |
| { |
| setBodyInnerHTML( |
| "<div style='padding-left:10px;'>" |
| " <span style='position:relative; left:5px; top:6px;'>" |
| " <span id='target' style='position:relative; left:50px; top:100px;'>text</span>" |
| " </span>" |
| "</div>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| LayoutInline* parent = toLayoutInline(target->parent()); |
| LayoutBlockFlow* containingBlock = toLayoutBlockFlow(parent->parent()); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, containingBlock, FloatPoint(20, 10)); |
| EXPECT_EQ(FloatPoint(75, 116), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, containingBlock, mappedPoint); |
| EXPECT_EQ(FloatPoint(20, 10), mappedPoint); |
| |
| // Walk each ancestor in the chain separately, to verify each step on the way. |
| mappedPoint = mapLocalToAncestor(target, parent, FloatPoint(20, 10)); |
| EXPECT_EQ(FloatPoint(70, 110), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(parent, containingBlock, mappedPoint); |
| EXPECT_EQ(FloatPoint(75, 116), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(parent, containingBlock, mappedPoint); |
| EXPECT_EQ(FloatPoint(70, 110), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(target, parent, mappedPoint); |
| EXPECT_EQ(FloatPoint(20, 10), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, RelPosBlock) |
| { |
| setBodyInnerHTML( |
| "<div id='container' style='margin:666px; border:8px solid; padding:7px;'>" |
| " <div id='middle' style='margin:30px; border:1px solid;'>" |
| " <div id='target' style='position:relative; left:50px; top:50px; margin:10px; border:666px; padding:666px;'></div>" |
| " </div>" |
| "</div>"); |
| |
| LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target")); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(106, 106), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, container, FloatPoint(110, 110)); |
| EXPECT_EQ(FloatPoint(4, 4), mappedPoint); |
| |
| // Walk each ancestor in the chain separately, to verify each step on the way. |
| LayoutBox* middle = toLayoutBox(getLayoutObjectByElementId("middle")); |
| |
| mappedPoint = mapLocalToAncestor(target, middle, FloatPoint()); |
| EXPECT_EQ(FloatPoint(61, 61), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(middle, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(106, 106), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(middle, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(61, 61), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(target, middle, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, AbsPos) |
| { |
| setBodyInnerHTML( |
| "<div id='container' style='position:relative; margin:666px; border:8px solid; padding:7px;'>" |
| " <div id='staticChild' style='margin:30px; padding-top:666px;'>" |
| " <div style='padding-top:666px;'></div>" |
| " <div id='target' style='position:absolute; left:-1px; top:-1px; margin:10px; border:666px; padding:666px;'></div>" |
| " </div>" |
| "</div>"); |
| |
| LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target")); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(17, 17), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, container, FloatPoint(18, 18)); |
| EXPECT_EQ(FloatPoint(1, 1), mappedPoint); |
| |
| // Walk each ancestor in the chain separately, to verify each step on the way. |
| LayoutBox* staticChild = toLayoutBox(getLayoutObjectByElementId("staticChild")); |
| |
| mappedPoint = mapLocalToAncestor(target, staticChild, FloatPoint()); |
| EXPECT_EQ(FloatPoint(-28, -28), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(staticChild, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(17, 17), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(staticChild, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(-28, -28), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(target, staticChild, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, AbsPosAuto) |
| { |
| setBodyInnerHTML( |
| "<div id='container' style='position:absolute; margin:666px; border:8px solid; padding:7px;'>" |
| " <div id='staticChild' style='margin:30px; padding-top:5px;'>" |
| " <div style='padding-top:20px;'></div>" |
| " <div id='target' style='position:absolute; margin:10px; border:666px; padding:666px;'></div>" |
| " </div>" |
| "</div>"); |
| |
| LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target")); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(55, 80), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, container, FloatPoint(56, 82)); |
| EXPECT_EQ(FloatPoint(1, 2), mappedPoint); |
| |
| // Walk each ancestor in the chain separately, to verify each step on the way. |
| LayoutBox* staticChild = toLayoutBox(getLayoutObjectByElementId("staticChild")); |
| |
| mappedPoint = mapLocalToAncestor(target, staticChild, FloatPoint()); |
| EXPECT_EQ(FloatPoint(10, 35), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(staticChild, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(55, 80), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(staticChild, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(10, 35), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(target, staticChild, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, FixedPos) |
| { |
| // Assuming BODY margin of 8px. |
| setBodyInnerHTML( |
| "<div id='container' style='position:absolute; margin:4px; border:5px solid; padding:7px;'>" |
| " <div id='staticChild' style='padding-top:666px;'>" |
| " <div style='padding-top:666px;'></div>" |
| " <div id='target' style='position:fixed; left:-1px; top:-1px; margin:10px; border:666px; padding:666px;'></div>" |
| " </div>" |
| "</div>"); |
| |
| LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target")); |
| LayoutBox* staticChild = toLayoutBox(getLayoutObjectByElementId("staticChild")); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| LayoutBox* body = container->parentBox(); |
| LayoutBox* html = body->parentBox(); |
| LayoutBox* view = html->parentBox(); |
| ASSERT_TRUE(view->isLayoutView()); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, view, FloatPoint()); |
| EXPECT_EQ(FloatPoint(9, 9), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, view, FloatPoint(10, 11)); |
| EXPECT_EQ(FloatPoint(1, 2), mappedPoint); |
| |
| // Walk each ancestor in the chain separately, to verify each step on the way. |
| mappedPoint = mapLocalToAncestor(target, staticChild, FloatPoint()); |
| EXPECT_EQ(FloatPoint(-15, -15), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(staticChild, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(-3, -3), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(container, body, mappedPoint); |
| EXPECT_EQ(FloatPoint(1, 1), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(body, html, mappedPoint); |
| EXPECT_EQ(FloatPoint(9, 9), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(html, view, mappedPoint); |
| EXPECT_EQ(FloatPoint(9, 9), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(html, view, mappedPoint); |
| EXPECT_EQ(FloatPoint(9, 9), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(body, html, mappedPoint); |
| EXPECT_EQ(FloatPoint(1, 1), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(container, body, mappedPoint); |
| EXPECT_EQ(FloatPoint(-3, -3), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(staticChild, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(-15, -15), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(target, staticChild, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, FixedPosAuto) |
| { |
| // Assuming BODY margin of 8px. |
| setBodyInnerHTML( |
| "<div id='container' style='position:absolute; margin:3px; border:8px solid; padding:7px;'>" |
| " <div id='staticChild' style='padding-top:5px;'>" |
| " <div style='padding-top:20px;'></div>" |
| " <div id='target' style='position:fixed; margin:10px; border:666px; padding:666px;'></div>" |
| " </div>" |
| "</div>"); |
| |
| LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target")); |
| LayoutBox* staticChild = toLayoutBox(getLayoutObjectByElementId("staticChild")); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| LayoutBox* body = container->parentBox(); |
| LayoutBox* html = body->parentBox(); |
| LayoutBox* view = html->parentBox(); |
| ASSERT_TRUE(view->isLayoutView()); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, target->containingBlock(), FloatPoint()); |
| EXPECT_EQ(FloatPoint(36, 61), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, target->containingBlock(), FloatPoint(36, 61)); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| |
| // Walk each ancestor in the chain separately, to verify each step on the way. |
| mappedPoint = mapLocalToAncestor(target, staticChild, FloatPoint()); |
| EXPECT_EQ(FloatPoint(10, 35), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(staticChild, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(25, 50), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(container, body, mappedPoint); |
| EXPECT_EQ(FloatPoint(28, 53), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(body, html, mappedPoint); |
| EXPECT_EQ(FloatPoint(36, 61), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(html, view, mappedPoint); |
| EXPECT_EQ(FloatPoint(36, 61), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(html, view, mappedPoint); |
| EXPECT_EQ(FloatPoint(36, 61), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(body, html, mappedPoint); |
| EXPECT_EQ(FloatPoint(28, 53), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(container, body, mappedPoint); |
| EXPECT_EQ(FloatPoint(25, 50), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(staticChild, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(10, 35), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(target, staticChild, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, FixedPosInFixedPos) |
| { |
| // Assuming BODY margin of 8px. |
| setBodyInnerHTML( |
| "<div id='container' style='position:absolute; margin:4px; border:5px solid; padding:7px;'>" |
| " <div id='staticChild' style='padding-top:666px;'>" |
| " <div style='padding-top:666px;'></div>" |
| " <div id='outerFixed' style='position:fixed; left:100px; top:100px; margin:10px; border:666px; padding:666px;'>" |
| " <div id='target' style='position:fixed; left:-1px; top:-1px; margin:10px; border:666px; padding:666px;'></div>" |
| " </div>" |
| " </div>" |
| "</div>"); |
| |
| LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target")); |
| LayoutBox* outerFixed = toLayoutBox(getLayoutObjectByElementId("outerFixed")); |
| LayoutBox* staticChild = toLayoutBox(getLayoutObjectByElementId("staticChild")); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| LayoutBox* body = container->parentBox(); |
| LayoutBox* html = body->parentBox(); |
| LayoutBox* view = html->parentBox(); |
| ASSERT_TRUE(view->isLayoutView()); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, view, FloatPoint()); |
| EXPECT_EQ(FloatPoint(9, 9), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, view, FloatPoint(9, 9)); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| |
| // Walk each ancestor in the chain separately, to verify each step on the way. |
| mappedPoint = mapLocalToAncestor(target, outerFixed, FloatPoint()); |
| EXPECT_EQ(FloatPoint(-101, -101), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(outerFixed, staticChild, mappedPoint); |
| EXPECT_EQ(FloatPoint(-15, -15), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(staticChild, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(-3, -3), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(container, body, mappedPoint); |
| EXPECT_EQ(FloatPoint(1, 1), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(body, html, mappedPoint); |
| EXPECT_EQ(FloatPoint(9, 9), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(html, view, mappedPoint); |
| EXPECT_EQ(FloatPoint(9, 9), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(html, view, mappedPoint); |
| EXPECT_EQ(FloatPoint(9, 9), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(body, html, mappedPoint); |
| EXPECT_EQ(FloatPoint(1, 1), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(container, body, mappedPoint); |
| EXPECT_EQ(FloatPoint(-3, -3), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(staticChild, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(-15, -15), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(outerFixed, staticChild, mappedPoint); |
| EXPECT_EQ(FloatPoint(-101, -101), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(target, outerFixed, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| // TODO(chrishtr): add more multi-frame tests. |
| TEST_F(MapCoordinatesTest, FixedPosInScrolledIFrame) |
| { |
| document().setBaseURLOverride(KURL(ParsedURLString, "http://test.com")); |
| setBodyInnerHTML( |
| "<style>body { margin: 0; }</style>" |
| "<div style='width: 200; height: 8000px'></div>" |
| "<iframe id=frame src='http://test.com' width='500' height='500' frameBorder='0'>" |
| "</iframe>"); |
| |
| Document& frameDocument = setupChildIframe("frame", "<style>body { margin: 0; } #target { width: 200px; height: 200px; position:fixed}</style><div id=target></div>"); |
| |
| document().view()->setScrollPosition(DoublePoint(0.0, 1000), ProgrammaticScroll); |
| document().view()->updateAllLifecyclePhases(); |
| |
| Element* target = frameDocument.getElementById("target"); |
| ASSERT_TRUE(target); |
| FloatPoint mappedPoint = mapAncestorToLocal(target->layoutObject(), nullptr, FloatPoint(10, 70), TraverseDocumentBoundaries); |
| |
| // y = 70 - 8000, since the iframe is offset by 8000px from the main frame. |
| // The scroll is not taken into account because the element is not fixed to the root LayoutView, |
| // and the space of the root LayoutView does not include scroll. |
| EXPECT_EQ(FloatPoint(10, -7930), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, MulticolWithText) |
| { |
| setBodyInnerHTML( |
| "<div id='multicol' style='-webkit-columns:2; -webkit-column-gap:20px; width:400px; line-height:50px; padding:5px;'>" |
| " <br id='sibling'>" |
| " text" |
| "</div>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("sibling")->nextSibling(); |
| ASSERT_TRUE(target->isText()); |
| LayoutBox* flowThread = toLayoutBox(target->parent()); |
| ASSERT_TRUE(flowThread->isLayoutFlowThread()); |
| LayoutBox* multicol = toLayoutBox(getLayoutObjectByElementId("multicol")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, flowThread, FloatPoint(10, 70)); |
| EXPECT_EQ(FloatPoint(10, 70), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(flowThread, multicol, mappedPoint); |
| EXPECT_EQ(FloatPoint(225, 25), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(flowThread, multicol, mappedPoint); |
| EXPECT_EQ(FloatPoint(220, 20), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(target, flowThread, mappedPoint); |
| EXPECT_EQ(FloatPoint(10, 70), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, MulticolWithInline) |
| { |
| setBodyInnerHTML( |
| "<div id='multicol' style='-webkit-columns:2; -webkit-column-gap:20px; width:400px; line-height:50px; padding:5px;'>" |
| " <span id='target'><br>text</span>" |
| "</div>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| LayoutBox* flowThread = toLayoutBox(target->parent()); |
| ASSERT_TRUE(flowThread->isLayoutFlowThread()); |
| LayoutBox* multicol = toLayoutBox(getLayoutObjectByElementId("multicol")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, flowThread, FloatPoint(10, 70)); |
| EXPECT_EQ(FloatPoint(10, 70), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(flowThread, multicol, mappedPoint); |
| EXPECT_EQ(FloatPoint(225, 25), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(flowThread, multicol, mappedPoint); |
| EXPECT_EQ(FloatPoint(220, 20), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(target, flowThread, mappedPoint); |
| EXPECT_EQ(FloatPoint(10, 70), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, MulticolWithBlock) |
| { |
| setBodyInnerHTML( |
| "<div id='container' style='-webkit-columns:3; -webkit-column-gap:0; column-fill:auto; width:300px; height:100px; border:8px solid; padding:7px;'>" |
| " <div style='height:110px;'></div>" |
| " <div id='target' style='margin:10px; border:13px; padding:13px;'></div>" |
| "</div>"); |
| |
| LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target")); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(125, 35), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| |
| // Walk each ancestor in the chain separately, to verify each step on the way. |
| LayoutBox* flowThread = target->parentBox(); |
| ASSERT_TRUE(flowThread->isLayoutFlowThread()); |
| |
| mappedPoint = mapLocalToAncestor(target, flowThread, FloatPoint()); |
| EXPECT_EQ(FloatPoint(10, 120), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(flowThread, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(125, 35), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(flowThread, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(110, 20), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(target, flowThread, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, MulticolWithAbsPosInRelPos) |
| { |
| setBodyInnerHTML( |
| "<div id='multicol' style='-webkit-columns:3; -webkit-column-gap:0; column-fill:auto; width:300px; height:100px; border:8px solid; padding:7px;'>" |
| " <div style='height:110px;'></div>" |
| " <div id='relpos' style='position:relative; left:4px; top:4px;'>" |
| " <div id='target' style='position:absolute; left:15px; top:15px; margin:10px; border:13px; padding:13px;'></div>" |
| " </div>" |
| "</div>"); |
| |
| LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target")); |
| LayoutBox* multicol = toLayoutBox(getLayoutObjectByElementId("multicol")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, multicol, FloatPoint()); |
| EXPECT_EQ(FloatPoint(144, 54), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, multicol, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| |
| // Walk each ancestor in the chain separately, to verify each step on the way. |
| LayoutBox* relpos = toLayoutBox(getLayoutObjectByElementId("relpos")); |
| LayoutBox* flowThread = relpos->parentBox(); |
| ASSERT_TRUE(flowThread->isLayoutFlowThread()); |
| |
| mappedPoint = mapLocalToAncestor(target, relpos, FloatPoint()); |
| EXPECT_EQ(FloatPoint(25, 25), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(relpos, flowThread, mappedPoint); |
| EXPECT_EQ(FloatPoint(29, 139), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(flowThread, multicol, mappedPoint); |
| EXPECT_EQ(FloatPoint(144, 54), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(flowThread, multicol, mappedPoint); |
| EXPECT_EQ(FloatPoint(129, 39), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(relpos, flowThread, mappedPoint); |
| EXPECT_EQ(FloatPoint(25, 25), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(target, relpos, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, MulticolWithAbsPosNotContained) |
| { |
| setBodyInnerHTML( |
| "<div id='container' style='position:relative; margin:666px; border:7px solid; padding:3px;'>" |
| " <div id='multicol' style='-webkit-columns:3; -webkit-column-gap:0; column-fill:auto; width:300px; height:100px; border:8px solid; padding:7px;'>" |
| " <div style='height:110px;'></div>" |
| " <div id='target' style='position:absolute; left:-1px; top:-1px; margin:10px; border:13px; padding:13px;'></div>" |
| " </div>" |
| "</div>"); |
| |
| LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target")); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| // The multicol container isn't in the containing block chain of the abspos #target. |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(16, 16), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| |
| // Walk each ancestor in the chain separately, to verify each step on the way. |
| LayoutBox* multicol = toLayoutBox(getLayoutObjectByElementId("multicol")); |
| LayoutBox* flowThread = target->parentBox(); |
| ASSERT_TRUE(flowThread->isLayoutFlowThread()); |
| |
| mappedPoint = mapLocalToAncestor(target, flowThread, FloatPoint()); |
| EXPECT_EQ(FloatPoint(-9, -9), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(flowThread, multicol, mappedPoint); |
| EXPECT_EQ(FloatPoint(6, 6), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(multicol, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(16, 16), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(multicol, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(6, 6), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(flowThread, multicol, mappedPoint); |
| EXPECT_EQ(FloatPoint(-9, -9), mappedPoint); |
| |
| mappedPoint = mapAncestorToLocal(target, flowThread, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, FlippedBlocksWritingModeWithText) |
| { |
| setBodyInnerHTML( |
| "<div style='-webkit-writing-mode:vertical-rl;'>" |
| " <div style='width:13px;'></div>" |
| " <div style='width:200px; height:400px; line-height:50px;'>" |
| " <br id='sibling'>text" |
| " </div>" |
| " <div style='width:5px;'></div>" |
| "</div>"); |
| |
| LayoutObject* br = getLayoutObjectByElementId("sibling"); |
| LayoutObject* text = br->nextSibling(); |
| ASSERT_TRUE(text->isText()); |
| |
| // Map to the nearest container. Flipping should occur. |
| FloatPoint mappedPoint = mapLocalToAncestor(text, text->containingBlock(), FloatPoint(75, 10), ApplyContainerFlip); |
| EXPECT_EQ(FloatPoint(125, 10), mappedPoint); |
| mappedPoint = mapAncestorToLocal(text, text->containingBlock(), mappedPoint, ApplyContainerFlip); |
| EXPECT_EQ(FloatPoint(75, 10), mappedPoint); |
| |
| // Map to a container further up in the tree. Flipping should still occur on the nearest |
| // container. LayoutObject::mapLocalToAncestor() is called recursively until the ancestor is |
| // reached, and the ApplyContainerFlip flag is cleared after having processed the innermost |
| // object. |
| mappedPoint = mapLocalToAncestor(text, text->containingBlock()->containingBlock(), FloatPoint(75, 10), ApplyContainerFlip); |
| EXPECT_EQ(FloatPoint(130, 10), mappedPoint); |
| mappedPoint = mapAncestorToLocal(text, text->containingBlock()->containingBlock(), mappedPoint, ApplyContainerFlip); |
| EXPECT_EQ(FloatPoint(75, 10), mappedPoint); |
| |
| // If the ApplyContainerFlip flag isn't specified, no flipping should take place. |
| mappedPoint = mapLocalToAncestor(text, text->containingBlock()->containingBlock(), FloatPoint(75, 10)); |
| EXPECT_EQ(FloatPoint(80, 10), mappedPoint); |
| mappedPoint = mapAncestorToLocal(text, text->containingBlock()->containingBlock(), mappedPoint); |
| EXPECT_EQ(FloatPoint(75, 10), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, FlippedBlocksWritingModeWithInline) |
| { |
| setBodyInnerHTML( |
| "<div style='-webkit-writing-mode:vertical-rl;'>" |
| " <div style='width:13px;'></div>" |
| " <div style='width:200px; height:400px; line-height:50px;'>" |
| " <span>" |
| " <span id='target'><br>text</span>" |
| " </span>" |
| " </div>" |
| " <div style='width:7px;'></div>" |
| "</div>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| ASSERT_TRUE(target); |
| |
| // First map to the parent SPAN. Nothing special should happen, since flipping occurs at the nearest container. |
| FloatPoint mappedPoint = mapLocalToAncestor(target, toLayoutBoxModelObject(target->parent()), FloatPoint(75, 10), ApplyContainerFlip); |
| EXPECT_EQ(FloatPoint(75, 10), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, toLayoutBoxModelObject(target->parent()), mappedPoint, ApplyContainerFlip); |
| EXPECT_EQ(FloatPoint(75, 10), mappedPoint); |
| |
| // Continue to the nearest container. Flipping should occur. |
| mappedPoint = mapLocalToAncestor(toLayoutBoxModelObject(target->parent()), target->containingBlock(), FloatPoint(75, 10), ApplyContainerFlip); |
| EXPECT_EQ(FloatPoint(125, 10), mappedPoint); |
| mappedPoint = mapAncestorToLocal(toLayoutBoxModelObject(target->parent()), target->containingBlock(), mappedPoint, ApplyContainerFlip); |
| EXPECT_EQ(FloatPoint(75, 10), mappedPoint); |
| |
| // Now map from the innermost inline to the nearest container in one go. |
| mappedPoint = mapLocalToAncestor(target, target->containingBlock(), FloatPoint(75, 10), ApplyContainerFlip); |
| EXPECT_EQ(FloatPoint(125, 10), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, target->containingBlock(), mappedPoint, ApplyContainerFlip); |
| EXPECT_EQ(FloatPoint(75, 10), mappedPoint); |
| |
| // Map to a container further up in the tree. Flipping should still only occur on the nearest container. |
| mappedPoint = mapLocalToAncestor(target, target->containingBlock()->containingBlock(), FloatPoint(75, 10), ApplyContainerFlip); |
| EXPECT_EQ(FloatPoint(132, 10), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, target->containingBlock()->containingBlock(), mappedPoint, ApplyContainerFlip); |
| EXPECT_EQ(FloatPoint(75, 10), mappedPoint); |
| |
| // If the ApplyContainerFlip flag isn't specified, no flipping should take place. |
| mappedPoint = mapLocalToAncestor(target, target->containingBlock()->containingBlock(), FloatPoint(75, 10)); |
| EXPECT_EQ(FloatPoint(82, 10), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, target->containingBlock()->containingBlock(), mappedPoint); |
| EXPECT_EQ(FloatPoint(75, 10), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, FlippedBlocksWritingModeWithBlock) |
| { |
| setBodyInnerHTML( |
| "<div id='container' style='-webkit-writing-mode:vertical-rl; border:8px solid; padding:7px; width:200px; height:200px;'>" |
| " <div id='middle' style='border:1px solid;'>" |
| " <div style='width:30px;'></div>" |
| " <div id='target' style='margin:6px; width:25px;'></div>" |
| " </div>" |
| "</div>"); |
| |
| LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target")); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(153, 22), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| |
| // Walk each ancestor in the chain separately, to verify each step on the way. |
| LayoutBox* middle = toLayoutBox(getLayoutObjectByElementId("middle")); |
| |
| mappedPoint = mapLocalToAncestor(target, middle, FloatPoint()); |
| EXPECT_EQ(FloatPoint(7, 7), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, middle, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(middle, container, FloatPoint(7, 7)); |
| EXPECT_EQ(FloatPoint(153, 22), mappedPoint); |
| mappedPoint = mapAncestorToLocal(middle, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(7, 7), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, Table) |
| { |
| setBodyInnerHTML( |
| "<style>td { padding: 2px; }</style>" |
| "<div id='container' style='border:3px solid;'>" |
| " <table style='margin:9px; border:5px solid; border-spacing:10px;'>" |
| " <thead>" |
| " <tr>" |
| " <td>" |
| " <div style='width:100px; height:100px;'></div>" |
| " </td>" |
| " </tr>" |
| " </thead>" |
| " <tbody>" |
| " <tr>" |
| " <td>" |
| " <div style='width:100px; height:100px;'></div>" |
| " </td>" |
| " </tr>" |
| " <tr>" |
| " <td>" |
| " <div style='width:100px; height:100px;'></div>" |
| " </td>" |
| " <td>" |
| " <div id='target' style='width:100px; height:10px;'></div>" |
| " </td>" |
| " </tr>" |
| " </tbody>" |
| " </table>" |
| "</div>"); |
| |
| LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target")); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(143, 302), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| |
| // Walk each ancestor in the chain separately, to verify each step on the way. |
| LayoutBox* td = target->parentBox(); |
| ASSERT_TRUE(td->isTableCell()); |
| mappedPoint = mapLocalToAncestor(target, td, FloatPoint()); |
| // Cells are middle-aligned by default. |
| EXPECT_EQ(FloatPoint(2, 47), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, td, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| |
| LayoutBox* tr = td->parentBox(); |
| ASSERT_TRUE(tr->isTableRow()); |
| mappedPoint = mapLocalToAncestor(td, tr, FloatPoint(2, 47)); |
| EXPECT_EQ(FloatPoint(126, 47), mappedPoint); |
| mappedPoint = mapAncestorToLocal(td, tr, mappedPoint); |
| EXPECT_EQ(FloatPoint(2, 47), mappedPoint); |
| |
| LayoutBox* tbody = tr->parentBox(); |
| ASSERT_TRUE(tbody->isTableSection()); |
| mappedPoint = mapLocalToAncestor(tr, tbody, FloatPoint(126, 47)); |
| EXPECT_EQ(FloatPoint(126, 161), mappedPoint); |
| mappedPoint = mapAncestorToLocal(tr, tbody, mappedPoint); |
| EXPECT_EQ(FloatPoint(126, 47), mappedPoint); |
| |
| LayoutBox* table = tbody->parentBox(); |
| ASSERT_TRUE(table->isTable()); |
| mappedPoint = mapLocalToAncestor(tbody, table, FloatPoint(126, 161)); |
| EXPECT_EQ(FloatPoint(131, 290), mappedPoint); |
| mappedPoint = mapAncestorToLocal(tbody, table, mappedPoint); |
| EXPECT_EQ(FloatPoint(126, 161), mappedPoint); |
| |
| mappedPoint = mapLocalToAncestor(table, container, FloatPoint(131, 290)); |
| EXPECT_EQ(FloatPoint(143, 302), mappedPoint); |
| mappedPoint = mapAncestorToLocal(table, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(131, 290), mappedPoint); |
| } |
| |
| static bool floatValuesAlmostEqual(float expected, float actual) |
| { |
| return fabs(expected - actual) < 0.01; |
| } |
| |
| static bool floatQuadsAlmostEqual(const FloatQuad& expected, const FloatQuad& actual) |
| { |
| return floatValuesAlmostEqual(expected.p1().x(), actual.p1().x()) |
| && floatValuesAlmostEqual(expected.p1().y(), actual.p1().y()) |
| && floatValuesAlmostEqual(expected.p2().x(), actual.p2().x()) |
| && floatValuesAlmostEqual(expected.p2().y(), actual.p2().y()) |
| && floatValuesAlmostEqual(expected.p3().x(), actual.p3().x()) |
| && floatValuesAlmostEqual(expected.p3().y(), actual.p3().y()) |
| && floatValuesAlmostEqual(expected.p4().x(), actual.p4().x()) |
| && floatValuesAlmostEqual(expected.p4().y(), actual.p4().y()); |
| } |
| |
| // If comparison fails, pretty-print the error using EXPECT_EQ() |
| #define EXPECT_FLOAT_QUAD_EQ(expected, actual) \ |
| do { \ |
| if (!floatQuadsAlmostEqual(expected, actual)) { \ |
| EXPECT_EQ(expected, actual); \ |
| } \ |
| } while (false) |
| |
| |
| TEST_F(MapCoordinatesTest, Transforms) |
| { |
| setBodyInnerHTML( |
| "<div id='container'>" |
| " <div id='outerTransform' style='transform:rotate(45deg); width:200px; height:200px;'>" |
| " <div id='innerTransform' style='transform:rotate(45deg); width:200px; height:200px;'>" |
| " <div id='target' style='width:200px; height:200px;'></div>" |
| " </div>" |
| " </div>" |
| "</div>"); |
| |
| LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target")); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatQuad initialQuad(FloatPoint(0, 0), FloatPoint(200, 0), FloatPoint(200, 200), FloatPoint(0, 200)); |
| FloatQuad mappedQuad = mapLocalToAncestor(target, container, initialQuad, UseTransforms); |
| EXPECT_FLOAT_QUAD_EQ(FloatQuad(FloatPoint(200, 0), FloatPoint(200, 200), FloatPoint(0, 200), FloatPoint(0, 0)), mappedQuad); |
| mappedQuad = mapAncestorToLocal(target, container, mappedQuad, UseTransforms); |
| EXPECT_FLOAT_QUAD_EQ(initialQuad, mappedQuad); |
| |
| // Walk each ancestor in the chain separately, to verify each step on the way. |
| LayoutBox* innerTransform = toLayoutBox(getLayoutObjectByElementId("innerTransform")); |
| LayoutBox* outerTransform = toLayoutBox(getLayoutObjectByElementId("outerTransform")); |
| |
| mappedQuad = mapLocalToAncestor(target, innerTransform, initialQuad, UseTransforms); |
| EXPECT_FLOAT_QUAD_EQ(FloatQuad(FloatPoint(0, 0), FloatPoint(200, 0), FloatPoint(200, 200), FloatPoint(0, 200)), mappedQuad); |
| mappedQuad = mapAncestorToLocal(target, innerTransform, mappedQuad, UseTransforms); |
| EXPECT_FLOAT_QUAD_EQ(initialQuad, mappedQuad); |
| |
| initialQuad = FloatQuad(FloatPoint(0, 0), FloatPoint(200, 0), FloatPoint(200, 200), FloatPoint(0, 200)); |
| mappedQuad = mapLocalToAncestor(innerTransform, outerTransform, initialQuad, UseTransforms); |
| // Clockwise rotation by 45 degrees. |
| EXPECT_FLOAT_QUAD_EQ(FloatQuad(FloatPoint(100, -41.42), FloatPoint(241.42, 100), FloatPoint(100, 241.42), FloatPoint(-41.42, 100)), mappedQuad); |
| mappedQuad = mapAncestorToLocal(innerTransform, outerTransform, mappedQuad, UseTransforms); |
| EXPECT_FLOAT_QUAD_EQ(initialQuad, mappedQuad); |
| |
| initialQuad = FloatQuad(FloatPoint(100, -41.42), FloatPoint(241.42, 100), FloatPoint(100, 241.42), FloatPoint(-41.42, 100)); |
| mappedQuad = mapLocalToAncestor(outerTransform, container, initialQuad, UseTransforms); |
| // Another clockwise rotation by 45 degrees. So now 90 degrees in total. |
| EXPECT_FLOAT_QUAD_EQ(FloatQuad(FloatPoint(200, 0), FloatPoint(200, 200), FloatPoint(0, 200), FloatPoint(0, 0)), mappedQuad); |
| mappedQuad = mapAncestorToLocal(outerTransform, container, mappedQuad, UseTransforms); |
| EXPECT_FLOAT_QUAD_EQ(initialQuad, mappedQuad); |
| } |
| |
| TEST_F(MapCoordinatesTest, SVGShape) |
| { |
| setBodyInnerHTML( |
| "<svg id='container'>" |
| " <g transform='translate(100 200)'>" |
| " <rect id='target' width='100' height='100'/>" |
| " </g>" |
| "</svg>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(100, 200), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, SVGShapeScale) |
| { |
| setBodyInnerHTML( |
| "<svg id='container'>" |
| " <g transform='scale(2) translate(50 40)'>" |
| " <rect id='target' transform='translate(50 80)' x='66' y='77' width='100' height='100'/>" |
| " </g>" |
| "</svg>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(200, 240), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, SVGShapeWithViewBoxWithoutScale) |
| { |
| setBodyInnerHTML( |
| "<svg id='container' viewBox='0 0 200 200' width='400' height='200'>" |
| " <g transform='translate(100 50)'>" |
| " <rect id='target' width='100' height='100'/>" |
| " </g>" |
| "</svg>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(200, 50), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, SVGShapeWithViewBoxWithScale) |
| { |
| setBodyInnerHTML( |
| "<svg id='container' viewBox='0 0 100 100' width='400' height='200'>" |
| " <g transform='translate(50 50)'>" |
| " <rect id='target' width='100' height='100'/>" |
| " </g>" |
| "</svg>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(200, 100), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, SVGShapeWithViewBoxWithNonZeroOffset) |
| { |
| setBodyInnerHTML( |
| "<svg id='container' viewBox='100 100 200 200' width='400' height='200'>" |
| " <g transform='translate(100 50)'>" |
| " <rect id='target' transform='translate(100 100)' width='100' height='100'/>" |
| " </g>" |
| "</svg>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(200, 50), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, SVGShapeWithViewBoxWithNonZeroOffsetAndScale) |
| { |
| setBodyInnerHTML( |
| "<svg id='container' viewBox='100 100 100 100' width='400' height='200'>" |
| " <g transform='translate(50 50)'>" |
| " <rect id='target' transform='translate(100 100)' width='100' height='100'/>" |
| " </g>" |
| "</svg>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(200, 100), mappedPoint); |
| mappedPoint = mapAncestorToLocal(target, container, mappedPoint); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, SVGForeignObject) |
| { |
| setBodyInnerHTML( |
| "<svg id='container' viewBox='0 0 100 100' width='400' height='200'>" |
| " <g transform='translate(50 50)'>" |
| " <foreignObject transform='translate(-25 -25)'>" |
| " <div xmlns='http://www.w3.org/1999/xhtml' id='target' style='margin-left: 50px; border: 42px; padding: 84px; width: 50px; height: 50px'>" |
| " </div>" |
| " </foreignObject>" |
| " </g>" |
| "</svg>"); |
| |
| LayoutObject* target = getLayoutObjectByElementId("target"); |
| LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container")); |
| |
| FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint()); |
| EXPECT_EQ(FloatPoint(250, 50), mappedPoint); |
| // <svg> |
| mappedPoint = mapAncestorToLocal(target->parent()->parent()->parent(), container, FloatPoint(250, 50)); |
| EXPECT_EQ(FloatPoint(250, 50), mappedPoint); |
| // <g> |
| mappedPoint = mapAncestorToLocal(target->parent()->parent(), container, FloatPoint(250, 50)); |
| EXPECT_EQ(FloatPoint(25, -25), mappedPoint); |
| // <foreignObject> |
| mappedPoint = mapAncestorToLocal(target->parent(), container, FloatPoint(250, 50)); |
| EXPECT_EQ(FloatPoint(50, 0), mappedPoint); |
| // <div> |
| mappedPoint = mapAncestorToLocal(target, container, FloatPoint(250, 50)); |
| EXPECT_EQ(FloatPoint(), mappedPoint); |
| } |
| |
| TEST_F(MapCoordinatesTest, LocalToAbsoluteTransform) |
| { |
| setBodyInnerHTML( |
| "<div id='container' style='position: absolute; left: 0; top: 0;'>" |
| " <div id='scale' style='transform: scale(2.0); transform-origin: left top;'>" |
| " <div id='child'></div>" |
| " </div>" |
| "</div>"); |
| LayoutBoxModelObject* container = toLayoutBoxModelObject(getLayoutObjectByElementId("container")); |
| TransformationMatrix containerMatrix = container->localToAbsoluteTransform(); |
| EXPECT_TRUE(containerMatrix.isIdentity()); |
| |
| LayoutObject* child = getLayoutObjectByElementId("child"); |
| TransformationMatrix childMatrix = child->localToAbsoluteTransform(); |
| EXPECT_FALSE(childMatrix.isIdentityOrTranslation()); |
| EXPECT_TRUE(childMatrix.isAffine()); |
| EXPECT_EQ(0.0, childMatrix.projectPoint(FloatPoint(0.0, 0.0)).x()); |
| EXPECT_EQ(0.0, childMatrix.projectPoint(FloatPoint(0.0, 0.0)).y()); |
| EXPECT_EQ(20.0, childMatrix.projectPoint(FloatPoint(10.0, 20.0)).x()); |
| EXPECT_EQ(40.0, childMatrix.projectPoint(FloatPoint(10.0, 20.0)).y()); |
| } |
| |
| TEST_F(MapCoordinatesTest, LocalToAncestorTransform) |
| { |
| setBodyInnerHTML( |
| "<div id='container'>" |
| " <div id='rotate1' style='transform: rotate(45deg); transform-origin: left top;'>" |
| " <div id='rotate2' style='transform: rotate(90deg); transform-origin: left top;'>" |
| " <div id='child'></div>" |
| " </div>" |
| " </div>" |
| "</div>"); |
| LayoutBoxModelObject* container = toLayoutBoxModelObject(getLayoutObjectByElementId("container")); |
| LayoutBoxModelObject* rotate1 = toLayoutBoxModelObject(getLayoutObjectByElementId("rotate1")); |
| LayoutBoxModelObject* rotate2 = toLayoutBoxModelObject(getLayoutObjectByElementId("rotate2")); |
| LayoutObject* child = getLayoutObjectByElementId("child"); |
| TransformationMatrix matrix; |
| |
| matrix = child->localToAncestorTransform(rotate2); |
| EXPECT_TRUE(matrix.isIdentity()); |
| |
| // Rotate (100, 0) 90 degrees to (0, 100) |
| matrix = child->localToAncestorTransform(rotate1); |
| EXPECT_FALSE(matrix.isIdentity()); |
| EXPECT_TRUE(matrix.isAffine()); |
| EXPECT_NEAR(0.0, matrix.projectPoint(FloatPoint(100.0, 0.0)).x(), LayoutUnit::epsilon()); |
| EXPECT_NEAR(100.0, matrix.projectPoint(FloatPoint(100.0, 0.0)).y(), LayoutUnit::epsilon()); |
| |
| // Rotate (100, 0) 135 degrees to (-70.7, 70.7) |
| matrix = child->localToAncestorTransform(container); |
| EXPECT_FALSE(matrix.isIdentity()); |
| EXPECT_TRUE(matrix.isAffine()); |
| EXPECT_NEAR(-100.0 * sqrt(2.0) / 2.0, matrix.projectPoint(FloatPoint(100.0, 0.0)).x(), LayoutUnit::epsilon()); |
| EXPECT_NEAR(100.0 * sqrt(2.0) / 2.0, matrix.projectPoint(FloatPoint(100.0, 0.0)).y(), LayoutUnit::epsilon()); |
| } |
| |
| TEST_F(MapCoordinatesTest, LocalToAbsoluteTransformFlattens) |
| { |
| document().frame()->settings()->setAcceleratedCompositingEnabled(true); |
| setBodyInnerHTML( |
| "<div style='position: absolute; left: 0; top: 0;'>" |
| " <div style='transform: rotateY(45deg); -webkit-transform-style:preserve-3d;'>" |
| " <div style='transform: rotateY(-45deg); -webkit-transform-style:preserve-3d;'>" |
| " <div id='child1'></div>" |
| " </div>" |
| " </div>" |
| " <div style='transform: rotateY(45deg);'>" |
| " <div style='transform: rotateY(-45deg);'>" |
| " <div id='child2'></div>" |
| " </div>" |
| " </div>" |
| "</div>"); |
| LayoutObject* child1 = getLayoutObjectByElementId("child1"); |
| LayoutObject* child2 = getLayoutObjectByElementId("child2"); |
| TransformationMatrix matrix; |
| |
| matrix = child1->localToAbsoluteTransform(); |
| |
| // With child1, the rotations cancel and points should map basically back to themselves. |
| EXPECT_NEAR(100.0, matrix.projectPoint(FloatPoint(100.0, 50.0)).x(), LayoutUnit::epsilon()); |
| EXPECT_NEAR(50.0, matrix.projectPoint(FloatPoint(100.0, 50.0)).y(), LayoutUnit::epsilon()); |
| EXPECT_NEAR(50.0, matrix.projectPoint(FloatPoint(50.0, 100.0)).x(), LayoutUnit::epsilon()); |
| EXPECT_NEAR(100.0, matrix.projectPoint(FloatPoint(50.0, 100.0)).y(), LayoutUnit::epsilon()); |
| |
| // With child2, each rotation gets flattened and the end result is approximately a 90-degree rotation. |
| matrix = child2->localToAbsoluteTransform(); |
| EXPECT_NEAR(50.0, matrix.projectPoint(FloatPoint(100.0, 50.0)).x(), LayoutUnit::epsilon()); |
| EXPECT_NEAR(50.0, matrix.projectPoint(FloatPoint(100.0, 50.0)).y(), LayoutUnit::epsilon()); |
| EXPECT_NEAR(25.0, matrix.projectPoint(FloatPoint(50.0, 100.0)).x(), LayoutUnit::epsilon()); |
| EXPECT_NEAR(100.0, matrix.projectPoint(FloatPoint(50.0, 100.0)).y(), LayoutUnit::epsilon()); |
| } |
| |
| } // namespace blink |