Add underlays and split off common overlay functionality

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 36 matching lines @@
   }
 };
 
 class SimpleDrawQuadConstructMagicNumberTwo : public SimpleDrawQuad {
  public:
   SimpleDrawQuadConstructMagicNumberTwo() : SimpleDrawQuad() {
     set_value(kMagicNumberToUseForDrawQuadTwo);
   }
 };
 
-class MockDrawQuad : public DrawQuad {
+class MockDrawQuad : public SimpleDrawQuadConstructMagicNumberOne {
  public:
   ~MockDrawQuad() override { Destruct(); }
-  void IterateResources(const ResourceIteratorCallback& callback) override {}
-  void ExtendValue(base::trace_event::TracedValue* value) const override {}
   MOCK_METHOD0(Destruct, void());
 };
 
+class MockDrawQuadSubclass : public MockDrawQuad {
+ public:
+  MockDrawQuadSubclass() { set_value(kMagicNumberToUseForDrawQuadTwo); }
+};
+
+const size_t kLargestQuadSize =
+    std::max(LargestDrawQuadSize(), sizeof(MockDrawQuadSubclass));
+
 TEST(ListContainerTest, ConstructorCalledInAllocateAndConstruct) {
-  ListContainer<DrawQuad> list(LargestDrawQuadSize());
+  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) {
-  ListContainer<DrawQuad> list(LargestDrawQuadSize());
+  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) {
-  ListContainer<DrawQuad> list(LargestDrawQuadSize());
+  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, DestructorCalledOnceWhenErase) {
-  ListContainer<DrawQuad> list(LargestDrawQuadSize());
+TEST(ListContainerTest, 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) {
+  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());
@@ skipping 297 matching lines @@
              sqs_list.rbegin();
          sqs_iter != sqs_list.rend();
          ++sqs_iter) {
       EXPECT_EQ(*sqs_iter, *iter);
       ++iter;
     }
   }
 }
 
 TEST(ListContainerTest, SimpleDeletion) {
-  ListContainer<DrawQuad> list(LargestDrawQuadSize());
+  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, SimpleIterationAndManipulation) {
-  ListContainer<DrawQuad> list(LargestDrawQuadSize());
+  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) {
-  ListContainer<DrawQuad> list(LargestDrawQuadSize());
+  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);
   }
@@ skipping 50 matching lines @@
   for (ListContainer<SharedQuadState>::ReverseIterator iter = list.rbegin();
        iter != list.rend();
        ++iter) {
     EXPECT_EQ(i, iter.index());
     ++i;
   }
 }
 
 }  // namespace
 }  // namespace cc