cc: Consolidate LayerList types.

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 "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/base/thread.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
+#include "cc/layers/render_surface.h"
+#include "cc/layers/render_surface_impl.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/quad_f.h"
@@ skipping 52 matching lines @@
                                                   bounds,
                                                   preserves3d);
   layer->SetContentBounds(bounds);
 }
 
 void ExecuteCalculateDrawProperties(Layer* root_layer,
                                     float device_scale_factor,
                                     float page_scale_factor,
                                     bool can_use_lcd_text) {
   gfx::Transform identity_matrix;
-  std::vector<scoped_refptr<Layer> > dummy_render_surface_layer_list;
+  LayerList dummy_render_surface_layer_list;
   int dummy_max_texture_size = 512;
   gfx::Size device_viewport_size =
       gfx::Size(root_layer->bounds().width() * device_scale_factor,
                 root_layer->bounds().height() * device_scale_factor);
 
   // We are probably not testing what is intended if the root_layer bounds are
   // empty.
   DCHECK(!root_layer->bounds().IsEmpty());
   LayerTreeHostCommon::CalculateDrawProperties(
       root_layer,
       device_viewport_size,
       device_scale_factor,
       page_scale_factor,
       dummy_max_texture_size,
       can_use_lcd_text,
       &dummy_render_surface_layer_list);
 }
 
 void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
                                     float device_scale_factor,
                                     float page_scale_factor,
                                     bool can_use_lcd_text) {
   gfx::Transform identity_matrix;
-  std::vector<LayerImpl*> dummy_render_surface_layer_list;
+  LayerImplList dummy_render_surface_layer_list;
   int dummy_max_texture_size = 512;
   gfx::Size device_viewport_size =
       gfx::Size(root_layer->bounds().width() * device_scale_factor,
                 root_layer->bounds().height() * device_scale_factor);
 
   // We are probably not testing what is intended if the root_layer bounds are
   // empty.
   DCHECK(!root_layer->bounds().IsEmpty());
   LayerTreeHostCommon::CalculateDrawProperties(root_layer,
                                                device_viewport_size,
@@ skipping 1420 matching lines @@
                                gfx::PointF(),
                                gfx::PointF(30.f, 30.f),
                                gfx::Size(10, 10),
                                false);
 
   parent->AddChild(render_surface1);
   parent->SetMasksToBounds(true);
   render_surface1->AddChild(child);
   render_surface1->SetForceRenderSurface(true);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
   // The child layer's content is entirely outside the parent's clip rect, so
@@ skipping 26 matching lines @@
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false);
 
   parent->AddChild(render_surface1);
   render_surface1->AddChild(child);
   render_surface1->SetForceRenderSurface(true);
   render_surface1->SetOpacity(0.f);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
   // Since the layer is transparent, render_surface1->render_surface() should
@@ skipping 36 matching lines @@
                                gfx::Size(10, 10),
                                false);
 
   parent->AddChild(render_surface1);
   render_surface1->AddChild(child);
 
   // Sanity check before the actual test
   EXPECT_FALSE(parent->render_surface());
   EXPECT_FALSE(render_surface1->render_surface());
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
   // The root layer always creates a render surface
@@ skipping 786 matching lines @@
                                gfx::PointF(),
                                gfx::Size(20, 20),
                                false);
 
   child->SetMasksToBounds(true);
   child->SetOpacity(0.4f);
   child->SetForceRenderSurface(true);
   grand_child->SetOpacity(0.5f);
   great_grand_child->SetOpacity(0.4f);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
   ASSERT_EQ(2U, render_surface_layer_list.size());
@@ skipping 58 matching lines @@
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false);
 
   parent->SetMasksToBounds(true);
   child->SetOpacity(0.4f);
   child->SetForceRenderSurface(true);
   grand_child->SetOpacity(0.4f);
   grand_child->SetForceRenderSurface(true);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
   // Without an animation, we should cull child and grand_child from the
@@ skipping 103 matching lines @@
                                false);
   SetLayerPropertiesForTesting(leaf_node2.get(),
                                identity_matrix,
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false);
 
   // Case 1: nothing is clipped except the root render surface.
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
   ASSERT_TRUE(root->render_surface());
@@ skipping 138 matching lines @@
   child->SetMasksToBounds(true);
   grand_child3->SetMasksToBounds(true);
 
   // Force everyone to be a render surface.
   child->SetOpacity(0.4f);
   grand_child1->SetOpacity(0.5f);
   grand_child2->SetOpacity(0.5f);
   grand_child3->SetOpacity(0.5f);
   grand_child4->SetOpacity(0.5f);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
   EXPECT_RECT_EQ(gfx::Rect(5, 5, 10, 10),
@@ skipping 122 matching lines @@
   child->SetForceRenderSurface(true);
   grand_child1->SetOpacity(0.5f);
   grand_child1->SetForceRenderSurface(true);
   grand_child2->SetOpacity(0.5f);
   grand_child2->SetForceRenderSurface(true);
   grand_child3->SetOpacity(0.5f);
   grand_child3->SetForceRenderSurface(true);
   grand_child4->SetOpacity(0.5f);
   grand_child4->SetForceRenderSurface(true);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
   ASSERT_TRUE(grand_child1->render_surface());
@@ skipping 1276 matching lines @@
                                gfx::Size(100, 100),
                                false);
   SetLayerPropertiesForTesting(back_facing_child_of_back_facing_surface.get(),
                                backface_matrix,
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
   // Verify which render surfaces were created.
@@ skipping 171 matching lines @@
                                gfx::Size(100, 100),
                                false);
   SetLayerPropertiesForTesting(back_facing_child_of_back_facing_surface.get(),
                                backface_matrix,
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
   // Verify which render surfaces were created.
@@ skipping 117 matching lines @@
                                gfx::Size(100, 100),
                                false);
   SetLayerPropertiesForTesting(child2.get(),
                                identity_matrix,
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
   EXPECT_FALSE(child->render_surface());
@@ skipping 105 matching lines @@
                                gfx::Size(100, 100),
                                false);
   SetLayerPropertiesForTesting(child2.get(),
                                identity_matrix,
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
   // Verify which render surfaces were created.
@@ skipping 23 matching lines @@
       front_facing_surface->id(),
       render_surface_layer_list[1]->render_surface()->layer_list()[0]->id());
   EXPECT_EQ(
       child1->id(),
       render_surface_layer_list[1]->render_surface()->layer_list()[1]->id());
 }
 
 TEST(LayerTreeHostCommonTest, HitTestingForEmptyLayerList) {
   // Hit testing on an empty render_surface_layer_list should return a null
   // pointer.
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
 
   gfx::Point test_point(0, 0);
   LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(10, 20);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   EXPECT_FALSE(result_layer);
@@ skipping 11 matching lines @@
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                identity_matrix,
                                anchor,
                                position,
                                bounds,
                                false);
   root->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 54 matching lines @@
                                identity_matrix,
                                anchor,
                                position,
                                hud_bounds,
                                false);
   hud->SetDrawsContent(true);
 
   host_impl.active_tree()->set_hud_layer(hud.get());
   root->AddChild(hud.PassAs<LayerImpl>());
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                hud_bounds,
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 46 matching lines @@
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                uninvertible_transform,
                                identity_matrix,
                                anchor,
                                position,
                                bounds,
                                false);
   root->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 55 matching lines @@
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                identity_matrix,
                                anchor,
                                position,
                                bounds,
                                false);
   root->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 44 matching lines @@
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                rotation45_degrees_about_center,
                                identity_matrix,
                                anchor,
                                position,
                                bounds,
                                false);
   root->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 57 matching lines @@
   SetLayerPropertiesForTesting(
       root.get(),
       perspective_projection_about_center * translation_by_z,
       identity_matrix,
       anchor,
       position,
       bounds,
       false);
   root->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 68 matching lines @@
                                  false);
 
     // override content bounds and contents scale
     test_layer->SetContentBounds(gfx::Size(100, 100));
     test_layer->SetContentsScale(2, 2);
 
     test_layer->SetDrawsContent(true);
     root->AddChild(test_layer.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 79 matching lines @@
                                  identity_matrix,
                                  anchor,
                                  position,
                                  bounds,
                                  false);
     child->SetDrawsContent(true);
     clipping_layer->AddChild(child.Pass());
     root->AddChild(clipping_layer.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 112 matching lines @@
                                  position,
                                  bounds,
                                  false);
     rotated_leaf->SetDrawsContent(true);
 
     grand_child->AddChild(rotated_leaf.Pass());
     child->AddChild(grand_child.Pass());
     root->AddChild(child.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 105 matching lines @@
                                  identity_matrix,
                                  anchor,
                                  position,
                                  bounds,
                                  false);
     child->SetDrawsContent(true);
     intermediate_layer->AddChild(child.Pass());
     root->AddChild(intermediate_layer.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 96 matching lines @@
 
     child1->AddChild(grand_child1.Pass());
     root->AddChild(child1.Pass());
     root->AddChild(child2.Pass());
   }
 
   LayerImpl* child1 = root->children()[0];
   LayerImpl* child2 = root->children()[1];
   LayerImpl* grand_child1 = child1->children()[0];
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 132 matching lines @@
 
     child1->AddChild(grand_child1.Pass());
     root->AddChild(child1.Pass());
     root->AddChild(child2.Pass());
   }
 
   LayerImpl* child1 = root->children()[0];
   LayerImpl* child2 = root->children()[1];
   LayerImpl* grand_child1 = child1->children()[0];
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 61 matching lines @@
   test_point = gfx::Point(20, 51);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 }
 
 TEST(LayerTreeHostCommonTest, HitCheckingTouchHandlerRegionsForEmptyLayerList) {
   // Hit checking on an empty render_surface_layer_list should return a null
   // pointer.
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
 
   gfx::Point test_point(0, 0);
   LayerImpl* result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point, render_surface_layer_list);
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(10, 20);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
@@ skipping 14 matching lines @@
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                identity_matrix,
                                anchor,
                                position,
                                bounds,
                                false);
   root->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 76 matching lines @@
   SetLayerPropertiesForTesting(root.get(),
                                uninvertible_transform,
                                identity_matrix,
                                anchor,
                                position,
                                bounds,
                                false);
   root->SetDrawsContent(true);
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 66 matching lines @@
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                identity_matrix,
                                anchor,
                                position,
                                bounds,
                                false);
   root->SetDrawsContent(true);
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 84 matching lines @@
 
     // override content bounds and contents scale
     test_layer->SetContentBounds(gfx::Size(100, 100));
     test_layer->SetContentsScale(2, 2);
 
     test_layer->SetDrawsContent(true);
     test_layer->SetTouchEventHandlerRegion(touch_handler_region);
     root->AddChild(test_layer.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 87 matching lines @@
                                  anchor,
                                  position,
                                  bounds,
                                  false);
 
     test_layer->SetDrawsContent(true);
     test_layer->SetTouchEventHandlerRegion(touch_handler_region);
     root->AddChild(test_layer.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   float device_scale_factor = 3.f;
   float page_scale_factor = 5.f;
   gfx::Transform page_scale_transform;
   page_scale_transform.Scale(page_scale_factor, page_scale_factor);
   // Applying the page_scale_factor through impl_transform.
   root->SetImplTransform(page_scale_transform);
   gfx::Size scaled_bounds_for_root = gfx::ToCeiledSize(
       gfx::ScaleSize(root->bounds(), device_scale_factor * page_scale_factor));
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
@@ skipping 126 matching lines @@
                                  anchor,
                                  position,
                                  bounds,
                                  false);
     child->SetDrawsContent(true);
     child->SetTouchEventHandlerRegion(touch_handler_region);
     clipping_layer->AddChild(child.Pass());
     root->AddChild(clipping_layer.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
@@ skipping 115 matching lines @@
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                true);
 
   parent->AddChild(child);
   parent->AddChild(child_empty);
   parent->AddChild(child_no_scale);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 1.f;
 
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                device_scale_factor,
                                                page_scale_factor,
                                                dummy_max_texture_size,
@@ skipping 114 matching lines @@
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                true);
 
   perspective_surface->SetForceRenderSurface(true);
   scale_surface->SetForceRenderSurface(true);
 
   parent->AddChild(perspective_surface);
   parent->AddChild(scale_surface);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 3.f;
 
   gfx::Transform page_scale_transform;
   page_scale_transform.Scale(page_scale_factor, page_scale_factor);
   parent->SetImplTransform(page_scale_transform);
 
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
@@ skipping 82 matching lines @@
                                identity_matrix,
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(13, 13),
                                true);
 
   parent->AddChild(child);
   parent->AddChild(child_no_scale);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 1.7f;
   float page_scale_factor = 1.f;
 
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                device_scale_factor,
                                                page_scale_factor,
                                                dummy_max_texture_size,
@@ skipping 130 matching lines @@
 
   // FIXME: Remove this when page_scale_factor is applied in the compositor.
   // Page scale should not apply to the parent.
   parent->SetBoundsContainPageScale(true);
 
   parent->AddChild(child_scale);
   parent->AddChild(child_empty);
   parent->AddChild(child_no_scale);
   parent->AddChild(child_no_auto_scale);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 1.f;
 
   // FIXME: Remove this when page_scale_factor is applied in the compositor.
   gfx::Transform page_scale_matrix;
   page_scale_matrix.Scale(page_scale_factor, page_scale_factor);
   parent->SetSublayerTransform(page_scale_matrix);
 
@@ skipping 153 matching lines @@
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                true);
 
   // FIXME: Remove this when page_scale_factor is applied in the compositor.
   // Page scale should not apply to the parent.
   parent->SetBoundsContainPageScale(true);
 
   parent->AddChild(child_scale);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 0.01f;
 
   // FIXME: Remove this when page_scale_factor is applied in the compositor.
   gfx::Transform page_scale_matrix;
   page_scale_matrix.Scale(page_scale_factor, page_scale_factor);
   parent->SetSublayerTransform(page_scale_matrix);
 
@@ skipping 160 matching lines @@
   surface_scale->AddChild(surface_scale_child_no_scale);
 
   surface_no_scale->SetForceRenderSurface(true);
   surface_no_scale->AddChild(surface_no_scale_child_scale);
   surface_no_scale->AddChild(surface_no_scale_child_no_scale);
 
   surface_no_auto_scale->SetForceRenderSurface(true);
   surface_no_auto_scale->AddChild(surface_no_auto_scale_child_scale);
   surface_no_auto_scale->AddChild(surface_no_auto_scale_child_no_scale);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   double device_scale_factor = 5;
   double page_scale_factor = 7;
 
   // FIXME: Remove this when page_scale_factor is applied in the compositor.
   gfx::Transform page_scale_matrix;
   page_scale_matrix.Scale(page_scale_factor, page_scale_factor);
   parent->SetSublayerTransform(page_scale_matrix);
 
@@ skipping 188 matching lines @@
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                true);
 
   parent->AddChild(child_scale);
 
   // Now put an animating transform on child.
   int animation_id = AddAnimatedTransformToController(
       child_scale->layer_animation_controller(), 10.0, 30, 0);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
@@ skipping 62 matching lines @@
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                true);
 
   parent->AddChild(child);
   child->AddChild(duplicate_child_non_owner);
   child->SetReplicaLayer(replica.get());
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 1.5f;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                device_scale_factor,
                                                1,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
@@ skipping 114 matching lines @@
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(13, 11),
                                true);
 
   parent->AddChild(child);
   child->AddChild(duplicate_child_non_owner);
   child->SetReplicaLayer(replica.get());
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 1.7f;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                device_scale_factor,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
@@ skipping 240 matching lines @@
   EXPECT_EQ(can_use_lcd_text_, child_->can_use_lcd_text());
   EXPECT_EQ(can_use_lcd_text_, grand_child_->can_use_lcd_text());
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostCommonTest,
                         LCDTextTest,
                         testing::Combine(testing::Bool(), testing::Bool()));
 
 }  // namespace
 }  // namespace cc