cc: Consolidate LayerList types.

cc/trees/quad_culler_unittest.cc

 // Copyright 2012 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/quad_culler.h"
 
 #include <vector>
 
 #include "cc/base/math_util.h"
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/layers/append_quads_data.h"
+#include "cc/layers/render_surface_impl.h"
 #include "cc/layers/tiled_layer_impl.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/layer_tiling_data.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/trees/occlusion_tracker.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/transform.h"
@@ skipping 14 matching lines @@
     return scissor_rect_in_screen_;
   }
 
  private:
   gfx::Rect scissor_rect_in_screen_;
 
   DISALLOW_COPY_AND_ASSIGN(TestOcclusionTrackerImpl);
 };
 
 typedef LayerIterator<LayerImpl,
-                      std::vector<LayerImpl*>,
+                      LayerImplList,
                       RenderSurfaceImpl,
                       LayerIteratorActions::FrontToBack> LayerIteratorType;
 
 class QuadCullerTest : public testing::Test {
  public:
   QuadCullerTest()
       : host_impl_(&proxy_),
         layer_id_(1) {}
 
   scoped_ptr<TiledLayerImpl> MakeLayer(
       TiledLayerImpl* parent,
       const gfx::Transform& draw_transform,
       gfx::Rect layer_rect,
       float opacity,
       bool opaque,
       gfx::Rect layer_opaque_rect,
-      std::vector<LayerImpl*>& surface_layer_list) {
+      LayerImplList& surface_layer_list) {
     scoped_ptr<TiledLayerImpl> layer =
         TiledLayerImpl::Create(host_impl_.active_tree(), layer_id_++);
     scoped_ptr<LayerTilingData> tiler = LayerTilingData::Create(
         gfx::Size(100, 100), LayerTilingData::NO_BORDER_TEXELS);
     tiler->SetBounds(layer_rect.size());
     layer->SetTilingData(*tiler);
     layer->set_skips_draw(false);
     layer->draw_properties().target_space_transform = draw_transform;
     layer->draw_properties().screen_space_transform = draw_transform;
     layer->draw_properties().visible_content_rect = layer_rect;
@@ skipping 50 matching lines @@
   FakeImplProxy proxy_;
   FakeLayerTreeHostImpl host_impl_;
   int layer_id_;
 
   DISALLOW_COPY_AND_ASSIGN(QuadCullerTest);
 };
 
 #define DECLARE_AND_INITIALIZE_TEST_QUADS()                                    \
   QuadList quad_list;                                                          \
   SharedQuadStateList shared_state_list;                                       \
-  std::vector<LayerImpl*> render_surface_layer_list;                           \
+  LayerImplList render_surface_layer_list;                                     \
   gfx::Transform child_transform;                                              \
   gfx::Size root_size = gfx::Size(300, 300);                                   \
   gfx::Rect root_rect = gfx::Rect(root_size);                                  \
   gfx::Size child_size = gfx::Size(200, 200);                                  \
   gfx::Rect child_rect = gfx::Rect(child_size);
 
 TEST_F(QuadCullerTest, VerifyNoCulling) {
   DECLARE_AND_INITIALIZE_TEST_QUADS();
 
   scoped_ptr<TiledLayerImpl> root_layer =
@@ skipping 781 matching lines @@
   EXPECT_NEAR(
       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 0, 1);
   EXPECT_NEAR(
       occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(), 0, 1);
   EXPECT_NEAR(
       occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(), 0, 1);
 }
 
 }  // namespace
 }  // namespace cc