cc: Implement RemoveLast for DisplayItemList.

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/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"
@@ skipping 632 matching lines @@
   }
 
   i = 0;
   for (ListContainer<SharedQuadState>::ReverseIterator iter = list.rbegin();
        iter != list.rend(); ++iter) {
     EXPECT_EQ(i, iter.index());
     ++i;
   }
 }
 
+// Increments an int when constructed (or the counter pointer is supplied) and
+// decrements when destructed.
+class InstanceCounter {
+ public:
+  InstanceCounter() : counter_(nullptr) {}
+  explicit InstanceCounter(int* counter) { SetCounter(counter); }
+  ~InstanceCounter() {
+    if (counter_)
+      --*counter_;
+  }
+  void SetCounter(int* counter) {
+    counter_ = counter;
+    ++*counter_;
+  }
+
+ private:
+  int* counter_;
+};
+
+TEST(ListContainerTest, RemoveLast) {

[jbroman, 2015/06/02 19:36:19]

Note that this will probably collide with a Samsung contributor's effort to move
this unit test out of cc/quads, but it should be pretty easy to resolve the
merge conflict, whoever it hits.

+  // We keep an explicit instance count to make sure that the destructors are
+  // indeed getting called.
+  int counter = 0;
+  ListContainer<InstanceCounter> list(sizeof(InstanceCounter), 1);
+  EXPECT_EQ(0, counter);
+  EXPECT_EQ(0u, list.size());
+
+  // We should be okay to add one and then go back to zero.
+  list.AllocateAndConstruct<InstanceCounter>()->SetCounter(&counter);
+  EXPECT_EQ(1, counter);
+  EXPECT_EQ(1u, list.size());
+  list.RemoveLast();
+  EXPECT_EQ(0, counter);
+  EXPECT_EQ(0u, list.size());
+
+  // We should also be okay to remove the last multiple times, as long as there

[danakj, 2015/06/02 20:04:32]

Can you add a test where you append one past a new allocation, and then remove
it, and verify iterators work begin/end/rbegin/rend/etc. Then append over the
boundary again and verify the same thing?

+  // are enough elements in the first place.
+  list.AllocateAndConstruct<InstanceCounter>()->SetCounter(&counter);
+  list.AllocateAndConstruct<InstanceCounter>()->SetCounter(&counter);
+  list.AllocateAndConstruct<InstanceCounter>()->SetCounter(&counter);
+  list.AllocateAndConstruct<InstanceCounter>()->SetCounter(&counter);
+  list.AllocateAndConstruct<InstanceCounter>()->SetCounter(&counter);
+  list.AllocateAndConstruct<InstanceCounter>()->SetCounter(&counter);
+  list.RemoveLast();
+  list.RemoveLast();
+  EXPECT_EQ(4, counter);  // Leaves one in the last list.
+  EXPECT_EQ(4u, list.size());
+  list.RemoveLast();
+  EXPECT_EQ(3, counter);  // Removes an inner list from before.
+  EXPECT_EQ(3u, list.size());
+}
+
 }  // namespace
 }  // namespace cc