Rename and change parameter type of some GeometryMapper methods

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 "platform/testing/RuntimeEnabledFeaturesTestHelpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
-class GeometryMapperTest : public ::testing::Test {
+class GeometryMapperTest : public ::testing::Test,
+                           public ScopedSlimmingPaintV2ForTest {
  public:
+  GeometryMapperTest() : ScopedSlimmingPaintV2ForTest(true) {}
+
   std::unique_ptr<GeometryMapper> geometryMapper;
 
   PropertyTreeState rootPropertyTreeState() {
     PropertyTreeState state(
         TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
         EffectPaintPropertyNode::root(), ScrollPaintPropertyNode::root());
     return state;
   }
 
   PrecomputedDataForAncestor& getPrecomputedDataForAncestor(
       const PropertyTreeState& propertyTreeState) {
-    return geometryMapper->getPrecomputedDataForAncestor(propertyTreeState);
+    return geometryMapper->getPrecomputedDataForAncestor(
+        propertyTreeState.transform());
   }
 
   const TransformPaintPropertyNode* leastCommonAncestor(
       const TransformPaintPropertyNode* a,
       const TransformPaintPropertyNode* b) {
     return GeometryMapper::leastCommonAncestor(a, b);
   }
 
  private:
   void SetUp() override {
@@ skipping 24 matching lines @@
         << ", 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(           \
+                   geometryMapper->localToAncestorVisualRect(                  \
                        inputRect, localPropertyTreeState,                      \
                        ancestorPropertyTreeState, success));                   \
     EXPECT_TRUE(success);                                                      \
     FloatRect mappedClip = geometryMapper->localToAncestorClipRect(            \
         localPropertyTreeState, ancestorPropertyTreeState, success);           \
     EXPECT_TRUE(success);                                                      \
     EXPECT_RECT_EQ(expectedClipInAncestorSpace, mappedClip);                   \
     EXPECT_RECT_EQ(expectedVisualRect,                                         \
-                   geometryMapper->mapToVisualRectInDestinationSpace(          \
+                   geometryMapper->sourceToDestinationVisualRect(              \
                        inputRect, localPropertyTreeState,                      \
                        ancestorPropertyTreeState, success));                   \
     EXPECT_TRUE(success);                                                      \
     EXPECT_RECT_EQ(expectedTransformedRect,                                    \
                    geometryMapper->localToAncestorRect(                        \
-                       inputRect, localPropertyTreeState,                      \
-                       ancestorPropertyTreeState, success));                   \
+                       inputRect, localPropertyTreeState.transform(),          \
+                       ancestorPropertyTreeState.transform(), success));       \
     EXPECT_RECT_EQ(expectedTransformedRect,                                    \
-                   geometryMapper->mapRectToDestinationSpace(                  \
-                       inputRect, localPropertyTreeState,                      \
-                       ancestorPropertyTreeState, success));                   \
+                   geometryMapper->sourceToDestinationRect(                    \
+                       inputRect, localPropertyTreeState.transform(),          \
+                       ancestorPropertyTreeState.transform(), success));       \
     EXPECT_TRUE(success);                                                      \
     if (ancestorPropertyTreeState.transform() !=                               \
         localPropertyTreeState.transform()) {                                  \
       EXPECT_EQ(                                                               \
           expectedTransformToAncestor,                                         \
           getPrecomputedDataForAncestor(ancestorPropertyTreeState)             \
               .toAncestorTransforms.get(localPropertyTreeState.transform()));  \
     }                                                                          \
     if (ancestorPropertyTreeState.clip() != localPropertyTreeState.clip()) {   \
       EXPECT_EQ(expectedClipInAncestorSpace,                                   \
@@ skipping 36 matching lines @@
   localState.setTransform(transform.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output = transformMatrix.mapRect(input);
 
   CHECK_MAPPINGS(input, output, output, transform->matrix(),
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
                  rootPropertyTreeState());
 
   bool success = false;
-  EXPECT_RECT_EQ(input,
-                 geometryMapper->ancestorToLocalRect(
-                     output, localState, rootPropertyTreeState(), success));
+  EXPECT_RECT_EQ(input, geometryMapper->ancestorToLocalRect(
+                            output, rootPropertyTreeState().transform(),
+                            localState.transform(), success));
   EXPECT_TRUE(success);
 }
 
 TEST_F(GeometryMapperTest, RotationAndScaleTransform) {
   TransformationMatrix transformMatrix;
   transformMatrix.rotate(45);
   transformMatrix.scale(2);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          transformMatrix,
@@ skipping 275 matching lines @@
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform2, FloatPoint3D());
 
   PropertyTreeState transform1State = rootPropertyTreeState();
   transform1State.setTransform(transform1.get());
   PropertyTreeState transform2State = rootPropertyTreeState();
   transform2State.setTransform(transform2.get());
 
   bool success;
   FloatRect input(0, 0, 100, 100);
-  FloatRect result = geometryMapper->localToVisualRectInAncestorSpace(
+  FloatRect result = geometryMapper->localToAncestorVisualRect(
       input, transform1State, transform2State, success);
   // Fails, because the transform2state is not an ancestor of transform1State.
   EXPECT_FALSE(success);
   EXPECT_RECT_EQ(input, result);
 
-  result = geometryMapper->localToAncestorRect(input, transform1State,
-                                               transform2State, success);
+  result = geometryMapper->localToAncestorRect(input, transform1.get(),
+                                               transform2.get(), 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);
+  result = geometryMapper->localToAncestorVisualRect(input, transform2State,
+                                                     transform1State, success);
   // Fails, because the transform1state is not an ancestor of transform2State.
   EXPECT_FALSE(success);
   EXPECT_RECT_EQ(input, result);
 
-  result = geometryMapper->localToAncestorRect(input, transform2State,
-                                               transform1State, success);
+  result = geometryMapper->localToAncestorRect(input, transform2.get(),
+                                               transform1.get(), 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(
+  result = geometryMapper->sourceToDestinationVisualRect(
       input, transform1State, transform2State, success);
   EXPECT_TRUE(success);
   EXPECT_RECT_EQ(expected, result);
 
-  result = geometryMapper->mapRectToDestinationSpace(input, transform1State,
-                                                     transform2State, success);
+  result = geometryMapper->sourceToDestinationRect(input, transform1.get(),
+                                                   transform2.get(), success);
   EXPECT_TRUE(success);
   EXPECT_RECT_EQ(expected, result);
 }
 
 TEST_F(GeometryMapperTest, SiblingTransformsWithClip) {
   // These transforms are siblings. Thus mapping from one to the other requires
   // going through the root.
   TransformationMatrix rotateTransform1;
   rotateTransform1.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
@@ skipping 16 matching lines @@
   transform2AndClipState.setTransform(transform2.get());
   transform2AndClipState.setClip(clip.get());
 
   bool success;
   FloatRect input(0, 0, 100, 100);
 
   // Test map from transform1State to transform2AndClipState.
   FloatRect expected =
       rotateTransform2.inverse().mapRect(rotateTransform1.mapRect(input));
 
-  // mapToVisualRectInDestinationSpace ignores clip from the common ancestor to
+  // sourceToDestinationVisualRect ignores clip from the common ancestor to
   // destination.
-  FloatRect result = geometryMapper->mapToVisualRectInDestinationSpace(
+  FloatRect result = geometryMapper->sourceToDestinationVisualRect(
       input, transform1State, transform2AndClipState, success);
   // Fails, because the clip of the destination state is not an ancestor of the
   // clip of the source state.
   EXPECT_FALSE(success);
 
-  // mapRectToDestinationSpace ignores clip.
-  result = geometryMapper->mapRectToDestinationSpace(
-      input, transform1State, transform2AndClipState, success);
+  // sourceToDestinationRect applies transforms only.
+  result = geometryMapper->sourceToDestinationRect(input, transform1.get(),
+                                                   transform2.get(), success);
   EXPECT_TRUE(success);
   EXPECT_RECT_EQ(expected, result);
 
   // Test map from transform2AndClipState to transform1State.
   FloatRect expectedUnclipped =
       rotateTransform1.inverse().mapRect(rotateTransform2.mapRect(input));
   FloatRect expectedClipped = rotateTransform1.inverse().mapRect(
       rotateTransform2.mapRect(FloatRect(10, 10, 70, 70)));
 
-  // mapToVisualRectInDestinationSpace ignores clip from the common ancestor to
+  // sourceToDestinationVisualRect ignores clip from the common ancestor to
   // destination.
-  result = geometryMapper->mapToVisualRectInDestinationSpace(
+  result = geometryMapper->sourceToDestinationVisualRect(
       input, transform2AndClipState, transform1State, success);
   EXPECT_TRUE(success);
   EXPECT_RECT_EQ(expectedClipped, result);
 
-  // mapRectToDestinationSpace ignores clip.
-  result = geometryMapper->mapRectToDestinationSpace(
-      input, transform2AndClipState, transform1State, success);
+  // sourceToDestinationRect applies transforms only.
+  result = geometryMapper->sourceToDestinationRect(input, transform2.get(),
+                                                   transform1.get(), success);
   EXPECT_TRUE(success);
   EXPECT_RECT_EQ(expectedUnclipped, result);
 }
 
 TEST_F(GeometryMapperTest, LeastCommonAncestor) {
   TransformationMatrix matrix;
   RefPtr<TransformPaintPropertyNode> child1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          matrix, FloatPoint3D());
   RefPtr<TransformPaintPropertyNode> child2 =
@@ skipping 21 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