Store alloc history data in memory leak report protobuf

components/metrics/leak_detector/leak_detector.h

 // 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.
 
 #ifndef COMPONENTS_METRICS_LEAK_DETECTOR_LEAK_DETECTOR_H_
 #define COMPONENTS_METRICS_LEAK_DETECTOR_LEAK_DETECTOR_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
 #include <vector>
 
 #include "base/feature_list.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
+#include "components/metrics/proto/memory_leak_report.pb.h"
 
 namespace base {
 template <typename T>
 struct DefaultLazyInstanceTraits;
 }
 
 namespace metrics {
 
 namespace leak_detector {
 class LeakDetectorImpl;
@@ skipping 10 matching lines @@
 // These member functions are thread-safe:
 // - AllocHook
 // - FreeHook
 // - AddObserver
 // - RemoveObserver
 //
 // All other functions must always be called from the same thread. This is
 // enforced with a DCHECK.
 class LeakDetector {
  public:
-  // Contains a report of a detected memory leak.
-  struct LeakReport {
-    LeakReport();
-    LeakReport(const LeakReport& other);
-    ~LeakReport();
-
-    size_t alloc_size_bytes;
-
-    // Unlike the CallStack struct, which consists of addresses, this call stack
-    // will contain offsets in the executable binary.
-    std::vector<uintptr_t> call_stack;
-  };
-
   // Interface for receiving leak reports.
   class Observer {
    public:
     virtual ~Observer() {}
 
-    // Called by leak detector to report a leak.
-    virtual void OnLeakFound(const LeakReport& report) = 0;
+    // Called by leak detector to report leaks.
+    virtual void OnLeaksFound(
+        const std::vector<MemoryLeakReportProto>& reports) = 0;
   };
 
   // Returns the sole instance, or creates it if it hasn't already been created.
   static LeakDetector* GetInstance();
 
   // Initializer arguments:
   // sampling_rate:
   //     Pseudorandomly sample a fraction of the incoming allocations and frees,
   //     based on hash values. Setting to 0 means no allocs/frees are sampled.
   //     Setting to 1.0 or more means all allocs/frees are sampled. Anything in
@@ skipping 38 matching lines @@
   // Allocator hook function that processes each free. Performs sampling and
   // passes the allocation address |ptr| to |impl_|.
   static void FreeHook(const void* ptr);
 
   // Give an pointer |ptr|, computes a hash of the pointer value and compares it
   // against |sampling_factor_| to determine if it should be sampled. This
   // allows the same pointer to be sampled during both alloc and free.
   bool ShouldSample(const void* ptr) const;
 
   // Notifies all Observers in |observers_| with the given vector of leak
-  // reports.
-  void NotifyObservers(const std::vector<LeakReport>& reports);
+  // report protobufs.
+  void NotifyObservers(const std::vector<MemoryLeakReportProto>& reports);
 
   // List of observers to notify when there's a leak report.
   // TODO(sque): Consider using ObserverListThreadSafe instead.
   base::ObserverList<Observer> observers_;
 
   // For atomic access to |observers_|.
   base::Lock observers_lock_;
 
   // Handles leak detection logic. Must be called under lock as LeakDetectorImpl
   // uses shared resources.
@@ skipping 24 matching lines @@
   // corresponds to the allowable range of |sampling_rate| passed in during
   // initialization: [0.0f, 1.0f] -> [0, UINT64_MAX].
   uint64_t sampling_factor_;
 
   DISALLOW_COPY_AND_ASSIGN(LeakDetector);
 };
 
 }  // namespace metrics
 
 #endif  // COMPONENTS_METRICS_LEAK_DETECTOR_LEAK_DETECTOR_H_