Use custom ListContainer to allocate DrawQuads

content/common/cc_messages_unittest.cc

Index: content/common/cc_messages_unittest.cc
diff --git a/content/common/cc_messages_unittest.cc b/content/common/cc_messages_unittest.cc
index 1da44b3f1d719f10b84af2420bb07ac4bd67cc11..59061160c83e0f83284b5987ec9c036eb49e858a 100644
--- a/content/common/cc_messages_unittest.cc
+++ b/content/common/cc_messages_unittest.cc
@@ -477,16 +477,27 @@ TEST_F(CCMessagesTest, AllQuads) {
     Compare(pass_cmp->shared_quad_state_list[i],
             pass_in->shared_quad_state_list[i]);
   }
-  for (size_t i = 0; i < pass_in->quad_list.size(); ++i)
-    Compare(pass_cmp->quad_list[i], pass_in->quad_list[i]);
-  for (size_t i = 1; i < pass_in->quad_list.size(); ++i) {
-    bool same_shared_quad_state_cmp =
-        pass_cmp->quad_list[i]->shared_quad_state ==
-        pass_cmp->quad_list[i - 1]->shared_quad_state;
-    bool same_shared_quad_state_in =
-        pass_in->quad_list[i]->shared_quad_state ==
-        pass_in->quad_list[i - 1]->shared_quad_state;
-    EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_in);
+  for (cc::QuadList::Iterator in_iter = pass_in->quad_list.begin(),
+                              cmp_iter = pass_cmp->quad_list.begin();
+       in_iter != pass_in->quad_list.end();
+       ++in_iter, ++cmp_iter)
+    Compare(&*cmp_iter, &*in_iter);
+
+  cc::QuadList::Iterator in_iter_next = pass_in->quad_list.begin();
+  ++in_iter_next;
+  cc::QuadList::Iterator cmp_iter_next = pass_cmp->quad_list.begin();
+  ++cmp_iter_next;
+  for (cc::QuadList::Iterator in_iter = pass_in->quad_list.begin(),
+                              cmp_iter = pass_cmp->quad_list.begin();
+       in_iter_next != pass_in->quad_list.end();
+       ++in_iter, ++cmp_iter, ++in_iter_next, ++cmp_iter_next) {
+    if (in_iter_next != pass_in->quad_list.end()) {

[danakj, 2014/09/23 17:59:38]

Can you do this without managing 2 sets of 2 iterators? An at() method might
help here, or prev_iter = it;--prev_iter inside the loop or something.

[weiliangc, 2014/09/24 20:14:35]

Done with using at().

I was thinking every time at() is called it needs to figure out which InnerList
it could be on and seems less efficient; however, I suppose it doesn't really
matter in unittest.

+      bool same_shared_quad_state_cmp =
+          in_iter->shared_quad_state == in_iter_next->shared_quad_state;
+      bool same_shared_quad_state_in =
+          cmp_iter->shared_quad_state == cmp_iter_next->shared_quad_state;
+      EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_in);
+    }
   }
 
   DelegatedFrameData frame_in;
@@ -509,16 +520,27 @@ TEST_F(CCMessagesTest, AllQuads) {
     Compare(pass_cmp->shared_quad_state_list[i],
             pass_out->shared_quad_state_list[i]);
   }
-  for (size_t i = 0; i < pass_out->quad_list.size(); ++i)
-    Compare(pass_cmp->quad_list[i], pass_out->quad_list[i]);
-  for (size_t i = 1; i < pass_out->quad_list.size(); ++i) {
-    bool same_shared_quad_state_cmp =
-        pass_cmp->quad_list[i]->shared_quad_state ==
-        pass_cmp->quad_list[i - 1]->shared_quad_state;
-    bool same_shared_quad_state_out =
-        pass_out->quad_list[i]->shared_quad_state ==
-        pass_out->quad_list[i - 1]->shared_quad_state;
-    EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_out);
+  for (cc::QuadList::Iterator out_iter = pass_out->quad_list.begin(),
+                              cmp_iter = pass_cmp->quad_list.begin();
+       out_iter != pass_out->quad_list.end();
+       ++out_iter, ++cmp_iter)
+    Compare(&*cmp_iter, &*out_iter);
+
+  cc::QuadList::Iterator out_iter_next = pass_out->quad_list.begin();
+  ++out_iter_next;
+  cmp_iter_next = pass_cmp->quad_list.begin();
+  ++cmp_iter_next;
+  for (cc::QuadList::Iterator out_iter = pass_out->quad_list.begin(),
+                              cmp_iter = pass_cmp->quad_list.begin();
+       out_iter_next != pass_out->quad_list.end();
+       ++out_iter, ++cmp_iter, ++out_iter_next, ++cmp_iter_next) {
+    if (out_iter_next != pass_out->quad_list.end()) {
+      bool same_shared_quad_state_cmp =
+          out_iter->shared_quad_state == out_iter_next->shared_quad_state;
+      bool same_shared_quad_state_out =
+          cmp_iter->shared_quad_state == cmp_iter_next->shared_quad_state;
+      EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_out);
+    }
   }
 }