Cleanup: Replace 'DurationInt' with int32, and always use 32-bit integers for tracking time.

base/tracked_objects.cc

 // Copyright (c) 2012 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.
 
 #include "base/tracked_objects.h"
 
 #include <math.h>
 #include <stdlib.h>
 
 #include "base/format_macros.h"
@@ skipping 48 matching lines @@
 }
 
 // TODO(jar): I need to see if this macro to optimize branching is worth using.
 //
 // This macro has no branching, so it is surely fast, and is equivalent to:
 //             if (assign_it)
 //               target = source;
 // We use a macro rather than a template to force this to inline.
 // Related code for calculating max is discussed on the web.
 #define CONDITIONAL_ASSIGN(assign_it, target, source) \
-    ((target) ^= ((target) ^ (source)) & -static_cast<DurationInt>(assign_it))
+    ((target) ^= ((target) ^ (source)) & -static_cast<int32>(assign_it))
 
-void DeathData::RecordDeath(const DurationInt queue_duration,
-                            const DurationInt run_duration,
+void DeathData::RecordDeath(const int32 queue_duration,
+                            const int32 run_duration,
                             int32 random_number) {
   ++count_;
   queue_duration_sum_ += queue_duration;
   run_duration_sum_ += run_duration;
 
   if (queue_duration_max_ < queue_duration)
     queue_duration_max_ = queue_duration;
   if (run_duration_max_ < run_duration)
     run_duration_max_ = run_duration;
 
   // Take a uniformly distributed sample over all durations ever supplied.
   // The probability that we (instead) use this new sample is 1/count_.  This
   // results in a completely uniform selection of the sample.
   // We ignore the fact that we correlated our selection of a sample of run
   // and queue times.
   if (0 == (random_number % count_)) {
     queue_duration_sample_ = queue_duration;
     run_duration_sample_ = run_duration;
   }
 }
 
 int DeathData::count() const { return count_; }
 
-DurationInt DeathData::run_duration_sum() const { return run_duration_sum_; }
+int32 DeathData::run_duration_sum() const { return run_duration_sum_; }
 
-DurationInt DeathData::run_duration_max() const { return run_duration_max_; }
+int32 DeathData::run_duration_max() const { return run_duration_max_; }
 
-DurationInt DeathData::run_duration_sample() const {
+int32 DeathData::run_duration_sample() const {
   return run_duration_sample_;
 }
 
-DurationInt DeathData::queue_duration_sum() const {
+int32 DeathData::queue_duration_sum() const {
   return queue_duration_sum_;
 }
 
-DurationInt DeathData::queue_duration_max() const {
+int32 DeathData::queue_duration_max() const {
   return queue_duration_max_;
 }
 
-DurationInt DeathData::queue_duration_sample() const {
+int32 DeathData::queue_duration_sample() const {
   return queue_duration_sample_;
 }
 
 
 base::DictionaryValue* DeathData::ToValue() const {
   base::DictionaryValue* dictionary = new base::DictionaryValue;
   dictionary->Set("count", base::Value::CreateIntegerValue(count_));
   dictionary->Set("run_ms",
       base::Value::CreateIntegerValue(run_duration_sum()));
   dictionary->Set("run_ms_max",
@@ skipping 244 matching lines @@
       // snapshot it (but they lock before copying it).
       base::AutoLock lock(map_lock_);
       parent_child_set_.insert(pair);
     }
   }
 
   return child;
 }
 
 void ThreadData::TallyADeath(const Births& birth,
-                             DurationInt queue_duration,
-                             DurationInt run_duration) {
+                             int32 queue_duration,
+                             int32 run_duration) {
   // Stir in some randomness, plus add constant in case durations are zero.
-  const DurationInt kSomePrimeNumber = 2147483647;
+  const int32 kSomePrimeNumber = 2147483647;
   random_number_ += queue_duration + run_duration + kSomePrimeNumber;
   // An address is going to have some randomness to it as well ;-).
   random_number_ ^= static_cast<int32>(&birth - reinterpret_cast<Births*>(0));
 
   // We don't have queue durations without OS timer. OS timer is automatically
   // used for task-post-timing, so the use of an alternate timer implies all
   // queue times are invalid.
   if (kAllowAlternateTimeSourceHandling && now_function_)
     queue_duration = 0;
 
@@ skipping 54 matching lines @@
   // have for non-delayed tasks, and we consistently call it queueing delay.
   TrackedTime effective_post_time = completed_task.delayed_run_time.is_null()
       ? tracked_objects::TrackedTime(completed_task.time_posted)
       : tracked_objects::TrackedTime(completed_task.delayed_run_time);
 
   // Watch out for a race where status_ is changing, and hence one or both
   // of start_of_run or end_of_run is zero.  In that case, we didn't bother to
   // get a time value since we "weren't tracking" and we were trying to be
   // efficient by not calling for a genuine time value. For simplicity, we'll
   // use a default zero duration when we can't calculate a true value.
-  DurationInt queue_duration = 0;
-  DurationInt run_duration = 0;
+  int32 queue_duration = 0;
+  int32 run_duration = 0;
   if (!start_of_run.is_null()) {
     queue_duration = (start_of_run - effective_post_time).InMilliseconds();
     if (!end_of_run.is_null())
       run_duration = (end_of_run - start_of_run).InMilliseconds();
   }
   current_thread_data->TallyADeath(*birth, queue_duration, run_duration);
 }
 
 // static
 void ThreadData::TallyRunOnWorkerThreadIfTracking(
@@ skipping 16 matching lines @@
   // (since we'll use locks on TallyBirth and TallyDeath).  The good news is
   // that the locks on TallyDeath will be *after* the worker thread has run, and
   // hence nothing will be waiting for the completion (... besides some other
   // thread that might like to run).  Also, the worker threads tasks are
   // generally longer, and hence the cost of the lock may perchance be amortized
   // over the long task's lifetime.
   ThreadData* current_thread_data = Get();
   if (!current_thread_data)
     return;
 
-  DurationInt queue_duration = 0;
-  DurationInt run_duration = 0;
+  int32 queue_duration = 0;
+  int32 run_duration = 0;
   if (!start_of_run.is_null()) {
     queue_duration = (start_of_run - time_posted).InMilliseconds();
     if (!end_of_run.is_null())
       run_duration = (end_of_run - start_of_run).InMilliseconds();
   }
   current_thread_data->TallyADeath(*birth, queue_duration, run_duration);
 }
 
 // static
 void ThreadData::TallyRunInAScopedRegionIfTracking(
     const Births* birth,
     const TrackedTime& start_of_run,
     const TrackedTime& end_of_run) {
   if (!kTrackAllTaskObjects)
     return;  // Not compiled in.
 
   // Even if we have been DEACTIVATED, we will process any pending births so
   // that our data structures (which counted the outstanding births) remain
   // consistent.
   if (!birth)
     return;
 
   ThreadData* current_thread_data = Get();
   if (!current_thread_data)
     return;
 
-  DurationInt queue_duration = 0;
-  DurationInt run_duration = 0;
+  int32 queue_duration = 0;
+  int32 run_duration = 0;
   if (!start_of_run.is_null() && !end_of_run.is_null())
     run_duration = (end_of_run - start_of_run).InMilliseconds();
   current_thread_data->TallyADeath(*birth, queue_duration, run_duration);
 }
 
 const std::string ThreadData::thread_name() const { return thread_name_; }
 
 // This may be called from another thread.
 void ThreadData::SnapshotMaps(bool reset_max,
                               BirthMap* birth_map,
@@ skipping 349 matching lines @@
        ++it) {
     base::DictionaryValue* parent_child = new base::DictionaryValue;
     it->first->ToValue("parent", parent_child);
     it->second->ToValue("child", parent_child);
     descendants->Append(parent_child);
   }
   dictionary->Set("descendants", descendants);
 }
 
 }  // namespace tracked_objects