Use custom ListContainer to allocate DrawQuads

cc/quads/list_container_unittest.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/quads/list_container.h"
 
 #include <vector>
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/largest_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
@@ skipping 118 matching lines @@
     testing::InSequence s;
     EXPECT_CALL(*dq_1, Destruct());
     EXPECT_CALL(separator, Call());
     EXPECT_CALL(*dq_1, Destruct()).Times(0);
   }
 
   list.EraseAndInvalidateAllPointers(list.begin());
   separator.Call();
 }
 
+TEST(ListContainerTest, SimpleIndexAccessSharedQuadState) {
+  ListContainer<SharedQuadState> list;
+
+  size_t size = 3;
+  SharedQuadState* sqs_1 = list.AllocateAndConstruct<SharedQuadState>();
+  SharedQuadState* sqs_2 = list.AllocateAndConstruct<SharedQuadState>();
+  SharedQuadState* sqs_3 = list.AllocateAndConstruct<SharedQuadState>();
+
+  EXPECT_EQ(size, list.size());
+  EXPECT_EQ(sqs_1, list.front());
+  EXPECT_EQ(sqs_3, list.back());
+  EXPECT_EQ(list.front(), list.ElementAt(0));
+  EXPECT_EQ(sqs_2, list.ElementAt(1));
+  EXPECT_EQ(list.back(), list.ElementAt(2));
+}
+
 TEST(ListContainerTest, SimpleInsertionSharedQuadState) {
   ListContainer<SharedQuadState> list;
 
   size_t size = 3;
   SharedQuadState* sqs_1 = list.AllocateAndConstruct<SharedQuadState>();
   list.AllocateAndConstruct<SharedQuadState>();
   SharedQuadState* sqs_3 = list.AllocateAndConstruct<SharedQuadState>();
 
   EXPECT_EQ(size, list.size());
   EXPECT_EQ(sqs_1, list.front());
@@ skipping 310 matching lines @@
 
   int i = 0;
   for (std::vector<SimpleDrawQuad*>::const_iterator sdq_iter = sdq_list.begin();
        sdq_iter < sdq_list.end();
        ++sdq_iter) {
     EXPECT_EQ(i, (*sdq_iter)->get_value());
     ++i;
   }
 }
 
+TEST(ListContainerTest, SimpleIterationWithIndexSimpleDrawQuad) {

[danakj, 2014/09/24 23:55:57]

This test seems to be testing iterators, which are tested elsewhere and don't
iteract with ElementAt(), so I'm not sure why it was added, or at the least, I
think it should be more focused on the new thing it's trying to test.

+  ListContainer<DrawQuad> list(sizeof(kLargestDrawQuad));
+  std::vector<SimpleDrawQuad*> dq_list;
+  size_t size = 10;
+  for (size_t i = 0; i < size; ++i) {
+    dq_list.push_back(list.AllocateAndConstruct<SimpleDrawQuad>());
+  }
+  EXPECT_EQ(size, list.size());
+
+  for (size_t i = 0; i < size; ++i) {
+    static_cast<SimpleDrawQuad*>(list.ElementAt(i))->set_value(i);
+  }
+
+  size_t num_iters_in_list = 0;
+  {
+    int i = 0;
+    std::vector<SimpleDrawQuad*>::const_iterator dq_iter = dq_list.begin();
+    for (ListContainer<DrawQuad>::Iterator iter = list.begin();
+         iter != list.end();
+         ++iter) {
+      EXPECT_EQ(*dq_iter, &*iter);
+      EXPECT_EQ(i, static_cast<SimpleDrawQuad&>(*iter).get_value());
+      ++i;
+      ++num_iters_in_list;
+      ++dq_iter;
+    }
+  }
+
+  size_t num_iters_in_vector = 0;
+  {
+    int i = 0;
+    ListContainer<DrawQuad>::Iterator iter = list.begin();
+    for (std::vector<SimpleDrawQuad*>::const_iterator dq_iter = dq_list.begin();
+         dq_iter != dq_list.end();
+         ++dq_iter) {
+      EXPECT_EQ(*dq_iter, &*iter);
+      EXPECT_EQ(i, (*dq_iter)->get_value());
+      ++i;
+      ++num_iters_in_vector;
+      ++iter;
+    }
+  }
+
+  EXPECT_EQ(num_iters_in_vector, num_iters_in_list);
+}
+
+TEST(ListContainerTest,
+     SimpleIterationWithIndexMoreThanOneAllocationSimpleDrawQuad) {
+  ListContainer<DrawQuad> list(sizeof(kLargestDrawQuad), 2);
+  std::vector<SimpleDrawQuad*> dq_list;
+  size_t size = 10;
+  for (size_t i = 0; i < size; ++i) {
+    dq_list.push_back(list.AllocateAndConstruct<SimpleDrawQuad>());
+  }
+  EXPECT_EQ(size, list.size());
+
+  for (size_t i = 0; i < size; ++i) {
+    static_cast<SimpleDrawQuad*>(list.ElementAt(i))->set_value(i);
+  }
+
+  size_t num_iters_in_list = 0;
+  {
+    int i = 0;
+    std::vector<SimpleDrawQuad*>::const_iterator dq_iter = dq_list.begin();

[danakj, 2014/09/24 23:55:57]

similar comment here for this test. i like that you're testing ElementAt across
more than 1 inner list, but this test ends up testing a lot of other things,.

+    for (ListContainer<DrawQuad>::Iterator iter = list.begin();
+         iter != list.end();
+         ++iter) {
+      EXPECT_EQ(*dq_iter, &*iter);
+      EXPECT_EQ(i, static_cast<SimpleDrawQuad&>(*iter).get_value());
+      ++i;
+      ++num_iters_in_list;
+      ++dq_iter;
+    }
+  }
+
+  size_t num_iters_in_vector = 0;
+  {
+    int i = 0;
+    ListContainer<DrawQuad>::Iterator iter = list.begin();
+    for (std::vector<SimpleDrawQuad*>::const_iterator dq_iter = dq_list.begin();
+         dq_iter != dq_list.end();
+         ++dq_iter) {
+      EXPECT_EQ(*dq_iter, &*iter);
+      EXPECT_EQ(i, (*dq_iter)->get_value());
+      ++i;
+      ++num_iters_in_vector;
+      ++iter;
+    }
+  }
+
+  EXPECT_EQ(num_iters_in_vector, num_iters_in_list);
+}
+
 }  // namespace
 }  // namespace cc