Update from https://crrev.com/320343

base/tracked_objects.cc

 // Copyright (c) 2012 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 "base/tracked_objects.h"
 
 #include <limits.h>
 #include <stdlib.h>
 
 #include "base/atomicops.h"
@@ skipping 145 matching lines @@
 }
 
 int32 DeathData::queue_duration_max() const {
   return queue_duration_max_;
 }
 
 int32 DeathData::queue_duration_sample() const {
   return queue_duration_sample_;
 }
 
-void DeathData::ResetMax() {
-  run_duration_max_ = 0;
-  queue_duration_max_ = 0;
-}
-
 void DeathData::Clear() {
   count_ = 0;
   run_duration_sum_ = 0;
   run_duration_max_ = 0;
   run_duration_sample_ = 0;
   queue_duration_sum_ = 0;
   queue_duration_max_ = 0;
   queue_duration_sample_ = 0;
 }
 
@@ skipping 44 matching lines @@
 
 //------------------------------------------------------------------------------
 Births::Births(const Location& location, const ThreadData& current)
     : BirthOnThread(location, current),
       birth_count_(1) { }
 
 int Births::birth_count() const { return birth_count_; }
 
 void Births::RecordBirth() { ++birth_count_; }
 
-void Births::ForgetBirth() { --birth_count_; }
-
-void Births::Clear() { birth_count_ = 0; }
-
 //------------------------------------------------------------------------------
 // ThreadData maintains the central data for all births and deaths on a single
 // thread.
 
 // TODO(jar): We should pull all these static vars together, into a struct, and
 // optimize layout so that we benefit from locality of reference during accesses
 // to them.
 
 // static
 NowFunction* ThreadData::now_function_ = NULL;
@@ skipping 143 matching lines @@
     return;
   }
   // We must NOT do any allocations during this callback.
   // Using the simple linked lists avoids all allocations.
   DCHECK_EQ(this->next_retired_worker_, reinterpret_cast<ThreadData*>(NULL));
   this->next_retired_worker_ = first_retired_worker_;
   first_retired_worker_ = this;
 }
 
 // static
-void ThreadData::Snapshot(bool reset_max, ProcessDataSnapshot* process_data) {
+void ThreadData::Snapshot(ProcessDataSnapshot* process_data) {
   // Add births that have run to completion to |collected_data|.
   // |birth_counts| tracks the total number of births recorded at each location
   // for which we have not seen a death count.
   BirthCountMap birth_counts;
-  ThreadData::SnapshotAllExecutedTasks(reset_max, process_data, &birth_counts);
+  ThreadData::SnapshotAllExecutedTasks(process_data, &birth_counts);
 
   // Add births that are still active -- i.e. objects that have tallied a birth,
   // but have not yet tallied a matching death, and hence must be either
   // running, queued up, or being held in limbo for future posting.
   for (BirthCountMap::const_iterator it = birth_counts.begin();
        it != birth_counts.end(); ++it) {
     if (it->second > 0) {
       process_data->tasks.push_back(
           TaskSnapshot(*it->first, DeathData(it->second), "Still_Alive"));
     }
@@ skipping 162 matching lines @@
 
   ThreadData* current_thread_data = stopwatch.GetThreadData();
   if (!current_thread_data)
     return;
 
   int32 queue_duration = 0;
   current_thread_data->TallyADeath(*birth, queue_duration, stopwatch);
 }
 
 // static
-void ThreadData::SnapshotAllExecutedTasks(bool reset_max,
-                                          ProcessDataSnapshot* process_data,
+void ThreadData::SnapshotAllExecutedTasks(ProcessDataSnapshot* process_data,
                                           BirthCountMap* birth_counts) {
   if (!kTrackAllTaskObjects)
     return;  // Not compiled in.
 
   // Get an unchanging copy of a ThreadData list.
   ThreadData* my_list = ThreadData::first();
 
   // Gather data serially.
   // This hackish approach *can* get some slighly corrupt tallies, as we are
   // grabbing values without the protection of a lock, but it has the advantage
   // of working even with threads that don't have message loops.  If a user
   // sees any strangeness, they can always just run their stats gathering a
   // second time.
   for (ThreadData* thread_data = my_list;
        thread_data;
        thread_data = thread_data->next()) {
-    thread_data->SnapshotExecutedTasks(reset_max, process_data, birth_counts);
+    thread_data->SnapshotExecutedTasks(process_data, birth_counts);
   }
 }
 
-void ThreadData::SnapshotExecutedTasks(bool reset_max,
-                                       ProcessDataSnapshot* process_data,
+void ThreadData::SnapshotExecutedTasks(ProcessDataSnapshot* process_data,
                                        BirthCountMap* birth_counts) {
   // Get copy of data, so that the data will not change during the iterations
   // and processing.
   ThreadData::BirthMap birth_map;
   ThreadData::DeathMap death_map;
   ThreadData::ParentChildSet parent_child_set;
-  SnapshotMaps(reset_max, &birth_map, &death_map, &parent_child_set);
+  SnapshotMaps(&birth_map, &death_map, &parent_child_set);
 
   for (ThreadData::DeathMap::const_iterator it = death_map.begin();
        it != death_map.end(); ++it) {
     process_data->tasks.push_back(
         TaskSnapshot(*it->first, it->second, thread_name()));
     (*birth_counts)[it->first] -= it->first->birth_count();
   }
 
   for (ThreadData::BirthMap::const_iterator it = birth_map.begin();
        it != birth_map.end(); ++it) {
     (*birth_counts)[it->second] += it->second->birth_count();
   }
 
   if (!kTrackParentChildLinks)
     return;
 
   for (ThreadData::ParentChildSet::const_iterator it = parent_child_set.begin();
        it != parent_child_set.end(); ++it) {
     process_data->descendants.push_back(ParentChildPairSnapshot(*it));
   }
 }
 
 // This may be called from another thread.
-void ThreadData::SnapshotMaps(bool reset_max,
-                              BirthMap* birth_map,
+void ThreadData::SnapshotMaps(BirthMap* birth_map,
                               DeathMap* death_map,
                               ParentChildSet* parent_child_set) {
   base::AutoLock lock(map_lock_);
   for (BirthMap::const_iterator it = birth_map_.begin();
        it != birth_map_.end(); ++it)
     (*birth_map)[it->first] = it->second;
   for (DeathMap::iterator it = death_map_.begin();
        it != death_map_.end(); ++it) {
     (*death_map)[it->first] = it->second;
-    if (reset_max)
-      it->second.ResetMax();
   }
 
   if (!kTrackParentChildLinks)
     return;
 
   for (ParentChildSet::iterator it = parent_child_set_.begin();
        it != parent_child_set_.end(); ++it)
     parent_child_set->insert(*it);
 }
 
-// static
-void ThreadData::ResetAllThreadData() {
-  ThreadData* my_list = first();
-
-  for (ThreadData* thread_data = my_list;
-       thread_data;
-       thread_data = thread_data->next())
-    thread_data->Reset();
-}
-
-void ThreadData::Reset() {
-  base::AutoLock lock(map_lock_);
-  for (DeathMap::iterator it = death_map_.begin();
-       it != death_map_.end(); ++it)
-    it->second.Clear();
-  for (BirthMap::iterator it = birth_map_.begin();
-       it != birth_map_.end(); ++it)
-    it->second->Clear();
-}
-
 static void OptionallyInitializeAlternateTimer() {
   NowFunction* alternate_time_source = GetAlternateTimeSource();
   if (alternate_time_source)
     ThreadData::SetAlternateTimeSource(alternate_time_source);
 }
 
 bool ThreadData::Initialize() {
   if (!kTrackAllTaskObjects)
     return false;  // Not compiled in.
   if (status_ >= DEACTIVATED)
@@ skipping 303 matching lines @@
     : process_id(base::GetCurrentProcId()) {
 #else
     : process_id(0) {
 #endif
 }
 
 ProcessDataSnapshot::~ProcessDataSnapshot() {
 }
 
 }  // namespace tracked_objects