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>
+
 #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"
 
 #if defined(OS_CHROMEOS)
 #include <link.h>  // for dl_iterate_phdr
 #else
 #error "Getting binary mapping info is not supported on this platform."
 #endif  // defined(OS_CHROMEOS)
 
 namespace metrics {
 
-using LeakReport = LeakDetector::LeakReport;
 using InternalLeakReport = leak_detector::LeakDetectorImpl::LeakReport;
 template <typename T>
 using InternalVector = leak_detector::LeakDetectorImpl::InternalVector<T>;
 
 namespace {
 
 // Add the thread-local alloc size count to the shared alloc size count
 // (LeakDetector::total_alloc_size_) whenever the local counter reaches
 // |LeakDetector::analysis_interval_bytes_| divided by this value. Choose a
 // high enough value that there is plenty of granularity, but low enough that a
@@ skipping 55 matching lines @@
 // Convert a pointer to a hash value. Returns only the upper eight bits.
 inline uint64_t PointerToHash(const void* ptr) {
   // The input data is the pointer address, not the location in memory pointed
   // to by the pointer.
   // The multiplier is taken from Farmhash code:
   //   https://github.com/google/farmhash/blob/master/src/farmhash.cc
   const uint64_t kMultiplier = 0x9ddfea08eb382d69ULL;
   return reinterpret_cast<uint64_t>(ptr) * kMultiplier;
 }
 
-// Converts a vector of leak reports generated by LeakDetectorImpl
-// (InternalLeakReport) to a vector of leak reports suitable for sending to
-// LeakDetector's observers (LeakReport).
-void GetReportsForObservers(
-    const InternalVector<InternalLeakReport>& leak_reports,
-    std::vector<LeakReport>* reports_for_observers) {
-  reports_for_observers->clear();
-  reports_for_observers->reserve(leak_reports.size());
-  for (const InternalLeakReport& report : leak_reports) {
-    reports_for_observers->push_back(LeakReport());
-    LeakReport* new_report = &reports_for_observers->back();
+// Converts an memory leak report generated by LeakDetectorImpl
+// (InternalLeakReport) to protobuf format (MemoryLeakReportProto).
+MemoryLeakReportProto ConvertLeakReportToProto(
+    const InternalLeakReport& report) {
+  MemoryLeakReportProto proto;
 
-    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]));
-    }
+  proto.set_size_bytes(report.alloc_size_bytes());
+  for (auto call_stack_entry : report.call_stack())

[Ilya Sherman, 2016/04/14 01:08:45]

nit: Most Chromium code that I've seen prefers to always use curly braces with
loops, even one-line loops.

[Simon Que, 2016/04/14 01:24:30]

Done.

+    proto.add_call_stack(call_stack_entry);
+
+  for (const auto& entry : report.alloc_breakdown_history()) {
+    auto* proto_entry = proto.add_alloc_breakdown_history();
+    for (const uint32_t count : entry.counts_by_size)
+      proto_entry->add_counts_by_size(count);
+    proto_entry->set_count_for_call_stack(entry.count_for_call_stack);
   }
+
+  return proto;
 }
 
 // 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;
 
 // Returns the contents of |g_hook_data_tls| as a HookData structure.
@@ skipping 14 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::LeakReport() {}
-
-LeakDetector::LeakReport::LeakReport(const LeakReport& other) = default;
-
-LeakDetector::LeakReport::~LeakReport() {}
-
 // static
 LeakDetector* LeakDetector::GetInstance() {
   return g_instance.Pointer();
 }
 
 void LeakDetector::Init(float sampling_rate,
                         size_t max_call_stack_unwind_depth,
                         uint64_t analysis_interval_bytes,
                         uint32_t size_suspicion_threshold,
                         uint32_t call_stack_suspicion_threshold) {
@@ skipping 95 matching lines @@
     if (total_alloc_size >
         detector->last_analysis_alloc_size_ + analysis_interval_bytes) {
       // Try to maintain regular intervals of size |analysis_interval_bytes_|.
       detector->last_analysis_alloc_size_ =
           total_alloc_size - total_alloc_size % analysis_interval_bytes;
 
       InternalVector<InternalLeakReport> leak_reports;
       detector->impl_->TestForLeaks(&leak_reports);
 
       // Pass leak reports to observers.
-      std::vector<LeakReport> leak_reports_for_observers;
-      GetReportsForObservers(leak_reports, &leak_reports_for_observers);
-      detector->NotifyObservers(leak_reports_for_observers);
+      std::vector<MemoryLeakReportProto> leak_report_protos;
+      std::transform(leak_reports.begin(), leak_reports.end(),
+                     leak_report_protos.begin(), &ConvertLeakReportToProto);
+      detector->NotifyObservers(leak_report_protos);
     }
   }
 
   {
     // The internal memory of |stack| should be freed before setting
     // |entered_hook| to false at the end of this function. Free it here by
     // moving the internal memory to a temporary variable that will go out of
     // scope.
     std::vector<void*> dummy_stack;
     dummy_stack.swap(stack);
@@ skipping 22 matching lines @@
   }
 
   hook_data.entered_hook = false;
   StoreHookDataToTLS(hook_data);
 }
 
 inline bool LeakDetector::ShouldSample(const void* ptr) const {
   return PointerToHash(ptr) < sampling_factor_;
 }
 
-void LeakDetector::NotifyObservers(const std::vector<LeakReport>& reports) {
+void LeakDetector::NotifyObservers(
+    const std::vector<MemoryLeakReportProto>& reports) {
   if (reports.empty())
     return;
 
   if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
         base::Bind(&LeakDetector::NotifyObservers, base::Unretained(this),
                    reports));
     return;
   }
 
-  for (const LeakReport& report : reports) {
+  {
     base::AutoLock lock(observers_lock_);
-    FOR_EACH_OBSERVER(Observer, observers_, OnLeakFound(report));
+    FOR_EACH_OBSERVER(Observer, observers_, OnLeaksFound(reports));
   }
 }
 
 }  // namespace metrics