Add/improve a bunch of comments...

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 <string>
@@ skipping 339 matching lines @@
   std::map<const ThreadData*, int> birth_threads_;
   DeathData death_data_;
   std::map<const ThreadData*, int> death_threads_;
 
   DISALLOW_COPY_AND_ASSIGN(Aggregation);
 };
 
 //------------------------------------------------------------------------------
 // Comparator is a class that supports the comparison of Snapshot instances.
 // An instance is actually a list of chained Comparitors, that can provide for
-// arbitrary ordering.  The path portion of an about:objects URL is translated
+// arbitrary ordering.  The path portion of an about:tasks URL is translated
 // into such a chain, which is then used to order Snapshot 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 in an
 // aggregation).
 
 class Comparator {
  public:
   // Selector enum is the token identifier for each parsed keyword, most of
   // which specify a sort order.
   // Since it is not meaningful to sort more than once on a specific key, we
@@ skipping 45 matching lines @@
   bool IsGroupedBy(Selector selector) const;
 
   // Using the tiebreakers as set above, we mostly get an ordering, which
   // equivalent groups.  If those groups are displayed (rather than just being
   // aggregated, then the following is used to order them (within the group).
   void SetSubgroupTiebreaker(Selector selector);
 
   // Translate a keyword and restriction in URL path to a selector for sorting.
   void ParseKeyphrase(const std::string& key_phrase);
 
-  // Parse a query in an about:objects URL to decide on sort ordering.
+  // Parse a query in an about:tasks URL to decide on sort ordering.
   bool ParseQuery(const std::string& query);
 
   // Output a header line that can be used to indicated what items will be
   // collected in the group.  It lists all (potentially) tested attributes and
   // their values (in the sample item).
   bool WriteSortGrouping(const Snapshot& sample, std::string* output) const;
 
   // Output a sample, with SortGroup details not displayed.
   void WriteSnapshot(const Snapshot& sample, std::string* output) const;
 
@@ skipping 35 matching lines @@
   ThreadData();
   ~ThreadData();
 
   // 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.
   // If shutdown has already started, and we don't yet have an instance, then
   // return null.
   static ThreadData* current();
 
-  // For a given about:objects URL, develop resulting HTML, and append to
-  // output.
+  // For a given about:tasks URL, develop resulting HTML, and append to output.
   static void WriteHTML(const std::string& query, std::string* output);
 
   // 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);
 
   // 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& lifetimes, const base::TimeDelta& duration);
 
   // (Thread safe) Get start of list of instances.
   static ThreadData* first();
   // Iterate through the null terminated list of instances.
   ThreadData* next() const { return next_; }
 
   MessageLoop* message_loop() const { return message_loop_; }
   const std::string ThreadName() const;
 
   // 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:objects.
+  // in order to build an HTML page for about:tasks.
   void SnapshotBirthMap(BirthMap *output) const;
   void SnapshotDeathMap(DeathMap *output) const;
 
   // 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();
 
   // Using our lock to protect the iteration, Clear all birth and death data.
@@ skipping 139 matching lines @@
   };
   static State state_;
 
   DISALLOW_COPY_AND_ASSIGN(AutoTracking);
 };
 
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_