Provide and use auto startup/teardown for tracked objects...

base/tracked_objects.h

 // Copyright (c) 2006-2008 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_
 
 //------------------------------------------------------------------------------
 #include <map>
 #include <string>
@@ skipping 21 matching lines @@
  private:
   // File/lineno of birth.  This defines the essence of the type, as the context
   // of the birth (construction) often tell what the item is for.  This field
   // is const, and hence safe to access from any thread.
   const Location location_;
 
   // The thread that records births into this object.  Only this thread is
   // allowed to access birth_count_ (which changes over time).
   const ThreadData* birth_thread_;  // The thread this birth took place on.
 
-  DISALLOW_EVIL_CONSTRUCTORS(BirthOnThread);
+  DISALLOW_COPY_AND_ASSIGN(BirthOnThread);
 };
 
 //------------------------------------------------------------------------------
 // A class for accumulating counts of births (without bothering with a map<>).
 
 class Births: public BirthOnThread {
  public:
   explicit Births(const Location& location);
 
   int birth_count() const { return birth_count_; }
 
   // When we have a birth we update the count for this BirhPLace.
   void RecordBirth() { ++birth_count_; }
 
   // When a birthplace is changed (updated), we need to decrement the counter
   // for the old instance.
   void ForgetBirth() { --birth_count_; }  // We corrected a birth place.
 
  private:
   // The number of births on this thread for our location_.
   int birth_count_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(Births);
+  DISALLOW_COPY_AND_ASSIGN(Births);
 };
 
 //------------------------------------------------------------------------------
 // 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 DeathData {
  public:
   // Default initializer.
@@ skipping 100 matching lines @@
   // 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.
   typedef std::map<const BirthOnThread*, int> BirthCount;
   BirthCount global_birth_count_;
 
   Lock accumulation_lock_;  // Protects access during accumulation phase.
 
-  DISALLOW_EVIL_CONSTRUCTORS(DataCollector);
+  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.
 
 class Aggregation: public DeathData {
  public:
   Aggregation() : birth_count_(0) {}
 
   void AddDeathSnapshot(const Snapshot& snapshot);
   void AddBirths(const Births& births);
   void AddBirth(const BirthOnThread& birth);
   void AddBirthPlace(const Location& location);
   void Write(std::string* output) const;
   void Clear();
 
  private:
   int birth_count_;
   std::map<std::string, int> birth_files_;
   std::map<Location, int> locations_;
   std::map<const ThreadData*, int> birth_threads_;
   DeathData death_data_;
   std::map<const ThreadData*, int> death_threads_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(Aggregation);
+  DISALLOW_COPY_AND_ASSIGN(Aggregation);
 };
 
 //------------------------------------------------------------------------------
 // Comparator does the comparison of Snapshot instances.  It is
 // used to order the instances in a vector.  It orders them into groups (for
 // aggregation), and can also order instances within the groups (for detailed
 // rendering of the instances).
 
 class Comparator {
  public:
@@ skipping 198 matching lines @@
                  ThreadSafeDownCounter* counter);
     // Run the supplied static method, and optionally set the event.
     void Run();
 
    private:
     FunctionPointer function_;
     HANDLE completion_handle_;
     // Make sure enough tasks are called before completion is signaled.
     ThreadSafeDownCounter* counter_;
 
-    DISALLOW_EVIL_CONSTRUCTORS(RunTheStatic);
+    DISALLOW_COPY_AND_ASSIGN(RunTheStatic);
   };
 #endif
 
   // Each registered thread is called to set status_ to SHUTDOWN.
   // This is done redundantly on every registered thread because it is not
   // protected by a mutex.  Running on all threads guarantees we get the
   // notification into the memory cache of all possible threads.
   static void ShutdownDisablingFurtherTracking();
 
   // We use thread local store to identify which ThreadData to interact with.
@@ skipping 31 matching lines @@
   // instances (i.e., when a tracked instance was destroyed on this thread).
   DeathMap death_map_;
 
   // Lock to protect *some* access to BirthMap and DeathMap.  We only use
   // locking protection when we are growing the maps, or using an iterator.  We
   // only do writes to members from this thread, so the updates of values are
   // atomic.  Folks can read from other threads, and get (via races) new or old
   // data, but that is considered acceptable errors (mis-information).
   Lock lock_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(ThreadData);
+  DISALLOW_COPY_AND_ASSIGN(ThreadData);
 };
 
+
+//------------------------------------------------------------------------------
+// Provide simple way to to start global tracking, and to tear down tracking
+// when done.  Note that construction and destruction of this object must be
+// done when running in single threaded mode (before spawning a lot of threads
+// for construction, and after shutting down all the threads for destruction).
+
+class AutoTracking {
+ public:
+  AutoTracking() { ThreadData::StartTracking(true); }
+
+  ~AutoTracking() {
+#ifndef NDEBUG  // Don't call these in a Release build: they just waste time.
+    // The following should ONLY be called when in single threaded mode. It is
+    // unsafe to do this cleanup if other threads are still active.
+    // It is also very unnecessary, so I'm only doing this in debug to satisfy
+    // purify (if we need to!).
+    ThreadData::ShutdownSingleThreadedCleanup();
+#endif
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AutoTracking);
+};
+
+
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_