Use custom ListContainer to allocate DrawQuads

cc/test/layer_test_common.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/test/layer_test_common.h"
 
 #include "cc/base/math_util.h"
 #include "cc/base/region.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/render_pass.h"
+#include "cc/quads/render_pass_draw_quad.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/mock_occlusion_tracker.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
@@ skipping 11 matching lines @@
       gfx::ToFlooredSize(r.size()) == r.size())
     return true;
 
   return false;
 }
 
 void LayerTestCommon::VerifyQuadsExactlyCoverRect(const QuadList& quads,
                                                   const gfx::Rect& rect) {
   Region remaining = rect;
 
-  for (size_t i = 0; i < quads.size(); ++i) {
-    DrawQuad* quad = quads[i];
+  size_t i = 0;
+  for (QuadList::ConstIterator iter = quads.begin(); iter != quads.end();
+       ++iter) {
+    const DrawQuad* quad = &*iter;
     gfx::RectF quad_rectf =
         MathUtil::MapClippedRect(quad->quadTransform(), gfx::RectF(quad->rect));
 
     // Before testing for exact coverage in the integer world, assert that
     // rounding will not round the rect incorrectly.
     ASSERT_TRUE(CanRectFBeSafelyRoundedToRect(quad_rectf));
 
     gfx::Rect quad_rect = gfx::ToEnclosingRect(quad_rectf);
 
     EXPECT_TRUE(rect.Contains(quad_rect)) << quad_string << i
                                           << " rect: " << rect.ToString()
                                           << " quad: " << quad_rect.ToString();
     EXPECT_TRUE(remaining.Contains(quad_rect))
         << quad_string << i << " remaining: " << remaining.ToString()
         << " quad: " << quad_rect.ToString();
     remaining.Subtract(quad_rect);
+
+    ++i;
   }
 
   EXPECT_TRUE(remaining.IsEmpty());
 }
 
 // static
 void LayerTestCommon::VerifyQuadsCoverRectWithOcclusion(
     const QuadList& quads,
     const gfx::Rect& rect,
     const gfx::Rect& occluded,
     size_t* partially_occluded_count) {
   // No quad should exist if it's fully occluded.
-  for (size_t i = 0; i < quads.size(); ++i) {
-    EXPECT_FALSE(occluded.Contains(quads[i]->visible_rect));
+  for (QuadList::ConstIterator iter = quads.begin(); iter != quads.end();
+       ++iter) {
+    EXPECT_FALSE(occluded.Contains(iter->visible_rect));
   }
 
   // Quads that are fully occluded on one axis only should be shrunken.
-  for (size_t i = 0; i < quads.size(); ++i) {
-    DrawQuad* quad = quads[i];
+  for (QuadList::ConstIterator iter = quads.begin(); iter != quads.end();
+       ++iter) {
+    const DrawQuad* quad = &*iter;
     DCHECK(quad->quadTransform().IsIdentityOrIntegerTranslation());
     gfx::Rect target_rect =
         MathUtil::MapEnclosingClippedRect(quad->quadTransform(), quad->rect);
     gfx::Rect target_visible_rect = MathUtil::MapEnclosingClippedRect(
         quad->quadTransform(), quad->visible_rect);
 
     bool fully_occluded_horizontal = target_rect.x() >= occluded.x() &&
                                      target_rect.right() <= occluded.right();
     bool fully_occluded_vertical = target_rect.y() >= occluded.y() &&
                                    target_rect.bottom() <= occluded.bottom();
@@ skipping 65 matching lines @@
   render_pass_->shared_quad_state_list.clear();
   occlusion_tracker_.set_occluded_target_rect_for_contributing_surface(
       occluded);
   bool for_replica = false;
   RenderPassId id(1, 1);
   surface_impl->AppendQuads(
       render_pass_.get(), occlusion_tracker_, &data, for_replica, id);
 }
 
 }  // namespace cc