Rename, simplify and change parameter type of some GeometryMapper methods

Rename
mapRectToDestinationSpace to sourceToDestinationRect
mapToVisualRectInDestinationSpace to sourceToDestinationVisualRect
localToVisualRectInAncestorSpace to localToAncestorVisualRect
so that all mapping methods are in the form
  (local|source|ancestor)To(local|source|ancestor)(Rect|VisualRect|Matrix|ClipRect)

Changed parameters to localToAncestorMatrix and getPrecomputedDataForAncestor()
from const PropertyTreeState& to const TransformPaintPropertyNode*
because some later changes will require the new form (
TransformationPaintPropertyNode without a state).

Simplified localToAncestorMatrix and localToAncestorClipRect because
we have early returns when the local node is the same as the ancestor
node and we no longer need to handle that condition in the loop.

CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2

Review-Url: https://codereview.chromium.org/2623823002
Cr-Commit-Position: refs/heads/master@{#443436}

third_party/WebKit/Source/core/paint/PaintInvalidator.cpp

@@ -110,7 +110,7 @@ static LayoutRect mapLocalRectToPaintInvalidationBacking(
         containerPaintProperties->contentsProperties();
 
     bool success = false;
-    result = LayoutRect(geometryMapper.mapToVisualRectInDestinationSpace(
+    result = LayoutRect(geometryMapper.sourceToDestinationVisualRect(
         rect, currentTreeState, containerContentsProperties, success));
     DCHECK(success);
 
@@ -166,11 +166,6 @@ LayoutPoint PaintInvalidator::computeLocationInBacking(
   if (object != context.paintInvalidationContainer) {
     point.moveBy(FloatPoint(object.paintOffset()));
 
-    PropertyTreeState currentTreeState(
-        context.treeBuilderContext.current.transform,
-        context.treeBuilderContext.current.clip,
-        context.treeBuilderContext.currentEffect,
-        context.treeBuilderContext.current.scroll);
     const auto* containerPaintProperties =
         context.paintInvalidationContainer->paintProperties();
     auto containerContentsProperties =
@@ -178,9 +173,10 @@ LayoutPoint PaintInvalidator::computeLocationInBacking(
 
     bool success = false;
     point = m_geometryMapper
-                .mapRectToDestinationSpace(FloatRect(point, FloatSize()),
-                                           currentTreeState,
-                                           containerContentsProperties, success)
+                .sourceToDestinationRect(
+                    FloatRect(point, FloatSize()),
+                    context.treeBuilderContext.current.transform,
+                    containerContentsProperties.transform(), success)
                 .location();
     DCHECK(success);
 

third_party/WebKit/Source/core/paint/PaintLayerClipper.cpp

@@ -216,15 +216,18 @@ LayoutRect PaintLayerClipper::localClipRect(
     // The rect now needs to be transformed to the local space of this
     // PaintLayer.
     bool success = false;
-    FloatRect clippedRectInLocalSpace =
-        m_geometryMapper->mapRectToDestinationSpace(
-            FloatRect(clipRect.rect()), *clippingRootLayer->layoutObject()
+    const auto* clipRootLayerTransform = clippingRootLayer->layoutObject()
                                              ->paintProperties()
-                                             ->localBorderBoxProperties(),
-            *m_layer.layoutObject()
-                 ->paintProperties()
-                 ->localBorderBoxProperties(),
-            success);
+                                             ->localBorderBoxProperties()
+                                             ->transform();
+    const auto* layerTransform = m_layer.layoutObject()
+                                     ->paintProperties()
+                                     ->localBorderBoxProperties()
+                                     ->transform();
+    FloatRect clippedRectInLocalSpace =
+        m_geometryMapper->sourceToDestinationRect(FloatRect(clipRect.rect()),
+                                                  clipRootLayerTransform,
+                                                  layerTransform, success);
     DCHECK(success);
 
     return LayoutRect(clippedRectInLocalSpace);
@@ -259,16 +262,19 @@ void PaintLayerClipper::mapLocalToRootWithGeometryMapper(
   DCHECK(m_geometryMapper);
   bool success;
 
-  const auto* layerBorderBoxProperties =
-      m_layer.layoutObject()->paintProperties()->localBorderBoxProperties();
+  const auto* layerTransform = m_layer.layoutObject()
+                                   ->paintProperties()
+                                   ->localBorderBoxProperties()
+                                   ->transform();
+  const auto* rootTransform = context.rootLayer->layoutObject()
+                                  ->paintProperties()
+                                  ->localBorderBoxProperties()
+                                  ->transform();
+
   FloatRect localRect(layoutRect);
   localRect.moveBy(FloatPoint(m_layer.layoutObject()->paintOffset()));
-
-  layoutRect = LayoutRect(m_geometryMapper->mapRectToDestinationSpace(
-      localRect, *layerBorderBoxProperties, *context.rootLayer->layoutObject()
-                                                 ->paintProperties()
-                                                 ->localBorderBoxProperties(),
-      success));
+  layoutRect = LayoutRect(m_geometryMapper->sourceToDestinationRect(
+      localRect, layerTransform, rootTransform, success));
   DCHECK(success);
 }
 
@@ -452,7 +458,7 @@ ClipRect PaintLayerClipper::clipRectWithGeometryMapper(
       destinationPropertyTreeState.setClip(ancestorProperties->overflowClip());
   }
   FloatRect clippedRectInRootLayerSpace =
-      m_geometryMapper->mapToVisualRectInDestinationSpace(
+      m_geometryMapper->sourceToDestinationVisualRect(
           FloatRect(source), propertyTreeState, destinationPropertyTreeState,
           success);
   DCHECK(success);

third_party/WebKit/Source/core/paint/PaintPropertyTreeBuilderTest.cpp

@@ -80,7 +80,7 @@ void PaintPropertyTreeBuilderTest::TearDown() {
     auto contentsProperties =                                                  \
         (ancestorLayoutObject)->paintProperties()->contentsProperties();       \
     LayoutRect actual =                                                        \
-        LayoutRect(geometryMapper.mapToVisualRectInDestinationSpace(           \
+        LayoutRect(geometryMapper.sourceToDestinationVisualRect(               \
             FloatRect(source), *(sourceLayoutObject)                           \
                                     ->paintProperties()                        \
                                     ->localBorderBoxProperties(),              \

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositor.cpp

@@ -286,8 +286,8 @@ static void applyClipsBetweenStates(const PropertyTreeState& localState,
   if (transformNode != ancestorState.transform()) {
     bool success = false;
     const TransformationMatrix& localToAncestorMatrix =
-        geometryMapper.localToAncestorMatrix(transformNode, ancestorState,
-                                             success);
+        geometryMapper.localToAncestorMatrix(
+            transformNode, ancestorState.transform(), success);
     DCHECK(success);
     // Clips are only in descendant spaces that are transformed by one
     // or more scrolls.
@@ -373,8 +373,8 @@ static void recordPairedBeginDisplayItems(
           const TransformPaintPropertyNode* transformNode =
               pairedState->effect()->localTransformSpace();
           const TransformationMatrix& localToAncestorMatrix =
-              geometryMapper.localToAncestorMatrix(transformNode, *pairedState,
-                                                   success);
+              geometryMapper.localToAncestorMatrix(
+                  transformNode, pairedState->transform(), success);
           DCHECK(success);
           // Effects are only in descendant spaces that are transformed by one
           // or more scrolls.
@@ -1084,14 +1084,14 @@ bool PaintArtifactCompositor::mightOverlap(
 
   bool success = false;
   FloatRect paintChunkScreenVisualRect =
-      geometryMapper.localToVisualRectInAncestorSpace(
+      geometryMapper.localToAncestorVisualRect(
           paintChunk.bounds, paintChunk.properties.propertyTreeState,
           rootPropertyTreeState, success);
   DCHECK(success);
 
   success = false;
   FloatRect pendingLayerScreenVisualRect =
-      geometryMapper.localToVisualRectInAncestorSpace(
+      geometryMapper.localToAncestorVisualRect(
           candidatePendingLayer.bounds, candidatePendingLayer.propertyTreeState,
           rootPropertyTreeState, success);
   DCHECK(success);
@@ -1117,8 +1117,8 @@ void PaintArtifactCompositor::PendingLayer::add(
   if (geometryMapper) {
     bool success = false;
     mappedBounds = geometryMapper->localToAncestorRect(
-        mappedBounds, paintChunk.properties.propertyTreeState,
-        propertyTreeState, success);
+        mappedBounds, paintChunk.properties.propertyTreeState.transform(),
+        propertyTreeState.transform(), success);
     DCHECK(success);
   }
   bounds.unite(mappedBounds);

third_party/WebKit/Source/platform/graphics/paint/GeometryMapper.h

@@ -45,14 +45,14 @@ struct PrecomputedDataForAncestor {
 class PLATFORM_EXPORT GeometryMapper {
  public:
   GeometryMapper() {}
-  // The runtime of m calls among localToVisualRectInAncestorSpace,
-  // localToAncestorRect or ancestorToLocalRect with the same |ancestorState|
-  // parameter is guaranteed to be O(n + m), where n is the number of transform
-  // and clip nodes in their respective property trees.
+  // The runtime of m calls among localToAncestorVisualRect, localToAncestorRect
+  // or ancestorToLocalRect with the same |ancestorState| parameter is
+  // guaranteed to be O(n + m), where n is the number of transform and clip
+  // nodes in their respective property trees.
 
   // If the clips and transforms of |sourceState| are equal to or descendants of
   // those of |destinationState|, returns the same value as
-  // localToVisualRectInAncestorSpace. Otherwise, maps the input rect to the
+  // localToAncestorVisualRect. Otherwise, maps the input rect to the
   // transform state which is the least common ancestor of
   // |sourceState.transform| and |destinationState.transform|, then multiplies
   // it by the the inverse transform mapping from the least common ancestor to
@@ -60,18 +60,19 @@ class PLATFORM_EXPORT GeometryMapper {
   //
   // Sets |success| to whether that inverse transform is invertible. If it is
   // not, returns the input rect.
-  FloatRect mapToVisualRectInDestinationSpace(
+  FloatRect sourceToDestinationVisualRect(
       const FloatRect&,
       const PropertyTreeState& sourceState,
       const PropertyTreeState& destinationState,
       bool& success);
 
-  // Same as mapToVisualRectInDestinationSpace() except that *no* clip is
+  // Same as sourceToDestinationVisualRect() except that only transforms are
   // applied.
-  FloatRect mapRectToDestinationSpace(const FloatRect&,
-                                      const PropertyTreeState& sourceState,
-                                      const PropertyTreeState& destinationState,
-                                      bool& success);
+  FloatRect sourceToDestinationRect(
+      const FloatRect&,
+      const TransformPaintPropertyNode* sourceTransformNode,
+      const TransformPaintPropertyNode* destinationTransformNode,
+      bool& success);
 
   // Maps from a rect in |localTransformSpace| to its visual rect in
   // |ancestorState|. This is computed by multiplying the rect by its combined
@@ -85,44 +86,46 @@ class PLATFORM_EXPORT GeometryMapper {
   // If any of the paint property tree nodes in |localTransformState| are not
   // equal to or a descendant of that in |ancestorState|, returns the passed-in
   // rect and sets |success| to false. Otherwise, sets |success| to true.
-  FloatRect localToVisualRectInAncestorSpace(
+  FloatRect localToAncestorVisualRect(
       const FloatRect&,
       const PropertyTreeState& localTransformState,
       const PropertyTreeState& ancestorState,
       bool& success);
 
-  // Maps from a rect in |localTransformSpace| to its transformed rect in
-  // |ancestorSpace|. This is computed by multiplying the rect by the combined
-  // transform between |localTransformState| and |ancestorState|, then
-  // flattening into 2D space.
+  // Maps from a rect in |localTransformNode| space to its transformed rect in
+  // |ancestorTransformNode| space. This is computed by multiplying the rect by
+  // the combined transform between |localTransformNode| and
+  // |ancestorTransformNode|, then flattening into 2D space.
   //
-  // If any of the paint property tree nodes in |localTransformState| are not
-  // equal to or a descendant of that in |ancestorState|, returns the passed-in
-  // rec and sets |success| to false. Otherwise, sets |success| to true.
-  FloatRect localToAncestorRect(const FloatRect&,
-                                const PropertyTreeState& localTransformState,
-                                const PropertyTreeState& ancestorState,
-                                bool& success);
-
-  // Maps from a rect in |ancestorSpace| to its transformed rect in
-  // |localTransformSpace|. This is computed by multiplying the rect by the
-  // inverse combined transform between |localTransformState| and
-  // |ancestorState|, if the transform is invertible.
+  // If |localTransformNode| is not equal to or a descendant of
+  // |ancestorTransformNode|, returns the passed-in rec and sets |success| to
+  // false. Otherwise, sets |success| to true.
+  FloatRect localToAncestorRect(
+      const FloatRect&,
+      const TransformPaintPropertyNode* localTransformNode,
+      const TransformPaintPropertyNode* ancestorTransformNode,
+      bool& success);
+
+  // Maps from a rect in |ancestorTransformNode| space to its transformed rect
+  // in |localTransformNode| space. This is computed by multiplying the rect by
+  // the inverse combined transform between |localTransformNode| and
+  // |ancestorTransformNode|, if the transform is invertible.
   //
-  // If any of the paint property tree nodes in |localTransformState| are not
-  // equal to or a descendant of that in |ancestorState|, returns the passed-in
+  // If the combined transform is not invertible, or |localTransformNode| is not
+  // equal to or a descendant of |ancestorTransformNode|, returns the passed-in
   // rect and sets |success| to false. Otherwise, sets |success| to true.
-  FloatRect ancestorToLocalRect(const FloatRect&,
-                                const PropertyTreeState& localTransformState,
-                                const PropertyTreeState& ancestorState,
-                                bool& success);
+  FloatRect ancestorToLocalRect(
+      const FloatRect&,
+      const TransformPaintPropertyNode* ancestorTransformNode,
+      const TransformPaintPropertyNode* localTransformNode,
+      bool& success);
 
   // Returns the matrix used in |LocalToAncestorRect|. Sets |success| to false
   // iff |localTransformNode| is not equal to or a descendant of
-  // |ancestorState.transform|.
+  // |ancestorTransformNode|.
   const TransformationMatrix& localToAncestorMatrix(
       const TransformPaintPropertyNode* localTransformNode,
-      const PropertyTreeState& ancestorState,
+      const TransformPaintPropertyNode* ancestorTransformNode,
       bool& success);
 
   // Returns the "clip visual rect" between |localTransformState| and
@@ -133,26 +136,26 @@ class PLATFORM_EXPORT GeometryMapper {
       bool& success);
 
  private:
-  // Used by mapToVisualRectInDestinationSpace() after fast mapping (assuming
+  // Used by sourceToDestinationVisualRect() after fast mapping (assuming
   // destination is an ancestor of source) failed.
-  FloatRect slowMapToVisualRectInDestinationSpace(
+  FloatRect slowSourceToDestinationVisualRect(
       const FloatRect&,
       const PropertyTreeState& sourceState,
       const PropertyTreeState& destinationState,
       bool& success);
 
-  // Used by mapRectToDestinationSpace() after fast mapping (assuming
-  // destination is an ancestor of source) failed.
-  FloatRect slowMapRectToDestinationSpace(
+  // Used by sourceToDestinationRect() after fast mapping (assuming destination
+  // is an ancestor of source) failed.
+  FloatRect slowSourceToDestinationRect(
       const FloatRect&,
-      const PropertyTreeState& sourceState,
-      const PropertyTreeState& destinationState,
+      const TransformPaintPropertyNode* sourceTransformNode,
+      const TransformPaintPropertyNode* destinationTransformNode,
       bool& success);
 
   // Returns the precomputed data if already set, or adds and memoizes a new
   // PrecomputedDataForAncestor otherwise.
   PrecomputedDataForAncestor& getPrecomputedDataForAncestor(
-      const PropertyTreeState&);
+      const TransformPaintPropertyNode*);
 
   // Returns the least common ancestor in the transform tree.
   static const TransformPaintPropertyNode* leastCommonAncestor(

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

@@ -11,12 +11,16 @@
 #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() {
@@ -28,7 +32,8 @@ class GeometryMapperTest : public ::testing::Test {
 
   PrecomputedDataForAncestor& getPrecomputedDataForAncestor(
       const PropertyTreeState& propertyTreeState) {
-    return geometryMapper->getPrecomputedDataForAncestor(propertyTreeState);
+    return geometryMapper->getPrecomputedDataForAncestor(
+        propertyTreeState.transform());
   }
 
   const TransformPaintPropertyNode* leastCommonAncestor(
@@ -73,7 +78,7 @@ const static float kTestEpsilon = 1e-6;
   do {                                                                         \
     bool success = false;                                                      \
     EXPECT_RECT_EQ(expectedVisualRect,                                         \
-                   geometryMapper->localToVisualRectInAncestorSpace(           \
+                   geometryMapper->localToAncestorVisualRect(                  \
                        inputRect, localPropertyTreeState,                      \
                        ancestorPropertyTreeState, success));                   \
     EXPECT_TRUE(success);                                                      \
@@ -82,18 +87,18 @@ const static float kTestEpsilon = 1e-6;
     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()) {                                  \
@@ -150,9 +155,9 @@ TEST_F(GeometryMapperTest, TranslationTransform) {
                  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);
 }
 
@@ -448,39 +453,39 @@ TEST_F(GeometryMapperTest, SiblingTransforms) {
 
   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);
 }
@@ -517,17 +522,17 @@ TEST_F(GeometryMapperTest, SiblingTransformsWithClip) {
   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);
 
@@ -537,16 +542,16 @@ TEST_F(GeometryMapperTest, SiblingTransformsWithClip) {
   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);
 }