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

cc/trees/layer_tree_impl_unittest.cc

 // Copyright 2014 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_impl.h"
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 18 matching lines @@
 };
 
 class LayerTreeImplTest : public testing::Test {
  public:
   LayerTreeImplTest() : impl_test_(LayerTreeImplTestSettings()) {}
 
   FakeLayerTreeHostImpl& host_impl() const { return *impl_test_.host_impl(); }
 
   LayerImpl* root_layer() { return impl_test_.root_layer_for_testing(); }
 
-  const LayerImplList& RenderSurfaceLayerList() const {
-    return host_impl().active_tree()->RenderSurfaceLayerList();
+  const RenderSurfaceList& GetRenderSurfaceList() const {
+    return host_impl().active_tree()->GetRenderSurfaceList();
   }
 
   void ExecuteCalculateDrawProperties(LayerImpl* root_layer) {
     // We are probably not testing what is intended if the root_layer bounds are
     // empty.
     DCHECK(!root_layer->bounds().IsEmpty());
 
-    render_surface_layer_list_impl_.clear();
+    render_surface_list_impl_.clear();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root_layer, root_layer->bounds(), &render_surface_layer_list_impl_);
+        root_layer, root_layer->bounds(), &render_surface_list_impl_);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
   }
 
   int HitTestSimpleTree(int root_id,
                         int left_child_id,
                         int right_child_id,
                         int root_sorting_context,
                         int left_child_sorting_context,
                         int right_child_sorting_context,
@@ skipping 37 matching lines @@
       right_child->SetBounds(bounds);
       right_child->SetDrawsContent(true);
     }
 
     root->test_properties()->AddChild(std::move(left_child));
     root->test_properties()->AddChild(std::move(right_child));
 
     host_impl().SetViewportSize(root->bounds());
     host_impl().active_tree()->SetRootLayerForTesting(std::move(root));
     host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
-    CHECK_EQ(1u, RenderSurfaceLayerList().size());
+    CHECK_EQ(1u, GetRenderSurfaceList().size());
 
     gfx::PointF test_point = gfx::PointF(1.f, 1.f);
     LayerImpl* result_layer =
         host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 
     CHECK(result_layer);
     return result_layer->id();
   }
 
  private:
   LayerTestCommon::LayerImplTest impl_test_;
-  std::vector<LayerImpl*> render_surface_layer_list_impl_;
+  RenderSurfaceList render_surface_list_impl_;
 };
 
 TEST_F(LayerTreeImplTest, HitTestingForSingleLayer) {
   gfx::Size bounds(100, 100);
   LayerImpl* root = root_layer();
   root->SetBounds(bounds);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root_layer()->GetRenderSurface()->layer_list().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(1, root_layer()->GetRenderSurface()->num_contributors());
 
   // Hit testing for a point outside the layer should return a null pointer.
   gfx::PointF test_point(101.f, 101.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::PointF(-1.f, -1.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
@@ skipping 47 matching lines @@
       HeadsUpDisplayLayerImpl::Create(host_impl().active_tree(), 11111);
   hud->SetBounds(gfx::Size(200, 200));
   hud->SetDrawsContent(true);
 
   host_impl().SetViewportSize(hud->bounds());
   host_impl().active_tree()->set_hud_layer(hud.get());
   root->test_properties()->AddChild(std::move(hud));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(2u, root_layer()->GetRenderSurface()->layer_list().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(2, root_layer()->GetRenderSurface()->num_contributors());
 
   // Hit testing for a point inside HUD, but outside root should return null
   gfx::PointF test_point(101.f, 101.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::PointF(-1.f, -1.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
@@ skipping 23 matching lines @@
   ASSERT_FALSE(uninvertible_transform.IsInvertible());
 
   LayerImpl* root = root_layer();
   root->test_properties()->transform = uninvertible_transform;
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root_layer()->GetRenderSurface()->layer_list().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(1, root_layer()->GetRenderSurface()->num_contributors());
   ASSERT_FALSE(root_layer()->ScreenSpaceTransform().IsInvertible());
 
   // Hit testing any point should not hit the layer. If the invertible matrix is
   // accidentally ignored and treated like an identity, then the hit testing
   // will incorrectly hit the layer when it shouldn't.
   gfx::PointF test_point(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
@@ skipping 33 matching lines @@
   // layer is located.
   LayerImpl* root = root_layer();
   root->SetPosition(gfx::PointF(50.f, 50.f));
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root_layer()->GetRenderSurface()->layer_list().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(1, root_layer()->GetRenderSurface()->num_contributors());
 
   // Hit testing for a point outside the layer should return a null pointer.
   gfx::PointF test_point(49.f, 49.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   // Even though the layer exists at (101, 101), it should not be visible there
   // since the root render surface would clamp it.
   test_point = gfx::PointF(101.f, 101.f);
@@ skipping 23 matching lines @@
 
   LayerImpl* root = root_layer();
   root->test_properties()->transform = rotation45_degrees_about_center;
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root_layer()->GetRenderSurface()->layer_list().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(1, root_layer()->GetRenderSurface()->num_contributors());
 
   // Hit testing for points outside the layer.
   // These corners would have been inside the un-transformed layer, but they
   // should not hit the correctly transformed layer.
   gfx::PointF test_point(99.f, 99.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::PointF(1.f, 1.f);
@@ skipping 146 matching lines @@
   LayerImpl* root = root_layer();
   root->test_properties()->transform =
       (perspective_projection_about_center * translation_by_z);
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root_layer()->GetRenderSurface()->layer_list().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(1, root_layer()->GetRenderSurface()->num_contributors());
 
   // Hit testing for points outside the layer.
   // These corners would have been inside the un-transformed layer, but they
   // should not hit the correctly transformed layer.
   gfx::PointF test_point(24.f, 24.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::PointF(76.f, 76.f);
@@ skipping 36 matching lines @@
     child->SetBounds(gfx::Size(300, 300));
     child->SetDrawsContent(true);
     clipping_layer->test_properties()->AddChild(std::move(child));
     root->test_properties()->AddChild(std::move(clipping_layer));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root_layer()->GetRenderSurface()->layer_list().size());
-  ASSERT_EQ(456, root_layer()->GetRenderSurface()->layer_list().at(0)->id());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(1, root_layer()->GetRenderSurface()->num_contributors());
+  LayerImpl* child_layer = host_impl().active_tree()->LayerById(456);
+  EXPECT_TRUE(child_layer->is_drawn_render_surface_layer_list_member());
 
   // Hit testing for a point outside the layer should return a null pointer.
   // Despite the child layer being very large, it should be clipped to the root
   // layer's bounds.
   gfx::PointF test_point(24.f, 24.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   // Even though the layer exists at (101, 101), it should not be visible there
@@ skipping 154 matching lines @@
     child->SetBounds(gfx::Size(20, 20));
     child->SetDrawsContent(true);
     intermediate_layer->test_properties()->AddChild(std::move(child));
     root->test_properties()->AddChild(std::move(intermediate_layer));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root_layer()->GetRenderSurface()->layer_list().size());
-  ASSERT_EQ(456, root_layer()->GetRenderSurface()->layer_list().at(0)->id());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(1, root_layer()->GetRenderSurface()->num_contributors());
+  LayerImpl* child_layer = host_impl().active_tree()->LayerById(456);
+  EXPECT_TRUE(child_layer->is_drawn_render_surface_layer_list_member());
 
   // Hit testing for a point outside the layer should return a null pointer.
   gfx::PointF test_point(69.f, 69.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::PointF(91.f, 91.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
@@ skipping 57 matching lines @@
   LayerImpl* child2 = root->test_properties()->children[1];
   LayerImpl* grand_child1 = child1->test_properties()->children[0];
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_TRUE(child1);
   ASSERT_TRUE(child2);
   ASSERT_TRUE(grand_child1);
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
 
   RenderSurfaceImpl* root_render_surface = root->GetRenderSurface();
-  ASSERT_EQ(4u, root_render_surface->layer_list().size());
-  ASSERT_EQ(1, root_render_surface->layer_list().at(0)->id());  // root layer
-  ASSERT_EQ(2, root_render_surface->layer_list().at(1)->id());  // child1
-  ASSERT_EQ(4, root_render_surface->layer_list().at(2)->id());  // grand_child1
-  ASSERT_EQ(3, root_render_surface->layer_list().at(3)->id());  // child2
+  ASSERT_EQ(4, root_render_surface->num_contributors());
+  EXPECT_TRUE(root_layer()->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(child1->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(child2->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(grand_child1->is_drawn_render_surface_layer_list_member());
 
   // Nothing overlaps the root at (1, 1), so hit testing there should find
   // the root layer.
   gfx::PointF test_point = gfx::PointF(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(1, result_layer->id());
 
   // At (15, 15), child1 and root are the only layers. child1 is expected to be
@@ skipping 124 matching lines @@
   LayerImpl* child2 = root->test_properties()->children[1];
   LayerImpl* grand_child1 = child1->test_properties()->children[0];
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_TRUE(child1);
   ASSERT_TRUE(child2);
   ASSERT_TRUE(grand_child1);
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
 
   // Nothing overlaps the root_layer at (1, 1), so hit testing there should find
   // the root layer.
   gfx::PointF test_point = gfx::PointF(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(1, result_layer->id());
 
   // At (15, 15), child1 and root are the only layers. child1 is expected to be
@@ skipping 179 matching lines @@
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_TRUE(child1);
   ASSERT_TRUE(child2);
   ASSERT_TRUE(grand_child1);
   ASSERT_TRUE(child1->GetRenderSurface());
   ASSERT_TRUE(child2->GetRenderSurface());
   ASSERT_TRUE(grand_child1->GetRenderSurface());
-  ASSERT_EQ(4u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(4u, GetRenderSurfaceList().size());
   // The root surface has the root layer, and child1's and child2's render
   // surfaces.
-  ASSERT_EQ(3u, root->GetRenderSurface()->layer_list().size());
+  ASSERT_EQ(3, root->GetRenderSurface()->num_contributors());
   // The child1 surface has the child1 layer and grand_child1's render surface.
-  ASSERT_EQ(2u, child1->GetRenderSurface()->layer_list().size());
-  ASSERT_EQ(1u, child2->GetRenderSurface()->layer_list().size());
-  ASSERT_EQ(1u, grand_child1->GetRenderSurface()->layer_list().size());
-  ASSERT_EQ(1, RenderSurfaceLayerList().at(0)->id());  // root layer
-  ASSERT_EQ(2, RenderSurfaceLayerList()[1]->id());     // child1
-  ASSERT_EQ(4, RenderSurfaceLayerList().at(2)->id());  // grand_child1
-  ASSERT_EQ(3, RenderSurfaceLayerList()[3]->id());     // child2
+  ASSERT_EQ(2, child1->GetRenderSurface()->num_contributors());
+  ASSERT_EQ(1, child2->GetRenderSurface()->num_contributors());
+  ASSERT_EQ(1, grand_child1->GetRenderSurface()->num_contributors());
+  EXPECT_TRUE(root_layer()->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(child1->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(grand_child1->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(child2->is_drawn_render_surface_layer_list_member());
 
   // Nothing overlaps the root at (1, 1), so hit testing there should find
   // the root layer.
   gfx::PointF test_point(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(1, result_layer->id());
 
   // At (15, 15), child1 and root are the only layers. child1 is expected to be
@@ skipping 40 matching lines @@
   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
 
   LayerImpl* root = root_layer();
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root->GetRenderSurface()->layer_list().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(1, root->GetRenderSurface()->num_contributors());
 
   // Hit checking for any point should return a null pointer for a layer without
   // any touch event handler regions.
   gfx::PointF test_point(11.f, 11.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
   root->SetTouchEventHandlerRegion(touch_handler_region);
@@ skipping 55 matching lines @@
   LayerImpl* root = root_layer();
   root->test_properties()->transform = uninvertible_transform;
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root->GetRenderSurface()->layer_list().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(1, root->GetRenderSurface()->num_contributors());
   ASSERT_FALSE(root->ScreenSpaceTransform().IsInvertible());
 
   // Hit checking any point should not hit the touch handler region on the
   // layer. If the invertible matrix is accidentally ignored and treated like an
   // identity, then the hit testing will incorrectly hit the layer when it
   // shouldn't.
   gfx::PointF test_point(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
@@ skipping 45 matching lines @@
   LayerImpl* root = root_layer();
   root->SetPosition(gfx::PointF(50.f, 50.f));
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root->GetRenderSurface()->layer_list().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(1, root->GetRenderSurface()->num_contributors());
 
   // Hit checking for a point outside the layer should return a null pointer.
   gfx::PointF test_point(49.f, 49.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
   // Even though the layer has a touch handler region containing (101, 101), it
   // should not be visible there since the root render surface would clamp it.
@@ skipping 63 matching lines @@
   host_impl().active_tree()->BuildLayerListAndPropertyTreesForTesting();
   host_impl().active_tree()->PushPageScaleFromMainThread(
       page_scale_factor, page_scale_factor, max_page_scale_factor);
   host_impl().active_tree()->SetPageScaleOnActiveTree(page_scale_factor);
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   // The visible content rect for test_layer is actually 100x100, even though
   // its layout size is 50x50, positioned at 25x25.
   LayerImpl* test_layer = root->test_properties()->children[0];
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root->GetRenderSurface()->layer_list().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(1, root->GetRenderSurface()->num_contributors());
 
   // Check whether the child layer fits into the root after scaled.
   EXPECT_EQ(gfx::Rect(test_layer->bounds()), test_layer->visible_layer_rect());
 
   // Hit checking for a point outside the layer should return a null pointer
   // (the root layer does not have a touch event handler, so it will not be
   // tested either).
   gfx::PointF test_point(76.f, 76.f);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
@@ skipping 105 matching lines @@
     child->SetDrawsContent(true);
     child->SetTouchEventHandlerRegion(touch_handler_region);
     clipping_layer->test_properties()->AddChild(std::move(child));
     root->test_properties()->AddChild(std::move(clipping_layer));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root->GetRenderSurface()->layer_list().size());
-  ASSERT_EQ(456, root->GetRenderSurface()->layer_list().at(0)->id());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(1, root->GetRenderSurface()->num_contributors());
+  LayerImpl* child_layer = host_impl().active_tree()->LayerById(456);
+  EXPECT_TRUE(child_layer->is_drawn_render_surface_layer_list_member());
 
   // Hit checking for a point outside the layer should return a null pointer.
   // Despite the child layer being very large, it should be clipped to the root
   // layer's bounds.
   gfx::PointF test_point(24.f, 24.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
@@ skipping 73 matching lines @@
   host_impl().active_tree()->SetDeviceScaleFactor(device_scale_factor);
   host_impl().active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 1, 1,
                                                       Layer::INVALID_ID);
   host_impl().active_tree()->BuildLayerListAndPropertyTreesForTesting();
   host_impl().active_tree()->PushPageScaleFromMainThread(
       page_scale_factor, page_scale_factor, max_page_scale_factor);
   host_impl().active_tree()->SetPageScaleOnActiveTree(page_scale_factor);
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(2u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(2u, GetRenderSurfaceList().size());
 
   // Hit checking for a point outside the layer should return a null pointer.
   // Despite the child layer being very large, it should be clipped to the root
   // layer's bounds.
   gfx::PointF test_point(24.f, 24.f);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
@@ skipping 36 matching lines @@
     notouch_layer->SetPosition(gfx::PointF(0, 25));
     notouch_layer->SetBounds(gfx::Size(50, 50));
     notouch_layer->SetDrawsContent(true);
     root->test_properties()->AddChild(std::move(notouch_layer));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(2u, root->GetRenderSurface()->layer_list().size());
-  ASSERT_EQ(123, root->GetRenderSurface()->layer_list().at(0)->id());
-  ASSERT_EQ(1234, root->GetRenderSurface()->layer_list().at(1)->id());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(2, root->GetRenderSurface()->num_contributors());
+  LayerImpl* touch_layer = host_impl().active_tree()->LayerById(123);
+  LayerImpl* notouch_layer = host_impl().active_tree()->LayerById(1234);
+  EXPECT_TRUE(touch_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(notouch_layer->is_drawn_render_surface_layer_list_member());
 
   gfx::PointF test_point(35.f, 35.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
 
   // We should have passed through the no-touch layer and found the layer
   // behind it.
   EXPECT_TRUE(result_layer);
 
@@ skipping 32 matching lines @@
         LayerImpl::Create(host_impl().active_tree(), 12345);
     test_layer->SetBounds(gfx::Size(50, 50));
     test_layer->SetDrawsContent(false);
     test_layer->SetTouchEventHandlerRegion(touch_handler_region);
     root->test_properties()->AddChild(std::move(test_layer));
   }
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   LayerImpl* test_layer = root->test_properties()->children[0];
-  // As test_layer doesn't draw content, the layer list of root's render surface
-  // should contain only the root layer.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root->GetRenderSurface()->layer_list().size());
+  // As test_layer doesn't draw content, it shouldn't contribute content to the
+  // root surface.
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  EXPECT_FALSE(test_layer->is_drawn_render_surface_layer_list_member());
 
   // Hit testing for a point outside the test layer should return null pointer.
   // We also implicitly check that the updated screen space transform of a layer
   // that is not in drawn render surface layer list (test_layer) is used during
   // hit testing (becuase the point is inside test_layer with respect to the old
   // screen space transform).
   gfx::PointF test_point(24.f, 24.f);
   test_layer->SetPosition(gfx::PointF(25.f, 25.f));
   gfx::Transform expected_screen_space_transform;
   expected_screen_space_transform.Translate(25.f, 25.f);
@@ skipping 36 matching lines @@
 
 TEST_F(LayerTreeImplTest, SelectionBoundsForSingleLayer) {
   LayerImpl* root = root_layer();
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(1u, root->GetRenderSurface()->layer_list().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
+  ASSERT_EQ(1, root->GetRenderSurface()->num_contributors());
 
   LayerSelection input;
 
   input.start.type = gfx::SelectionBound::LEFT;
   input.start.edge_top = gfx::Point(10, 10);
   input.start.edge_bottom = gfx::Point(10, 20);
   input.start.layer_id = root->id();
 
   input.end.type = gfx::SelectionBound::RIGHT;
   input.end.edge_top = gfx::Point(50, 10);
@@ skipping 59 matching lines @@
     clipped_layer->SetBounds(gfx::Size(100, 100));
     clipped_layer->SetDrawsContent(true);
     clipping_layer->test_properties()->AddChild(std::move(clipped_layer));
     root->test_properties()->AddChild(std::move(clipping_layer));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
 
   LayerSelection input;
   input.start.type = gfx::SelectionBound::LEFT;
   input.start.edge_top = gfx::Point(25, 10);
   input.start.edge_bottom = gfx::Point(25, 30);
   input.start.layer_id = clipped_layer_id;
 
   input.end.type = gfx::SelectionBound::RIGHT;
   input.end.edge_top = gfx::Point(75, 10);
   input.end.edge_bottom = gfx::Point(75, 30);
@@ skipping 117 matching lines @@
   host_impl().active_tree()->SetDeviceScaleFactor(device_scale_factor);
   host_impl().active_tree()->SetPageScaleOnActiveTree(page_scale_factor);
   host_impl().active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 1, 1,
                                                       Layer::INVALID_ID);
   host_impl().active_tree()->PushPageScaleFromMainThread(
       page_scale_factor, page_scale_factor, page_scale_factor);
   host_impl().active_tree()->SetPageScaleOnActiveTree(page_scale_factor);
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, GetRenderSurfaceList().size());
 
   LayerSelection input;
   input.start.type = gfx::SelectionBound::LEFT;
   input.start.edge_top = gfx::Point(10, 10);
   input.start.edge_bottom = gfx::Point(10, 30);
   input.start.layer_id = root_layer_id;
 
   input.end.type = gfx::SelectionBound::RIGHT;
   input.end.edge_top = gfx::Point(0, 0);
   input.end.edge_bottom = gfx::Point(0, 20);
@@ skipping 147 matching lines @@
     translate_z.Translate3d(0, 0, 10);
     right_child->test_properties()->transform = translate_z;
     right_child->SetBounds(gfx::Size(100, 100));
   }
 
   root->test_properties()->AddChild(std::move(left_child));
   root->test_properties()->AddChild(std::move(right_child));
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
-  CHECK_EQ(1u, RenderSurfaceLayerList().size());
+  CHECK_EQ(1u, GetRenderSurfaceList().size());
 
   gfx::PointF test_point = gfx::PointF(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 
   CHECK(result_layer);
   EXPECT_EQ(2, result_layer->id());
 }
 
 namespace {
@@ skipping 99 matching lines @@
     auto weak_promise = promise->AsWeakPtr();
     host_impl().active_tree()->QueueSwapPromise(std::move(promise));
     host_impl().active_tree()->BreakSwapPromises(
         SwapPromise::DidNotSwapReason::SWAP_FAILS);
     EXPECT_FALSE(weak_promise);
   }
 }
 
 }  // namespace
 }  // namespace cc