Store alloc history data in memory leak report protobuf

chrome/browser/metrics/leak_detector_controller_unittest.cc

 // Copyright 2016 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 "chrome/browser/metrics/leak_detector_controller.h"
 
 #include <set>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
@@ skipping 51 matching lines @@
   EXPECT_EQ(4U, proto.max_stack_depth());
   EXPECT_EQ(32U * 1024 * 1024, proto.analysis_interval_bytes());
   EXPECT_EQ(4U, proto.size_suspicion_threshold());
   EXPECT_EQ(4U, proto.call_stack_suspicion_threshold());
 
   // No more reports.
   controller->GetLeakReports(&stored_reports);
   ASSERT_EQ(0U, stored_reports.size());
 }
 
+TEST(LeakDetectorControllerTest, SingleReportHistory) {
+  LeakReport report;
+  report.alloc_breakdown_history.resize(3);
+  report.alloc_breakdown_history[0].counts_by_size = {100, 200, 300};
+  report.alloc_breakdown_history[0].count_for_call_stack = 15;
+  report.alloc_breakdown_history[1].counts_by_size = {150, 250, 350, 650};
+  report.alloc_breakdown_history[1].count_for_call_stack = 30;
+  report.alloc_breakdown_history[2].counts_by_size = {200, 300, 400, 700, 800};
+  report.alloc_breakdown_history[2].count_for_call_stack = 45;
+
+  TestLeakDetectorController* controller = &g_instance.Get();
+  controller->OnLeakFound(report);
+
+  std::vector<MemoryLeakReportProto> stored_reports;
+  controller->GetLeakReports(&stored_reports);
+  ASSERT_EQ(1U, stored_reports.size());
+
+  const auto& history = stored_reports[0].alloc_breakdown_history();
+  ASSERT_EQ(3, history.size());
+
+  ASSERT_EQ(3, history.Get(0).counts_by_size().size());
+  EXPECT_EQ(100U, history.Get(0).counts_by_size(0));
+  EXPECT_EQ(200U, history.Get(0).counts_by_size(1));
+  EXPECT_EQ(300U, history.Get(0).counts_by_size(2));
+  EXPECT_EQ(15U, history.Get(0).count_for_call_stack());
+
+  ASSERT_EQ(4, history.Get(1).counts_by_size_size());
+  EXPECT_EQ(150U, history.Get(1).counts_by_size(0));
+  EXPECT_EQ(250U, history.Get(1).counts_by_size(1));
+  EXPECT_EQ(350U, history.Get(1).counts_by_size(2));
+  EXPECT_EQ(650U, history.Get(1).counts_by_size(3));
+  EXPECT_EQ(30U, history.Get(1).count_for_call_stack());
+
+  ASSERT_EQ(5, history.Get(2).counts_by_size_size());
+  EXPECT_EQ(200U, history.Get(2).counts_by_size(0));
+  EXPECT_EQ(300U, history.Get(2).counts_by_size(1));
+  EXPECT_EQ(400U, history.Get(2).counts_by_size(2));
+  EXPECT_EQ(700U, history.Get(2).counts_by_size(3));
+  EXPECT_EQ(800U, history.Get(2).counts_by_size(4));
+  EXPECT_EQ(45U, history.Get(2).count_for_call_stack());
+
+  // No more reports.
+  controller->GetLeakReports(&stored_reports);
+  ASSERT_EQ(0U, stored_reports.size());
+}
+
 TEST(LeakDetectorControllerTest, MultipleReportsSeparately) {
   TestLeakDetectorController* controller = &g_instance.Get();
   std::vector<MemoryLeakReportProto> stored_reports;
 
   // Pass in first report.
   LeakReport report;
   report.alloc_size_bytes = 8;
   report.call_stack = {1, 2, 3, 4};
 
   controller->OnLeakFound(report);
@@ skipping 97 matching lines @@
   EXPECT_EQ(13U, stored_reports[2].call_stack().Get(4));
   EXPECT_EQ(14U, stored_reports[2].call_stack().Get(5));
   EXPECT_EQ(15U, stored_reports[2].call_stack().Get(6));
   EXPECT_EQ(16U, stored_reports[2].call_stack().Get(7));
 
   controller->GetLeakReports(&stored_reports);
   ASSERT_EQ(0U, stored_reports.size());
 }
 
 }  // namespace metrics