Compute rounded-ness of visual rects

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 31 matching lines @@
       const TransformPaintPropertyNode* a,
       const TransformPaintPropertyNode* b) {
     return GeometryMapper::lowestCommonAncestor(a, b);
   }
 
   void sourceToDestinationVisualRectInternal(
       const PropertyTreeState& sourceState,
       const PropertyTreeState& destinationState,
       FloatRect& mappingRect,
       bool& success) {
+    FloatClipRect floatClipRect(mappingRect);
     GeometryMapper::localToAncestorVisualRectInternal(
-        sourceState, destinationState, mappingRect, success);
+        sourceState, destinationState, floatClipRect, success);
+    mappingRect = floatClipRect.rect();
   }
 
   void localToAncestorVisualRectInternal(const PropertyTreeState& localState,
                                          const PropertyTreeState& ancestorState,
                                          FloatRect& mappingRect,
                                          bool& success) {
+    FloatClipRect floatClipRect(mappingRect);
     GeometryMapper::localToAncestorVisualRectInternal(localState, ancestorState,
-                                                      mappingRect, success);
+                                                      floatClipRect, success);
+    mappingRect = floatClipRect.rect();
   }
 
   void localToAncestorRectInternal(
       const TransformPaintPropertyNode* localTransformNode,
       const TransformPaintPropertyNode* ancestorTransformNode,
       FloatRect& rect,
       bool& success) {
     GeometryMapper::localToAncestorRectInternal(
         localTransformNode, ancestorTransformNode, rect, success);
   }
@@ skipping 27 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 {                                                                         \
-    FloatRect floatRect = inputRect;                                           \
+    FloatClipRect floatRect(inputRect);                                        \
     GeometryMapper::localToAncestorVisualRect(                                 \
         localPropertyTreeState, ancestorPropertyTreeState, floatRect);         \
-    EXPECT_RECT_EQ(expectedVisualRect, floatRect);                             \
+    EXPECT_RECT_EQ(expectedVisualRect, floatRect.rect());                      \
+    EXPECT_EQ(hasRadius, floatRect.hasRadius());                               \
     FloatClipRect floatClipRect;                                               \
     floatClipRect = GeometryMapper::localToAncestorClipRect(                   \
         localPropertyTreeState, ancestorPropertyTreeState);                    \
     EXPECT_EQ(hasRadius, floatClipRect.hasRadius());                           \
     EXPECT_CLIP_RECT_EQ(expectedClipInAncestorSpace, floatClipRect);           \
-    floatRect = inputRect;                                                     \
+    floatRect.setRect(inputRect);                                              \
     GeometryMapper::sourceToDestinationVisualRect(                             \
         localPropertyTreeState, ancestorPropertyTreeState, floatRect);         \
-    EXPECT_RECT_EQ(expectedVisualRect, floatRect);                             \
+    EXPECT_RECT_EQ(expectedVisualRect, floatRect.rect());                      \
+    EXPECT_EQ(hasRadius, floatRect.hasRadius());                               \
     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);                   \
@@ skipping 533 matching lines @@
   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 = input;
+  FloatClipRect floatClipRect(result);
   GeometryMapper::sourceToDestinationVisualRect(transform1State,
-                                                transform2State, result);
+                                                transform2State, floatClipRect);
+  result = floatClipRect.rect();
   EXPECT_RECT_EQ(expected, result);
 
   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
@@ skipping 44 matching lines @@
 
   // 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 = input;
+  FloatClipRect floatClipRect(result);
   GeometryMapper::sourceToDestinationVisualRect(transform2AndClipState,
-                                                transform1State, result);
+                                                transform1State, floatClipRect);
+  result = floatClipRect.rect();
   EXPECT_RECT_EQ(expectedClipped, result);
 
   // sourceToDestinationRect applies transforms only.
   result = input;
   GeometryMapper::sourceToDestinationRect(transform2.get(), transform1.get(),
                                           result);
   EXPECT_RECT_EQ(expectedUnclipped, result);
 }
 
 TEST_F(GeometryMapperTest, LowestCommonAncestor) {
@@ skipping 100 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, PropertyTreeState::root(), hasRadius);
 }
 
 }  // namespace blink