Track parent-child relations during profiling

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 <math.h>
 
 #include "base/format_macros.h"
 #include "base/message_loop.h"
@@ skipping 375 matching lines @@
     DCHECK_EQ(parent_stack_.top(), &birth);
     parent_stack_.pop();
   }
 }
 
 // static
 Births* ThreadData::TallyABirthIfActive(const Location& location) {
   if (!kTrackAllTaskObjects)
     return NULL;  // Not compiled in.
 
-  if (!tracking_status())
+  if (!TrackingStatus())
     return NULL;
   ThreadData* current_thread_data = Get();
   if (!current_thread_data)
     return NULL;
   return current_thread_data->TallyABirth(location);
 }
 
 // static
 void ThreadData::TallyRunOnNamedThreadIfTracking(
     const base::TrackingInfo& completed_task,
@@ skipping 208 matching lines @@
   // we get the lock earlier in this method.
   status_ = kInitialStartupState;
   if (!kTrackParentChildLinks &&
       kInitialStartupState == PROFILING_CHILDREN_ACTIVE)
     status_ = PROFILING_ACTIVE;
   DCHECK(status_ != UNINITIALIZED);
   return true;
 }
 
 // static
-bool ThreadData::InitializeAndSetTrackingStatus(bool status) {
+bool ThreadData::InitializeAndSetTrackingStatus(Status status) {
+  DCHECK_GE(status, DEACTIVATED);
+  DCHECK_LE(status, PROFILING_CHILDREN_ACTIVE);
+
   if (!Initialize())  // No-op if already initialized.
     return false;  // Not compiled in.
 
-  if (!status) {
-    status_ = DEACTIVATED;
-  } else {
-    if (kTrackParentChildLinks)
-      status_ = PROFILING_CHILDREN_ACTIVE;
-    else
-      status_ = PROFILING_ACTIVE;
-  }
+  if (!kTrackParentChildLinks && status > DEACTIVATED)
+    status = PROFILING_ACTIVE;
+  status_ = status;
   return true;
 }
 
 // static
-bool ThreadData::tracking_status() {
+ThreadData::Status ThreadData::status() {
+  return status_;
+}
+
+// static
+bool ThreadData::TrackingStatus() {
   return status_ > DEACTIVATED;
 }
 
 // static
-bool ThreadData::tracking_parent_child_status() {
+bool ThreadData::TrackingParentChildStatus() {
   return status_ >= PROFILING_CHILDREN_ACTIVE;
 }
 
 // static
 TrackedTime ThreadData::NowForStartOfRun(const Births* parent) {
   if (kTrackParentChildLinks && parent && status_ > PROFILING_ACTIVE) {
     ThreadData* current_thread_data = Get();
     if (current_thread_data)
       current_thread_data->parent_stack_.push(parent);
   }
   return Now();
 }
 
 // static
 TrackedTime ThreadData::NowForEndOfRun() {
   return Now();
 }
 
 // static
 TrackedTime ThreadData::Now() {
-  if (kTrackAllTaskObjects && tracking_status())
+  if (kTrackAllTaskObjects && TrackingStatus())
     return TrackedTime::Now();
   return TrackedTime();  // Super fast when disabled, or not compiled.
 }
 
 // static
 void ThreadData::EnsureCleanupWasCalled(int major_threads_shutdown_count) {
   base::AutoLock lock(*list_lock_.Pointer());
   if (worker_thread_data_creation_count_ == 0)
     return;  // We haven't really run much, and couldn't have leaked.
   // Verify that we've at least shutdown/cleanup the major namesd threads.  The
   // caller should tell us how many thread shutdowns should have taken place by
   // now.
   return;  // TODO(jar): until this is working on XP, don't run the real test.
   CHECK_GT(cleanup_count_, major_threads_shutdown_count);
 }
 
 // static
 void ThreadData::ShutdownSingleThreadedCleanup(bool leak) {
   // This is only called from test code, where we need to cleanup so that
   // additional tests can be run.
   // We must be single threaded... but be careful anyway.
-  if (!InitializeAndSetTrackingStatus(false))
+  if (!InitializeAndSetTrackingStatus(DEACTIVATED))
     return;
   ThreadData* thread_data_list;
   {
     base::AutoLock lock(*list_lock_.Pointer());
     thread_data_list = all_thread_data_list_head_;
     all_thread_data_list_head_ = NULL;
     ++incarnation_counter_;
     // To be clean, break apart the retired worker list (though we leak them).
     while (first_retired_worker_) {
       ThreadData* worker = first_retired_worker_;
@@ skipping 127 matching lines @@
        ++it) {
     base::DictionaryValue* parent_child = new base::DictionaryValue;
     it->first->ToValue("parent", parent_child);
     it->second->ToValue("child", parent_child);
     descendants->Append(parent_child);
   }
   dictionary->Set("descendants", descendants);
 }
 
 }  // namespace tracked_objects