Add cooldown to LeakDetectorImpl leak report generation

components/metrics/leak_detector/leak_detector_impl.cc

 // Copyright 2015 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 "leak_detector_impl.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 #include <algorithm>  // For std::move
 #include <iterator>  // For std::advance
 #include <new>
+#include <utility>
 
 #include "base/hash.h"
 #include "base/process/process_handle.h"
 #include "components/metrics/leak_detector/call_stack_table.h"
 #include "components/metrics/leak_detector/custom_allocator.h"
 #include "components/metrics/leak_detector/ranked_set.h"
 
 namespace metrics {
 namespace leak_detector {
 
@@ skipping 154 matching lines @@
   RankedSet size_ranked_set(kRankedSetSize);
   for (size_t i = 0; i < size_entries_.size(); ++i) {
     const AllocSizeEntry& entry = size_entries_[i];
     ValueType size_value(IndexToSize(i));
     size_ranked_set.Add(size_value, entry.GetNetAllocs());
   }
   size_leak_analyzer_.AddSample(std::move(size_ranked_set));
 
   RecordCurrentAllocationDataInHistory();
 
+  UpdateLeakCooldowns();
+
   // Get suspected leaks by size.
   for (const ValueType& size_value : size_leak_analyzer_.suspected_leaks()) {
     uint32_t size = size_value.size();
     AllocSizeEntry* entry = &size_entries_[SizeToIndex(size)];
     if (entry->stack_table)
       continue;
     entry->stack_table = new (CustomAllocator::Allocate(sizeof(CallStackTable)))
         CallStackTable(call_stack_suspicion_threshold_);
     ++num_stack_tables_;
   }
@@ skipping 11 matching lines @@
       continue;
 
     size_t size = IndexToSize(i);
 
     // Get suspected leaks by call stack.
     stack_table->TestForLeaks();
     const LeakAnalyzer& leak_analyzer = stack_table->leak_analyzer();
     for (const ValueType& call_stack_value : leak_analyzer.suspected_leaks()) {
       const CallStack* call_stack = call_stack_value.call_stack();
 
+      if (!ReadyToGenerateReport(size, call_stack))
+        continue;
+
       // Return reports by storing in |*reports|.
       reports->resize(reports->size() + 1);
       LeakReport* report = &reports->back();
       report->alloc_size_bytes_ = size;
       report->call_stack_.resize(call_stack->depth);
       for (size_t j = 0; j < call_stack->depth; ++j) {
         report->call_stack_[j] = GetOffset(call_stack->stack[j]);
       }
 
       StoreHistoricalDataInReport(size, call_stack, report);
+      ResetLeakCooldown(size, call_stack);
     }
   }
 }
 
 LeakDetectorImpl::AllocSizeEntry::AllocSizeEntry() : num_allocs(0),
                                                      num_frees(0),
                                                      stack_table(nullptr) {}
 
 LeakDetectorImpl::AllocSizeEntry::~AllocSizeEntry() {}
 
@@ skipping 67 matching lines @@
   while (src_iter != src.end() && dest_iter != dest->end()) {
     const RankedSet& ranked_call_sites = *src_iter;
     auto find_call_site_iter = ranked_call_sites.FindCallStack(call_site);
     if (find_call_site_iter != ranked_call_sites.end())
       dest_iter->count_for_call_stack = find_call_site_iter->count;
     ++src_iter;
     ++dest_iter;
   }
 }
 
+bool LeakDetectorImpl::ReadyToGenerateReport(
+    size_t size,
+    const CallStack* call_stack) const {
+  return cooldowns_per_leak_.find(std::make_pair(size, call_stack)) ==
+         cooldowns_per_leak_.end();
+}
+
+void LeakDetectorImpl::ResetLeakCooldown(size_t size,
+                                         const CallStack* call_stack) {
+  cooldowns_per_leak_[std::make_pair(size, call_stack)] =
+      kNumSizeEntriesInHistory;
+}
+
+void LeakDetectorImpl::UpdateLeakCooldowns() {
+  for (auto iter = cooldowns_per_leak_.begin();
+       iter != cooldowns_per_leak_.end();
+       /* No iterating here */) {
+    if (--iter->second > 0) {
+      ++iter;
+    } else {
+      cooldowns_per_leak_.erase(iter++);
+    }
+  }
+}
+
 }  // namespace leak_detector
 }  // namespace metrics