Move Time, TimeDelta and TimeTicks into namespace base.

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 62 matching lines @@
 class DeathData {
  public:
   // Default initializer.
   DeathData() : count_(0), square_duration_(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), square_duration_(0) {}
 
-  void RecordDeath(const TimeDelta& duration);
+  void RecordDeath(const base::TimeDelta& duration);
 
   // Metrics accessors.
   int count() const { return count_; }
-  TimeDelta life_duration() const { return life_duration_; }
+  base::TimeDelta life_duration() const { return life_duration_; }
   int64 square_duration() const { return square_duration_; }
   int AverageMsDuration() const;
   double StandardDeviation() const;
 
   // Accumulate metrics from other into this.
   void AddDeathData(const DeathData& other);
 
   // Simple print of internal state.
   void Write(std::string* output) const;
 
   void Clear();
 
  private:
   int count_;                // Number of destructions.
-  TimeDelta life_duration_;    // Sum of all lifetime durations.
+  base::TimeDelta life_duration_;    // Sum of all lifetime durations.
   int64 square_duration_;  // Sum of squares in milliseconds.
 };
 
 //------------------------------------------------------------------------------
 // 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 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(); }
-  TimeDelta life_duration() const { return death_data_.life_duration(); }
+  base::TimeDelta life_duration() const { return death_data_.life_duration(); }
   int64 square_duration() const { return death_data_.square_duration(); }
   int AverageMsDuration() const { return death_data_.AverageMsDuration(); }
 
   void Write(std::string* output) const;
 
   void Add(const Snapshot& other);
 
  private:
   const BirthOnThread* birth_;  // Includes Location and birth_thread.
   const ThreadData* death_thread_;
@@ skipping 190 matching lines @@
   // 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, find a place to record a new birth.
   Births* FindLifetime(const Location& location);
 
   // Find a place to record a death on this thread.
-  void TallyADeath(const Births& lifetimes, const TimeDelta& duration);
+  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
@@ skipping 127 matching lines @@
   // data, but that is considered acceptable errors (mis-information).
   Lock lock_;
 
   DISALLOW_EVIL_CONSTRUCTORS(ThreadData);
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_