[SPv2] Add createOpacityOnlyEffect test helper

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/ScrollPaintPropertyNode.h"
 #include "platform/graphics/paint/TransformPaintPropertyNode.h"
+#include "platform/testing/PaintPropertyTestHelpers.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;
-  RefPtr<ScrollPaintPropertyNode> rootScrollNode;
-
   std::unique_ptr<GeometryMapper> geometryMapper;
 
   PropertyTreeState rootPropertyTreeState() {
-    PropertyTreeState state(rootTransformNode.get(), rootClipNode.get(),
-                            rootEffectNode.get(), rootScrollNode.get());
+    PropertyTreeState state(
+        TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+        EffectPaintPropertyNode::root(), ScrollPaintPropertyNode::root());
     return state;
   }
 
   PrecomputedDataForAncestor& getPrecomputedDataForAncestor(
       const PropertyTreeState& propertyTreeState) {
     return geometryMapper->getPrecomputedDataForAncestor(propertyTreeState);
   }
 
   const TransformPaintPropertyNode* leastCommonAncestor(
       const TransformPaintPropertyNode* a,
       const TransformPaintPropertyNode* b) {
     return GeometryMapper::leastCommonAncestor(a, b);
   }
 
  private:
   void SetUp() override {
-    rootTransformNode = TransformPaintPropertyNode::create(
-        nullptr, TransformationMatrix(), FloatPoint3D());
-    rootClipNode = ClipPaintPropertyNode::create(
-        nullptr, rootTransformNode,
-        FloatRoundedRect(LayoutRect::infiniteIntRect()));
-    rootEffectNode = EffectPaintPropertyNode::create(
-        nullptr, rootTransformNode, rootClipNode, CompositorFilterOperations(),
-        1.0);
-    rootScrollNode = ScrollPaintPropertyNode::create(
-        nullptr, rootTransformNode, IntSize(), IntSize(), false, false, 0);
     geometryMapper = WTF::makeUnique<GeometryMapper>();
   }
 
   void TearDown() override { geometryMapper.reset(); }
 };
 
 const static float kTestEpsilon = 1e-6;
 
 #define EXPECT_RECT_EQ(expected, actual)                                       \
   do {                                                                         \
@@ skipping 44 matching lines @@
         getPrecomputedDataForAncestor(ancestorPropertyTreeState)               \
             .toAncestorTransforms.get(localPropertyTreeState.transform()));    \
     EXPECT_EQ(expectedClipInAncestorSpace,                                     \
               getPrecomputedDataForAncestor(ancestorPropertyTreeState)         \
                   .toAncestorClipRects.get(localPropertyTreeState.clip()));    \
   } while (false)
 
 TEST_F(GeometryMapperTest, Root) {
   FloatRect input(0, 0, 100, 100);
 
-  CHECK_MAPPINGS(input, input, input, rootTransformNode->matrix(),
-                 rootClipNode->clipRect().rect(), rootPropertyTreeState(),
-                 rootPropertyTreeState());
+  CHECK_MAPPINGS(input, input, input,
+                 TransformPaintPropertyNode::root()->matrix(),
+                 ClipPaintPropertyNode::root()->clipRect().rect(),
+                 rootPropertyTreeState(), rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, IdentityTransform) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          TransformationMatrix(),
                                          FloatPoint3D());
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform.get());
 
   FloatRect input(0, 0, 100, 100);
 
   CHECK_MAPPINGS(input, input, input, transform->matrix(),
-                 rootClipNode->clipRect().rect(), localState,
+                 ClipPaintPropertyNode::root()->clipRect().rect(), localState,
                  rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, TranslationTransform) {
   TransformationMatrix transformMatrix;
   transformMatrix.translate(20, 10);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          transformMatrix, FloatPoint3D());
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output = transformMatrix.mapRect(input);
 
   CHECK_MAPPINGS(input, output, output, transform->matrix(),
-                 rootClipNode->clipRect().rect(), localState,
+                 ClipPaintPropertyNode::root()->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(rootPropertyTreeState().transform(),
                                          transformMatrix,
                                          FloatPoint3D(0, 0, 0));
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output = transformMatrix.mapRect(input);
 
   CHECK_MAPPINGS(input, output, output, transformMatrix,
-                 rootClipNode->clipRect().rect(), localState,
+                 ClipPaintPropertyNode::root()->clipRect().rect(), localState,
                  rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, RotationAndScaleTransformWithTransformOrigin) {
   TransformationMatrix transformMatrix;
   transformMatrix.rotate(45);
   transformMatrix.scale(2);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          transformMatrix,
                                          FloatPoint3D(50, 50, 0));
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(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,
+                 ClipPaintPropertyNode::root()->clipRect().rect(), localState,
                  rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, NestedTransforms) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   TransformationMatrix scaleTransform;
   scaleTransform.scale(2);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(transform1, scaleTransform,
                                          FloatPoint3D());
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(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_MAPPINGS(input, output, output, final,
+                 ClipPaintPropertyNode::root()->clipRect().rect(), localState,
+                 rootPropertyTreeState());
 
   // Check the cached matrix for the intermediate transform.
   EXPECT_EQ(rotateTransform,
             getPrecomputedDataForAncestor(rootPropertyTreeState())
                 .toAncestorTransforms.get(transform1.get()));
 }
 
 TEST_F(GeometryMapperTest, NestedTransformsScaleAndTranslation) {
   TransformationMatrix scaleTransform;
   scaleTransform.scale(2);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          scaleTransform, FloatPoint3D());
 
   TransformationMatrix translateTransform;
   translateTransform.translate(100, 0);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(transform1, translateTransform,
                                          FloatPoint3D());
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform2.get());
 
   FloatRect input(0, 0, 100, 100);
   // Note: unlike NestedTransforms, the order of these transforms matters. This
   // tests correct order of matrix multiplication.
   TransformationMatrix final = scaleTransform * translateTransform;
   FloatRect output = final.mapRect(input);
 
-  CHECK_MAPPINGS(input, output, output, final, rootClipNode->clipRect().rect(),
-                 localState, rootPropertyTreeState());
+  CHECK_MAPPINGS(input, output, output, final,
+                 ClipPaintPropertyNode::root()->clipRect().rect(), localState,
+                 rootPropertyTreeState());
 
   // Check the cached matrix for the intermediate transform.
   EXPECT_EQ(scaleTransform,
             getPrecomputedDataForAncestor(rootPropertyTreeState())
                 .toAncestorTransforms.get(transform1.get()));
 }
 
 TEST_F(GeometryMapperTest, NestedTransformsIntermediateDestination) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
@@ skipping 10 matching lines @@
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform2.get());
 
   PropertyTreeState intermediateState = rootPropertyTreeState();
   intermediateState.setTransform(transform1.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output = scaleTransform.mapRect(input);
 
   CHECK_MAPPINGS(input, output, output, scaleTransform,
-                 rootClipNode->clipRect().rect(), localState,
+                 ClipPaintPropertyNode::root()->clipRect().rect(), localState,
                  intermediateState);
 }
 
 TEST_F(GeometryMapperTest, SimpleClip) {
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
-      rootClipNode, rootTransformNode, FloatRoundedRect(10, 10, 50, 50));
+      ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
+      FloatRoundedRect(10, 10, 50, 50));
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setClip(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());
+  CHECK_MAPPINGS(input,   // Input
+                 output,  // Visual rect
+                 input,   // Transformed rect (not clipped).
+                 TransformPaintPropertyNode::root()
+                     ->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(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
-      rootClipNode, transform.get(), FloatRoundedRect(10, 10, 50, 50));
+      ClipPaintPropertyNode::root(), transform.get(),
+      FloatRoundedRect(10, 10, 50, 50));
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setClip(clip.get());
   localState.setTransform(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(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
-  RefPtr<ClipPaintPropertyNode> clip =
-      ClipPaintPropertyNode::create(rootClipNode, rootTransformNode.get(),
-                                    FloatRoundedRect(10, 10, 200, 200));
+  RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
+      ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
+      FloatRoundedRect(10, 10, 200, 200));
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setClip(clip.get());
   localState.setTransform(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(rootClipNode, rootTransformNode.get(),
-                                    FloatRoundedRect(10, 10, 200, 200));
+  RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(
+      ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
+      FloatRoundedRect(10, 10, 200, 200));
 
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   RefPtr<ClipPaintPropertyNode> clip2 = ClipPaintPropertyNode::create(
       clip1, transform.get(), FloatRoundedRect(10, 10, 200, 200));
 
@@ skipping 199 matching lines @@
   EXPECT_EQ(rootPropertyTreeState().transform(),
             leastCommonAncestor(childOfChild2.get(),
                                 rootPropertyTreeState().transform()));
   EXPECT_EQ(child2, leastCommonAncestor(childOfChild2.get(), child2.get()));
 
   EXPECT_EQ(rootPropertyTreeState().transform(),
             leastCommonAncestor(child1.get(), child2.get()));
 }
 
 }  // namespace blink