Reduce 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 57 matching lines @@
       const FloatRect& rect,
       const PropertyTreeState& localState,
       const PropertyTreeState& ancestorState,
       bool& success) {
     return geometryMapper
         ->localToAncestorVisualRectInternal(rect, localState, ancestorState,
                                             success)
         .rect();
   }
 
-  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 33 matching lines @@
     EXPECT_EQ(hasRadius, clipRect.hasRadius());                                \
     EXPECT_RECT_EQ(expectedVisualRect, clipRect.rect());                       \
     clipRect = 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()));                \
+    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 =                              \
@@ skipping 38 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 411 matching lines @@
   transform2State.setTransform(transform2.get());
 
   bool success;
   FloatRect input(0, 0, 100, 100);
   FloatRect result = localToAncestorVisualRectInternal(
       input, transform1State, transform2State, 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);
   // 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();
   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 24 matching lines @@
 
   // sourceToDestinationVisualRect ignores clip from the common ancestor to
   // destination.
   FloatRect result = sourceToDestinationVisualRectInternal(
       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);
 
   // 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();
   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