Switch to using an intergral type for durations inside profiler

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>
@@ skipping 214 matching lines @@
 // 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) {}
+  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(DurationInt queue_duration,
+                   DurationInt run_duration);
 
   // Metrics accessors.
   int count() const { return count_; }
-  Duration run_duration() const { return run_time_.duration(); }
-  int AverageMsRunDuration() const;
-  Duration run_duration_max() const { return run_time_.max(); }
-  Duration queue_duration() const { return queue_time_.duration(); }
-  int AverageMsQueueDuration() const;
-  Duration queue_duration_max() const { return queue_time_.max(); }
+  DurationInt run_duration() const { return run_time_.duration(); }
+  DurationInt AverageMsRunDuration() const;
+  DurationInt run_duration_max() const { return run_time_.max(); }
+  DurationInt queue_duration() const { return queue_time_.duration(); }
+  DurationInt AverageMsQueueDuration() const;
+  DurationInt queue_duration_max() const { return queue_time_.max(); }
 
   // 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
   // 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:
   // DeathData::Data is a helper class, useful when different metrics need to be
   // aggregated, such as queueing times, or run times.
   class Data {
    public:
-    Data() {}
+    Data() : duration_(0), max_(0) {}
     ~Data() {}
 
-    Duration duration() const { return duration_; }
-    Duration max() const { return max_; }
+    DurationInt duration() const { return duration_; }
+    DurationInt max() const { return max_; }
 
     // Emits HTML formated description of members, assuming |count| instances
     // when calculating averages.
     void WriteHTML(int count, std::string* output) const;
 
     // Agggegate data into our state.
     void AddData(const Data& other);
-    void AddDuration(const Duration& duration);
+    void AddDuration(DurationInt duration);
 
     // Central helper function for calculating averages (correctly, in only one
     // place).
-    int AverageMsDuration(int count) const;
+    DurationInt AverageMsDuration(int count) const;
 
     // Resets all members to zero.
     void Clear();
 
    private:
-    Duration duration_;  // Sum of all durations seen.
-    Duration max_;       // Largest singular duration seen.
+    DurationInt duration_;  // Sum of all durations seen.
+    DurationInt max_;       // Largest singular duration seen.
   };
 
 
   int count_;         // Number of deaths seen.
   Data run_time_;    // Data about run time durations.
   Data queue_time_;  // Data about queueing times durations.
 };
 
 //------------------------------------------------------------------------------
 // A temporary collection of data that can be sorted and summarized.  It is
@@ skipping 12 matching lines @@
   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(); }
-  int AverageMsRunDuration() const {
+  DurationInt run_duration() const { return death_data_.run_duration(); }
+  DurationInt AverageMsRunDuration() const {
     return death_data_.AverageMsRunDuration();
   }
-  Duration run_duration_max() const {
+  DurationInt run_duration_max() const {
     return death_data_.run_duration_max();
   }
-  Duration queue_duration() const { return death_data_.queue_duration(); }
-  int AverageMsQueueDuration() const {
+  DurationInt queue_duration() const { return death_data_.queue_duration(); }
+  DurationInt AverageMsQueueDuration() const {
     return death_data_.AverageMsQueueDuration();
   }
-  Duration queue_duration_max() const {
+  DurationInt queue_duration_max() const {
     return death_data_.queue_duration_max();
   }
 
   // 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;
 
@@ skipping 337 matching lines @@
   // 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);
+                   DurationInt queue_duration,
+                   DurationInt 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.
@@ skipping 99 matching lines @@
   }
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(AutoTracking);
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_