| // 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 "third_party/blink/renderer/platform/graphics/paint/geometry_mapper.h" |
| #include "build/build_config.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/blink/renderer/platform/geometry/geometry_test_helpers.h" |
| #include "third_party/blink/renderer/platform/geometry/layout_rect.h" |
| #include "third_party/blink/renderer/platform/graphics/box_reflection.h" |
| #include "third_party/blink/renderer/platform/graphics/filters/paint_filter_builder.h" |
| #include "third_party/blink/renderer/platform/graphics/paint/clip_paint_property_node.h" |
| #include "third_party/blink/renderer/platform/graphics/paint/effect_paint_property_node.h" |
| #include "third_party/blink/renderer/platform/graphics/paint/transform_paint_property_node.h" |
| #include "third_party/blink/renderer/platform/testing/paint_property_test_helpers.h" |
| #include "third_party/blink/renderer/platform/testing/paint_test_configurations.h" |
| |
| namespace blink { |
| |
| class GeometryMapperTest : public testing::Test, |
| public PaintTestConfigurations { |
| public: |
| const FloatClipRect* GetCachedClip( |
| 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(), |
| kIgnorePlatformOverlayScrollbarSize); |
| return descendant_clip->GetClipCache().GetCachedClip(clip_and_transform); |
| } |
| |
| void LocalToAncestorVisualRectInternal( |
| const PropertyTreeState& local_state, |
| const PropertyTreeState& ancestor_state, |
| FloatClipRect& mapping_rect, |
| bool& success) { |
| GeometryMapper::LocalToAncestorVisualRectInternal( |
| local_state, ancestor_state, mapping_rect, |
| kIgnorePlatformOverlayScrollbarSize, kNonInclusiveIntersect, success); |
| } |
| |
| // Variables required by CHECK_MAPPINGS(). The tests should set these |
| // variables with proper values before calling CHECK_MAPPINGS(). |
| PropertyTreeState local_state = PropertyTreeState::Root(); |
| PropertyTreeState ancestor_state = PropertyTreeState::Root(); |
| FloatRect input_rect; |
| FloatClipRect expected_visual_rect; |
| TransformationMatrix expected_transform; |
| FloatClipRect expected_clip; |
| FloatRect expected_transformed_rect; |
| }; |
| |
| INSTANTIATE_PAINT_TEST_CASE_P(GeometryMapperTest); |
| |
| #define EXPECT_FLOAT_RECT_NEAR(expected, actual) \ |
| do { \ |
| EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, (actual).X(), \ |
| (expected).X()); \ |
| EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, (actual).Y(), \ |
| (expected).Y()); \ |
| EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, (actual).Width(), \ |
| (expected).Width()); \ |
| EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, (actual).Height(), \ |
| (expected).Height()); \ |
| } while (false) |
| |
| #define EXPECT_CLIP_RECT_EQ(expected, actual) \ |
| do { \ |
| SCOPED_TRACE("EXPECT_CLIP_RECT_EQ: " #expected " vs " #actual); \ |
| EXPECT_EQ((expected).IsInfinite(), (actual).IsInfinite()); \ |
| EXPECT_EQ((expected).HasRadius(), (actual).HasRadius()); \ |
| EXPECT_EQ((expected).IsTight(), (actual).IsTight()); \ |
| if (!(expected).IsInfinite()) \ |
| EXPECT_FLOAT_RECT_NEAR((expected).Rect(), (actual).Rect()); \ |
| } while (false) |
| |
| #define CHECK_LOCAL_TO_ANCESTOR_VISUAL_RECT() \ |
| do { \ |
| SCOPED_TRACE("Check LocalToAncestorVisualRect"); \ |
| FloatClipRect actual_visual_rect(input_rect); \ |
| GeometryMapper::LocalToAncestorVisualRect(local_state, ancestor_state, \ |
| actual_visual_rect); \ |
| EXPECT_CLIP_RECT_EQ(expected_visual_rect, actual_visual_rect); \ |
| } while (false) |
| |
| #define CHECK_LOCAL_TO_ANCESTOR_CLIP_RECT() \ |
| do { \ |
| SCOPED_TRACE("Check LocalToAncestorClipRect"); \ |
| FloatClipRect actual_clip_rect; \ |
| actual_clip_rect = \ |
| GeometryMapper::LocalToAncestorClipRect(local_state, ancestor_state); \ |
| EXPECT_CLIP_RECT_EQ(expected_clip, actual_clip_rect); \ |
| } while (false) |
| |
| #define CHECK_SOURCE_TO_DESTINATION_RECT() \ |
| do { \ |
| SCOPED_TRACE("Check SourceToDestinationRect"); \ |
| auto actual_transformed_rect = input_rect; \ |
| GeometryMapper::SourceToDestinationRect(local_state.Transform(), \ |
| ancestor_state.Transform(), \ |
| actual_transformed_rect); \ |
| EXPECT_FLOAT_RECT_NEAR(expected_transformed_rect, \ |
| actual_transformed_rect); \ |
| } while (false) |
| |
| #define CHECK_SOURCE_TO_DESTINATION_PROJECTION() \ |
| do { \ |
| SCOPED_TRACE("Check SourceToDestinationProjection"); \ |
| const auto& actual_transform_to_ancestor = \ |
| GeometryMapper::SourceToDestinationProjection( \ |
| local_state.Transform(), ancestor_state.Transform()); \ |
| EXPECT_EQ(expected_transform, actual_transform_to_ancestor); \ |
| } while (false) |
| |
| #define CHECK_CACHED_CLIP() \ |
| do { \ |
| if (ancestor_state.Effect() != local_state.Effect()) \ |
| break; \ |
| SCOPED_TRACE("Check cached clip"); \ |
| auto* local_clip = local_state.Clip()->Unalias(); \ |
| const auto* cached_clip = GetCachedClip(local_clip, ancestor_state); \ |
| if (ancestor_state.Clip() == local_clip || \ |
| (ancestor_state.Clip() == local_clip->Parent() && \ |
| ancestor_state.Transform() == local_clip->LocalTransformSpace())) { \ |
| EXPECT_EQ(nullptr, cached_clip); \ |
| break; \ |
| } \ |
| ASSERT_NE(nullptr, cached_clip); \ |
| EXPECT_CLIP_RECT_EQ(expected_clip, *cached_clip); \ |
| } while (false) |
| |
| // See the data fields of GeometryMapperTest for variables that will be used in |
| // this macro. |
| #define CHECK_MAPPINGS() \ |
| do { \ |
| CHECK_LOCAL_TO_ANCESTOR_VISUAL_RECT(); \ |
| CHECK_LOCAL_TO_ANCESTOR_CLIP_RECT(); \ |
| CHECK_SOURCE_TO_DESTINATION_RECT(); \ |
| CHECK_SOURCE_TO_DESTINATION_PROJECTION(); \ |
| { \ |
| SCOPED_TRACE("Repeated check to test caching"); \ |
| CHECK_LOCAL_TO_ANCESTOR_VISUAL_RECT(); \ |
| CHECK_LOCAL_TO_ANCESTOR_CLIP_RECT(); \ |
| CHECK_SOURCE_TO_DESTINATION_RECT(); \ |
| CHECK_SOURCE_TO_DESTINATION_PROJECTION(); \ |
| } \ |
| CHECK_CACHED_CLIP(); \ |
| } while (false) |
| |
| TEST_P(GeometryMapperTest, Root) { |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_visual_rect = FloatClipRect(input_rect); |
| expected_transformed_rect = input_rect; |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, IdentityTransform) { |
| auto transform = CreateTransform(t0(), TransformationMatrix()); |
| local_state.SetTransform(transform.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = input_rect; |
| expected_visual_rect = FloatClipRect(input_rect); |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, TranslationTransform) { |
| expected_transform = TransformationMatrix().Translate(20, 10); |
| auto transform = CreateTransform(t0(), expected_transform); |
| local_state.SetTransform(transform.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| expected_visual_rect = FloatClipRect(expected_transformed_rect); |
| CHECK_MAPPINGS(); |
| |
| FloatRect rect = expected_transformed_rect; |
| GeometryMapper::SourceToDestinationRect(&t0(), local_state.Transform(), rect); |
| EXPECT_FLOAT_RECT_NEAR(input_rect, rect); |
| } |
| |
| TEST_P(GeometryMapperTest, TranslationTransformWithAlias) { |
| expected_transform = TransformationMatrix().Translate(20, 10); |
| auto real_transform = CreateTransform(t0(), expected_transform); |
| auto transform = TransformPaintPropertyNode::CreateAlias(*real_transform); |
| local_state.SetTransform(transform.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| expected_visual_rect = FloatClipRect(expected_transformed_rect); |
| CHECK_MAPPINGS(); |
| |
| FloatRect rect = expected_transformed_rect; |
| GeometryMapper::SourceToDestinationRect(&t0(), local_state.Transform(), rect); |
| EXPECT_FLOAT_RECT_NEAR(input_rect, rect); |
| } |
| |
| TEST_P(GeometryMapperTest, RotationAndScaleTransform) { |
| expected_transform = TransformationMatrix().Rotate(45).Scale(2); |
| auto transform = CreateTransform(t0(), expected_transform); |
| local_state.SetTransform(transform.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| expected_visual_rect = FloatClipRect(expected_transformed_rect); |
| expected_visual_rect.ClearIsTight(); |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, RotationAndScaleTransformWithAlias) { |
| expected_transform = TransformationMatrix().Rotate(45).Scale(2); |
| auto real_transform = CreateTransform(t0(), expected_transform); |
| auto transform = TransformPaintPropertyNode::CreateAlias(*real_transform); |
| local_state.SetTransform(transform.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| expected_visual_rect = FloatClipRect(expected_transformed_rect); |
| expected_visual_rect.ClearIsTight(); |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, RotationAndScaleTransformWithTransformOrigin) { |
| expected_transform = TransformationMatrix().Rotate(45).Scale(2); |
| auto transform = |
| CreateTransform(t0(), expected_transform, FloatPoint3D(50, 50, 0)); |
| local_state.SetTransform(transform.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transform.ApplyTransformOrigin(50, 50, 0); |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| expected_visual_rect = FloatClipRect(expected_transformed_rect); |
| expected_visual_rect.ClearIsTight(); |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, NestedTransforms) { |
| auto rotate_transform = TransformationMatrix().Rotate(45); |
| auto transform1 = CreateTransform(t0(), rotate_transform); |
| |
| auto scale_transform = TransformationMatrix().Scale(2); |
| auto transform2 = CreateTransform(*transform1, scale_transform); |
| local_state.SetTransform(transform2.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transform = rotate_transform * scale_transform; |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| expected_visual_rect = FloatClipRect(expected_transformed_rect); |
| expected_visual_rect.ClearIsTight(); |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, NestedTransformsFlattening) { |
| TransformPaintPropertyNode::State rotate_transform; |
| rotate_transform.matrix.Rotate3d(45, 0, 0); |
| auto transform1 = |
| TransformPaintPropertyNode::Create(t0(), std::move(rotate_transform)); |
| |
| TransformPaintPropertyNode::State inverse_rotate_transform; |
| inverse_rotate_transform.matrix.Rotate3d(-45, 0, 0); |
| inverse_rotate_transform.flattens_inherited_transform = true; |
| auto transform2 = TransformPaintPropertyNode::Create( |
| *transform1, std::move(inverse_rotate_transform)); |
| local_state.SetTransform(transform2.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| rotate_transform.matrix.FlattenTo2d(); |
| expected_transform = |
| rotate_transform.matrix * inverse_rotate_transform.matrix; |
| expected_transform.FlattenTo2d(); |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| expected_visual_rect = FloatClipRect(expected_transformed_rect); |
| expected_visual_rect.ClearIsTight(); |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, NestedTransformsScaleAndTranslation) { |
| auto scale_transform = TransformationMatrix().Scale(2); |
| auto transform1 = CreateTransform(t0(), scale_transform); |
| |
| auto translate_transform = TransformationMatrix().Translate(100, 0); |
| auto transform2 = CreateTransform(*transform1, translate_transform); |
| local_state.SetTransform(transform2.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| // Note: unlike NestedTransforms, the order of these transforms matters. This |
| // tests correct order of matrix multiplication. |
| expected_transform = scale_transform * translate_transform; |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| expected_visual_rect = FloatClipRect(expected_transformed_rect); |
| expected_visual_rect.ClearIsTight(); |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, NestedTransformsIntermediateDestination) { |
| auto translate_transform = TransformationMatrix().Translate(10, 20); |
| auto transform1 = CreateTransform(t0(), translate_transform); |
| |
| auto scale_transform = TransformationMatrix().Scale(3); |
| auto transform2 = CreateTransform(*transform1, scale_transform); |
| |
| local_state.SetTransform(transform2.get()); |
| ancestor_state.SetTransform(transform1.get()); |
| |
| expected_transform = scale_transform; |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| expected_visual_rect = FloatClipRect(expected_transformed_rect); |
| expected_visual_rect.ClearIsTight(); |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, SimpleClip) { |
| auto clip = CreateClip(c0(), &t0(), FloatRoundedRect(10, 10, 50, 50)); |
| local_state.SetClip(clip.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = input_rect; // not clipped. |
| expected_clip = FloatClipRect(clip->ClipRect()); |
| expected_visual_rect = expected_clip; |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, SimpleClipWithAlias) { |
| auto real_clip = CreateClip(c0(), &t0(), FloatRoundedRect(10, 10, 50, 50)); |
| auto clip = ClipPaintPropertyNode::CreateAlias(*real_clip); |
| local_state.SetClip(clip.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = input_rect; // not clipped. |
| expected_clip = FloatClipRect(clip->Unalias()->ClipRect()); |
| expected_visual_rect = expected_clip; |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, SimpleClipOverlayScrollbars) { |
| ClipPaintPropertyNode::State clip_state; |
| clip_state.local_transform_space = &t0(); |
| clip_state.clip_rect = FloatRoundedRect(10, 10, 50, 50); |
| clip_state.clip_rect_excluding_overlay_scrollbars = |
| FloatRoundedRect(10, 10, 45, 43); |
| auto clip = ClipPaintPropertyNode::Create(c0(), std::move(clip_state)); |
| local_state.SetClip(clip.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| |
| FloatClipRect actual_visual_rect(input_rect); |
| GeometryMapper::LocalToAncestorVisualRect( |
| local_state, ancestor_state, actual_visual_rect, |
| kExcludeOverlayScrollbarSizeForHitTesting); |
| EXPECT_CLIP_RECT_EQ(FloatClipRect(FloatRect(10, 10, 45, 43)), |
| actual_visual_rect); |
| |
| // Check that not passing kExcludeOverlayScrollbarSizeForHitTesting gives |
| // a different result. |
| actual_visual_rect = FloatClipRect(input_rect); |
| GeometryMapper::LocalToAncestorVisualRect( |
| local_state, ancestor_state, actual_visual_rect, |
| kIgnorePlatformOverlayScrollbarSize); |
| EXPECT_CLIP_RECT_EQ(FloatClipRect(FloatRect(10, 10, 50, 50)), |
| actual_visual_rect); |
| |
| FloatClipRect actual_clip_rect = GeometryMapper::LocalToAncestorClipRect( |
| local_state, ancestor_state, kExcludeOverlayScrollbarSizeForHitTesting); |
| EXPECT_CLIP_RECT_EQ(FloatClipRect(FloatRect(10, 10, 45, 43)), |
| actual_clip_rect); |
| |
| // Check that not passing kExcludeOverlayScrollbarSizeForHitTesting gives |
| // a different result. |
| actual_clip_rect = GeometryMapper::LocalToAncestorClipRect( |
| local_state, ancestor_state, kIgnorePlatformOverlayScrollbarSize); |
| EXPECT_CLIP_RECT_EQ(FloatClipRect(FloatRect(10, 10, 50, 50)), |
| actual_clip_rect); |
| } |
| |
| TEST_P(GeometryMapperTest, SimpleClipInclusiveIntersect) { |
| auto clip = CreateClip(c0(), &t0(), FloatRoundedRect(10, 10, 50, 50)); |
| local_state.SetClip(clip.get()); |
| |
| FloatClipRect actual_clip_rect(FloatRect(60, 10, 10, 10)); |
| GeometryMapper::LocalToAncestorVisualRect( |
| local_state, ancestor_state, actual_clip_rect, |
| kIgnorePlatformOverlayScrollbarSize, kInclusiveIntersect); |
| EXPECT_CLIP_RECT_EQ(FloatClipRect(FloatRect(60, 10, 0, 10)), |
| actual_clip_rect); |
| |
| // Check that not passing kExcludeOverlayScrollbarSizeForHitTesting gives |
| // a different result. |
| actual_clip_rect.SetRect(FloatRect(60, 10, 10, 10)); |
| GeometryMapper::LocalToAncestorVisualRect( |
| local_state, ancestor_state, actual_clip_rect, |
| kIgnorePlatformOverlayScrollbarSize, kNonInclusiveIntersect); |
| EXPECT_CLIP_RECT_EQ(FloatClipRect(FloatRect()), actual_clip_rect); |
| } |
| |
| TEST_P(GeometryMapperTest, RoundedClip) { |
| FloatRoundedRect rect(FloatRect(10, 10, 50, 50), |
| FloatRoundedRect::Radii(FloatSize(1, 1), FloatSize(), |
| FloatSize(), FloatSize())); |
| auto clip = CreateClip(c0(), &t0(), rect); |
| local_state.SetClip(clip.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = input_rect; |
| expected_clip = FloatClipRect(clip->ClipRect()); |
| EXPECT_TRUE(expected_clip.HasRadius()); |
| expected_visual_rect = expected_clip; |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, ClipPath) { |
| FloatRoundedRect rect(FloatRect(10, 10, 50, 50), |
| FloatRoundedRect::Radii(FloatSize(1, 1), FloatSize(), |
| FloatSize(), FloatSize())); |
| auto clip = CreateClipPathClip(c0(), &t0(), FloatRoundedRect(10, 10, 50, 50)); |
| local_state.SetClip(clip.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = input_rect; |
| expected_clip = FloatClipRect(FloatRect(10, 10, 50, 50)); |
| expected_clip.ClearIsTight(); |
| expected_visual_rect = expected_clip; |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, TwoClips) { |
| FloatRoundedRect clip_rect1( |
| FloatRect(10, 10, 30, 40), |
| FloatRoundedRect::Radii(FloatSize(1, 1), FloatSize(), FloatSize(), |
| FloatSize())); |
| |
| auto clip1 = CreateClip(c0(), &t0(), clip_rect1); |
| auto clip2 = CreateClip(*clip1, &t0(), FloatRoundedRect(10, 10, 50, 50)); |
| local_state.SetClip(clip2.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = input_rect; |
| expected_clip = FloatClipRect(clip1->ClipRect()); |
| EXPECT_TRUE(expected_clip.HasRadius()); |
| expected_visual_rect = expected_clip; |
| CHECK_MAPPINGS(); |
| |
| ancestor_state.SetClip(clip1.get()); |
| expected_clip = FloatClipRect(clip2->ClipRect()); |
| expected_visual_rect = expected_clip; |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, TwoClipsTransformAbove) { |
| auto transform = CreateTransform(t0(), TransformationMatrix()); |
| |
| FloatRoundedRect clip_rect1( |
| FloatRect(10, 10, 50, 50), |
| FloatRoundedRect::Radii(FloatSize(1, 1), FloatSize(), FloatSize(), |
| FloatSize())); |
| |
| auto clip1 = CreateClip(c0(), transform.get(), clip_rect1); |
| auto clip2 = |
| CreateClip(*clip1, transform.get(), FloatRoundedRect(10, 10, 30, 40)); |
| local_state.SetClip(clip2.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = input_rect; |
| expected_clip = FloatClipRect(clip2->ClipRect()); |
| expected_clip.SetHasRadius(); |
| expected_visual_rect = expected_clip; |
| CHECK_MAPPINGS(); |
| |
| expected_clip = FloatClipRect(clip1->ClipRect()); |
| EXPECT_TRUE(expected_clip.HasRadius()); |
| local_state.SetClip(clip1.get()); |
| expected_visual_rect = expected_clip; |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, ClipBeforeTransform) { |
| expected_transform = TransformationMatrix().Rotate(45); |
| auto transform = CreateTransform(t0(), expected_transform); |
| auto clip = |
| CreateClip(c0(), transform.get(), FloatRoundedRect(10, 10, 50, 50)); |
| local_state.SetClip(clip.get()); |
| local_state.SetTransform(transform.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_visual_rect = FloatClipRect(input_rect); |
| expected_visual_rect.Intersect(FloatClipRect(clip->ClipRect())); |
| expected_visual_rect.Map(expected_transform); |
| EXPECT_FALSE(expected_visual_rect.IsTight()); |
| expected_clip = FloatClipRect(clip->ClipRect()); |
| expected_clip.Map(expected_transform); |
| EXPECT_FALSE(expected_clip.IsTight()); |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, ClipAfterTransform) { |
| expected_transform = TransformationMatrix().Rotate(45); |
| auto transform = CreateTransform(t0(), expected_transform); |
| auto clip = CreateClip(c0(), &t0(), FloatRoundedRect(10, 10, 200, 200)); |
| local_state.SetClip(clip.get()); |
| local_state.SetTransform(transform.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| expected_visual_rect = FloatClipRect(input_rect); |
| expected_visual_rect.Map(expected_transform); |
| expected_visual_rect.Intersect(FloatClipRect(clip->ClipRect())); |
| EXPECT_FALSE(expected_visual_rect.IsTight()); |
| expected_clip = FloatClipRect(clip->ClipRect()); |
| EXPECT_TRUE(expected_clip.IsTight()); |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, TwoClipsWithTransformBetween) { |
| auto clip1 = CreateClip(c0(), &t0(), FloatRoundedRect(10, 10, 200, 200)); |
| expected_transform = TransformationMatrix().Rotate(45); |
| auto transform = CreateTransform(t0(), expected_transform); |
| auto clip2 = |
| CreateClip(*clip1, transform.get(), FloatRoundedRect(10, 10, 200, 200)); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| |
| { |
| local_state.SetClip(clip1.get()); |
| local_state.SetTransform(transform.get()); |
| |
| expected_visual_rect = FloatClipRect(input_rect); |
| expected_visual_rect.Map(expected_transform); |
| expected_visual_rect.Intersect(FloatClipRect(clip1->ClipRect())); |
| EXPECT_FALSE(expected_visual_rect.IsTight()); |
| expected_clip = FloatClipRect(clip1->ClipRect()); |
| EXPECT_TRUE(expected_clip.IsTight()); |
| CHECK_MAPPINGS(); |
| } |
| |
| { |
| local_state.SetClip(clip2.get()); |
| local_state.SetTransform(transform.get()); |
| |
| expected_clip = FloatClipRect(clip2->ClipRect()); |
| expected_clip.Map(expected_transform); |
| expected_clip.Intersect(FloatClipRect(clip1->ClipRect())); |
| EXPECT_FALSE(expected_clip.IsTight()); |
| |
| // All clips are performed in the space of the ancestor. In cases such as |
| // this, this means the clip is not tight. |
| expected_visual_rect = FloatClipRect(input_rect); |
| expected_visual_rect.Map(expected_transform); |
| // Intersect with all clips between local and ancestor, independently mapped |
| // to ancestor space. |
| expected_visual_rect.Intersect(expected_clip); |
| EXPECT_FALSE(expected_visual_rect.IsTight()); |
| |
| CHECK_MAPPINGS(); |
| } |
| } |
| |
| TEST_P(GeometryMapperTest, SiblingTransforms) { |
| // These transforms are siblings. Thus mapping from one to the other requires |
| // going through the root. |
| auto rotate_transform1 = TransformationMatrix().Rotate(45); |
| auto transform1 = CreateTransform(t0(), rotate_transform1); |
| |
| auto rotate_transform2 = TransformationMatrix().Rotate(-45); |
| auto transform2 = CreateTransform(t0(), rotate_transform2); |
| |
| auto transform1_state = PropertyTreeState::Root(); |
| transform1_state.SetTransform(transform1.get()); |
| auto transform2_state = PropertyTreeState::Root(); |
| transform2_state.SetTransform(transform2.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| FloatClipRect result_clip(input_rect); |
| GeometryMapper::LocalToAncestorVisualRect(transform1_state, transform2_state, |
| result_clip); |
| FloatClipRect expected_clip(FloatRect(-100, 0, 100, 100)); |
| // We convervatively treat any rotated clip rect as not tight, even if it's |
| // rotated by 90 degrees. |
| expected_clip.ClearIsTight(); |
| EXPECT_CLIP_RECT_EQ(expected_clip, result_clip); |
| |
| FloatRect result = input_rect; |
| GeometryMapper::SourceToDestinationRect(transform1.get(), transform2.get(), |
| result); |
| EXPECT_FLOAT_RECT_NEAR(FloatRect(-100, 0, 100, 100), result); |
| |
| result_clip = FloatClipRect(input_rect); |
| GeometryMapper::LocalToAncestorVisualRect(transform2_state, transform1_state, |
| result_clip); |
| expected_clip = FloatClipRect(FloatRect(0, -100, 100, 100)); |
| expected_clip.ClearIsTight(); |
| EXPECT_CLIP_RECT_EQ(expected_clip, result_clip); |
| |
| result = input_rect; |
| GeometryMapper::SourceToDestinationRect(transform2.get(), transform1.get(), |
| result); |
| EXPECT_FLOAT_RECT_NEAR(FloatRect(0, -100, 100, 100), result); |
| } |
| |
| TEST_P(GeometryMapperTest, SiblingTransformsWithClip) { |
| // These transforms are siblings. Thus mapping from one to the other requires |
| // going through the root. |
| auto rotate_transform1 = TransformationMatrix().Rotate(45); |
| auto transform1 = CreateTransform(t0(), rotate_transform1); |
| |
| auto rotate_transform2 = TransformationMatrix().Rotate(-45); |
| auto transform2 = CreateTransform(t0(), rotate_transform2); |
| |
| auto clip = |
| CreateClip(c0(), transform2.get(), FloatRoundedRect(10, 20, 30, 40)); |
| |
| auto transform1_state = PropertyTreeState::Root(); |
| transform1_state.SetTransform(transform1.get()); |
| auto transform2_and_clip_state = PropertyTreeState::Root(); |
| transform2_and_clip_state.SetTransform(transform2.get()); |
| transform2_and_clip_state.SetClip(clip.get()); |
| |
| bool success; |
| input_rect = FloatRect(0, 0, 100, 100); |
| FloatClipRect result(input_rect); |
| LocalToAncestorVisualRectInternal(transform1_state, transform2_and_clip_state, |
| result, success); |
| // Fails, because the clip of the destination state is not an ancestor of the |
| // clip of the source state. A known bug in SPv1 would make such query, |
| // in such case, no clips are applied. |
| if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled()) { |
| EXPECT_FALSE(success); |
| } else { |
| EXPECT_TRUE(success); |
| FloatClipRect expected(FloatRect(-100, 0, 100, 100)); |
| expected.ClearIsTight(); |
| EXPECT_CLIP_RECT_EQ(expected, result); |
| } |
| |
| result = FloatClipRect(input_rect); |
| GeometryMapper::LocalToAncestorVisualRect(transform2_and_clip_state, |
| transform1_state, result); |
| FloatClipRect expected(FloatRect(20, -40, 40, 30)); |
| // This is because the combined Rotate(45) and Rotate(-45) is not exactly a |
| // translation-only transform due to calculation errors. |
| expected.ClearIsTight(); |
| EXPECT_CLIP_RECT_EQ(expected, result); |
| } |
| |
| TEST_P(GeometryMapperTest, FilterWithClipsAndTransforms) { |
| auto transform_above_effect = |
| CreateTransform(t0(), TransformationMatrix().Translate(40, 50)); |
| auto transform_below_effect = CreateTransform( |
| *transform_above_effect, TransformationMatrix().Translate(20, 30)); |
| |
| // This clip is between transformAboveEffect and the effect. |
| auto clip_above_effect = CreateClip(c0(), transform_above_effect.get(), |
| FloatRoundedRect(-100, -100, 200, 200)); |
| // This clip is between the effect and transformBelowEffect. |
| auto clip_below_effect = |
| CreateClip(*clip_above_effect, transform_above_effect.get(), |
| FloatRoundedRect(10, 10, 100, 100)); |
| |
| CompositorFilterOperations filters; |
| filters.AppendBlurFilter(20); |
| auto effect = CreateFilterEffect(e0(), transform_above_effect.get(), |
| clip_above_effect.get(), filters); |
| |
| local_state = PropertyTreeState(transform_below_effect.get(), |
| clip_below_effect.get(), effect.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| // 1. transformBelowEffect |
| auto output = transform_below_effect->Matrix().MapRect(input_rect); |
| // 2. clipBelowEffect |
| output.Intersect(clip_below_effect->ClipRect().Rect()); |
| EXPECT_EQ(FloatRect(20, 30, 90, 80), output); |
| // 3. effect (the outset is 3 times of blur amount). |
| output = filters.MapRect(output); |
| EXPECT_EQ(FloatRect(-40, -30, 210, 200), output); |
| // 4. clipAboveEffect |
| output.Intersect(clip_above_effect->ClipRect().Rect()); |
| EXPECT_EQ(FloatRect(-40, -30, 140, 130), output); |
| // 5. transformAboveEffect |
| output = transform_above_effect->Matrix().MapRect(output); |
| EXPECT_EQ(FloatRect(0, 20, 140, 130), output); |
| |
| expected_transform = |
| transform_above_effect->Matrix() * transform_below_effect->Matrix(); |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| expected_visual_rect = FloatClipRect(output); |
| expected_visual_rect.ClearIsTight(); |
| expected_clip = FloatClipRect(FloatRect(50, 60, 90, 90)); |
| expected_clip.ClearIsTight(); |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, FilterWithClipsAndTransformsWithAlias) { |
| auto transform_above_effect = |
| CreateTransform(t0(), TransformationMatrix().Translate(40, 50)); |
| auto transform_below_effect = CreateTransform( |
| *transform_above_effect, TransformationMatrix().Translate(20, 30)); |
| |
| // This clip is between transformAboveEffect and the effect. |
| auto clip_above_effect = CreateClip(c0(), transform_above_effect.get(), |
| FloatRoundedRect(-100, -100, 200, 200)); |
| // This clip is between the effect and transformBelowEffect. |
| auto clip_below_effect = |
| CreateClip(*clip_above_effect, transform_above_effect.get(), |
| FloatRoundedRect(10, 10, 100, 100)); |
| |
| CompositorFilterOperations filters; |
| filters.AppendBlurFilter(20); |
| auto real_effect = CreateFilterEffect(e0(), transform_above_effect.get(), |
| clip_above_effect.get(), filters); |
| auto effect = EffectPaintPropertyNode::CreateAlias(*real_effect); |
| |
| local_state = PropertyTreeState(transform_below_effect.get(), |
| clip_below_effect.get(), effect.get()); |
| |
| input_rect = FloatRect(0, 0, 100, 100); |
| // 1. transformBelowEffect |
| auto output = transform_below_effect->Matrix().MapRect(input_rect); |
| // 2. clipBelowEffect |
| output.Intersect(clip_below_effect->ClipRect().Rect()); |
| EXPECT_EQ(FloatRect(20, 30, 90, 80), output); |
| // 3. effect (the outset is 3 times of blur amount). |
| output = filters.MapRect(output); |
| EXPECT_EQ(FloatRect(-40, -30, 210, 200), output); |
| // 4. clipAboveEffect |
| output.Intersect(clip_above_effect->ClipRect().Rect()); |
| EXPECT_EQ(FloatRect(-40, -30, 140, 130), output); |
| // 5. transformAboveEffect |
| output = transform_above_effect->Matrix().MapRect(output); |
| EXPECT_EQ(FloatRect(0, 20, 140, 130), output); |
| |
| expected_transform = |
| transform_above_effect->Matrix() * transform_below_effect->Matrix(); |
| expected_transformed_rect = expected_transform.MapRect(input_rect); |
| expected_visual_rect = FloatClipRect(output); |
| expected_visual_rect.ClearIsTight(); |
| expected_clip = FloatClipRect(FloatRect(50, 60, 90, 90)); |
| expected_clip.ClearIsTight(); |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, ReflectionWithPaintOffset) { |
| CompositorFilterOperations filters; |
| filters.AppendReferenceFilter(paint_filter_builder::BuildBoxReflectFilter( |
| BoxReflection(BoxReflection::kHorizontalReflection, 0), nullptr)); |
| auto effect = CreateFilterEffect(e0(), filters, FloatPoint(100, 100)); |
| local_state.SetEffect(effect.get()); |
| |
| input_rect = FloatRect(100, 100, 50, 50); |
| expected_transformed_rect = input_rect; |
| // Reflection is at (50, 100, 50, 50). |
| expected_visual_rect = FloatClipRect(FloatRect(50, 100, 100, 50)); |
| expected_visual_rect.ClearIsTight(); |
| |
| CHECK_MAPPINGS(); |
| } |
| |
| TEST_P(GeometryMapperTest, InvertedClip) { |
| // This test is invalid for CAP. |
| if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled()) |
| return; |
| |
| auto clip = CreateClip(c0(), &t0(), FloatRoundedRect(10, 10, 50, 50)); |
| PropertyTreeState dest(&t0(), clip.get(), &e0()); |
| |
| FloatClipRect visual_rect(FloatRect(0, 0, 10, 200)); |
| GeometryMapper::LocalToAncestorVisualRect(PropertyTreeState::Root(), dest, |
| visual_rect); |
| |
| // 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), visual_rect.Rect()); |
| EXPECT_FALSE(visual_rect.IsTight()); |
| } |
| |
| TEST_P(GeometryMapperTest, PointVisibleInAncestorSpaceSimpleClip) { |
| auto clip = CreateClip(c0(), &t0(), FloatRoundedRect(10, 10, 50, 50)); |
| |
| PropertyTreeState local_state(&t0(), clip.get(), &e0()); |
| PropertyTreeState ancestor_state = PropertyTreeState::Root(); |
| |
| EXPECT_TRUE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(30, 30))); |
| |
| EXPECT_TRUE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(11, 11))); |
| |
| EXPECT_FALSE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(5, 5))); |
| } |
| |
| TEST_P(GeometryMapperTest, PointVisibleInAncestorSpaceRoundedClip) { |
| FloatRoundedRect clip_rect(FloatRoundedRect(10, 10, 50, 50)); |
| FloatRoundedRect::Radii radii; |
| radii.SetTopLeft(FloatSize(8, 8)); |
| clip_rect.SetRadii(radii); |
| auto clip = CreateClip(c0(), &t0(), clip_rect); |
| |
| PropertyTreeState local_state(&t0(), clip.get(), &e0()); |
| PropertyTreeState ancestor_state = PropertyTreeState::Root(); |
| |
| EXPECT_TRUE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(30, 30))); |
| |
| // Clipped out by radius. |
| EXPECT_FALSE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(11, 11))); |
| |
| EXPECT_FALSE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(5, 5))); |
| } |
| |
| TEST_P(GeometryMapperTest, PointVisibleInAncestorSpaceClipPath) { |
| RefCountedPath* path = new RefCountedPath; |
| path->MoveTo(FloatPoint(10, 10)); |
| path->AddLineTo(FloatPoint(10, 60)); |
| path->AddLineTo(FloatPoint(60, 60)); |
| path->AddLineTo(FloatPoint(60, 10)); |
| path->AddLineTo(FloatPoint(10, 10)); |
| |
| ClipPaintPropertyNode::State state; |
| state.local_transform_space = &t0(); |
| state.clip_rect = FloatRoundedRect(FloatRect(0, 0, 500, 500)); |
| state.clip_path = base::AdoptRef(path); |
| auto clip = ClipPaintPropertyNode::Create(c0(), std::move(state)); |
| |
| PropertyTreeState local_state(&t0(), clip.get(), &e0()); |
| PropertyTreeState ancestor_state = PropertyTreeState::Root(); |
| |
| EXPECT_TRUE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(30, 30))); |
| |
| EXPECT_TRUE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(11, 11))); |
| |
| EXPECT_FALSE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(5, 5))); |
| } |
| |
| TEST_P(GeometryMapperTest, PointVisibleInAncestorSpaceSimpleClipWithTransform) { |
| auto transform = |
| CreateTransform(t0(), TransformationMatrix().Translate(10, 10)); |
| auto clip = |
| CreateClip(c0(), &t0(), FloatRoundedRect(FloatRect(20, 20, 50, 50))); |
| |
| PropertyTreeState local_state(transform.get(), clip.get(), &e0()); |
| PropertyTreeState ancestor_state = PropertyTreeState::Root(); |
| |
| EXPECT_TRUE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(30, 30))); |
| |
| EXPECT_TRUE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(11, 11))); |
| |
| EXPECT_FALSE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(5, 5))); |
| } |
| |
| TEST_P(GeometryMapperTest, PointVisibleInAncestorSpaceClipPathWithTransform) { |
| auto transform = |
| CreateTransform(t0(), TransformationMatrix().Translate(10, 10)); |
| |
| RefCountedPath* path = new RefCountedPath; |
| path->MoveTo(FloatPoint(20, 20)); |
| path->AddLineTo(FloatPoint(20, 60)); |
| path->AddLineTo(FloatPoint(60, 60)); |
| path->AddLineTo(FloatPoint(60, 20)); |
| path->AddLineTo(FloatPoint(20, 20)); |
| |
| ClipPaintPropertyNode::State state; |
| state.local_transform_space = &t0(); |
| state.clip_rect = FloatRoundedRect(FloatRect(0, 0, 500, 500)); |
| state.clip_path = base::AdoptRef(path); |
| auto clip = ClipPaintPropertyNode::Create(c0(), std::move(state)); |
| |
| PropertyTreeState local_state(transform.get(), clip.get(), &e0()); |
| PropertyTreeState ancestor_state = PropertyTreeState::Root(); |
| |
| EXPECT_TRUE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(30, 30))); |
| |
| EXPECT_TRUE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(11, 11))); |
| |
| EXPECT_FALSE(GeometryMapper::PointVisibleInAncestorSpace( |
| local_state, ancestor_state, FloatPoint(5, 5))); |
| } |
| |
| TEST_P(GeometryMapperTest, Precision) { |
| auto t1 = CreateTransform(t0(), TransformationMatrix().Scale(32767)); |
| auto t2 = CreateTransform(*t1, TransformationMatrix().Rotate(1)); |
| auto t3 = CreateTransform(*t2, TransformationMatrix()); |
| auto t4 = CreateTransform(*t3, TransformationMatrix()); |
| EXPECT_EQ(TransformationMatrix(), |
| GeometryMapper::SourceToDestinationProjection(t4.get(), t4.get())); |
| EXPECT_EQ(TransformationMatrix(), |
| GeometryMapper::SourceToDestinationProjection(t3.get(), t4.get())); |
| EXPECT_EQ(TransformationMatrix(), |
| GeometryMapper::SourceToDestinationProjection(t2.get(), t4.get())); |
| EXPECT_EQ(TransformationMatrix(), |
| GeometryMapper::SourceToDestinationProjection(t3.get(), t2.get())); |
| EXPECT_EQ(TransformationMatrix(), |
| GeometryMapper::SourceToDestinationProjection(t4.get(), t2.get())); |
| EXPECT_EQ(TransformationMatrix(), |
| GeometryMapper::SourceToDestinationProjection(t4.get(), t3.get())); |
| EXPECT_EQ(TransformationMatrix(), |
| GeometryMapper::SourceToDestinationProjection(t2.get(), t3.get())); |
| } |
| |
| } // namespace blink |
