GeometryMapper: Support computing visual rects in spaces that are not direct ancestors.

third_party/WebKit/Source/platform/graphics/paint/GeometryMapperTest.cpp

 // 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 "platform/graphics/paint/GeometryMapper.h"
 
 #include "platform/geometry/GeometryTestHelpers.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/graphics/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/EffectPaintPropertyNode.h"
 #include "platform/graphics/paint/TransformPaintPropertyNode.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
 class GeometryMapperTest : public ::testing::Test {
 public:
     RefPtr<TransformPaintPropertyNode> rootTransformNode;
     RefPtr<ClipPaintPropertyNode> rootClipNode;
     RefPtr<EffectPaintPropertyNode> rootEffectNode;
 
     std::unique_ptr<GeometryMapper> geometryMapper;
 
     PropertyTreeState rootPropertyTreeState()
     {
         PropertyTreeState state(rootTransformNode.get(), rootClipNode.get(), rootEffectNode.get());
         return state;
     }
 
-    PrecomputedDataForAncestor& GetPrecomputedDataForAncestor(const PropertyTreeState& propertyTreeState)
+    PrecomputedDataForAncestor& getPrecomputedDataForAncestor(const PropertyTreeState& propertyTreeState)
     {
-        return geometryMapper->GetPrecomputedDataForAncestor(propertyTreeState);
+        return geometryMapper->getPrecomputedDataForAncestor(propertyTreeState);
     }
 
+    PassRefPtr<TransformPaintPropertyNode> leastCommonAncestor(PassRefPtr<TransformPaintPropertyNode> a, PassRefPtr<TransformPaintPropertyNode> b)
+    {
+        return geometryMapper->leastCommonAncestor(a, b);
+    }
+

[pdr., 2016/06/30 21:21:50]

Nit: extra newline

[chrishtr, 2016/07/01 17:52:24]

Done.

+
 private:
     void SetUp() override
     {
         rootTransformNode = TransformPaintPropertyNode::create(TransformationMatrix(), FloatPoint3D(), nullptr);
         rootClipNode = ClipPaintPropertyNode::create(rootTransformNode, FloatRoundedRect(LayoutRect::infiniteIntRect()), nullptr);
         rootEffectNode = EffectPaintPropertyNode::create(1.0, nullptr);
         geometryMapper = wrapUnique(new GeometryMapper());
     }
 
     void TearDown() override
     {
         geometryMapper.reset();
     }
 };
 
 const static float kTestEpsilon = 1e-6;
 
 #define EXPECT_RECT_EQ(expected, actual) \
 do { \
     const FloatRect& actualRect = actual; \
     EXPECT_TRUE(GeometryTest::ApproximatelyEqual(expected.x(), actualRect.x(), kTestEpsilon)) << "actual: " << actualRect.x() << ", expected: " << expected.x(); \
     EXPECT_TRUE(GeometryTest::ApproximatelyEqual(expected.y(), actualRect.y(), kTestEpsilon)) << "actual: " << actualRect.y() << ", expected: " << expected.y(); \
     EXPECT_TRUE(GeometryTest::ApproximatelyEqual(expected.width(), actualRect.width(), kTestEpsilon)) << "actual: " << actualRect.width() << ", expected: " << expected.width(); \
     EXPECT_TRUE(GeometryTest::ApproximatelyEqual(expected.height(), actualRect.height(), kTestEpsilon)) << "actual: " << actualRect.height() << ", expected: " << expected.height(); \
 } while (false)
 
 #define CHECK_MAPPINGS(inputRect, expectedVisualRect, expectedTransformedRect, expectedTransformToAncestor, expectedClipInAncestorSpace, localPropertyTreeState, ancestorPropertyTreeState) \
 do { \
+    bool success = false; \
     EXPECT_RECT_EQ(expectedVisualRect, \
-        geometryMapper->LocalToVisualRectInAncestorSpace(inputRect, localPropertyTreeState, ancestorPropertyTreeState)); \
+        geometryMapper->localToVisualRectInAncestorSpace(inputRect, localPropertyTreeState, ancestorPropertyTreeState, &success)); \
+    EXPECT_TRUE(success); \
     EXPECT_RECT_EQ(expectedTransformedRect, \
-        geometryMapper->LocalToAncestorRect(inputRect, localPropertyTreeState, ancestorPropertyTreeState)); \
-    EXPECT_EQ(expectedTransformToAncestor, GetPrecomputedDataForAncestor(ancestorPropertyTreeState).toAncestorTransforms.get(localPropertyTreeState.transform)); \
-    EXPECT_EQ(expectedClipInAncestorSpace, GetPrecomputedDataForAncestor(ancestorPropertyTreeState).toAncestorClipRects.get(localPropertyTreeState.clip)); \
+        geometryMapper->localToAncestorRect(inputRect, localPropertyTreeState, ancestorPropertyTreeState, &success)); \
+    EXPECT_TRUE(success); \
+    EXPECT_EQ(expectedTransformToAncestor, getPrecomputedDataForAncestor(ancestorPropertyTreeState).toAncestorTransforms.get(localPropertyTreeState.transform.get())); \
+    EXPECT_EQ(expectedClipInAncestorSpace, getPrecomputedDataForAncestor(ancestorPropertyTreeState).toAncestorClipRects.get(localPropertyTreeState.clip.get())); \
 } while (false)
 
 TEST_F(GeometryMapperTest, Root)
 {
     FloatRect input(0, 0, 100, 100);
 
     CHECK_MAPPINGS(input, input, input, rootTransformNode->matrix(), rootClipNode->clipRect().rect(), rootPropertyTreeState(), rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, IdentityTransform)
@@ skipping 15 matching lines @@
     PropertyTreeState localState = rootPropertyTreeState();
     localState.transform = transform.get();
 
     FloatRect input(0, 0, 100, 100);
     FloatRect output = transformMatrix.mapRect(input);
 
     CHECK_MAPPINGS(input, output, output, transform->matrix(), rootClipNode->clipRect().rect(), localState, rootPropertyTreeState());
 
     bool success = false;
     EXPECT_RECT_EQ(input,
-        geometryMapper->AncestorToLocalRect(output, localState, rootPropertyTreeState(), &success));
+        geometryMapper->ancestorToLocalRect(output, localState, rootPropertyTreeState(), &success));
     EXPECT_TRUE(success);
 }
 
 TEST_F(GeometryMapperTest, RotationAndScaleTransform)
 {
     TransformationMatrix transformMatrix;
     transformMatrix.rotate(45);
     transformMatrix.scale(2);
     RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(transformMatrix, FloatPoint3D(0, 0, 0), rootPropertyTreeState().transform);
     PropertyTreeState localState = rootPropertyTreeState();
@@ skipping 34 matching lines @@
     PropertyTreeState localState = rootPropertyTreeState();
     localState.transform = transform2.get();
 
     FloatRect input(0, 0, 100, 100);
     TransformationMatrix final = rotateTransform * scaleTransform;
     FloatRect output = final.mapRect(input);
 
     CHECK_MAPPINGS(input, output, output, final, rootClipNode->clipRect().rect(), localState, rootPropertyTreeState());
 
     // Check the cached matrix for the intermediate transform.
-    EXPECT_EQ(rotateTransform, GetPrecomputedDataForAncestor(rootPropertyTreeState()).toAncestorTransforms.get(transform1.get()));
+    EXPECT_EQ(rotateTransform, getPrecomputedDataForAncestor(rootPropertyTreeState()).toAncestorTransforms.get(transform1.get()));
 }
 
 TEST_F(GeometryMapperTest, NestedTransformsIntermediateDestination)
 {
     TransformationMatrix rotateTransform;
     rotateTransform.rotate(45);
     RefPtr<TransformPaintPropertyNode> transform1 = TransformPaintPropertyNode::create(rotateTransform, FloatPoint3D(), rootPropertyTreeState().transform);
 
     TransformationMatrix scaleTransform;
     scaleTransform.scale(2);
@@ skipping 132 matching lines @@
         CHECK_MAPPINGS(
             input, // Input
             output, // Visual rect
             rotateTransform.mapRect(input), // Transformed rect (not clipped)
             rotateTransform, // Transform matrix to ancestor space
             mappedClip, // Clip rect in ancestor space
             localState, rootPropertyTreeState());
     }
 }
 
+TEST_F(GeometryMapperTest, SiblingTransforms)
+{
+    // These transforms are siblings. Thus mapping from one to the other requires going through the root.
+    TransformationMatrix rotateTransform1;
+    rotateTransform1.rotate(45);
+    RefPtr<TransformPaintPropertyNode> transform1 = TransformPaintPropertyNode::create(rotateTransform1, FloatPoint3D(), rootPropertyTreeState().transform);
+
+    TransformationMatrix rotateTransform2;
+    rotateTransform2.rotate(-45);
+    RefPtr<TransformPaintPropertyNode> transform2 = TransformPaintPropertyNode::create(rotateTransform2, FloatPoint3D(), rootPropertyTreeState().transform);
+
+    PropertyTreeState transform1State = rootPropertyTreeState();
+    transform1State.transform = transform1;
+    PropertyTreeState transform2State = rootPropertyTreeState();
+    transform2State.transform = transform2;
+
+    bool success;
+    FloatRect input(0, 0, 100, 100);
+    FloatRect result = geometryMapper->localToVisualRectInAncestorSpace(input, transform1State, transform2State, &success);
+    // Fails, because the transform2state is not an ancestor of transform1State.
+    EXPECT_FALSE(success);
+    EXPECT_RECT_EQ(input, result);
+
+    result = geometryMapper->localToVisualRectInAncestorSpace(input, transform2State, transform1State, &success);
+    // Fails, because the transform1state is not an ancestor of transform2State.
+    EXPECT_FALSE(success);
+    EXPECT_RECT_EQ(input, result);
+
+    FloatRect expected = rotateTransform2.inverse().mapRect(rotateTransform1.mapRect(input));
+    result = geometryMapper->mapToVisualRectInDestinationSpace(input, transform1State, transform2State, &success);
+    EXPECT_TRUE(success);
+    EXPECT_RECT_EQ(expected, result);

[pdr., 2016/06/30 21:21:50]

Can you use real numbers for this test? Maybe transform1 = rotate(90) and
transform2 = rotate(-180), then verify the rect is transformed by -90deg?

+}
+
+TEST_F(GeometryMapperTest, LeastCommonAncestor)
+{
+    TransformationMatrix matrix;
+    RefPtr<TransformPaintPropertyNode> child1 = TransformPaintPropertyNode::create(matrix, FloatPoint3D(), rootPropertyTreeState().transform);
+    RefPtr<TransformPaintPropertyNode> child2 = TransformPaintPropertyNode::create(matrix, FloatPoint3D(), rootPropertyTreeState().transform);
+
+    RefPtr<TransformPaintPropertyNode> childOfChild1 = TransformPaintPropertyNode::create(matrix, FloatPoint3D(), child1);
+    RefPtr<TransformPaintPropertyNode> childOfChild2 = TransformPaintPropertyNode::create(matrix, FloatPoint3D(), child2);
+
+    EXPECT_EQ(rootPropertyTreeState().transform, leastCommonAncestor(childOfChild1, childOfChild2));
+    EXPECT_EQ(rootPropertyTreeState().transform, leastCommonAncestor(childOfChild1, child2));
+    EXPECT_EQ(rootPropertyTreeState().transform, leastCommonAncestor(childOfChild1, rootPropertyTreeState().transform));
+    EXPECT_EQ(child1, leastCommonAncestor(childOfChild1, child1));
+
+    EXPECT_EQ(rootPropertyTreeState().transform, leastCommonAncestor(childOfChild2, childOfChild1));
+    EXPECT_EQ(rootPropertyTreeState().transform, leastCommonAncestor(childOfChild2, child1));
+    EXPECT_EQ(rootPropertyTreeState().transform, leastCommonAncestor(childOfChild2, rootPropertyTreeState().transform));
+    EXPECT_EQ(child2, leastCommonAncestor(childOfChild2, child2));
+
+    EXPECT_EQ(rootPropertyTreeState().transform, leastCommonAncestor(child1, child2));
+}
+
 } // namespace blink