Use Custome ListContainer to Allocate SharedQuadState

cc/quads/render_pass.cc

Index: cc/quads/render_pass.cc
diff --git a/cc/quads/render_pass.cc b/cc/quads/render_pass.cc
index e487c0963824d58f842e479f29c20711642c682c..ef2f9cda2140ceacd4d5dbbdf420c6e9d5a875a8 100644
--- a/cc/quads/render_pass.cc
+++ b/cc/quads/render_pass.cc
@@ -44,20 +44,38 @@ scoped_ptr<RenderPass> RenderPass::Create(size_t num_layers) {
   return make_scoped_ptr(new RenderPass(num_layers));
 }
 
+scoped_ptr<RenderPass> RenderPass::Create(size_t shared_quad_state_list_size,
+                                          size_t quad_list_size) {
+  return make_scoped_ptr(
+      new RenderPass(shared_quad_state_list_size, quad_list_size));
+}
+
 RenderPass::RenderPass()
     : id(RenderPassId(-1, -1)),
       has_transparent_background(true),
-      quad_list(kDefaultNumQuadsToReserve) {
-  shared_quad_state_list.reserve(kDefaultNumSharedQuadStatesToReserve);
+      quad_list(kDefaultNumQuadsToReserve),
+      shared_quad_state_list(sizeof(SharedQuadState),
+                             kDefaultNumSharedQuadStatesToReserve) {
 }
 
+// Each layer usually produces one shared quad state, so the number of layers
+// is a good hint for what to reserve here.
 RenderPass::RenderPass(size_t num_layers)
     : 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(kDefaultNumQuadsToReserve),
+      shared_quad_state_list(
+          sizeof(SharedQuadState),
+          num_layers ? num_layers : kDefaultNumSharedQuadStatesToReserve) {

[danakj, 2014/09/26 20:40:55]

can num_layers be 0? Can the ListContainer not handle that as an input? maybe
you can fix that instead of doing this check here?

[weiliangc, 2014/09/26 21:48:02]

num_layer can be 0 in unittests.

Yeah you are right. The size would be "minimum" size of list to reserve for,
thus a 0 input would make sense.

I thought of this input as "exact" size of list so it's user's responsibility to
not reserve for size 0. 

+}
+
+RenderPass::RenderPass(size_t shared_quad_state_list_size,
+                       size_t quad_list_size)
+    : id(RenderPassId(-1, -1)),
+      has_transparent_background(true),
+      quad_list(quad_list_size),
+      shared_quad_state_list(sizeof(SharedQuadState),
+                             shared_quad_state_list_size) {
 }
 
 RenderPass::~RenderPass() {
@@ -67,7 +85,8 @@ RenderPass::~RenderPass() {
 }
 
 scoped_ptr<RenderPass> RenderPass::Copy(RenderPassId new_id) const {
-  scoped_ptr<RenderPass> copy_pass(Create());
+  scoped_ptr<RenderPass> copy_pass(
+      Create(shared_quad_state_list.size(), quad_list.size()));
   copy_pass->SetAll(new_id,
                     output_rect,
                     damage_rect,
@@ -86,26 +105,34 @@ void RenderPass::CopyAll(const ScopedPtrVector<RenderPass>& in,
     // you may have copy_requests present.
     DCHECK_EQ(source->copy_requests.size(), 0u);
 
-    scoped_ptr<RenderPass> copy_pass(Create());
+    scoped_ptr<RenderPass> copy_pass(Create(
+        source->shared_quad_state_list.size(), source->quad_list.size()));
     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) {
+    for (SharedQuadStateList::ConstIterator iter =
+             source->shared_quad_state_list.begin();
+         iter != source->shared_quad_state_list.end();
+         ++iter) {
       SharedQuadState* copy_shared_quad_state =
           copy_pass->CreateAndAppendSharedQuadState();
-      copy_shared_quad_state->CopyFrom(source->shared_quad_state_list[i]);
+      copy_shared_quad_state->CopyFrom(&(*iter));

[danakj, 2014/09/26 20:40:55]

you didn't use &(*a) just &*a in other patches, what changed?

[weiliangc, 2014/09/26 21:48:02]

...I used &*a in ListContainer and its unittest.

For iterators, operator* return T&, and to get T*, it has to be &*iter

Plus the use of const T* for input field in some code.

Clean up time for const T* related to SQS and DQ?

     }
-    size_t sqs_i = 0;
+    SharedQuadStateList::Iterator sqs_iter =
+        source->shared_quad_state_list.begin();
+    SharedQuadStateList::Iterator copy_sqs_iter =
+        copy_pass->shared_quad_state_list.begin();
     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());
+      while (iter->shared_quad_state != &(*sqs_iter)) {

[danakj, 2014/09/26 20:40:55]

&*?

[weiliangc, 2014/10/01 23:02:00]

Done.

+        ++sqs_iter;
+        ++copy_sqs_iter;
+        DCHECK(sqs_iter != source->shared_quad_state_list.end());
       }
-      DCHECK(iter->shared_quad_state == source->shared_quad_state_list[sqs_i]);
+      DCHECK(iter->shared_quad_state == &(*sqs_iter));

[danakj, 2014/09/26 20:40:55]

&*?

[weiliangc, 2014/10/01 23:02:00]

Done.

 
       DrawQuad* quad = &*iter;

[danakj, 2014/09/26 20:40:55]

can you put the copy SQS* into a variable here too, to make below more clear?

[weiliangc, 2014/10/01 23:02:00]

Done.

 
@@ -113,12 +140,9 @@ void RenderPass::CopyAll(const ScopedPtrVector<RenderPass>& in,
         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);
+            pass_quad, &*copy_sqs_iter, pass_quad->render_pass_id);
       } else {
-        copy_pass->CopyFromAndAppendDrawQuad(
-            quad, copy_pass->shared_quad_state_list[sqs_i]);
+        copy_pass->CopyFromAndAppendDrawQuad(quad, &*copy_sqs_iter);
       }
     }
     out->push_back(copy_pass.Pass());
@@ -175,9 +199,12 @@ void RenderPass::AsValueInto(base::debug::TracedValue* value) const {
   value->SetInteger("copy_requests", copy_requests.size());
 
   value->BeginArray("shared_quad_state_list");
-  for (size_t i = 0; i < shared_quad_state_list.size(); ++i) {
+  for (SharedQuadStateList::ConstIterator iter =
+           this->shared_quad_state_list.begin();
+       iter != this->shared_quad_state_list.end();
+       ++iter) {
     value->BeginDictionary();
-    shared_quad_state_list[i]->AsValueInto(value);
+    iter->AsValueInto(value);
     value->EndDictionary();
   }
   value->EndArray();
@@ -200,8 +227,7 @@ void RenderPass::AsValueInto(base::debug::TracedValue* value) const {
 }
 
 SharedQuadState* RenderPass::CreateAndAppendSharedQuadState() {
-  shared_quad_state_list.push_back(make_scoped_ptr(new SharedQuadState));
-  return shared_quad_state_list.back();
+  return shared_quad_state_list.AllocateAndConstruct<SharedQuadState>();
 }
 
 RenderPassDrawQuad* RenderPass::CopyFromAndAppendRenderPassDrawQuad(