Use custom ListContainer to allocate DrawQuads

cc/layers/tiled_layer_impl_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/layers/tiled_layer_impl.h"
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/layer_tiling_data.h"
 #include "cc/test/fake_impl_proxy.h"
@@ skipping 154 matching lines @@
   // No checkerboarding
   {
     MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
     AppendQuadsData data;
     layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
     EXPECT_EQ(render_pass->quad_list.size(), 4u);
     EXPECT_EQ(0u, data.num_missing_tiles);
 
-    for (size_t i = 0; i < render_pass->quad_list.size(); ++i)
-      EXPECT_EQ(render_pass->quad_list[i]->material, DrawQuad::TILED_CONTENT);
+    for (QuadList::Iterator iter = render_pass->quad_list.begin();
+         iter != render_pass->quad_list.end();
+         ++iter)
+      EXPECT_EQ(iter->material, DrawQuad::TILED_CONTENT);
   }
 
   for (int i = 0; i < num_tiles_x; ++i)
     for (int j = 0; j < num_tiles_y; ++j)
       layer->PushTileProperties(i, j, 0, gfx::Rect(), false);
 
   // All checkerboarding
   {
     MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
     AppendQuadsData data;
     layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
     EXPECT_LT(0u, data.num_missing_tiles);
     EXPECT_EQ(render_pass->quad_list.size(), 4u);
-    for (size_t i = 0; i < render_pass->quad_list.size(); ++i)
-      EXPECT_NE(render_pass->quad_list[i]->material, DrawQuad::TILED_CONTENT);
+    for (QuadList::Iterator iter = render_pass->quad_list.begin();
+         iter != render_pass->quad_list.end();
+         ++iter)
+      EXPECT_NE(iter->material, DrawQuad::TILED_CONTENT);
   }
 }
 
 // Test with both border texels and without.
 #define WITH_AND_WITHOUT_BORDER_TEST(text_fixture_name)                        \
   TEST_F(TiledLayerImplBorderTest, text_fixture_name##NoBorders) {             \
     text_fixture_name(LayerTilingData::NO_BORDER_TEXELS);                      \
   }                                                                            \
   TEST_F(TiledLayerImplBorderTest, text_fixture_name##HasBorders) {            \
     text_fixture_name(LayerTilingData::HAS_BORDER_TEXELS);                     \
@@ skipping 55 matching lines @@
 TEST_F(TiledLayerImplTest, TextureInfoForLayerNoBorders) {
   gfx::Size tile_size(50, 50);
   gfx::Size layer_size(250, 250);
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   GetQuads(render_pass.get(),
            tile_size,
            layer_size,
            LayerTilingData::NO_BORDER_TEXELS,
            gfx::Rect(layer_size));
 
-  for (size_t i = 0; i < render_pass->quad_list.size(); ++i) {
-    const TileDrawQuad* quad =
-        TileDrawQuad::MaterialCast(render_pass->quad_list[i]);
+  size_t i = 0;
+  for (QuadList::Iterator iter = render_pass->quad_list.begin();
+       iter != render_pass->quad_list.end();
+       ++iter) {
+    const TileDrawQuad* quad = TileDrawQuad::MaterialCast(&*iter);
 
     EXPECT_NE(0u, quad->resource_id) << LayerTestCommon::quad_string << i;
     EXPECT_EQ(gfx::RectF(gfx::PointF(), tile_size), quad->tex_coord_rect)
         << LayerTestCommon::quad_string << i;
     EXPECT_EQ(tile_size, quad->texture_size) << LayerTestCommon::quad_string
                                              << i;
     EXPECT_EQ(gfx::Size(1, 1).ToString(), quad->opaque_rect.size().ToString())
         << LayerTestCommon::quad_string << i;
+    ++i;
   }
 }
 
 TEST_F(TiledLayerImplTest, GPUMemoryUsage) {
   gfx::Size tile_size(20, 30);
   int num_tiles_x = 12;
   int num_tiles_y = 32;
   gfx::Size layer_size(tile_size.width() * num_tiles_x,
                        tile_size.height() * num_tiles_y);
 
@@ skipping 87 matching lines @@
         occluded,
         &partially_occluded_count);
     // The layer outputs one quad, which is partially occluded.
     EXPECT_EQ(100u - 10u, impl.quad_list().size());
     EXPECT_EQ(10u + 10u, partially_occluded_count);
   }
 }
 
 }  // namespace
 }  // namespace cc