Revert 107895 - Fully enable about:tracking by default

base/tracked_objects.h

 // Copyright (c) 2011 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.
 
 #ifndef BASE_TRACKED_OBJECTS_H_
 #define BASE_TRACKED_OBJECTS_H_
 #pragma once
 
 #include <map>
 #include <stack>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/location.h"
 #include "base/time.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_local_storage.h"
-#include "base/tracking_info.h"
 #include "base/values.h"
 
-#if defined(OS_WIN)
-#include <mmsystem.h>  // Declare timeGetTime();
-#endif
-
 // TrackedObjects provides a database of stats about objects (generally Tasks)
 // that are tracked.  Tracking means their birth, death, duration, birth thread,
 // death thread, and birth place are recorded.  This data is carefully spread
 // across a series of objects so that the counts and times can be rapidly
 // updated without (usually) having to lock the data, and hence there is usually
 // very little contention caused by the tracking.  The data can be viewed via
 // the about:tracking URL, with a variety of sorting and filtering choices.
 //
 // These classes serve as the basis of a profiler of sorts for the Tasks system.
 // As a result, design decisions were made to maximize speed, by minimizing
@@ skipping 31 matching lines @@
 // For Tasks, having now either constructed or found the Births instance
 // described above, a pointer to the Births instance is then recorded into the
 // PendingTask structure in MessageLoop.  This fact alone is very useful in
 // debugging, when there is a question of where an instance came from.  In
 // addition, the birth time is also recorded and used to later evaluate the
 // lifetime duration of the whole Task.  As a result of the above embedding, we
 // can find out a Task's location of birth, and thread of birth, without using
 // any locks, as all that data is constant across the life of the process.
 //
 // The above work *could* also be done for any other object as well by calling
-// TallyABirthIfActive() and TallyRunOnNamedThreadIfTracking() as appropriate.
+// TallyABirthIfActive() and TallyADeathIfActive() as appropriate.
 //
 // The amount of memory used in the above data structures depends on how many
 // threads there are, and how many Locations of construction there are.
 // Fortunately, we don't use memory that is the product of those two counts, but
 // rather we only need one Births instance for each thread that constructs an
 // instance at a Location. In many cases, instances are only created on one
 // thread, so the memory utilization is actually fairly restrained.
 //
 // Lastly, when an instance is deleted, the final tallies of statistics are
 // carefully accumulated.  That tallying wrties into slots (members) in a
@@ skipping 77 matching lines @@
 // asynchronously relative to ongoing updates, and worse yet, some data fields
 // are 64bit quantities, and are not atomicly accessed (reset or incremented
 // etc.).  For basic profiling, this will work "most of the time," and should be
 // sufficient... but storing away DataCollections is the "right way" to do this.
 
 class MessageLoop;
 
 namespace tracked_objects {
 
 //------------------------------------------------------------------------------
-
-#define USE_FAST_TIME_CLASS_FOR_DURATION_CALCULATIONS
-
-#if defined(USE_FAST_TIME_CLASS_FOR_DURATION_CALCULATIONS)
-
-// TimeTicks maintains a wasteful 64 bits of data (we need less than 32), and on
-// windows, a 64 bit timer is expensive to even obtain. We use a simple
-// millisecond counter for most of our time values, as well as millisecond units
-// of duration between those values.  This means we can only handle durations
-// up to 49 days (range), or 24 days (non-negative time durations).
-// We only define enough methods to service the needs of the tracking classes,
-// and our interfaces are modeled after what TimeTicks and TimeDelta use (so we
-// can swap them into place if we want to use the "real" classes).
-
-class BASE_EXPORT Duration {  // Similar to base::TimeDelta.
- public:
-  Duration() : ms_(0) {}
-
-  Duration& operator+=(const Duration& other) {
-    ms_ += other.ms_;
-    return *this;
-  }
-
-  Duration operator+(const Duration& other) const {
-    return Duration(ms_ + other.ms_);
-  }
-
-  bool operator==(const Duration& other) const { return ms_ == other.ms_; }
-  bool operator!=(const Duration& other) const { return ms_ != other.ms_; }
-  bool operator>(const Duration& other) const { return ms_ > other.ms_; }
-
-  static Duration FromMilliseconds(int ms) { return Duration(ms); }
-
-  int32 InMilliseconds() const { return ms_; }
-
- private:
-  friend class TrackedTime;
-  explicit Duration(int32 duration) : ms_(duration) {}
-
-  // Internal time is stored directly in milliseconds.
-  int32 ms_;
-};
-
-class BASE_EXPORT TrackedTime {  // Similar to base::TimeTicks.
- public:
-  TrackedTime() : ms_(0) {}
-  explicit TrackedTime(const base::TimeTicks& time)
-      : ms_((time - base::TimeTicks()).InMilliseconds()) {
-  }
-
-  static TrackedTime Now() {
-#if defined(OS_WIN)
-    // Use lock-free accessor to 32 bit time.
-    // Note that TimeTicks::Now() is built on this, so we have "compatible"
-    // times when we down-convert a TimeTicks sample.
-    // TODO(jar): Surface this interface via something in base/time.h.
-    return TrackedTime(static_cast<int32>(::timeGetTime()));
-#else
-    // Posix has nice cheap 64 bit times, so we just down-convert it.
-    return TrackedTime(base::TimeTicks::Now());
-#endif  // OS_WIN
-  }
-
-  Duration operator-(const TrackedTime& other) const {
-    return Duration(ms_ - other.ms_);
-  }
-
-  TrackedTime operator+(const Duration& other) const {
-    return TrackedTime(ms_ + other.ms_);
-  }
-
-  bool is_null() const { return ms_ == 0; }
-
- private:
-  friend class Duration;
-  explicit TrackedTime(int32 ms) : ms_(ms) {}
-
-  // Internal duration is stored directly in milliseconds.
-  uint32 ms_;
-};
-
-#else
-
-// Just use full 64 bit time calculations, and the slower TimeTicks::Now().
-typedef base::TimeTicks TrackedTime;
-typedef base::TimeDelta Duration;
-
-#endif  // USE_FAST_TIME_CLASS_FOR_DURATION_CALCULATIONS
-
-//------------------------------------------------------------------------------
 // For a specific thread, and a specific birth place, the collection of all
 // death info (with tallies for each death thread, to prevent access conflicts).
 class ThreadData;
 class BASE_EXPORT BirthOnThread {
  public:
   BirthOnThread(const Location& location, const ThreadData& current);
 
   const Location location() const { return location_; }
   const ThreadData* birth_thread() const { return birth_thread_; }
 
@@ skipping 30 matching lines @@
   void Clear() { birth_count_ = 0; }
 
  private:
   // The number of births on this thread for our location_.
   int birth_count_;
 
   DISALLOW_COPY_AND_ASSIGN(Births);
 };
 
 //------------------------------------------------------------------------------
-// Basic info summarizing multiple destructions of a tracked object with a
-// single birthplace (fixed Location).  Used both on specific threads, and also
+// Basic info summarizing multiple destructions of an object with a single
+// birthplace (fixed Location).  Used both on specific threads, and also used
 // in snapshots when integrating assembled data.
 
 class BASE_EXPORT DeathData {
  public:
   // Default initializer.
   DeathData() : count_(0) {}
 
   // When deaths have not yet taken place, and we gather data from all the
   // threads, we create DeathData stats that tally the number of births without
   // a corrosponding death.
   explicit DeathData(int count) : count_(count) {}
 
   // Update stats for a task destruction (death) that had a Run() time of
   // |duration|, and has had a queueing delay of |queue_duration|.
-  void RecordDeath(const Duration& queue_duration,
-                   const Duration& run_duration);
+  void RecordDeath(const base::TimeDelta& queue_duration,
+                   const base::TimeDelta& run_duration);
 
   // Metrics accessors.
   int count() const { return count_; }
-  Duration run_duration() const { return run_duration_; }
+  base::TimeDelta run_duration() const { return run_duration_; }
   int AverageMsRunDuration() const;
-  Duration queue_duration() const { return queue_duration_; }
+  base::TimeDelta queue_duration() const { return queue_duration_; }
   int AverageMsQueueDuration() const;
 
   // Accumulate metrics from other into this.  This method is never used on
   // realtime statistics, and only used in snapshots and aggregatinos.
   void AddDeathData(const DeathData& other);
 
   // Simple print of internal state for use in line of HTML.
   void WriteHTML(std::string* output) const;
 
-  // Construct a DictionaryValue instance containing all our stats. The caller
+  // Constructe a DictionaryValue instance containing all our stats. The caller
   // assumes ownership of the returned instance.
   base::DictionaryValue* ToValue() const;
 
   // Reset all tallies to zero. This is used as a hack on realtime data.
   void Clear();
 
  private:
   int count_;                       // Number of destructions.
-  Duration run_duration_;    // Sum of all Run()time durations.
-  Duration queue_duration_;  // Sum of all queue time durations.
+  base::TimeDelta run_duration_;    // Sum of all Run()time durations.
+  base::TimeDelta queue_duration_;  // Sum of all queue time durations.
 };
 
 //------------------------------------------------------------------------------
 // A temporary collection of data that can be sorted and summarized.  It is
 // gathered (carefully) from many threads.  Instances are held in arrays and
 // processed, filtered, and rendered.
 // The source of this data was collected on many threads, and is asynchronously
 // changing.  The data in this instance is not asynchronously changing.
 
 class BASE_EXPORT Snapshot {
  public:
   // When snapshotting a full life cycle set (birth-to-death), use this:
   Snapshot(const BirthOnThread& birth_on_thread, const ThreadData& death_thread,
            const DeathData& death_data);
 
   // When snapshotting a birth, with no death yet, use this:
   Snapshot(const BirthOnThread& birth_on_thread, int count);
 
   const ThreadData* birth_thread() const { return birth_->birth_thread(); }
   const Location location() const { return birth_->location(); }
   const BirthOnThread& birth() const { return *birth_; }
   const ThreadData* death_thread() const {return death_thread_; }
   const DeathData& death_data() const { return death_data_; }
   const std::string DeathThreadName() const;
 
   int count() const { return death_data_.count(); }
-  Duration run_duration() const { return death_data_.run_duration(); }
-  Duration queue_duration() const { return death_data_.queue_duration(); }
+  base::TimeDelta run_duration() const { return death_data_.run_duration(); }
   int AverageMsRunDuration() const {
     return death_data_.AverageMsRunDuration();
   }
+  base::TimeDelta queue_duration() const {
+    return death_data_.queue_duration();
+  }
   int AverageMsQueueDuration() const {
     return death_data_.AverageMsQueueDuration();
   }
 
   // Emit contents for use in a line of HTML
   void WriteHTML(std::string* output) const;
 
   // Construct a DictionaryValue instance containing all our data recursively.
   // The caller assumes ownership of the memory in the returned instance.
   base::DictionaryValue* ToValue() const;
 
+  void Add(const Snapshot& other);
+
  private:
   const BirthOnThread* birth_;  // Includes Location and birth_thread.
   const ThreadData* death_thread_;
   DeathData death_data_;
 };
 
 //------------------------------------------------------------------------------
 // DataCollector is a container class for Snapshot and BirthOnThread count
 // items.
 
 class BASE_EXPORT DataCollector {
  public:
   typedef std::vector<Snapshot> Collection;
 
   // Construct with a list of how many threads should contribute.  This helps us
   // determine (in the async case) when we are done with all contributions.
   DataCollector();
   ~DataCollector();
 
-  // Adds all stats from the indicated thread into our arrays.  This function
-  // uses locks at the lowest level (when accessing the underlying maps which
-  // could change when not locked), and can be called from any threads.
+  // Add all stats from the indicated thread into our arrays.  This function is
+  // mutex protected, and *could* be called from any threads (although current
+  // implementation serialized calls to Append).
   void Append(const ThreadData& thread_data);
 
   // After the accumulation phase, the following accessor is used to process the
-  // data (i.e., sort it, filter it, etc.).
+  // data.
   Collection* collection();
 
-  // Adds entries for all the remaining living objects (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).
-  // This should be called after all known ThreadData instances have been
-  // processed using Append().
+  // After collection of death data is complete, we can add entries for all the
+  // remaining living objects.
   void AddListOfLivingObjects();
 
-  // Generates a ListValue representation of the vector of snapshots. The caller
+  // Generate a ListValue representation of the vector of snapshots.  The caller
   // assumes ownership of the memory in the returned instance.
   base::ListValue* ToValue() const;
 
  private:
   typedef std::map<const BirthOnThread*, int> BirthCount;
 
   // The array that we collect data into.
   Collection collection_;
 
   // The total number of births recorded at each location for which we have not
-  // seen a death count.  This map changes as we do Append() calls, and is later
-  // used by AddListOfLivingObjects() to gather up unaccounted for births.
+  // seen a death count.
   BirthCount global_birth_count_;
 
   DISALLOW_COPY_AND_ASSIGN(DataCollector);
 };
 
 //------------------------------------------------------------------------------
 // Aggregation contains summaries (totals and subtotals) of groups of Snapshot
 // instances to provide printing of these collections on a single line.
-// We generally provide an aggregate total for the entire list, as well as
-// aggregate subtotals for groups of stats (example: group of all lives that
-// died on the specific thread).
 
 class BASE_EXPORT Aggregation: public DeathData {
  public:
   Aggregation();
   ~Aggregation();
 
   void AddDeathSnapshot(const Snapshot& snapshot);
   void AddBirths(const Births& births);
   void AddBirth(const BirthOnThread& birth);
   void AddBirthPlace(const Location& location);
@@ skipping 35 matching lines @@
     BIRTH_FUNCTION = 8,
     BIRTH_LINE = 16,
     COUNT = 32,
     AVERAGE_RUN_DURATION = 64,
     TOTAL_RUN_DURATION = 128,
     AVERAGE_QUEUE_DURATION = 256,
     TOTAL_QUEUE_DURATION = 512,
 
     // Imediate action keywords.
     RESET_ALL_DATA = -1,
-    UNKNOWN_KEYWORD = -2,
   };
 
   explicit Comparator();
 
   // Reset the comparator to a NIL selector.  Clear() and recursively delete any
   // tiebreaker_ entries.  NOTE: We can't use a standard destructor, because
   // the sort algorithm makes copies of this object, and then deletes them,
   // which would cause problems (either we'd make expensive deep copies, or we'd
   // do more thna one delete on a tiebreaker_.
   void Clear();
@@ skipping 36 matching lines @@
   bool WriteSortGrouping(const Snapshot& sample, std::string* output) const;
 
   // Output a sample, with SortGroup details not displayed.
   void WriteSnapshotHTML(const Snapshot& sample, std::string* output) const;
 
  private:
   // The selector directs this instance to compare based on the specified
   // members of the tested elements.
   enum Selector selector_;
 
-  // Translate a path keyword into a selector.  This is a slow implementation,
-  // but this is rarely done, and only for HTML presentations.
-  static Selector FindSelector(const std::string& keyword);
-
   // For filtering into acceptable and unacceptable snapshot instance, the
   // following is required to be a substring of the selector_ field.
   std::string required_;
 
   // If this instance can't decide on an ordering, we can consult a tie-breaker
   // which may have a different basis of comparison.
   Comparator* tiebreaker_;
 
   // We or together all the selectors we sort on (not counting sub-group
   // selectors), so that we can tell if we've decided to group on any given
   // criteria.
   int combined_selectors_;
 
   // Some tiebreakrs are for subgroup ordering, and not for basic ordering (in
   // preparation for aggregation).  The subgroup tiebreakers are not consulted
   // when deciding if two items are in equivalent groups.  This flag tells us
   // to ignore the tiebreaker when doing Equivalent() testing.
   bool use_tiebreaker_for_sort_only_;
 };
 
 //------------------------------------------------------------------------------
 // For each thread, we have a ThreadData that stores all tracking info generated
 // on this thread.  This prevents the need for locking as data accumulates.
-// We use ThreadLocalStorage to quickly identfy the current ThreadData context.
-// We also have a linked list of ThreadData instances, and that list is used to
-// harvest data from all existing instances.
 
 class BASE_EXPORT ThreadData {
  public:
-  // Current allowable states of the tracking system.  The states can vary
-  // between ACTIVE and DEACTIVATED, but can never go back to UNINITIALIZED.
-  enum Status {
-    UNINITIALIZED,
-    ACTIVE,
-    DEACTIVATED,
-  };
-
   typedef std::map<Location, Births*> BirthMap;
   typedef std::map<const Births*, DeathData> DeathMap;
 
   // Initialize the current thread context with a new instance of ThreadData.
-  // This is used by all threads that have names, and should be explicitly
-  // set *before* any births on the threads have taken place.  It is generally
-  // only used by the message loop, which has a well defined thread name.
+  // This is used by all threads that have names, and can be explicitly
+  // set *before* any births are threads have taken place.  It is generally
+  // only used by the message loop, which has a well defined name.
   static void InitializeThreadContext(const std::string& suggested_name);
 
   // Using Thread Local Store, find the current instance for collecting data.
   // If an instance does not exist, construct one (and remember it for use on
   // this thread.
   // This may return NULL if the system is disabled for any reason.
   static ThreadData* Get();
 
   // For a given (unescaped) about:tracking query, develop resulting HTML, and
   // append to output.
   static void WriteHTML(const std::string& query, std::string* output);
 
+  // Constructe a ListValue instance containing all recursive results in our
+  // process.  The caller assumes ownership of the memory in the returned
+  // instance.  The |process_type| should become an enum, which corresponds
+  // to all possible process types.  I'm using an int as a placeholder.
+  static base::Value* ToValue(int process_type);
+
   // For a given accumulated array of results, use the comparator to sort and
   // subtotal, writing the results to the output.
   static void WriteHTMLTotalAndSubtotals(
       const DataCollector::Collection& match_array,
       const Comparator& comparator, std::string* output);
 
-  // Constructs a DictionaryValue instance containing all recursive results in
-  // our process.  The caller assumes ownership of the memory in the returned
-  // instance.
-  static base::DictionaryValue* ToValue();
-
-  // Finds (or creates) a place to count births from the given location in this
+  // Find (or create) a place to count births from the given location in this
   // thread, and increment that tally.
   // TallyABirthIfActive will returns NULL if the birth cannot be tallied.
   static Births* TallyABirthIfActive(const Location& location);
 
-  // Records the end of a timed run of an object.  The |completed_task| contains
-  // a pointer to a Births, the time_posted, and a delayed_start_time if any.
-  // The |start_of_run| indicates when we started to perform the run of the
-  // task.  The delayed_start_time is non-null for tasks that were posted as
-  // delayed tasks, and it indicates when the task should have run (i.e., when
-  // it should have posted out of the timer queue, and into the work queue.
-  // The |end_of_run| was just obtained by a call to Now() (just after the task
-  // finished). It is provided as an argument to help with testing.
-  static void TallyRunOnNamedThreadIfTracking(
-      const base::TrackingInfo& completed_task,
-      const TrackedTime& start_of_run,
-      const TrackedTime& end_of_run);
-
   // Record the end of a timed run of an object.  The |birth| is the record for
-  // the instance, the |time_posted| records that instant, which is presumed to
-  // be when the task was posted into a queue to run on a worker thread.
-  // The |start_of_run| is when the worker thread started to perform the run of
-  // the task.
+  // the instance, the |time_posted| and |start_of_run| are times of posting
+  // into a message loop queue, and of starting to perform the run of the task.
   // The |end_of_run| was just obtained by a call to Now() (just after the task
   // finished).
-  static void TallyRunOnWorkerThreadIfTracking(
-      const Births* birth,
-      const TrackedTime& time_posted,
-      const TrackedTime& start_of_run,
-      const TrackedTime& end_of_run);
+  static void TallyADeathIfActive(const Births* birth,
+                                  const base::TimeTicks& time_posted,
+                                  const base::TimeTicks& delayed_start_time,
+                                  const base::TimeTicks& start_of_run,
+                                  const base::TimeTicks& end_of_run);
 
   const std::string thread_name() const { return thread_name_; }
 
   // ---------------------
   // The following functions should all be private, and are only public because
   // the collection is done externally.  We need to relocate that code from the
   // collection class into this class, and then all these methods can be made
   // private.
   // (Thread safe) Get start of list of all ThreadData instances.
   static ThreadData* first();
   // Iterate through the null terminated list of ThreadData instances.
   ThreadData* next() const { return next_; }
   // Using our lock, make a copy of the specified maps.  These calls may arrive
   // from non-local threads, and are used to quickly scan data from all threads
   // in order to build an HTML page for about:tracking.
   void SnapshotBirthMap(BirthMap *output) const;
   void SnapshotDeathMap(DeathMap *output) const;
   // -------- end of should be private methods.
 
   // Hack: asynchronously clear all birth counts and death tallies data values
   // in all ThreadData instances.  The numerical (zeroing) part is done without
   // use of a locks or atomics exchanges, and may (for int64 values) produce
   // bogus counts VERY rarely.
   static void ResetAllThreadData();
 
-  // Initializes all statics if needed (this initialization call should be made
-  // while we are single threaded). Returns false if unable to initialize.
-  static bool Initialize();
-
-  // Sets internal status_ to either become ACTIVE, or DEACTIVATED,
+  // Set internal status_ to either become ACTIVE, or later, to be SHUTDOWN,
   // based on argument being true or false respectively.
-  // If tracking is not compiled in, this function will return false.
-  static bool InitializeAndSetTrackingStatus(bool status);
-  static bool tracking_status();
+  // IF tracking is not compiled in, this function will return false.
+  static bool StartTracking(bool status);
+  static bool IsActive();
 
   // Provide a time function that does nothing (runs fast) when we don't have
   // the profiler enabled.  It will generally be optimized away when it is
   // ifdef'ed to be small enough (allowing the profiler to be "compiled out" of
   // the code).
-  static TrackedTime Now();
+  static base::TimeTicks Now();
 
   // WARNING: ONLY call this function when you are running single threaded
   // (again) and all message loops and threads have terminated.  Until that
   // point some threads may still attempt to write into our data structures.
   // Delete recursively all data structures, starting with the list of
   // ThreadData instances.
   static void ShutdownSingleThreadedCleanup();
 
  private:
+  // Current allowable states of the tracking system.  The states always
+  // proceed towards SHUTDOWN, and never go backwards.
+  enum Status {
+    UNINITIALIZED,
+    ACTIVE,
+    SHUTDOWN,
+  };
+
   typedef std::stack<const ThreadData*> ThreadDataPool;
 
   // Worker thread construction creates a name since there is none.
   ThreadData();
   // Message loop based construction should provide a name.
   explicit ThreadData(const std::string& suggested_name);
 
   ~ThreadData();
 
   // Push this instance to the head of all_thread_data_list_head_, linking it to
   // the previous head.  This is performed after each construction, and leaves
   // the instance permanently on that list.
   void PushToHeadOfList();
 
   // In this thread's data, record a new birth.
   Births* TallyABirth(const Location& location);
 
   // Find a place to record a death on this thread.
   void TallyADeath(const Births& birth,
-                   const Duration& queue_duration,
-                   const Duration& duration);
+                   const base::TimeDelta& queue_duration,
+                   const base::TimeDelta& duration);
 
   // Using our lock to protect the iteration, Clear all birth and death data.
   void Reset();
 
   // This method is called by the TLS system when a thread terminates.
   // The argument may be NULL if this thread has never tracked a birth or death.
   static void OnThreadTermination(void* thread_data);
 
   // This method should be called when a worker thread terminates, so that we
   // can save all the thread data into a cache of reusable ThreadData instances.
   void OnThreadTerminationCleanup() const;
 
   // We use thread local store to identify which ThreadData to interact with.
   static base::ThreadLocalStorage::Slot tls_index_;
 
   // Link to the most recently created instance (starts a null terminated list).
   // The list is traversed by about:tracking when it needs to snapshot data.
   static ThreadData* all_thread_data_list_head_;
   // Set of ThreadData instances for use with worker threads. When a worker
   // thread is done (terminating), we push it into this pool.  When a new worker
   // thread is created, we first try to re-use a ThreadData instance from the
   // pool, and if none are available, construct a new one.
   static ThreadDataPool* unregistered_thread_data_pool_;
   // Protection for access to all_thread_data_list_head_, and to
-  // unregistered_thread_data_pool_.  This lock is leaked at shutdown.
-  static base::Lock* list_lock_;
+  // unregistered_thread_data_pool_.
+  static base::Lock list_lock_;
 
   // We set status_ to SHUTDOWN when we shut down the tracking service.
   static Status status_;
 
   // Link to next instance (null terminated list). Used to globally track all
   // registered instances (corresponds to all registered threads where we keep
   // data).
   ThreadData* next_;
 
   // The name of the thread that is being recorded.  If this thread has no
@@ skipping 33 matching lines @@
 
 //------------------------------------------------------------------------------
 // Provide simple way to to start global tracking, and to tear down tracking
 // when done.  The design has evolved to *not* do any teardown (and just leak
 // all allocated data structures).  As a result, we don't have any code in this
 // destructor, and perhaps this whole class should go away.
 
 class BASE_EXPORT AutoTracking {
  public:
   AutoTracking() {
-    ThreadData::Initialize();
+    if (state_ != kNeverBeenRun)
+      return;
+    ThreadData::StartTracking(true);
+    state_ = kRunning;
   }
 
   ~AutoTracking() {
-    // TODO(jar): Consider emitting a CSV dump of the data at this point.  This
-    // should be called after the message loops have all terminated (or at least
-    // the main message loop is gone), so there is little chance for additional
-    // tasks to be Run.
   }
 
  private:
+  enum State {
+    kNeverBeenRun,
+    kRunning,
+  };
+  static State state_;
 
   DISALLOW_COPY_AND_ASSIGN(AutoTracking);
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_