Plumb border radius through when computing clip 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/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/EffectPaintPropertyNode.h"
@@ skipping 32 matching lines @@
       const TransformPaintPropertyNode* a,
       const TransformPaintPropertyNode* b) {
     return GeometryMapper::lowestCommonAncestor(a, b);
   }
 
   FloatRect sourceToDestinationVisualRectInternal(
       const FloatRect& rect,
       const PropertyTreeState& sourceState,
       const PropertyTreeState& destinationState,
       bool& success) {
-    return geometryMapper->localToAncestorVisualRectInternal(
-        rect, sourceState, destinationState, success);
+    return geometryMapper
+        ->localToAncestorVisualRectInternal(rect, sourceState, destinationState,
+                                            success)
+        .rect();
   }
 
   FloatRect localToAncestorVisualRectInternal(
       const FloatRect& rect,
       const PropertyTreeState& localState,
       const PropertyTreeState& ancestorState,
       bool& success) {
-    return geometryMapper->localToAncestorVisualRectInternal(
-        rect, localState, ancestorState, success);
+    return geometryMapper
+        ->localToAncestorVisualRectInternal(rect, localState, ancestorState,
+                                            success)
+        .rect();
   }
 
   FloatRect localToAncestorRectInternal(
       const FloatRect& rect,
       const TransformPaintPropertyNode* localTransformNode,
       const TransformPaintPropertyNode* ancestorTransformNode,
       bool& success) {
     return geometryMapper->localToAncestorRectInternal(
         rect, localTransformNode, ancestorTransformNode, success);
   }
@@ skipping 23 matching lines @@
         << ", expected: " << expected.width();                                 \
     EXPECT_TRUE(GeometryTest::ApproximatelyEqual(                              \
         expected.height(), actualRect.height(), kTestEpsilon))                 \
         << "actual: " << actualRect.height()                                   \
         << ", expected: " << expected.height();                                \
   } while (false)
 
 #define CHECK_MAPPINGS(inputRect, expectedVisualRect, expectedTransformedRect, \
                        expectedTransformToAncestor,                            \
                        expectedClipInAncestorSpace, localPropertyTreeState,    \
-                       ancestorPropertyTreeState)                              \
+                       ancestorPropertyTreeState, hasRadius)                   \
   do {                                                                         \
-    EXPECT_RECT_EQ(                                                            \
-        expectedVisualRect,                                                    \
-        geometryMapper->localToAncestorVisualRect(                             \
-            inputRect, localPropertyTreeState, ancestorPropertyTreeState));    \
-    FloatRect mappedClip = geometryMapper->localToAncestorClipRect(            \
+    FloatClipRect clipRect = geometryMapper->localToAncestorVisualRect(        \
+        inputRect, localPropertyTreeState, ancestorPropertyTreeState);         \
+    EXPECT_EQ(hasRadius, clipRect.hasRadius());                                \
+    EXPECT_RECT_EQ(expectedVisualRect, clipRect.rect());                       \
+    clipRect = geometryMapper->localToAncestorClipRect(                        \
         localPropertyTreeState, ancestorPropertyTreeState);                    \
-    EXPECT_RECT_EQ(expectedClipInAncestorSpace, mappedClip);                   \
-    EXPECT_RECT_EQ(                                                            \
-        expectedVisualRect,                                                    \
-        geometryMapper->sourceToDestinationVisualRect(                         \
-            inputRect, localPropertyTreeState, ancestorPropertyTreeState));    \
+    EXPECT_EQ(hasRadius, clipRect.hasRadius());                                \
+    EXPECT_RECT_EQ(expectedClipInAncestorSpace, clipRect.rect());              \
+    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()));                \
     if (ancestorPropertyTreeState.transform() !=                               \
         localPropertyTreeState.transform()) {                                  \
       EXPECT_EQ(expectedTransformToAncestor,                                   \
                 getTransformCache(ancestorPropertyTreeState)                   \
                     .get(localPropertyTreeState.transform()));                 \
     }                                                                          \
     if (ancestorPropertyTreeState.clip() != localPropertyTreeState.clip()) {   \
       EXPECT_EQ(expectedClipInAncestorSpace,                                   \
                 getClipCache(ancestorPropertyTreeState)                        \
-                    .get(localPropertyTreeState.clip()));                      \
+                    .get(localPropertyTreeState.clip())                        \
+                    .rect());                                                  \
     }                                                                          \
   } while (false)
 
 TEST_F(GeometryMapperTest, Root) {
   FloatRect input(0, 0, 100, 100);
 
+  bool hasRadius = false;
   CHECK_MAPPINGS(input, input, input,
                  TransformPaintPropertyNode::root()->matrix(),
                  ClipPaintPropertyNode::root()->clipRect().rect(),
-                 rootPropertyTreeState(), rootPropertyTreeState());
+                 rootPropertyTreeState(), rootPropertyTreeState(), hasRadius);
 }
 
 TEST_F(GeometryMapperTest, IdentityTransform) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          TransformationMatrix(),
                                          FloatPoint3D());
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform.get());
 
   FloatRect input(0, 0, 100, 100);
 
+  bool hasRadius = false;
   CHECK_MAPPINGS(input, input, input, transform->matrix(),
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 rootPropertyTreeState());
+                 rootPropertyTreeState(), hasRadius);
 }
 
 TEST_F(GeometryMapperTest, TranslationTransform) {
   TransformationMatrix transformMatrix;
   transformMatrix.translate(20, 10);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          transformMatrix, FloatPoint3D());
   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(),
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 rootPropertyTreeState());
+                 rootPropertyTreeState(), hasRadius);
 
   EXPECT_RECT_EQ(input, geometryMapper->ancestorToLocalRect(
                             output, rootPropertyTreeState().transform(),
                             localState.transform()));
 }
 
 TEST_F(GeometryMapperTest, RotationAndScaleTransform) {
   TransformationMatrix transformMatrix;
   transformMatrix.rotate(45);
   transformMatrix.scale(2);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          transformMatrix,
                                          FloatPoint3D(0, 0, 0));
   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, transformMatrix,
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 rootPropertyTreeState());
+                 rootPropertyTreeState(), hasRadius);
 }
 
 TEST_F(GeometryMapperTest, RotationAndScaleTransformWithTransformOrigin) {
   TransformationMatrix transformMatrix;
   transformMatrix.rotate(45);
   transformMatrix.scale(2);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          transformMatrix,
                                          FloatPoint3D(50, 50, 0));
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform.get());
 
   FloatRect input(0, 0, 100, 100);
   transformMatrix.applyTransformOrigin(50, 50, 0);
   FloatRect output = transformMatrix.mapRect(input);
 
+  bool hasRadius = false;
   CHECK_MAPPINGS(input, output, output, transformMatrix,
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 rootPropertyTreeState());
+                 rootPropertyTreeState(), hasRadius);
 }
 
 TEST_F(GeometryMapperTest, NestedTransforms) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   TransformationMatrix scaleTransform;
   scaleTransform.scale(2);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(transform1, scaleTransform,
                                          FloatPoint3D());
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform2.get());
 
   FloatRect input(0, 0, 100, 100);
   TransformationMatrix final = rotateTransform * scaleTransform;
   FloatRect output = final.mapRect(input);
 
+  bool hasRadius = false;
   CHECK_MAPPINGS(input, output, output, final,
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 rootPropertyTreeState());
+                 rootPropertyTreeState(), hasRadius);
 
   // Check the cached matrix for the intermediate transform.
   EXPECT_EQ(rotateTransform,
             getTransformCache(rootPropertyTreeState()).get(transform1.get()));
 }
 
 TEST_F(GeometryMapperTest, NestedTransformsScaleAndTranslation) {
   TransformationMatrix scaleTransform;
   scaleTransform.scale(2);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          scaleTransform, FloatPoint3D());
 
   TransformationMatrix translateTransform;
   translateTransform.translate(100, 0);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(transform1, translateTransform,
                                          FloatPoint3D());
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform2.get());
 
   FloatRect input(0, 0, 100, 100);
   // Note: unlike NestedTransforms, the order of these transforms matters. This
   // tests correct order of matrix multiplication.
   TransformationMatrix final = scaleTransform * translateTransform;
   FloatRect output = final.mapRect(input);
 
+  bool hasRadius = false;
   CHECK_MAPPINGS(input, output, output, final,
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 rootPropertyTreeState());
+                 rootPropertyTreeState(), hasRadius);
 
   // Check the cached matrix for the intermediate transform.
   EXPECT_EQ(scaleTransform, getTransformCache(rootPropertyTreeState())
 
                                 .get(transform1.get()));
 }
 
 TEST_F(GeometryMapperTest, NestedTransformsIntermediateDestination) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   TransformationMatrix scaleTransform;
   scaleTransform.scale(2);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(transform1, scaleTransform,
                                          FloatPoint3D());
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform2.get());
 
   PropertyTreeState intermediateState = rootPropertyTreeState();
   intermediateState.setTransform(transform1.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output = scaleTransform.mapRect(input);
 
+  bool hasRadius = false;
   CHECK_MAPPINGS(input, output, output, scaleTransform,
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 intermediateState);
+                 intermediateState, hasRadius);
 }
 
 TEST_F(GeometryMapperTest, SimpleClip) {
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
       FloatRoundedRect(10, 10, 50, 50));
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setClip(clip.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output(10, 10, 50, 50);
 
+  bool hasRadius = false;
   CHECK_MAPPINGS(input,   // Input
                  output,  // Visual rect
                  input,   // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),           // Transform matrix to ancestor space
                  clip->clipRect().rect(),  // Clip rect in ancestor space
                  localState,
-                 rootPropertyTreeState());
+                 rootPropertyTreeState(), hasRadius);
+}
+
+TEST_F(GeometryMapperTest, RoundedClip) {
+  FloatRoundedRect rect(FloatRect(10, 10, 50, 50),
+                        FloatRoundedRect::Radii(FloatSize(1, 1), FloatSize(),
+                                                FloatSize(), FloatSize()));
+  RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
+      ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(), rect);
+
+  PropertyTreeState localState = rootPropertyTreeState();
+  localState.setClip(clip.get());
+
+  FloatRect input(0, 0, 100, 100);
+  FloatRect output(10, 10, 50, 50);
+
+  bool hasRadius = true;
+  CHECK_MAPPINGS(input,   // Input
+                 output,  // Visual rect
+                 input,   // Transformed rect (not clipped).
+                 TransformPaintPropertyNode::root()
+                     ->matrix(),           // Transform matrix to ancestor space
+                 clip->clipRect().rect(),  // Clip rect in ancestor space
+                 localState,
+                 rootPropertyTreeState(), hasRadius);
 }
 
 TEST_F(GeometryMapperTest, TwoClips) {
+  FloatRoundedRect clipRect1(
+      FloatRect(10, 10, 30, 40),
+      FloatRoundedRect::Radii(FloatSize(1, 1), FloatSize(), FloatSize(),
+                              FloatSize()));
+
   RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
-      FloatRoundedRect(10, 10, 30, 40));
+      clipRect1);
 
   RefPtr<ClipPaintPropertyNode> clip2 =
       ClipPaintPropertyNode::create(clip1, TransformPaintPropertyNode::root(),
                                     FloatRoundedRect(10, 10, 50, 50));
 
   PropertyTreeState localState = rootPropertyTreeState();
   PropertyTreeState ancestorState = rootPropertyTreeState();
   localState.setClip(clip2.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output1(10, 10, 30, 40);
 
+  bool hasRadius = true;
   CHECK_MAPPINGS(input,    // Input
                  output1,  // Visual rect
                  input,    // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),  // Transform matrix to ancestor space
                  clip1->clipRect().rect(),  // Clip rect in ancestor space
                  localState,
-                 ancestorState);
+                 ancestorState, hasRadius);
 
   ancestorState.setClip(clip1.get());
   FloatRect output2(10, 10, 50, 50);
 
+  hasRadius = false;
   CHECK_MAPPINGS(input,    // Input
                  output2,  // Visual rect
                  input,    // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),  // Transform matrix to ancestor space
                  clip2->clipRect().rect(),  // Clip rect in ancestor space
                  localState,
-                 ancestorState);
+                 ancestorState, hasRadius);
 }
 
 TEST_F(GeometryMapperTest, ClipBeforeTransform) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), transform.get(),
       FloatRoundedRect(10, 10, 50, 50));
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setClip(clip.get());
   localState.setTransform(transform.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output(input);
   output.intersect(clip->clipRect().rect());
   output = rotateTransform.mapRect(output);
 
+  bool hasRadius = false;
   CHECK_MAPPINGS(
       input,                           // Input
       output,                          // Visual rect
       rotateTransform.mapRect(input),  // Transformed rect (not clipped).
       rotateTransform,                 // Transform matrix to ancestor space
       rotateTransform.mapRect(
           clip->clipRect().rect()),  // Clip rect in ancestor space
       localState,
-      rootPropertyTreeState());
+      rootPropertyTreeState(), hasRadius);
 }
 
 TEST_F(GeometryMapperTest, ClipAfterTransform) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
       FloatRoundedRect(10, 10, 200, 200));
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setClip(clip.get());
   localState.setTransform(transform.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output(input);
   output = rotateTransform.mapRect(output);
   output.intersect(clip->clipRect().rect());
 
+  bool hasRadius = false;
   CHECK_MAPPINGS(
       input,                           // Input
       output,                          // Visual rect
       rotateTransform.mapRect(input),  // Transformed rect (not clipped)
       rotateTransform,                 // Transform matrix to ancestor space
       clip->clipRect().rect(),         // Clip rect in ancestor space
-      localState, rootPropertyTreeState());
+      localState, rootPropertyTreeState(), hasRadius);
 }
 
 TEST_F(GeometryMapperTest, TwoClipsWithTransformBetween) {
   RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
       FloatRoundedRect(10, 10, 200, 200));
 
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   RefPtr<ClipPaintPropertyNode> clip2 = ClipPaintPropertyNode::create(
       clip1, transform.get(), FloatRoundedRect(10, 10, 200, 200));
 
   FloatRect input(0, 0, 100, 100);
 
+  bool hasRadius = false;
   {
     PropertyTreeState localState = rootPropertyTreeState();
     localState.setClip(clip1.get());
     localState.setTransform(transform.get());
 
     FloatRect output(input);
     output = rotateTransform.mapRect(output);
     output.intersect(clip1->clipRect().rect());
 
     CHECK_MAPPINGS(
         input,                           // Input
         output,                          // Visual rect
         rotateTransform.mapRect(input),  // Transformed rect (not clipped)
         rotateTransform,                 // Transform matrix to ancestor space
         clip1->clipRect().rect(),        // Clip rect in ancestor space
-        localState, rootPropertyTreeState());
+        localState, rootPropertyTreeState(), hasRadius);
   }
 
   {
     PropertyTreeState localState = rootPropertyTreeState();
     localState.setClip(clip2.get());
     localState.setTransform(transform.get());
 
     FloatRect mappedClip = rotateTransform.mapRect(clip2->clipRect().rect());
     mappedClip.intersect(clip1->clipRect().rect());
 
     // All clips are performed in the space of the ancestor. In cases such as
     // this, this means the clip is a bit lossy.
     FloatRect output(input);
     // Map to transformed rect in ancestor space.
     output = rotateTransform.mapRect(output);
     // Intersect with all clips between local and ancestor, independently mapped
     // to ancestor space.
     output.intersect(mappedClip);
 
     CHECK_MAPPINGS(
         input,                           // Input
         output,                          // Visual rect
         rotateTransform.mapRect(input),  // Transformed rect (not clipped)
         rotateTransform,                 // Transform matrix to ancestor space
         mappedClip,                      // Clip rect in ancestor space
-        localState, rootPropertyTreeState());
+        localState, rootPropertyTreeState(), hasRadius);
   }
 }
 
 TEST_F(GeometryMapperTest, SiblingTransforms) {
   // 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 31 matching lines @@
   EXPECT_RECT_EQ(input, result);
 
   result = localToAncestorRectInternal(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->sourceToDestinationVisualRect(input, transform1State,
-                                                         transform2State);
+  result = geometryMapper
+               ->sourceToDestinationVisualRect(input, transform1State,
+                                               transform2State)
+               .rect();
   EXPECT_RECT_EQ(expected, result);
 
   result = geometryMapper->sourceToDestinationRect(input, transform1.get(),
                                                    transform2.get());
   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.
@@ skipping 40 matching lines @@
   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);
+  result = geometryMapper
+               ->sourceToDestinationVisualRect(input, transform2AndClipState,
+                                               transform1State)
+               .rect();
   EXPECT_RECT_EQ(expectedClipped, result);
 
   // sourceToDestinationRect applies transforms only.
   result = geometryMapper->sourceToDestinationRect(input, transform2.get(),
                                                    transform1.get());
   EXPECT_RECT_EQ(expectedUnclipped, result);
 }
 
 TEST_F(GeometryMapperTest, LowestCommonAncestor) {
   TransformationMatrix matrix;
@@ skipping 25 matching lines @@
   EXPECT_EQ(rootPropertyTreeState().transform(),
             lowestCommonAncestor(childOfChild2.get(),
                                  rootPropertyTreeState().transform()));
   EXPECT_EQ(child2, lowestCommonAncestor(childOfChild2.get(), child2.get()));
 
   EXPECT_EQ(rootPropertyTreeState().transform(),
             lowestCommonAncestor(child1.get(), child2.get()));
 }
 
 }  // namespace blink