[SPv1] Fix return value for "fallback" case of inverted clips.

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"
 #include "platform/graphics/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/EffectPaintPropertyNode.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,
-                           public ScopedSlimmingPaintV2ForTest {
+typedef bool SlimmingPaintV2Enabled;
+class GeometryMapperTest
+    : public ::testing::Test,
+      public ::testing::WithParamInterface<SlimmingPaintV2Enabled>,
+      public ScopedSlimmingPaintV2ForTest {
  public:
-  GeometryMapperTest() : ScopedSlimmingPaintV2ForTest(true) {}
+  GeometryMapperTest() : ScopedSlimmingPaintV2ForTest(GetParam()) {}
 
   const FloatClipRect* GetClip(
       const ClipPaintPropertyNode* descendant_clip,
       const PropertyTreeState& ancestor_property_tree_state) {
     GeometryMapperClipCache::ClipAndTransform clip_and_transform(
         ancestor_property_tree_state.Clip(),
         ancestor_property_tree_state.Transform());
     return descendant_clip->GetClipCache().GetCachedClip(clip_and_transform);
   }
 
@@ skipping 37 matching lines @@
       const TransformPaintPropertyNode* ancestor_transform_node,
       FloatRect& rect,
       bool& success) {
     GeometryMapper::LocalToAncestorRectInternal(
         local_transform_node, ancestor_transform_node, rect, success);
   }
 
  private:
 };
 
+bool values[] = {false, true};
+
+INSTANTIATE_TEST_CASE_P(All, GeometryMapperTest, ::testing::ValuesIn(values));
+
 const static float kTestEpsilon = 1e-6;
 
 #define EXPECT_RECT_EQ(expected, actual)                                    \
   do {                                                                      \
     const FloatRect& actual_rect = actual;                                  \
     EXPECT_TRUE(GeometryTest::ApproximatelyEqual(                           \
         expected.X(), actual_rect.X(), kTestEpsilon))                       \
         << "actual: " << actual_rect.X() << ", expected: " << expected.X(); \
     EXPECT_TRUE(GeometryTest::ApproximatelyEqual(                           \
         expected.Y(), actual_rect.Y(), kTestEpsilon))                       \
@@ skipping 59 matching lines @@
       DCHECK(output_clip_for_testing);                                         \
       EXPECT_EQ(expectedClipInAncestorSpace, *output_clip_for_testing)         \
           << "expected: " << expectedClipInAncestorSpace.Rect().ToString()     \
           << " (hasRadius: " << expectedClipInAncestorSpace.HasRadius()        \
           << ") "                                                              \
           << "actual: " << output_clip_for_testing->Rect().ToString()          \
           << " (hasRadius: " << output_clip_for_testing->HasRadius() << ")";   \
     }                                                                          \
   } while (false)
 
-TEST_F(GeometryMapperTest, Root) {
+TEST_P(GeometryMapperTest, Root) {
   FloatRect input(0, 0, 100, 100);
 
   bool has_radius = false;
   CHECK_MAPPINGS(input, input, input,
                  TransformPaintPropertyNode::Root()->Matrix(), FloatClipRect(),
                  PropertyTreeState::Root(), PropertyTreeState::Root());
 }
 
-TEST_F(GeometryMapperTest, IdentityTransform) {
+TEST_P(GeometryMapperTest, IdentityTransform) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          TransformationMatrix(),
                                          FloatPoint3D());
   PropertyTreeState local_state = PropertyTreeState::Root();
   local_state.SetTransform(transform.Get());
 
   FloatRect input(0, 0, 100, 100);
 
   bool has_radius = false;
   CHECK_MAPPINGS(input, input, input, transform->Matrix(), FloatClipRect(),
                  local_state, PropertyTreeState::Root());
 }
 
-TEST_F(GeometryMapperTest, TranslationTransform) {
+TEST_P(GeometryMapperTest, TranslationTransform) {
   TransformationMatrix transform_matrix;
   transform_matrix.Translate(20, 10);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          transform_matrix, FloatPoint3D());
   PropertyTreeState local_state = PropertyTreeState::Root();
   local_state.SetTransform(transform.Get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output = transform_matrix.MapRect(input);
 
   bool has_radius = false;
   CHECK_MAPPINGS(input, output, output, transform->Matrix(), FloatClipRect(),
                  local_state, PropertyTreeState::Root());
 
   GeometryMapper::AncestorToLocalRect(TransformPaintPropertyNode::Root(),
                                       local_state.Transform(), output);
   EXPECT_RECT_EQ(input, output);
 }
 
-TEST_F(GeometryMapperTest, RotationAndScaleTransform) {
+TEST_P(GeometryMapperTest, RotationAndScaleTransform) {
   TransformationMatrix transform_matrix;
   transform_matrix.Rotate(45);
   transform_matrix.Scale(2);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          transform_matrix,
                                          FloatPoint3D(0, 0, 0));
   PropertyTreeState local_state = PropertyTreeState::Root();
   local_state.SetTransform(transform.Get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output = transform_matrix.MapRect(input);
 
   bool has_radius = false;
   CHECK_MAPPINGS(input, output, output, transform_matrix, FloatClipRect(),
                  local_state, PropertyTreeState::Root());
 }
 
-TEST_F(GeometryMapperTest, RotationAndScaleTransformWithTransformOrigin) {
+TEST_P(GeometryMapperTest, RotationAndScaleTransformWithTransformOrigin) {
   TransformationMatrix transform_matrix;
   transform_matrix.Rotate(45);
   transform_matrix.Scale(2);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          transform_matrix,
                                          FloatPoint3D(50, 50, 0));
   PropertyTreeState local_state = PropertyTreeState::Root();
   local_state.SetTransform(transform.Get());
 
   FloatRect input(0, 0, 100, 100);
   transform_matrix.ApplyTransformOrigin(50, 50, 0);
   FloatRect output = transform_matrix.MapRect(input);
 
   bool has_radius = false;
   CHECK_MAPPINGS(input, output, output, transform_matrix, FloatClipRect(),
                  local_state, PropertyTreeState::Root());
 }
 
-TEST_F(GeometryMapperTest, NestedTransforms) {
+TEST_P(GeometryMapperTest, NestedTransforms) {
   TransformationMatrix rotate_transform;
   rotate_transform.Rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          rotate_transform, FloatPoint3D());
 
   TransformationMatrix scale_transform;
   scale_transform.Scale(2);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::Create(transform1, scale_transform,
                                          FloatPoint3D());
 
   PropertyTreeState local_state = PropertyTreeState::Root();
   local_state.SetTransform(transform2.Get());
 
   FloatRect input(0, 0, 100, 100);
   TransformationMatrix final = rotate_transform * scale_transform;
   FloatRect output = final.MapRect(input);
 
   bool has_radius = false;
   CHECK_MAPPINGS(input, output, output, final, FloatClipRect(), local_state,
                  PropertyTreeState::Root());
 
   // Check the cached matrix for the intermediate transform.
   EXPECT_EQ(
       rotate_transform,
       *GetTransform(transform1.Get(), TransformPaintPropertyNode::Root()));
 }
 
-TEST_F(GeometryMapperTest, NestedTransformsFlattening) {
+TEST_P(GeometryMapperTest, NestedTransformsFlattening) {
   TransformationMatrix rotate_transform;
   rotate_transform.Rotate3d(45, 0, 0);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          rotate_transform, FloatPoint3D());
 
   TransformationMatrix inverse_rotate_transform;
   inverse_rotate_transform.Rotate3d(-45, 0, 0);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::Create(transform1, inverse_rotate_transform,
                                          FloatPoint3D(),
                                          true);  // Flattens
 
   PropertyTreeState local_state = PropertyTreeState::Root();
   local_state.SetTransform(transform2.Get());
 
   FloatRect input(0, 0, 100, 100);
   rotate_transform.FlattenTo2d();
   TransformationMatrix final = rotate_transform * inverse_rotate_transform;
   FloatRect output = final.MapRect(input);
   bool has_radius = false;
   CHECK_MAPPINGS(input, output, output, final, FloatClipRect(), local_state,
                  PropertyTreeState::Root());
 }
 
-TEST_F(GeometryMapperTest, NestedTransformsScaleAndTranslation) {
+TEST_P(GeometryMapperTest, NestedTransformsScaleAndTranslation) {
   TransformationMatrix scale_transform;
   scale_transform.Scale(2);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          scale_transform, FloatPoint3D());
 
   TransformationMatrix translate_transform;
   translate_transform.Translate(100, 0);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::Create(transform1, translate_transform,
@@ skipping 10 matching lines @@
 
   bool has_radius = false;
   CHECK_MAPPINGS(input, output, output, final, FloatClipRect(), local_state,
                  PropertyTreeState::Root());
 
   // Check the cached matrix for the intermediate transform.
   EXPECT_EQ(scale_transform, *GetTransform(transform1.Get(),
                                            TransformPaintPropertyNode::Root()));
 }
 
-TEST_F(GeometryMapperTest, NestedTransformsIntermediateDestination) {
+TEST_P(GeometryMapperTest, NestedTransformsIntermediateDestination) {
   TransformationMatrix rotate_transform;
   rotate_transform.Rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          rotate_transform, FloatPoint3D());
 
   TransformationMatrix scale_transform;
   scale_transform.Scale(2);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::Create(transform1, scale_transform,
                                          FloatPoint3D());
 
   PropertyTreeState local_state = PropertyTreeState::Root();
   local_state.SetTransform(transform2.Get());
 
   PropertyTreeState intermediate_state = PropertyTreeState::Root();
   intermediate_state.SetTransform(transform1.Get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output = scale_transform.MapRect(input);
 
   bool has_radius = false;
   CHECK_MAPPINGS(input, output, output, scale_transform, FloatClipRect(),
                  local_state, intermediate_state);
 }
 
-TEST_F(GeometryMapperTest, SimpleClip) {
+TEST_P(GeometryMapperTest, SimpleClip) {
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::Create(
       ClipPaintPropertyNode::Root(), TransformPaintPropertyNode::Root(),
       FloatRoundedRect(10, 10, 50, 50));
 
   PropertyTreeState local_state = PropertyTreeState::Root();
   local_state.SetClip(clip.Get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output(10, 10, 50, 50);
 
   bool has_radius = false;
   CHECK_MAPPINGS(input,   // Input
                  output,  // Visual rect
                  input,   // Transformed rect (not clipped).
                  TransformPaintPropertyNode::Root()
                      ->Matrix(),  // Transform matrix to ancestor space
                  FloatClipRect(clip->ClipRect().Rect()),  // Clip rect in
                                                           // ancestor space
                  local_state, PropertyTreeState::Root());
 }
 
-TEST_F(GeometryMapperTest, RoundedClip) {
+TEST_P(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 local_state = PropertyTreeState::Root();
   local_state.SetClip(clip.Get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output(10, 10, 50, 50);
 
   FloatClipRect expected_clip(clip->ClipRect().Rect());
   expected_clip.SetHasRadius();
 
   bool has_radius = true;
   CHECK_MAPPINGS(input,   // Input
                  output,  // Visual rect
                  input,   // Transformed rect (not clipped).
                  TransformPaintPropertyNode::Root()
                      ->Matrix(),  // Transform matrix to ancestor space
                  expected_clip,   // Clip rect in ancestor space
                  local_state, PropertyTreeState::Root());
 }
 
-TEST_F(GeometryMapperTest, TwoClips) {
+TEST_P(GeometryMapperTest, TwoClips) {
   FloatRoundedRect clip_rect1(
       FloatRect(10, 10, 30, 40),
       FloatRoundedRect::Radii(FloatSize(1, 1), FloatSize(), FloatSize(),
                               FloatSize()));
 
   RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::Create(
       ClipPaintPropertyNode::Root(), TransformPaintPropertyNode::Root(),
       clip_rect1);
 
   RefPtr<ClipPaintPropertyNode> clip2 =
@@ skipping 28 matching lines @@
   has_radius = false;
   CHECK_MAPPINGS(input,    // Input
                  output2,  // Visual rect
                  input,    // Transformed rect (not clipped).
                  TransformPaintPropertyNode::Root()
                      ->Matrix(),  // Transform matrix to ancestor space
                  clip_rect2,      // Clip rect in ancestor space
                  local_state, ancestor_state);
 }
 
-TEST_F(GeometryMapperTest, TwoClipsTransformAbove) {
+TEST_P(GeometryMapperTest, TwoClipsTransformAbove) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          TransformationMatrix(),
                                          FloatPoint3D());
 
   FloatRoundedRect clip_rect1(
       FloatRect(10, 10, 50, 50),
       FloatRoundedRect::Radii(FloatSize(1, 1), FloatSize(), FloatSize(),
                               FloatSize()));
 
@@ skipping 27 matching lines @@
   FloatRect output2(10, 10, 50, 50);
   CHECK_MAPPINGS(input,    // Input
                  output2,  // Visual rect
                  input,    // Transformed rect (not clipped).
                  TransformPaintPropertyNode::Root()
                      ->Matrix(),  // Transform matrix to ancestor space
                  expected_clip,   // Clip rect in ancestor space
                  local_state, ancestor_state);
 }
 
-TEST_F(GeometryMapperTest, ClipBeforeTransform) {
+TEST_P(GeometryMapperTest, ClipBeforeTransform) {
   TransformationMatrix rotate_transform;
   rotate_transform.Rotate(45);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          rotate_transform, FloatPoint3D());
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::Create(
       ClipPaintPropertyNode::Root(), transform.Get(),
       FloatRoundedRect(10, 10, 50, 50));
 
@@ skipping 10 matching lines @@
   CHECK_MAPPINGS(
       input,                            // Input
       output,                           // Visual rect
       rotate_transform.MapRect(input),  // Transformed rect (not clipped).
       rotate_transform,                 // Transform matrix to ancestor space
       FloatClipRect(rotate_transform.MapRect(
           clip->ClipRect().Rect())),  // Clip rect in ancestor space
       local_state, PropertyTreeState::Root());
 }
 
-TEST_F(GeometryMapperTest, ClipAfterTransform) {
+TEST_P(GeometryMapperTest, ClipAfterTransform) {
   TransformationMatrix rotate_transform;
   rotate_transform.Rotate(45);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          rotate_transform, FloatPoint3D());
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::Create(
       ClipPaintPropertyNode::Root(), TransformPaintPropertyNode::Root(),
       FloatRoundedRect(10, 10, 200, 200));
 
   PropertyTreeState local_state = PropertyTreeState::Root();
   local_state.SetClip(clip.Get());
   local_state.SetTransform(transform.Get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output(input);
   output = rotate_transform.MapRect(output);
   output.Intersect(clip->ClipRect().Rect());
 
   bool has_radius = false;
   CHECK_MAPPINGS(
       input,                            // Input
       output,                           // Visual rect
       rotate_transform.MapRect(input),  // Transformed rect (not clipped)
       rotate_transform,                 // Transform matrix to ancestor space
       FloatClipRect(clip->ClipRect().Rect()),  // Clip rect in ancestor space
       local_state, PropertyTreeState::Root());
 }
 
-TEST_F(GeometryMapperTest, TwoClipsWithTransformBetween) {
+TEST_P(GeometryMapperTest, TwoClipsWithTransformBetween) {
   RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::Create(
       ClipPaintPropertyNode::Root(), TransformPaintPropertyNode::Root(),
       FloatRoundedRect(10, 10, 200, 200));
 
   TransformationMatrix rotate_transform;
   rotate_transform.Rotate(45);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          rotate_transform, FloatPoint3D());
 
@@ skipping 41 matching lines @@
     CHECK_MAPPINGS(
         input,                            // Input
         output,                           // Visual rect
         rotate_transform.MapRect(input),  // Transformed rect (not clipped)
         rotate_transform,                 // Transform matrix to ancestor space
         FloatClipRect(mapped_clip),       // Clip rect in ancestor space
         local_state, PropertyTreeState::Root());
   }
 }
 
-TEST_F(GeometryMapperTest, SiblingTransforms) {
+TEST_P(GeometryMapperTest, SiblingTransforms) {
   // These transforms are siblings. Thus mapping from one to the other requires
   // going through the root.
   TransformationMatrix rotate_transform1;
   rotate_transform1.Rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          rotate_transform1, FloatPoint3D());
 
   TransformationMatrix rotate_transform2;
   rotate_transform2.Rotate(-45);
@@ skipping 44 matching lines @@
       transform1_state, transform2_state, float_clip_rect);
   result = float_clip_rect.Rect();
   EXPECT_RECT_EQ(expected, result);
 
   result = input;
   GeometryMapper::SourceToDestinationRect(transform1.Get(), transform2.Get(),
                                           result);
   EXPECT_RECT_EQ(expected, result);
 }
 
-TEST_F(GeometryMapperTest, SiblingTransformsWithClip) {
+TEST_P(GeometryMapperTest, SiblingTransformsWithClip) {
   // These transforms are siblings. Thus mapping from one to the other requires
   // going through the root.
   TransformationMatrix rotate_transform1;
   rotate_transform1.Rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          rotate_transform1, FloatPoint3D());
 
   TransformationMatrix rotate_transform2;
   rotate_transform2.Rotate(-45);
@@ skipping 48 matching lines @@
   result = float_clip_rect.Rect();
   EXPECT_RECT_EQ(expected_clipped, result);
 
   // sourceToDestinationRect applies transforms only.
   result = input;
   GeometryMapper::SourceToDestinationRect(transform2.Get(), transform1.Get(),
                                           result);
   EXPECT_RECT_EQ(expected_unclipped, result);
 }
 
-TEST_F(GeometryMapperTest, LowestCommonAncestor) {
+TEST_P(GeometryMapperTest, LowestCommonAncestor) {
   TransformationMatrix matrix;
   RefPtr<TransformPaintPropertyNode> child1 =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          matrix, FloatPoint3D());
   RefPtr<TransformPaintPropertyNode> child2 =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          matrix, FloatPoint3D());
 
   RefPtr<TransformPaintPropertyNode> child_of_child1 =
       TransformPaintPropertyNode::Create(child1, matrix, FloatPoint3D());
@@ skipping 15 matching lines @@
             LowestCommonAncestor(child_of_child2.Get(), child1.Get()));
   EXPECT_EQ(TransformPaintPropertyNode::Root(),
             LowestCommonAncestor(child_of_child2.Get(),
                                  TransformPaintPropertyNode::Root()));
   EXPECT_EQ(child2, LowestCommonAncestor(child_of_child2.Get(), child2.Get()));
 
   EXPECT_EQ(TransformPaintPropertyNode::Root(),
             LowestCommonAncestor(child1.Get(), child2.Get()));
 }
 
-TEST_F(GeometryMapperTest, FilterWithClipsAndTransforms) {
+TEST_P(GeometryMapperTest, FilterWithClipsAndTransforms) {
   RefPtr<TransformPaintPropertyNode> transform_above_effect =
       TransformPaintPropertyNode::Create(TransformPaintPropertyNode::Root(),
                                          TransformationMatrix().Scale(3),
                                          FloatPoint3D());
   RefPtr<TransformPaintPropertyNode> transform_below_effect =
       TransformPaintPropertyNode::Create(transform_above_effect,
                                          TransformationMatrix().Scale(2),
                                          FloatPoint3D());
 
   // This clip is between transformAboveEffect and the effect.
@@ skipping 32 matching lines @@
   EXPECT_EQ(FloatRect(-150, -150, 450, 450), output);
 
   bool has_radius = false;
   TransformationMatrix combined_transform =
       transform_above_effect->Matrix() * transform_below_effect->Matrix();
   CHECK_MAPPINGS(input, output, FloatRect(0, 0, 300, 300), combined_transform,
                  FloatClipRect(FloatRect(30, 30, 270, 270)), local_state,
                  PropertyTreeState::Root());
 }
 
-TEST_F(GeometryMapperTest, ReflectionWithPaintOffset) {
+TEST_P(GeometryMapperTest, ReflectionWithPaintOffset) {
   CompositorFilterOperations filters;
   filters.AppendReferenceFilter(SkiaImageFilterBuilder::BuildBoxReflectFilter(
       BoxReflection(BoxReflection::kHorizontalReflection, 0), nullptr));
   RefPtr<EffectPaintPropertyNode> effect = EffectPaintPropertyNode::Create(
       EffectPaintPropertyNode::Root(), TransformPaintPropertyNode::Root(),
       ClipPaintPropertyNode::Root(), kColorFilterNone, filters, 1.0,
       SkBlendMode::kSrcOver, kCompositingReasonNone, CompositorElementId(),
       FloatPoint(100, 100));
 
   PropertyTreeState local_state = PropertyTreeState::Root();
   local_state.SetEffect(effect);
 
   FloatRect input(100, 100, 50, 50);
   // Reflection is at (50, 100, 50, 50).
   FloatRect output(50, 100, 100, 50);
 
   bool has_radius = false;
   CHECK_MAPPINGS(input, output, input, TransformationMatrix(), FloatClipRect(),
                  local_state, PropertyTreeState::Root());
 }
 
+TEST_P(GeometryMapperTest, InvertedClip) {
+  if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+    return;
+
+  RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::Create(
+      ClipPaintPropertyNode::Root(), TransformPaintPropertyNode::Root(),
+      FloatRoundedRect(10, 10, 50, 50));
+
+  PropertyTreeState dest(TransformPaintPropertyNode::Root(), clip.Get(),
+                         EffectPaintPropertyNode::Root());
+
+  FloatClipRect floatClipRect(FloatRect(0, 0, 10, 200));
+  GeometryMapper::LocalToAncestorVisualRect(PropertyTreeState::Root(), dest,
+                                            floatClipRect);
+
+  // The "ancestor" clip is below the source clip in this case, so
+  // LocalToAncestorVisualRect must fall back to the original rect, mapped
+  // into the root space.
+  EXPECT_EQ(FloatRect(0, 0, 10, 200), floatClipRect.Rect());
+}
+
 }  // namespace blink