Use custom ListContainer to allocate DrawQuads

cc/surfaces/surface_aggregator.cc

 // Copyright 2014 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/surfaces/surface_aggregator.h"
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 110 matching lines @@
   bool invalid_frame = false;
   DrawQuad::ResourceIteratorCallback remap =
       base::Bind(&ResourceRemapHelper,
                  &invalid_frame,
                  provider_->GetChildToParentMap(child_id),
                  &referenced_resources);
   for (RenderPassList::iterator it = render_pass_list->begin();
        it != render_pass_list->end();
        ++it) {
     QuadList& quad_list = (*it)->quad_list;
-    for (QuadList::iterator quad_it = quad_list.begin();
+    for (QuadList::Iterator quad_it = quad_list.begin();
          quad_it != quad_list.end();
          ++quad_it) {
-      (*quad_it)->IterateResources(remap);
+      quad_it->IterateResources(remap);
     }
   }
   if (!invalid_frame)
     provider_->DeclareUsedResourcesFromChild(child_id, referenced_resources);
 
   return invalid_frame;
 }
 
 gfx::Rect SurfaceAggregator::DamageRectForSurface(const Surface* surface,
                                                   const RenderPass& source) {
@@ skipping 82 matching lines @@
                     dest_pass,
                     surface_id);
   } else {
     RenderPassId remapped_pass_id = RemapPassId(last_pass.id, surface_id);
 
     dest_pass_list_->back()->copy_requests.swap(copy_requests);
 
     SharedQuadState* shared_quad_state =
         dest_pass->CreateAndAppendSharedQuadState();
     shared_quad_state->CopyFrom(surface_quad->shared_quad_state);
-    scoped_ptr<RenderPassDrawQuad> quad(new RenderPassDrawQuad);
+    RenderPassDrawQuad* quad =
+        dest_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
     quad->SetNew(shared_quad_state,
                  surface_quad->rect,
                  surface_quad->visible_rect,
                  remapped_pass_id,
                  0,
                  gfx::RectF(),
                  FilterOperations(),
                  gfx::Vector2dF(),
                  FilterOperations());
-    dest_pass->quad_list.push_back(quad.PassAs<DrawQuad>());
   }
   dest_pass->damage_rect =
       gfx::UnionRects(dest_pass->damage_rect,
                       MathUtil::MapEnclosingClippedRect(
                           surface_quad->quadTransform(),
                           DamageRectForSurface(surface, last_pass)));
 
   referenced_surfaces_.erase(it);
 }
 
@@ skipping 19 matching lines @@
 }
 
 void SurfaceAggregator::CopyQuadsToPass(
     const QuadList& source_quad_list,
     const SharedQuadStateList& source_shared_quad_state_list,
     const gfx::Transform& content_to_target_transform,
     RenderPass* dest_pass,
     SurfaceId surface_id) {
   const SharedQuadState* last_copied_source_shared_quad_state = NULL;
 
-  for (size_t i = 0, sqs_i = 0; i < source_quad_list.size(); ++i) {
-    DrawQuad* quad = source_quad_list[i];
+  size_t sqs_i = 0;
+  for (QuadList::ConstIterator iter = source_quad_list.begin();
+       iter != source_quad_list.end();
+       ++iter) {
+    const DrawQuad* quad = &*iter;
     while (quad->shared_quad_state != source_shared_quad_state_list[sqs_i]) {
       ++sqs_i;
       DCHECK_LT(sqs_i, source_shared_quad_state_list.size());
     }
     DCHECK_EQ(quad->shared_quad_state, source_shared_quad_state_list[sqs_i]);
 
     if (quad->material == DrawQuad::SURFACE_CONTENT) {
       const SurfaceDrawQuad* surface_quad = SurfaceDrawQuad::MaterialCast(quad);
       HandleSurfaceQuad(surface_quad, dest_pass);
     } else {
@@ skipping 91 matching lines @@
       surface->TakeLatencyInfo(&frame->metadata.latency_info);
   }
 
   // TODO(jamesr): Aggregate all resource references into the returned frame's
   // resource list.
 
   return frame.Pass();
 }
 
 }  // namespace cc