Revert of Leak reports collect information about the last uptrend

components/metrics/leak_detector/call_stack_table.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 "components/metrics/leak_detector/call_stack_table.h"
 
 #include <algorithm>
 
 #include "components/metrics/leak_detector/call_stack_manager.h"
 
@@ skipping 24 matching lines @@
 CallStackTable::CallStackTable(int call_stack_suspicion_threshold)
     : num_allocs_(0),
       num_frees_(0),
       entry_map_(kInitialHashTableSize),
       leak_analyzer_(kMaxCountOfSuspciousStacks,
                      call_stack_suspicion_threshold) {}
 
 CallStackTable::~CallStackTable() {}
 
 void CallStackTable::Add(const CallStack* call_stack) {
-  ++entry_map_[call_stack].count;
+  ++entry_map_[call_stack];
   ++num_allocs_;
 }
 
 void CallStackTable::Remove(const CallStack* call_stack) {
   auto iter = entry_map_.find(call_stack);
   if (iter == entry_map_.end())
     return;
-  uint32_t& count_for_call_stack = iter->second.count;
+  uint32_t& count_for_call_stack = iter->second;
   --count_for_call_stack;
   ++num_frees_;
 
   // Delete zero-alloc entries to free up space.
   if (count_for_call_stack == 0)
     entry_map_.erase(iter);
 }
 
 void CallStackTable::TestForLeaks() {
   // Add all entries to the ranked list.
   RankedSet ranked_entries(kMaxCountOfSuspciousStacks);
   GetTopCallStacks(&ranked_entries);
   leak_analyzer_.AddSample(std::move(ranked_entries));
 }
 
 void CallStackTable::GetTopCallStacks(RankedSet* top_entries) const {
-  for (const auto& call_stack_count_info : entry_map_) {
-    top_entries->AddCallStack(call_stack_count_info.first,
-                              call_stack_count_info.second.count);
+  for (const auto& call_stack_and_count : entry_map_) {
+    top_entries->AddCallStack(call_stack_and_count.first,
+                              call_stack_and_count.second);
   }
 }
 
-void CallStackTable::UpdateLastDropInfo(size_t timestamp) {
-  for (auto& call_stack_and_info : entry_map_) {
-    auto& count_info = call_stack_and_info.second;
-
-    // If the |previous_count| is 0 then we need to initialize info.
-    if (count_info.previous_count == 0 ||
-        count_info.count < count_info.previous_count) {
-      count_info.last_drop_timestamp = timestamp;
-      count_info.last_drop_count = count_info.count;
-    }
-    count_info.previous_count = count_info.count;
-  }
-}
-
-void CallStackTable::GetLastUptrendInfo(
-    const CallStack* call_stack, size_t timestamp, size_t* timestamp_delta,
-    uint32_t* count_delta) const {
-  const auto& call_stack_count_info_iter = entry_map_.find(call_stack);
-
-  if (call_stack_count_info_iter != entry_map_.end()) {
-    const auto& count_info = call_stack_count_info_iter->second;
-    *timestamp_delta = timestamp - count_info.last_drop_timestamp;
-    *count_delta = count_info.count - count_info.last_drop_count;
-  } else {
-    DLOG(WARNING) << "Accessing information about a call stack that has not "
-                  << "been recorded";
-    *timestamp_delta = timestamp;
-    *count_delta = 0;
-  }
-}
-
 }  // namespace leak_detector
 }  // namespace metrics