Reuse existing paint property node is possible

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"
@@ skipping 17 matching lines @@
     }
 
     PrecomputedDataForAncestor& getPrecomputedDataForAncestor(const PropertyTreeState& propertyTreeState)
     {
         return geometryMapper->getPrecomputedDataForAncestor(propertyTreeState);
     }
 
 private:
     void SetUp() override
     {
-        rootTransformNode = TransformPaintPropertyNode::create(TransformationMatrix(), FloatPoint3D(), nullptr);
-        rootClipNode = ClipPaintPropertyNode::create(rootTransformNode, FloatRoundedRect(LayoutRect::infiniteIntRect()), nullptr);
-        rootEffectNode = EffectPaintPropertyNode::create(1.0, nullptr);
+        rootTransformNode = TransformPaintPropertyNode::create(nullptr, TransformationMatrix(), FloatPoint3D());
+        rootClipNode = ClipPaintPropertyNode::create(nullptr, rootTransformNode, FloatRoundedRect(LayoutRect::infiniteIntRect()));
+        rootEffectNode = EffectPaintPropertyNode::create(nullptr, 1.0);
         geometryMapper = wrapUnique(new GeometryMapper());
     }
 
     void TearDown() override
     {
         geometryMapper.reset();
     }
 };
 
 const static float kTestEpsilon = 1e-6;
@@ skipping 22 matching lines @@
 
 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)
 {
-    RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(TransformationMatrix(), FloatPoint3D(), rootPropertyTreeState().transform);
+    RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(rootPropertyTreeState().transform, TransformationMatrix(), FloatPoint3D());
     PropertyTreeState localState = rootPropertyTreeState();
     localState.transform = transform.get();
 
     FloatRect input(0, 0, 100, 100);
 
     CHECK_MAPPINGS(input, input, input, transform->matrix(), rootClipNode->clipRect().rect(), localState, rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, TranslationTransform)
 {
     TransformationMatrix transformMatrix;
     transformMatrix.translate(20, 10);
-    RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(transformMatrix, FloatPoint3D(), rootPropertyTreeState().transform);
+    RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(rootPropertyTreeState().transform, transformMatrix, FloatPoint3D());
     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));
     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);
+    RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(rootPropertyTreeState().transform, transformMatrix, FloatPoint3D(0, 0, 0));
     PropertyTreeState localState = rootPropertyTreeState();
     localState.transform = transform.get();
 
     FloatRect input(0, 0, 100, 100);
     FloatRect output = transformMatrix.mapRect(input);
 
     CHECK_MAPPINGS(input, output, output, transformMatrix, rootClipNode->clipRect().rect(), localState, rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, RotationAndScaleTransformWithTransformOrigin)
 {
     TransformationMatrix transformMatrix;
     transformMatrix.rotate(45);
     transformMatrix.scale(2);
-    RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(transformMatrix, FloatPoint3D(50, 50, 0), rootPropertyTreeState().transform);
+    RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(rootPropertyTreeState().transform, transformMatrix, FloatPoint3D(50, 50, 0));
     PropertyTreeState localState = rootPropertyTreeState();
     localState.transform = transform.get();
 
     FloatRect input(0, 0, 100, 100);
     transformMatrix.applyTransformOrigin(50, 50, 0);
     FloatRect output = transformMatrix.mapRect(input);
 
     CHECK_MAPPINGS(input, output, output, transformMatrix, rootClipNode->clipRect().rect(), localState, rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, NestedTransforms)
 {
     TransformationMatrix rotateTransform;
     rotateTransform.rotate(45);
-    RefPtr<TransformPaintPropertyNode> transform1 = TransformPaintPropertyNode::create(rotateTransform, FloatPoint3D(), rootPropertyTreeState().transform);
+    RefPtr<TransformPaintPropertyNode> transform1 = TransformPaintPropertyNode::create(rootPropertyTreeState().transform, rotateTransform, FloatPoint3D());
 
     TransformationMatrix scaleTransform;
     scaleTransform.scale(2);
-    RefPtr<TransformPaintPropertyNode> transform2 = TransformPaintPropertyNode::create(scaleTransform, FloatPoint3D(), transform1);
+    RefPtr<TransformPaintPropertyNode> transform2 = TransformPaintPropertyNode::create(transform1, scaleTransform, FloatPoint3D());
 
     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()));
 }
 
 TEST_F(GeometryMapperTest, NestedTransformsIntermediateDestination)
 {
     TransformationMatrix rotateTransform;
     rotateTransform.rotate(45);
-    RefPtr<TransformPaintPropertyNode> transform1 = TransformPaintPropertyNode::create(rotateTransform, FloatPoint3D(), rootPropertyTreeState().transform);
+    RefPtr<TransformPaintPropertyNode> transform1 = TransformPaintPropertyNode::create(rootPropertyTreeState().transform, rotateTransform, FloatPoint3D());
 
     TransformationMatrix scaleTransform;
     scaleTransform.scale(2);
-    RefPtr<TransformPaintPropertyNode> transform2 = TransformPaintPropertyNode::create(scaleTransform, FloatPoint3D(), transform1);
+    RefPtr<TransformPaintPropertyNode> transform2 = TransformPaintPropertyNode::create(transform1, scaleTransform, FloatPoint3D());
 
     PropertyTreeState localState = rootPropertyTreeState();
     localState.transform = transform2.get();
 
     PropertyTreeState intermediateState = rootPropertyTreeState();
     intermediateState.transform = transform1.get();
 
     FloatRect input(0, 0, 100, 100);
     FloatRect output = scaleTransform.mapRect(input);
 
     CHECK_MAPPINGS(input, output, output, scaleTransform, rootClipNode->clipRect().rect(), localState, intermediateState);
 }
 
 TEST_F(GeometryMapperTest, SimpleClip)
 {
-    RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(rootTransformNode, FloatRoundedRect(10, 10, 50, 50), rootClipNode);
+    RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(rootClipNode, rootTransformNode, FloatRoundedRect(10, 10, 50, 50));
 
     PropertyTreeState localState = rootPropertyTreeState();
     localState.clip = clip.get();
 
     FloatRect input(0, 0, 100, 100);
     FloatRect output(10, 10, 50, 50);
 
     CHECK_MAPPINGS(
         input, // Input
         output, // Visual rect
         input, // Transformed rect (not clipped).
         rootTransformNode->matrix(), // Transform matrix to ancestor space
         clip->clipRect().rect(), // Clip rect in ancestor space
         localState, rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, ClipBeforeTransform)
 {
     TransformationMatrix rotateTransform;
     rotateTransform.rotate(45);
-    RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(rotateTransform, FloatPoint3D(), rootPropertyTreeState().transform);
+    RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(rootPropertyTreeState().transform, rotateTransform, FloatPoint3D());
 
-    RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(transform.get(), FloatRoundedRect(10, 10, 50, 50), rootClipNode);
+    RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(rootClipNode, transform.get(), FloatRoundedRect(10, 10, 50, 50));
 
     PropertyTreeState localState = rootPropertyTreeState();
     localState.clip = clip.get();
     localState.transform = transform.get();
 
     FloatRect input(0, 0, 100, 100);
     FloatRect output(input);
     output.intersect(clip->clipRect().rect());
     output = rotateTransform.mapRect(output);
 
     CHECK_MAPPINGS(
         input, // Input
         output, // Visual rect
         rotateTransform.mapRect(input), // Transformed rect (not clipped).
         rotateTransform, // Transform matrix to ancestor space
         rotateTransform.mapRect(clip->clipRect().rect()), // Clip rect in ancestor space
         localState, rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, ClipAfterTransform)
 {
     TransformationMatrix rotateTransform;
     rotateTransform.rotate(45);
-    RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(rotateTransform, FloatPoint3D(), rootPropertyTreeState().transform);
+    RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(rootPropertyTreeState().transform, rotateTransform, FloatPoint3D());
 
-    RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(rootTransformNode.get(), FloatRoundedRect(10, 10, 200, 200), rootClipNode);
+    RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(rootClipNode, rootTransformNode.get(), FloatRoundedRect(10, 10, 200, 200));
 
     PropertyTreeState localState = rootPropertyTreeState();
     localState.clip = clip.get();
     localState.transform = transform.get();
 
     FloatRect input(0, 0, 100, 100);
     FloatRect output(input);
     output = rotateTransform.mapRect(output);
     output.intersect(clip->clipRect().rect());
 
     CHECK_MAPPINGS(
         input, // Input
         output, // Visual rect
         rotateTransform.mapRect(input), // Transformed rect (not clipped)
         rotateTransform, // Transform matrix to ancestor space
         clip->clipRect().rect(), // Clip rect in ancestor space
         localState, rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, TwoClipsWithTransformBetween)
 {
-    RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(rootTransformNode.get(), FloatRoundedRect(10, 10, 200, 200), rootClipNode);
+    RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(rootClipNode, rootTransformNode.get(), FloatRoundedRect(10, 10, 200, 200));
 
     TransformationMatrix rotateTransform;
     rotateTransform.rotate(45);
-    RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(rotateTransform, FloatPoint3D(), rootPropertyTreeState().transform);
+    RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(rootPropertyTreeState().transform, rotateTransform, FloatPoint3D());
 
-    RefPtr<ClipPaintPropertyNode> clip2 = ClipPaintPropertyNode::create(transform.get(), FloatRoundedRect(10, 10, 200, 200), clip1.get());
+    RefPtr<ClipPaintPropertyNode> clip2 = ClipPaintPropertyNode::create(clip1, transform.get(), FloatRoundedRect(10, 10, 200, 200));
 
     FloatRect input(0, 0, 100, 100);
 
     {
         PropertyTreeState localState = rootPropertyTreeState();
         localState.clip = clip1.get();
         localState.transform = transform.get();
 
         FloatRect output(input);
         output = rotateTransform.mapRect(output);
@@ skipping 33 matching lines @@
             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);
+    RefPtr<TransformPaintPropertyNode> transform1 = TransformPaintPropertyNode::create(rootPropertyTreeState().transform, rotateTransform1, FloatPoint3D());
 
     TransformationMatrix rotateTransform2;
     rotateTransform2.rotate(-45);
-    RefPtr<TransformPaintPropertyNode> transform2 = TransformPaintPropertyNode::create(rotateTransform2, FloatPoint3D(), rootPropertyTreeState().transform);
+    RefPtr<TransformPaintPropertyNode> transform2 = TransformPaintPropertyNode::create(rootPropertyTreeState().transform, rotateTransform2, FloatPoint3D());
 
     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);
 }
 
 } // namespace blink