Store alloc history data in memory leak report protobuf

components/metrics/leak_detector/leak_detector.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 "components/metrics/leak_detector/leak_detector.h"
 
 #include <stdint.h>
 
+#include <algorithm>  // For std::transform

[Ilya Sherman, 2016/04/13 00:07:12]

nit: I'd omit the comment, since it's likely to drift out of date.

[Ilya Sherman, 2016/04/13 00:07:12]

... though, actually, you don't seem to use std::transform in the code.  Is this
include just not needed in the latest patch set?

[Simon Que, 2016/04/13 22:41:31]

Yes, I forgot to delete it when I no longer used it. But I'm using it in the new
patch set.

+
 #include "base/allocator/allocator_extension.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/threading/thread_local.h"
 #include "components/metrics/leak_detector/custom_allocator.h"
 #include "components/metrics/leak_detector/leak_detector_impl.h"
 #include "content/public/browser/browser_thread.h"
 
@@ skipping 92 matching lines @@
   for (const InternalLeakReport& report : leak_reports) {
     reports_for_observers->push_back(LeakReport());
     LeakReport* new_report = &reports_for_observers->back();
 
     new_report->alloc_size_bytes = report.alloc_size_bytes();
     if (!report.call_stack().empty()) {
       new_report->call_stack.resize(report.call_stack().size());
       memcpy(new_report->call_stack.data(), report.call_stack().data(),
              report.call_stack().size() * sizeof(report.call_stack()[0]));
     }
+
+    new_report->alloc_breakdown_history.reserve(
+        report.alloc_breakdown_history().size());

[Ilya Sherman, 2016/04/13 00:07:12]

I think you can skip this reserve() call, unless the vector size is actually
quite large.  It makes the code somewhat more complex to read, whereas I think
the performance benefit is likely to be negligible.

[Simon Que, 2016/04/13 22:41:31]

Done.

+    for (const auto& entry : report.alloc_breakdown_history()) {
+      LeakReport::AllocationBreakdown new_entry;
+      new_entry.counts_by_size.reserve(entry.counts_by_size.size());

[Ilya Sherman, 2016/04/13 00:07:12]

Ditto here, especially since you write the vector contents in a single call,
rather than adding elements one at a time.

[Simon Que, 2016/04/13 22:41:31]

Done.

+      new_entry.counts_by_size.assign(entry.counts_by_size.begin(),
+                                      entry.counts_by_size.end());
+      new_entry.count_for_call_stack = entry.count_for_call_stack;
+      new_report->alloc_breakdown_history.push_back(new_entry);
+    }
   }
 }
 
 // The only instance of LeakDetector that should be used.
 base::LazyInstance<LeakDetector>::Leaky g_instance = LAZY_INSTANCE_INITIALIZER;
 
 // Thread-specific data to be used by hook functions.
 base::LazyInstance<base::ThreadLocalPointer<void>>::Leaky g_hook_data_tls =
     LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 15 matching lines @@
 inline void StoreHookDataToTLS(HookData hook_data) {
   // NOTE: |alloc_size| loses its upper bit when it gets stored in the TLS here.
   // The effective max value of |alloc_size| is thus half its nominal max value.
   uintptr_t ptr_value =
       (hook_data.entered_hook ? 1 : 0) | (hook_data.alloc_size << 1);
   g_hook_data_tls.Get().Set(reinterpret_cast<void*>(ptr_value));
 }
 
 }  // namespace
 
+LeakDetector::LeakReport::AllocationBreakdown::AllocationBreakdown()
+    : count_for_call_stack(0) {}
+
+LeakDetector::LeakReport::AllocationBreakdown::~AllocationBreakdown() {}
+
 LeakDetector::LeakReport::LeakReport() {}
 
 LeakDetector::LeakReport::~LeakReport() {}
 
 // static
 LeakDetector* LeakDetector::GetInstance() {
   return g_instance.Pointer();
 }
 
 void LeakDetector::Init(float sampling_rate,
@@ skipping 163 matching lines @@
     return;
   }
 
   for (const LeakReport& report : reports) {
     base::AutoLock lock(observers_lock_);
     FOR_EACH_OBSERVER(Observer, observers_, OnLeakFound(report));
   }
 }
 
 }  // namespace metrics