Cleanup: removing unused descendants information from tracked objects

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 83 matching lines @@
               process_data_phase.tasks[0].death_data.run_duration_sample);
     EXPECT_EQ(count * queue_ms,
               process_data_phase.tasks[0].death_data.queue_duration_sum);
     EXPECT_EQ(queue_ms,
               process_data_phase.tasks[0].death_data.queue_duration_max);
     EXPECT_EQ(queue_ms,
               process_data_phase.tasks[0].death_data.queue_duration_sample);
 
     EXPECT_EQ(death_thread, process_data_phase.tasks[0].death_thread_name);
 
-    EXPECT_EQ(0u, process_data_phase.descendants.size());
-
     EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
   }
 
   // Sets time that will be returned by ThreadData::Now().
   static void SetTestTime(unsigned int test_time) { test_time_ = test_time; }
 
  private:
   // Returns test time in milliseconds.
   static unsigned int GetTestTime() { return test_time_; }
 
   // Test time in milliseconds.
   static unsigned int test_time_;
 };
 
 // static
 unsigned int TrackedObjectsTest::test_time_;
 
 TEST_F(TrackedObjectsTest, TaskStopwatchNoStartStop) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   // Check that creating and destroying a stopwatch without starting it doesn't
   // crash.
   TaskStopwatch stopwatch;
 }
 
 TEST_F(TrackedObjectsTest, MinimalStartupShutdown) {
   // Minimal test doesn't even create any tasks.
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   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::DeathsSnapshot deaths;
-  ThreadData::ParentChildSet parent_child_set;
-  data->SnapshotMaps(0, &birth_map, &deaths, &parent_child_set);
+  data->SnapshotMaps(0, &birth_map, &deaths);
   EXPECT_EQ(0u, birth_map.size());
   EXPECT_EQ(0u, deaths.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_TRUE(
+      ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_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();
   deaths.clear();
-  parent_child_set.clear();
-  data->SnapshotMaps(0, &birth_map, &deaths, &parent_child_set);
+  data->SnapshotMaps(0, &birth_map, &deaths);
   EXPECT_EQ(0u, birth_map.size());
   EXPECT_EQ(0u, deaths.size());
-  EXPECT_EQ(0u, parent_child_set.size());
 }
 
 TEST_F(TrackedObjectsTest, TinyStartupShutdown) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     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::TallyABirthIfActive(location);
 
   ThreadData* data = ThreadData::first();
   ASSERT_TRUE(data);
   EXPECT_FALSE(data->next());
   EXPECT_EQ(data, ThreadData::Get());
   ThreadData::BirthMap birth_map;
   ThreadData::DeathsSnapshot deaths;
-  ThreadData::ParentChildSet parent_child_set;
-  data->SnapshotMaps(0, &birth_map, &deaths, &parent_child_set);
+  data->SnapshotMaps(0, &birth_map, &deaths);
   EXPECT_EQ(1u, birth_map.size());                         // 1 birth location.
   EXPECT_EQ(1, birth_map.begin()->second->birth_count());  // 1 birth.
   EXPECT_EQ(0u, deaths.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();
   deaths.clear();
-  parent_child_set.clear();
-  data->SnapshotMaps(0, &birth_map, &deaths, &parent_child_set);
+  data->SnapshotMaps(0, &birth_map, &deaths);
   EXPECT_EQ(1u, birth_map.size());                         // 1 birth location.
   EXPECT_EQ(2, birth_map.begin()->second->birth_count());  // 2 births.
   EXPECT_EQ(1u, deaths.size());                            // 1 location.
   EXPECT_EQ(1, deaths.begin()->second.death_data.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, deaths.begin()->first);
 
   ProcessDataSnapshot process_data;
   ThreadData::Snapshot(0, &process_data);
 
   ASSERT_EQ(1u, process_data.phased_snapshots.size());
   auto it = process_data.phased_snapshots.find(0);
   ASSERT_TRUE(it != process_data.phased_snapshots.end());
   const ProcessDataPhaseSnapshot& process_data_phase = it->second;
   ASSERT_EQ(1u, process_data_phase.tasks.size());
   EXPECT_EQ(kFile, process_data_phase.tasks[0].birth.location.file_name);
   EXPECT_EQ(kFunction,
             process_data_phase.tasks[0].birth.location.function_name);
   EXPECT_EQ(kLineNumber,
             process_data_phase.tasks[0].birth.location.line_number);
   EXPECT_EQ(kWorkerThreadName, process_data_phase.tasks[0].birth.thread_name);
   EXPECT_EQ(1, process_data_phase.tasks[0].death_data.count);
   EXPECT_EQ(time_elapsed,
             process_data_phase.tasks[0].death_data.run_duration_sum);
   EXPECT_EQ(time_elapsed,
             process_data_phase.tasks[0].death_data.run_duration_max);
   EXPECT_EQ(time_elapsed,
             process_data_phase.tasks[0].death_data.run_duration_sample);
   EXPECT_EQ(0, process_data_phase.tasks[0].death_data.queue_duration_sum);
   EXPECT_EQ(0, process_data_phase.tasks[0].death_data.queue_duration_max);
   EXPECT_EQ(0, process_data_phase.tasks[0].death_data.queue_duration_sample);
   EXPECT_EQ(kWorkerThreadName, process_data_phase.tasks[0].death_thread_name);
-
-  if (ThreadData::TrackingParentChildStatus()) {
-    ASSERT_EQ(1u, process_data_phase.descendants.size());
-    EXPECT_EQ(kFile,
-              process_data_phase.descendants[0].parent.location.file_name);
-    EXPECT_EQ(kFunction,
-              process_data_phase.descendants[0].parent.location.function_name);
-    EXPECT_EQ(kLineNumber,
-              process_data_phase.descendants[0].parent.location.line_number);
-    EXPECT_EQ(kWorkerThreadName,
-              process_data_phase.descendants[0].parent.thread_name);
-    EXPECT_EQ(kFile,
-              process_data_phase.descendants[0].child.location.file_name);
-    EXPECT_EQ(kFunction,
-              process_data_phase.descendants[0].child.location.function_name);
-    EXPECT_EQ(kLineNumber,
-              process_data_phase.descendants[0].child.location.line_number);
-    EXPECT_EQ(kWorkerThreadName,
-              process_data_phase.descendants[0].child.thread_name);
-  } else {
-    EXPECT_EQ(0u, process_data_phase.descendants.size());
-  }
 }
 
 TEST_F(TrackedObjectsTest, DeathDataTestRecordDeath) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   scoped_ptr<DeathData> data(new DeathData());
   ASSERT_NE(data, reinterpret_cast<DeathData*>(NULL));
   EXPECT_EQ(data->run_duration_sum(), 0);
   EXPECT_EQ(data->run_duration_max(), 0);
   EXPECT_EQ(data->run_duration_sample(), 0);
   EXPECT_EQ(data->queue_duration_sum(), 0);
@@ skipping 22 matching lines @@
   EXPECT_EQ(data->run_duration_sample(), run_ms);
   EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms);
   EXPECT_EQ(data->queue_duration_max(), queue_ms);
   EXPECT_EQ(data->queue_duration_sample(), queue_ms);
   EXPECT_EQ(data->count(), 2);
   EXPECT_EQ(nullptr, data->last_phase_snapshot());
 }
 
 TEST_F(TrackedObjectsTest, DeathDataTest2Phases) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   scoped_ptr<DeathData> data(new DeathData());
   ASSERT_NE(data, reinterpret_cast<DeathData*>(NULL));
 
   int32 run_ms = 42;
   int32 queue_ms = 8;
 
@@ skipping 48 matching lines @@
             data->last_phase_snapshot()->death_data.queue_duration_sum);
   EXPECT_EQ(queue_ms,
             data->last_phase_snapshot()->death_data.queue_duration_max);
   EXPECT_EQ(queue_ms,
             data->last_phase_snapshot()->death_data.queue_duration_sample);
   EXPECT_EQ(nullptr, data->last_phase_snapshot()->prev);
 }
 
 TEST_F(TrackedObjectsTest, Delta) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   DeathDataSnapshot snapshot;
   snapshot.count = 10;
   snapshot.run_duration_sum = 100;
   snapshot.run_duration_max = 50;
   snapshot.run_duration_sample = 25;
   snapshot.queue_duration_sum = 200;
@@ skipping 64 matching lines @@
   ASSERT_TRUE(it != process_data.phased_snapshots.end());
   const ProcessDataPhaseSnapshot& process_data_phase = it->second;
 
   ASSERT_EQ(0u, process_data_phase.tasks.size());
 
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 TEST_F(TrackedObjectsTest, BirthOnlyToSnapshotWorkerThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   const char kFunction[] = "BirthOnlyToSnapshotWorkerThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, std::string());
 
   ProcessDataSnapshot process_data;
   ThreadData::Snapshot(0, &process_data);
   ExpectSimpleProcessData(process_data, kFunction, kWorkerThreadName,
                           kStillAlive, 1, 0, 0);
 }
 
 TEST_F(TrackedObjectsTest, BirthOnlyToSnapshotMainThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   const char kFunction[] = "BirthOnlyToSnapshotMainThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
   ProcessDataSnapshot process_data;
   ThreadData::Snapshot(0, &process_data);
   ExpectSimpleProcessData(process_data, kFunction, kMainThreadName, kStillAlive,
                           1, 0, 0);
 }
 
 TEST_F(TrackedObjectsTest, LifeCycleToSnapshotMainThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   const char kFunction[] = "LifeCycleToSnapshotMainThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
   const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
@@ skipping 12 matching lines @@
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, stopwatch);
 
   ProcessDataSnapshot process_data;
   ThreadData::Snapshot(0, &process_data);
   ExpectSimpleProcessData(process_data, kFunction, kMainThreadName,
                           kMainThreadName, 1, 2, 4);
 }
 
 TEST_F(TrackedObjectsTest, TwoPhases) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   const char kFunction[] = "TwoPhases";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
   const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
@@ skipping 53 matching lines @@
   EXPECT_EQ(1, process_data_phase0.tasks[0].death_data.count);
   EXPECT_EQ(2, process_data_phase0.tasks[0].death_data.run_duration_sum);
   EXPECT_EQ(2, process_data_phase0.tasks[0].death_data.run_duration_max);
   EXPECT_EQ(2, process_data_phase0.tasks[0].death_data.run_duration_sample);
   EXPECT_EQ(4, process_data_phase0.tasks[0].death_data.queue_duration_sum);
   EXPECT_EQ(4, process_data_phase0.tasks[0].death_data.queue_duration_max);
   EXPECT_EQ(4, process_data_phase0.tasks[0].death_data.queue_duration_sample);
 
   EXPECT_EQ(kMainThreadName, process_data_phase0.tasks[0].death_thread_name);
 
-  EXPECT_EQ(0u, process_data_phase0.descendants.size());
-
   auto it1 = process_data.phased_snapshots.find(1);
   ASSERT_TRUE(it1 != process_data.phased_snapshots.end());
   const ProcessDataPhaseSnapshot& process_data_phase1 = it1->second;
 
   ASSERT_EQ(1u, process_data_phase1.tasks.size());
 
   EXPECT_EQ(kFile, process_data_phase1.tasks[0].birth.location.file_name);
   EXPECT_EQ(kFunction,
             process_data_phase1.tasks[0].birth.location.function_name);
   EXPECT_EQ(kLineNumber,
             process_data_phase1.tasks[0].birth.location.line_number);
 
   EXPECT_EQ(kMainThreadName, process_data_phase1.tasks[0].birth.thread_name);
 
   EXPECT_EQ(1, process_data_phase1.tasks[0].death_data.count);
   EXPECT_EQ(10, process_data_phase1.tasks[0].death_data.run_duration_sum);
   EXPECT_EQ(10, process_data_phase1.tasks[0].death_data.run_duration_max);
   EXPECT_EQ(10, process_data_phase1.tasks[0].death_data.run_duration_sample);
   EXPECT_EQ(2, process_data_phase1.tasks[0].death_data.queue_duration_sum);
   EXPECT_EQ(2, process_data_phase1.tasks[0].death_data.queue_duration_max);
   EXPECT_EQ(2, process_data_phase1.tasks[0].death_data.queue_duration_sample);
 
   EXPECT_EQ(kMainThreadName, process_data_phase1.tasks[0].death_thread_name);
 
-  EXPECT_EQ(0u, process_data_phase1.descendants.size());
-
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 TEST_F(TrackedObjectsTest, ThreePhases) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   const char kFunction[] = "ThreePhases";
   Location location(kFunction, kFile, kLineNumber, NULL);
 
   // Phase 0
   {
     TallyABirth(location, kMainThreadName);
@@ skipping 71 matching lines @@
   EXPECT_EQ(1, process_data_phase0.tasks[0].death_data.count);
   EXPECT_EQ(6, process_data_phase0.tasks[0].death_data.run_duration_sum);
   EXPECT_EQ(6, process_data_phase0.tasks[0].death_data.run_duration_max);
   EXPECT_EQ(6, process_data_phase0.tasks[0].death_data.run_duration_sample);
   EXPECT_EQ(7, process_data_phase0.tasks[0].death_data.queue_duration_sum);
   EXPECT_EQ(7, process_data_phase0.tasks[0].death_data.queue_duration_max);
   EXPECT_EQ(7, process_data_phase0.tasks[0].death_data.queue_duration_sample);
 
   EXPECT_EQ(kMainThreadName, process_data_phase0.tasks[0].death_thread_name);
 
-  EXPECT_EQ(0u, process_data_phase0.descendants.size());
-
   auto it1 = process_data.phased_snapshots.find(1);
   ASSERT_TRUE(it1 != process_data.phased_snapshots.end());
   const ProcessDataPhaseSnapshot& process_data_phase1 = it1->second;
 
   ASSERT_EQ(1u, process_data_phase1.tasks.size());
 
   EXPECT_EQ(kFile, process_data_phase1.tasks[0].birth.location.file_name);
   EXPECT_EQ(kFunction,
             process_data_phase1.tasks[0].birth.location.function_name);
   EXPECT_EQ(kLineNumber,
             process_data_phase1.tasks[0].birth.location.line_number);
 
   EXPECT_EQ(kMainThreadName, process_data_phase1.tasks[0].birth.thread_name);
 
   EXPECT_EQ(1, process_data_phase1.tasks[0].death_data.count);
   EXPECT_EQ(4, process_data_phase1.tasks[0].death_data.run_duration_sum);
   EXPECT_EQ(4, process_data_phase1.tasks[0].death_data.run_duration_max);
   EXPECT_EQ(4, process_data_phase1.tasks[0].death_data.run_duration_sample);
   EXPECT_EQ(5, process_data_phase1.tasks[0].death_data.queue_duration_sum);
   EXPECT_EQ(5, process_data_phase1.tasks[0].death_data.queue_duration_max);
   EXPECT_EQ(5, process_data_phase1.tasks[0].death_data.queue_duration_sample);
 
   EXPECT_EQ(kMainThreadName, process_data_phase1.tasks[0].death_thread_name);
 
-  EXPECT_EQ(0u, process_data_phase1.descendants.size());
-
   auto it2 = process_data.phased_snapshots.find(2);
   ASSERT_TRUE(it2 != process_data.phased_snapshots.end());
   const ProcessDataPhaseSnapshot& process_data_phase2 = it2->second;
 
   ASSERT_EQ(1u, process_data_phase2.tasks.size());
 
   EXPECT_EQ(kFile, process_data_phase2.tasks[0].birth.location.file_name);
   EXPECT_EQ(kFunction,
             process_data_phase2.tasks[0].birth.location.function_name);
   EXPECT_EQ(kLineNumber,
             process_data_phase2.tasks[0].birth.location.line_number);
 
   EXPECT_EQ(kMainThreadName, process_data_phase2.tasks[0].birth.thread_name);
 
   EXPECT_EQ(1, process_data_phase2.tasks[0].death_data.count);
   EXPECT_EQ(2, process_data_phase2.tasks[0].death_data.run_duration_sum);
   EXPECT_EQ(2, process_data_phase2.tasks[0].death_data.run_duration_max);
   EXPECT_EQ(2, process_data_phase2.tasks[0].death_data.run_duration_sample);
   EXPECT_EQ(3, process_data_phase2.tasks[0].death_data.queue_duration_sum);
   EXPECT_EQ(3, process_data_phase2.tasks[0].death_data.queue_duration_max);
   EXPECT_EQ(3, process_data_phase2.tasks[0].death_data.queue_duration_sample);
 
   EXPECT_EQ(kMainThreadName, process_data_phase2.tasks[0].death_thread_name);
 
-  EXPECT_EQ(0u, process_data_phase2.descendants.size());
-
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 TEST_F(TrackedObjectsTest, TwoPhasesSecondEmpty) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   const char kFunction[] = "TwoPhasesSecondEmpty";
   Location location(kFunction, kFile, kLineNumber, NULL);
   ThreadData::InitializeThreadContext(kMainThreadName);
 
   const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
@@ skipping 41 matching lines @@
   EXPECT_EQ(4, process_data_phase0.tasks[0].death_data.queue_duration_sample);
 
   EXPECT_EQ(kMainThreadName, process_data_phase0.tasks[0].death_thread_name);
 
   auto it1 = process_data.phased_snapshots.find(1);
   ASSERT_TRUE(it1 != process_data.phased_snapshots.end());
   const ProcessDataPhaseSnapshot& process_data_phase1 = it1->second;
 
   ASSERT_EQ(0u, process_data_phase1.tasks.size());
 
-  EXPECT_EQ(0u, process_data_phase0.descendants.size());
-
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 TEST_F(TrackedObjectsTest, TwoPhasesFirstEmpty) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   ThreadData::OnProfilingPhaseCompleted(0);
 
   const char kFunction[] = "TwoPhasesSecondEmpty";
   Location location(kFunction, kFile, kLineNumber, NULL);
   ThreadData::InitializeThreadContext(kMainThreadName);
 
@@ skipping 44 matching lines @@
 
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 // 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(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   const char kFunction[] = "LifeCycleMidDeactivatedToSnapshotMainThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
   const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
@@ skipping 59 matching lines @@
   ASSERT_TRUE(it != process_data.phased_snapshots.end());
   const ProcessDataPhaseSnapshot& process_data_phase = it->second;
 
   ASSERT_EQ(0u, process_data_phase.tasks.size());
 
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 TEST_F(TrackedObjectsTest, TwoLives) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   const char kFunction[] = "TwoLives";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
   const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
@@ skipping 23 matching lines @@
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task2, stopwatch2);
 
   ProcessDataSnapshot process_data;
   ThreadData::Snapshot(0, &process_data);
   ExpectSimpleProcessData(process_data, kFunction, kMainThreadName,
                           kMainThreadName, 2, 2, 4);
 }
 
 TEST_F(TrackedObjectsTest, DifferentLives) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext(kMainThreadName);
   const char kFunction[] = "DifferentLives";
   Location location(kFunction, kFile, kLineNumber, NULL);
 
   const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
@@ skipping 50 matching lines @@
             process_data_phase.tasks[1].birth.location.line_number);
   EXPECT_EQ(kMainThreadName, process_data_phase.tasks[1].birth.thread_name);
   EXPECT_EQ(1, process_data_phase.tasks[1].death_data.count);
   EXPECT_EQ(0, process_data_phase.tasks[1].death_data.run_duration_sum);
   EXPECT_EQ(0, process_data_phase.tasks[1].death_data.run_duration_max);
   EXPECT_EQ(0, process_data_phase.tasks[1].death_data.run_duration_sample);
   EXPECT_EQ(0, process_data_phase.tasks[1].death_data.queue_duration_sum);
   EXPECT_EQ(0, process_data_phase.tasks[1].death_data.queue_duration_max);
   EXPECT_EQ(0, process_data_phase.tasks[1].death_data.queue_duration_sample);
   EXPECT_EQ(kStillAlive, process_data_phase.tasks[1].death_thread_name);
-  EXPECT_EQ(0u, process_data_phase.descendants.size());
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 TEST_F(TrackedObjectsTest, TaskWithNestedExclusion) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   const char kFunction[] = "TaskWithNestedExclusion";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
   const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
@@ skipping 17 matching lines @@
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, task_stopwatch);
 
   ProcessDataSnapshot process_data;
   ThreadData::Snapshot(0, &process_data);
   ExpectSimpleProcessData(process_data, kFunction, kMainThreadName,
                           kMainThreadName, 1, 6, 4);
 }
 
 TEST_F(TrackedObjectsTest, TaskWith2NestedExclusions) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   const char kFunction[] = "TaskWith2NestedExclusions";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
   const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
@@ skipping 23 matching lines @@
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, task_stopwatch);
 
   ProcessDataSnapshot process_data;
   ThreadData::Snapshot(0, &process_data);
   ExpectSimpleProcessData(process_data, kFunction, kMainThreadName,
                           kMainThreadName, 1, 13, 4);
 }
 
 TEST_F(TrackedObjectsTest, TaskWithNestedExclusionWithNestedTask) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_CHILDREN_ACTIVE)) {
+          ThreadData::PROFILING_ACTIVE)) {
     // Don't run the test if task tracking is not compiled in.
     return;
   }
 
   const char kFunction[] = "TaskWithNestedExclusionWithNestedTask";
   Location location(kFunction, kFile, kLineNumber, NULL);
 
   const int kSecondFakeLineNumber = 999;
 
   TallyABirth(location, kMainThreadName);
@@ skipping 69 matching lines @@
             process_data_phase.tasks[t1].birth.location.line_number);
   EXPECT_EQ(kMainThreadName, process_data_phase.tasks[t1].birth.thread_name);
   EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.count);
   EXPECT_EQ(2, process_data_phase.tasks[t1].death_data.run_duration_sum);
   EXPECT_EQ(2, process_data_phase.tasks[t1].death_data.run_duration_max);
   EXPECT_EQ(2, process_data_phase.tasks[t1].death_data.run_duration_sample);
   EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_sum);
   EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_max);
   EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_sample);
   EXPECT_EQ(kMainThreadName, process_data_phase.tasks[t1].death_thread_name);
-  EXPECT_EQ(0u, process_data_phase.descendants.size());
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 }  // namespace tracked_objects