Delete LayerImpl::GetRenderSurface.

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 729 matching lines @@
   parent->test_properties()->transform = parent_layer_transform;
   parent->test_properties()->transform_origin = gfx::Point3F(2.5f, 30.f, 0.f);
   parent->SetBounds(gfx::Size(100, 120));
   child->SetBounds(gfx::Size(16, 18));
   child->test_properties()->force_render_surface = true;
   grand_child->SetBounds(gfx::Size(8, 10));
   grand_child->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   // Render surface should have been created now.
-  ASSERT_TRUE(child->GetRenderSurface());
-  ASSERT_EQ(child->GetRenderSurface(), child->render_target());
+  ASSERT_TRUE(GetRenderSurface(child));
+  ASSERT_EQ(GetRenderSurface(child), 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.
   EXPECT_TRANSFORMATION_MATRIX_EQ(surface_sublayer_transform,
                                   child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform,
                                   child->ScreenSpaceTransform());
 
   // Because the grand_child is the only drawable content, the child's render
   // surface will tighten its bounds to the grand_child.  The scale at which the
@@ skipping 163 matching lines @@
   grand_child_of_rs1->SetBounds(gfx::Size(10, 10));
   grand_child_of_rs2->test_properties()->transform_origin =
       gfx::Point3F(2.5f, 0.f, 0.f);
   grand_child_of_rs2->test_properties()->transform = layer_transform;
   grand_child_of_rs2->SetBounds(gfx::Size(10, 10));
 
   ExecuteCalculateDrawProperties(root);
 
   // Only layers that are associated with render surfaces should have an actual
   // RenderSurface() value.
-  ASSERT_TRUE(root->GetRenderSurface());
-  ASSERT_FALSE(child_of_root->GetRenderSurface());
-  ASSERT_FALSE(grand_child_of_root->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(root));
+  ASSERT_FALSE(GetRenderSurface(child_of_root));
+  ASSERT_FALSE(GetRenderSurface(grand_child_of_root));
 
-  ASSERT_TRUE(render_surface1->GetRenderSurface());
-  ASSERT_FALSE(child_of_rs1->GetRenderSurface());
-  ASSERT_FALSE(grand_child_of_rs1->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(render_surface1));
+  ASSERT_FALSE(GetRenderSurface(child_of_rs1));
+  ASSERT_FALSE(GetRenderSurface(grand_child_of_rs1));
 
-  ASSERT_TRUE(render_surface2->GetRenderSurface());
-  ASSERT_FALSE(child_of_rs2->GetRenderSurface());
-  ASSERT_FALSE(grand_child_of_rs2->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(render_surface2));
+  ASSERT_FALSE(GetRenderSurface(child_of_rs2));
+  ASSERT_FALSE(GetRenderSurface(grand_child_of_rs2));
 
   // Verify all render target accessors
-  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(GetRenderSurface(root), parent->render_target());
+  EXPECT_EQ(GetRenderSurface(root), child_of_root->render_target());
+  EXPECT_EQ(GetRenderSurface(root), grand_child_of_root->render_target());
 
-  EXPECT_EQ(render_surface1->GetRenderSurface(),
+  EXPECT_EQ(GetRenderSurface(render_surface1),
             render_surface1->render_target());
-  EXPECT_EQ(render_surface1->GetRenderSurface(), child_of_rs1->render_target());
-  EXPECT_EQ(render_surface1->GetRenderSurface(),
+  EXPECT_EQ(GetRenderSurface(render_surface1), child_of_rs1->render_target());
+  EXPECT_EQ(GetRenderSurface(render_surface1),
             grand_child_of_rs1->render_target());
 
-  EXPECT_EQ(render_surface2->GetRenderSurface(),
+  EXPECT_EQ(GetRenderSurface(render_surface2),
             render_surface2->render_target());
-  EXPECT_EQ(render_surface2->GetRenderSurface(), child_of_rs2->render_target());
-  EXPECT_EQ(render_surface2->GetRenderSurface(),
+  EXPECT_EQ(GetRenderSurface(render_surface2), child_of_rs2->render_target());
+  EXPECT_EQ(GetRenderSurface(render_surface2),
             grand_child_of_rs2->render_target());
 
   // Verify layer draw transforms note that draw transforms are described with
   // respect to the nearest ancestor render surface but screen space transforms
   // are described with respect to the root.
   EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A, child_of_root->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A * A,
                                   grand_child_of_root->DrawTransform());
 
@@ skipping 25 matching lines @@
                                   render_surface2->ScreenSpaceTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A * A * A,
                                   child_of_rs2->ScreenSpaceTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A * A * A * A,
                                   grand_child_of_rs2->ScreenSpaceTransform());
 
   // Verify render surface transforms.
   //
   // Draw transform of render surface 1 is described with respect to root.
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      A * A * S1, render_surface1->GetRenderSurface()->draw_transform());
+      A * A * S1, GetRenderSurface(render_surface1)->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      A * A * S1,
-      render_surface1->GetRenderSurface()->screen_space_transform());
+      A * A * S1, GetRenderSurface(render_surface1)->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->GetRenderSurface()->draw_transform());
+      SS1 * A * S2, GetRenderSurface(render_surface2)->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       A * A * A * S2,
-      render_surface2->GetRenderSurface()->screen_space_transform());
+      GetRenderSurface(render_surface2)->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
   // the screen-space transform encodes the "depth" of the layer in the tree.
   EXPECT_FLOAT_EQ(1.0, parent->ScreenSpaceTransform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(2.0,
                   child_of_root->ScreenSpaceTransform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(
       3.0, grand_child_of_root->ScreenSpaceTransform().matrix().get(1, 3));
 
@@ skipping 50 matching lines @@
   gfx::Transform expected_grand_child_screen_space_transform =
       flattened_rotation_about_y * rotation_about_y_axis;
   gfx::Transform expected_great_grand_child_draw_transform =
       flattened_rotation_about_y;
   gfx::Transform expected_great_grand_child_screen_space_transform =
       flattened_rotation_about_y * flattened_rotation_about_y;
 
   ExecuteCalculateDrawProperties(root);
 
   // The child's draw transform should have been taken by its surface.
-  ASSERT_TRUE(child->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(child));
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_draw_transform,
-                                  child->GetRenderSurface()->draw_transform());
+                                  GetRenderSurface(child)->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_child_screen_space_transform,
-      child->GetRenderSurface()->screen_space_transform());
+      GetRenderSurface(child)->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_screen_space_transform,
                                   child->ScreenSpaceTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_draw_transform,
                                   grand_child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform,
                                   grand_child->ScreenSpaceTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_draw_transform,
                                   great_grand_child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
@@ skipping 55 matching lines @@
   grand_child->SetDrawsContent(true);
 
   root->SetBounds(gfx::Size(100, 100));
   // The child height is zero, but has non-zero width that should be accounted
   // for while computing draw transforms.
   child->SetBounds(gfx::Size(10, 0));
   child->test_properties()->force_render_surface = true;
   grand_child->SetBounds(gfx::Size(10, 10));
   ExecuteCalculateDrawProperties(root);
 
-  ASSERT_TRUE(child->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(child));
   // This is the real test, the rest are sanity checks.
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
-                                  child->GetRenderSurface()->draw_transform());
+                                  GetRenderSurface(child)->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                   grand_child->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceWithSublayerScale) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(render_surface);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
@@ skipping 46 matching lines @@
     RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), translate, &render_surface_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         translate, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         translate, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
-                                    root->GetRenderSurface()->draw_transform());
+                                    GetRenderSurface(root)->draw_transform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(translate, child->ScreenSpaceTransform());
     EXPECT_EQ(gfx::Rect(50, 50, 100, 100), child->clip_rect());
   }
 
   gfx::Transform scale;
   scale.Scale(2, 2);
   {
     RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), scale, &render_surface_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         scale, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         scale, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
-                                    root->GetRenderSurface()->draw_transform());
+                                    GetRenderSurface(root)->draw_transform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(scale, child->ScreenSpaceTransform());
     EXPECT_EQ(gfx::Rect(0, 0, 200, 200), child->clip_rect());
   }
 
   gfx::Transform rotate;
   rotate.Rotate(2);
   {
     RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), rotate, &render_surface_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         rotate, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         rotate, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
-                                    root->GetRenderSurface()->draw_transform());
+                                    GetRenderSurface(root)->draw_transform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(rotate, child->ScreenSpaceTransform());
     EXPECT_EQ(gfx::Rect(-4, 0, 104, 104), child->clip_rect());
   }
 
   gfx::Transform composite;
   composite.ConcatTransform(translate);
   composite.ConcatTransform(scale);
   composite.ConcatTransform(rotate);
   {
     RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), composite, &render_surface_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         composite, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         composite, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
-                                    root->GetRenderSurface()->draw_transform());
+                                    GetRenderSurface(root)->draw_transform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(composite, child->ScreenSpaceTransform());
     EXPECT_EQ(gfx::Rect(89, 103, 208, 208), child->clip_rect());
   }
 
   // Verify it composes correctly with device scale.
   float device_scale_factor = 1.5f;
 
   {
     RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), translate, &render_surface_list_impl);
     inputs.device_scale_factor = device_scale_factor;
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     gfx::Transform device_scaled_translate = translate;
     device_scaled_translate.Scale(device_scale_factor, device_scale_factor);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         device_scaled_translate,
         root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         device_scaled_translate,
         child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
-                                    root->GetRenderSurface()->draw_transform());
+                                    GetRenderSurface(root)->draw_transform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(device_scaled_translate,
                                     child->ScreenSpaceTransform());
     EXPECT_EQ(gfx::Rect(50, 50, 150, 150), child->clip_rect());
   }
 
   // Verify it composes correctly with page scale.
   float page_scale_factor = 2.f;
 
   {
     RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), translate, &render_surface_list_impl);
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_layer = root;
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     gfx::Transform page_scaled_translate = translate;
     page_scaled_translate.Scale(page_scale_factor, page_scale_factor);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         page_scaled_translate, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         page_scaled_translate, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
-                                    root->GetRenderSurface()->draw_transform());
+                                    GetRenderSurface(root)->draw_transform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(page_scaled_translate,
                                     child->ScreenSpaceTransform());
     EXPECT_EQ(gfx::Rect(50, 50, 200, 200), child->clip_rect());
   }
 
   // Verify that it composes correctly with transforms directly on root layer.
   root->test_properties()->transform = composite;
 
   {
     RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), composite, &render_surface_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     gfx::Transform compositeSquared = composite;
     compositeSquared.ConcatTransform(composite);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
-                                    root->GetRenderSurface()->draw_transform());
+                                    GetRenderSurface(root)->draw_transform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(compositeSquared,
                                     child->ScreenSpaceTransform());
     EXPECT_EQ(gfx::Rect(254, 316, 428, 428), child->clip_rect());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceListForRenderSurfaceWithClippedLayer) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
 
   root->SetBounds(gfx::Size(10, 10));
   root->SetMasksToBounds(true);
   render_surface1->SetBounds(gfx::Size(10, 10));
   render_surface1->test_properties()->force_render_surface = true;
   child->SetDrawsContent(true);
   child->SetPosition(gfx::PointF(30.f, 30.f));
   child->SetBounds(gfx::Size(10, 10));
   ExecuteCalculateDrawProperties(root);
 
   // The child layer's content is entirely outside the root's clip rect, so
   // the intermediate render surface should not be listed here, even if it was
   // 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->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(root));
   EXPECT_EQ(1U, render_surface_list_impl()->size());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
 
   render_surface1->SetBounds(gfx::Size(10, 10));
   render_surface1->test_properties()->force_render_surface = true;
   render_surface1->test_properties()->opacity = 0.f;
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
 
   RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root, root->bounds(), &render_surface_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // 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->GetRenderSurface());
-  EXPECT_EQ(0, root->GetRenderSurface()->num_contributors());
+  ASSERT_TRUE(GetRenderSurface(root));
+  EXPECT_EQ(0, GetRenderSurface(root)->num_contributors());
   EXPECT_EQ(1U, render_surface_list.size());
   EXPECT_EQ(root->id(), render_surface_list.at(0)->id());
   EXPECT_EQ(gfx::Rect(), root->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceListForTransparentChildWithBackgroundFilter) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
@@ skipping 13 matching lines @@
   {
     RenderSurfaceList render_surface_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), &render_surface_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_EQ(2U, render_surface_list.size());
   }
   // The layer is fully transparent, but has a background filter, so it
   // shouldn't be skipped and should be drawn.
-  ASSERT_TRUE(root->GetRenderSurface());
-  EXPECT_EQ(1, root->GetRenderSurface()->num_contributors());
+  ASSERT_TRUE(GetRenderSurface(root));
+  EXPECT_EQ(1, GetRenderSurface(root)->num_contributors());
   EXPECT_EQ(gfx::RectF(0, 0, 10, 10),
-            root->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(root)->DrawableContentRect());
   EffectTree& effect_tree =
       root->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(render_surface1->effect_tree_index());
   EXPECT_TRUE(node->is_drawn);
 
   // When root is transparent, the layer should not be drawn.
   root->layer_tree_impl()->SetOpacityMutated(root->element_id(), 0.f);
   root->layer_tree_impl()->SetOpacityMutated(render_surface1->element_id(),
                                              1.f);
   render_surface1->set_visible_layer_rect(gfx::Rect());
@@ skipping 32 matching lines @@
   child2->SetBounds(gfx::Size(25, 25));
   child2->SetDrawsContent(true);
   child2->test_properties()->force_render_surface = true;
 
   RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root, root->bounds(), &render_surface_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
-  ASSERT_TRUE(parent->GetRenderSurface());
-  EXPECT_EQ(2, parent->GetRenderSurface()->num_contributors());
+  ASSERT_TRUE(GetRenderSurface(parent));
+  EXPECT_EQ(2, GetRenderSurface(parent)->num_contributors());
   EXPECT_EQ(4U, render_surface_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->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(parent)->DrawableContentRect());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableContentRectForReferenceFilter) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
   root->SetBounds(gfx::Size(100, 100));
   child->SetBounds(gfx::Size(25, 25));
   child->SetDrawsContent(true);
   child->test_properties()->force_render_surface = true;
   FilterOperations filters;
   filters.Append(FilterOperation::CreateReferenceFilter(
       SkOffsetImageFilter::Make(50, 50, nullptr)));
   child->test_properties()->filters = filters;
   ExecuteCalculateDrawProperties(root);
 
   // 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->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(child));
   EXPECT_EQ(gfx::RectF(50, 50, 25, 25),
-            child->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(child)->DrawableContentRect());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableContentRectForReferenceFilterHighDpi) {
   const float device_scale_factor = 2.0f;
 
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
   root->SetBounds(gfx::Size(100, 100));
   child->SetBounds(gfx::Size(25, 25));
   child->SetDrawsContent(true);
   child->test_properties()->force_render_surface = true;
 
   FilterOperations filters;
   filters.Append(FilterOperation::CreateReferenceFilter(
       SkOffsetImageFilter::Make(50, 50, nullptr)));
   child->test_properties()->filters = filters;
 
   ExecuteCalculateDrawProperties(root, device_scale_factor);
 
   // 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). All coordinates should be scaled by 2,
   // corresponding to the device scale factor.
-  ASSERT_TRUE(child->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(child));
   EXPECT_EQ(gfx::RectF(100, 100, 50, 50),
-            child->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(child)->DrawableContentRect());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceForBlendMode) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
   root->SetBounds(gfx::Size(10, 10));
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
   child->test_properties()->blend_mode = SkBlendMode::kMultiply;
   child->test_properties()->opacity = 0.5f;
   child->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
 
   // Since the child layer has a blend mode other than normal, it should get
   // its own render surface.
-  ASSERT_TRUE(child->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(child));
   EXPECT_EQ(1.0f, child->draw_opacity());
-  EXPECT_EQ(0.5f, child->GetRenderSurface()->draw_opacity());
-  EXPECT_EQ(SkBlendMode::kMultiply, child->GetRenderSurface()->BlendMode());
+  EXPECT_EQ(0.5f, GetRenderSurface(child)->draw_opacity());
+  EXPECT_EQ(SkBlendMode::kMultiply, GetRenderSurface(child)->BlendMode());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceDrawOpacity) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* not_surface = AddChild<LayerImpl>(surface1);
   LayerImpl* surface2 = AddChild<LayerImpl>(not_surface);
 
   root->SetBounds(gfx::Size(10, 10));
   surface1->SetBounds(gfx::Size(10, 10));
   surface1->SetDrawsContent(true);
   surface1->test_properties()->opacity = 0.5f;
   surface1->test_properties()->force_render_surface = true;
   not_surface->SetBounds(gfx::Size(10, 10));
   not_surface->test_properties()->opacity = 0.5f;
   surface2->SetBounds(gfx::Size(10, 10));
   surface2->SetDrawsContent(true);
   surface2->test_properties()->opacity = 0.5f;
   surface2->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
 
-  ASSERT_TRUE(surface1->GetRenderSurface());
-  ASSERT_FALSE(not_surface->GetRenderSurface());
-  ASSERT_TRUE(surface2->GetRenderSurface());
-  EXPECT_EQ(0.5f, surface1->GetRenderSurface()->draw_opacity());
+  ASSERT_TRUE(GetRenderSurface(surface1));
+  ASSERT_FALSE(GetRenderSurface(not_surface));
+  ASSERT_TRUE(GetRenderSurface(surface2));
+  EXPECT_EQ(0.5f, GetRenderSurface(surface1)->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->GetRenderSurface()->draw_opacity());
+  EXPECT_EQ(0.25f, GetRenderSurface(surface2)->draw_opacity());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawOpacityWhenCannotRenderToSeparateSurface) {
   // Tests that when separate surfaces are disabled, a layer's draw opacity is
   // the product of all ancestor layer opacties and the layer's own opacity.
   // (Rendering will still be incorrect in situations where we really do need
   // surfaces to apply opacity, such as when we have overlapping layers with an
   // ancestor whose opacity is <1.)
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
@@ skipping 57 matching lines @@
   root->SetBounds(gfx::Size(10, 10));
   render_surface1->SetBounds(gfx::Size(10, 10));
   render_surface1->test_properties()->force_render_surface = true;
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
 
   {
     ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
     // The root layer always creates a render surface
-    EXPECT_TRUE(root->GetRenderSurface());
-    EXPECT_TRUE(render_surface1->GetRenderSurface());
+    EXPECT_TRUE(GetRenderSurface(root));
+    EXPECT_TRUE(GetRenderSurface(render_surface1));
   }
 
   {
     render_surface1->test_properties()->force_render_surface = false;
     render_surface1->layer_tree_impl()->property_trees()->needs_rebuild = true;
     ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
-    EXPECT_TRUE(root->GetRenderSurface());
-    EXPECT_FALSE(render_surface1->GetRenderSurface());
+    EXPECT_TRUE(GetRenderSurface(root));
+    EXPECT_FALSE(GetRenderSurface(render_surface1));
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfacesFlattenScreenSpaceTransform) {
   // Render surfaces act as a flattening point for their subtree, so should
   // always flatten the target-to-screen space transform seen by descendants.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform rotation_about_y_axis;
   rotation_about_y_axis.RotateAboutYAxis(30.0);
 
   root->SetBounds(gfx::Size(100, 100));
   parent->test_properties()->transform = rotation_about_y_axis;
   parent->SetBounds(gfx::Size(10, 10));
   parent->test_properties()->force_render_surface = true;
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
   grand_child->SetBounds(gfx::Size(10, 10));
   grand_child->SetDrawsContent(true);
   grand_child->test_properties()->should_flatten_transform = false;
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_TRUE(parent->GetRenderSurface());
-  EXPECT_FALSE(child->GetRenderSurface());
-  EXPECT_FALSE(grand_child->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(parent));
+  EXPECT_FALSE(GetRenderSurface(child));
+  EXPECT_FALSE(GetRenderSurface(grand_child));
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                   grand_child->DrawTransform());
 
   // The screen-space transform inherited by |child| and |grand_child| should
   // have been flattened at their render target. In particular, the fact that
   // |grand_child| happens to preserve 3d shouldn't affect this flattening.
   gfx::Transform flattened_rotation_about_y = rotation_about_y_axis;
   flattened_rotation_about_y.FlattenTo2d();
@@ skipping 117 matching lines @@
   grand_child->SetBounds(gfx::Size(100, 100));
   grand_child->SetDrawsContent(true);
   leaf_node1->SetBounds(gfx::Size(100, 100));
   leaf_node1->SetDrawsContent(true);
   leaf_node2->SetBounds(gfx::Size(100, 100));
   leaf_node2->SetDrawsContent(true);
 
   // Case 1: nothing is clipped except the root render surface.
   ExecuteCalculateDrawProperties(root);
 
-  ASSERT_TRUE(root->GetRenderSurface());
-  ASSERT_TRUE(child2->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(root));
+  ASSERT_TRUE(GetRenderSurface(child2));
 
   EXPECT_FALSE(root->is_clipped());
-  EXPECT_TRUE(root->GetRenderSurface()->is_clipped());
+  EXPECT_TRUE(GetRenderSurface(root)->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
-  EXPECT_FALSE(child2->GetRenderSurface()->is_clipped());
+  EXPECT_FALSE(GetRenderSurface(child2)->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
 
   // Case 2: parent MasksToBounds, so the parent, child1, and child2's
   // surface are clipped. But layers that contribute to child2's surface are
   // not clipped explicitly because child2's surface already accounts for
   // that clip.
   parent->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
 
-  ASSERT_TRUE(root->GetRenderSurface());
-  ASSERT_TRUE(child2->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(root));
+  ASSERT_TRUE(GetRenderSurface(child2));
 
   EXPECT_FALSE(root->is_clipped());
-  EXPECT_TRUE(root->GetRenderSurface()->is_clipped());
+  EXPECT_TRUE(GetRenderSurface(root)->is_clipped());
   EXPECT_TRUE(parent->is_clipped());
   EXPECT_TRUE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
-  EXPECT_TRUE(child2->GetRenderSurface()->is_clipped());
+  EXPECT_TRUE(GetRenderSurface(child2)->is_clipped());
   EXPECT_TRUE(grand_child->is_clipped());
   EXPECT_TRUE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
 
   parent->SetMasksToBounds(false);
 
   // Case 3: child2 MasksToBounds. The layer and subtree are clipped, and
   // child2's render surface is not clipped.
   child2->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
 
-  ASSERT_TRUE(root->GetRenderSurface());
-  ASSERT_TRUE(child2->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(root));
+  ASSERT_TRUE(GetRenderSurface(child2));
 
   EXPECT_FALSE(root->is_clipped());
-  EXPECT_TRUE(root->GetRenderSurface()->is_clipped());
+  EXPECT_TRUE(GetRenderSurface(root)->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_TRUE(child2->is_clipped());
-  EXPECT_FALSE(child2->GetRenderSurface()->is_clipped());
+  EXPECT_FALSE(GetRenderSurface(child2)->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, UpdateClipRectCorrectly) {
   // Tests that when as long as layer is clipped, it's clip rect is set to
   // correct value.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
@@ skipping 262 matching lines @@
   leaf_node1->SetBounds(gfx::Size(10, 10));
   leaf_node1->SetDrawsContent(true);
   leaf_node2->SetBounds(gfx::Size(10, 10));
   leaf_node2->SetDrawsContent(true);
   leaf_node3->SetBounds(gfx::Size(10, 10));
   leaf_node3->SetDrawsContent(true);
   leaf_node4->SetBounds(gfx::Size(10, 10));
   leaf_node4->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(parent);
 
-  ASSERT_TRUE(grand_child1->GetRenderSurface());
-  ASSERT_TRUE(grand_child2->GetRenderSurface());
-  ASSERT_TRUE(grand_child3->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(grand_child1));
+  ASSERT_TRUE(GetRenderSurface(grand_child2));
+  ASSERT_TRUE(GetRenderSurface(grand_child3));
 
   // 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->GetRenderSurface()->clip_rect());
+            GetRenderSurface(grand_child1)->clip_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
-            grand_child2->GetRenderSurface()->clip_rect());
+            GetRenderSurface(grand_child2)->clip_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
-            grand_child3->GetRenderSurface()->clip_rect());
+            GetRenderSurface(grand_child3)->clip_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipRectWhenCannotRenderToSeparateSurface) {
   // Tests that when separate surfaces are disabled, a layer's clip_rect is the
   // intersection of all ancestor clips in screen space; in particular, if a
   // layer masks to bounds, it contributes to the clip_rect of all layers in its
   // subtree (since there are no render surfaces that can reset the clip_rect).
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child1 = AddChild<LayerImpl>(parent);
@@ skipping 25 matching lines @@
   leaf_node2->SetDrawsContent(true);
 
   root->test_properties()->force_render_surface = true;
   child1->test_properties()->force_render_surface = true;
   grand_child->test_properties()->force_render_surface = true;
 
   // Case 1: Nothing is clipped. In this case, each layer's clip rect is its
   // 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->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(GetRenderSurface(root));
+  EXPECT_FALSE(GetRenderSurface(parent));
+  EXPECT_TRUE(GetRenderSurface(child1));
+  EXPECT_FALSE(GetRenderSurface(child2));
+  EXPECT_TRUE(GetRenderSurface(grand_child));
+  EXPECT_FALSE(GetRenderSurface(leaf_node1));
+  EXPECT_FALSE(GetRenderSurface(leaf_node2));
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
-  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());
+  EXPECT_TRUE(GetRenderSurface(root)->is_clipped());
+  EXPECT_FALSE(GetRenderSurface(child1)->is_clipped());
+  EXPECT_FALSE(GetRenderSurface(grand_child)->is_clipped());
+  EXPECT_EQ(gfx::Rect(100, 100), GetRenderSurface(root)->clip_rect());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
-  EXPECT_TRUE(root->GetRenderSurface()->is_clipped());
-  EXPECT_EQ(gfx::Rect(100, 100), root->GetRenderSurface()->clip_rect());
+  EXPECT_TRUE(GetRenderSurface(root)->is_clipped());
+  EXPECT_EQ(gfx::Rect(100, 100), GetRenderSurface(root)->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.
   root->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   root->test_properties()->force_render_surface = true;
   child1->test_properties()->force_render_surface = true;
   grand_child->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
-  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(GetRenderSurface(root));
+  EXPECT_FALSE(GetRenderSurface(parent));
+  EXPECT_TRUE(GetRenderSurface(child1));
+  EXPECT_FALSE(GetRenderSurface(child2));
+  EXPECT_TRUE(GetRenderSurface(grand_child));
+  EXPECT_FALSE(GetRenderSurface(leaf_node1));
+  EXPECT_FALSE(GetRenderSurface(leaf_node2));
   EXPECT_TRUE(root->is_clipped());
   EXPECT_TRUE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
-  EXPECT_TRUE(child1->GetRenderSurface()->is_clipped());
+  EXPECT_TRUE(GetRenderSurface(child1)->is_clipped());
   EXPECT_TRUE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
-  EXPECT_FALSE(grand_child->GetRenderSurface()->is_clipped());
+  EXPECT_FALSE(GetRenderSurface(grand_child)->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->GetRenderSurface()->clip_rect());
+  EXPECT_EQ(gfx::Rect(100, 100), GetRenderSurface(child1)->clip_rect());
   EXPECT_EQ(gfx::Rect(100, 100), child2->clip_rect());
   EXPECT_EQ(gfx::Rect(100, 100), leaf_node2->clip_rect());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_TRUE(root->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());
@@ skipping 14 matching lines @@
   // child1's clip rect doesn't contribute to its descendants, since its only
   // child is a render surface. However, without surfaces, these clip rects
   // contribute to all descendants.
   parent->SetMasksToBounds(true);
   child1->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   root->test_properties()->force_render_surface = true;
   child1->test_properties()->force_render_surface = true;
   grand_child->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
-  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(GetRenderSurface(root));
+  EXPECT_FALSE(GetRenderSurface(parent));
+  EXPECT_TRUE(GetRenderSurface(child1));
+  EXPECT_FALSE(GetRenderSurface(child2));
+  EXPECT_TRUE(GetRenderSurface(grand_child));
+  EXPECT_FALSE(GetRenderSurface(leaf_node1));
+  EXPECT_FALSE(GetRenderSurface(leaf_node2));
   EXPECT_FALSE(root->is_clipped());
-  EXPECT_TRUE(root->GetRenderSurface()->is_clipped());
+  EXPECT_TRUE(GetRenderSurface(root)->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->GetRenderSurface()->is_clipped());
+  EXPECT_TRUE(GetRenderSurface(grand_child)->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
-  EXPECT_EQ(gfx::Rect(100, 100), root->GetRenderSurface()->clip_rect());
+  EXPECT_EQ(gfx::Rect(100, 100), GetRenderSurface(root)->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->GetRenderSurface()->clip_rect());
+  EXPECT_EQ(gfx::Rect(800, 800), GetRenderSurface(grand_child)->clip_rect());
   EXPECT_EQ(gfx::Rect(2, 2, 400, 400), leaf_node2->clip_rect());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_FALSE(root->is_clipped());
-  EXPECT_TRUE(root->GetRenderSurface()->is_clipped());
+  EXPECT_TRUE(GetRenderSurface(root)->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->GetRenderSurface()->clip_rect());
+  EXPECT_EQ(gfx::Rect(100, 100), GetRenderSurface(root)->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());
   EXPECT_EQ(gfx::Rect(6, 6, 396, 396), grand_child->clip_rect());
   EXPECT_EQ(gfx::Rect(6, 6, 396, 396), leaf_node1->clip_rect());
   EXPECT_EQ(gfx::Rect(2, 2, 400, 400), leaf_node2->clip_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingWhenSurfacesDisabled) {
   LayerImpl* root = root_layer_for_testing();
@@ skipping 179 matching lines @@
   AddAnimatedTransformToElementWithPlayer(grand_child_of_root->element_id(),
                                           timeline_impl(), 10.0, 30, 0);
   AddAnimatedTransformToElementWithPlayer(grand_child_of_rs2->element_id(),
                                           timeline_impl(), 10.0, 30, 0);
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
 
   // Only layers that are associated with render surfaces should have an actual
   // RenderSurface() value.
-  ASSERT_TRUE(root->GetRenderSurface());
-  ASSERT_FALSE(child_of_root->GetRenderSurface());
-  ASSERT_FALSE(grand_child_of_root->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(root));
+  ASSERT_FALSE(GetRenderSurface(child_of_root));
+  ASSERT_FALSE(GetRenderSurface(grand_child_of_root));
 
-  ASSERT_TRUE(render_surface1->GetRenderSurface());
-  ASSERT_FALSE(child_of_rs1->GetRenderSurface());
-  ASSERT_FALSE(grand_child_of_rs1->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(render_surface1));
+  ASSERT_FALSE(GetRenderSurface(child_of_rs1));
+  ASSERT_FALSE(GetRenderSurface(grand_child_of_rs1));
 
-  ASSERT_TRUE(render_surface2->GetRenderSurface());
-  ASSERT_FALSE(child_of_rs2->GetRenderSurface());
-  ASSERT_FALSE(grand_child_of_rs2->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(render_surface2));
+  ASSERT_FALSE(GetRenderSurface(child_of_rs2));
+  ASSERT_FALSE(GetRenderSurface(grand_child_of_rs2));
 
   // Verify all render target accessors
-  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(GetRenderSurface(root), root->render_target());
+  EXPECT_EQ(GetRenderSurface(root), child_of_root->render_target());
+  EXPECT_EQ(GetRenderSurface(root), grand_child_of_root->render_target());
 
-  EXPECT_EQ(render_surface1->GetRenderSurface(),
+  EXPECT_EQ(GetRenderSurface(render_surface1),
             render_surface1->render_target());
-  EXPECT_EQ(render_surface1->GetRenderSurface(), child_of_rs1->render_target());
-  EXPECT_EQ(render_surface1->GetRenderSurface(),
+  EXPECT_EQ(GetRenderSurface(render_surface1), child_of_rs1->render_target());
+  EXPECT_EQ(GetRenderSurface(render_surface1),
             grand_child_of_rs1->render_target());
 
-  EXPECT_EQ(render_surface2->GetRenderSurface(),
+  EXPECT_EQ(GetRenderSurface(render_surface2),
             render_surface2->render_target());
-  EXPECT_EQ(render_surface2->GetRenderSurface(), child_of_rs2->render_target());
-  EXPECT_EQ(render_surface2->GetRenderSurface(),
+  EXPECT_EQ(GetRenderSurface(render_surface2), child_of_rs2->render_target());
+  EXPECT_EQ(GetRenderSurface(render_surface2),
             grand_child_of_rs2->render_target());
 
   // Verify screen_space_transform_is_animating values
   EXPECT_FALSE(root->screen_space_transform_is_animating());
   EXPECT_FALSE(child_of_root->screen_space_transform_is_animating());
   EXPECT_TRUE(grand_child_of_root->screen_space_transform_is_animating());
   EXPECT_FALSE(render_surface1->screen_space_transform_is_animating());
   EXPECT_FALSE(child_of_rs1->screen_space_transform_is_animating());
   EXPECT_FALSE(grand_child_of_rs1->screen_space_transform_is_animating());
   EXPECT_TRUE(render_surface2->screen_space_transform_is_animating());
@@ skipping 403 matching lines @@
 TEST_F(LayerTreeHostCommonTest,
        VisibleRectsForPositionedRootLayerClippedByViewport) {
   LayerImpl* root = root_layer_for_testing();
 
   root->SetPosition(gfx::PointF(60, 70));
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
-            root->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(root)->DrawableContentRect());
   // In target space, not clipped.
   EXPECT_EQ(gfx::Rect(60, 70, 100, 100), root->drawable_content_rect());
   // In layer space, clipped.
   EXPECT_EQ(gfx::Rect(40, 30), root->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsForSimpleLayers) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child1_layer = AddChildToRoot<LayerImpl>();
   LayerImpl* child2_layer = AddChildToRoot<LayerImpl>();
   LayerImpl* child3_layer = AddChildToRoot<LayerImpl>();
 
   root->SetBounds(gfx::Size(100, 100));
   child1_layer->SetBounds(gfx::Size(50, 50));
   child1_layer->SetDrawsContent(true);
   child2_layer->SetPosition(gfx::PointF(75.f, 75.f));
   child2_layer->SetBounds(gfx::Size(50, 50));
   child2_layer->SetDrawsContent(true);
   child3_layer->SetPosition(gfx::PointF(125.f, 125.f));
   child3_layer->SetBounds(gfx::Size(50, 50));
   child3_layer->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
-            root->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(root)->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());
 
   // layer visible_layer_rects are clipped by their target surface.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1_layer->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2_layer->visible_layer_rect());
   EXPECT_TRUE(child3_layer->visible_layer_rect().IsEmpty());
 
   // layer drawable_content_rects are not clipped.
@@ skipping 18 matching lines @@
   grand_child1->SetDrawsContent(true);
   grand_child2->SetPosition(gfx::PointF(75.f, 75.f));
   grand_child2->SetBounds(gfx::Size(50, 50));
   grand_child2->SetDrawsContent(true);
   grand_child3->SetPosition(gfx::PointF(125.f, 125.f));
   grand_child3->SetBounds(gfx::Size(50, 50));
   grand_child3->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
-            root->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(root)->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());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child->visible_layer_rect());
 
   // All grandchild visible content rects should be clipped by child.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), grand_child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), grand_child2->visible_layer_rect());
   EXPECT_TRUE(grand_child3->visible_layer_rect().IsEmpty());
 
@@ skipping 36 matching lines @@
   clip->SetBounds(gfx::Size(10, 10));
   filter->test_properties()->force_render_surface = true;
   filter_child->SetBounds(gfx::Size(2000, 2000));
   filter_child->SetPosition(gfx::PointF(-50, -50));
   filter_child->SetDrawsContent(true);
 
   clip->SetMasksToBounds(true);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(50, 50, 10, 10), filter_child->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(10, 10), filter->GetRenderSurface()->content_rect());
+  EXPECT_EQ(gfx::Rect(10, 10), GetRenderSurface(filter)->content_rect());
 
   FilterOperations blur_filter;
   blur_filter.Append(FilterOperation::CreateBlurFilter(4.0f));
   filter->test_properties()->filters = blur_filter;
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(38, 38, 34, 34), filter_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(-12, -12, 34, 34),
-            filter->GetRenderSurface()->content_rect());
+            GetRenderSurface(filter)->content_rect());
 
   gfx::Transform vertical_flip;
   vertical_flip.Scale(1, -1);
   sk_sp<SkImageFilter> flip_filter = SkImageFilter::MakeMatrixFilter(
       vertical_flip.matrix(), kLow_SkFilterQuality, nullptr);
   FilterOperations reflection_filter;
   reflection_filter.Append(
       FilterOperation::CreateReferenceFilter(SkXfermodeImageFilter::Make(
           SkBlendMode::kSrcOver, std::move(flip_filter))));
   filter->test_properties()->filters = reflection_filter;
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(50, 40, 10, 20), filter_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, -10, 10, 20),
-            filter->GetRenderSurface()->content_rect());
+            GetRenderSurface(filter)->content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleRectWithScalingClippingAndFilters) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* scale = AddChild<LayerImpl>(root);
   LayerImpl* clip = AddChild<LayerImpl>(scale);
   LayerImpl* filter = AddChild<LayerImpl>(clip);
   LayerImpl* filter_child = AddChild<LayerImpl>(filter);
 
   root->SetBounds(gfx::Size(100, 100));
   clip->SetBounds(gfx::Size(10, 10));
   filter->test_properties()->force_render_surface = true;
   filter_child->SetBounds(gfx::Size(2000, 2000));
   filter_child->SetPosition(gfx::PointF(-50, -50));
   filter_child->SetDrawsContent(true);
 
   clip->SetMasksToBounds(true);
 
   gfx::Transform scale_transform;
   scale_transform.Scale(3, 3);
   scale->test_properties()->transform = scale_transform;
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(50, 50, 10, 10), filter_child->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(30, 30), filter->GetRenderSurface()->content_rect());
+  EXPECT_EQ(gfx::Rect(30, 30), GetRenderSurface(filter)->content_rect());
 
   FilterOperations blur_filter;
   blur_filter.Append(FilterOperation::CreateBlurFilter(4.0f));
   filter->test_properties()->filters = blur_filter;
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(38, 38, 34, 34), filter_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(-36, -36, 102, 102),
-            filter->GetRenderSurface()->content_rect());
+            GetRenderSurface(filter)->content_rect());
 
   gfx::Transform vertical_flip;
   vertical_flip.Scale(1, -1);
   sk_sp<SkImageFilter> flip_filter = SkImageFilter::MakeMatrixFilter(
       vertical_flip.matrix(), kLow_SkFilterQuality, nullptr);
   FilterOperations reflection_filter;
   reflection_filter.Append(
       FilterOperation::CreateReferenceFilter(SkXfermodeImageFilter::Make(
           SkBlendMode::kSrcOver, std::move(flip_filter))));
   filter->test_properties()->filters = reflection_filter;
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(50, 40, 10, 20), filter_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, -30, 30, 60),
-            filter->GetRenderSurface()->content_rect());
+            GetRenderSurface(filter)->content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipRectWithClipParentAndFilters) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip = AddChild<LayerImpl>(root);
   LayerImpl* filter = AddChild<LayerImpl>(clip);
   LayerImpl* filter_child_1 = AddChild<LayerImpl>(filter);
   LayerImpl* filter_child_2 = AddChild<LayerImpl>(filter);
 
   root->SetBounds(gfx::Size(100, 100));
@@ skipping 77 matching lines @@
   child1->SetBounds(gfx::Size(50, 50));
   child1->SetDrawsContent(true);
   child2->SetPosition(gfx::PointF(75.f, 75.f));
   child2->SetBounds(gfx::Size(50, 50));
   child2->SetDrawsContent(true);
   child3->SetPosition(gfx::PointF(125.f, 125.f));
   child3->SetBounds(gfx::Size(50, 50));
   child3->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
-  ASSERT_TRUE(render_surface->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(render_surface));
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
-            root->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(root)->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());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface->visible_layer_rect());
 
   // 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->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(render_surface)->DrawableContentRect());
 
   // All layers that draw content into the unclipped surface are also unclipped.
   // Only the viewport clip should apply
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child3->visible_layer_rect());
 
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
@@ skipping 194 matching lines @@
   child3->SetPosition(gfx::PointF(125.f, 125.f));
   child3->SetBounds(gfx::Size(50, 50));
   child3->SetDrawsContent(true);
 
   RenderSurfaceList render_surface_list_impl;
   // Now set the root render surface an empty clip.
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root, gfx::Size(), &render_surface_list_impl);
 
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
-  ASSERT_TRUE(root->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(root));
   EXPECT_FALSE(root->is_clipped());
 
   gfx::Rect empty;
-  EXPECT_EQ(empty, root->GetRenderSurface()->clip_rect());
-  EXPECT_TRUE(root->GetRenderSurface()->is_clipped());
+  EXPECT_EQ(empty, GetRenderSurface(root)->clip_rect());
+  EXPECT_TRUE(GetRenderSurface(root)->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
   // is unclipped.
   EXPECT_EQ(empty, child1->visible_layer_rect());
   EXPECT_EQ(empty, child2->visible_layer_rect());
   EXPECT_EQ(empty, child3->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
@@ skipping 133 matching lines @@
   child->test_properties()->AddChild(std::move(surface_sibling));
   root->test_properties()->AddChild(std::move(child));
   host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
   host_impl.SetVisible(true);
   host_impl.InitializeRenderer(compositor_frame_sink.get());
   host_impl.active_tree()->BuildLayerListAndPropertyTreesForTesting();
   bool update_lcd_text = false;
   host_impl.active_tree()->UpdateDrawProperties(update_lcd_text);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      surface_ptr->GetRenderSurface()->draw_transform(), translate);
+      GetRenderSurface(surface_ptr)->draw_transform(), translate);
   // surface_sibling draws into the root render surface and occludes
   // surface_child's contents.
   Occlusion actual_occlusion =
-      surface_child_ptr->GetRenderSurface()->occlusion_in_content_space();
+      GetRenderSurface(surface_child_ptr)->occlusion_in_content_space();
   Occlusion expected_occlusion(translate, SimpleEnclosedRegion(gfx::Rect()),
                                SimpleEnclosedRegion(gfx::Rect(200, 200)));
   EXPECT_TRUE(expected_occlusion.IsEqual(actual_occlusion));
 
   // Mask layer should have the same occlusion.
   actual_occlusion =
       surface_child_mask_ptr->draw_properties().occlusion_in_content_space;
   EXPECT_TRUE(expected_occlusion.IsEqual(actual_occlusion));
 }
 
@@ skipping 132 matching lines @@
   child1->SetBounds(gfx::Size(50, 50));
   child1->SetDrawsContent(true);
   child2->SetPosition(gfx::PointF(75.f, 75.f));
   child2->SetBounds(gfx::Size(50, 50));
   child2->SetDrawsContent(true);
   child3->SetPosition(gfx::PointF(125.f, 125.f));
   child3->SetBounds(gfx::Size(50, 50));
   child3->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
-  ASSERT_TRUE(render_surface->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(render_surface));
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
-            root->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(root)->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());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface->visible_layer_rect());
 
   // 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->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(render_surface)->DrawableContentRect());
 
   // All layers that draw content into the surface have their visible content
   // rect clipped by the surface clip rect.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_layer_rect());
   EXPECT_TRUE(child3->visible_layer_rect().IsEmpty());
 
   // But the DrawableContentRects are unclipped.
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
@@ skipping 20 matching lines @@
   child1->SetBounds(gfx::Size(50, 50));
   child1->SetDrawsContent(true);
   child2->SetPosition(gfx::PointF(75.f, 75.f));
   child2->SetBounds(gfx::Size(50, 50));
   child2->SetDrawsContent(true);
   child3->SetPosition(gfx::PointF(125.f, 125.f));
   child3->SetBounds(gfx::Size(50, 50));
   child3->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
-  ASSERT_TRUE(render_surface1->GetRenderSurface());
-  ASSERT_TRUE(render_surface2->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(render_surface1));
+  ASSERT_TRUE(GetRenderSurface(render_surface2));
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
-            root->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(root)->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());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface2->visible_layer_rect());
 
   // 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->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(render_surface1)->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->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(render_surface2)->DrawableContentRect());
 
   // All layers that draw content into render_surface2 think they are unclipped
   // by the surface. So, only the viewport clip applies.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child3->visible_layer_rect());
 
   // DrawableContentRects are also unclipped.
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
@@ skipping 90 matching lines @@
   render_surface2->SetBounds(gfx::Size(60, 60));
   render_surface2->SetDrawsContent(true);
   render_surface2->test_properties()->force_render_surface = true;
 
   clip_parent->SetMasksToBounds(true);
   clip_layer->SetMasksToBounds(true);
   render_surface1->SetMasksToBounds(true);
 
   float device_scale_factor = 1.f;
   ExecuteCalculateDrawProperties(root, device_scale_factor);
-  EXPECT_EQ(gfx::Rect(50, 50),
-            render_surface2->GetRenderSurface()->clip_rect());
+  EXPECT_EQ(gfx::Rect(50, 50), GetRenderSurface(render_surface2)->clip_rect());
   device_scale_factor = 2.f;
   ExecuteCalculateDrawProperties(root, device_scale_factor);
   EXPECT_EQ(gfx::Rect(100, 100),
-            render_surface2->GetRenderSurface()->clip_rect());
+            GetRenderSurface(render_surface2)->clip_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceContentRectWhenLayerNotDrawn) {
   // Test that only drawn layers contribute to render surface content rect.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* surface = AddChildToRoot<LayerImpl>();
   LayerImpl* test_layer = AddChild<LayerImpl>(surface);
 
   root->SetBounds(gfx::Size(200, 200));
   surface->SetBounds(gfx::Size(100, 100));
   surface->SetDrawsContent(true);
   surface->test_properties()->force_render_surface = true;
   test_layer->SetBounds(gfx::Size(150, 150));
 
   ExecuteCalculateDrawProperties(root);
-  EXPECT_EQ(gfx::Rect(100, 100), surface->GetRenderSurface()->content_rect());
+  EXPECT_EQ(gfx::Rect(100, 100), GetRenderSurface(surface)->content_rect());
 
   test_layer->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
-  EXPECT_EQ(gfx::Rect(150, 150), surface->GetRenderSurface()->content_rect());
+  EXPECT_EQ(gfx::Rect(150, 150), GetRenderSurface(surface)->content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleRectsMultipleSurfaces) {
   // Tests visible rects computation when we have unclipped_surface->
   // surface_with_unclipped_descendants->clipped_surface, checks that the bounds
   // of surface_with_unclipped_descendants doesn't propagate to the
   // clipped_surface below it.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* unclipped_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_parent = AddChild<LayerImpl>(unclipped_surface);
@@ skipping 87 matching lines @@
   root->SetBounds(gfx::Size(100, 100));
   render_surface->SetBounds(gfx::Size(3, 4));
   render_surface->test_properties()->force_render_surface = true;
   child1->test_properties()->transform = child_rotation;
   child1->SetPosition(gfx::PointF(25.f, 25.f));
   child1->SetBounds(gfx::Size(50, 50));
   child1->SetDrawsContent(true);
   child1->test_properties()->transform_origin = gfx::Point3F(25.f, 25.f, 0.f);
   ExecuteCalculateDrawProperties(root);
 
-  ASSERT_TRUE(render_surface->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(render_surface));
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
-            root->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(root)->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());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface->visible_layer_rect());
 
   // The unclipped surface grows its DrawableContentRect to include all drawable
   // regions of the subtree.
   int diagonal_radius = ceil(sqrt(2.0) * 25.0);
   gfx::Rect expected_surface_drawable_content =
       gfx::Rect(50 - diagonal_radius,
                 50 - diagonal_radius,
                 diagonal_radius * 2,
                 diagonal_radius * 2);
   EXPECT_EQ(gfx::RectF(expected_surface_drawable_content),
-            render_surface->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(render_surface)->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());
   EXPECT_EQ(expected_surface_drawable_content, child1->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsWithTransformOnClippedSurface) {
   // Layers that have non-axis aligned bounds (due to transforms) have an
   // expanded, axis-aligned DrawableContentRect and visible content rect.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* child1 = AddChild<LayerImpl>(render_surface);
 
   gfx::Transform child_rotation;
   child_rotation.Rotate(45.0);
 
   root->SetBounds(gfx::Size(50, 50));
   root->SetMasksToBounds(true);
   render_surface->SetBounds(gfx::Size(3, 4));
   render_surface->test_properties()->force_render_surface = true;
   child1->SetPosition(gfx::PointF(25.f, 25.f));
   child1->SetBounds(gfx::Size(50, 50));
   child1->SetDrawsContent(true);
   child1->test_properties()->transform = child_rotation;
   child1->test_properties()->transform_origin = gfx::Point3F(25.f, 25.f, 0.f);
   ExecuteCalculateDrawProperties(root);
 
-  ASSERT_TRUE(render_surface->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(render_surface));
 
   // The clipped surface clamps the DrawableContentRect that encloses the
   // rotated layer.
   int diagonal_radius = ceil(sqrt(2.0) * 25.0);
   gfx::Rect unclipped_surface_content = gfx::Rect(50 - diagonal_radius,
                                                   50 - diagonal_radius,
                                                   diagonal_radius * 2,
                                                   diagonal_radius * 2);
   gfx::RectF expected_surface_drawable_content(
       gfx::IntersectRects(unclipped_surface_content, gfx::Rect(50, 50)));
   EXPECT_EQ(expected_surface_drawable_content,
-            render_surface->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(render_surface)->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
   // up covering the full left half of child1.
   EXPECT_EQ(gfx::Rect(0, 0, 25, 50), child1->visible_layer_rect());
 
   // The child's DrawableContentRect is unclipped.
   EXPECT_EQ(unclipped_surface_content, child1->drawable_content_rect());
 }
 
@@ skipping 25 matching lines @@
   child1->SetDrawsContent(true);
   child2->SetBounds(gfx::Size(50, 50));
   child2->SetPosition(gfx::PointF(75.f, 75.f));
   child2->SetDrawsContent(true);
   child3->SetBounds(gfx::Size(50, 50));
   child3->SetPosition(gfx::PointF(125.f, 125.f));
   child3->SetDrawsContent(true);
   float device_scale_factor = 2.f;
   ExecuteCalculateDrawProperties(root, device_scale_factor);
 
-  ASSERT_TRUE(render_surface1->GetRenderSurface());
-  ASSERT_TRUE(render_surface2->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(render_surface1));
+  ASSERT_TRUE(GetRenderSurface(render_surface2));
 
   // drawable_content_rects for all layers and surfaces are scaled by
   // device_scale_factor.
   EXPECT_EQ(gfx::RectF(200.f, 200.f),
-            root->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(root)->DrawableContentRect());
   EXPECT_EQ(gfx::RectF(10.f, 10.f, 190.f, 190.f),
-            render_surface1->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(render_surface1)->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->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(render_surface2)->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());
   EXPECT_EQ(gfx::Rect(250, 250, 100, 100), child3->drawable_content_rect());
 
   // The root layer does not actually draw content of its own.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
 
   // All layer visible content rects are not expressed in content space of each
   // layer, so they are not scaled by the device_scale_factor.
@@ skipping 71 matching lines @@
       backface_matrix;
   back_facing_child_of_back_facing_surface->test_properties()->transform =
       backface_matrix;
 
   // Note: No layers preserve 3d. According to current W3C CSS gfx::Transforms
   // spec, these layers should blindly use their own local transforms to
   // determine back-face culling.
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   // Verify which render surfaces were created.
-  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_FALSE(GetRenderSurface(front_facing_child));
+  EXPECT_FALSE(GetRenderSurface(back_facing_child));
+  EXPECT_TRUE(GetRenderSurface(front_facing_surface));
+  EXPECT_TRUE(GetRenderSurface(back_facing_surface));
+  EXPECT_FALSE(GetRenderSurface(front_facing_child_of_front_facing_surface));
+  EXPECT_FALSE(GetRenderSurface(back_facing_child_of_front_facing_surface));
+  EXPECT_FALSE(GetRenderSurface(front_facing_child_of_back_facing_surface));
+  EXPECT_FALSE(GetRenderSurface(back_facing_child_of_back_facing_surface));
 
   EXPECT_EQ(3u, update_layer_list_impl()->size());
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_child->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_surface->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(
       front_facing_child_of_front_facing_surface->id()));
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {
   // Verify the behavior of back-face culling when preserves-3d transform style
@@ skipping 80 matching lines @@
   back_facing_child_of_front_facing_surface->test_properties()
       ->sorting_context_id = 1;
   front_facing_child_of_back_facing_surface->test_properties()
       ->sorting_context_id = 1;
   back_facing_child_of_back_facing_surface->test_properties()
       ->sorting_context_id = 1;
 
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   // Verify which render surfaces were created and used.
-  EXPECT_FALSE(front_facing_child->GetRenderSurface());
-  EXPECT_FALSE(back_facing_child->GetRenderSurface());
-  EXPECT_TRUE(front_facing_surface->GetRenderSurface());
+  EXPECT_FALSE(GetRenderSurface(front_facing_child));
+  EXPECT_FALSE(GetRenderSurface(back_facing_child));
+  EXPECT_TRUE(GetRenderSurface(front_facing_surface));
   // We expect that a has_render_surface was created but not used.
-  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_TRUE(GetRenderSurface(back_facing_surface));
+  EXPECT_FALSE(GetRenderSurface(front_facing_child_of_front_facing_surface));
+  EXPECT_FALSE(GetRenderSurface(back_facing_child_of_front_facing_surface));
+  EXPECT_FALSE(GetRenderSurface(front_facing_child_of_back_facing_surface));
+  EXPECT_FALSE(GetRenderSurface(back_facing_child_of_back_facing_surface));
 
   EXPECT_EQ(3u, update_layer_list_impl()->size());
 
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_child->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_surface->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(
       front_facing_child_of_front_facing_surface->id()));
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
@@ skipping 45 matching lines @@
   animating_surface->test_properties()->transform = backface_matrix;
   animating_surface->test_properties()->force_render_surface = true;
   child_of_animating_surface->SetBounds(gfx::Size(100, 100));
   child_of_animating_surface->test_properties()->transform = backface_matrix;
   animating_child->SetBounds(gfx::Size(100, 100));
   animating_child->test_properties()->transform = backface_matrix;
   child2->SetBounds(gfx::Size(100, 100));
 
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
-  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_FALSE(GetRenderSurface(child));
+  EXPECT_TRUE(GetRenderSurface(animating_surface));
+  EXPECT_FALSE(GetRenderSurface(child_of_animating_surface));
+  EXPECT_FALSE(GetRenderSurface(animating_child));
+  EXPECT_FALSE(GetRenderSurface(child2));
 
   EXPECT_EQ(1u, update_layer_list_impl()->size());
 
   // The back facing layers are culled from the layer list, and have an empty
   // visible rect.
   EXPECT_TRUE(UpdateLayerListImplContains(child2->id()));
   EXPECT_TRUE(child->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(animating_surface->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(child_of_animating_surface->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(animating_child->visible_layer_rect().IsEmpty());
@@ skipping 35 matching lines @@
   back_facing_surface->test_properties()->force_render_surface = true;
   child1->SetBounds(gfx::Size(100, 100));
   child2->SetBounds(gfx::Size(100, 100));
 
   front_facing_surface->test_properties()->sorting_context_id = 1;
   back_facing_surface->test_properties()->sorting_context_id = 1;
 
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   // Verify which render surfaces were created and used.
-  EXPECT_TRUE(front_facing_surface->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(front_facing_surface));
 
   // We expect the render surface to have been created, but remain unused.
-  EXPECT_TRUE(back_facing_surface->GetRenderSurface());
-  EXPECT_FALSE(child1->GetRenderSurface());
-  EXPECT_FALSE(child2->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(back_facing_surface));
+  EXPECT_FALSE(GetRenderSurface(child1));
+  EXPECT_FALSE(GetRenderSurface(child2));
 
   EXPECT_EQ(2u, update_layer_list_impl()->size());
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_surface->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(child1->id()));
 }
 
 TEST_F(LayerTreeHostCommonScalingTest, LayerTransformsInHighDPI) {
   // Verify draw and screen space transforms of layers not in a surface.
   LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(100, 100));
@@ skipping 163 matching lines @@
   expected_perspective_surface_draw_transform.PreconcatTransform(
       perspective_matrix);
   expected_perspective_surface_draw_transform.PreconcatTransform(
       scale_small_matrix);
   gfx::Transform expected_perspective_surface_layer_draw_transform;
   expected_perspective_surface_layer_draw_transform.Scale(
       device_scale_factor * page_scale_factor,
       device_scale_factor * page_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_perspective_surface_draw_transform,
-      perspective_surface->GetRenderSurface()->draw_transform());
+      GetRenderSurface(perspective_surface)->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_perspective_surface_layer_draw_transform,
       perspective_surface->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonScalingTest, SmallIdealScale) {
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
@@ skipping 122 matching lines @@
       duplicate_child_non_owner->ScreenSpaceTransform());
   EXPECT_EQ(child->drawable_content_rect(),
             duplicate_child_non_owner->drawable_content_rect());
   EXPECT_EQ(child->bounds(), duplicate_child_non_owner->bounds());
 
   gfx::Transform expected_render_surface_draw_transform;
   expected_render_surface_draw_transform.Translate(
       device_scale_factor * child->position().x(),
       device_scale_factor * child->position().y());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_render_surface_draw_transform,
-                                  child->GetRenderSurface()->draw_transform());
+                                  GetRenderSurface(child)->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->GetRenderSurface()->draw_transform());
+                                  GetRenderSurface(child)->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->GetRenderSurface()->screen_space_transform());
+      GetRenderSurface(child)->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      RenderSurfaceTransformsInHighDPIAccurateScaleZeroPosition) {
   LayerImpl* parent = root_layer_for_testing();
   parent->SetBounds(gfx::Size(33, 31));
   parent->SetDrawsContent(true);
 
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   child->SetBounds(gfx::Size(13, 11));
   child->SetDrawsContent(true);
   child->test_properties()->force_render_surface = true;
 
   float device_scale_factor = 1.7f;
   ExecuteCalculateDrawProperties(parent, device_scale_factor);
 
   // We should have two render surfaces. The root's render surface and child's
   // render surface (it needs one because of force_render_surface).
   EXPECT_EQ(2u, render_surface_list_impl()->size());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
-                                  child->GetRenderSurface()->draw_transform());
+                                  GetRenderSurface(child)->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
-                                  child->GetRenderSurface()->draw_transform());
+                                  GetRenderSurface(child)->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      gfx::Transform(), child->GetRenderSurface()->screen_space_transform());
+      gfx::Transform(), GetRenderSurface(child)->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerSearch) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<Layer> grand_child = Layer::Create();
   scoped_refptr<Layer> mask_layer = Layer::Create();
 
   child->AddChild(grand_child.get());
   child->SetMaskLayer(mask_layer.get());
@@ skipping 13 matching lines @@
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   root->SetBounds(gfx::Size(100, 100));
   child->SetBounds(gfx::Size(10, 10));
   child->test_properties()->opacity = 0.5f;
   grand_child->SetBounds(gfx::Size(10, 10));
   grand_child->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
-  EXPECT_FALSE(child->GetRenderSurface());
+  EXPECT_FALSE(GetRenderSurface(child));
 }
 
 TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(host()->GetSettings(), &task_runner_provider,
                                   &task_graph_runner);
   host_impl.CreatePendingTree();
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.pending_tree(), 1);
@@ skipping 25 matching lines @@
 
   RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // We should have one render surface and one layer. The child
   // layer should not be included as its transparent.
   ASSERT_EQ(1u, render_surface_list.size());
-  ASSERT_EQ(1, root_layer->GetRenderSurface()->num_contributors());
+  ASSERT_EQ(1, GetRenderSurface(root_layer)->num_contributors());
 
   // If the root itself is hidden, the child should not be drawn and should not
   // raster even if it has an animating opacity.
   root_layer->test_properties()->opacity = 0.0f;
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   RenderSurfaceList render_surface_list2;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs2(
       root_layer, root_layer->bounds(), &render_surface_list2);
   inputs2.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs2);
@@ skipping 281 matching lines @@
 
   RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
   ASSERT_EQ(1u, render_surface_list.size());
-  ASSERT_EQ(2, root_layer->GetRenderSurface()->num_contributors());
+  ASSERT_EQ(2, GetRenderSurface(root_layer)->num_contributors());
   EXPECT_TRUE(root_layer->contributes_to_drawn_render_surface());
   EXPECT_TRUE(child_layer->contributes_to_drawn_render_surface());
   EXPECT_FALSE(grand_child_layer->contributes_to_drawn_render_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
   host_impl.CreatePendingTree();
@@ skipping 23 matching lines @@
 
   RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // We should have one render surface and one layer. The child has
   // hidden itself and the grand child.
   ASSERT_EQ(1u, render_surface_list.size());
-  ASSERT_EQ(1, root_layer->GetRenderSurface()->num_contributors());
+  ASSERT_EQ(1, GetRenderSurface(root_layer)->num_contributors());
   EXPECT_TRUE(root_layer->contributes_to_drawn_render_surface());
   EXPECT_FALSE(child_layer->contributes_to_drawn_render_surface());
   EXPECT_FALSE(grand_child_layer->contributes_to_drawn_render_surface());
 }
 
 void EmptyCopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {}
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestTaskGraphRunner task_graph_runner;
@@ skipping 89 matching lines @@
   // We should have four render surfaces, one for the root, one for the grand
   // parent since it has opacity and two drawing descendants, one for the parent
   // since it owns a surface, and one for the copy_layer.
   ASSERT_EQ(4u, render_surface_list.size());
   EXPECT_EQ(root_layer->id(), render_surface_list.at(0)->id());
   EXPECT_EQ(copy_grand_parent_layer->id(), render_surface_list.at(1)->id());
   EXPECT_EQ(copy_parent_layer->id(), render_surface_list.at(2)->id());
   EXPECT_EQ(copy_layer->id(), render_surface_list.at(3)->id());
 
   // The root render surface should have 2 contributing layers.
-  EXPECT_EQ(2, root_layer->GetRenderSurface()->num_contributors());
+  EXPECT_EQ(2, GetRenderSurface(root_layer)->num_contributors());
   EXPECT_TRUE(root_layer->contributes_to_drawn_render_surface());
   EXPECT_FALSE(copy_grand_parent_layer->contributes_to_drawn_render_surface());
   EXPECT_FALSE(copy_grand_parent_sibling_before_layer
                    ->contributes_to_drawn_render_surface());
   EXPECT_FALSE(copy_grand_parent_sibling_after_layer
                    ->contributes_to_drawn_render_surface());
 
   // 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(1, copy_parent_layer->GetRenderSurface()->num_contributors());
+  ASSERT_EQ(1, GetRenderSurface(copy_parent_layer)->num_contributors());
   EXPECT_FALSE(copy_parent_layer->contributes_to_drawn_render_surface());
 
   // The copy layer's render surface should have 2 contributing layers.
-  ASSERT_EQ(2, copy_layer->GetRenderSurface()->num_contributors());
+  ASSERT_EQ(2, GetRenderSurface(copy_layer)->num_contributors());
   EXPECT_TRUE(copy_layer->contributes_to_drawn_render_surface());
   EXPECT_TRUE(copy_child_layer->contributes_to_drawn_render_surface());
   EXPECT_FALSE(copy_grand_child_layer->contributes_to_drawn_render_surface());
 
   // 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.
   // copy grand child should not be drawn as its hidden even in the copy
   // request.
   EffectTree& tree =
       root_layer->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = tree.Node(copy_grand_parent_layer->effect_tree_index());
   EXPECT_FALSE(node->is_drawn);
   node = tree.Node(copy_parent_layer->effect_tree_index());
   EXPECT_FALSE(node->is_drawn);
   node = tree.Node(copy_layer->effect_tree_index());
   EXPECT_TRUE(node->is_drawn);
   node = tree.Node(copy_child_layer->effect_tree_index());
   EXPECT_TRUE(node->is_drawn);
   node = tree.Node(copy_grand_child_layer->effect_tree_index());
   EXPECT_FALSE(node->is_drawn);
 
   // Though copy_layer is drawn, it shouldn't contribute to drawn surface as its
   // actually hidden.
-  EXPECT_FALSE(copy_layer->GetRenderSurface()->contributes_to_drawn_surface());
+  EXPECT_FALSE(GetRenderSurface(copy_layer)->contributes_to_drawn_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
   host_impl.CreatePendingTree();
 
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.pending_tree(), 1);
@@ skipping 30 matching lines @@
       root_layer, root_layer->bounds(), &render_surface_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // We should have two render surface, as the others are clipped out.
   ASSERT_EQ(2u, render_surface_list.size());
   EXPECT_EQ(root_layer->id(), render_surface_list.at(0)->id());
 
   // The root render surface should have only 2 contributing layer, since the
   // other layers are clipped away.
-  ASSERT_EQ(2, root_layer->GetRenderSurface()->num_contributors());
+  ASSERT_EQ(2, GetRenderSurface(root_layer)->num_contributors());
   EXPECT_TRUE(root_layer->contributes_to_drawn_render_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, SingularTransformAndCopyRequests) {
   LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
 
   LayerImpl* singular_transform_layer = AddChild<LayerImpl>(root);
   singular_transform_layer->SetBounds(gfx::Size(100, 100));
@@ skipping 144 matching lines @@
   render_surface->test_properties()->force_render_surface = true;
   clip_parent->test_properties()->transform = scale_transform;
   clip_parent->SetPosition(gfx::PointF(1.f, 1.f));
   clip_parent->SetBounds(gfx::Size(10, 10));
   intervening->SetPosition(gfx::PointF(1.f, 1.f));
   intervening->SetBounds(gfx::Size(5, 5));
   clip_child->SetPosition(gfx::PointF(1.f, 1.f));
   clip_child->SetBounds(gfx::Size(10, 10));
   ExecuteCalculateDrawProperties(root);
 
-  ASSERT_TRUE(root->GetRenderSurface());
-  ASSERT_TRUE(render_surface->GetRenderSurface());
+  ASSERT_TRUE(GetRenderSurface(root));
+  ASSERT_TRUE(GetRenderSurface(render_surface));
 
   // Ensure that we've inherited our clip parent's clip and weren't affected
   // by the intervening clip layer.
   ASSERT_EQ(gfx::Rect(1, 1, 20, 20), clip_parent->clip_rect());
   ASSERT_EQ(clip_parent->clip_rect(), clip_child->clip_rect());
   ASSERT_EQ(gfx::Rect(3, 3, 10, 10), intervening->clip_rect());
 
   // 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->GetRenderSurface()->content_rect());
+            GetRenderSurface(render_surface)->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->GetRenderSurface()->content_rect()));
+      GetRenderSurface(render_surface)->content_rect()));
   ASSERT_FALSE(intervening->clip_rect().Contains(
-      render_surface->GetRenderSurface()->content_rect()));
+      GetRenderSurface(render_surface)->content_rect()));
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipParentWithInterveningRenderSurface) {
   // Ensure that intervening render surfaces are not a problem in the basic
   // case. In the following tree, both render surfaces should be resized to
   // accomodate for the clip child, despite an intervening clip.
   //
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + render_surface1 (sets opacity)
@@ skipping 25 matching lines @@
   render_surface1->SetBounds(gfx::Size(10, 10));
   render_surface1->test_properties()->force_render_surface = true;
   intervening->SetPosition(gfx::PointF(1.f, 1.f));
   intervening->SetBounds(gfx::Size(5, 5));
   render_surface2->SetBounds(gfx::Size(10, 10));
   render_surface2->test_properties()->force_render_surface = true;
   clip_child->SetPosition(gfx::PointF(-10.f, -10.f));
   clip_child->SetBounds(gfx::Size(60, 60));
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_TRUE(root->GetRenderSurface());
-  EXPECT_TRUE(render_surface1->GetRenderSurface());
-  EXPECT_TRUE(render_surface2->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(root));
+  EXPECT_TRUE(GetRenderSurface(render_surface1));
+  EXPECT_TRUE(GetRenderSurface(render_surface2));
 
   // render_surface1 should apply the clip from clip_parent. Though there is a
   // clip child, render_surface1 can apply the clip as there are no clips
   // between the clip parent and render_surface1
   EXPECT_EQ(gfx::Rect(1, 1, 40, 40),
-            render_surface1->GetRenderSurface()->clip_rect());
-  EXPECT_TRUE(render_surface1->GetRenderSurface()->is_clipped());
+            GetRenderSurface(render_surface1)->clip_rect());
+  EXPECT_TRUE(GetRenderSurface(render_surface1)->is_clipped());
   EXPECT_EQ(gfx::Rect(), render_surface1->clip_rect());
   EXPECT_FALSE(render_surface1->is_clipped());
 
   // render_surface2 could have expanded, as there is a clip between
   // clip_child's clip (clip_parent) and render_surface2's clip (intervening).
   // So, it should not be clipped (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_surface2->GetRenderSurface()->clip_rect());
-  EXPECT_FALSE(render_surface2->GetRenderSurface()->is_clipped());
+            GetRenderSurface(render_surface2)->clip_rect());
+  EXPECT_FALSE(GetRenderSurface(render_surface2)->is_clipped());
 
   // This value is inherited from the clipping ancestor layer, 'intervening'.
   EXPECT_EQ(gfx::Rect(0, 0, 5, 5), render_surface2->clip_rect());
   EXPECT_TRUE(render_surface2->is_clipped());
 
   // The content rects of render_surface2 should have expanded to contain the
   // clip child.
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40),
-            render_surface1->GetRenderSurface()->content_rect());
+            GetRenderSurface(render_surface1)->content_rect());
   EXPECT_EQ(gfx::Rect(-10, -10, 60, 60),
-            render_surface2->GetRenderSurface()->content_rect());
+            GetRenderSurface(render_surface2)->content_rect());
 
   // The clip child should have inherited the clip parent's clip (projected to
   // the right space, of course), but as render_surface1 already applies that
   // clip, clip_child need not apply it again.
   EXPECT_EQ(gfx::Rect(), clip_child->clip_rect());
   EXPECT_EQ(gfx::Rect(9, 9, 40, 40), clip_child->visible_layer_rect());
   EXPECT_FALSE(clip_child->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipParentScrolledInterveningLayer) {
@@ skipping 35 matching lines @@
   render_surface1->SetBounds(gfx::Size(10, 10));
   render_surface1->test_properties()->force_render_surface = true;
   intervening->SetPosition(gfx::PointF(1.f, 1.f));
   intervening->SetBounds(gfx::Size(5, 5));
   render_surface2->SetBounds(gfx::Size(10, 10));
   render_surface2->test_properties()->force_render_surface = true;
   clip_child->SetPosition(gfx::PointF(-10.f, -10.f));
   clip_child->SetBounds(gfx::Size(60, 60));
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_TRUE(root->GetRenderSurface());
-  EXPECT_TRUE(render_surface1->GetRenderSurface());
-  EXPECT_TRUE(render_surface2->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(root));
+  EXPECT_TRUE(GetRenderSurface(render_surface1));
+  EXPECT_TRUE(GetRenderSurface(render_surface2));
 
   // render_surface1 should apply the clip from clip_parent. Though there is a
   // clip child, render_surface1 can apply the clip as there are no clips
   // between the clip parent and render_surface1
   EXPECT_EQ(gfx::Rect(3, 3, 40, 40),
-            render_surface1->GetRenderSurface()->clip_rect());
-  EXPECT_TRUE(render_surface1->GetRenderSurface()->is_clipped());
+            GetRenderSurface(render_surface1)->clip_rect());
+  EXPECT_TRUE(GetRenderSurface(render_surface1)->is_clipped());
   EXPECT_EQ(gfx::Rect(), render_surface1->clip_rect());
   EXPECT_FALSE(render_surface1->is_clipped());
 
   // render_surface2 could have expanded, as there is a clip between
   // clip_child's clip (clip_parent) and render_surface2's clip (intervening).
   // So, it should not be clipped (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_surface2->GetRenderSurface()->clip_rect());
-  EXPECT_FALSE(render_surface2->GetRenderSurface()->is_clipped());
+            GetRenderSurface(render_surface2)->clip_rect());
+  EXPECT_FALSE(GetRenderSurface(render_surface2)->is_clipped());
   // This value is inherited from the clipping ancestor layer, 'intervening'.
   EXPECT_EQ(gfx::Rect(0, 0, 5, 5), render_surface2->clip_rect());
   EXPECT_TRUE(render_surface2->is_clipped());
 
   // The content rects of render_surface2 should have expanded to contain the
   // clip child.
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40),
-            render_surface1->GetRenderSurface()->content_rect());
+            GetRenderSurface(render_surface1)->content_rect());
   EXPECT_EQ(gfx::Rect(-10, -10, 60, 60),
-            render_surface2->GetRenderSurface()->content_rect());
+            GetRenderSurface(render_surface2)->content_rect());
 
   // The clip child should have inherited the clip parent's clip (projected to
   // the right space, of course), but as render_surface1 already applies that
   // clip, clip_child need not apply it again.
   EXPECT_EQ(gfx::Rect(), clip_child->clip_rect());
   EXPECT_EQ(gfx::Rect(12, 12, 40, 40), clip_child->visible_layer_rect());
   EXPECT_FALSE(clip_child->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, DescendantsOfClipChildren) {
@@ skipping 21 matching lines @@
   root->SetBounds(gfx::Size(50, 50));
   clip_parent->SetBounds(gfx::Size(40, 40));
   clip_parent->SetMasksToBounds(true);
   intervening->SetBounds(gfx::Size(5, 5));
   intervening->SetMasksToBounds(true);
   clip_child->SetBounds(gfx::Size(60, 60));
   child->SetBounds(gfx::Size(60, 60));
 
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_TRUE(root->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(root));
 
   // Neither the clip child nor its descendant should have inherited the clip
   // from |intervening|.
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), clip_child->clip_rect());
   EXPECT_TRUE(clip_child->is_clipped());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), child->visible_layer_rect());
   EXPECT_TRUE(child->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest,
@@ skipping 38 matching lines @@
   render_surface1->SetBounds(gfx::Size(5, 5));
   render_surface1->test_properties()->force_render_surface = true;
   render_surface2->SetBounds(gfx::Size(5, 5));
   render_surface2->test_properties()->force_render_surface = true;
   clip_child->SetPosition(gfx::PointF(-1, 1));
   clip_child->SetBounds(gfx::Size(10, 10));
   non_clip_child->SetBounds(gfx::Size(5, 5));
 
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_TRUE(root->GetRenderSurface());
-  EXPECT_TRUE(render_surface1->GetRenderSurface());
-  EXPECT_TRUE(render_surface2->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(root));
+  EXPECT_TRUE(GetRenderSurface(render_surface1));
+  EXPECT_TRUE(GetRenderSurface(render_surface2));
 
   EXPECT_EQ(gfx::Rect(-5, -5, 10, 10), render_surface1->clip_rect());
   EXPECT_TRUE(render_surface1->is_clipped());
 
   // 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->GetRenderSurface()->clip_rect());
-  EXPECT_FALSE(render_surface1->GetRenderSurface()->is_clipped());
+            GetRenderSurface(render_surface1)->clip_rect());
+  EXPECT_FALSE(GetRenderSurface(render_surface1)->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->GetRenderSurface()->content_rect());
+            GetRenderSurface(render_surface1)->content_rect());
 
   // This render surface should clip. It has no unclipped descendants.
   EXPECT_EQ(gfx::Rect(0, 0, 10, 10),
-            render_surface2->GetRenderSurface()->clip_rect());
-  EXPECT_TRUE(render_surface2->GetRenderSurface()->is_clipped());
+            GetRenderSurface(render_surface2)->clip_rect());
+  EXPECT_TRUE(GetRenderSurface(render_surface2)->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->GetRenderSurface()->content_rect());
+            GetRenderSurface(render_surface2)->content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        CreateRenderSurfaceWhenFlattenInsideRenderingContext) {
   // Verifies that Render Surfaces are created at the edge of rendering context.
 
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child2 = AddChild<LayerImpl>(child1);
   LayerImpl* child3 = AddChild<LayerImpl>(child2);
   root->SetDrawsContent(true);
 
   gfx::Size bounds(100, 100);
 
   root->SetBounds(bounds);
   child1->SetBounds(bounds);
   child1->SetDrawsContent(true);
   child1->test_properties()->should_flatten_transform = false;
   child1->test_properties()->sorting_context_id = 1;
   child2->SetBounds(bounds);
   child2->SetDrawsContent(true);
   child2->test_properties()->sorting_context_id = 1;
   child3->SetBounds(bounds);
   child3->SetDrawsContent(true);
   child3->test_properties()->sorting_context_id = 1;
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   // Verify which render surfaces were created.
-  EXPECT_TRUE(root->GetRenderSurface());
-  EXPECT_FALSE(child1->GetRenderSurface());
-  EXPECT_TRUE(child2->GetRenderSurface());
-  EXPECT_FALSE(child3->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(root));
+  EXPECT_FALSE(GetRenderSurface(child1));
+  EXPECT_TRUE(GetRenderSurface(child2));
+  EXPECT_FALSE(GetRenderSurface(child3));
 }
 
 TEST_F(LayerTreeHostCommonTest, CanRenderToSeparateSurface) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
 
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
   std::unique_ptr<LayerImpl> child1 =
@@ skipping 302 matching lines @@
       base::MakeUnique<std::set<LayerImpl*>>();
   scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
   root->SetBounds(gfx::Size(50, 50));
   scroll_parent_border->SetBounds(gfx::Size(40, 40));
   scroll_parent_clip->SetBounds(gfx::Size(30, 30));
   scroll_parent->SetBounds(gfx::Size(50, 50));
   scroll_child->SetBounds(gfx::Size(50, 50));
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_TRUE(root->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(root));
 
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30), scroll_child->clip_rect());
   EXPECT_TRUE(scroll_child->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, ScrollChildAndScrollParentDifferentTargets) {
   // Tests the computation of draw transform for the scroll child when its
   // target is different from its scroll parent's target.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* scroll_child_target = AddChildToRoot<LayerImpl>();
@@ skipping 106 matching lines @@
   scroll_parent->SetBounds(gfx::Size(50, 50));
   scroll_child->SetBounds(gfx::Size(50, 50));
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
   scroll_parent->test_properties()->scroll_children =
       base::MakeUnique<std::set<LayerImpl*>>();
   scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_TRUE(root->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(root));
 
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30), scroll_child->clip_rect());
   EXPECT_TRUE(scroll_child->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollGrandparent) {
   // Checks that clipping by a scroll parent and scroll grandparent that follow
   // you in paint order still results in correct clipping.
   //
   // + root
@@ skipping 37 matching lines @@
   scroll_grandparent_border->SetBounds(gfx::Size(40, 40));
   scroll_grandparent_clip->SetBounds(gfx::Size(20, 20));
   scroll_grandparent->SetBounds(gfx::Size(50, 50));
   scroll_parent_border->SetBounds(gfx::Size(40, 40));
   scroll_parent_clip->SetBounds(gfx::Size(30, 30));
   scroll_parent->SetBounds(gfx::Size(50, 50));
   scroll_child->SetBounds(gfx::Size(50, 50));
 
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_TRUE(root->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(root));
 
   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(3, root->GetRenderSurface()->num_contributors());
+  EXPECT_EQ(3, GetRenderSurface(root)->num_contributors());
   EXPECT_TRUE(scroll_child->contributes_to_drawn_render_surface());
   EXPECT_TRUE(scroll_parent->contributes_to_drawn_render_surface());
   EXPECT_TRUE(scroll_grandparent->contributes_to_drawn_render_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, OutOfOrderClippingRequiresRSLLSorting) {
   // Ensures that even if we visit layers out of order, we still produce a
   // correctly ordered render surface layer list.
   // + root
   //   + scroll_child
@@ skipping 49 matching lines @@
   render_surface1->test_properties()->force_render_surface = true;
   scroll_parent_border->SetBounds(gfx::Size(40, 40));
   scroll_parent_clip->SetBounds(gfx::Size(30, 30));
   scroll_parent->SetBounds(gfx::Size(50, 50));
   render_surface2->SetBounds(gfx::Size(50, 50));
   render_surface2->test_properties()->force_render_surface = true;
   scroll_child->SetBounds(gfx::Size(50, 50));
 
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_TRUE(root->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(root));
 
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20), scroll_child->clip_rect());
   EXPECT_TRUE(scroll_child->is_clipped());
 
   // Despite the fact that we had to process the layers out of order to get the
   // right clip, our render_surface_list's order should be unaffected.
   EXPECT_EQ(3u, render_surface_list_impl()->size());
-  EXPECT_EQ(root->GetRenderSurface(), render_surface_list_impl()->at(0));
-  EXPECT_EQ(render_surface2->GetRenderSurface(),
+  EXPECT_EQ(GetRenderSurface(root), render_surface_list_impl()->at(0));
+  EXPECT_EQ(GetRenderSurface(render_surface2),
             render_surface_list_impl()->at(1));
-  EXPECT_EQ(render_surface1->GetRenderSurface(),
+  EXPECT_EQ(GetRenderSurface(render_surface1),
             render_surface_list_impl()->at(2));
 }
 
 TEST_F(LayerTreeHostCommonTest, FixedPositionWithInterveningRenderSurface) {
   // Ensures that when we have a render surface between a fixed position layer
   // and its container, we compute the fixed position layer's draw transform
   // with respect to that intervening render surface, not with respect to its
   // container's render target.
   //
   // + root
@@ skipping 2361 matching lines @@
   child->SetDrawsContent(true);
   grandchild->SetBounds(gfx::Size(50, 50));
   grandchild->SetDrawsContent(true);
 
   SetElementIdsForTesting();
   AddOpacityTransitionToElementWithPlayer(child->element_id(), timeline_impl(),
                                           10.0, 1.f, 0.2f, false);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(1.f, child->Opacity());
-  EXPECT_TRUE(root->GetRenderSurface());
-  EXPECT_TRUE(child->GetRenderSurface());
-  EXPECT_FALSE(grandchild->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(root));
+  EXPECT_TRUE(GetRenderSurface(child));
+  EXPECT_FALSE(GetRenderSurface(grandchild));
 }
 
 // Verify that having an animated filter (but no current filter, as these
 // are mutually exclusive) correctly creates a render surface.
 TEST_F(LayerTreeHostCommonTest, AnimatedFilterCreatesRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
   root->SetBounds(gfx::Size(50, 50));
   child->SetBounds(gfx::Size(50, 50));
   grandchild->SetBounds(gfx::Size(50, 50));
 
   SetElementIdsForTesting();
   AddAnimatedFilterToElementWithPlayer(child->element_id(), timeline_impl(),
                                        10.0, 0.1f, 0.2f);
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_TRUE(root->GetRenderSurface());
-  EXPECT_TRUE(child->GetRenderSurface());
-  EXPECT_FALSE(grandchild->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(root));
+  EXPECT_TRUE(GetRenderSurface(child));
+  EXPECT_FALSE(GetRenderSurface(grandchild));
 
-  EXPECT_TRUE(root->GetRenderSurface()->Filters().IsEmpty());
-  EXPECT_TRUE(child->GetRenderSurface()->Filters().IsEmpty());
+  EXPECT_TRUE(GetRenderSurface(root)->Filters().IsEmpty());
+  EXPECT_TRUE(GetRenderSurface(child)->Filters().IsEmpty());
 
   EXPECT_FALSE(root->FilterIsAnimating());
   EXPECT_TRUE(child->FilterIsAnimating());
   EXPECT_FALSE(grandchild->FilterIsAnimating());
 }
 
 // Verify that having a filter animation with a delayed start time creates a
 // render surface.
 TEST_F(LayerTreeHostCommonTest, DelayedFilterAnimationCreatesRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
@@ skipping 18 matching lines @@
       base::TimeDelta::FromMilliseconds(100), end_filters, nullptr));
   std::unique_ptr<Animation> animation =
       Animation::Create(std::move(curve), 0, 1, TargetProperty::FILTER);
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
 
   AddAnimationToElementWithPlayer(child->element_id(), timeline_impl(),
                                   std::move(animation));
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_TRUE(root->GetRenderSurface());
-  EXPECT_TRUE(child->GetRenderSurface());
-  EXPECT_FALSE(grandchild->GetRenderSurface());
+  EXPECT_TRUE(GetRenderSurface(root));
+  EXPECT_TRUE(GetRenderSurface(child));
+  EXPECT_FALSE(GetRenderSurface(grandchild));
 
-  EXPECT_TRUE(root->GetRenderSurface()->Filters().IsEmpty());
-  EXPECT_TRUE(child->GetRenderSurface()->Filters().IsEmpty());
+  EXPECT_TRUE(GetRenderSurface(root)->Filters().IsEmpty());
+  EXPECT_TRUE(GetRenderSurface(child)->Filters().IsEmpty());
 
   EXPECT_FALSE(root->FilterIsAnimating());
   EXPECT_FALSE(root->HasPotentiallyRunningFilterAnimation());
   EXPECT_FALSE(child->FilterIsAnimating());
   EXPECT_TRUE(child->HasPotentiallyRunningFilterAnimation());
   EXPECT_FALSE(grandchild->FilterIsAnimating());
   EXPECT_FALSE(grandchild->HasPotentiallyRunningFilterAnimation());
 }
 
 // Ensures that the property tree code accounts for offsets between fixed
@@ skipping 686 matching lines @@
   ExecuteCalculateDrawProperties(root, device_scale_factor, page_scale_factor,
                                  page_scale_layer, inner_viewport_scroll_layer,
                                  outer_viewport_scroll_layer);
 
   TransformTree& transform_tree =
       root->layer_tree_impl()->property_trees()->transform_tree;
   TransformNode* transform_node =
       transform_tree.Node(significant_transform->transform_tree_index());
   EXPECT_EQ(transform_node->owning_layer_id, significant_transform->id());
 
-  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());
+  EXPECT_TRUE(GetRenderSurface(root));
+  EXPECT_FALSE(GetRenderSurface(significant_transform));
+  EXPECT_TRUE(GetRenderSurface(layer_clips_subtree));
+  EXPECT_TRUE(GetRenderSurface(render_surface));
+  EXPECT_FALSE(GetRenderSurface(test_layer));
 
   EXPECT_EQ(gfx::Rect(30, 20), test_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformOfParentClipNodeAncestorOfTarget) {
   // Ensure that when parent clip node's transform is an ancestor of current
   // clip node's target, clip is 'projected' from parent space to current
   // target space and visible rects are calculated correctly.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_layer = AddChild<LayerImpl>(root);
@@ skipping 185 matching lines @@
   clipped_surface->SetDrawsContent(true);
   clipped_surface->test_properties()->force_render_surface = true;
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
       base::MakeUnique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(50, 50),
-            unclipped_surface->GetRenderSurface()->content_rect());
+            GetRenderSurface(unclipped_surface)->content_rect());
   EXPECT_EQ(gfx::Rect(50, 50),
-            unclipped_desc_surface->GetRenderSurface()->content_rect());
+            GetRenderSurface(unclipped_desc_surface)->content_rect());
   EXPECT_EQ(gfx::Rect(60, 60),
-            unclipped_desc_surface2->GetRenderSurface()->content_rect());
+            GetRenderSurface(unclipped_desc_surface2)->content_rect());
   EXPECT_EQ(gfx::Rect(50, 50),
-            clipped_surface->GetRenderSurface()->content_rect());
+            GetRenderSurface(clipped_surface)->content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipBetweenClipChildTargetAndClipParentTarget) {
   // Tests the value of render surface content rect when we have a layer that
   // clips between the clip parent's target and clip child's target.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_layer = AddChild<LayerImpl>(surface);
   LayerImpl* clip_parent = AddChild<LayerImpl>(clip_layer);
   LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
@@ skipping 21 matching lines @@
   clip_child->SetDrawsContent(true);
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
       base::MakeUnique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(10, 10),
-            unclipped_desc_surface->GetRenderSurface()->content_rect());
+            GetRenderSurface(unclipped_desc_surface)->content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleRectForDescendantOfScaledSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_layer = AddChild<LayerImpl>(surface);
   LayerImpl* clip_parent = AddChild<LayerImpl>(clip_layer);
   LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface);
 
@@ skipping 143 matching lines @@
 
   root->SetBounds(gfx::Size(30, 30));
   hidden->SetBounds(gfx::Size(30, 30));
   hidden->test_properties()->force_render_surface = true;
   hidden->test_properties()->hide_layer_and_subtree = true;
   test->SetBounds(gfx::Size(30, 30));
   test->test_properties()->force_render_surface = true;
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(0.f,
-            test->GetRenderSurface()->OwningEffectNode()->screen_space_opacity);
+            GetRenderSurface(test)->OwningEffectNode()->screen_space_opacity);
 
   hidden->test_properties()->hide_layer_and_subtree = false;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(1.f,
-            test->GetRenderSurface()->OwningEffectNode()->screen_space_opacity);
+            GetRenderSurface(test)->OwningEffectNode()->screen_space_opacity);
 }
 
 TEST_F(LayerTreeHostCommonTest, TwoUnclippedRenderSurfaces) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_layer = AddChild<LayerImpl>(root);
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_layer);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface2);
 
   root->SetBounds(gfx::Size(30, 30));
@@ skipping 167 matching lines @@
   // child has one, the large transform applied to child will result in NaNs in
   // the draw_transform of the render_surface, thus make draw property updates
   // skip the child layer. We need further investigation into this to know
   // what exactly happens here.
   child->test_properties()->transform = large_transform;
   child->SetBounds(gfx::Size(30, 30));
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::RectF(),
-            render_surface1->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(render_surface1)->DrawableContentRect());
 
   bool is_inf_or_nan = std::isinf(child->DrawTransform().matrix().get(0, 0)) ||
                        std::isnan(child->DrawTransform().matrix().get(0, 0));
   EXPECT_TRUE(is_inf_or_nan);
 
   is_inf_or_nan = std::isinf(child->DrawTransform().matrix().get(1, 1)) ||
                   std::isnan(child->DrawTransform().matrix().get(1, 1));
   EXPECT_TRUE(is_inf_or_nan);
 
   // The root layer should be in the RenderSurfaceList.
   const auto* rsl = render_surface_list_impl();
-  EXPECT_NE(std::find(rsl->begin(), rsl->end(), root->GetRenderSurface()),
+  EXPECT_NE(std::find(rsl->begin(), rsl->end(), GetRenderSurface(root)),
             rsl->end());
 }
 
 TEST_F(LayerTreeHostCommonTest, PropertyTreesRebuildWithOpacityChanges) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(child);
   host()->SetRootLayer(root);
 
@@ skipping 357 matching lines @@
   render_surface->test_properties()->transform = transform;
 
   child->SetDrawsContent(true);
   child->SetMasksToBounds(true);
   child->SetBounds(gfx::Size(10, 10));
 
   ExecuteCalculateDrawPropertiesWithoutAdjustingRasterScales(root);
 
   // Check surface draw properties.
   EXPECT_EQ(gfx::Rect(10, 10),
-            render_surface->GetRenderSurface()->content_rect());
-  EXPECT_EQ(transform, render_surface->GetRenderSurface()->draw_transform());
+            GetRenderSurface(render_surface)->content_rect());
+  EXPECT_EQ(transform, GetRenderSurface(render_surface)->draw_transform());
   EXPECT_EQ(gfx::RectF(50.0f, 50.0f),
-            render_surface->GetRenderSurface()->DrawableContentRect());
+            GetRenderSurface(render_surface)->DrawableContentRect());
 
   // Check child layer draw properties.
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_layer_rect());
   EXPECT_EQ(gfx::Transform(), child->DrawTransform());
   EXPECT_EQ(gfx::Rect(10, 10), child->clip_rect());
   EXPECT_EQ(gfx::Rect(10, 10), child->drawable_content_rect());
 }
 
 }  // namespace
 }  // namespace cc