cc/trees/layer_tree_host_common_unittest.cc - Issue 2716733007: cc: Rename LayerImpl::render_surface to GetRenderSurface

Unified Diff: cc/trees/layer_tree_host_common_unittest.cc

Issue 2716733007: cc: Rename LayerImpl::render_surface to GetRenderSurface (Closed)

Patch Set: Created 3 years, 10 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

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 090f0d5c57009a2dc132bb90d9aab7669d33f804..ecb60c9004b77b9d1fb2f8e102ad68290c254827 100644

--- a/cc/trees/layer_tree_host_common_unittest.cc

+++ b/cc/trees/layer_tree_host_common_unittest.cc

@@ -743,8 +743,8 @@ TEST_F(LayerTreeHostCommonTest, TransformsForSingleRenderSurface) {

ExecuteCalculateDrawProperties(root);

// Render surface should have been created now.

- ASSERT_TRUE(child->render_surface());

- ASSERT_EQ(child->render_surface(), child->render_target());

+ ASSERT_TRUE(child->GetRenderSurface());

+ ASSERT_EQ(child->GetRenderSurface(), child->render_target());

// The child layer's draw transform should refer to its new render surface.

// The screen-space transform, however, should still refer to the root.

@@ -928,33 +928,33 @@ TEST_F(LayerTreeHostCommonTest, TransformsForRenderSurfaceHierarchy) {

// Only layers that are associated with render surfaces should have an actual

// RenderSurface() value.

- ASSERT_TRUE(root->render_surface());

- ASSERT_FALSE(child_of_root->render_surface());

- ASSERT_FALSE(grand_child_of_root->render_surface());

+ ASSERT_TRUE(root->GetRenderSurface());

+ ASSERT_FALSE(child_of_root->GetRenderSurface());

+ ASSERT_FALSE(grand_child_of_root->GetRenderSurface());

- ASSERT_TRUE(render_surface1->render_surface());

- ASSERT_FALSE(child_of_rs1->render_surface());

- ASSERT_FALSE(grand_child_of_rs1->render_surface());

+ ASSERT_TRUE(render_surface1->GetRenderSurface());

+ ASSERT_FALSE(child_of_rs1->GetRenderSurface());

+ ASSERT_FALSE(grand_child_of_rs1->GetRenderSurface());

- ASSERT_TRUE(render_surface2->render_surface());

- ASSERT_FALSE(child_of_rs2->render_surface());

- ASSERT_FALSE(grand_child_of_rs2->render_surface());

+ ASSERT_TRUE(render_surface2->GetRenderSurface());

+ ASSERT_FALSE(child_of_rs2->GetRenderSurface());

+ ASSERT_FALSE(grand_child_of_rs2->GetRenderSurface());

// Verify all render target accessors

- EXPECT_EQ(root->render_surface(), parent->render_target());

- EXPECT_EQ(root->render_surface(), child_of_root->render_target());

- EXPECT_EQ(root->render_surface(), grand_child_of_root->render_target());

+ EXPECT_EQ(root->GetRenderSurface(), parent->render_target());

+ EXPECT_EQ(root->GetRenderSurface(), child_of_root->render_target());

+ EXPECT_EQ(root->GetRenderSurface(), grand_child_of_root->render_target());

- EXPECT_EQ(render_surface1->render_surface(),

+ EXPECT_EQ(render_surface1->GetRenderSurface(),

render_surface1->render_target());

- EXPECT_EQ(render_surface1->render_surface(), child_of_rs1->render_target());

- EXPECT_EQ(render_surface1->render_surface(),

+ EXPECT_EQ(render_surface1->GetRenderSurface(), child_of_rs1->render_target());

+ EXPECT_EQ(render_surface1->GetRenderSurface(),

grand_child_of_rs1->render_target());

- EXPECT_EQ(render_surface2->render_surface(),

+ EXPECT_EQ(render_surface2->GetRenderSurface(),

render_surface2->render_target());

- EXPECT_EQ(render_surface2->render_surface(), child_of_rs2->render_target());

- EXPECT_EQ(render_surface2->render_surface(),

+ EXPECT_EQ(render_surface2->GetRenderSurface(), child_of_rs2->render_target());

+ EXPECT_EQ(render_surface2->GetRenderSurface(),

grand_child_of_rs2->render_target());

// Verify layer draw transforms note that draw transforms are described with

@@ -1000,16 +1000,17 @@ TEST_F(LayerTreeHostCommonTest, TransformsForRenderSurfaceHierarchy) {

// Draw transform of render surface 1 is described with respect to root.

EXPECT_TRANSFORMATION_MATRIX_EQ(

- A * A * S1, render_surface1->render_surface()->draw_transform());

+ A * A * S1, render_surface1->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(

- A * A * S1, render_surface1->render_surface()->screen_space_transform());

+ A * A * S1,

+ render_surface1->GetRenderSurface()->screen_space_transform());

// Draw transform of render surface 2 is described with respect to render

// surface 1.

EXPECT_TRANSFORMATION_MATRIX_EQ(

- SS1 * A * S2, render_surface2->render_surface()->draw_transform());

+ SS1 * A * S2, render_surface2->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(

A * A * A * S2,

- render_surface2->render_surface()->screen_space_transform());

+ render_surface2->GetRenderSurface()->screen_space_transform());

// Sanity check. If these fail there is probably a bug in the test itself. It

// is expected that we correctly set up transforms so that the y-component of

@@ -1080,12 +1081,12 @@ TEST_F(LayerTreeHostCommonTest, TransformsForFlatteningLayer) {

ExecuteCalculateDrawProperties(root);

// The child's draw transform should have been taken by its surface.

- ASSERT_TRUE(child->render_surface());

+ ASSERT_TRUE(child->GetRenderSurface());

EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_draw_transform,

- child->render_surface()->draw_transform());

+ child->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(

expected_child_screen_space_transform,

- child->render_surface()->screen_space_transform());

+ child->GetRenderSurface()->screen_space_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), child->DrawTransform());

EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_screen_space_transform,

child->ScreenSpaceTransform());

@@ -1163,10 +1164,10 @@ TEST_F(LayerTreeHostCommonTest, TransformsForDegenerateIntermediateLayer) {

grand_child->SetBounds(gfx::Size(10, 10));

ExecuteCalculateDrawProperties(root);

- ASSERT_TRUE(child->has_render_surface());

+ ASSERT_TRUE(child->GetRenderSurface());

// This is the real test, the rest are sanity checks.

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),

- child->render_surface()->draw_transform());

+ child->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), child->DrawTransform());

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),

grand_child->DrawTransform());

@@ -1233,7 +1234,7 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {

EXPECT_TRANSFORMATION_MATRIX_EQ(

translate, child->draw_properties().target_space_transform);

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),

- root->render_surface()->draw_transform());

+ root->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(translate, child->ScreenSpaceTransform());

EXPECT_EQ(gfx::Rect(50, 50, 100, 100), child->clip_rect());

}

@@ -1251,7 +1252,7 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {

EXPECT_TRANSFORMATION_MATRIX_EQ(

scale, child->draw_properties().target_space_transform);

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),

- root->render_surface()->draw_transform());

+ root->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(scale, child->ScreenSpaceTransform());

EXPECT_EQ(gfx::Rect(0, 0, 200, 200), child->clip_rect());

}

@@ -1269,7 +1270,7 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {

EXPECT_TRANSFORMATION_MATRIX_EQ(

rotate, child->draw_properties().target_space_transform);

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),

- root->render_surface()->draw_transform());

+ root->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(rotate, child->ScreenSpaceTransform());

EXPECT_EQ(gfx::Rect(-4, 0, 104, 104), child->clip_rect());

}

@@ -1289,7 +1290,7 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {

EXPECT_TRANSFORMATION_MATRIX_EQ(

composite, child->draw_properties().target_space_transform);

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),

- root->render_surface()->draw_transform());

+ root->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(composite, child->ScreenSpaceTransform());

EXPECT_EQ(gfx::Rect(89, 103, 208, 208), child->clip_rect());

}

@@ -1313,7 +1314,7 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {

device_scaled_translate,

child->draw_properties().target_space_transform);

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),

- root->render_surface()->draw_transform());

+ root->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(device_scaled_translate,

child->ScreenSpaceTransform());

EXPECT_EQ(gfx::Rect(50, 50, 150, 150), child->clip_rect());

@@ -1337,7 +1338,7 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {

EXPECT_TRANSFORMATION_MATRIX_EQ(

page_scaled_translate, child->draw_properties().target_space_transform);

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),

- root->render_surface()->draw_transform());

+ root->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(page_scaled_translate,

child->ScreenSpaceTransform());

EXPECT_EQ(gfx::Rect(50, 50, 200, 200), child->clip_rect());

@@ -1359,7 +1360,7 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {

EXPECT_TRANSFORMATION_MATRIX_EQ(

compositeSquared, child->draw_properties().target_space_transform);

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),

- root->render_surface()->draw_transform());

+ root->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(compositeSquared,

child->ScreenSpaceTransform());

EXPECT_EQ(gfx::Rect(254, 316, 428, 428), child->clip_rect());

@@ -1386,7 +1387,7 @@ TEST_F(LayerTreeHostCommonTest,

// forced to be created. Render surfaces without children or visible content

// are unexpected at draw time (e.g. we might try to create a content texture

// of size 0).

- ASSERT_TRUE(root->render_surface());

+ ASSERT_TRUE(root->GetRenderSurface());

EXPECT_EQ(1U, render_surface_layer_list_impl()->size());

}

@@ -1407,11 +1408,11 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {

inputs.can_adjust_raster_scales = true;

LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);

- // Since the layer is transparent, render_surface1->render_surface() should

+ // Since the layer is transparent, render_surface1->GetRenderSurface() should

// not have gotten added anywhere. Also, the drawable content rect should not

// have been extended by the children.

- ASSERT_TRUE(root->render_surface());

- EXPECT_EQ(0U, root->render_surface()->layer_list().size());

+ ASSERT_TRUE(root->GetRenderSurface());

+ EXPECT_EQ(0U, root->GetRenderSurface()->layer_list().size());

EXPECT_EQ(1U, render_surface_layer_list.size());

EXPECT_EQ(root->id(), render_surface_layer_list.at(0)->id());

EXPECT_EQ(gfx::Rect(), root->drawable_content_rect());

@@ -1444,10 +1445,10 @@ TEST_F(LayerTreeHostCommonTest,

}

// The layer is fully transparent, but has a background filter, so it

// shouldn't be skipped and should be drawn.

- ASSERT_TRUE(root->render_surface());

- EXPECT_EQ(1U, root->render_surface()->layer_list().size());

+ ASSERT_TRUE(root->GetRenderSurface());

+ EXPECT_EQ(1U, root->GetRenderSurface()->layer_list().size());

EXPECT_EQ(gfx::RectF(0, 0, 10, 10),

- root->render_surface()->DrawableContentRect());

+ root->GetRenderSurface()->DrawableContentRect());

EffectTree& effect_tree =

root->layer_tree_impl()->property_trees()->effect_tree;

EffectNode* node = effect_tree.Node(render_surface1->effect_tree_index());

@@ -1501,15 +1502,15 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForFilter) {

inputs.can_adjust_raster_scales = true;

LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);

- ASSERT_TRUE(parent->render_surface());

- EXPECT_EQ(2U, parent->render_surface()->layer_list().size());

+ ASSERT_TRUE(parent->GetRenderSurface());

+ EXPECT_EQ(2U, parent->GetRenderSurface()->layer_list().size());

EXPECT_EQ(4U, render_surface_layer_list.size());

// The rectangle enclosing child1 and child2 (0,0 50x50), expanded for the

// blur (-30,-30 110x110), and then scaled by the scale matrix

// (-60,-60 220x220).

EXPECT_EQ(gfx::RectF(-60, -60, 220, 220),

- parent->render_surface()->DrawableContentRect());

+ parent->GetRenderSurface()->DrawableContentRect());

}

TEST_F(LayerTreeHostCommonTest, DrawableContentRectForReferenceFilter) {

@@ -1529,9 +1530,9 @@ TEST_F(LayerTreeHostCommonTest, DrawableContentRectForReferenceFilter) {

// The render surface's size should be unaffected by the offset image filter;

// it need only have a drawable content rect large enough to contain the

// contents (at the new offset).

- ASSERT_TRUE(child->render_surface());

+ ASSERT_TRUE(child->GetRenderSurface());

EXPECT_EQ(gfx::RectF(50, 50, 25, 25),

- child->render_surface()->DrawableContentRect());

+ child->GetRenderSurface()->DrawableContentRect());

}

TEST_F(LayerTreeHostCommonTest, DrawableContentRectForReferenceFilterHighDpi) {

@@ -1556,9 +1557,9 @@ TEST_F(LayerTreeHostCommonTest, DrawableContentRectForReferenceFilterHighDpi) {

// it need only have a drawable content rect large enough to contain the

// contents (at the new offset). All coordinates should be scaled by 2,

// corresponding to the device scale factor.

- ASSERT_TRUE(child->render_surface());

+ ASSERT_TRUE(child->GetRenderSurface());

EXPECT_EQ(gfx::RectF(100, 100, 50, 50),

- child->render_surface()->DrawableContentRect());

+ child->GetRenderSurface()->DrawableContentRect());

}

TEST_F(LayerTreeHostCommonTest, RenderSurfaceForBlendMode) {

@@ -1577,9 +1578,9 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceForBlendMode) {

// its own render surface. Also, layer's draw_properties should contain the

// default blend mode, since the render surface becomes responsible for

// applying the blend mode.

- ASSERT_TRUE(child->render_surface());

+ ASSERT_TRUE(child->GetRenderSurface());

EXPECT_EQ(1.0f, child->draw_opacity());

- EXPECT_EQ(0.5f, child->render_surface()->draw_opacity());

+ EXPECT_EQ(0.5f, child->GetRenderSurface()->draw_opacity());

EXPECT_EQ(SkBlendMode::kSrcOver, child->draw_blend_mode());

}

@@ -1602,13 +1603,13 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceDrawOpacity) {

surface2->test_properties()->force_render_surface = true;

ExecuteCalculateDrawProperties(root);

- ASSERT_TRUE(surface1->render_surface());

- ASSERT_FALSE(not_surface->render_surface());

- ASSERT_TRUE(surface2->render_surface());

- EXPECT_EQ(0.5f, surface1->render_surface()->draw_opacity());

+ ASSERT_TRUE(surface1->GetRenderSurface());

+ ASSERT_FALSE(not_surface->GetRenderSurface());

+ ASSERT_TRUE(surface2->GetRenderSurface());

+ EXPECT_EQ(0.5f, surface1->GetRenderSurface()->draw_opacity());

// surface2's draw opacity should include the opacity of not-surface and

// itself, but not the opacity of surface1.

- EXPECT_EQ(0.25f, surface2->render_surface()->draw_opacity());

+ EXPECT_EQ(0.25f, surface2->GetRenderSurface()->draw_opacity());

}

TEST_F(LayerTreeHostCommonTest, DrawOpacityWhenCannotRenderToSeparateSurface) {

@@ -1686,16 +1687,16 @@ TEST_F(LayerTreeHostCommonTest, ForceRenderSurface) {

ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);

// The root layer always creates a render surface

- EXPECT_TRUE(root->has_render_surface());

- EXPECT_TRUE(render_surface1->has_render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

+ EXPECT_TRUE(render_surface1->GetRenderSurface());

}

{

render_surface1->test_properties()->force_render_surface = false;

render_surface1->layer_tree_impl()->property_trees()->needs_rebuild = true;

ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);

- EXPECT_TRUE(root->has_render_surface());

- EXPECT_FALSE(render_surface1->has_render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

+ EXPECT_FALSE(render_surface1->GetRenderSurface());

}

@@ -1721,9 +1722,9 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfacesFlattenScreenSpaceTransform) {

grand_child->test_properties()->should_flatten_transform = false;

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(parent->render_surface());

- EXPECT_FALSE(child->render_surface());

- EXPECT_FALSE(grand_child->render_surface());

+ EXPECT_TRUE(parent->GetRenderSurface());

+ EXPECT_FALSE(child->GetRenderSurface());

+ EXPECT_FALSE(grand_child->GetRenderSurface());

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), child->DrawTransform());

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),

@@ -1862,15 +1863,15 @@ TEST_F(LayerTreeHostCommonTest, IsClippedIsSetCorrectlyLayerImpl) {

// Case 1: nothing is clipped except the root render surface.

ExecuteCalculateDrawProperties(root);

- ASSERT_TRUE(root->render_surface());

- ASSERT_TRUE(child2->render_surface());

+ ASSERT_TRUE(root->GetRenderSurface());

+ ASSERT_TRUE(child2->GetRenderSurface());

EXPECT_FALSE(root->is_clipped());

- EXPECT_TRUE(root->render_surface()->is_clipped());

+ EXPECT_TRUE(root->GetRenderSurface()->is_clipped());

EXPECT_FALSE(parent->is_clipped());

EXPECT_FALSE(child1->is_clipped());

EXPECT_FALSE(child2->is_clipped());

- EXPECT_FALSE(child2->render_surface()->is_clipped());

+ EXPECT_FALSE(child2->GetRenderSurface()->is_clipped());

EXPECT_FALSE(grand_child->is_clipped());

EXPECT_FALSE(leaf_node1->is_clipped());

EXPECT_FALSE(leaf_node2->is_clipped());

@@ -1884,15 +1885,15 @@ TEST_F(LayerTreeHostCommonTest, IsClippedIsSetCorrectlyLayerImpl) {

ExecuteCalculateDrawProperties(root);

- ASSERT_TRUE(root->render_surface());

- ASSERT_TRUE(child2->render_surface());

+ ASSERT_TRUE(root->GetRenderSurface());

+ ASSERT_TRUE(child2->GetRenderSurface());

EXPECT_FALSE(root->is_clipped());

- EXPECT_TRUE(root->render_surface()->is_clipped());

+ EXPECT_TRUE(root->GetRenderSurface()->is_clipped());

EXPECT_TRUE(parent->is_clipped());

EXPECT_TRUE(child1->is_clipped());

EXPECT_FALSE(child2->is_clipped());

- EXPECT_TRUE(child2->render_surface()->is_clipped());

+ EXPECT_TRUE(child2->GetRenderSurface()->is_clipped());

EXPECT_TRUE(grand_child->is_clipped());

EXPECT_TRUE(leaf_node1->is_clipped());

EXPECT_FALSE(leaf_node2->is_clipped());

@@ -1906,15 +1907,15 @@ TEST_F(LayerTreeHostCommonTest, IsClippedIsSetCorrectlyLayerImpl) {

ExecuteCalculateDrawProperties(root);

- ASSERT_TRUE(root->render_surface());

- ASSERT_TRUE(child2->render_surface());

+ ASSERT_TRUE(root->GetRenderSurface());

+ ASSERT_TRUE(child2->GetRenderSurface());

EXPECT_FALSE(root->is_clipped());

- EXPECT_TRUE(root->render_surface()->is_clipped());

+ EXPECT_TRUE(root->GetRenderSurface()->is_clipped());

EXPECT_FALSE(parent->is_clipped());

EXPECT_FALSE(child1->is_clipped());

EXPECT_TRUE(child2->is_clipped());

- EXPECT_FALSE(child2->render_surface()->is_clipped());

+ EXPECT_FALSE(child2->GetRenderSurface()->is_clipped());

EXPECT_FALSE(grand_child->is_clipped());

EXPECT_FALSE(leaf_node1->is_clipped());

EXPECT_TRUE(leaf_node2->is_clipped());

@@ -2197,18 +2198,18 @@ TEST_F(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {

leaf_node4->SetDrawsContent(true);

ExecuteCalculateDrawProperties(parent);

- ASSERT_TRUE(grand_child1->render_surface());

- ASSERT_TRUE(grand_child2->render_surface());

- ASSERT_TRUE(grand_child3->render_surface());

+ ASSERT_TRUE(grand_child1->GetRenderSurface());

+ ASSERT_TRUE(grand_child2->GetRenderSurface());

+ ASSERT_TRUE(grand_child3->GetRenderSurface());

// Surfaces are clipped by their parent, but un-affected by the owning layer's

// MasksToBounds.

EXPECT_EQ(gfx::Rect(0, 0, 20, 20),

- grand_child1->render_surface()->clip_rect());

+ grand_child1->GetRenderSurface()->clip_rect());

EXPECT_EQ(gfx::Rect(0, 0, 20, 20),

- grand_child2->render_surface()->clip_rect());

+ grand_child2->GetRenderSurface()->clip_rect());

EXPECT_EQ(gfx::Rect(0, 0, 20, 20),

- grand_child3->render_surface()->clip_rect());

+ grand_child3->GetRenderSurface()->clip_rect());

}

TEST_F(LayerTreeHostCommonTest, ClipRectWhenCannotRenderToSeparateSurface) {

@@ -2254,13 +2255,13 @@ TEST_F(LayerTreeHostCommonTest, ClipRectWhenCannotRenderToSeparateSurface) {

// bounds in target space. The only thing that changes when surfaces are

// disabled is that target space is always screen space.

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(root->has_render_surface());

- EXPECT_FALSE(parent->has_render_surface());

- EXPECT_TRUE(child1->has_render_surface());

- EXPECT_FALSE(child2->has_render_surface());

- EXPECT_TRUE(grand_child->has_render_surface());

- EXPECT_FALSE(leaf_node1->has_render_surface());

- EXPECT_FALSE(leaf_node2->has_render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

+ EXPECT_FALSE(parent->GetRenderSurface());

+ EXPECT_TRUE(child1->GetRenderSurface());

+ EXPECT_FALSE(child2->GetRenderSurface());

+ EXPECT_TRUE(grand_child->GetRenderSurface());

+ EXPECT_FALSE(leaf_node1->GetRenderSurface());

+ EXPECT_FALSE(leaf_node2->GetRenderSurface());

EXPECT_FALSE(root->is_clipped());

EXPECT_FALSE(parent->is_clipped());

EXPECT_FALSE(child1->is_clipped());

@@ -2268,10 +2269,10 @@ TEST_F(LayerTreeHostCommonTest, ClipRectWhenCannotRenderToSeparateSurface) {

EXPECT_FALSE(grand_child->is_clipped());

EXPECT_FALSE(leaf_node1->is_clipped());

EXPECT_FALSE(leaf_node2->is_clipped());

- EXPECT_TRUE(root->render_surface()->is_clipped());

- EXPECT_FALSE(child1->render_surface()->is_clipped());

- EXPECT_FALSE(grand_child->render_surface()->is_clipped());

- EXPECT_EQ(gfx::Rect(100, 100), root->render_surface()->clip_rect());

+ EXPECT_TRUE(root->GetRenderSurface()->is_clipped());

+ EXPECT_FALSE(child1->GetRenderSurface()->is_clipped());

+ EXPECT_FALSE(grand_child->GetRenderSurface()->is_clipped());

+ EXPECT_EQ(gfx::Rect(100, 100), root->GetRenderSurface()->clip_rect());

ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);

EXPECT_FALSE(root->is_clipped());

@@ -2281,8 +2282,8 @@ TEST_F(LayerTreeHostCommonTest, ClipRectWhenCannotRenderToSeparateSurface) {

EXPECT_FALSE(grand_child->is_clipped());

EXPECT_FALSE(leaf_node1->is_clipped());

EXPECT_FALSE(leaf_node2->is_clipped());

- EXPECT_TRUE(root->render_surface()->is_clipped());

- EXPECT_EQ(gfx::Rect(100, 100), root->render_surface()->clip_rect());

+ EXPECT_TRUE(root->GetRenderSurface()->is_clipped());

+ EXPECT_EQ(gfx::Rect(100, 100), root->GetRenderSurface()->clip_rect());

// Case 2: The root is clipped. In this case, layers that draw into the root

// render surface are clipped by the root's bounds.

@@ -2292,25 +2293,25 @@ TEST_F(LayerTreeHostCommonTest, ClipRectWhenCannotRenderToSeparateSurface) {

child1->test_properties()->force_render_surface = true;

grand_child->test_properties()->force_render_surface = true;

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(root->has_render_surface());

- EXPECT_FALSE(parent->has_render_surface());

- EXPECT_TRUE(child1->has_render_surface());

- EXPECT_FALSE(child2->has_render_surface());

- EXPECT_TRUE(grand_child->has_render_surface());

- EXPECT_FALSE(leaf_node1->has_render_surface());

- EXPECT_FALSE(leaf_node2->has_render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

+ EXPECT_FALSE(parent->GetRenderSurface());

+ EXPECT_TRUE(child1->GetRenderSurface());

+ EXPECT_FALSE(child2->GetRenderSurface());

+ EXPECT_TRUE(grand_child->GetRenderSurface());

+ EXPECT_FALSE(leaf_node1->GetRenderSurface());

+ EXPECT_FALSE(leaf_node2->GetRenderSurface());

EXPECT_TRUE(root->is_clipped());

EXPECT_TRUE(parent->is_clipped());

EXPECT_FALSE(child1->is_clipped());

- EXPECT_TRUE(child1->render_surface()->is_clipped());

+ EXPECT_TRUE(child1->GetRenderSurface()->is_clipped());

EXPECT_TRUE(child2->is_clipped());

EXPECT_FALSE(grand_child->is_clipped());

- EXPECT_FALSE(grand_child->render_surface()->is_clipped());

+ EXPECT_FALSE(grand_child->GetRenderSurface()->is_clipped());

EXPECT_FALSE(leaf_node1->is_clipped());

EXPECT_TRUE(leaf_node2->is_clipped());

EXPECT_EQ(gfx::Rect(100, 100), root->clip_rect());

EXPECT_EQ(gfx::Rect(100, 100), parent->clip_rect());

- EXPECT_EQ(gfx::Rect(100, 100), child1->render_surface()->clip_rect());

+ EXPECT_EQ(gfx::Rect(100, 100), child1->GetRenderSurface()->clip_rect());

EXPECT_EQ(gfx::Rect(100, 100), child2->clip_rect());

EXPECT_EQ(gfx::Rect(100, 100), leaf_node2->clip_rect());

@@ -2345,39 +2346,39 @@ TEST_F(LayerTreeHostCommonTest, ClipRectWhenCannotRenderToSeparateSurface) {

child1->test_properties()->force_render_surface = true;

grand_child->test_properties()->force_render_surface = true;

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(root->has_render_surface());

- EXPECT_FALSE(parent->has_render_surface());

- EXPECT_TRUE(child1->has_render_surface());

- EXPECT_FALSE(child2->has_render_surface());

- EXPECT_TRUE(grand_child->has_render_surface());

- EXPECT_FALSE(leaf_node1->has_render_surface());

- EXPECT_FALSE(leaf_node2->has_render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

+ EXPECT_FALSE(parent->GetRenderSurface());

+ EXPECT_TRUE(child1->GetRenderSurface());

+ EXPECT_FALSE(child2->GetRenderSurface());

+ EXPECT_TRUE(grand_child->GetRenderSurface());

+ EXPECT_FALSE(leaf_node1->GetRenderSurface());

+ EXPECT_FALSE(leaf_node2->GetRenderSurface());

EXPECT_FALSE(root->is_clipped());

- EXPECT_TRUE(root->render_surface()->is_clipped());

+ EXPECT_TRUE(root->GetRenderSurface()->is_clipped());

EXPECT_TRUE(parent->is_clipped());

EXPECT_TRUE(child1->is_clipped());

EXPECT_TRUE(child2->is_clipped());

EXPECT_FALSE(grand_child->is_clipped());

- EXPECT_TRUE(grand_child->render_surface()->is_clipped());

+ EXPECT_TRUE(grand_child->GetRenderSurface()->is_clipped());

EXPECT_FALSE(leaf_node1->is_clipped());

EXPECT_TRUE(leaf_node2->is_clipped());

- EXPECT_EQ(gfx::Rect(100, 100), root->render_surface()->clip_rect());

+ EXPECT_EQ(gfx::Rect(100, 100), root->GetRenderSurface()->clip_rect());

EXPECT_EQ(gfx::Rect(2, 2, 400, 400), parent->clip_rect());

EXPECT_EQ(gfx::Rect(800, 800), child1->clip_rect());

EXPECT_EQ(gfx::Rect(2, 2, 400, 400), child2->clip_rect());

- EXPECT_EQ(gfx::Rect(800, 800), grand_child->render_surface()->clip_rect());

+ EXPECT_EQ(gfx::Rect(800, 800), grand_child->GetRenderSurface()->clip_rect());

EXPECT_EQ(gfx::Rect(2, 2, 400, 400), leaf_node2->clip_rect());

ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);

EXPECT_FALSE(root->is_clipped());

- EXPECT_TRUE(root->render_surface()->is_clipped());

+ EXPECT_TRUE(root->GetRenderSurface()->is_clipped());

EXPECT_TRUE(parent->is_clipped());

EXPECT_TRUE(child1->is_clipped());

EXPECT_TRUE(child2->is_clipped());

EXPECT_TRUE(grand_child->is_clipped());

EXPECT_TRUE(leaf_node1->is_clipped());

EXPECT_TRUE(leaf_node2->is_clipped());

- EXPECT_EQ(gfx::Rect(100, 100), root->render_surface()->clip_rect());

+ EXPECT_EQ(gfx::Rect(100, 100), root->GetRenderSurface()->clip_rect());

EXPECT_EQ(gfx::Rect(2, 2, 400, 400), parent->clip_rect());

EXPECT_EQ(gfx::Rect(6, 6, 396, 396), child1->clip_rect());

EXPECT_EQ(gfx::Rect(2, 2, 400, 400), child2->clip_rect());

@@ -2578,33 +2579,33 @@ TEST_F(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) {

// Only layers that are associated with render surfaces should have an actual

// RenderSurface() value.

- ASSERT_TRUE(root->render_surface());

- ASSERT_FALSE(child_of_root->render_surface());

- ASSERT_FALSE(grand_child_of_root->render_surface());

+ ASSERT_TRUE(root->GetRenderSurface());

+ ASSERT_FALSE(child_of_root->GetRenderSurface());

+ ASSERT_FALSE(grand_child_of_root->GetRenderSurface());

- ASSERT_TRUE(render_surface1->render_surface());

- ASSERT_FALSE(child_of_rs1->render_surface());

- ASSERT_FALSE(grand_child_of_rs1->render_surface());

+ ASSERT_TRUE(render_surface1->GetRenderSurface());

+ ASSERT_FALSE(child_of_rs1->GetRenderSurface());

+ ASSERT_FALSE(grand_child_of_rs1->GetRenderSurface());

- ASSERT_TRUE(render_surface2->render_surface());

- ASSERT_FALSE(child_of_rs2->render_surface());

- ASSERT_FALSE(grand_child_of_rs2->render_surface());

+ ASSERT_TRUE(render_surface2->GetRenderSurface());

+ ASSERT_FALSE(child_of_rs2->GetRenderSurface());

+ ASSERT_FALSE(grand_child_of_rs2->GetRenderSurface());

// Verify all render target accessors

- EXPECT_EQ(root->render_surface(), root->render_target());

- EXPECT_EQ(root->render_surface(), child_of_root->render_target());

- EXPECT_EQ(root->render_surface(), grand_child_of_root->render_target());

+ EXPECT_EQ(root->GetRenderSurface(), root->render_target());

+ EXPECT_EQ(root->GetRenderSurface(), child_of_root->render_target());

+ EXPECT_EQ(root->GetRenderSurface(), grand_child_of_root->render_target());

- EXPECT_EQ(render_surface1->render_surface(),

+ EXPECT_EQ(render_surface1->GetRenderSurface(),

render_surface1->render_target());

- EXPECT_EQ(render_surface1->render_surface(), child_of_rs1->render_target());

- EXPECT_EQ(render_surface1->render_surface(),

+ EXPECT_EQ(render_surface1->GetRenderSurface(), child_of_rs1->render_target());

+ EXPECT_EQ(render_surface1->GetRenderSurface(),

grand_child_of_rs1->render_target());

- EXPECT_EQ(render_surface2->render_surface(),

+ EXPECT_EQ(render_surface2->GetRenderSurface(),

render_surface2->render_target());

- EXPECT_EQ(render_surface2->render_surface(), child_of_rs2->render_target());

- EXPECT_EQ(render_surface2->render_surface(),

+ EXPECT_EQ(render_surface2->GetRenderSurface(), child_of_rs2->render_target());

+ EXPECT_EQ(render_surface2->GetRenderSurface(),

grand_child_of_rs2->render_target());

// Verify screen_space_transform_is_animating values

@@ -3016,7 +3017,7 @@ TEST_F(LayerTreeHostCommonTest,

ExecuteCalculateDrawProperties(root);

EXPECT_EQ(gfx::RectF(100.f, 100.f),

- root->render_surface()->DrawableContentRect());

+ root->GetRenderSurface()->DrawableContentRect());

// In target space, not clipped.

EXPECT_EQ(gfx::Rect(60, 70, 100, 100), root->drawable_content_rect());

// In layer space, clipped.

@@ -3041,7 +3042,7 @@ TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsForSimpleLayers) {

ExecuteCalculateDrawProperties(root);

EXPECT_EQ(gfx::RectF(100.f, 100.f),

- root->render_surface()->DrawableContentRect());

+ root->GetRenderSurface()->DrawableContentRect());

// Layers that do not draw content should have empty visible_layer_rects.

EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());

@@ -3080,7 +3081,7 @@ TEST_F(LayerTreeHostCommonTest,

ExecuteCalculateDrawProperties(root);

EXPECT_EQ(gfx::RectF(100.f, 100.f),

- root->render_surface()->DrawableContentRect());

+ root->GetRenderSurface()->DrawableContentRect());

// Layers that do not draw content should have empty visible content rects.

EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());

@@ -3137,7 +3138,7 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectWithClippingAndFilters) {

ExecuteCalculateDrawProperties(root);

EXPECT_EQ(gfx::Rect(50, 50, 10, 10), filter_child->visible_layer_rect());

- EXPECT_EQ(gfx::Rect(10, 10), filter->render_surface()->content_rect());

+ EXPECT_EQ(gfx::Rect(10, 10), filter->GetRenderSurface()->content_rect());

FilterOperations blur_filter;

blur_filter.Append(FilterOperation::CreateBlurFilter(4.0f));

@@ -3148,7 +3149,7 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectWithClippingAndFilters) {

EXPECT_EQ(gfx::Rect(38, 38, 34, 34), filter_child->visible_layer_rect());

EXPECT_EQ(gfx::Rect(-12, -12, 34, 34),

- filter->render_surface()->content_rect());

+ filter->GetRenderSurface()->content_rect());

gfx::Transform vertical_flip;

vertical_flip.Scale(1, -1);

@@ -3165,7 +3166,7 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectWithClippingAndFilters) {

EXPECT_EQ(gfx::Rect(50, 40, 10, 20), filter_child->visible_layer_rect());

EXPECT_EQ(gfx::Rect(0, -10, 10, 20),

- filter->render_surface()->content_rect());

+ filter->GetRenderSurface()->content_rect());

}

TEST_F(LayerTreeHostCommonTest, VisibleRectWithScalingClippingAndFilters) {

@@ -3190,7 +3191,7 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectWithScalingClippingAndFilters) {

ExecuteCalculateDrawProperties(root);

EXPECT_EQ(gfx::Rect(50, 50, 10, 10), filter_child->visible_layer_rect());

- EXPECT_EQ(gfx::Rect(30, 30), filter->render_surface()->content_rect());

+ EXPECT_EQ(gfx::Rect(30, 30), filter->GetRenderSurface()->content_rect());

FilterOperations blur_filter;

blur_filter.Append(FilterOperation::CreateBlurFilter(4.0f));

@@ -3201,7 +3202,7 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectWithScalingClippingAndFilters) {

EXPECT_EQ(gfx::Rect(38, 38, 34, 34), filter_child->visible_layer_rect());

EXPECT_EQ(gfx::Rect(-36, -36, 102, 102),

- filter->render_surface()->content_rect());

+ filter->GetRenderSurface()->content_rect());

gfx::Transform vertical_flip;

vertical_flip.Scale(1, -1);

@@ -3218,7 +3219,7 @@ TEST_F(LayerTreeHostCommonTest, VisibleRectWithScalingClippingAndFilters) {

EXPECT_EQ(gfx::Rect(50, 40, 10, 20), filter_child->visible_layer_rect());

EXPECT_EQ(gfx::Rect(0, -30, 30, 60),

- filter->render_surface()->content_rect());

+ filter->GetRenderSurface()->content_rect());

}

TEST_F(LayerTreeHostCommonTest, ClipRectWithClipParentAndFilters) {

@@ -3316,10 +3317,10 @@ TEST_F(LayerTreeHostCommonTest,

child3->SetDrawsContent(true);

ExecuteCalculateDrawProperties(root);

- ASSERT_TRUE(render_surface->render_surface());

+ ASSERT_TRUE(render_surface->GetRenderSurface());

EXPECT_EQ(gfx::RectF(100.f, 100.f),

- root->render_surface()->DrawableContentRect());

+ root->GetRenderSurface()->DrawableContentRect());

// Layers that do not draw content should have empty visible content rects.

EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());

@@ -3328,7 +3329,7 @@ TEST_F(LayerTreeHostCommonTest,

// An unclipped surface grows its DrawableContentRect to include all drawable

// regions of the subtree.

EXPECT_EQ(gfx::RectF(5.f, 5.f, 170.f, 170.f),

- render_surface->render_surface()->DrawableContentRect());

+ render_surface->GetRenderSurface()->DrawableContentRect());

// All layers that draw content into the unclipped surface are also unclipped.

// Only the viewport clip should apply

@@ -3543,12 +3544,12 @@ TEST_F(LayerTreeHostCommonTest,

root, gfx::Size(), &render_surface_layer_list_impl);

LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);

- ASSERT_TRUE(root->render_surface());

+ ASSERT_TRUE(root->GetRenderSurface());

EXPECT_FALSE(root->is_clipped());

gfx::Rect empty;

- EXPECT_EQ(empty, root->render_surface()->clip_rect());

- EXPECT_TRUE(root->render_surface()->is_clipped());

+ EXPECT_EQ(empty, root->GetRenderSurface()->clip_rect());

+ EXPECT_TRUE(root->GetRenderSurface()->is_clipped());

// Visible content rect calculation will check if the target surface is

// clipped or not. An empty clip rect does not indicate the render surface

@@ -3702,11 +3703,11 @@ TEST_F(LayerTreeHostCommonTest, OcclusionBySiblingOfTarget) {

host_impl.active_tree()->UpdateDrawProperties(update_lcd_text);

EXPECT_TRANSFORMATION_MATRIX_EQ(

- surface_ptr->render_surface()->draw_transform(), translate);

+ surface_ptr->GetRenderSurface()->draw_transform(), translate);

// surface_sibling draws into the root render surface and occludes

// surface_child's contents.

Occlusion actual_occlusion =

- surface_child_ptr->render_surface()->occlusion_in_content_space();

+ surface_child_ptr->GetRenderSurface()->occlusion_in_content_space();

Occlusion expected_occlusion(translate, SimpleEnclosedRegion(gfx::Rect()),

SimpleEnclosedRegion(gfx::Rect(200, 200)));

EXPECT_TRUE(expected_occlusion.IsEqual(actual_occlusion));

@@ -3859,10 +3860,10 @@ TEST_F(LayerTreeHostCommonTest,

child3->SetDrawsContent(true);

ExecuteCalculateDrawProperties(root);

- ASSERT_TRUE(render_surface->render_surface());

+ ASSERT_TRUE(render_surface->GetRenderSurface());

EXPECT_EQ(gfx::RectF(100.f, 100.f),

- root->render_surface()->DrawableContentRect());

+ root->GetRenderSurface()->DrawableContentRect());

// Layers that do not draw content should have empty visible content rects.

EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());

@@ -3871,7 +3872,7 @@ TEST_F(LayerTreeHostCommonTest,

// A clipped surface grows its DrawableContentRect to include all drawable

// regions of the subtree, but also gets clamped by the ancestor's clip.

EXPECT_EQ(gfx::RectF(5.f, 5.f, 95.f, 95.f),

- render_surface->render_surface()->DrawableContentRect());

+ render_surface->GetRenderSurface()->DrawableContentRect());

// All layers that draw content into the surface have their visible content

// rect clipped by the surface clip rect.

@@ -3912,11 +3913,11 @@ TEST_F(LayerTreeHostCommonTest,

child3->SetDrawsContent(true);

ExecuteCalculateDrawProperties(root);

- ASSERT_TRUE(render_surface1->render_surface());

- ASSERT_TRUE(render_surface2->render_surface());

+ ASSERT_TRUE(render_surface1->GetRenderSurface());

+ ASSERT_TRUE(render_surface2->GetRenderSurface());

EXPECT_EQ(gfx::RectF(100.f, 100.f),

- root->render_surface()->DrawableContentRect());

+ root->GetRenderSurface()->DrawableContentRect());

// Layers that do not draw content should have empty visible content rects.

EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());

@@ -3926,13 +3927,13 @@ TEST_F(LayerTreeHostCommonTest,

// A clipped surface grows its DrawableContentRect to include all drawable

// regions of the subtree, but also gets clamped by the ancestor's clip.

EXPECT_EQ(gfx::RectF(5.f, 5.f, 95.f, 95.f),

- render_surface1->render_surface()->DrawableContentRect());

+ render_surface1->GetRenderSurface()->DrawableContentRect());

// render_surface1 lives in the "unclipped universe" of render_surface1, and

// is only implicitly clipped by render_surface1's content rect. So,

// render_surface2 grows to enclose all drawable content of its subtree.

EXPECT_EQ(gfx::RectF(5.f, 5.f, 170.f, 170.f),

- render_surface2->render_surface()->DrawableContentRect());

+ render_surface2->GetRenderSurface()->DrawableContentRect());

// All layers that draw content into render_surface2 think they are unclipped

// by the surface. So, only the viewport clip applies.

@@ -4038,7 +4039,8 @@ TEST_F(LayerTreeHostCommonTest, ClipRectOfSurfaceWhoseParentIsAClipChild) {

render_surface1->SetMasksToBounds(true);

ExecuteCalculateDrawProperties(root);

- EXPECT_EQ(gfx::Rect(50, 50), render_surface2->render_surface()->clip_rect());

+ EXPECT_EQ(gfx::Rect(50, 50),

+ render_surface2->GetRenderSurface()->clip_rect());

}

TEST_F(LayerTreeHostCommonTest, RenderSurfaceContentRectWhenLayerNotDrawn) {

@@ -4054,11 +4056,11 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceContentRectWhenLayerNotDrawn) {

test_layer->SetBounds(gfx::Size(150, 150));

ExecuteCalculateDrawProperties(root);

- EXPECT_EQ(gfx::Rect(100, 100), surface->render_surface()->content_rect());

+ EXPECT_EQ(gfx::Rect(100, 100), surface->GetRenderSurface()->content_rect());

test_layer->SetDrawsContent(true);

ExecuteCalculateDrawProperties(root);

- EXPECT_EQ(gfx::Rect(150, 150), surface->render_surface()->content_rect());

+ EXPECT_EQ(gfx::Rect(150, 150), surface->GetRenderSurface()->content_rect());

}

TEST_F(LayerTreeHostCommonTest, VisibleRectsMultipleSurfaces) {

@@ -4166,10 +4168,10 @@ TEST_F(LayerTreeHostCommonTest,

child1->test_properties()->transform_origin = gfx::Point3F(25.f, 25.f, 0.f);

ExecuteCalculateDrawProperties(root);

- ASSERT_TRUE(render_surface->render_surface());

+ ASSERT_TRUE(render_surface->GetRenderSurface());

EXPECT_EQ(gfx::RectF(100.f, 100.f),

- root->render_surface()->DrawableContentRect());

+ root->GetRenderSurface()->DrawableContentRect());

// Layers that do not draw content should have empty visible content rects.

EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());

@@ -4184,7 +4186,7 @@ TEST_F(LayerTreeHostCommonTest,

diagonal_radius * 2,

diagonal_radius * 2);

EXPECT_EQ(gfx::RectF(expected_surface_drawable_content),

- render_surface->render_surface()->DrawableContentRect());

+ render_surface->GetRenderSurface()->DrawableContentRect());

// All layers that draw content into the unclipped surface are also unclipped.

EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());

@@ -4213,7 +4215,7 @@ TEST_F(LayerTreeHostCommonTest,

child1->test_properties()->transform_origin = gfx::Point3F(25.f, 25.f, 0.f);

ExecuteCalculateDrawProperties(root);

- ASSERT_TRUE(render_surface->render_surface());

+ ASSERT_TRUE(render_surface->GetRenderSurface());

// The clipped surface clamps the DrawableContentRect that encloses the

// rotated layer.

@@ -4225,7 +4227,7 @@ TEST_F(LayerTreeHostCommonTest,

gfx::RectF expected_surface_drawable_content(

gfx::IntersectRects(unclipped_surface_content, gfx::Rect(50, 50)));

EXPECT_EQ(expected_surface_drawable_content,

- render_surface->render_surface()->DrawableContentRect());

+ render_surface->GetRenderSurface()->DrawableContentRect());

// On the clipped surface, only a quarter of the child1 is visible, but when

// rotating it back to child1's content space, the actual enclosing rect ends

@@ -4271,20 +4273,20 @@ TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsInHighDPI) {

float device_scale_factor = 2.f;

ExecuteCalculateDrawProperties(root, device_scale_factor);

- ASSERT_TRUE(render_surface1->render_surface());

- ASSERT_TRUE(render_surface2->render_surface());

+ ASSERT_TRUE(render_surface1->GetRenderSurface());

+ ASSERT_TRUE(render_surface2->GetRenderSurface());

// drawable_content_rects for all layers and surfaces are scaled by

// device_scale_factor.

EXPECT_EQ(gfx::RectF(200.f, 200.f),

- root->render_surface()->DrawableContentRect());

+ root->GetRenderSurface()->DrawableContentRect());

EXPECT_EQ(gfx::RectF(10.f, 10.f, 190.f, 190.f),

- render_surface1->render_surface()->DrawableContentRect());

+ render_surface1->GetRenderSurface()->DrawableContentRect());

// render_surface2 lives in the "unclipped universe" of render_surface1, and

// is only implicitly clipped by render_surface1.

EXPECT_EQ(gfx::RectF(10.f, 10.f, 350.f, 350.f),

- render_surface2->render_surface()->DrawableContentRect());

+ render_surface2->GetRenderSurface()->DrawableContentRect());

EXPECT_EQ(gfx::Rect(10, 10, 100, 100), child1->drawable_content_rect());

EXPECT_EQ(gfx::Rect(150, 150, 100, 100), child2->drawable_content_rect());

@@ -4376,15 +4378,14 @@ TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {

ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);

// Verify which render surfaces were created.

- EXPECT_FALSE(front_facing_child->has_render_surface());

- EXPECT_FALSE(back_facing_child->has_render_surface());

- EXPECT_TRUE(front_facing_surface->has_render_surface());

- EXPECT_TRUE(back_facing_surface->has_render_surface());

- EXPECT_FALSE(

- front_facing_child_of_front_facing_surface->has_render_surface());

- EXPECT_FALSE(back_facing_child_of_front_facing_surface->has_render_surface());

- EXPECT_FALSE(front_facing_child_of_back_facing_surface->has_render_surface());

- EXPECT_FALSE(back_facing_child_of_back_facing_surface->has_render_surface());

+ EXPECT_FALSE(front_facing_child->GetRenderSurface());

+ EXPECT_FALSE(back_facing_child->GetRenderSurface());

+ EXPECT_TRUE(front_facing_surface->GetRenderSurface());

+ EXPECT_TRUE(back_facing_surface->GetRenderSurface());

+ EXPECT_FALSE(front_facing_child_of_front_facing_surface->GetRenderSurface());

+ EXPECT_FALSE(back_facing_child_of_front_facing_surface->GetRenderSurface());

+ EXPECT_FALSE(front_facing_child_of_back_facing_surface->GetRenderSurface());

+ EXPECT_FALSE(back_facing_child_of_back_facing_surface->GetRenderSurface());

EXPECT_EQ(3u, update_layer_list_impl()->size());

EXPECT_TRUE(UpdateLayerListImplContains(front_facing_child->id()));

@@ -4485,16 +4486,15 @@ TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {

ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);

// Verify which render surfaces were created and used.

- EXPECT_FALSE(front_facing_child->has_render_surface());

- EXPECT_FALSE(back_facing_child->has_render_surface());

- EXPECT_TRUE(front_facing_surface->has_render_surface());

+ EXPECT_FALSE(front_facing_child->GetRenderSurface());

+ EXPECT_FALSE(back_facing_child->GetRenderSurface());

+ EXPECT_TRUE(front_facing_surface->GetRenderSurface());

// We expect that a has_render_surface was created but not used.

- EXPECT_TRUE(back_facing_surface->has_render_surface());

- EXPECT_FALSE(

- front_facing_child_of_front_facing_surface->has_render_surface());

- EXPECT_FALSE(back_facing_child_of_front_facing_surface->has_render_surface());

- EXPECT_FALSE(front_facing_child_of_back_facing_surface->has_render_surface());

- EXPECT_FALSE(back_facing_child_of_back_facing_surface->has_render_surface());

+ EXPECT_TRUE(back_facing_surface->GetRenderSurface());

+ EXPECT_FALSE(front_facing_child_of_front_facing_surface->GetRenderSurface());

+ EXPECT_FALSE(back_facing_child_of_front_facing_surface->GetRenderSurface());

+ EXPECT_FALSE(front_facing_child_of_back_facing_surface->GetRenderSurface());

+ EXPECT_FALSE(back_facing_child_of_back_facing_surface->GetRenderSurface());

EXPECT_EQ(3u, update_layer_list_impl()->size());

@@ -4560,11 +4560,11 @@ TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {

ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);

- EXPECT_FALSE(child->has_render_surface());

- EXPECT_TRUE(animating_surface->has_render_surface());

- EXPECT_FALSE(child_of_animating_surface->has_render_surface());

- EXPECT_FALSE(animating_child->has_render_surface());

- EXPECT_FALSE(child2->has_render_surface());

+ EXPECT_FALSE(child->GetRenderSurface());

+ EXPECT_TRUE(animating_surface->GetRenderSurface());

+ EXPECT_FALSE(child_of_animating_surface->GetRenderSurface());

+ EXPECT_FALSE(animating_child->GetRenderSurface());

+ EXPECT_FALSE(child2->GetRenderSurface());

EXPECT_EQ(1u, update_layer_list_impl()->size());

@@ -4620,12 +4620,12 @@ TEST_F(LayerTreeHostCommonTest,

ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);

// Verify which render surfaces were created and used.

- EXPECT_TRUE(front_facing_surface->has_render_surface());

+ EXPECT_TRUE(front_facing_surface->GetRenderSurface());

// We expect the render surface to have been created, but remain unused.

- EXPECT_TRUE(back_facing_surface->has_render_surface());

- EXPECT_FALSE(child1->has_render_surface());

- EXPECT_FALSE(child2->has_render_surface());

+ EXPECT_TRUE(back_facing_surface->GetRenderSurface());

+ EXPECT_FALSE(child1->GetRenderSurface());

+ EXPECT_FALSE(child2->GetRenderSurface());

EXPECT_EQ(2u, update_layer_list_impl()->size());

EXPECT_TRUE(UpdateLayerListImplContains(front_facing_surface->id()));

@@ -4809,7 +4809,7 @@ TEST_F(LayerTreeHostCommonScalingTest, SurfaceLayerTransformsInHighDPI) {

device_scale_factor * page_scale_factor);

EXPECT_TRANSFORMATION_MATRIX_EQ(

expected_perspective_surface_draw_transform,

- perspective_surface->render_surface()->draw_transform());

+ perspective_surface->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(

expected_perspective_surface_layer_draw_transform,

perspective_surface->DrawTransform());

@@ -4952,20 +4952,20 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) {

device_scale_factor * child->position().x(),

device_scale_factor * child->position().y());

EXPECT_TRANSFORMATION_MATRIX_EQ(expected_render_surface_draw_transform,

- child->render_surface()->draw_transform());

+ child->GetRenderSurface()->draw_transform());

gfx::Transform expected_surface_draw_transform;

expected_surface_draw_transform.Translate(device_scale_factor * 2.f,

device_scale_factor * 2.f);

EXPECT_TRANSFORMATION_MATRIX_EQ(expected_surface_draw_transform,

- child->render_surface()->draw_transform());

+ child->GetRenderSurface()->draw_transform());

gfx::Transform expected_surface_screen_space_transform;

expected_surface_screen_space_transform.Translate(device_scale_factor * 2.f,

device_scale_factor * 2.f);

EXPECT_TRANSFORMATION_MATRIX_EQ(

expected_surface_screen_space_transform,

- child->render_surface()->screen_space_transform());

+ child->GetRenderSurface()->screen_space_transform());

}

TEST_F(LayerTreeHostCommonTest,

@@ -4987,11 +4987,11 @@ TEST_F(LayerTreeHostCommonTest,

EXPECT_EQ(2u, render_surface_layer_list_impl()->size());

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),

- child->render_surface()->draw_transform());

+ child->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),

- child->render_surface()->draw_transform());

+ child->GetRenderSurface()->draw_transform());

EXPECT_TRANSFORMATION_MATRIX_EQ(

- gfx::Transform(), child->render_surface()->screen_space_transform());

+ gfx::Transform(), child->GetRenderSurface()->screen_space_transform());

}

TEST_F(LayerTreeHostCommonTest, LayerSearch) {

@@ -5025,7 +5025,7 @@ TEST_F(LayerTreeHostCommonTest, TransparentChildRenderSurfaceCreation) {

grand_child->SetBounds(gfx::Size(10, 10));

grand_child->SetDrawsContent(true);

ExecuteCalculateDrawProperties(root);

- EXPECT_FALSE(child->has_render_surface());

+ EXPECT_FALSE(child->GetRenderSurface());

}

TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {

@@ -5072,7 +5072,7 @@ TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {

// We should have one render surface and two layers. The child

// layer should be included even though it is transparent.

ASSERT_EQ(1u, render_surface_layer_list.size());

- ASSERT_EQ(2u, root_layer->render_surface()->layer_list().size());

+ ASSERT_EQ(2u, root_layer->GetRenderSurface()->layer_list().size());

// If the root itself is hidden, the child should not be drawn even if it has

// an animating opacity.

@@ -5382,9 +5382,9 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayerImpl) {

// We should have one render surface and two layers. The grand child has

// hidden itself.

ASSERT_EQ(1u, render_surface_layer_list.size());

- ASSERT_EQ(2u, root_layer->render_surface()->layer_list().size());

- EXPECT_EQ(1, root_layer->render_surface()->layer_list().at(0)->id());

- EXPECT_EQ(2, root_layer->render_surface()->layer_list().at(1)->id());

+ ASSERT_EQ(2u, root_layer->GetRenderSurface()->layer_list().size());

+ EXPECT_EQ(1, root_layer->GetRenderSurface()->layer_list().at(0)->id());

+ EXPECT_EQ(2, root_layer->GetRenderSurface()->layer_list().at(1)->id());

}

TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {

@@ -5423,8 +5423,8 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {

// We should have one render surface and one layers. The child has

// hidden itself and the grand child.

ASSERT_EQ(1u, render_surface_layer_list.size());

- ASSERT_EQ(1u, root_layer->render_surface()->layer_list().size());

- EXPECT_EQ(1, root_layer->render_surface()->layer_list().at(0)->id());

+ ASSERT_EQ(1u, root_layer->GetRenderSurface()->layer_list().size());

+ EXPECT_EQ(1, root_layer->GetRenderSurface()->layer_list().at(0)->id());

}

void EmptyCopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {}

@@ -5532,24 +5532,24 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {

EXPECT_EQ(copy_layer->id(), render_surface_layer_list.at(3)->id());

// The root render surface should have 2 contributing layers.

- ASSERT_EQ(2u, root_layer->render_surface()->layer_list().size());

+ ASSERT_EQ(2u, root_layer->GetRenderSurface()->layer_list().size());

EXPECT_EQ(root_layer->id(),

- root_layer->render_surface()->layer_list().at(0)->id());

+ root_layer->GetRenderSurface()->layer_list().at(0)->id());

EXPECT_EQ(copy_grand_parent_layer->id(),

- root_layer->render_surface()->layer_list().at(1)->id());

+ root_layer->GetRenderSurface()->layer_list().at(1)->id());

// Nothing actually draws into the copy parent, so only the copy_layer will

// appear in its list, since it needs to be drawn for the copy request.

- ASSERT_EQ(1u, copy_parent_layer->render_surface()->layer_list().size());

+ ASSERT_EQ(1u, copy_parent_layer->GetRenderSurface()->layer_list().size());

EXPECT_EQ(copy_layer->id(),

- copy_parent_layer->render_surface()->layer_list().at(0)->id());

+ copy_parent_layer->GetRenderSurface()->layer_list().at(0)->id());

// The copy_layer's render surface should have two contributing layers.

- ASSERT_EQ(2u, copy_layer->render_surface()->layer_list().size());

+ ASSERT_EQ(2u, copy_layer->GetRenderSurface()->layer_list().size());

EXPECT_EQ(copy_layer->id(),

- copy_layer->render_surface()->layer_list().at(0)->id());

+ copy_layer->GetRenderSurface()->layer_list().at(0)->id());

EXPECT_EQ(copy_child_layer->id(),

- copy_layer->render_surface()->layer_list().at(1)->id());

+ copy_layer->GetRenderSurface()->layer_list().at(1)->id());

// copy_grand_parent, copy_parent shouldn't be drawn because they are hidden,

// but the copy_layer and copy_child should be drawn for the copy request.

@@ -5570,7 +5570,7 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {

// Though copy_layer is drawn, it shouldn't contribute to drawn surface as its

// actually hidden.

- EXPECT_FALSE(copy_layer->render_surface()->contributes_to_drawn_surface());

+ EXPECT_FALSE(copy_layer->GetRenderSurface()->contributes_to_drawn_surface());

}

TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) {

@@ -5621,9 +5621,9 @@ TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) {

// The root render surface should only have 2 contributing layer, since the

// other layers are empty/clipped away.

- ASSERT_EQ(2u, root_layer->render_surface()->layer_list().size());

+ ASSERT_EQ(2u, root_layer->GetRenderSurface()->layer_list().size());

EXPECT_EQ(root_layer->id(),

- root_layer->render_surface()->layer_list().at(0)->id());

+ root_layer->GetRenderSurface()->layer_list().at(0)->id());

}

TEST_F(LayerTreeHostCommonTest, VisibleRectInNonRootCopyRequest) {

@@ -5743,8 +5743,8 @@ TEST_F(LayerTreeHostCommonTest, TransformedClipParent) {

clip_child->SetBounds(gfx::Size(10, 10));

ExecuteCalculateDrawProperties(root);

- ASSERT_TRUE(root->render_surface());

- ASSERT_TRUE(render_surface->render_surface());

+ ASSERT_TRUE(root->GetRenderSurface());

+ ASSERT_TRUE(render_surface->GetRenderSurface());

// Ensure that we've inherited our clip parent's clip and weren't affected

// by the intervening clip layer.

@@ -5755,14 +5755,14 @@ TEST_F(LayerTreeHostCommonTest, TransformedClipParent) {

// Ensure that the render surface reports a content rect that has been grown

// to accomodate for the clip child.

ASSERT_EQ(gfx::Rect(1, 1, 20, 20),

- render_surface->render_surface()->content_rect());

+ render_surface->GetRenderSurface()->content_rect());

// The above check implies the two below, but they nicely demonstrate that

// we've grown, despite the intervening layer's clip.

ASSERT_TRUE(clip_parent->clip_rect().Contains(

- render_surface->render_surface()->content_rect()));

+ render_surface->GetRenderSurface()->content_rect()));

ASSERT_FALSE(intervening->clip_rect().Contains(

- render_surface->render_surface()->content_rect()));

+ render_surface->GetRenderSurface()->content_rect()));

}

TEST_F(LayerTreeHostCommonTest, ClipParentWithInterveningRenderSurface) {

@@ -5808,19 +5808,19 @@ TEST_F(LayerTreeHostCommonTest, ClipParentWithInterveningRenderSurface) {

clip_child->SetBounds(gfx::Size(60, 60));

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(root->render_surface());

- EXPECT_TRUE(render_surface1->render_surface());

- EXPECT_TRUE(render_surface2->render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

+ EXPECT_TRUE(render_surface1->GetRenderSurface());

+ EXPECT_TRUE(render_surface2->GetRenderSurface());

// Since the render surfaces could have expanded, they should not clip (their

// bounds would no longer be reliable). We should resort to layer clipping

// in this case.

EXPECT_EQ(gfx::Rect(0, 0, 0, 0),

- render_surface1->render_surface()->clip_rect());

- EXPECT_FALSE(render_surface1->render_surface()->is_clipped());

+ render_surface1->GetRenderSurface()->clip_rect());

+ EXPECT_FALSE(render_surface1->GetRenderSurface()->is_clipped());

EXPECT_EQ(gfx::Rect(0, 0, 0, 0),

- render_surface2->render_surface()->clip_rect());

- EXPECT_FALSE(render_surface2->render_surface()->is_clipped());

+ render_surface2->GetRenderSurface()->clip_rect());

+ EXPECT_FALSE(render_surface2->GetRenderSurface()->is_clipped());

// NB: clip rects are in target space.

EXPECT_EQ(gfx::Rect(0, 0, 40, 40), render_surface1->clip_rect());

@@ -5833,9 +5833,9 @@ TEST_F(LayerTreeHostCommonTest, ClipParentWithInterveningRenderSurface) {

// The content rects of both render surfaces should both have expanded to

// contain the clip child.

EXPECT_EQ(gfx::Rect(0, 0, 40, 40),

- render_surface1->render_surface()->content_rect());

+ render_surface1->GetRenderSurface()->content_rect());

EXPECT_EQ(gfx::Rect(-1, -1, 40, 40),

- render_surface2->render_surface()->content_rect());

+ render_surface2->GetRenderSurface()->content_rect());

// The clip child should have inherited the clip parent's clip (projected to

// the right space, of course), and should have the correctly sized visible

@@ -5891,19 +5891,19 @@ TEST_F(LayerTreeHostCommonTest, ClipParentScrolledInterveningLayer) {

clip_child->SetBounds(gfx::Size(60, 60));

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(root->render_surface());

- EXPECT_TRUE(render_surface1->render_surface());

- EXPECT_TRUE(render_surface2->render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

+ EXPECT_TRUE(render_surface1->GetRenderSurface());

+ EXPECT_TRUE(render_surface2->GetRenderSurface());

// Since the render surfaces could have expanded, they should not clip (their

// bounds would no longer be reliable). We should resort to layer clipping

// in this case.

EXPECT_EQ(gfx::Rect(0, 0, 0, 0),

- render_surface1->render_surface()->clip_rect());

- EXPECT_FALSE(render_surface1->render_surface()->is_clipped());

+ render_surface1->GetRenderSurface()->clip_rect());

+ EXPECT_FALSE(render_surface1->GetRenderSurface()->is_clipped());

EXPECT_EQ(gfx::Rect(0, 0, 0, 0),

- render_surface2->render_surface()->clip_rect());

- EXPECT_FALSE(render_surface2->render_surface()->is_clipped());

+ render_surface2->GetRenderSurface()->clip_rect());

+ EXPECT_FALSE(render_surface2->GetRenderSurface()->is_clipped());

// NB: clip rects are in target space.

EXPECT_EQ(gfx::Rect(0, 0, 40, 40), render_surface1->clip_rect());

@@ -5916,9 +5916,9 @@ TEST_F(LayerTreeHostCommonTest, ClipParentScrolledInterveningLayer) {

// The content rects of both render surfaces should both have expanded to

// contain the clip child.

EXPECT_EQ(gfx::Rect(0, 0, 40, 40),

- render_surface1->render_surface()->content_rect());

+ render_surface1->GetRenderSurface()->content_rect());

EXPECT_EQ(gfx::Rect(2, 2, 40, 40),

- render_surface2->render_surface()->content_rect());

+ render_surface2->GetRenderSurface()->content_rect());

// The clip child should have inherited the clip parent's clip (projected to

// the right space, of course), and should have the correctly sized visible

@@ -5960,7 +5960,7 @@ TEST_F(LayerTreeHostCommonTest, DescendantsOfClipChildren) {

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(root->render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

// Neither the clip child nor its descendant should have inherited the clip

// from |intervening|.

@@ -6016,9 +6016,9 @@ TEST_F(LayerTreeHostCommonTest,

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(root->render_surface());

- EXPECT_TRUE(render_surface1->render_surface());

- EXPECT_TRUE(render_surface2->render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

+ EXPECT_TRUE(render_surface1->GetRenderSurface());

+ EXPECT_TRUE(render_surface2->GetRenderSurface());

EXPECT_EQ(gfx::Rect(0, 0, 5, 5), render_surface1->clip_rect());

EXPECT_TRUE(render_surface1->is_clipped());

@@ -6026,23 +6026,23 @@ TEST_F(LayerTreeHostCommonTest,

// The render surface should not clip (it has unclipped descendants), instead

// it should rely on layer clipping.

EXPECT_EQ(gfx::Rect(0, 0, 0, 0),

- render_surface1->render_surface()->clip_rect());

- EXPECT_FALSE(render_surface1->render_surface()->is_clipped());

+ render_surface1->GetRenderSurface()->clip_rect());

+ EXPECT_FALSE(render_surface1->GetRenderSurface()->is_clipped());

// That said, it should have grown to accomodate the unclipped descendant and

// its own size.

EXPECT_EQ(gfx::Rect(-1, 0, 6, 5),

- render_surface1->render_surface()->content_rect());

+ render_surface1->GetRenderSurface()->content_rect());

// This render surface should clip. It has no unclipped descendants.

EXPECT_EQ(gfx::Rect(0, 0, 10, 10),

- render_surface2->render_surface()->clip_rect());

- EXPECT_TRUE(render_surface2->render_surface()->is_clipped());

+ render_surface2->GetRenderSurface()->clip_rect());

+ EXPECT_TRUE(render_surface2->GetRenderSurface()->is_clipped());

EXPECT_FALSE(render_surface2->is_clipped());

// It also shouldn't have grown to accomodate the clip child.

EXPECT_EQ(gfx::Rect(0, 0, 5, 5),

- render_surface2->render_surface()->content_rect());

+ render_surface2->GetRenderSurface()->content_rect());

// Sanity check our num_unclipped_descendants values.

EXPECT_EQ(1u, render_surface1->test_properties()->num_unclipped_descendants);

@@ -6075,10 +6075,10 @@ TEST_F(LayerTreeHostCommonTest,

ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);

// Verify which render surfaces were created.

- EXPECT_TRUE(root->has_render_surface());

- EXPECT_FALSE(child1->has_render_surface());

- EXPECT_TRUE(child2->has_render_surface());

- EXPECT_FALSE(child3->has_render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

+ EXPECT_FALSE(child1->GetRenderSurface());

+ EXPECT_TRUE(child2->GetRenderSurface());

+ EXPECT_FALSE(child3->GetRenderSurface());

}

TEST_F(LayerTreeHostCommonTest, CanRenderToSeparateSurface) {

@@ -6217,16 +6217,18 @@ TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleSurfaces) {

ExecuteCalculateDrawProperties(root);

EXPECT_EQ(3u, render_surface_layer_list_impl()->size());

- EXPECT_EQ(2u, render_surface_layer_list_impl()

- ->at(0)

- ->render_surface()

- ->layer_list()

- .size());

- EXPECT_EQ(1u, render_surface_layer_list_impl()

- ->at(1)

- ->render_surface()

- ->layer_list()

- .size());

+ EXPECT_EQ(2u,

+ render_surface_layer_list_impl()

+ ->at(0)

+ ->GetRenderSurface()

+ ->layer_list()

+ .size());

+ EXPECT_EQ(1u,

+ render_surface_layer_list_impl()

+ ->at(1)

+ ->GetRenderSurface()

+ ->layer_list()

+ .size());

gfx::Transform rotation_transform;

rotation_transform.RotateAboutXAxis(180.0);

@@ -6241,11 +6243,12 @@ TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleSurfaces) {

// double-sided, but will still be in RSLL as it's in a different 3d rendering

// context.

EXPECT_EQ(2u, render_surface_layer_list_impl()->size());

- EXPECT_EQ(1u, render_surface_layer_list_impl()

- ->at(0)

- ->render_surface()

- ->layer_list()

- .size());

+ EXPECT_EQ(1u,

+ render_surface_layer_list_impl()

+ ->at(0)

+ ->GetRenderSurface()

+ ->layer_list()

+ .size());

}

TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleLayers) {

@@ -6265,10 +6268,11 @@ TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleLayers) {

ExecuteCalculateDrawProperties(root);

EXPECT_EQ(1u, render_surface_layer_list_impl()->size());

- EXPECT_EQ(grand_child, render_surface_layer_list_impl()

- ->at(0)

- ->render_surface()

- ->layer_list()[0]);

+ EXPECT_EQ(grand_child,

+ render_surface_layer_list_impl()

+ ->at(0)

+ ->GetRenderSurface()

+ ->layer_list()[0]);

// As all layers have identity transform, we shouldn't check for backface

// visibility.

@@ -6291,11 +6295,12 @@ TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleLayers) {

ExecuteCalculateDrawProperties(root);

EXPECT_EQ(1u, render_surface_layer_list_impl()->size());

- EXPECT_EQ(0u, render_surface_layer_list_impl()

- ->at(0)

- ->render_surface()

- ->layer_list()

- .size());

+ EXPECT_EQ(0u,

+ render_surface_layer_list_impl()

+ ->at(0)

+ ->GetRenderSurface()

+ ->layer_list()

+ .size());

// We should check for backface visibilty of child as it has a rotation

// transform. We should also check for grand_child as it uses the backface

@@ -6317,11 +6322,12 @@ TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleLayers) {

ExecuteCalculateDrawProperties(root);

EXPECT_EQ(1u, render_surface_layer_list_impl()->size());

- EXPECT_EQ(0u, render_surface_layer_list_impl()

- ->at(0)

- ->render_surface()

- ->layer_list()

- .size());

+ EXPECT_EQ(0u,

+ render_surface_layer_list_impl()

+ ->at(0)

+ ->GetRenderSurface()

+ ->layer_list()

+ .size());

// We should check the backface visibility of child as it has a rotation

// transform and for grand_child as it is in a 3d rendering context and not

@@ -6425,7 +6431,7 @@ TEST_F(LayerTreeHostCommonTest, ClippedByScrollParent) {

scroll_child->SetBounds(gfx::Size(50, 50));

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(root->render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

EXPECT_EQ(gfx::Rect(0, 0, 30, 30), scroll_child->clip_rect());

EXPECT_TRUE(scroll_child->is_clipped());

@@ -6597,7 +6603,7 @@ TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollParent) {

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(root->render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

EXPECT_EQ(gfx::Rect(0, 0, 30, 30), scroll_child->clip_rect());

EXPECT_TRUE(scroll_child->is_clipped());

@@ -6655,17 +6661,17 @@ TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollGrandparent) {

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(root->render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

EXPECT_EQ(gfx::Rect(0, 0, 20, 20), scroll_child->clip_rect());

EXPECT_TRUE(scroll_child->is_clipped());

// Despite the fact that we visited the above layers out of order to get the

// correct clip, the layer lists should be unaffected.

- EXPECT_EQ(3u, root->render_surface()->layer_list().size());

- EXPECT_EQ(scroll_child, root->render_surface()->layer_list().at(0));

- EXPECT_EQ(scroll_parent, root->render_surface()->layer_list().at(1));

- EXPECT_EQ(scroll_grandparent, root->render_surface()->layer_list().at(2));

+ EXPECT_EQ(3u, root->GetRenderSurface()->layer_list().size());

+ EXPECT_EQ(scroll_child, root->GetRenderSurface()->layer_list().at(0));

+ EXPECT_EQ(scroll_parent, root->GetRenderSurface()->layer_list().at(1));

+ EXPECT_EQ(scroll_grandparent, root->GetRenderSurface()->layer_list().at(2));

}

TEST_F(LayerTreeHostCommonTest, OutOfOrderClippingRequiresRSLLSorting) {

@@ -6732,7 +6738,7 @@ TEST_F(LayerTreeHostCommonTest, OutOfOrderClippingRequiresRSLLSorting) {

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(root->render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

EXPECT_EQ(gfx::Rect(0, 0, 20, 20), scroll_child->clip_rect());

EXPECT_TRUE(scroll_child->is_clipped());

@@ -6743,9 +6749,9 @@ TEST_F(LayerTreeHostCommonTest, OutOfOrderClippingRequiresRSLLSorting) {

EXPECT_EQ(root, render_surface_layer_list_impl()->at(0));

EXPECT_EQ(render_surface2, render_surface_layer_list_impl()->at(1));

EXPECT_EQ(render_surface1, render_surface_layer_list_impl()->at(2));

- EXPECT_TRUE(render_surface_layer_list_impl()->at(0)->render_surface());

- EXPECT_TRUE(render_surface_layer_list_impl()->at(1)->render_surface());

- EXPECT_TRUE(render_surface_layer_list_impl()->at(2)->render_surface());

+ EXPECT_TRUE(render_surface_layer_list_impl()->at(0)->GetRenderSurface());

+ EXPECT_TRUE(render_surface_layer_list_impl()->at(1)->GetRenderSurface());

+ EXPECT_TRUE(render_surface_layer_list_impl()->at(2)->GetRenderSurface());

}

TEST_F(LayerTreeHostCommonTest, FixedPositionWithInterveningRenderSurface) {

@@ -8272,8 +8278,8 @@ static void GatherDrawnLayers(const LayerImplList* rsll,

if (!it.represents_contributing_render_surface())

continue;

- if (layer->render_surface()->MaskLayer())

- drawn_layers->insert(layer->render_surface()->MaskLayer());

+ if (layer->GetRenderSurface()->MaskLayer())

+ drawn_layers->insert(layer->GetRenderSurface()->MaskLayer());

}

@@ -9000,9 +9006,9 @@ TEST_F(LayerTreeHostCommonTest, AnimatedOpacityCreatesRenderSurface) {

ExecuteCalculateDrawProperties(root);

EXPECT_EQ(1.f, child->Opacity());

- EXPECT_TRUE(root->has_render_surface());

- EXPECT_TRUE(child->has_render_surface());

- EXPECT_FALSE(grandchild->has_render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

+ EXPECT_TRUE(child->GetRenderSurface());

+ EXPECT_FALSE(grandchild->GetRenderSurface());

}

// Verify that having an animated filter (but no current filter, as these

@@ -9021,12 +9027,12 @@ TEST_F(LayerTreeHostCommonTest, AnimatedFilterCreatesRenderSurface) {

10.0, 0.1f, 0.2f);

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(root->has_render_surface());

- EXPECT_TRUE(child->has_render_surface());

- EXPECT_FALSE(grandchild->has_render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

+ EXPECT_TRUE(child->GetRenderSurface());

+ EXPECT_FALSE(grandchild->GetRenderSurface());

- EXPECT_TRUE(root->render_surface()->Filters().IsEmpty());

- EXPECT_TRUE(child->render_surface()->Filters().IsEmpty());

+ EXPECT_TRUE(root->GetRenderSurface()->Filters().IsEmpty());

+ EXPECT_TRUE(child->GetRenderSurface()->Filters().IsEmpty());

EXPECT_FALSE(root->FilterIsAnimating());

EXPECT_TRUE(child->FilterIsAnimating());

@@ -9065,12 +9071,12 @@ TEST_F(LayerTreeHostCommonTest, DelayedFilterAnimationCreatesRenderSurface) {

std::move(animation));

ExecuteCalculateDrawProperties(root);

- EXPECT_TRUE(root->has_render_surface());

- EXPECT_TRUE(child->has_render_surface());

- EXPECT_FALSE(grandchild->has_render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

+ EXPECT_TRUE(child->GetRenderSurface());

+ EXPECT_FALSE(grandchild->GetRenderSurface());

- EXPECT_TRUE(root->render_surface()->Filters().IsEmpty());

- EXPECT_TRUE(child->render_surface()->Filters().IsEmpty());

+ EXPECT_TRUE(root->GetRenderSurface()->Filters().IsEmpty());

+ EXPECT_TRUE(child->GetRenderSurface()->Filters().IsEmpty());

EXPECT_FALSE(root->FilterIsAnimating());

EXPECT_FALSE(root->HasPotentiallyRunningFilterAnimation());

@@ -9790,11 +9796,11 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceClipsSubtree) {

transform_tree.Node(significant_transform->transform_tree_index());

EXPECT_EQ(transform_node->owning_layer_id, significant_transform->id());

- EXPECT_TRUE(root->has_render_surface());

- EXPECT_FALSE(significant_transform->has_render_surface());

- EXPECT_TRUE(layer_clips_subtree->has_render_surface());

- EXPECT_TRUE(render_surface->has_render_surface());

- EXPECT_FALSE(test_layer->has_render_surface());

+ EXPECT_TRUE(root->GetRenderSurface());

+ EXPECT_FALSE(significant_transform->GetRenderSurface());

+ EXPECT_TRUE(layer_clips_subtree->GetRenderSurface());

+ EXPECT_TRUE(render_surface->GetRenderSurface());

+ EXPECT_FALSE(test_layer->GetRenderSurface());

ClipTree& clip_tree = root->layer_tree_impl()->property_trees()->clip_tree;

ClipNode* clip_node = clip_tree.Node(render_surface->clip_tree_index());

@@ -10005,13 +10011,13 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceContentRectWithMultipleSurfaces) {

ExecuteCalculateDrawProperties(root);

EXPECT_EQ(gfx::Rect(50, 50),

- unclipped_surface->render_surface()->content_rect());

+ unclipped_surface->GetRenderSurface()->content_rect());

EXPECT_EQ(gfx::Rect(50, 50),

- unclipped_desc_surface->render_surface()->content_rect());

+ unclipped_desc_surface->GetRenderSurface()->content_rect());

EXPECT_EQ(gfx::Rect(50, 50),

- unclipped_desc_surface2->render_surface()->content_rect());

+ unclipped_desc_surface2->GetRenderSurface()->content_rect());

EXPECT_EQ(gfx::Rect(50, 50),

- clipped_surface->render_surface()->content_rect());

+ clipped_surface->GetRenderSurface()->content_rect());

}

TEST_F(LayerTreeHostCommonTest, ClipBetweenClipChildTargetAndClipParentTarget) {

@@ -10053,7 +10059,7 @@ TEST_F(LayerTreeHostCommonTest, ClipBetweenClipChildTargetAndClipParentTarget) {

ExecuteCalculateDrawProperties(root);

EXPECT_EQ(gfx::Rect(10, 10),

- unclipped_desc_surface->render_surface()->content_rect());

+ unclipped_desc_surface->GetRenderSurface()->content_rect());

}

TEST_F(LayerTreeHostCommonTest, VisibleRectForDescendantOfScaledSurface) {

@@ -10401,7 +10407,7 @@ TEST_F(LayerTreeHostCommonTest, LargeTransformTest) {

ExecuteCalculateDrawProperties(root);

EXPECT_EQ(gfx::RectF(),

- render_surface1->render_surface()->DrawableContentRect());

+ render_surface1->GetRenderSurface()->DrawableContentRect());

bool is_inf_or_nan = std::isinf(child->DrawTransform().matrix().get(0, 0)) ||

std::isnan(child->DrawTransform().matrix().get(0, 0));

« no previous file with comments | « cc/trees/layer_tree_host_common.cc ('k') | cc/trees/layer_tree_host_impl.cc » ('j') | no next file with comments »