Update from https://crrev.com/320343

base/tracked_objects_unittest.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.
 
 // Test of classes in the tracked_objects.h classes.
 
 #include "base/tracked_objects.h"
 
 #include <stddef.h>
 
@@ skipping 120 matching lines @@
 
   EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
   ThreadData* data = ThreadData::Get();
   EXPECT_TRUE(ThreadData::first());  // Now class was constructed.
   ASSERT_TRUE(data);
   EXPECT_FALSE(data->next());
   EXPECT_EQ(data, ThreadData::Get());
   ThreadData::BirthMap birth_map;
   ThreadData::DeathMap death_map;
   ThreadData::ParentChildSet parent_child_set;
-  data->SnapshotMaps(false, &birth_map, &death_map, &parent_child_set);
+  data->SnapshotMaps(&birth_map, &death_map, &parent_child_set);
   EXPECT_EQ(0u, birth_map.size());
   EXPECT_EQ(0u, death_map.size());
   EXPECT_EQ(0u, parent_child_set.size());
 
   // Clean up with no leaking.
   Reset();
 
   // Do it again, just to be sure we reset state completely.
   EXPECT_TRUE(ThreadData::InitializeAndSetTrackingStatus(
       ThreadData::PROFILING_CHILDREN_ACTIVE));
   EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
   data = ThreadData::Get();
   EXPECT_TRUE(ThreadData::first());  // Now class was constructed.
   ASSERT_TRUE(data);
   EXPECT_FALSE(data->next());
   EXPECT_EQ(data, ThreadData::Get());
   birth_map.clear();
   death_map.clear();
   parent_child_set.clear();
-  data->SnapshotMaps(false, &birth_map, &death_map, &parent_child_set);
+  data->SnapshotMaps(&birth_map, &death_map, &parent_child_set);
   EXPECT_EQ(0u, birth_map.size());
   EXPECT_EQ(0u, death_map.size());
   EXPECT_EQ(0u, parent_child_set.size());
 }
 
 TEST_F(TrackedObjectsTest, TinyStartupShutdown) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
           ThreadData::PROFILING_CHILDREN_ACTIVE)) {
     return;
   }
 
   // Instigate tracking on a single tracked object, on our thread.
   const char kFunction[] = "TinyStartupShutdown";
   Location location(kFunction, kFile, kLineNumber, NULL);
   Births* first_birth = ThreadData::TallyABirthIfActive(location);
 
   ThreadData* data = ThreadData::first();
   ASSERT_TRUE(data);
   EXPECT_FALSE(data->next());
   EXPECT_EQ(data, ThreadData::Get());
   ThreadData::BirthMap birth_map;
   ThreadData::DeathMap death_map;
   ThreadData::ParentChildSet parent_child_set;
-  data->SnapshotMaps(false, &birth_map, &death_map, &parent_child_set);
+  data->SnapshotMaps(&birth_map, &death_map, &parent_child_set);
   EXPECT_EQ(1u, birth_map.size());                         // 1 birth location.
   EXPECT_EQ(1, birth_map.begin()->second->birth_count());  // 1 birth.
   EXPECT_EQ(0u, death_map.size());                         // No deaths.
   EXPECT_EQ(0u, parent_child_set.size());                  // No children.
 
 
   // Now instigate another birth, while we are timing the run of the first
   // execution.
   ThreadData::PrepareForStartOfRun(first_birth);
   // Create a child (using the same birth location).
   // TrackingInfo will call TallyABirth() during construction.
   const int32 start_time = 1;
   base::TimeTicks kBogusBirthTime = base::TimeTicks() +
       base::TimeDelta::FromMilliseconds(start_time);
   base::TrackingInfo pending_task(location, kBogusBirthTime);
   SetTestTime(1);
   TaskStopwatch stopwatch;
   stopwatch.Start();
   // Finally conclude the outer run.
   const int32 time_elapsed = 1000;
   SetTestTime(start_time + time_elapsed);
   stopwatch.Stop();
 
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, stopwatch);
 
   birth_map.clear();
   death_map.clear();
   parent_child_set.clear();
-  data->SnapshotMaps(false, &birth_map, &death_map, &parent_child_set);
+  data->SnapshotMaps(&birth_map, &death_map, &parent_child_set);
   EXPECT_EQ(1u, birth_map.size());                         // 1 birth location.
   EXPECT_EQ(2, birth_map.begin()->second->birth_count());  // 2 births.
   EXPECT_EQ(1u, death_map.size());                         // 1 location.
   EXPECT_EQ(1, death_map.begin()->second.count());         // 1 death.
   if (ThreadData::TrackingParentChildStatus()) {
     EXPECT_EQ(1u, parent_child_set.size());                  // 1 child.
     EXPECT_EQ(parent_child_set.begin()->first,
               parent_child_set.begin()->second);
   } else {
     EXPECT_EQ(0u, parent_child_set.size());                  // no stats.
   }
 
   // The births were at the same location as the one known death.
   EXPECT_EQ(birth_map.begin()->second, death_map.begin()->first);
 
   ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
+  ThreadData::Snapshot(&process_data);
 
   ASSERT_EQ(1u, process_data.tasks.size());
   EXPECT_EQ(kFile, process_data.tasks[0].birth.location.file_name);
   EXPECT_EQ(kFunction, process_data.tasks[0].birth.location.function_name);
   EXPECT_EQ(kLineNumber, process_data.tasks[0].birth.location.line_number);
   EXPECT_EQ(kWorkerThreadName, process_data.tasks[0].birth.thread_name);
   EXPECT_EQ(1, process_data.tasks[0].death_data.count);
   EXPECT_EQ(time_elapsed, process_data.tasks[0].death_data.run_duration_sum);
   EXPECT_EQ(time_elapsed, process_data.tasks[0].death_data.run_duration_max);
   EXPECT_EQ(time_elapsed, process_data.tasks[0].death_data.run_duration_sample);
@@ skipping 68 matching lines @@
   // Start in the deactivated state.
   if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED)) {
     return;
   }
 
   const char kFunction[] = "DeactivatedBirthOnlyToSnapshotWorkerThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, std::string());
 
   ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
+  ThreadData::Snapshot(&process_data);
   EXPECT_EQ(0u, process_data.tasks.size());
   EXPECT_EQ(0u, process_data.descendants.size());
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToSnapshotMainThread) {
   // Start in the deactivated state.
   if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED)) {
     return;
   }
 
   const char kFunction[] = "DeactivatedBirthOnlyToSnapshotMainThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
   ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
+  ThreadData::Snapshot(&process_data);
   EXPECT_EQ(0u, process_data.tasks.size());
   EXPECT_EQ(0u, process_data.descendants.size());
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 TEST_F(TrackedObjectsTest, BirthOnlyToSnapshotWorkerThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
           ThreadData::PROFILING_CHILDREN_ACTIVE)) {
     return;
   }
 
   const char kFunction[] = "BirthOnlyToSnapshotWorkerThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, std::string());
 
   ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
+  ThreadData::Snapshot(&process_data);
   ExpectSimpleProcessData(process_data, kFunction, kWorkerThreadName,
                           kStillAlive, 1, 0, 0);
 }
 
 TEST_F(TrackedObjectsTest, BirthOnlyToSnapshotMainThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
           ThreadData::PROFILING_CHILDREN_ACTIVE)) {
     return;
   }
 
   const char kFunction[] = "BirthOnlyToSnapshotMainThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
   ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
+  ThreadData::Snapshot(&process_data);
   ExpectSimpleProcessData(process_data, kFunction, kMainThreadName, kStillAlive,
                           1, 0, 0);
 }
 
 TEST_F(TrackedObjectsTest, LifeCycleToSnapshotMainThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
           ThreadData::PROFILING_CHILDREN_ACTIVE)) {
     return;
   }
 
@@ skipping 11 matching lines @@
   const unsigned int kEndOfRun = 7;
   SetTestTime(kStartOfRun);
   TaskStopwatch stopwatch;
   stopwatch.Start();
   SetTestTime(kEndOfRun);
   stopwatch.Stop();
 
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, stopwatch);
 
   ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
+  ThreadData::Snapshot(&process_data);
   ExpectSimpleProcessData(process_data, kFunction, kMainThreadName,
                           kMainThreadName, 1, 2, 4);
 }
 
 // We will deactivate tracking after the birth, and before the death, and
 // demonstrate that the lifecycle is completely tallied. This ensures that
 // our tallied births are matched by tallied deaths (except for when the
 // task is still running, or is queued).
 TEST_F(TrackedObjectsTest, LifeCycleMidDeactivatedToSnapshotMainThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
@@ skipping 19 matching lines @@
   const unsigned int kEndOfRun = 7;
   SetTestTime(kStartOfRun);
   TaskStopwatch stopwatch;
   stopwatch.Start();
   SetTestTime(kEndOfRun);
   stopwatch.Stop();
 
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, stopwatch);
 
   ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
+  ThreadData::Snapshot(&process_data);
   ExpectSimpleProcessData(process_data, kFunction, kMainThreadName,
                           kMainThreadName, 1, 2, 4);
 }
 
 // We will deactivate tracking before starting a life cycle, and neither
 // the birth nor the death will be recorded.
 TEST_F(TrackedObjectsTest, LifeCyclePreDeactivatedToSnapshotMainThread) {
   // Start in the deactivated state.
   if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED)) {
     return;
@@ skipping 13 matching lines @@
   const unsigned int kEndOfRun = 7;
   SetTestTime(kStartOfRun);
   TaskStopwatch stopwatch;
   stopwatch.Start();
   SetTestTime(kEndOfRun);
   stopwatch.Stop();
 
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, stopwatch);
 
   ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
+  ThreadData::Snapshot(&process_data);
   EXPECT_EQ(0u, process_data.tasks.size());
   EXPECT_EQ(0u, process_data.descendants.size());
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
-TEST_F(TrackedObjectsTest, LifeCycleToSnapshotWorkerThread) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
-    return;
-  }
-
-  const char kFunction[] = "LifeCycleToSnapshotWorkerThread";
-  Location location(kFunction, kFile, kLineNumber, NULL);
-  // Do not delete |birth|.  We don't own it.
-  Births* birth = ThreadData::TallyABirthIfActive(location);
-  EXPECT_NE(reinterpret_cast<Births*>(NULL), birth);
-
-  const unsigned int kTimePosted = 1;
-  const unsigned int kStartOfRun = 5;
-  const unsigned int kEndOfRun = 7;
-  SetTestTime(kStartOfRun);
-  TaskStopwatch stopwatch;
-  stopwatch.Start();
-  SetTestTime(kEndOfRun);
-  stopwatch.Stop();
-
-  ThreadData::TallyRunOnWorkerThreadIfTracking(
-  birth, TrackedTime() + Duration::FromMilliseconds(kTimePosted), stopwatch);
-
-  // Call for the ToSnapshot, but tell it to not reset the maxes after scanning.
-  ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
-  ExpectSimpleProcessData(process_data, kFunction, kWorkerThreadName,
-                          kWorkerThreadName, 1, 2, 4);
-
-  // Call for the ToSnapshot, but tell it to reset the maxes after scanning.
-  // We'll still get the same values, but the data will be reset (which we'll
-  // see in a moment).
-  ProcessDataSnapshot process_data_pre_reset;
-  ThreadData::Snapshot(true, &process_data_pre_reset);
-  ExpectSimpleProcessData(process_data, kFunction, kWorkerThreadName,
-                          kWorkerThreadName, 1, 2, 4);
-
-  // Call for the ToSnapshot, and now we'll see the result of the last
-  // translation, as the max will have been pushed back to zero.
-  ProcessDataSnapshot process_data_post_reset;
-  ThreadData::Snapshot(true, &process_data_post_reset);
-  ASSERT_EQ(1u, process_data_post_reset.tasks.size());
-  EXPECT_EQ(kFile, process_data_post_reset.tasks[0].birth.location.file_name);
-  EXPECT_EQ(kFunction,
-            process_data_post_reset.tasks[0].birth.location.function_name);
-  EXPECT_EQ(kLineNumber,
-            process_data_post_reset.tasks[0].birth.location.line_number);
-  EXPECT_EQ(kWorkerThreadName,
-            process_data_post_reset.tasks[0].birth.thread_name);
-  EXPECT_EQ(1, process_data_post_reset.tasks[0].death_data.count);
-  EXPECT_EQ(2, process_data_post_reset.tasks[0].death_data.run_duration_sum);
-  EXPECT_EQ(0, process_data_post_reset.tasks[0].death_data.run_duration_max);
-  EXPECT_EQ(2, process_data_post_reset.tasks[0].death_data.run_duration_sample);
-  EXPECT_EQ(4, process_data_post_reset.tasks[0].death_data.queue_duration_sum);
-  EXPECT_EQ(0, process_data_post_reset.tasks[0].death_data.queue_duration_max);
-  EXPECT_EQ(4,
-            process_data_post_reset.tasks[0].death_data.queue_duration_sample);
-  EXPECT_EQ(kWorkerThreadName,
-            process_data_post_reset.tasks[0].death_thread_name);
-  EXPECT_EQ(0u, process_data_post_reset.descendants.size());
-  EXPECT_EQ(base::GetCurrentProcId(), process_data_post_reset.process_id);
-}
-
 TEST_F(TrackedObjectsTest, TwoLives) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
           ThreadData::PROFILING_CHILDREN_ACTIVE)) {
     return;
   }
 
   const char kFunction[] = "TwoLives";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
@@ skipping 18 matching lines @@
   pending_task2.time_posted = kTimePosted;  // Overwrite implied Now().
   SetTestTime(kStartOfRun);
   TaskStopwatch stopwatch2;
   stopwatch2.Start();
   SetTestTime(kEndOfRun);
   stopwatch2.Stop();
 
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task2, stopwatch2);
 
   ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
+  ThreadData::Snapshot(&process_data);
   ExpectSimpleProcessData(process_data, kFunction, kMainThreadName,
                           kMainThreadName, 2, 2, 4);
 }
 
 TEST_F(TrackedObjectsTest, DifferentLives) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
           ThreadData::PROFILING_CHILDREN_ACTIVE)) {
     return;
   }
 
@@ skipping 19 matching lines @@
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, stopwatch);
 
   const int kSecondFakeLineNumber = 999;
   Location second_location(kFunction, kFile, kSecondFakeLineNumber, NULL);
 
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task2(second_location, kDelayedStartTime);
   pending_task2.time_posted = kTimePosted;  // Overwrite implied Now().
 
   ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
+  ThreadData::Snapshot(&process_data);
   ASSERT_EQ(2u, process_data.tasks.size());
 
   EXPECT_EQ(kFile, process_data.tasks[0].birth.location.file_name);
   EXPECT_EQ(kFunction, process_data.tasks[0].birth.location.function_name);
   EXPECT_EQ(kLineNumber, process_data.tasks[0].birth.location.line_number);
   EXPECT_EQ(kMainThreadName, process_data.tasks[0].birth.thread_name);
   EXPECT_EQ(1, process_data.tasks[0].death_data.count);
   EXPECT_EQ(2, process_data.tasks[0].death_data.run_duration_sum);
   EXPECT_EQ(2, process_data.tasks[0].death_data.run_duration_max);
   EXPECT_EQ(2, process_data.tasks[0].death_data.run_duration_sample);
@@ skipping 43 matching lines @@
     exclusion_stopwatch.Start();
     SetTestTime(12);
     exclusion_stopwatch.Stop();
   }
   SetTestTime(15);
   task_stopwatch.Stop();
 
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, task_stopwatch);
 
   ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
+  ThreadData::Snapshot(&process_data);
   ExpectSimpleProcessData(process_data, kFunction, kMainThreadName,
                           kMainThreadName, 1, 6, 4);
 }
 
 TEST_F(TrackedObjectsTest, TaskWith2NestedExclusions) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
           ThreadData::PROFILING_CHILDREN_ACTIVE)) {
     return;
   }
 
@@ skipping 22 matching lines @@
     exclusion_stopwatch2.Start();
     SetTestTime(18);
     exclusion_stopwatch2.Stop();
   }
   SetTestTime(25);
   task_stopwatch.Stop();
 
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, task_stopwatch);
 
   ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
+  ThreadData::Snapshot(&process_data);
   ExpectSimpleProcessData(process_data, kFunction, kMainThreadName,
                           kMainThreadName, 1, 13, 4);
 }
 
 TEST_F(TrackedObjectsTest, TaskWithNestedExclusionWithNestedTask) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
           ThreadData::PROFILING_CHILDREN_ACTIVE)) {
     return;
   }
 
@@ skipping 32 matching lines @@
     }
     SetTestTime(12);
     exclusion_stopwatch.Stop();
   }
   SetTestTime(15);
   task_stopwatch.Stop();
 
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, task_stopwatch);
 
   ProcessDataSnapshot process_data;
-  ThreadData::Snapshot(false, &process_data);
+  ThreadData::Snapshot(&process_data);
 
   // The order in which the two task follow is platform-dependent.
   int t0 = (process_data.tasks[0].birth.location.line_number == kLineNumber) ?
       0 : 1;
   int t1 = 1 - t0;
 
   ASSERT_EQ(2u, process_data.tasks.size());
   EXPECT_EQ(kFile, process_data.tasks[t0].birth.location.file_name);
   EXPECT_EQ(kFunction, process_data.tasks[t0].birth.location.function_name);
   EXPECT_EQ(kLineNumber, process_data.tasks[t0].birth.location.line_number);
@@ skipping 17 matching lines @@
   EXPECT_EQ(2, process_data.tasks[t1].death_data.run_duration_sample);
   EXPECT_EQ(1, process_data.tasks[t1].death_data.queue_duration_sum);
   EXPECT_EQ(1, process_data.tasks[t1].death_data.queue_duration_max);
   EXPECT_EQ(1, process_data.tasks[t1].death_data.queue_duration_sample);
   EXPECT_EQ(kMainThreadName, process_data.tasks[t1].death_thread_name);
   EXPECT_EQ(0u, process_data.descendants.size());
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 }  // namespace tracked_objects