Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(141)

Unified Diff: cc/trees/layer_tree_host_common_unittest.cc

Issue 1902893002: cc: Move calculation of content rect to RenderSurfaceImpl class (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@targetid
Patch Set: fix error Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « cc/trees/layer_tree_host_common.cc ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/trees/layer_tree_host_common_unittest.cc
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index bb3b18dec062a87b04a17fdf4f6bfad0a346f4bb..07170e35e498c7d95ba53ed8398d3a0e46d71a1b 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -104,6 +104,41 @@ class LayerTreeHostCommonScalingTest : public LayerTreeHostCommonTest {
: LayerTreeHostCommonTest(LayerTreeSettingsScaleContent()) {}
};
+class LayerTreeHostCommonDrawRectsTest : public LayerTreeHostCommonTest {
+ public:
+ LayerTreeHostCommonDrawRectsTest() : LayerTreeHostCommonTest() {}
+
+ LayerImpl* TestVisibleRectAndDrawableContentRect(
+ const gfx::Rect& target_rect,
+ const gfx::Transform& layer_transform,
+ const gfx::Rect& layer_rect) {
+ LayerImpl* root = root_layer();
+ LayerImpl* target = AddChild<LayerImpl>(root);
+ LayerImpl* drawing_layer = AddChild<LayerImpl>(target);
+
+ root->SetDrawsContent(true);
+ target->SetDrawsContent(true);
+ target->SetMasksToBounds(true);
+ drawing_layer->SetDrawsContent(true);
+
+ gfx::Transform identity;
+
+ SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
+ gfx::Size(500, 500), true, false, true);
+ SetLayerPropertiesForTesting(target, identity, gfx::Point3F(),
+ gfx::PointF(target_rect.origin()),
+ target_rect.size(), true, false, true);
+ SetLayerPropertiesForTesting(drawing_layer, layer_transform, gfx::Point3F(),
+ gfx::PointF(layer_rect.origin()),
+ layer_rect.size(), true, false, false);
+
+ host_impl()->active_tree()->property_trees()->needs_rebuild = true;
+ ExecuteCalculateDrawProperties(root);
+
+ return drawing_layer;
+ }
+};
+
TEST_F(LayerTreeHostCommonTest, TransformsForNoOpLayer) {
// Sanity check: For layers positioned at zero, with zero size,
// and with identity transforms, then the draw transform,
@@ -2696,70 +2731,47 @@ TEST_F(LayerTreeHostCommonTest,
EXPECT_TRUE(great_grand_child->screen_space_transform_is_animating());
}
-TEST_F(LayerTreeHostCommonTest, VisibleRectForIdentityTransform) {
- // Test the calculateVisibleRect() function works correctly for identity
- // transforms.
+TEST_F(LayerTreeHostCommonDrawRectsTest, DrawRectsForIdentityTransform) {
+ // Test visible layer rect and drawable content rect are calculated correctly
+ // correctly for identity transforms.
gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
gfx::Transform layer_to_surface_transform;
// Case 1: Layer is contained within the surface.
gfx::Rect layer_content_rect = gfx::Rect(10, 10, 30, 30);
- gfx::Rect expected = gfx::Rect(10, 10, 30, 30);
- gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected, actual);
+ gfx::Rect expected_visible_layer_rect = gfx::Rect(30, 30);
+ gfx::Rect expected_drawable_content_rect = gfx::Rect(10, 10, 30, 30);
+ LayerImpl* drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
// Case 2: Layer is outside the surface rect.
layer_content_rect = gfx::Rect(120, 120, 30, 30);
- actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_TRUE(actual.IsEmpty());
+ expected_visible_layer_rect = gfx::Rect();
+ expected_drawable_content_rect = gfx::Rect();
+ drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
// Case 3: Layer is partially overlapping the surface rect.
layer_content_rect = gfx::Rect(80, 80, 30, 30);
- expected = gfx::Rect(80, 80, 20, 20);
- actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected, actual);
+ expected_visible_layer_rect = gfx::Rect(20, 20);
+ expected_drawable_content_rect = gfx::Rect(80, 80, 20, 20);
+ drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
}
-TEST_F(LayerTreeHostCommonTest, VisibleRectForTranslations) {
- // Test the calculateVisibleRect() function works correctly for scaling
- // transforms.
-
- gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
- gfx::Rect layer_content_rect = gfx::Rect(0, 0, 30, 30);
- gfx::Transform layer_to_surface_transform;
-
- // Case 1: Layer is contained within the surface.
- layer_to_surface_transform.MakeIdentity();
- layer_to_surface_transform.Translate(10.0, 10.0);
- gfx::Rect expected = gfx::Rect(0, 0, 30, 30);
- gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected, actual);
-
- // Case 2: Layer is outside the surface rect.
- layer_to_surface_transform.MakeIdentity();
- layer_to_surface_transform.Translate(120.0, 120.0);
- actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_TRUE(actual.IsEmpty());
-
- // Case 3: Layer is partially overlapping the surface rect.
- layer_to_surface_transform.MakeIdentity();
- layer_to_surface_transform.Translate(80.0, 80.0);
- expected = gfx::Rect(0, 0, 20, 20);
- actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected, actual);
-}
-
-TEST_F(LayerTreeHostCommonTest, VisibleRectFor2DRotations) {
- // Test the calculateVisibleRect() function works correctly for rotations
- // about z-axis (i.e. 2D rotations). Remember that calculateVisibleRect()
- // should return the g in the layer's space.
+TEST_F(LayerTreeHostCommonDrawRectsTest, DrawRectsFor2DRotations) {
+ // Test visible layer rect and drawable content rect are calculated correctly
+ // for rotations about z-axis (i.e. 2D rotations).
gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
gfx::Rect layer_content_rect = gfx::Rect(0, 0, 30, 30);
@@ -2769,18 +2781,25 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectFor2DRotations) {
layer_to_surface_transform.MakeIdentity();
layer_to_surface_transform.Translate(50.0, 50.0);
layer_to_surface_transform.Rotate(45.0);
- gfx::Rect expected = gfx::Rect(0, 0, 30, 30);
- gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected, actual);
+ gfx::Rect expected_visible_layer_rect = gfx::Rect(30, 30);
+ gfx::Rect expected_drawable_content_rect = gfx::Rect(28, 50, 44, 43);
+ LayerImpl* drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
// Case 2: Layer is outside the surface rect.
layer_to_surface_transform.MakeIdentity();
layer_to_surface_transform.Translate(-50.0, 0.0);
layer_to_surface_transform.Rotate(45.0);
- actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_TRUE(actual.IsEmpty());
+ expected_visible_layer_rect = gfx::Rect();
+ expected_drawable_content_rect = gfx::Rect();
+ drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
// Case 3: The layer is rotated about its top-left corner. In surface space,
// the layer is oriented diagonally, with the left half outside of the render
@@ -2789,10 +2808,13 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectFor2DRotations) {
// and bottom-right corners of the layer are still visible.
layer_to_surface_transform.MakeIdentity();
layer_to_surface_transform.Rotate(45.0);
- expected = gfx::Rect(0, 0, 30, 30);
- actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected, actual);
+ expected_visible_layer_rect = gfx::Rect(30, 30);
+ expected_drawable_content_rect = gfx::Rect(22, 43);
+ drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
// Case 4: The layer is rotated about its top-left corner, and translated
// upwards. In surface space, the layer is oriented diagonally, with only the
@@ -2802,15 +2824,19 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectFor2DRotations) {
layer_to_surface_transform.MakeIdentity();
layer_to_surface_transform.Translate(0.0, -sqrt(2.0) * 15.0);
layer_to_surface_transform.Rotate(45.0);
- expected = gfx::Rect(15, 0, 15, 30); // Right half of layer bounds.
- actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected, actual);
+ // Right half of layer bounds.
+ expected_visible_layer_rect = gfx::Rect(15, 0, 15, 30);
+ expected_drawable_content_rect = gfx::Rect(22, 22);
+ drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
}
-TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dOrthographicTransform) {
- // Test that the calculateVisibleRect() function works correctly for 3d
- // transforms.
+TEST_F(LayerTreeHostCommonDrawRectsTest, DrawRectsFor3dOrthographicTransform) {
+ // Test visible layer rect and drawable content rect are calculated correctly
+ // for 3d transforms.
gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
gfx::Rect layer_content_rect = gfx::Rect(0, 0, 100, 100);
@@ -2818,32 +2844,40 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dOrthographicTransform) {
// Case 1: Orthographic projection of a layer rotated about y-axis by 45
// degrees, should be fully contained in the render surface.
+ // 100 is the un-rotated layer width; divided by sqrt(2) is the rotated width.
layer_to_surface_transform.MakeIdentity();
layer_to_surface_transform.RotateAboutYAxis(45.0);
- gfx::Rect expected = gfx::Rect(0, 0, 100, 100);
- gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected, actual);
+ gfx::Rect expected_visible_layer_rect = gfx::Rect(100, 100);
+ gfx::Rect expected_drawable_content_rect = gfx::Rect(71, 100);
+ LayerImpl* drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
// Case 2: Orthographic projection of a layer rotated about y-axis by 45
// degrees, but shifted to the side so only the right-half the layer would be
// visible on the surface.
- // 100 is the un-rotated layer width; divided by sqrt(2) is the rotated width.
+ // 50 is the un-rotated layer width; divided by sqrt(2) is the rotated width.
SkMScalar half_width_of_rotated_layer =
SkDoubleToMScalar((100.0 / sqrt(2.0)) * 0.5);
layer_to_surface_transform.MakeIdentity();
layer_to_surface_transform.Translate(-half_width_of_rotated_layer, 0.0);
layer_to_surface_transform.RotateAboutYAxis(45.0); // Rotates about the left
// edge of the layer.
- expected = gfx::Rect(50, 0, 50, 100); // Tight half of the layer.
- actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected, actual);
+ // Tight half of the layer.
+ expected_visible_layer_rect = gfx::Rect(50, 0, 50, 100);
+ expected_drawable_content_rect = gfx::Rect(36, 100);
+ drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
}
-TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveTransform) {
- // Test the calculateVisibleRect() function works correctly when the layer has
- // a perspective projection onto the target surface.
+TEST_F(LayerTreeHostCommonDrawRectsTest, DrawRectsFor3dPerspectiveTransform) {
+ // Test visible layer rect and drawable content rect are calculated correctly
+ // when the layer has a perspective projection onto the target surface.
gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
gfx::Rect layer_content_rect = gfx::Rect(-50, -50, 200, 200);
@@ -2863,10 +2897,15 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveTransform) {
// This translate places the layer in front of the surface's projection plane.
layer_to_surface_transform.Translate3d(0.0, 0.0, -27.0);
- gfx::Rect expected = gfx::Rect(-50, -50, 200, 200);
- gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected, actual);
+ // Layer position is (-50, -50), visible rect in layer space is layer bounds
+ // offset by layer position.
+ gfx::Rect expected_visible_layer_rect = gfx::Rect(50, 50, 150, 150);
+ gfx::Rect expected_drawable_content_rect = gfx::Rect(38, 38);
+ LayerImpl* drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
// Case 2: same projection as before, except that the layer is also translated
// to the side, so that only the right half of the layer should be visible.
@@ -2874,20 +2913,23 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveTransform) {
// Explanation of expected result: The perspective ratio is (z distance
// between layer and camera origin) / (z distance between projection plane and
// camera origin) == ((-27 - 9) / 9) Then, by similar triangles, if we want to
- // move a layer by translating -50 units in projected surface units (so that
+ // move a layer by translating -25 units in projected surface units (so that
// only half of it is visible), then we would need to translate by (-36 / 9) *
- // -50 == -200 in the layer's units.
- layer_to_surface_transform.Translate3d(-200.0, 0.0, 0.0);
- expected = gfx::Rect(gfx::Point(50, -50),
- gfx::Size(100, 200)); // The right half of the layer's
- // bounding rect.
- actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected, actual);
+ // -25 == -100 in the layer's units.
+ layer_to_surface_transform.Translate3d(-100.0, 0.0, 0.0);
+ // Visible layer rect is moved by 100, and drawable content rect is in target
+ // space and is moved by 25.
+ expected_visible_layer_rect = gfx::Rect(150, 50, 50, 150);
+ expected_drawable_content_rect = gfx::Rect(13, 38);
+ drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
}
-TEST_F(LayerTreeHostCommonTest,
- VisibleRectFor3dOrthographicIsNotClippedBehindSurface) {
+TEST_F(LayerTreeHostCommonDrawRectsTest,
+ DrawRectsFor3dOrthographicIsNotClippedBehindSurface) {
// There is currently no explicit concept of an orthographic projection plane
// in our code (nor in the CSS spec to my knowledge). Therefore, layers that
// are technically behind the surface in an orthographic world should not be
@@ -2904,22 +2946,30 @@ TEST_F(LayerTreeHostCommonTest,
layer_to_surface_transform.RotateAboutYAxis(45.0);
layer_to_surface_transform.Translate(-50.0, 0.0);
- gfx::Rect expected = gfx::Rect(0, 0, 100, 100);
- gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected, actual);
+ // Layer is rotated about Y Axis, and its width is 100/sqrt(2) in surface
+ // space.
+ gfx::Rect expected_visible_layer_rect = gfx::Rect(100, 100);
+ gfx::Rect expected_drawable_content_rect = gfx::Rect(14, 0, 72, 100);
+ LayerImpl* drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
}
-TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveWhenClippedByW) {
- // Test the calculateVisibleRect() function works correctly when projecting a
- // surface onto a layer, but the layer is partially behind the camera (not
- // just behind the projection plane). In this case, the cartesian coordinates
- // may seem to be valid, but actually they are not. The visible rect needs to
- // be properly clipped by the w = 0 plane in homogeneous coordinates before
- // converting to cartesian coordinates.
+TEST_F(LayerTreeHostCommonDrawRectsTest,
+ DrawRectsFor3dPerspectiveWhenClippedByW) {
+ // Test visible layer rect and drawable content rect are calculated correctly
+ // when projecting a surface onto a layer, but the layer is partially behind
+ // the camera (not just behind the projection plane). In this case, the
+ // cartesian coordinates may seem to be valid, but actually they are not. The
+ // visible rect needs to be properly clipped by the w = 0 plane in homogeneous
+ // coordinates before converting to cartesian coordinates. The drawable
+ // content rect would be entire surface rect because layer is rotated at the
+ // camera position.
- gfx::Rect target_surface_rect = gfx::Rect(-50, -50, 100, 100);
- gfx::Rect layer_content_rect = gfx::Rect(-10, -1, 20, 2);
+ gfx::Rect target_surface_rect = gfx::Rect(0, 0, 200, 200);
+ gfx::Rect layer_content_rect = gfx::Rect(0, 0, 20, 2);
gfx::Transform layer_to_surface_transform;
// The layer is positioned so that the right half of the layer should be in
@@ -2928,8 +2978,9 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveWhenClippedByW) {
// perspective and rotation about the center of the layer.
layer_to_surface_transform.MakeIdentity();
layer_to_surface_transform.ApplyPerspectiveDepth(1.0);
- layer_to_surface_transform.Translate3d(-2.0, 0.0, 1.0);
- layer_to_surface_transform.RotateAboutYAxis(45.0);
+ layer_to_surface_transform.Translate3d(10.0, 0.0, 1.0);
+ layer_to_surface_transform.RotateAboutYAxis(-45.0);
+ layer_to_surface_transform.Translate(-10, -1);
// Sanity check that this transform does indeed cause w < 0 when applying the
// transform, otherwise this code is not testing the intended scenario.
@@ -2939,15 +2990,16 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveWhenClippedByW) {
&clipped);
ASSERT_TRUE(clipped);
- int expected_x_position = 0;
- int expected_width = 10;
- gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected_x_position, actual.x());
- EXPECT_EQ(expected_width, actual.width());
+ gfx::Rect expected_visible_layer_rect = gfx::Rect(0, 1, 10, 1);
+ gfx::Rect expected_drawable_content_rect = target_surface_rect;
+ LayerImpl* drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
}
-TEST_F(LayerTreeHostCommonTest, VisibleRectForPerspectiveUnprojection) {
+TEST_F(LayerTreeHostCommonDrawRectsTest, DrawRectsForPerspectiveUnprojection) {
// To determine visible rect in layer space, there needs to be an
// un-projection from surface space to layer space. When the original
// transform was a perspective projection that was clipped, it returns a rect
@@ -2956,14 +3008,16 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectForPerspectiveUnprojection) {
// This sequence of transforms causes one corner of the layer to protrude
// across the w = 0 plane, and should be clipped.
- gfx::Rect target_surface_rect = gfx::Rect(-50, -50, 100, 100);
- gfx::Rect layer_content_rect = gfx::Rect(-10, -10, 20, 20);
+ gfx::Rect target_surface_rect = gfx::Rect(0, 0, 150, 150);
+ gfx::Rect layer_content_rect = gfx::Rect(0, 0, 20, 20);
gfx::Transform layer_to_surface_transform;
layer_to_surface_transform.MakeIdentity();
+ layer_to_surface_transform.Translate(10, 10);
layer_to_surface_transform.ApplyPerspectiveDepth(1.0);
layer_to_surface_transform.Translate3d(0.0, 0.0, -5.0);
layer_to_surface_transform.RotateAboutYAxis(45.0);
layer_to_surface_transform.RotateAboutXAxis(80.0);
+ layer_to_surface_transform.Translate(-10, -10);
// Sanity check that un-projection does indeed cause w < 0, otherwise this
// code is not testing the intended scenario.
@@ -2977,10 +3031,13 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectForPerspectiveUnprojection) {
// Only the corner of the layer is not visible on the surface because of being
// clipped. But, the net result of rounding visible region to an axis-aligned
// rect is that the entire layer should still be considered visible.
- gfx::Rect expected = gfx::Rect(-10, -10, 20, 20);
- gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
- target_surface_rect, layer_content_rect, layer_to_surface_transform);
- EXPECT_EQ(expected, actual);
+ gfx::Rect expected_visible_layer_rect = layer_content_rect;
+ gfx::Rect expected_drawable_content_rect = target_surface_rect;
+ LayerImpl* drawing_layer = TestVisibleRectAndDrawableContentRect(
+ target_surface_rect, layer_to_surface_transform, layer_content_rect);
+ EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
+ EXPECT_EQ(expected_drawable_content_rect,
+ drawing_layer->drawable_content_rect());
}
TEST_F(LayerTreeHostCommonTest,
« no previous file with comments | « cc/trees/layer_tree_host_common.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698