Reland of duce copying of local data structures in GeometryMapper and PaintLayerClipper.

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/BoxReflection.h"
 #include "platform/graphics/filters/SkiaImageFilterBuilder.h"
@@ skipping 35 matching lines @@
     return descendantTransform->getTransformCache().getCachedTransform(
         ancestorTransform);
   }
 
   const TransformPaintPropertyNode* lowestCommonAncestor(
       const TransformPaintPropertyNode* a,
       const TransformPaintPropertyNode* b) {
     return GeometryMapper::lowestCommonAncestor(a, b);
   }
 
-  FloatRect sourceToDestinationVisualRectInternal(
-      const FloatRect& rect,
+  void sourceToDestinationVisualRectInternal(
       const PropertyTreeState& sourceState,
       const PropertyTreeState& destinationState,
+      FloatRect& mappingRect,
       bool& success) {
-    return geometryMapper
-        ->localToAncestorVisualRectInternal(rect, sourceState, destinationState,
-                                            success)
-        .rect();
+    geometryMapper->localToAncestorVisualRectInternal(
+        sourceState, destinationState, mappingRect, success);
   }
 
-  FloatRect localToAncestorVisualRectInternal(
-      const FloatRect& rect,
-      const PropertyTreeState& localState,
-      const PropertyTreeState& ancestorState,
-      bool& success) {
-    return geometryMapper
-        ->localToAncestorVisualRectInternal(rect, localState, ancestorState,
-                                            success)
-        .rect();
+  void localToAncestorVisualRectInternal(const PropertyTreeState& localState,
+                                         const PropertyTreeState& ancestorState,
+                                         FloatRect& mappingRect,
+                                         bool& success) {
+    geometryMapper->localToAncestorVisualRectInternal(localState, ancestorState,
+                                                      mappingRect, success);
   }
 
-  FloatRect localToAncestorRectInternal(
-      const FloatRect& rect,
+  void localToAncestorRectInternal(
       const TransformPaintPropertyNode* localTransformNode,
       const TransformPaintPropertyNode* ancestorTransformNode,
+      FloatRect& rect,
       bool& success) {
-    return geometryMapper->localToAncestorRectInternal(
-        rect, localTransformNode, ancestorTransformNode, success);
+    geometryMapper->localToAncestorRectInternal(
+        localTransformNode, ancestorTransformNode, rect, success);
   }
 
  private:
   void SetUp() override { geometryMapper = GeometryMapper::create(); }
 
   void TearDown() override { geometryMapper.reset(); }
 };
 
 const static float kTestEpsilon = 1e-6;
 
@@ skipping 21 matching lines @@
     EXPECT_EQ(expected.isInfinite(), actual.isInfinite()); \
     if (!expected.isInfinite())                            \
       EXPECT_RECT_EQ(expected.rect(), actual.rect());      \
   } while (false)
 
 #define CHECK_MAPPINGS(inputRect, expectedVisualRect, expectedTransformedRect, \
                        expectedTransformToAncestor,                            \
                        expectedClipInAncestorSpace, localPropertyTreeState,    \
                        ancestorPropertyTreeState, hasRadius)                   \
   do {                                                                         \
-    FloatClipRect clipRect = geometryMapper->localToAncestorVisualRect(        \
-        inputRect, localPropertyTreeState, ancestorPropertyTreeState);         \
-    EXPECT_EQ(hasRadius, clipRect.hasRadius());                                \
-    EXPECT_RECT_EQ(expectedVisualRect, clipRect.rect());                       \
-    clipRect = geometryMapper->localToAncestorClipRect(                        \
+    FloatRect floatRect = inputRect;                                           \
+    geometryMapper->localToAncestorVisualRect(                                 \
+        localPropertyTreeState, ancestorPropertyTreeState, floatRect);         \
+    EXPECT_RECT_EQ(expectedVisualRect, floatRect);                             \
+    FloatClipRect floatClipRect;                                               \
+    floatClipRect = geometryMapper->localToAncestorClipRect(                   \
         localPropertyTreeState, ancestorPropertyTreeState);                    \
-    EXPECT_EQ(hasRadius, clipRect.hasRadius());                                \
-    EXPECT_CLIP_RECT_EQ(expectedClipInAncestorSpace, clipRect);                \
-    clipRect = geometryMapper->sourceToDestinationVisualRect(                  \
-        inputRect, localPropertyTreeState, ancestorPropertyTreeState);         \
-    EXPECT_EQ(hasRadius, clipRect.hasRadius());                                \
-    EXPECT_RECT_EQ(expectedVisualRect, clipRect.rect());                       \
-    EXPECT_RECT_EQ(expectedTransformedRect,                                    \
-                   geometryMapper->localToAncestorRect(                        \
-                       inputRect, localPropertyTreeState.transform(),          \
-                       ancestorPropertyTreeState.transform()));                \
-    EXPECT_RECT_EQ(expectedTransformedRect,                                    \
-                   geometryMapper->sourceToDestinationRect(                    \
-                       inputRect, localPropertyTreeState.transform(),          \
-                       ancestorPropertyTreeState.transform()));                \
+    EXPECT_EQ(hasRadius, floatClipRect.hasRadius());                           \
+    EXPECT_CLIP_RECT_EQ(expectedClipInAncestorSpace, floatClipRect);           \
+    floatRect = inputRect;                                                     \
+    geometryMapper->sourceToDestinationVisualRect(                             \
+        localPropertyTreeState, ancestorPropertyTreeState, floatRect);         \
+    EXPECT_RECT_EQ(expectedVisualRect, floatRect);                             \
+    FloatRect testMappedRect = inputRect;                                      \
+    geometryMapper->localToAncestorRect(localPropertyTreeState.transform(),    \
+                                        ancestorPropertyTreeState.transform(), \
+                                        testMappedRect);                       \
+    EXPECT_RECT_EQ(expectedTransformedRect, testMappedRect);                   \
+    testMappedRect = inputRect;                                                \
+    geometryMapper->sourceToDestinationRect(                                   \
+        localPropertyTreeState.transform(),                                    \
+        ancestorPropertyTreeState.transform(), testMappedRect);                \
+    EXPECT_RECT_EQ(expectedTransformedRect, testMappedRect);                   \
     if (ancestorPropertyTreeState.transform() !=                               \
         localPropertyTreeState.transform()) {                                  \
       const TransformationMatrix* transformForTesting =                        \
           getTransform(localPropertyTreeState.transform(),                     \
                        ancestorPropertyTreeState.transform());                 \
       CHECK(transformForTesting);                                              \
       EXPECT_EQ(expectedTransformToAncestor, *transformForTesting);            \
     }                                                                          \
     if (ancestorPropertyTreeState.clip() != localPropertyTreeState.clip()) {   \
       const FloatClipRect* outputClipForTesting =                              \
           getClip(localPropertyTreeState.clip(), ancestorPropertyTreeState);   \
       DCHECK(outputClipForTesting);                                            \
       EXPECT_EQ(expectedClipInAncestorSpace, *outputClipForTesting)            \
-          << expectedClipInAncestorSpace.rect().toString() << " "              \
-          << outputClipForTesting->rect().toString();                          \
+          << "expected: " << expectedClipInAncestorSpace.rect().toString()     \
+          << " (hasRadius: " << expectedClipInAncestorSpace.hasRadius()        \
+          << ") "                                                              \
+          << "actual: " << outputClipForTesting->rect().toString()             \
+          << " (hasRadius: " << outputClipForTesting->hasRadius() << ")";      \
     }                                                                          \
   } while (false)
 
 TEST_F(GeometryMapperTest, Root) {
   FloatRect input(0, 0, 100, 100);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, input, input,
                  TransformPaintPropertyNode::root()->matrix(), FloatClipRect(),
                  rootPropertyTreeState(), rootPropertyTreeState(), hasRadius);
@@ skipping 23 matching lines @@
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output = transformMatrix.mapRect(input);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, output, output, transform->matrix(), FloatClipRect(),
                  localState, rootPropertyTreeState(), hasRadius);
 
-  EXPECT_RECT_EQ(input, geometryMapper->ancestorToLocalRect(
-                            output, rootPropertyTreeState().transform(),
-                            localState.transform()));
+  geometryMapper->ancestorToLocalRect(rootPropertyTreeState().transform(),
+                                      localState.transform(), output);
+  EXPECT_RECT_EQ(input, output);
 }
 
 TEST_F(GeometryMapperTest, RotationAndScaleTransform) {
   TransformationMatrix transformMatrix;
   transformMatrix.rotate(45);
   transformMatrix.scale(2);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          transformMatrix,
                                          FloatPoint3D(0, 0, 0));
@@ skipping 196 matching lines @@
                  input,    // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),  // Transform matrix to ancestor space
                  clipRect,        // Clip rect in ancestor space
                  localState,
                  ancestorState, hasRadius);
 
   ancestorState.setClip(clip1.get());
   FloatRect output2(10, 10, 50, 50);
 
-  clipRect.setRect(clip2->clipRect().rect());
+  FloatClipRect clipRect2;
+  clipRect2.setRect(clip2->clipRect().rect());
 
   hasRadius = false;
   CHECK_MAPPINGS(input,    // Input
                  output2,  // Visual rect
                  input,    // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),  // Transform matrix to ancestor space
-                 clipRect,        // Clip rect in ancestor space
-                 localState,
-                 ancestorState, hasRadius);
+                 clipRect2,       // Clip rect in ancestor space
+                 localState, ancestorState, hasRadius);
 }
 
 TEST_F(GeometryMapperTest, TwoClipsTransformAbove) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          TransformationMatrix(),
                                          FloatPoint3D());
 
   FloatRoundedRect clipRect1(
       FloatRect(10, 10, 50, 50),
@@ skipping 178 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 = localToAncestorVisualRectInternal(
-      input, transform1State, transform2State, success);
+  FloatRect result = input;
+  localToAncestorVisualRectInternal(transform1State, transform2State, result,
+                                    success);
   // Fails, because the transform2state is not an ancestor of transform1State.
   EXPECT_FALSE(success);
   EXPECT_RECT_EQ(input, result);
 
-  result = localToAncestorRectInternal(input, transform1.get(),
-                                       transform2.get(), success);
+  result = input;
+  localToAncestorRectInternal(transform1.get(), transform2.get(), result,
+                              success);
   // Fails, because the transform2state is not an ancestor of transform1State.
   EXPECT_FALSE(success);
   EXPECT_RECT_EQ(input, result);
 
-  result = localToAncestorVisualRectInternal(input, transform2State,
-                                             transform1State, success);
+  result = input;
+  localToAncestorVisualRectInternal(transform2State, transform1State, result,
+                                    success);
   // Fails, because the transform1state is not an ancestor of transform2State.
   EXPECT_FALSE(success);
   EXPECT_RECT_EQ(input, result);
 
-  result = localToAncestorRectInternal(input, transform2.get(),
-                                       transform1.get(), success);
+  result = input;
+  localToAncestorRectInternal(transform2.get(), transform1.get(), result,
+                              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
-               ->sourceToDestinationVisualRect(input, transform1State,
-                                               transform2State)
-               .rect();
+  result = input;
+  geometryMapper->sourceToDestinationVisualRect(transform1State,
+                                                transform2State, result);
   EXPECT_RECT_EQ(expected, result);
 
-  result = geometryMapper->sourceToDestinationRect(input, transform1.get(),
-                                                   transform2.get());
+  result = input;
+  geometryMapper->sourceToDestinationRect(transform1.get(), transform2.get(),
+                                          result);
   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 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
@@ skipping 17 matching lines @@
 
   bool success;
   FloatRect input(0, 0, 100, 100);
 
   // Test map from transform1State to transform2AndClipState.
   FloatRect expected =
       rotateTransform2.inverse().mapRect(rotateTransform1.mapRect(input));
 
   // sourceToDestinationVisualRect ignores clip from the common ancestor to
   // destination.
-  FloatRect result = sourceToDestinationVisualRectInternal(
-      input, transform1State, transform2AndClipState, success);
+  FloatRect result = input;
+  sourceToDestinationVisualRectInternal(transform1State, transform2AndClipState,
+                                        result, success);
   // Fails, because the clip of the destination state is not an ancestor of the
   // clip of the source state.
   EXPECT_FALSE(success);
 
   // sourceToDestinationRect applies transforms only.
-  result = geometryMapper->sourceToDestinationRect(input, transform1.get(),
-                                                   transform2.get());
+  result = input;
+  geometryMapper->sourceToDestinationRect(transform1.get(), transform2.get(),
+                                          result);
   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)));
 
   // sourceToDestinationVisualRect ignores clip from the common ancestor to
   // destination.
-  result = geometryMapper
-               ->sourceToDestinationVisualRect(input, transform2AndClipState,
-                                               transform1State)
-               .rect();
+  result = input;
+  geometryMapper->sourceToDestinationVisualRect(transform2AndClipState,
+                                                transform1State, result);
   EXPECT_RECT_EQ(expectedClipped, result);
 
   // sourceToDestinationRect applies transforms only.
-  result = geometryMapper->sourceToDestinationRect(input, transform2.get(),
-                                                   transform1.get());
+  result = input;
+  geometryMapper->sourceToDestinationRect(transform2.get(), transform1.get(),
+                                          result);
   EXPECT_RECT_EQ(expectedUnclipped, result);
 }
 
 TEST_F(GeometryMapperTest, LowestCommonAncestor) {
   TransformationMatrix matrix;
   RefPtr<TransformPaintPropertyNode> child1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          matrix, FloatPoint3D());
   RefPtr<TransformPaintPropertyNode> child2 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
@@ skipping 94 matching lines @@
   FloatRect input(100, 100, 50, 50);
   // Reflection is at (50, 100, 50, 50).
   FloatRect output(50, 100, 100, 50);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, output, input, TransformationMatrix(), FloatClipRect(),
                  localState, rootPropertyTreeState(), hasRadius);
 }
 
 }  // namespace blink