cc: Move cc/quads/list_container.* files to cc/base.

cc/quads/quad_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 "cc/base/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"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 45 matching lines @@
 };
 
 class MockDrawQuadSubclass : public MockDrawQuad {
  public:
   MockDrawQuadSubclass() { set_value(kMagicNumberToUseForDrawQuadTwo); }
 };
 
 const size_t kLargestQuadSize =
     std::max(LargestDrawQuadSize(), sizeof(MockDrawQuadSubclass));
 
-TEST(ListContainerTest, ConstructorCalledInAllocateAndConstruct) {
+TEST(QuadListContainerTest, ConstructorCalledInAllocateAndConstruct) {

[enne (OOO), 2015/05/26 18:31:28]

I think these are really testing the list container, but happen to be using
quads.  So, I think this file and test names should stay as they were before.

[prashant.n, 2015/05/26 19:11:48]

Ok I can revert this. But again problem comes, as per chromium practice, we
cannot place the unit test file adjacent to the file i.e. list_container.cc.

So is it okay placing unit test file in quads folder OR we create simple mock
class which uses list container and place it in cc/base and modify the unit test
file accordingly to test list container and then place unit test also in
cc/base?

   ListContainer<DrawQuad> list(kLargestQuadSize);
 
   size_t size = 2;
   SimpleDrawQuadConstructMagicNumberOne* dq_1 =
       list.AllocateAndConstruct<SimpleDrawQuadConstructMagicNumberOne>();
   SimpleDrawQuadConstructMagicNumberTwo* dq_2 =
       list.AllocateAndConstruct<SimpleDrawQuadConstructMagicNumberTwo>();
 
   EXPECT_EQ(size, list.size());
   EXPECT_EQ(dq_1, list.front());
   EXPECT_EQ(dq_2, list.back());
 
   EXPECT_EQ(kMagicNumberToUseForDrawQuadOne, dq_1->get_value());
   EXPECT_EQ(kMagicNumberToUseForDrawQuadTwo, dq_2->get_value());
 }
 
-TEST(ListContainerTest, DestructorCalled) {
+TEST(QuadListContainerTest, DestructorCalled) {
   ListContainer<DrawQuad> list(kLargestQuadSize);
 
   size_t size = 1;
   MockDrawQuad* dq_1 = list.AllocateAndConstruct<MockDrawQuad>();
 
   EXPECT_CALL(*dq_1, Destruct());
   EXPECT_EQ(size, list.size());
   EXPECT_EQ(dq_1, list.front());
 }
 
-TEST(ListContainerTest, DestructorCalledOnceWhenClear) {
+TEST(QuadListContainerTest, DestructorCalledOnceWhenClear) {
   ListContainer<DrawQuad> list(kLargestQuadSize);
   size_t size = 1;
   MockDrawQuad* dq_1 = list.AllocateAndConstruct<MockDrawQuad>();
 
   EXPECT_EQ(size, list.size());
   EXPECT_EQ(dq_1, list.front());
 
   // Make sure destructor is called once during clear, and won't be called
   // again.
   testing::MockFunction<void()> separator;
   {
     testing::InSequence s;
     EXPECT_CALL(*dq_1, Destruct());
     EXPECT_CALL(separator, Call());
     EXPECT_CALL(*dq_1, Destruct()).Times(0);
   }
 
   list.clear();
   separator.Call();
 }
 
-TEST(ListContainerTest, ReplaceExistingElement) {
+TEST(QuadListContainerTest, ReplaceExistingElement) {
   ListContainer<DrawQuad> list(kLargestQuadSize);
   size_t size = 1;
   MockDrawQuad* dq_1 = list.AllocateAndConstruct<MockDrawQuad>();
 
   EXPECT_EQ(size, list.size());
   EXPECT_EQ(dq_1, list.front());
 
   // Make sure destructor is called once during clear, and won't be called
   // again.
   testing::MockFunction<void()> separator;
   {
     testing::InSequence s;
     EXPECT_CALL(*dq_1, Destruct());
     EXPECT_CALL(separator, Call());
     EXPECT_CALL(*dq_1, Destruct()).Times(0);
   }
 
   list.ReplaceExistingElement<MockDrawQuadSubclass>(list.begin());
   EXPECT_EQ(kMagicNumberToUseForDrawQuadTwo, dq_1->get_value());
   separator.Call();
 
   EXPECT_CALL(*dq_1, Destruct());
   list.clear();
 }
 
-TEST(ListContainerTest, DestructorCalledOnceWhenErase) {
+TEST(QuadListContainerTest, DestructorCalledOnceWhenErase) {
   ListContainer<DrawQuad> list(kLargestQuadSize);
   size_t size = 1;
   MockDrawQuad* dq_1 = list.AllocateAndConstruct<MockDrawQuad>();
 
   EXPECT_EQ(size, list.size());
   EXPECT_EQ(dq_1, list.front());
 
   // Make sure destructor is called once during clear, and won't be called
   // again.
   testing::MockFunction<void()> separator;
   {
     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) {
+TEST(QuadListContainerTest, 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) {
+TEST(QuadListContainerTest, 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());
   EXPECT_EQ(sqs_3, list.back());
 }
 
-TEST(ListContainerTest, SimpleInsertionAndClearSharedQuadState) {
+TEST(QuadListContainerTest, SimpleInsertionAndClearSharedQuadState) {
   ListContainer<SharedQuadState> list;
   EXPECT_TRUE(list.empty());
   EXPECT_EQ(0u, list.size());
 
   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());
   EXPECT_EQ(sqs_3, list.back());
   EXPECT_FALSE(list.empty());
 
   list.clear();
   EXPECT_TRUE(list.empty());
   EXPECT_EQ(0u, list.size());
 }
 
-TEST(ListContainerTest, SimpleInsertionClearAndInsertAgainSharedQuadState) {
+TEST(QuadListContainerTest, SimpleInsertionClearAndInsertAgainSharedQuadState) {
   ListContainer<SharedQuadState> list;
   EXPECT_TRUE(list.empty());
   EXPECT_EQ(0u, list.size());
 
   size_t size = 2;
   SharedQuadState* sqs_front = list.AllocateAndConstruct<SharedQuadState>();
   SharedQuadState* sqs_back = list.AllocateAndConstruct<SharedQuadState>();
 
   EXPECT_EQ(size, list.size());
   EXPECT_EQ(sqs_front, list.front());
@@ skipping 10 matching lines @@
   sqs_back = list.AllocateAndConstruct<SharedQuadState>();
 
   EXPECT_EQ(size, list.size());
   EXPECT_EQ(sqs_front, list.front());
   EXPECT_EQ(sqs_back, list.back());
   EXPECT_FALSE(list.empty());
 }
 
 // This test is used to test when there is more than one allocation needed
 // for, ListContainer can still perform like normal vector.
-TEST(ListContainerTest,
+TEST(QuadListContainerTest,
      SimpleInsertionTriggerMoreThanOneAllocationSharedQuadState) {
   ListContainer<SharedQuadState> list(sizeof(SharedQuadState), 2);
   std::vector<SharedQuadState*> sqs_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
   }
   EXPECT_EQ(size, list.size());
 
   ListContainer<SharedQuadState>::Iterator iter = list.begin();
   for (std::vector<SharedQuadState*>::const_iterator sqs_iter =
            sqs_list.begin();
        sqs_iter != sqs_list.end();
        ++sqs_iter) {
     EXPECT_EQ(*sqs_iter, *iter);
     ++iter;
   }
 }
 
-TEST(ListContainerTest,
+TEST(QuadListContainerTest,
      CorrectAllocationSizeForMoreThanOneAllocationSharedQuadState) {
   // Constructor sets the allocation size to 2. Every time ListContainer needs
   // to allocate again, it doubles allocation size. In this test, 10 elements is
   // needed, thus ListContainerShould allocate spaces 2, 4 and 8 elements.
   ListContainer<SharedQuadState> list(sizeof(SharedQuadState), 2);
   std::vector<SharedQuadState*> sqs_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     // Before asking for a new element, space available without another
     // allocation follows.
@@ skipping 64 matching lines @@
   ListContainer<SharedQuadState>::Iterator iter = list.begin();
   for (std::vector<SharedQuadState*>::const_iterator sqs_iter =
            sqs_list.begin();
        sqs_iter != sqs_list.end();
        ++sqs_iter) {
     EXPECT_EQ(*sqs_iter, *iter);
     ++iter;
   }
 }
 
-TEST(ListContainerTest, SimpleIterationSharedQuadState) {
+TEST(QuadListContainerTest, SimpleIterationSharedQuadState) {
   ListContainer<SharedQuadState> list;
   std::vector<SharedQuadState*> sqs_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
   }
   EXPECT_EQ(size, list.size());
 
   size_t num_iters_in_list = 0;
   {
@@ skipping 16 matching lines @@
          ++sqs_iter) {
       EXPECT_EQ(*sqs_iter, *iter);
       ++num_iters_in_vector;
       ++iter;
     }
   }
 
   EXPECT_EQ(num_iters_in_vector, num_iters_in_list);
 }
 
-TEST(ListContainerTest, SimpleConstIteratorIterationSharedQuadState) {
+TEST(QuadListContainerTest, SimpleConstIteratorIterationSharedQuadState) {
   ListContainer<SharedQuadState> list;
   std::vector<const SharedQuadState*> sqs_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
   }
   EXPECT_EQ(size, list.size());
 
   {
     std::vector<const SharedQuadState*>::const_iterator sqs_iter =
@@ skipping 24 matching lines @@
     for (std::vector<const SharedQuadState*>::const_iterator sqs_iter =
              sqs_list.begin();
          sqs_iter != sqs_list.end();
          ++sqs_iter) {
       EXPECT_EQ(*sqs_iter, *iter);
       ++iter;
     }
   }
 }
 
-TEST(ListContainerTest, SimpleReverseInsertionSharedQuadState) {
+TEST(QuadListContainerTest, SimpleReverseInsertionSharedQuadState) {
   ListContainer<SharedQuadState> list;
   std::vector<SharedQuadState*> sqs_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
   }
   EXPECT_EQ(size, list.size());
 
   {
     std::vector<SharedQuadState*>::const_reverse_iterator sqs_iter =
@@ skipping 11 matching lines @@
     for (std::vector<SharedQuadState*>::reverse_iterator sqs_iter =
              sqs_list.rbegin();
          sqs_iter != sqs_list.rend();
          ++sqs_iter) {
       EXPECT_EQ(*sqs_iter, *iter);
       ++iter;
     }
   }
 }
 
-TEST(ListContainerTest, SimpleDeletion) {
+TEST(QuadListContainerTest, SimpleDeletion) {
   ListContainer<DrawQuad> list(kLargestQuadSize);
   std::vector<SimpleDrawQuad*> sdq_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     sdq_list.push_back(list.AllocateAndConstruct<SimpleDrawQuad>());
     sdq_list.back()->set_value(i);
   }
   EXPECT_EQ(size, list.size());
 
   list.EraseAndInvalidateAllPointers(list.begin());
   --size;
   EXPECT_EQ(size, list.size());
   int i = 1;
   for (ListContainer<DrawQuad>::Iterator iter = list.begin();
        iter != list.end();
        ++iter) {
     EXPECT_EQ(i, static_cast<SimpleDrawQuad*>(*iter)->get_value());
     ++i;
   }
 }
 
-TEST(ListContainerTest, DeletionAllInAllocation) {
+TEST(QuadListContainerTest, DeletionAllInAllocation) {
   const size_t kReserve = 10;
   ListContainer<DrawQuad> list(kLargestQuadSize, kReserve);
   std::vector<SimpleDrawQuad*> sdq_list;
   // Add enough quads to cause another allocation.
   for (size_t i = 0; i < kReserve + 1; ++i) {
     sdq_list.push_back(list.AllocateAndConstruct<SimpleDrawQuad>());
     sdq_list.back()->set_value(static_cast<int>(i));
   }
   EXPECT_EQ(kReserve + 1, list.size());
 
   // Remove everything in the first allocation.
   for (size_t i = 0; i < kReserve; ++i)
     list.EraseAndInvalidateAllPointers(list.begin());
   EXPECT_EQ(1u, list.size());
 
   // The last quad is left.
   SimpleDrawQuad* quad = static_cast<SimpleDrawQuad*>(*list.begin());
   EXPECT_EQ(static_cast<int>(kReserve), quad->get_value());
 
   // Remove the quad from the 2nd allocation.
   list.EraseAndInvalidateAllPointers(list.begin());
   EXPECT_EQ(0u, list.size());
 }
 
-TEST(ListContainerTest, DeletionAllInAllocationReversed) {
+TEST(QuadListContainerTest, DeletionAllInAllocationReversed) {
   const size_t kReserve = 10;
   ListContainer<DrawQuad> list(kLargestQuadSize, kReserve);
   std::vector<SimpleDrawQuad*> sdq_list;
   // Add enough quads to cause another allocation.
   for (size_t i = 0; i < kReserve + 1; ++i) {
     sdq_list.push_back(list.AllocateAndConstruct<SimpleDrawQuad>());
     sdq_list.back()->set_value(static_cast<int>(i));
   }
   EXPECT_EQ(kReserve + 1, list.size());
 
@@ skipping 35 matching lines @@
 
   // Can forward iterate too.
   i = 0;
   for (auto it = list.begin(); it != list.end(); ++it) {
     SimpleDrawQuad* quad = static_cast<SimpleDrawQuad*>(*it);
     EXPECT_EQ(static_cast<int>(i), quad->get_value());
     ++i;
   }
 }
 
-TEST(ListContainerTest, SimpleIterationAndManipulation) {
+TEST(QuadListContainerTest, SimpleIterationAndManipulation) {
   ListContainer<DrawQuad> list(kLargestQuadSize);
   std::vector<SimpleDrawQuad*> sdq_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     SimpleDrawQuad* simple_dq = list.AllocateAndConstruct<SimpleDrawQuad>();
     sdq_list.push_back(simple_dq);
   }
   EXPECT_EQ(size, list.size());
 
   ListContainer<DrawQuad>::Iterator iter = list.begin();
   for (int i = 0; i < 10; ++i) {
     static_cast<SimpleDrawQuad*>(*iter)->set_value(i);
     ++iter;
   }
 
   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, SimpleManipulationWithIndexSimpleDrawQuad) {
+TEST(QuadListContainerTest, SimpleManipulationWithIndexSimpleDrawQuad) {
   ListContainer<DrawQuad> list(kLargestQuadSize);
   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);
   }
 
   int i = 0;
   for (std::vector<SimpleDrawQuad*>::const_iterator dq_iter = dq_list.begin();
        dq_iter != dq_list.end();
        ++dq_iter, ++i) {
     EXPECT_EQ(i, (*dq_iter)->get_value());
   }
 }
 
-TEST(ListContainerTest,
+TEST(QuadListContainerTest,
      SimpleManipulationWithIndexMoreThanOneAllocationSimpleDrawQuad) {
   ListContainer<DrawQuad> list(LargestDrawQuadSize(), 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);
   }
 
   int i = 0;
   for (std::vector<SimpleDrawQuad*>::const_iterator dq_iter = dq_list.begin();
        dq_iter != dq_list.end();
        ++dq_iter, ++i) {
     EXPECT_EQ(i, (*dq_iter)->get_value());
   }
 }
 
-TEST(ListContainerTest,
+TEST(QuadListContainerTest,
      SimpleIterationAndReverseIterationWithIndexSharedQuadState) {
   ListContainer<SharedQuadState> list;
   std::vector<SharedQuadState*> sqs_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
   }
   EXPECT_EQ(size, list.size());
 
   size_t i = 0;
   for (ListContainer<SharedQuadState>::Iterator iter = list.begin();
        iter != list.end();
        ++iter) {
     EXPECT_EQ(i, iter.index());
     ++i;
   }
 
   i = 0;
   for (ListContainer<SharedQuadState>::ReverseIterator iter = list.rbegin();
        iter != list.rend();
        ++iter) {
     EXPECT_EQ(i, iter.index());
     ++i;
   }
 }
 
 }  // namespace
 }  // namespace cc