Use custom ListContainer to allocate DrawQuads

cc/quads/render_pass.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/quads/render_pass.h"
 
 #include "base/debug/trace_event_argument.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/quads/checkerboard_draw_quad.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/io_surface_draw_quad.h"
+#include "cc/quads/largest_draw_quad.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
 
 namespace {
 const size_t kDefaultNumSharedQuadStatesToReserve = 32;
 const size_t kDefaultNumQuadsToReserve = 128;
 }
 
 namespace cc {
 
+QuadList::QuadList(size_t default_size_to_reserve)
+    : ListContainer<DrawQuad>(sizeof(kLargestDrawQuad),
+                              default_size_to_reserve) {
+}
+
 scoped_ptr<RenderPass> RenderPass::Create() {
   return make_scoped_ptr(new RenderPass());
 }
 
 scoped_ptr<RenderPass> RenderPass::Create(size_t num_layers) {
   return make_scoped_ptr(new RenderPass(num_layers));
 }
 
 RenderPass::RenderPass()
-    : id(RenderPassId(-1, -1)), has_transparent_background(true) {
+    : id(RenderPassId(-1, -1)),
+      has_transparent_background(true),
+      quad_list(kDefaultNumQuadsToReserve) {
   shared_quad_state_list.reserve(kDefaultNumSharedQuadStatesToReserve);
-  quad_list.reserve(kDefaultNumQuadsToReserve);
 }
 
 RenderPass::RenderPass(size_t num_layers)
-    : id(RenderPassId(-1, -1)), has_transparent_background(true) {
+    : id(RenderPassId(-1, -1)),
+      has_transparent_background(true),
+      quad_list(kDefaultNumQuadsToReserve) {
   // Each layer usually produces one shared quad state, so the number of layers
   // is a good hint for what to reserve here.
   shared_quad_state_list.reserve(num_layers);
-  quad_list.reserve(kDefaultNumQuadsToReserve);
 }
 
 RenderPass::~RenderPass() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
       "cc::RenderPass", id.AsTracingId());
 }
 
 scoped_ptr<RenderPass> RenderPass::Copy(RenderPassId new_id) const {
   scoped_ptr<RenderPass> copy_pass(Create());
@@ skipping 19 matching lines @@
     copy_pass->SetAll(source->id,
                       source->output_rect,
                       source->damage_rect,
                       source->transform_to_root_target,
                       source->has_transparent_background);
     for (size_t i = 0; i < source->shared_quad_state_list.size(); ++i) {
       SharedQuadState* copy_shared_quad_state =
           copy_pass->CreateAndAppendSharedQuadState();
       copy_shared_quad_state->CopyFrom(source->shared_quad_state_list[i]);
     }
-    for (size_t i = 0, sqs_i = 0; i < source->quad_list.size(); ++i) {
-      while (source->quad_list[i]->shared_quad_state !=
-             source->shared_quad_state_list[sqs_i]) {
+    size_t sqs_i = 0;
+    for (QuadList::Iterator iter = source->quad_list.begin();
+         iter != source->quad_list.end();
+         ++iter) {
+      while (iter->shared_quad_state != source->shared_quad_state_list[sqs_i]) {
         ++sqs_i;
         DCHECK_LT(sqs_i, source->shared_quad_state_list.size());
       }
-      DCHECK(source->quad_list[i]->shared_quad_state ==
-             source->shared_quad_state_list[sqs_i]);
+      DCHECK(iter->shared_quad_state == source->shared_quad_state_list[sqs_i]);
 
-      DrawQuad* quad = source->quad_list[i];
+      DrawQuad* quad = &*iter;
 
       if (quad->material == DrawQuad::RENDER_PASS) {
         const RenderPassDrawQuad* pass_quad =
             RenderPassDrawQuad::MaterialCast(quad);
         copy_pass->CopyFromAndAppendRenderPassDrawQuad(
             pass_quad,
             copy_pass->shared_quad_state_list[sqs_i],
             pass_quad->render_pass_id);
       } else {
         copy_pass->CopyFromAndAppendDrawQuad(
@@ skipping 55 matching lines @@
 
   value->BeginArray("shared_quad_state_list");
   for (size_t i = 0; i < shared_quad_state_list.size(); ++i) {
     value->BeginDictionary();
     shared_quad_state_list[i]->AsValueInto(value);
     value->EndDictionary();
   }
   value->EndArray();
 
   value->BeginArray("quad_list");
-  for (size_t i = 0; i < quad_list.size(); ++i) {
+  for (QuadList::ConstIterator iter = quad_list.begin();
+       iter != quad_list.end();
+       ++iter) {
     value->BeginDictionary();
-    quad_list[i]->AsValueInto(value);
+    iter->AsValueInto(value);
     value->EndDictionary();
   }
   value->EndArray();
 
   TracedValue::MakeDictIntoImplicitSnapshotWithCategory(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
       value,
       "cc::RenderPass",
       id.AsTracingId());
 }
@@ skipping 52 matching lines @@
     case DrawQuad::RENDER_PASS:
     case DrawQuad::INVALID:
       LOG(FATAL) << "Invalid DrawQuad material " << quad->material;
       break;
   }
   quad_list.back()->shared_quad_state = shared_quad_state;
   return quad_list.back();
 }
 
 }  // namespace cc