Use Custome ListContainer to Allocate SharedQuadState

mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc

Index: mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
diff --git a/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc b/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
index 7d1798ea6ae58c8e6c72e708db88cd09882f5c2e..11c25e9a04740a6e58403bef92cd5e225058305e 100644
--- a/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
+++ b/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
@@ -357,19 +357,20 @@ PassPtr TypeConverter<PassPtr, cc::RenderPass>::Convert(
   Array<QuadPtr> quads(input.quad_list.size());
   Array<SharedQuadStatePtr> shared_quad_state(
       input.shared_quad_state_list.size());
-  int sqs_i = -1;
-  const cc::SharedQuadState* last_sqs = NULL;
+  int sqs_i = 0;
   size_t i = 0;
+  cc::SharedQuadStateList::ConstIterator sqs_iter =
+      input.shared_quad_state_list.begin();
+  shared_quad_state[sqs_i] = SharedQuadState::From(*sqs_iter);

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

what if the list is empty? this seems less safe than the old code. maybe..

const cc::SQS* last_sqs = nullptr;
auto next_sqs_iter = input.sqs_list.begin();

and then the rest of the code looks mostly the same?

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

Done.

   for (cc::QuadList::ConstIterator iter = input.quad_list.begin();
        iter != input.quad_list.end();
        ++iter) {
     const cc::DrawQuad& quad = *iter;
     quads[i] = Quad::From(quad);
-    if (quad.shared_quad_state != last_sqs) {
+    if (quad.shared_quad_state != &*sqs_iter) {
+      ++sqs_iter;
       sqs_i++;

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

nit: ++sqs_i; to match

-      shared_quad_state[sqs_i] =
-          SharedQuadState::From(*input.shared_quad_state_list[sqs_i]);
-      last_sqs = quad.shared_quad_state;
+      shared_quad_state[sqs_i] = SharedQuadState::From(*sqs_iter);
     }
     quads[i]->shared_quad_state_index = sqs_i;
     ++i;
@@ -385,23 +386,26 @@ PassPtr TypeConverter<PassPtr, cc::RenderPass>::Convert(
 scoped_ptr<cc::RenderPass>
 TypeConverter<scoped_ptr<cc::RenderPass>, PassPtr>::Convert(
     const PassPtr& input) {
-  // TODO(weiliangc): RenderPass will have a constructor that takes in preset
-  // size of quad list and shared quad state list size in upcoming CL.
-  scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
+  scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create(
+      input->shared_quad_states.size(), input->quads.size());
   pass->SetAll(cc::RenderPassId(1, input->id),
                input->output_rect.To<gfx::Rect>(),
                input->damage_rect.To<gfx::Rect>(),
                input->transform_to_root_target.To<gfx::Transform>(),
                input->has_transparent_background);
-  cc::SharedQuadStateList& sqs_list = pass->shared_quad_state_list;
-  sqs_list.reserve(input->shared_quad_states.size());
   for (size_t i = 0; i < input->shared_quad_states.size(); ++i) {
     ConvertSharedQuadState(input->shared_quad_states[i], pass.get());
   }
+  cc::SharedQuadStateList::Iterator sqs_iter =
+      pass->shared_quad_state_list.begin();
+  int32_t sqs_i = 0;
   for (size_t i = 0; i < input->quads.size(); ++i) {
     QuadPtr quad = input->quads[i].Pass();
-    if (!ConvertDrawQuad(
-            quad, sqs_list[quad->shared_quad_state_index], pass.get()))
+    while (quad->shared_quad_state_index > sqs_i) {
+      ++sqs_i;

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

if you added an index() to the iterator, would it let you avoid this double
incrementing in a bunch of places?

[weiliangc, 2014/09/26 21:57:39]

This implementation would be kind of awkward. What would the index be for
rend()?

[danakj, 2014/09/26 22:46:40]

Either 0 or size is fine as long as we define it as such I think.

+      ++sqs_iter;
+    }
+    if (!ConvertDrawQuad(quad, &*sqs_iter, pass.get()))
       return scoped_ptr<cc::RenderPass>();
   }
   return pass.Pass();