Revert 120789 - Propogate status setting for profiler to track parents

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 "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 17 matching lines @@
   }
 
   // Provide access, since this class is a friend of ThreadData.
   void ShutdownSingleThreadedCleanup(bool leak) {
     ThreadData::ShutdownSingleThreadedCleanup(leak);
   }
 };
 
 TEST_F(TrackedObjectsTest, MinimalStartupShutdown) {
   // Minimal test doesn't even create any tasks.
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
   ThreadData* data = ThreadData::Get();
   EXPECT_TRUE(ThreadData::first());  // Now class was constructed.
   EXPECT_TRUE(data);
   EXPECT_TRUE(!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);
   EXPECT_EQ(0u, birth_map.size());
   EXPECT_EQ(0u, death_map.size());
   EXPECT_EQ(0u, parent_child_set.size());
   // Cleanup with no leaking.
   ShutdownSingleThreadedCleanup(false);
 
   // Do it again, just to be sure we reset state completely.
-  ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE);
+  ThreadData::InitializeAndSetTrackingStatus(true);
   EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
   data = ThreadData::Get();
   EXPECT_TRUE(ThreadData::first());  // Now class was constructed.
   EXPECT_TRUE(data);
   EXPECT_TRUE(!data->next());
   EXPECT_EQ(data, ThreadData::Get());
   birth_map.clear();
   death_map.clear();
   data->SnapshotMaps(false, &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))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   // Instigate tracking on a single tracked object, on our thread.
   const Location& location = FROM_HERE;
   Births* first_birth = ThreadData::TallyABirthIfActive(location);
 
   ThreadData* data = ThreadData::first();
   ASSERT_TRUE(data);
   EXPECT_TRUE(!data->next());
   EXPECT_EQ(data, ThreadData::Get());
@@ skipping 21 matching lines @@
                                               end_time);
 
   birth_map.clear();
   death_map.clear();
   parent_child_set.clear();
   data->SnapshotMaps(false, &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()) {
+  if (ThreadData::tracking_parent_child_status()) {
     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);
 }
 
 TEST_F(TrackedObjectsTest, ParentChildTest) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
-  if (!ThreadData::TrackingParentChildStatus())
+  if (!ThreadData::tracking_parent_child_status())
     return;   // Feature not compiled in.
 
   // Instigate tracking on a single tracked object, on our thread.
   const int kFakeLineNumber = 1776;
   const char* kFile = "FixedUnitTestFileName";
   const char* kFunction = "ParentChildTest";
   Location location(kFunction, kFile, kFakeLineNumber, NULL);
 
   // Now instigate another birth, while we are timing the run of the first
   // execution.
@@ skipping 62 matching lines @@
             "\"function_name\":\"ParentChildTest\","
             "\"line_number\":1776"
           "}"
         "}"
       "]"
     "}";
   EXPECT_EQ(json, birth_only_result);
 }
 
 TEST_F(TrackedObjectsTest, DeathDataTest) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     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_sample(), 0);
   EXPECT_EQ(data->queue_duration_sum(), 0);
   EXPECT_EQ(data->queue_duration_sample(), 0);
   EXPECT_EQ(data->count(), 0);
 
@@ skipping 38 matching lines @@
       "\"queue_ms_sample\":8,"
       "\"run_ms\":84,"
       "\"run_ms_max\":42,"
       "\"run_ms_sample\":42"
       "}";
   EXPECT_EQ(birth_only_result, json);
 }
 
 TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToValueWorkerThread) {
   // Transition to Deactivated state before doing anything.
-  if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED))
+  if (!ThreadData::InitializeAndSetTrackingStatus(false))
     return;
   // We don't initialize system with a thread name, so we're viewed as a worker
   // thread.
   const int kFakeLineNumber = 173;
   const char* kFile = "FixedFileName";
   const char* kFunction = "BirthOnlyToValueWorkerThread";
   Location location(kFunction, kFile, kFakeLineNumber, NULL);
   Births* birth = ThreadData::TallyABirthIfActive(location);
   // We should now see a NULL birth record.
   EXPECT_EQ(birth, reinterpret_cast<Births*>(NULL));
 
   scoped_ptr<base::Value> value(ThreadData::ToValue(false));
   std::string json;
   base::JSONWriter::Write(value.get(), false, &json);
   std::string birth_only_result = "{"
       "\"descendants\":["
       "],"
       "\"list\":["
       "]"
     "}";
   EXPECT_EQ(json, birth_only_result);
 }
 
 TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToValueMainThread) {
   // Start in the deactivated state.
-  if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED))
+  if (!ThreadData::InitializeAndSetTrackingStatus(false))
     return;
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext("SomeMainThreadName");
   const int kFakeLineNumber = 173;
   const char* kFile = "FixedFileName";
   const char* kFunction = "BirthOnlyToValueMainThread";
   Location location(kFunction, kFile, kFakeLineNumber, NULL);
   // Do not delete birth.  We don't own it.
   Births* birth = ThreadData::TallyABirthIfActive(location);
   // We expect to not get a birth record.
   EXPECT_EQ(birth, reinterpret_cast<Births*>(NULL));
 
   scoped_ptr<base::Value> value(ThreadData::ToValue(false));
   std::string json;
   base::JSONWriter::Write(value.get(), false, &json);
   std::string birth_only_result = "{"
       "\"descendants\":["
       "],"
       "\"list\":["
       "]"
     "}";
   EXPECT_EQ(json, birth_only_result);
 }
 
 TEST_F(TrackedObjectsTest, BirthOnlyToValueWorkerThread) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
   // We don't initialize system with a thread name, so we're viewed as a worker
   // thread.
   const int kFakeLineNumber = 173;
   const char* kFile = "FixedFileName";
   const char* kFunction = "BirthOnlyToValueWorkerThread";
   Location location(kFunction, kFile, kFakeLineNumber, NULL);
   Births* birth = ThreadData::TallyABirthIfActive(location);
   EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
 
@@ skipping 21 matching lines @@
             "\"function_name\":\"BirthOnlyToValueWorkerThread\","
             "\"line_number\":173"
           "}"
         "}"
       "]"
     "}";
   EXPECT_EQ(json, birth_only_result);
 }
 
 TEST_F(TrackedObjectsTest, BirthOnlyToValueMainThread) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext("SomeMainThreadName");
   const int kFakeLineNumber = 173;
   const char* kFile = "FixedFileName";
   const char* kFunction = "BirthOnlyToValueMainThread";
   Location location(kFunction, kFile, kFakeLineNumber, NULL);
   // Do not delete birth.  We don't own it.
   Births* birth = ThreadData::TallyABirthIfActive(location);
@@ skipping 23 matching lines @@
             "\"function_name\":\"BirthOnlyToValueMainThread\","
             "\"line_number\":173"
           "}"
         "}"
       "]"
     "}";
   EXPECT_EQ(json, birth_only_result);
 }
 
 TEST_F(TrackedObjectsTest, LifeCycleToValueMainThread) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext("SomeMainThreadName");
   const int kFakeLineNumber = 236;
   const char* kFile = "FixedFileName";
   const char* kFunction = "LifeCycleToValueMainThread";
   Location location(kFunction, kFile, kFakeLineNumber, NULL);
   // Do not delete birth.  We don't own it.
   Births* birth = ThreadData::TallyABirthIfActive(location);
@@ skipping 40 matching lines @@
       "]"
     "}";
   EXPECT_EQ(one_line_result, json);
 }
 
 // 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, LifeCycleMidDeactivatedToValueMainThread) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext("SomeMainThreadName");
   const int kFakeLineNumber = 236;
   const char* kFile = "FixedFileName";
   const char* kFunction = "LifeCycleToValueMainThread";
   Location location(kFunction, kFile, kFakeLineNumber, NULL);
   // Do not delete birth.  We don't own it.
   Births* birth = ThreadData::TallyABirthIfActive(location);
   EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
 
   const base::TimeTicks kTimePosted = base::TimeTicks()
       + base::TimeDelta::FromMilliseconds(1);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   // Turn off tracking now that we have births.
-  EXPECT_TRUE(ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::DEACTIVATED));
+  EXPECT_TRUE(ThreadData::InitializeAndSetTrackingStatus(false));
 
   const TrackedTime kStartOfRun = TrackedTime() +
       Duration::FromMilliseconds(5);
   const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7);
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task,
       kStartOfRun, kEndOfRun);
 
   scoped_ptr<base::Value> value(ThreadData::ToValue(false));
   std::string json;
   base::JSONWriter::Write(value.get(), false, &json);
@@ skipping 20 matching lines @@
           "}"
         "}"
       "]"
     "}";
   EXPECT_EQ(one_line_result, json);
 }
 
 // We will deactivate tracking before starting a life cycle, and neither
 // the birth nor the death will be recorded.
 TEST_F(TrackedObjectsTest, LifeCyclePreDeactivatedToValueMainThread) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED))
+  if (!ThreadData::InitializeAndSetTrackingStatus(false))
     return;
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext("SomeMainThreadName");
   const int kFakeLineNumber = 236;
   const char* kFile = "FixedFileName";
   const char* kFunction = "LifeCycleToValueMainThread";
   Location location(kFunction, kFile, kFakeLineNumber, NULL);
   // Do not delete birth.  We don't own it.
   Births* birth = ThreadData::TallyABirthIfActive(location);
@@ skipping 18 matching lines @@
   std::string one_line_result = "{"
       "\"descendants\":["
       "],"
       "\"list\":["
       "]"
     "}";
   EXPECT_EQ(one_line_result, json);
 }
 
 TEST_F(TrackedObjectsTest, LifeCycleToValueWorkerThread) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   // Don't initialize thread, so that we appear as a worker thread.
   // ThreadData::InitializeThreadContext("SomeMainThreadName");
 
   const int kFakeLineNumber = 236;
   const char* kFile = "FixedFileName";
   const char* kFunction = "LifeCycleToValueWorkerThread";
   Location location(kFunction, kFile, kFakeLineNumber, NULL);
   // Do not delete birth.  We don't own it.
@@ skipping 70 matching lines @@
             "\"function_name\":\"LifeCycleToValueWorkerThread\","
             "\"line_number\":236"
           "}"
         "}"
       "]"
     "}";
   EXPECT_EQ(one_line_result_with_zeros, json);
 }
 
 TEST_F(TrackedObjectsTest, TwoLives) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext("SomeFileThreadName");
   const int kFakeLineNumber = 222;
   const char* kFile = "AnotherFileName";
   const char* kFunction = "TwoLives";
   Location location(kFunction, kFile, kFakeLineNumber, NULL);
   // Do not delete birth.  We don't own it.
   Births* birth = ThreadData::TallyABirthIfActive(location);
@@ skipping 44 matching lines @@
             "\"function_name\":\"TwoLives\","
             "\"line_number\":222"
           "}"
         "}"
       "]"
     "}";
   EXPECT_EQ(one_line_result, json);
 }
 
 TEST_F(TrackedObjectsTest, DifferentLives) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext("SomeFileThreadName");
   const int kFakeLineNumber = 567;
   const char* kFile = "AnotherFileName";
   const char* kFunction = "DifferentLives";
   Location location(kFunction, kFile, kFakeLineNumber, NULL);
 
   const base::TimeTicks kTimePosted = base::TimeTicks()
@@ skipping 59 matching lines @@
             "\"line_number\":999"
           "}"
         "}"
       "]"
     "}";
   EXPECT_EQ(one_line_result, json);
 }
 
 
 }  // namespace tracked_objects