cc: Replace render surface layer list with a render surface list

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 121 matching lines @@
       root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
     root_layer->layer_tree_impl()->SetDeviceScaleFactor(device_scale_factor);
 
     EXPECT_TRUE(page_scale_layer || (page_scale_factor == 1.f));
 
     gfx::Size device_viewport_size =
         gfx::Size(root_layer->bounds().width() * device_scale_factor,
                   root_layer->bounds().height() * device_scale_factor);
 
-    render_surface_layer_list_impl_.reset(new LayerImplList);
+    render_surface_list_impl_.reset(new RenderSurfaceList);
 
     // We are probably not testing what is intended if the root_layer bounds are
     // empty.
     DCHECK(!root_layer->bounds().IsEmpty());
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root_layer, device_viewport_size,
-        render_surface_layer_list_impl_.get());
+        root_layer, device_viewport_size, render_surface_list_impl_.get());
     inputs.device_scale_factor = device_scale_factor;
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_layer = page_scale_layer;
     inputs.inner_viewport_scroll_layer = inner_viewport_scroll_layer;
     inputs.outer_viewport_scroll_layer = outer_viewport_scroll_layer;
     inputs.can_adjust_raster_scales = true;
 
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
   }
 
@@ skipping 91 matching lines @@
         root_layer->layer_tree_impl(), property_trees,
         update_layer_list_impl_.get());
     draw_property_utils::ComputeDrawPropertiesOfVisibleLayers(
         update_layer_list_impl(), property_trees);
   }
 
   void ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(
       LayerImpl* root_layer) {
     gfx::Size device_viewport_size =
         gfx::Size(root_layer->bounds().width(), root_layer->bounds().height());
-    render_surface_layer_list_impl_.reset(new LayerImplList);
+    render_surface_list_impl_.reset(new RenderSurfaceList);
 
     DCHECK(!root_layer->bounds().IsEmpty());
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root_layer, device_viewport_size,
-        render_surface_layer_list_impl_.get());
+        root_layer, device_viewport_size, render_surface_list_impl_.get());
     inputs.can_adjust_raster_scales = true;
     inputs.can_render_to_separate_surface = false;
 
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
   }
 
   void ExecuteCalculateDrawPropertiesWithoutAdjustingRasterScales(
       LayerImpl* root_layer) {
     gfx::Size device_viewport_size =
         gfx::Size(root_layer->bounds().width(), root_layer->bounds().height());
-    render_surface_layer_list_impl_.reset(new LayerImplList);
+    render_surface_list_impl_.reset(new RenderSurfaceList);
 
     DCHECK(!root_layer->bounds().IsEmpty());
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root_layer, device_viewport_size,
-        render_surface_layer_list_impl_.get());
+        root_layer, device_viewport_size, render_surface_list_impl_.get());
     inputs.can_render_to_separate_surface = true;
     inputs.can_adjust_raster_scales = false;
 
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
   }
 
   bool UpdateLayerListImplContains(int id) const {
     for (auto* layer : *update_layer_list_impl_) {
       if (layer->id() == id)
         return true;
     }
     return false;
   }
 
   bool UpdateLayerListContains(int id) const {
     for (const auto& layer : update_layer_list_) {
       if (layer->id() == id)
         return true;
     }
     return false;
   }
 
-  const LayerImplList* render_surface_layer_list_impl() const {
-    return render_surface_layer_list_impl_.get();
+  const RenderSurfaceList* render_surface_list_impl() const {
+    return render_surface_list_impl_.get();
   }
   const LayerImplList* update_layer_list_impl() const {
     return update_layer_list_impl_.get();
   }
   const LayerList& update_layer_list() const { return update_layer_list_; }
 
   bool VerifyLayerInList(scoped_refptr<Layer> layer,
                          const LayerList* layer_list) {
     return std::find(layer_list->begin(), layer_list->end(), layer) !=
            layer_list->end();
   }
 
  private:
-  std::unique_ptr<std::vector<LayerImpl*>> render_surface_layer_list_impl_;
+  std::unique_ptr<RenderSurfaceList> render_surface_list_impl_;
   LayerList update_layer_list_;
   std::unique_ptr<LayerImplList> update_layer_list_impl_;
 };
 
 class LayerTreeHostCommonTest : public LayerTreeHostCommonTestBase,
                                 public testing::Test {};
 
 class LayerWithForcedDrawsContent : public Layer {
  public:
   LayerWithForcedDrawsContent() {}
@@ skipping 861 matching lines @@
   render_surface->SetBounds(gfx::Size(100, 100));
   render_surface->test_properties()->force_render_surface = true;
   child->test_properties()->transform = translate;
   child->SetBounds(gfx::Size(100, 100));
   grand_child->test_properties()->transform = translate;
   grand_child->SetBounds(gfx::Size(100, 100));
   grand_child->SetDrawsContent(true);
 
   // render_surface will have a sublayer scale because of device scale factor.
   float device_scale_factor = 2.0f;
-  LayerImplList render_surface_layer_list_impl;
+  RenderSurfaceList render_surface_list_impl;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root, root->bounds(), translate, &render_surface_layer_list_impl);
+      root, root->bounds(), translate, &render_surface_list_impl);
   inputs.device_scale_factor = device_scale_factor;
   inputs.property_trees->needs_rebuild = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // Between grand_child and render_surface, we translate by (10, 10) and scale
   // by a factor of 2.
   gfx::Vector2dF expected_translation(20.0f, 20.0f);
   EXPECT_EQ(grand_child->DrawTransform().To2dTranslation(),
             expected_translation);
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
   // Transformations applied at the root of the tree should be forwarded
   // to child layers instead of applied to the root RenderSurface.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
   root->SetDrawsContent(true);
   root->SetBounds(gfx::Size(100, 100));
   child->SetDrawsContent(true);
   child->SetScrollClipLayer(root->id());
   child->SetBounds(gfx::Size(100, 100));
   child->SetMasksToBounds(true);
 
   gfx::Transform translate;
   translate.Translate(50, 50);
   {
-    LayerImplList render_surface_layer_list_impl;
+    RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), translate, &render_surface_layer_list_impl);
+        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());
     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);
   {
-    LayerImplList render_surface_layer_list_impl;
+    RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), scale, &render_surface_layer_list_impl);
+        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());
     EXPECT_TRANSFORMATION_MATRIX_EQ(scale, child->ScreenSpaceTransform());
     EXPECT_EQ(gfx::Rect(0, 0, 200, 200), child->clip_rect());
   }
 
   gfx::Transform rotate;
   rotate.Rotate(2);
   {
-    LayerImplList render_surface_layer_list_impl;
+    RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), rotate, &render_surface_layer_list_impl);
+        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());
     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);
   {
-    LayerImplList render_surface_layer_list_impl;
+    RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), composite, &render_surface_layer_list_impl);
+        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());
     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;
 
   {
-    LayerImplList render_surface_layer_list_impl;
+    RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), translate, &render_surface_layer_list_impl);
+        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());
     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;
 
   {
-    LayerImplList render_surface_layer_list_impl;
+    RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), translate, &render_surface_layer_list_impl);
+        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());
     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;
 
   {
-    LayerImplList render_surface_layer_list_impl;
+    RenderSurfaceList render_surface_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), composite, &render_surface_layer_list_impl);
+        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());
@@ skipping 17 matching lines @@
   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());
-  EXPECT_EQ(1U, render_surface_layer_list_impl()->size());
+  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);
 
-  LayerImplList render_surface_layer_list;
+  RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root, root->bounds(), &render_surface_layer_list);
+      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(0U, root->GetRenderSurface()->layer_list().size());
-  EXPECT_EQ(1U, render_surface_layer_list.size());
-  EXPECT_EQ(root->id(), render_surface_layer_list.at(0)->id());
+  EXPECT_EQ(0, root->GetRenderSurface()->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);
 
   root->SetBounds(gfx::Size(10, 10));
   render_surface1->SetBounds(gfx::Size(10, 10));
   render_surface1->test_properties()->force_render_surface = true;
   render_surface1->test_properties()->opacity = 0.f;
   render_surface1->SetDrawsContent(true);
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBlurFilter(1.5f));
   render_surface1->test_properties()->background_filters = filters;
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
   root->layer_tree_impl()->SetElementIdsForTesting();
 
   {
-    LayerImplList render_surface_layer_list;
+    RenderSurfaceList render_surface_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), &render_surface_layer_list);
+        root, root->bounds(), &render_surface_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
-    EXPECT_EQ(2U, render_surface_layer_list.size());
+    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(1U, root->GetRenderSurface()->layer_list().size());
+  EXPECT_EQ(1, root->GetRenderSurface()->num_contributors());
   EXPECT_EQ(gfx::RectF(0, 0, 10, 10),
             root->GetRenderSurface()->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());
   {
-    LayerImplList render_surface_layer_list;
+    RenderSurfaceList render_surface_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), &render_surface_layer_list);
+        root, root->bounds(), &render_surface_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
   }
 
   node = effect_tree.Node(render_surface1->effect_tree_index());
   EXPECT_FALSE(node->is_drawn);
   EXPECT_EQ(gfx::Rect(), render_surface1->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForFilter) {
@@ skipping 12 matching lines @@
   parent->test_properties()->filters = filters;
   parent->test_properties()->force_render_surface = true;
   child1->SetBounds(gfx::Size(25, 25));
   child1->SetDrawsContent(true);
   child1->test_properties()->force_render_surface = true;
   child2->SetPosition(gfx::PointF(25, 25));
   child2->SetBounds(gfx::Size(25, 25));
   child2->SetDrawsContent(true);
   child2->test_properties()->force_render_surface = true;
 
-  LayerImplList render_surface_layer_list;
+  RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root, root->bounds(), &render_surface_layer_list);
+      root, root->bounds(), &render_surface_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   ASSERT_TRUE(parent->GetRenderSurface());
-  EXPECT_EQ(2U, parent->GetRenderSurface()->layer_list().size());
-  EXPECT_EQ(4U, render_surface_layer_list.size());
+  EXPECT_EQ(2, parent->GetRenderSurface()->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());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableContentRectForReferenceFilter) {
   LayerImpl* root = root_layer_for_testing();
@@ skipping 216 matching lines @@
   gfx::Transform flattened_rotation_about_y = rotation_about_y_axis;
   flattened_rotation_about_y.FlattenTo2d();
   EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_y,
                                   child->ScreenSpaceTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_y,
                                   grand_child->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipRectCullsRenderSurfaces) {
   // The entire subtree of layers that are outside the clip rect should be
-  // culled away, and should not affect the render_surface_layer_list.
+  // culled away, and should not affect the render_surface_list.
   //
   // The test tree is set up as follows:
   //  - all layers except the leaf_nodes are forced to be a new render surface
   //  that have something to draw.
   //  - parent is a large container layer.
   //  - child has MasksToBounds=true to cause clipping.
   //  - grand_child is positioned outside of the child's bounds
   //  - great_grand_child is also kept outside child's bounds.
   //
   // In this configuration, grand_child and great_grand_child are completely
   // outside the clip rect, and they should never get scheduled on the list of
   // render surfaces.
 
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   LayerImpl* great_grand_child = AddChild<LayerImpl>(grand_child);
 
-  // leaf_node1 ensures that root and child are kept on the
-  // render_surface_layer_list, even though grand_child and great_grand_child
-  // should be clipped.
+  // leaf_node1 ensures that root and child are kept on the render_surface_list,
+  // even though grand_child and great_grand_child should be clipped.
   LayerImpl* leaf_node1 = AddChild<LayerImpl>(child);
   LayerImpl* leaf_node2 = AddChild<LayerImpl>(great_grand_child);
 
   root->SetBounds(gfx::Size(500, 500));
   child->SetBounds(gfx::Size(20, 20));
   child->SetMasksToBounds(true);
   child->test_properties()->force_render_surface = true;
   grand_child->SetPosition(gfx::PointF(45.f, 45.f));
   grand_child->SetBounds(gfx::Size(10, 10));
   great_grand_child->SetBounds(gfx::Size(10, 10));
   leaf_node1->SetBounds(gfx::Size(500, 500));
   leaf_node1->SetDrawsContent(true);
   leaf_node1->SetBounds(gfx::Size(20, 20));
   leaf_node2->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
-  ASSERT_EQ(2U, render_surface_layer_list_impl()->size());
-  EXPECT_EQ(root->id(), render_surface_layer_list_impl()->at(0)->id());
-  EXPECT_EQ(child->id(), render_surface_layer_list_impl()->at(1)->id());
+  ASSERT_EQ(2U, render_surface_list_impl()->size());
+  EXPECT_EQ(root->id(), render_surface_list_impl()->at(0)->id());
+  EXPECT_EQ(child->id(), render_surface_list_impl()->at(1)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipRectCullsSurfaceWithoutVisibleContent) {
   // When a render surface has a clip rect, it is used to clip the content rect
   // of the surface.
 
   // The test tree is set up as follows:
   //  - root is a container layer that masksToBounds=true to cause clipping.
   //  - child is a render surface, which has a clip rect set to the bounds of
   //  the root.
   //  - grand_child is a render surface, and the only visible content in child.
   //  It is positioned outside of the clip rect from root.
 
   // In this configuration, grand_child should be outside the clipped
   // content rect of the child, making grand_child not appear in the
-  // render_surface_layer_list.
+  // render_surface_list.
 
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   LayerImpl* leaf_node = AddChild<LayerImpl>(grand_child);
 
   root->SetMasksToBounds(true);
   root->SetBounds(gfx::Size(100, 100));
   child->SetBounds(gfx::Size(20, 20));
   child->test_properties()->force_render_surface = true;
   grand_child->SetPosition(gfx::PointF(200.f, 200.f));
   grand_child->SetBounds(gfx::Size(10, 10));
   grand_child->test_properties()->force_render_surface = true;
   leaf_node->SetBounds(gfx::Size(10, 10));
   leaf_node->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   // We should cull child and grand_child from the
-  // render_surface_layer_list.
-  ASSERT_EQ(1U, render_surface_layer_list_impl()->size());
-  EXPECT_EQ(root->id(), render_surface_layer_list_impl()->at(0)->id());
+  // render_surface_list.
+  ASSERT_EQ(1U, render_surface_list_impl()->size());
+  EXPECT_EQ(root->id(), render_surface_list_impl()->at(0)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, IsClippedIsSetCorrectlyLayerImpl) {
   // Tests that LayerImpl's IsClipped() property is set to true when:
   //  - the layer clips its subtree, e.g. masks to bounds,
   //  - the layer is clipped by an ancestor that contributes to the same
   //    render target,
   //  - a surface is clipped by an ancestor that contributes to the same
   //    render target.
   //
@@ skipping 1708 matching lines @@
   child1->SetPosition(gfx::PointF(5.f, 5.f));
   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);
 
-  LayerImplList render_surface_layer_list_impl;
+  RenderSurfaceList render_surface_list_impl;
   // Now set the root render surface an empty clip.
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root, gfx::Size(), &render_surface_layer_list_impl);
+      root, gfx::Size(), &render_surface_list_impl);
 
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
   ASSERT_TRUE(root->GetRenderSurface());
   EXPECT_FALSE(root->is_clipped());
 
   gfx::Rect empty;
   EXPECT_EQ(empty, root->GetRenderSurface()->clip_rect());
   EXPECT_TRUE(root->GetRenderSurface()->is_clipped());
 
   // Visible content rect calculation will check if the target surface is
@@ skipping 1103 matching lines @@
   child2->SetDrawsContent(true);
 
   float device_scale_factor = 2.5f;
   gfx::Size viewport_size(100, 100);
   ExecuteCalculateDrawProperties(root, device_scale_factor);
 
   EXPECT_FLOAT_EQ(device_scale_factor, root->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(device_scale_factor, child->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(device_scale_factor, child2->GetIdealContentsScale());
 
-  EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
+  EXPECT_EQ(1u, render_surface_list_impl()->size());
 
   // Verify root transforms
   gfx::Transform expected_root_transform;
   expected_root_transform.Scale(device_scale_factor, device_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_root_transform,
                                   root->ScreenSpaceTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_root_transform,
                                   root->DrawTransform());
 
   // Verify results of transformed root rects
@@ skipping 106 matching lines @@
 
   // The ideal scale will draw 1:1 with its render target space along
   // the larger-scale axis.
   gfx::Vector2dF target_space_transform_scales =
       MathUtil::ComputeTransform2dScaleComponents(
           scale_surface->draw_properties().target_space_transform, 0.f);
   EXPECT_FLOAT_EQ(max_2d_scale,
                   std::max(target_space_transform_scales.x(),
                            target_space_transform_scales.y()));
 
-  EXPECT_EQ(3u, render_surface_layer_list_impl()->size());
+  EXPECT_EQ(3u, render_surface_list_impl()->size());
 
   gfx::Transform expected_parent_draw_transform;
   expected_parent_draw_transform.Scale(device_scale_factor * page_scale_factor,
                                        device_scale_factor * page_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_draw_transform,
                                   parent->DrawTransform());
 
   // The scale for the perspective surface is not known, so it is rendered 1:1
   // with the screen, and then scaled during drawing.
   gfx::Transform expected_perspective_surface_draw_transform;
@@ skipping 110 matching lines @@
   // and screen space transforms.
   LayerImpl* duplicate_child_non_owner = AddChild<LayerImpl>(child);
   duplicate_child_non_owner->SetBounds(gfx::Size(10, 10));
   duplicate_child_non_owner->SetDrawsContent(true);
 
   float device_scale_factor = 1.5f;
   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_layer_list_impl()->size());
+  EXPECT_EQ(2u, render_surface_list_impl()->size());
 
   gfx::Transform expected_parent_transform;
   expected_parent_transform.Scale(device_scale_factor, device_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->ScreenSpaceTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->DrawTransform());
 
   gfx::Transform expected_draw_transform;
   expected_draw_transform.Scale(device_scale_factor, device_scale_factor);
@@ skipping 49 matching lines @@
   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_layer_list_impl()->size());
+  EXPECT_EQ(2u, render_surface_list_impl()->size());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                   child->GetRenderSurface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                   child->GetRenderSurface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       gfx::Transform(), child->GetRenderSurface()->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerSearch) {
@@ skipping 57 matching lines @@
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
   ElementId child_element_id =
       host_impl.pending_tree()->LayerById(child_id)->element_id();
 
   AddOpacityTransitionToElementWithPlayer(child_element_id, timeline, 10.0,
                                           0.0f, 1.0f, false);
 
-  LayerImplList render_surface_layer_list;
+  RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root_layer, root_layer->bounds(), &render_surface_layer_list);
+      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 child
   // layer should be included even though it is transparent.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(2u, root_layer->GetRenderSurface()->layer_list().size());
+  ASSERT_EQ(1u, render_surface_list.size());
+  ASSERT_EQ(2, root_layer->GetRenderSurface()->num_contributors());
 
   // If the root itself is hidden, the child should not be drawn even if it has
   // an animating opacity.
   root_layer->test_properties()->opacity = 0.0f;
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
-  LayerImplList render_surface_layer_list2;
+  RenderSurfaceList render_surface_list2;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs2(
-      root_layer, root_layer->bounds(), &render_surface_layer_list2);
+      root_layer, root_layer->bounds(), &render_surface_list2);
   inputs2.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs2);
 
   LayerImpl* child_ptr = root_layer->layer_tree_impl()->LayerById(2);
   EffectTree& tree =
       root_layer->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = tree.Node(child_ptr->effect_tree_index());
   EXPECT_FALSE(node->is_drawn);
 
   // A layer should be drawn and it should contribute to drawn surface when
   // it has animating opacity even if it has opacity 0.
   root_layer->test_properties()->opacity = 1.0f;
   child_ptr->test_properties()->opacity = 0.0f;
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
-  LayerImplList render_surface_layer_list3;
+  RenderSurfaceList render_surface_list3;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs3(
-      root_layer, root_layer->bounds(), &render_surface_layer_list3);
+      root_layer, root_layer->bounds(), &render_surface_list3);
   inputs3.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs3);
 
   child_ptr = root_layer->layer_tree_impl()->LayerById(2);
   tree = root_layer->layer_tree_impl()->property_trees()->effect_tree;
   node = tree.Node(child_ptr->effect_tree_index());
   EXPECT_TRUE(node->is_drawn);
   EXPECT_TRUE(tree.ContributesToDrawnSurface(child_ptr->effect_tree_index()));
 
   // But if the opacity of the layer remains 0 after activation, it should not
@@ skipping 244 matching lines @@
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.pending_tree(), 1);
   root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
   LayerImpl* root_layer = root.get();
 
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.pending_tree(), 2);
   child->SetBounds(gfx::Size(40, 40));
   child->SetDrawsContent(true);
+  LayerImpl* child_layer = child.get();
 
   std::unique_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 3);
   grand_child->SetBounds(gfx::Size(30, 30));
   grand_child->SetDrawsContent(true);
   grand_child->test_properties()->hide_layer_and_subtree = true;
+  LayerImpl* grand_child_layer = grand_child.get();
 
   child->test_properties()->AddChild(std::move(grand_child));
   root->test_properties()->AddChild(std::move(child));
   host_impl.pending_tree()->SetRootLayerForTesting(std::move(root));
 
-  LayerImplList render_surface_layer_list;
+  RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root_layer, root_layer->bounds(), &render_surface_layer_list);
+      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_layer_list.size());
-  ASSERT_EQ(2u, root_layer->GetRenderSurface()->layer_list().size());
-  EXPECT_EQ(1, root_layer->GetRenderSurface()->layer_list().at(0)->id());
-  EXPECT_EQ(2, root_layer->GetRenderSurface()->layer_list().at(1)->id());
+  ASSERT_EQ(1u, render_surface_list.size());
+  ASSERT_EQ(2, root_layer->GetRenderSurface()->num_contributors());
+  EXPECT_TRUE(root_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(child_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_FALSE(grand_child_layer->is_drawn_render_surface_layer_list_member());
 }
 
 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();
 
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.pending_tree(), 1);
   root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
   LayerImpl* root_layer = root.get();
 
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.pending_tree(), 2);
   child->SetBounds(gfx::Size(40, 40));
   child->SetDrawsContent(true);
   child->test_properties()->hide_layer_and_subtree = true;
+  LayerImpl* child_layer = child.get();
 
   std::unique_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 3);
   grand_child->SetBounds(gfx::Size(30, 30));
   grand_child->SetDrawsContent(true);
+  LayerImpl* grand_child_layer = grand_child.get();
 
   child->test_properties()->AddChild(std::move(grand_child));
   root->test_properties()->AddChild(std::move(child));
   host_impl.pending_tree()->SetRootLayerForTesting(std::move(root));
 
-  LayerImplList render_surface_layer_list;
+  RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root_layer, root_layer->bounds(), &render_surface_layer_list);
+      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 layers. The child has
+  // We should have one render surface and one layer. The child has
   // hidden itself and the grand child.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root_layer->GetRenderSurface()->layer_list().size());
-  EXPECT_EQ(1, root_layer->GetRenderSurface()->layer_list().at(0)->id());
+  ASSERT_EQ(1u, render_surface_list.size());
+  ASSERT_EQ(1, root_layer->GetRenderSurface()->num_contributors());
+  EXPECT_TRUE(root_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_FALSE(child_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_FALSE(grand_child_layer->is_drawn_render_surface_layer_list_member());
 }
 
 void EmptyCopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {}
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
   host_impl.CreatePendingTree();
 
@@ skipping 65 matching lines @@
   copy_grand_parent_layer->test_properties()->hide_layer_and_subtree = true;
   copy_grand_parent_sibling_before_layer->test_properties()
       ->hide_layer_and_subtree = true;
   copy_grand_parent_sibling_after_layer->test_properties()
       ->hide_layer_and_subtree = true;
   copy_grand_child_layer->test_properties()->hide_layer_and_subtree = true;
 
   copy_layer->test_properties()->copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
 
-  LayerImplList render_surface_layer_list;
+  RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root_layer, root_layer->bounds(), &render_surface_layer_list);
+      root_layer, root_layer->bounds(), &render_surface_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   EXPECT_TRUE(root_layer->has_copy_requests_in_target_subtree());
   EXPECT_TRUE(copy_grand_parent_layer->has_copy_requests_in_target_subtree());
   EXPECT_TRUE(copy_parent_layer->has_copy_requests_in_target_subtree());
   EXPECT_TRUE(copy_layer->has_copy_requests_in_target_subtree());
 
   // 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_layer_list.size());
-  EXPECT_EQ(root_layer->id(), render_surface_layer_list.at(0)->id());
-  EXPECT_EQ(copy_grand_parent_layer->id(),
-            render_surface_layer_list.at(1)->id());
-  EXPECT_EQ(copy_parent_layer->id(), render_surface_layer_list.at(2)->id());
-  EXPECT_EQ(copy_layer->id(), render_surface_layer_list.at(3)->id());
+  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.
-  ASSERT_EQ(2u, root_layer->GetRenderSurface()->layer_list().size());
-  EXPECT_EQ(root_layer->id(),
-            root_layer->GetRenderSurface()->layer_list().at(0)->id());
-  EXPECT_EQ(copy_grand_parent_layer->id(),
-            root_layer->GetRenderSurface()->layer_list().at(1)->id());
+  EXPECT_EQ(2, root_layer->GetRenderSurface()->num_contributors());
+  EXPECT_TRUE(root_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_FALSE(
+      copy_grand_parent_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_FALSE(copy_grand_parent_sibling_before_layer
+                   ->is_drawn_render_surface_layer_list_member());
+  EXPECT_FALSE(copy_grand_parent_sibling_after_layer
+                   ->is_drawn_render_surface_layer_list_member());
 
   // Nothing actually draws into the copy parent, so only the copy_layer will
   // appear in its list, since it needs to be drawn for the copy request.
-  ASSERT_EQ(1u, copy_parent_layer->GetRenderSurface()->layer_list().size());
-  EXPECT_EQ(copy_layer->id(),
-            copy_parent_layer->GetRenderSurface()->layer_list().at(0)->id());
+  ASSERT_EQ(1, copy_parent_layer->GetRenderSurface()->num_contributors());
+  EXPECT_FALSE(copy_parent_layer->is_drawn_render_surface_layer_list_member());
 
-  // The copy_layer's render surface should have two contributing layers.
-  ASSERT_EQ(2u, copy_layer->GetRenderSurface()->layer_list().size());
-  EXPECT_EQ(copy_layer->id(),
-            copy_layer->GetRenderSurface()->layer_list().at(0)->id());
-  EXPECT_EQ(copy_child_layer->id(),
-            copy_layer->GetRenderSurface()->layer_list().at(1)->id());
+  // The copy layer's render surface should have 2 contributing layers.
+  ASSERT_EQ(2, copy_layer->GetRenderSurface()->num_contributors());
+  EXPECT_TRUE(copy_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(copy_child_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_FALSE(
+      copy_grand_child_layer->is_drawn_render_surface_layer_list_member());
 
   // 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());
@@ skipping 37 matching lines @@
   copy_child->SetBounds(gfx::Size(20, 20));
   copy_child->SetDrawsContent(true);
 
   copy_layer->test_properties()->copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
 
   copy_layer->test_properties()->AddChild(std::move(copy_child));
   copy_parent->test_properties()->AddChild(std::move(copy_layer));
   root->test_properties()->AddChild(std::move(copy_parent));
 
-  LayerImplList render_surface_layer_list;
+  RenderSurfaceList render_surface_list;
   LayerImpl* root_layer = root.get();
   root_layer->layer_tree_impl()->SetRootLayerForTesting(std::move(root));
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root_layer, root_layer->bounds(), &render_surface_layer_list);
+      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_layer_list.size());
-  EXPECT_EQ(root_layer->id(), render_surface_layer_list.at(0)->id());
+  ASSERT_EQ(2u, render_surface_list.size());
+  EXPECT_EQ(root_layer->id(), render_surface_list.at(0)->id());
 
-  // The root render surface should only have 2 contributing layer, since the
-  // other layers are empty/clipped away.
-  ASSERT_EQ(2u, root_layer->GetRenderSurface()->layer_list().size());
-  EXPECT_EQ(root_layer->id(),
-            root_layer->GetRenderSurface()->layer_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());
+  EXPECT_TRUE(root_layer->is_drawn_render_surface_layer_list_member());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleRectInNonRootCopyRequest) {
   LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
   root->SetMasksToBounds(true);
 
   LayerImpl* copy_layer = AddChild<LayerImpl>(root);
   copy_layer->SetBounds(gfx::Size(100, 100));
@@ skipping 480 matching lines @@
   child3->SetDrawsContent(true);
   child3->test_properties()->sorting_context_id = 1;
 
   child2->test_properties()->AddChild(std::move(child3));
   child1->test_properties()->AddChild(std::move(child2));
   root->test_properties()->AddChild(std::move(child1));
   LayerImpl* root_layer = root.get();
   root_layer->layer_tree_impl()->SetRootLayerForTesting(std::move(root));
 
   {
-    LayerImplList render_surface_layer_list;
+    RenderSurfaceList render_surface_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root_layer, root_layer->bounds(), &render_surface_layer_list);
+        root_layer, root_layer->bounds(), &render_surface_list);
     inputs.can_render_to_separate_surface = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
-    EXPECT_EQ(2u, render_surface_layer_list.size());
+    EXPECT_EQ(2u, render_surface_list.size());
 
     int count_represents_target_render_surface = 0;
     int count_represents_contributing_render_surface = 0;
     int count_represents_itself = 0;
     for (EffectTreeLayerListIterator it(host_impl.active_tree());
          it.state() != EffectTreeLayerListIterator::State::END; ++it) {
       if (it.state() == EffectTreeLayerListIterator::State::TARGET_SURFACE) {
         count_represents_target_render_surface++;
       } else if (it.state() ==
                  EffectTreeLayerListIterator::State::CONTRIBUTING_SURFACE) {
         count_represents_contributing_render_surface++;
       } else {
         count_represents_itself++;
       }
     }
 
     // Two render surfaces.
     EXPECT_EQ(2, count_represents_target_render_surface);
     // Second render surface contributes to root render surface.
     EXPECT_EQ(1, count_represents_contributing_render_surface);
     // All 4 layers represent itself.
     EXPECT_EQ(4, count_represents_itself);
   }
 
   {
-    LayerImplList render_surface_layer_list;
+    RenderSurfaceList render_surface_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root_layer, root_layer->bounds(), &render_surface_layer_list);
+        root_layer, root_layer->bounds(), &render_surface_list);
     inputs.can_render_to_separate_surface = false;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
-    EXPECT_EQ(1u, render_surface_layer_list.size());
+    EXPECT_EQ(1u, render_surface_list.size());
 
     int count_represents_target_render_surface = 0;
     int count_represents_contributing_render_surface = 0;
     int count_represents_itself = 0;
     for (EffectTreeLayerListIterator it(host_impl.active_tree());
          it.state() != EffectTreeLayerListIterator::State::END; ++it) {
       if (it.state() == EffectTreeLayerListIterator::State::TARGET_SURFACE) {
         count_represents_target_render_surface++;
       } else if (it.state() ==
                  EffectTreeLayerListIterator::State::CONTRIBUTING_SURFACE) {
@@ skipping 38 matching lines @@
 
   flattener->SetBounds(gfx::Size(30, 30));
   render_surface2->SetBounds(gfx::Size(30, 30));
   render_surface2->test_properties()->should_flatten_transform = false;
   render_surface2->test_properties()->force_render_surface = true;
   render_surface2->test_properties()->double_sided = false;
   child2->SetBounds(gfx::Size(20, 20));
 
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_EQ(3u, render_surface_layer_list_impl()->size());
-  EXPECT_EQ(2u,
-            render_surface_layer_list_impl()
-                ->at(0)
-                ->GetRenderSurface()
-                ->layer_list()
-                .size());
-  EXPECT_EQ(1u,
-            render_surface_layer_list_impl()
-                ->at(1)
-                ->GetRenderSurface()
-                ->layer_list()
-                .size());
+  EXPECT_EQ(3u, render_surface_list_impl()->size());
+  EXPECT_EQ(2, render_surface_list_impl()->at(0)->num_contributors());
+  EXPECT_EQ(1, render_surface_list_impl()->at(1)->num_contributors());
 
   gfx::Transform rotation_transform;
   rotation_transform.RotateAboutXAxis(180.0);
 
   back_facing->test_properties()->transform = rotation_transform;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
 
   // render_surface1 is in the same 3d rendering context as back_facing and is
   // not double sided, so it should not be in RSLL. render_surface2 is also not
   // double-sided, but will still be in RSLL as it's in a different 3d rendering
   // context.
-  EXPECT_EQ(2u, render_surface_layer_list_impl()->size());
-  EXPECT_EQ(1u,
-            render_surface_layer_list_impl()
-                ->at(0)
-                ->GetRenderSurface()
-                ->layer_list()
-                .size());
+  EXPECT_EQ(2u, render_surface_list_impl()->size());
+  EXPECT_EQ(1, render_surface_list_impl()->at(0)->num_contributors());
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleLayers) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   root->SetBounds(gfx::Size(50, 50));
   root->test_properties()->should_flatten_transform = false;
   child->SetBounds(gfx::Size(30, 30));
   child->test_properties()->double_sided = false;
   child->test_properties()->should_flatten_transform = false;
   grand_child->SetBounds(gfx::Size(20, 20));
   grand_child->SetDrawsContent(true);
   grand_child->SetUseParentBackfaceVisibility(true);
   grand_child->test_properties()->should_flatten_transform = false;
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
-  EXPECT_EQ(grand_child,
-            render_surface_layer_list_impl()
-                ->at(0)
-                ->GetRenderSurface()
-                ->layer_list()[0]);
+  EXPECT_EQ(1u, render_surface_list_impl()->size());
+  EXPECT_TRUE(grand_child->is_drawn_render_surface_layer_list_member());
 
   // As all layers have identity transform, we shouldn't check for backface
   // visibility.
   EXPECT_FALSE(root->should_check_backface_visibility());
   EXPECT_FALSE(child->should_check_backface_visibility());
   EXPECT_FALSE(grand_child->should_check_backface_visibility());
   // As there are no 3d rendering contexts, all layers should use their local
   // transform for backface visibility.
   EXPECT_TRUE(root->use_local_transform_for_backface_visibility());
   EXPECT_TRUE(child->use_local_transform_for_backface_visibility());
   EXPECT_TRUE(grand_child->use_local_transform_for_backface_visibility());
 
   gfx::Transform rotation_transform;
   rotation_transform.RotateAboutXAxis(180.0);
 
   child->test_properties()->transform = rotation_transform;
   child->test_properties()->sorting_context_id = 1;
   grand_child->test_properties()->sorting_context_id = 1;
   child->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
-  EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
-  EXPECT_EQ(0u,
-            render_surface_layer_list_impl()
-                ->at(0)
-                ->GetRenderSurface()
-                ->layer_list()
-                .size());
+  EXPECT_EQ(1u, render_surface_list_impl()->size());
+  EXPECT_EQ(0, render_surface_list_impl()->at(0)->num_contributors());
 
   // We should check for backface visibilty of child as it has a rotation
   // transform. We should also check for grand_child as it uses the backface
   // visibility of its parent.
   EXPECT_FALSE(root->should_check_backface_visibility());
   EXPECT_TRUE(child->should_check_backface_visibility());
   EXPECT_TRUE(grand_child->should_check_backface_visibility());
   // child uses its local transform for backface visibility as it is the root of
   // a 3d rendering context. grand_child is in a 3d rendering context and is not
   // the root, but it derives its backface visibility from its parent which uses
   // its local transform.
   EXPECT_TRUE(root->use_local_transform_for_backface_visibility());
   EXPECT_TRUE(child->use_local_transform_for_backface_visibility());
   EXPECT_TRUE(grand_child->use_local_transform_for_backface_visibility());
 
   grand_child->SetUseParentBackfaceVisibility(false);
   grand_child->test_properties()->double_sided = false;
   grand_child->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
-  EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
-  EXPECT_EQ(0u,
-            render_surface_layer_list_impl()
-                ->at(0)
-                ->GetRenderSurface()
-                ->layer_list()
-                .size());
+  EXPECT_EQ(1u, render_surface_list_impl()->size());
+  EXPECT_EQ(0, render_surface_list_impl()->at(0)->num_contributors());
 
   // We should check the backface visibility of child as it has a rotation
   // transform and for grand_child as it is in a 3d rendering context and not
   // the root of it.
   EXPECT_FALSE(root->should_check_backface_visibility());
   EXPECT_TRUE(child->should_check_backface_visibility());
   EXPECT_TRUE(grand_child->should_check_backface_visibility());
   // grand_child is in an existing 3d rendering context, so it should not use
   // local transform for backface visibility.
   EXPECT_TRUE(root->use_local_transform_for_backface_visibility());
@@ skipping 115 matching lines @@
   scroll_child_target->SetBounds(gfx::Size(50, 50));
   scroll_child_target->test_properties()->force_render_surface = true;
   scroll_child->SetBounds(gfx::Size(50, 50));
   scroll_parent_target->SetPosition(gfx::PointF(10, 10));
   scroll_parent_target->SetBounds(gfx::Size(50, 50));
   scroll_parent_target->SetMasksToBounds(true);
   scroll_parent_target->test_properties()->force_render_surface = true;
   scroll_parent->SetBounds(gfx::Size(50, 50));
 
   float device_scale_factor = 1.5f;
-  LayerImplList render_surface_layer_list_impl;
+  RenderSurfaceList render_surface_list_impl;
   gfx::Size device_viewport_size =
       gfx::Size(root->bounds().width() * device_scale_factor,
                 root->bounds().height() * device_scale_factor);
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root, device_viewport_size, gfx::Transform(),
-      &render_surface_layer_list_impl);
+      root, device_viewport_size, gfx::Transform(), &render_surface_list_impl);
   inputs.device_scale_factor = device_scale_factor;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   EXPECT_EQ(scroll_child->effect_tree_index(),
             scroll_child_target->effect_tree_index());
   EXPECT_EQ(scroll_child->visible_layer_rect(), gfx::Rect(10, 10, 40, 40));
   EXPECT_EQ(scroll_child->clip_rect(), gfx::Rect(15, 15, 75, 75));
   gfx::Transform scale;
   scale.Scale(1.5f, 1.5f);
   EXPECT_TRANSFORMATION_MATRIX_EQ(scroll_child->DrawTransform(), scale);
@@ skipping 10 matching lines @@
   parent->SetBounds(gfx::Size(30, 30));
   parent->SetDrawsContent(true);
   parent->test_properties()->force_render_surface = true;
   parent->test_properties()->sorting_context_id = 1;
   child->SetBounds(gfx::Size(20, 20));
   child->SetDrawsContent(true);
   child->test_properties()->force_render_surface = true;
   child->test_properties()->sorting_context_id = 1;
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_EQ(3u, render_surface_layer_list_impl()->size());
+  EXPECT_EQ(3u, render_surface_list_impl()->size());
 
   gfx::Transform singular_transform;
   singular_transform.Scale3d(
       SkDoubleToMScalar(1.0), SkDoubleToMScalar(1.0), SkDoubleToMScalar(0.0));
 
   child->test_properties()->transform = singular_transform;
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_EQ(2u, render_surface_layer_list_impl()->size());
+  EXPECT_EQ(2u, render_surface_list_impl()->size());
 
   // Ensure that the entire subtree under a layer with singular transform does
   // not get rendered.
   parent->test_properties()->transform = singular_transform;
   child->test_properties()->transform = gfx::Transform();
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
+  EXPECT_EQ(1u, render_surface_list_impl()->size());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollParent) {
   // Checks that clipping by a scroll parent that follows you in paint order
   // still results in correct clipping.
   //
   // + root
   //   + scroll_parent_border
   //     + scroll_parent_clip
   //       + scroll_parent
@@ skipping 80 matching lines @@
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->GetRenderSurface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20), scroll_child->clip_rect());
   EXPECT_TRUE(scroll_child->is_clipped());
 
   // Despite the fact that we visited the above layers out of order to get the
   // correct clip, the layer lists should be unaffected.
-  EXPECT_EQ(3u, root->GetRenderSurface()->layer_list().size());
-  EXPECT_EQ(scroll_child, root->GetRenderSurface()->layer_list().at(0));
-  EXPECT_EQ(scroll_parent, root->GetRenderSurface()->layer_list().at(1));
-  EXPECT_EQ(scroll_grandparent, root->GetRenderSurface()->layer_list().at(2));
+  EXPECT_EQ(3, root->GetRenderSurface()->num_contributors());
+  EXPECT_TRUE(scroll_child->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(scroll_parent->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(scroll_grandparent->is_drawn_render_surface_layer_list_member());
 }
 
 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
   //   + scroll_parent_border
   //     + scroll_parent_clip
   //       + scroll_parent
@@ skipping 52 matching lines @@
   scroll_child->SetBounds(gfx::Size(50, 50));
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->GetRenderSurface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20), scroll_child->clip_rect());
   EXPECT_TRUE(scroll_child->is_clipped());
 
   // Despite the fact that we had to process the layers out of order to get the
-  // right clip, our render_surface_layer_list's order should be unaffected.
-  EXPECT_EQ(3u, render_surface_layer_list_impl()->size());
-  EXPECT_EQ(root, render_surface_layer_list_impl()->at(0));
-  EXPECT_EQ(render_surface2, render_surface_layer_list_impl()->at(1));
-  EXPECT_EQ(render_surface1, render_surface_layer_list_impl()->at(2));
-  EXPECT_TRUE(render_surface_layer_list_impl()->at(0)->GetRenderSurface());
-  EXPECT_TRUE(render_surface_layer_list_impl()->at(1)->GetRenderSurface());
-  EXPECT_TRUE(render_surface_layer_list_impl()->at(2)->GetRenderSurface());
+  // 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(),
+            render_surface_list_impl()->at(1));
+  EXPECT_EQ(render_surface1->GetRenderSurface(),
+            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
   //   + render_surface
@@ skipping 105 matching lines @@
   container->test_properties()->AddChild(std::move(scroller));
   root->test_properties()->AddChild(std::move(container));
   root->layer_tree_impl()->SetRootLayerForTesting(std::move(root_ptr));
   root->layer_tree_impl()->BuildPropertyTreesForTesting();
 
   // Rounded to integers already.
   {
     gfx::Vector2dF scroll_delta(3.0, 5.0);
     SetScrollOffsetDelta(scroll_layer, scroll_delta);
 
-    LayerImplList render_surface_layer_list;
+    RenderSurfaceList render_surface_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), &render_surface_layer_list);
+        root, root->bounds(), &render_surface_list);
     root->layer_tree_impl()
         ->property_trees()
         ->transform_tree.set_source_to_parent_updates_allowed(false);
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         container_layer->draw_properties().screen_space_transform,
         fixed_layer->draw_properties().screen_space_transform);
     EXPECT_VECTOR_EQ(
         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
         container_offset);
     EXPECT_VECTOR_EQ(scroll_layer->draw_properties()
                          .screen_space_transform.To2dTranslation(),
                      container_offset - scroll_delta);
   }
 
   // Scroll delta requiring rounding.
   {
     gfx::Vector2dF scroll_delta(4.1f, 8.1f);
     SetScrollOffsetDelta(scroll_layer, scroll_delta);
 
     gfx::Vector2dF rounded_scroll_delta(4.f, 8.f);
 
-    LayerImplList render_surface_layer_list;
+    RenderSurfaceList render_surface_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), &render_surface_layer_list);
+        root, root->bounds(), &render_surface_list);
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         container_layer->draw_properties().screen_space_transform,
         fixed_layer->draw_properties().screen_space_transform);
     EXPECT_VECTOR_EQ(
         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
         container_offset);
     EXPECT_VECTOR_EQ(scroll_layer->draw_properties()
                          .screen_space_transform.To2dTranslation(),
                      container_offset - rounded_scroll_delta);
   }
 
   // Scale is applied earlier in the tree.
   {
     SetScrollOffsetDelta(scroll_layer, gfx::Vector2dF());
     gfx::Transform scaled_container_transform = container_transform;
     scaled_container_transform.Scale3d(2.0, 2.0, 1.0);
     container_layer->test_properties()->transform = scaled_container_transform;
 
     root->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
     gfx::Vector2dF scroll_delta(4.5f, 8.5f);
     SetScrollOffsetDelta(scroll_layer, scroll_delta);
 
-    LayerImplList render_surface_layer_list;
+    RenderSurfaceList render_surface_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), &render_surface_layer_list);
+        root, root->bounds(), &render_surface_list);
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         container_layer->draw_properties().screen_space_transform,
         fixed_layer->draw_properties().screen_space_transform);
     EXPECT_VECTOR_EQ(
         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
         container_offset);
 
     container_layer->test_properties()->transform = container_transform;
@@ skipping 1724 matching lines @@
 
   EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(root_layer));
   EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(child1_layer));
   EXPECT_FLOAT_EQ(8.f, GetMaximumAnimationScale(child2_layer));
 
   // Changing page-scale would affect ideal_contents_scale and
   // maximum_animation_contents_scale.
 
   float page_scale_factor = 3.f;
   float device_scale_factor = 1.0f;
-  std::vector<LayerImpl*> render_surface_layer_list;
+  RenderSurfaceList render_surface_list;
   gfx::Size device_viewport_size =
       gfx::Size(root_layer->bounds().width() * device_scale_factor,
                 root_layer->bounds().height() * device_scale_factor);
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root_layer, device_viewport_size, &render_surface_layer_list);
+      root_layer, device_viewport_size, &render_surface_list);
 
   inputs.page_scale_factor = page_scale_factor;
   inputs.can_adjust_raster_scales = true;
   inputs.page_scale_layer = root_layer;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   EXPECT_FLOAT_EQ(3.f, root_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(9.f, child1_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(
       9.f,
@@ skipping 154 matching lines @@
 
   root->SetBounds(gfx::Size(768 / 2, 3000));
   root->SetDrawsContent(true);
   clip->SetBounds(gfx::Size(768 / 2, 10000));
   clip->SetMasksToBounds(true);
   content->SetBounds(gfx::Size(768 / 2, 10000));
   content->SetDrawsContent(true);
   content->test_properties()->force_render_surface = true;
 
   gfx::Size device_viewport_size(768, 582);
-  LayerImplList render_surface_layer_list_impl;
+  RenderSurfaceList render_surface_list_impl;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root, device_viewport_size, gfx::Transform(),
-      &render_surface_layer_list_impl);
+      root, device_viewport_size, gfx::Transform(), &render_surface_list_impl);
   inputs.device_scale_factor = 2.f;
   inputs.page_scale_factor = 1.f;
   inputs.page_scale_layer = nullptr;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // Layers in the root render surface have their visible content rect clipped
   // by the viewport.
   EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), root->visible_layer_rect());
 
   // Layers drawing to a child render surface should still have their visible
@@ skipping 32 matching lines @@
 
   root->test_properties()->AddChild(
       LayerImpl::Create(host_impl.active_tree(), 2));
 
   LayerImpl* sublayer = root->test_properties()->children[0];
   sublayer->SetBounds(sublayer_size);
   sublayer->SetDrawsContent(true);
 
   host_impl.active_tree()->BuildPropertyTreesForTesting();
 
-  LayerImplList layer_impl_list;
+  RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root, device_viewport_size, &layer_impl_list);
+      root, device_viewport_size, &render_surface_list);
 
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
   EXPECT_EQ(gfx::Rect(root_size), sublayer->visible_layer_rect());
 
   root->SetViewportBoundsDelta(gfx::Vector2dF(0.0, 50.0));
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   gfx::Rect affected_by_delta(0, 0, root_size.width(),
                               root_size.height() + 50);
   EXPECT_EQ(affected_by_delta, sublayer->visible_layer_rect());
@@ skipping 1561 matching lines @@
             render_surface1->GetRenderSurface()->DrawableContentRect());
 
   bool is_inf_or_nan = std::isinf(child->DrawTransform().matrix().get(0, 0)) ||
                        std::isnan(child->DrawTransform().matrix().get(0, 0));
   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 RenderSurfaceLayerListImpl.
-  const auto* rsll = render_surface_layer_list_impl();
-  EXPECT_NE(std::find(rsll->begin(), rsll->end(), root), rsll->end());
+  // 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()),
+            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);
 
   root->SetBounds(gfx::Size(100, 100));
@@ skipping 370 matching lines @@
 
   // 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