Defer allocation in cc::ContiguousContainerBase::Buffer.

cc/base/contiguous_container_unittest.cc

 // Copyright 2015 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 <stddef.h>
 
+#include <iterator>
+
 #include "cc/base/contiguous_container.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 struct Point2D {
   Point2D() : Point2D(0, 0) {}
   Point2D(int x, int y) : x(x), y(y) {}
@@ skipping 204 matching lines @@
   for (Point2D& point : list) {
     EXPECT_EQ((int)count, point.x);
     count++;
   }
   EXPECT_EQ(kNumElements, count);
 
   static_assert(std::is_same<decltype(*list.begin()), Point2D&>::value,
                 "Non-const iteration should produce non-const references.");
 }
 
+TEST(ContiguousContainerTest, ForwardIterationEmpty) {
+  ContiguousContainer<Point2D, kPointAlignment> list(kMaxPointSize);
+
+  // ContiguousContainer allocates memory for elements lazily at first append
+  // operation, so at this point memory is not allocated. Check that iteration
+  // doesn't crash and produces zero elements.
+  EXPECT_EQ(0, std::distance(list.begin(), list.end()));
+}
+
 TEST(ContiguousContainerTest, ConstForwardIteration) {
   ContiguousContainer<Point2D, kPointAlignment> list(kMaxPointSize);
   for (int i = 0; i < (int)kNumElements; i++)
     list.AllocateAndConstruct<Point2D>(i, i);
 
   const auto& const_list = list;
   unsigned count = 0;
   for (const Point2D& point : const_list) {
     EXPECT_EQ((int)count, point.x);
     count++;
@@ skipping 263 matching lines @@
   // Clearing should restore the capacity of the container to the same as a
   // newly allocated one (without reserved capacity requested).
   ContiguousContainer<Point2D, kPointAlignment> list(kMaxPointSize);
   size_t empty_capacity = list.GetCapacityInBytes();
   list.AllocateAndConstruct<Point2D>();
   list.AllocateAndConstruct<Point2D>();
   list.Clear();
   EXPECT_EQ(empty_capacity, list.GetCapacityInBytes());
 }
 
+TEST(ContiguousContainerTest, MemoryUsageInBytes) {
+  constexpr size_t initial_size1 = 10 * kMaxPointSize;
+  ContiguousContainer<Point2D, kPointAlignment> list1(kMaxPointSize,
+                                                      initial_size1);
+
+  constexpr size_t initial_size2 = 10000 * kMaxPointSize;
+  ContiguousContainer<Point2D, kPointAlignment> list2(kMaxPointSize,
+                                                      initial_size2);
+
+  // Memory is allocated lazily, so even though lists were created with
+  // different initial_size values, they'll have the same memory usage here.
+  size_t memory_usage1 = list1.MemoryUsageInBytes();
+  size_t memory_usage2 = list2.MemoryUsageInBytes();
+  EXPECT_EQ(memory_usage1, memory_usage2);
+
+  // Trigger memory allocation.
+  list1.AllocateAndConstruct<Point2D>();
+  list2.AllocateAndConstruct<Point2D>();
+
+  // Same object was created in both lists, but their memory usages grew
+  // differently, based on initial_size values lists were created with.
+  EXPECT_NE(list1.MemoryUsageInBytes(), list2.MemoryUsageInBytes());
+  EXPECT_GE(list1.MemoryUsageInBytes(), memory_usage1 + initial_size1);
+  EXPECT_GE(list2.MemoryUsageInBytes(), memory_usage2 + initial_size2);
+}
+
 TEST(ContiguousContainerTest, Alignment) {
   const size_t max_align = ALIGNOF(long double);
   ContiguousContainer<Point2D, max_align> list(kMaxPointSize);
 
   list.AllocateAndConstruct<Point2D>();
   EXPECT_EQ(0u, reinterpret_cast<intptr_t>(&list.last()) & (max_align - 1));
   list.AllocateAndConstruct<Point2D>();
   EXPECT_EQ(0u, reinterpret_cast<intptr_t>(&list.last()) & (max_align - 1));
   list.AllocateAndConstruct<Point3D>();
   EXPECT_EQ(0u, reinterpret_cast<intptr_t>(&list.last()) & (max_align - 1));
   list.AllocateAndConstruct<Point3D>();
   EXPECT_EQ(0u, reinterpret_cast<intptr_t>(&list.last()) & (max_align - 1));
   list.AllocateAndConstruct<Point2D>();
   EXPECT_EQ(0u, reinterpret_cast<intptr_t>(&list.last()) & (max_align - 1));
 
   list.AppendByMoving(&list[0], sizeof(Point2D));
   EXPECT_EQ(0u, reinterpret_cast<intptr_t>(&list.last()) & (max_align - 1));
   list.AppendByMoving(&list[1], sizeof(Point2D));
   EXPECT_EQ(0u, reinterpret_cast<intptr_t>(&list.last()) & (max_align - 1));
   list.AppendByMoving(&list[2], sizeof(Point3D));
   EXPECT_EQ(0u, reinterpret_cast<intptr_t>(&list.last()) & (max_align - 1));
   list.AppendByMoving(&list[3], sizeof(Point3D));
   EXPECT_EQ(0u, reinterpret_cast<intptr_t>(&list.last()) & (max_align - 1));
   list.AppendByMoving(&list[4], sizeof(Point2D));
   EXPECT_EQ(0u, reinterpret_cast<intptr_t>(&list.last()) & (max_align - 1));
 }
 
 }  // namespace
 }  // namespace cc