Use Custome ListContainer to Allocate SharedQuadState

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 170 matching lines @@
   surface->TakeCopyOutputRequests(&copy_requests);
 
   bool merge_pass = copy_requests.empty();
 
   const RenderPassList& referenced_passes = render_pass_list;
   size_t passes_to_copy =
       merge_pass ? referenced_passes.size() - 1 : referenced_passes.size();
   for (size_t j = 0; j < passes_to_copy; ++j) {
     const RenderPass& source = *referenced_passes[j];
 
-    scoped_ptr<RenderPass> copy_pass(RenderPass::Create());
+    size_t sqs_size = source.shared_quad_state_list.size();
+    size_t dq_size = source.quad_list.size();
+    scoped_ptr<RenderPass> copy_pass(RenderPass::Create(sqs_size, dq_size));
 
     RenderPassId remapped_pass_id = RemapPassId(source.id, surface_id);
 
     copy_pass->SetAll(remapped_pass_id,
                       source.output_rect,
                       source.damage_rect,
                       source.transform_to_root_target,
                       source.has_transparent_background);
 
     // Contributing passes aggregated in to the pass list need to take the
@@ skipping 75 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;
 
-  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());
+  SharedQuadStateList::ConstIterator sqs_iter =
+      source_shared_quad_state_list.begin();
+  for (const auto& quad : source_quad_list) {
+    while (quad.shared_quad_state != &*sqs_iter) {
+      ++sqs_iter;
+      DCHECK(sqs_iter != source_shared_quad_state_list.end());

[danakj, 2014/10/02 15:32:48]

sqs_iter is only used for dchecks, can you use ElementAt instead? i think using
the old size_t is a bit easier to read, or at least makes the diff easier. or
maybe use the iterator index (which i guess would mean no fancy for loop,
though)

[weiliangc, 2014/10/02 22:01:40]

It is used in the while loop check at line 292.

     }
-    DCHECK_EQ(quad->shared_quad_state, source_shared_quad_state_list[sqs_i]);
+    DCHECK_EQ(quad.shared_quad_state, &*sqs_iter);
 
-    if (quad->material == DrawQuad::SURFACE_CONTENT) {
-      const SurfaceDrawQuad* surface_quad = SurfaceDrawQuad::MaterialCast(quad);
+    if (quad.material == DrawQuad::SURFACE_CONTENT) {
+      const SurfaceDrawQuad* surface_quad =
+          SurfaceDrawQuad::MaterialCast(&quad);
       HandleSurfaceQuad(surface_quad, dest_pass);
     } else {
-      if (quad->shared_quad_state != last_copied_source_shared_quad_state) {
+      if (quad.shared_quad_state != last_copied_source_shared_quad_state) {
         CopySharedQuadState(
-            quad->shared_quad_state, content_to_target_transform, dest_pass);
-        last_copied_source_shared_quad_state = quad->shared_quad_state;
+            quad.shared_quad_state, content_to_target_transform, dest_pass);
+        last_copied_source_shared_quad_state = quad.shared_quad_state;
       }
-      if (quad->material == DrawQuad::RENDER_PASS) {
+      if (quad.material == DrawQuad::RENDER_PASS) {
         const RenderPassDrawQuad* pass_quad =
-            RenderPassDrawQuad::MaterialCast(quad);
+            RenderPassDrawQuad::MaterialCast(&quad);
         RenderPassId original_pass_id = pass_quad->render_pass_id;
         RenderPassId remapped_pass_id =
             RemapPassId(original_pass_id, surface_id);
 
         dest_pass->CopyFromAndAppendRenderPassDrawQuad(
             pass_quad,
             dest_pass->shared_quad_state_list.back(),
             remapped_pass_id);
       } else {
         dest_pass->CopyFromAndAppendDrawQuad(
-            quad, dest_pass->shared_quad_state_list.back());
+            &quad, dest_pass->shared_quad_state_list.back());
       }
     }
   }
 }
 
 void SurfaceAggregator::CopyPasses(const RenderPassList& source_pass_list,
                                    const Surface* surface) {
   for (size_t i = 0; i < source_pass_list.size(); ++i) {
     const RenderPass& source = *source_pass_list[i];
 
-    scoped_ptr<RenderPass> copy_pass(RenderPass::Create());
+    size_t sqs_size = source.shared_quad_state_list.size();
+    size_t dq_size = source.quad_list.size();
+    scoped_ptr<RenderPass> copy_pass(RenderPass::Create(sqs_size, dq_size));
 
     RenderPassId remapped_pass_id =
         RemapPassId(source.id, surface->surface_id());
 
     copy_pass->SetAll(remapped_pass_id,
                       source.output_rect,
                       DamageRectForSurface(surface, source),
                       source.transform_to_root_target,
                       source.has_transparent_background);
 
@@ skipping 51 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