Use custom ListContainer to allocate DrawQuads

cc/layers/delegated_renderer_layer_impl.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/delegated_renderer_layer_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 108 matching lines @@
 
   bool invalid_frame = false;
   ResourceProvider::ResourceIdArray resources_in_frame;
   DrawQuad::ResourceIteratorCallback remap_resources_to_parent_callback =
       base::Bind(&ResourceRemapHelper,
                  &invalid_frame,
                  resource_map,
                  &resources_in_frame);
   for (size_t i = 0; i < render_pass_list.size(); ++i) {
     RenderPass* pass = render_pass_list[i];
-    for (size_t j = 0; j < pass->quad_list.size(); ++j) {
-      DrawQuad* quad = pass->quad_list[j];
-      quad->IterateResources(remap_resources_to_parent_callback);
+    for (QuadList::Iterator iter = pass->quad_list.begin();
+         iter != pass->quad_list.end();
+         ++iter) {
+      iter->IterateResources(remap_resources_to_parent_callback);
     }
   }
 
   if (invalid_frame) {
     // Declare we are still using the last frame's resources.
     resource_provider->DeclareUsedResourcesFromChild(child_id_, resources_);
     return;
   }
 
   // Declare we are using the new frame's resources.
@@ skipping 244 matching lines @@
 
 void DelegatedRendererLayerImpl::AppendRenderPassQuads(
     RenderPass* render_pass,
     const OcclusionTracker<LayerImpl>& occlusion_tracker,
     AppendQuadsData* append_quads_data,
     const RenderPass* delegated_render_pass,
     const gfx::Size& frame_size) const {
   const SharedQuadState* delegated_shared_quad_state = NULL;
   SharedQuadState* output_shared_quad_state = NULL;
 
-  for (size_t i = 0; i < delegated_render_pass->quad_list.size(); ++i) {
-    const DrawQuad* delegated_quad = delegated_render_pass->quad_list[i];
+  for (QuadList::ConstIterator iter = delegated_render_pass->quad_list.begin();
+       iter != delegated_render_pass->quad_list.end();
+       ++iter) {
+    const DrawQuad* delegated_quad = &*iter;
 
     bool is_root_delegated_render_pass =
         delegated_render_pass == render_passes_in_draw_order_.back();
 
     if (delegated_quad->shared_quad_state != delegated_shared_quad_state) {
       delegated_shared_quad_state = delegated_quad->shared_quad_state;
       output_shared_quad_state = render_pass->CreateAndAppendSharedQuadState();
       output_shared_quad_state->CopyFrom(delegated_shared_quad_state);
 
       if (is_root_delegated_render_pass) {
@@ skipping 85 matching lines @@
   if (own_child_id_) {
     ResourceProvider* provider = layer_tree_impl()->resource_provider();
     provider->DestroyChild(child_id_);
   }
 
   resources_.clear();
   child_id_ = 0;
 }
 
 }  // namespace cc