Switch to standard integer types in base/.

base/tracked_objects.h

 // 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.
 
 #ifndef BASE_TRACKED_OBJECTS_H_
 #define BASE_TRACKED_OBJECTS_H_
 
+#include <stdint.h>
+
 #include <map>
 #include <set>
 #include <stack>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/process/process_handle.h"
 #include "base/profiler/alternate_timer.h"
 #include "base/profiler/tracked_time.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_local_storage.h"
 
 namespace base {
 struct TrackingInfo;
 }
@@ skipping 220 matching lines @@
 
 struct BASE_EXPORT DeathDataSnapshot {
   DeathDataSnapshot();
 
   // Constructs the snapshot from individual values.
   // The alternative would be taking a DeathData parameter, but this would
   // create a loop since DeathData indirectly refers DeathDataSnapshot.  Passing
   // a wrapper structure as a param or using an empty constructor for
   // snapshotting DeathData would be less efficient.
   DeathDataSnapshot(int count,
-                    int32 run_duration_sum,
-                    int32 run_duration_max,
-                    int32 run_duration_sample,
-                    int32 queue_duration_sum,
-                    int32 queue_duration_max,
-                    int32 queue_duration_sample);
+                    int32_t run_duration_sum,
+                    int32_t run_duration_max,
+                    int32_t run_duration_sample,
+                    int32_t queue_duration_sum,
+                    int32_t queue_duration_max,
+                    int32_t queue_duration_sample);
   ~DeathDataSnapshot();
 
   // Calculates and returns the delta between this snapshot and an earlier
   // snapshot of the same task |older|.
   DeathDataSnapshot Delta(const DeathDataSnapshot& older) const;
 
   int count;
-  int32 run_duration_sum;
-  int32 run_duration_max;
-  int32 run_duration_sample;
-  int32 queue_duration_sum;
-  int32 queue_duration_max;
-  int32 queue_duration_sample;
+  int32_t run_duration_sum;
+  int32_t run_duration_max;
+  int32_t run_duration_sample;
+  int32_t queue_duration_sum;
+  int32_t queue_duration_max;
+  int32_t queue_duration_sample;
 };
 
 //------------------------------------------------------------------------------
 // A "snapshotted" representation of the DeathData for a particular profiling
 // phase.  Used as an element of the list of phase snapshots owned by DeathData.
 
 struct DeathDataPhaseSnapshot {
   DeathDataPhaseSnapshot(int profiling_phase,
                          int count,
-                         int32 run_duration_sum,
-                         int32 run_duration_max,
-                         int32 run_duration_sample,
-                         int32 queue_duration_sum,
-                         int32 queue_duration_max,
-                         int32 queue_duration_sample,
+                         int32_t run_duration_sum,
+                         int32_t run_duration_max,
+                         int32_t run_duration_sample,
+                         int32_t queue_duration_sum,
+                         int32_t queue_duration_max,
+                         int32_t queue_duration_sample,
                          const DeathDataPhaseSnapshot* prev);
 
   // Profiling phase at which completion this snapshot was taken.
   int profiling_phase;
 
   // Death data snapshot.
   DeathDataSnapshot death_data;
 
   // Pointer to a snapshot from the previous phase.
   const DeathDataPhaseSnapshot* prev;
@@ skipping 12 matching lines @@
 // snapshotted.
 
 class BASE_EXPORT DeathData {
  public:
   DeathData();
   DeathData(const DeathData& other);
   ~DeathData();
 
   // 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 int32 queue_duration,
-                   const int32 run_duration,
-                   const uint32 random_number);
+  void RecordDeath(const int32_t queue_duration,
+                   const int32_t run_duration,
+                   const uint32_t random_number);
 
   // Metrics and past snapshots accessors, used only for serialization and in
   // tests.
   int count() const { return count_; }
-  int32 run_duration_sum() const { return run_duration_sum_; }
-  int32 run_duration_max() const { return run_duration_max_; }
-  int32 run_duration_sample() const { return run_duration_sample_; }
-  int32 queue_duration_sum() const { return queue_duration_sum_; }
-  int32 queue_duration_max() const { return queue_duration_max_; }
-  int32 queue_duration_sample() const { return queue_duration_sample_; }
+  int32_t run_duration_sum() const { return run_duration_sum_; }
+  int32_t run_duration_max() const { return run_duration_max_; }
+  int32_t run_duration_sample() const { return run_duration_sample_; }
+  int32_t queue_duration_sum() const { return queue_duration_sum_; }
+  int32_t queue_duration_max() const { return queue_duration_max_; }
+  int32_t queue_duration_sample() const { return queue_duration_sample_; }
   const DeathDataPhaseSnapshot* last_phase_snapshot() const {
     return last_phase_snapshot_;
   }
 
   // Called when the current profiling phase, identified by |profiling_phase|,
   // ends.
   // Must be called only on the snapshot thread.
   void OnProfilingPhaseCompleted(int profiling_phase);
 
  private:
   // Members are ordered from most regularly read and updated, to least
   // frequently used.  This might help a bit with cache lines.
   // Number of runs seen (divisor for calculating averages).
   // Can be incremented only on the death thread.
   int count_;
 
   // Count used in determining probability of selecting exec/queue times from a
   // recorded death as samples.
   // Gets incremented only on the death thread, but can be set to 0 by
   // OnProfilingPhaseCompleted() on the snapshot thread.
   int sample_probability_count_;
 
   // Basic tallies, used to compute averages.  Can be incremented only on the
   // death thread.
-  int32 run_duration_sum_;
-  int32 queue_duration_sum_;
+  int32_t run_duration_sum_;
+  int32_t queue_duration_sum_;
   // Max values, used by local visualization routines.  These are often read,
   // but rarely updated.  The max values get assigned only on the death thread,
   // but these fields can be set to 0 by OnProfilingPhaseCompleted() on the
   // snapshot thread.
-  int32 run_duration_max_;
-  int32 queue_duration_max_;
+  int32_t run_duration_max_;
+  int32_t queue_duration_max_;
   // Samples, used by crowd sourcing gatherers.  These are almost never read,
   // and rarely updated.  They can be modified only on the death thread.
-  int32 run_duration_sample_;
-  int32 queue_duration_sample_;
+  int32_t run_duration_sample_;
+  int32_t queue_duration_sample_;
 
   // Snapshot of this death data made at the last profiling phase completion, if
   // any.  DeathData owns the whole list starting with this pointer.
   // Can be accessed only on the snapshot thread.
   const DeathDataPhaseSnapshot* last_phase_snapshot_;
 
   DISALLOW_ASSIGN(DeathData);
 };
 
 //------------------------------------------------------------------------------
@@ skipping 181 matching lines @@
 
   // Iterate through the null terminated list of ThreadData instances.
   ThreadData* next() const;
 
 
   // 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& births,
-                   int32 queue_duration,
+                   int32_t queue_duration,
                    const TaskStopwatch& stopwatch);
 
   // Snapshots (under a lock) the profiled data for the tasks for this thread
   // and writes all of the executed tasks' data -- i.e. the data for all
   // profiling phases (including the current one: |current_profiling_phase|) for
   // the tasks with with entries in the death_map_ -- into |phased_snapshots|.
   // Also updates the |birth_counts| tally for each task to keep track of the
   // number of living instances of the task -- that is, each task maps to the
   // number of births for the task that have not yet been balanced by a death.
   void SnapshotExecutedTasks(int current_profiling_phase,
@@ skipping 112 matching lines @@
   // threads.  To support this, we acquire this lock if we are writing from this
   // thread, or reading from another thread.  For reading from this thread we
   // don't need a lock, as there is no potential for a conflict since the
   // writing is only done from this thread.
   mutable base::Lock map_lock_;
 
   // A random number that we used to select decide which sample to keep as a
   // representative sample in each DeathData instance.  We can't start off with
   // much randomness (because we can't call RandInt() on all our threads), so
   // we stir in more and more as we go.
-  uint32 random_number_;
+  uint32_t random_number_;
 
   // Record of what the incarnation_counter_ was when this instance was created.
   // If the incarnation_counter_ has changed, then we avoid pushing into the
   // pool (this is only critical in tests which go through multiple
   // incarnations).
   int incarnation_count_for_pool_;
 
   // Most recently started (i.e. most nested) stopwatch on the current thread,
   // if it exists; NULL otherwise.
   TaskStopwatch* current_stopwatch_;
@@ skipping 19 matching lines @@
   // Stops stopwatch.
   void Stop();
 
   // Returns the start time.
   TrackedTime StartTime() const;
 
   // Task's duration is calculated as the wallclock duration between starting
   // and stopping this stopwatch, minus the wallclock durations of any other
   // instances that are immediately nested in this one, started and stopped on
   // this thread during that period.
-  int32 RunDurationMs() const;
+  int32_t RunDurationMs() const;
 
   // Returns tracking info for the current thread.
   ThreadData* GetThreadData() const;
 
  private:
   // Time when the stopwatch was started.
   TrackedTime start_time_;
 
   // Wallclock duration of the task.
-  int32 wallclock_duration_ms_;
+  int32_t wallclock_duration_ms_;
 
   // Tracking info for the current thread.
   ThreadData* current_thread_data_;
 
   // Sum of wallclock durations of all stopwatches that were directly nested in
   // this one.
-  int32 excluded_duration_ms_;
+  int32_t excluded_duration_ms_;
 
   // Stopwatch which was running on our thread when this stopwatch was started.
   // That preexisting stopwatch must be adjusted to the exclude the wallclock
   // duration of this stopwatch.
   TaskStopwatch* parent_;
 
 #if DCHECK_IS_ON()
   // State of the stopwatch.  Stopwatch is first constructed in a created state
   // state, then is optionally started/stopped, then destructed.
   enum { CREATED, RUNNING, STOPPED } state_;
@@ skipping 25 matching lines @@
   ProcessDataSnapshot();
   ~ProcessDataSnapshot();
 
   PhasedProcessDataSnapshotMap phased_snapshots;
   base::ProcessId process_id;
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_