Improve the display of LoadLogs when truncation occurs....

net/base/load_log_unittest.cc

Index: net/base/load_log_unittest.cc
===================================================================
--- net/base/load_log_unittest.cc	(revision 31195)
+++ net/base/load_log_unittest.cc	(working copy)
@@ -18,10 +18,11 @@
 }
 
 TEST(LoadLogTest, Basic) {
-  scoped_refptr<LoadLog> log(new LoadLog);
+  scoped_refptr<LoadLog> log(new LoadLog(10));
 
   // Logs start off empty.
   EXPECT_EQ(0u, log->events().size());
+  EXPECT_EQ(0u, log->num_entries_truncated());
 
   // Add 3 entries.
 
@@ -31,6 +32,7 @@
            LoadLog::PHASE_END);
 
   EXPECT_EQ(3u, log->events().size());
+  EXPECT_EQ(0u, log->num_entries_truncated());
 
   ExpectLogContains(log, 0, MakeTime(0), LoadLog::TYPE_HOST_RESOLVER_IMPL,
                     LoadLog::PHASE_BEGIN);
@@ -45,32 +47,39 @@
 
 // Test that the log's size is strictly bounded.
 TEST(LoadLogTest, Truncation) {
-  scoped_refptr<LoadLog> log(new LoadLog);
+  size_t kMaxNumEntries = 10;
+  scoped_refptr<LoadLog> log(new LoadLog(kMaxNumEntries));
 
-  // Almost max it out.
-  for (size_t i = 0; i < LoadLog::kMaxNumEntries - 1; ++i) {
-    log->Add(MakeTime(0), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE);
+  // Max it out.
+  for (size_t i = 0; i < kMaxNumEntries; ++i) {
+    log->Add(MakeTime(i), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE);
   }
-  EXPECT_EQ(LoadLog::kMaxNumEntries - 1,
-            static_cast<int>(log->events().size()));
-  EXPECT_EQ(LoadLog::TYPE_CANCELLED,
-            log->events()[LoadLog::kMaxNumEntries - 2].type);
 
-  // Max it out (none of these get appended to the log).
+  EXPECT_EQ(kMaxNumEntries, log->events().size());
+  EXPECT_EQ(0u, log->num_entries_truncated());
+
+  // Check the last entry.
+  ExpectLogContains(log, 9, MakeTime(9),
+                    LoadLog::TYPE_CANCELLED,
+                    LoadLog::PHASE_NONE);
+
+  // Add three entries while maxed out (will cause truncation)
   log->Add(MakeTime(0), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE);
-  log->Add(MakeTime(0), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE);
-  log->Add(MakeTime(0), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE);
+  log->Add(MakeTime(1), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE);
+  log->Add(MakeTime(2), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE);
 
-  EXPECT_EQ(LoadLog::kMaxNumEntries, log->events().size());
+  EXPECT_EQ(kMaxNumEntries, log->events().size());
+  EXPECT_EQ(3u, log->num_entries_truncated());
 
-  // We terminated with a "truncation" event.
-  ExpectLogContains(log, LoadLog::kMaxNumEntries - 1, MakeTime(0),
-                    LoadLog::TYPE_LOG_TRUNCATED, LoadLog::PHASE_NONE);
+  // Check the last entry -- it should be the final entry we added.
+  ExpectLogContains(log, 9, MakeTime(2),
+                    LoadLog::TYPE_CANCELLED,
+                    LoadLog::PHASE_NONE);
 }
 
 TEST(LoadLogTest, Append) {
-  scoped_refptr<LoadLog> log1(new LoadLog);
-  scoped_refptr<LoadLog> log2(new LoadLog);
+  scoped_refptr<LoadLog> log1(new LoadLog(10));
+  scoped_refptr<LoadLog> log2(new LoadLog(10));
 
   log1->Add(MakeTime(0), LoadLog::TYPE_HOST_RESOLVER_IMPL,
             LoadLog::PHASE_BEGIN);
@@ -84,6 +93,7 @@
   log2->Add(MakeTime(19), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE);
 
   EXPECT_EQ(3u, log1->events().size());
+  EXPECT_EQ(0u, log1->num_entries_truncated());
 
   ExpectLogContains(log1, 0, MakeTime(0), LoadLog::TYPE_HOST_RESOLVER_IMPL,
                     LoadLog::PHASE_BEGIN);
@@ -99,22 +109,25 @@
   // Append() should also respect the maximum number of entries bound.
   // (This is basically the same test as LoadLogTest.Truncation).
 
-  // Create two load logs, which are 2/3 capcity.
-  scoped_refptr<LoadLog> log1(new LoadLog);
-  scoped_refptr<LoadLog> log2(new LoadLog);
-  for (size_t i = 0; i < 2 * LoadLog::kMaxNumEntries / 3; ++i) {
-    log1->Add(MakeTime(1), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE);
-    log2->Add(MakeTime(2), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE);
+  // Create two load logs, which both have 6 out of 10 entries filled.
+  size_t kMaxNumEntries = 10;
+  scoped_refptr<LoadLog> log1(new LoadLog(kMaxNumEntries));
+  scoped_refptr<LoadLog> log2(new LoadLog(kMaxNumEntries));
+  for (size_t i = 0; i < 6; ++i) {
+    log1->Add(MakeTime(i), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE);
+    log2->Add(MakeTime(2 * i), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE);
   }
 
   // Append log2 to log1.
   log1->Append(log2);
 
-  EXPECT_EQ(LoadLog::kMaxNumEntries, log1->events().size());
+  // The combined log totalled 12 entries, so 2 must have been dropped.
+  EXPECT_EQ(10u, log1->events().size());
+  EXPECT_EQ(2u, log1->num_entries_truncated());
 
-  // We terminated with a "truncation" event.
-  ExpectLogContains(log1, LoadLog::kMaxNumEntries - 1, MakeTime(2),
-                    LoadLog::TYPE_LOG_TRUNCATED, LoadLog::PHASE_NONE);
+  // Combined log should end with the final entry of log2.
+  ExpectLogContains(log1, 9, MakeTime(10), LoadLog::TYPE_CANCELLED,
+                    LoadLog::PHASE_NONE);
 }
 
 TEST(LoadLogTest, EventTypeToString) {