chrome://profiler infrastructure uses base time types.

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 <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/allocator/features.h"
 #include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/containers/hash_tables.h"
 #include "base/debug/debugging_flags.h"
 #include "base/debug/thread_heap_usage_tracker.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/tracked_time.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_local_storage.h"
 
 namespace base {
 struct TrackingInfo;
 }
 
 // TrackedObjects provides a database of stats about objects (generally Tasks)
 // that are tracked.  Tracking means their birth, death, duration, birth thread,
 // death thread, and birth place are recorded.  This data is carefully spread
@@ skipping 299 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 RecordDurations(const int32_t queue_duration,
-                       const int32_t run_duration,
+  void RecordDurations(const base::TimeDelta queue_duration,
+                       const base::TimeDelta run_duration,
                        const uint32_t random_number);
 
   // Update stats for a task destruction that performed |alloc_ops|
   // allocations, |free_ops| frees, allocated |allocated_bytes| bytes, freed
   // |freed_bytes|, where an estimated |alloc_overhead_bytes| went to heap
   // overhead, and where at most |max_allocated_bytes| were outstanding at any
   // one time.
   // Note that |alloc_overhead_bytes|/|alloc_ops| yields the average estimated
   // heap overhead of allocations in the task, and |allocated_bytes|/|alloc_ops|
   // yields the average size of allocation.
@@ skipping 241 matching lines @@
       const base::TrackingInfo& completed_task,
       const TaskStopwatch& stopwatch);
 
   // Record the end of a timed run of an object.  The |birth| is the record for
   // the instance, the |time_posted| records that instant, which is presumed to
   // be when the task was posted into a queue to run on a worker thread.
   // The |start_of_run| is when the worker thread started to perform the run of
   // the task.
   // The |end_of_run| was just obtained by a call to Now() (just after the task
   // finished).
-  static void TallyRunOnWorkerThreadIfTracking(const Births* births,
-                                               const TrackedTime& time_posted,
-                                               const TaskStopwatch& stopwatch);
+  static void TallyRunOnWorkerThreadIfTracking(
+      const Births* births,
+      const base::TimeTicks& time_posted,
+      const TaskStopwatch& stopwatch);
 
   // Record the end of execution in region, generally corresponding to a scope
   // being exited.
   static void TallyRunInAScopedRegionIfTracking(const Births* births,
                                                 const TaskStopwatch& stopwatch);
 
   const std::string& sanitized_thread_name() const {
     return sanitized_thread_name_;
   }
 
@@ skipping 12 matching lines @@
   // DEACTIVATED).
   static bool TrackingStatus();
 
   // Enables profiler timing.
   static void EnableProfilerTiming();
 
   // Provide a time function that does nothing (runs fast) when we don't have
   // the profiler enabled.  It will generally be optimized away when it is
   // ifdef'ed to be small enough (allowing the profiler to be "compiled out" of
   // the code).
-  static TrackedTime Now();
+  static base::TimeTicks Now();
 
   // This function can be called at process termination to validate that thread
   // cleanup routines have been called for at least some number of named
   // threads.
   static void EnsureCleanupWasCalled(int major_threads_shutdown_count);
 
  private:
   friend class TaskStopwatch;
   // Allow only tests to call ShutdownSingleThreadedCleanup.  We NEVER call it
   // in production code.
@@ skipping 24 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_t queue_duration,
+                   base::TimeDelta 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 135 matching lines @@
   TaskStopwatch();
   ~TaskStopwatch();
 
   // Starts stopwatch.
   void Start();
 
   // Stops stopwatch.
   void Stop();
 
   // Returns the start time.
-  TrackedTime StartTime() const;
+  base::TimeTicks 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_t RunDurationMs() const;
+  base::TimeDelta RunDuration() const;
 
 #if BUILDFLAG(USE_ALLOCATOR_SHIM)
   const base::debug::ThreadHeapUsageTracker& heap_usage() const {
     return heap_usage_;
   }
   bool heap_tracking_enabled() const { return heap_tracking_enabled_; }
 #endif
 
   // Returns tracking info for the current thread.
   ThreadData* GetThreadData() const;
 
  private:
   // Time when the stopwatch was started.
-  TrackedTime start_time_;
+  base::TimeTicks start_time_;
 
 #if BUILDFLAG(USE_ALLOCATOR_SHIM)
   base::debug::ThreadHeapUsageTracker heap_usage_;
   bool heap_tracking_enabled_;
 #endif
 
   // Wallclock duration of the task.
-  int32_t wallclock_duration_ms_;
+  base::TimeDelta wallclock_duration_;
 
   // 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_t excluded_duration_ms_;
+  base::TimeDelta excluded_duration_;
 
   // 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 27 matching lines @@
   ProcessDataSnapshot(const ProcessDataSnapshot& other);
   ~ProcessDataSnapshot();
 
   PhasedProcessDataSnapshotMap phased_snapshots;
   base::ProcessId process_id;
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_