chrome://profiler infrastructure uses base time types.

base/tracked_objects_unittest.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.
 
 // Test of classes in the tracked_objects.h classes.
 
 #include "base/tracked_objects.h"
 
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 62 matching lines @@
     else
       EXPECT_NE(reinterpret_cast<Births*>(NULL), birth);
   }
 
   // Helper function to verify the most common test expectations.
   void ExpectSimpleProcessData(const ProcessDataSnapshot& process_data,
                                const std::string& function_name,
                                const std::string& birth_thread,
                                const std::string& death_thread,
                                int count,
-                               int run_ms,
-                               int queue_ms) {
+                               int run_duration,
+                               int queue_duration) {
     ASSERT_EQ(1u, process_data.phased_snapshots.size());
     auto it = process_data.phased_snapshots.find(0);
     ASSERT_TRUE(it != process_data.phased_snapshots.end());
     const ProcessDataPhaseSnapshot& process_data_phase = it->second;
 
     ASSERT_EQ(1u, process_data_phase.tasks.size());
 
     EXPECT_EQ(kFile, process_data_phase.tasks[0].birth.location.file_name);
     EXPECT_EQ(function_name,
               process_data_phase.tasks[0].birth.location.function_name);
     EXPECT_EQ(kLineNumber,
               process_data_phase.tasks[0].birth.location.line_number);
 
     EXPECT_EQ(birth_thread,
               process_data_phase.tasks[0].birth.sanitized_thread_name);
 
     EXPECT_EQ(count, process_data_phase.tasks[0].death_data.count);
-    EXPECT_EQ(count * run_ms,
+    EXPECT_EQ(count * run_duration,
               process_data_phase.tasks[0].death_data.run_duration_sum);
-    EXPECT_EQ(run_ms, process_data_phase.tasks[0].death_data.run_duration_max);
-    EXPECT_EQ(run_ms,
+    EXPECT_EQ(run_duration,
+              process_data_phase.tasks[0].death_data.run_duration_max);
+    EXPECT_EQ(run_duration,
               process_data_phase.tasks[0].death_data.run_duration_sample);
-    EXPECT_EQ(count * queue_ms,
+    EXPECT_EQ(count * queue_duration,
               process_data_phase.tasks[0].death_data.queue_duration_sum);
-    EXPECT_EQ(queue_ms,
+    EXPECT_EQ(queue_duration,
               process_data_phase.tasks[0].death_data.queue_duration_max);
-    EXPECT_EQ(queue_ms,
+    EXPECT_EQ(queue_duration,
               process_data_phase.tasks[0].death_data.queue_duration_sample);
 
     EXPECT_EQ(death_thread,
               process_data_phase.tasks[0].death_sanitized_thread_name);
 
     EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
   }
 
   // Sets time that will be returned by ThreadData::Now().
   static void SetTestTime(unsigned int test_time) { test_time_ = test_time; }
@@ skipping 146 matching lines @@
   ASSERT_NE(data, nullptr);
   EXPECT_EQ(data->run_duration_sum(), 0);
   EXPECT_EQ(data->run_duration_max(), 0);
   EXPECT_EQ(data->run_duration_sample(), 0);
   EXPECT_EQ(data->queue_duration_sum(), 0);
   EXPECT_EQ(data->queue_duration_max(), 0);
   EXPECT_EQ(data->queue_duration_sample(), 0);
   EXPECT_EQ(data->count(), 0);
   EXPECT_EQ(nullptr, data->last_phase_snapshot());
 
-  int32_t run_ms = 42;
-  int32_t queue_ms = 8;
+  base::TimeDelta run_duration = base::TimeDelta::FromMilliseconds(42);
+  base::TimeDelta queue_duration = base::TimeDelta::FromMilliseconds(8);
 
   const int kUnrandomInt = 0;  // Fake random int that ensure we sample data.
-  data->RecordDurations(queue_ms, run_ms, kUnrandomInt);
-  EXPECT_EQ(data->run_duration_sum(), run_ms);
-  EXPECT_EQ(data->run_duration_max(), run_ms);
-  EXPECT_EQ(data->run_duration_sample(), run_ms);
-  EXPECT_EQ(data->queue_duration_sum(), queue_ms);
-  EXPECT_EQ(data->queue_duration_max(), queue_ms);
-  EXPECT_EQ(data->queue_duration_sample(), queue_ms);
+  data->RecordDurations(queue_duration, run_duration, kUnrandomInt);
+  EXPECT_EQ(data->run_duration_sum(), run_duration.InMilliseconds());
+  EXPECT_EQ(data->run_duration_max(), run_duration.InMilliseconds());
+  EXPECT_EQ(data->run_duration_sample(), run_duration.InMilliseconds());
+  EXPECT_EQ(data->queue_duration_sum(), queue_duration.InMilliseconds());
+  EXPECT_EQ(data->queue_duration_max(), queue_duration.InMilliseconds());
+  EXPECT_EQ(data->queue_duration_sample(), queue_duration.InMilliseconds());
   EXPECT_EQ(data->count(), 1);
   EXPECT_EQ(nullptr, data->last_phase_snapshot());
 
-  data->RecordDurations(queue_ms, run_ms, kUnrandomInt);
-  EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms);
-  EXPECT_EQ(data->run_duration_max(), run_ms);
-  EXPECT_EQ(data->run_duration_sample(), run_ms);
-  EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms);
-  EXPECT_EQ(data->queue_duration_max(), queue_ms);
-  EXPECT_EQ(data->queue_duration_sample(), queue_ms);
+  data->RecordDurations(queue_duration, run_duration, kUnrandomInt);
+  EXPECT_EQ(data->run_duration_sum(),
+            (run_duration + run_duration).InMilliseconds());
+  EXPECT_EQ(data->run_duration_max(), run_duration.InMilliseconds());
+  EXPECT_EQ(data->run_duration_sample(), run_duration.InMilliseconds());
+  EXPECT_EQ(data->queue_duration_sum(),
+            (queue_duration + queue_duration).InMilliseconds());
+  EXPECT_EQ(data->queue_duration_max(), queue_duration.InMilliseconds());
+  EXPECT_EQ(data->queue_duration_sample(), queue_duration.InMilliseconds());
   EXPECT_EQ(data->count(), 2);
   EXPECT_EQ(nullptr, data->last_phase_snapshot());
 }
 
 TEST_F(TrackedObjectsTest, DeathDataTestRecordAllocations) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   std::unique_ptr<DeathData> data(new DeathData());
   ASSERT_NE(data, nullptr);
 
@@ skipping 67 matching lines @@
             2 * static_cast<int64_t>(INT_MAX) + 3 * kAllocOverheadBytes);
   EXPECT_EQ(data->max_allocated_bytes(), INT_MAX);
 }
 
 TEST_F(TrackedObjectsTest, DeathDataTest2Phases) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   std::unique_ptr<DeathData> data(new DeathData());
   ASSERT_NE(data, nullptr);
 
-  const int32_t run_ms = 42;
-  const int32_t queue_ms = 8;
+  const base::TimeDelta run_duration = base::TimeDelta::FromMilliseconds(42);
+  const base::TimeDelta queue_duration = base::TimeDelta::FromMilliseconds(8);
 
   const int kUnrandomInt = 0;  // Fake random int that ensure we sample data.
-  data->RecordDurations(queue_ms, run_ms, kUnrandomInt);
-  data->RecordDurations(queue_ms, run_ms, kUnrandomInt);
+  data->RecordDurations(queue_duration, run_duration, kUnrandomInt);
+  data->RecordDurations(queue_duration, run_duration, kUnrandomInt);
 
   data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes,
                           kAllocOverheadBytes, kMaxAllocatedBytes);
 
   data->OnProfilingPhaseCompleted(123);
-  EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms);
+  EXPECT_EQ(data->run_duration_sum(),
+            (run_duration + run_duration).InMilliseconds());
   EXPECT_EQ(data->run_duration_max(), 0);
-  EXPECT_EQ(data->run_duration_sample(), run_ms);
-  EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms);
+  EXPECT_EQ(data->run_duration_sample(), run_duration.InMilliseconds());
+  EXPECT_EQ(data->queue_duration_sum(),
+            (queue_duration + queue_duration).InMilliseconds());
   EXPECT_EQ(data->queue_duration_max(), 0);
-  EXPECT_EQ(data->queue_duration_sample(), queue_ms);
+  EXPECT_EQ(data->queue_duration_sample(), queue_duration.InMilliseconds());
   EXPECT_EQ(data->count(), 2);
 
   EXPECT_EQ(data->alloc_ops(), kAllocOps);
   EXPECT_EQ(data->free_ops(), kFreeOps);
   EXPECT_EQ(data->allocated_bytes(), kAllocatedBytes);
   EXPECT_EQ(data->freed_bytes(), kFreedBytes);
   EXPECT_EQ(data->alloc_overhead_bytes(), kAllocOverheadBytes);
   EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes);
 
   ASSERT_NE(nullptr, data->last_phase_snapshot());
   EXPECT_EQ(123, data->last_phase_snapshot()->profiling_phase);
   EXPECT_EQ(2, data->last_phase_snapshot()->death_data.count);
-  EXPECT_EQ(2 * run_ms,
+  EXPECT_EQ(2 * run_duration.InMilliseconds(),
             data->last_phase_snapshot()->death_data.run_duration_sum);
-  EXPECT_EQ(run_ms, data->last_phase_snapshot()->death_data.run_duration_max);
-  EXPECT_EQ(run_ms,
+  EXPECT_EQ(run_duration.InMilliseconds(),
+            data->last_phase_snapshot()->death_data.run_duration_max);
+  EXPECT_EQ(run_duration.InMilliseconds(),
             data->last_phase_snapshot()->death_data.run_duration_sample);
-  EXPECT_EQ(2 * queue_ms,
+  EXPECT_EQ(2 * queue_duration.InMilliseconds(),
             data->last_phase_snapshot()->death_data.queue_duration_sum);
-  EXPECT_EQ(queue_ms,
+  EXPECT_EQ(queue_duration.InMilliseconds(),
             data->last_phase_snapshot()->death_data.queue_duration_max);
-  EXPECT_EQ(queue_ms,
+  EXPECT_EQ(queue_duration.InMilliseconds(),
             data->last_phase_snapshot()->death_data.queue_duration_sample);
 
   EXPECT_EQ(kAllocOps, data->last_phase_snapshot()->death_data.alloc_ops);
   EXPECT_EQ(kFreeOps, data->last_phase_snapshot()->death_data.free_ops);
   EXPECT_EQ(kAllocatedBytes,
             data->last_phase_snapshot()->death_data.allocated_bytes);
   EXPECT_EQ(kFreedBytes, data->last_phase_snapshot()->death_data.freed_bytes);
   EXPECT_EQ(kAllocOverheadBytes,
             data->last_phase_snapshot()->death_data.alloc_overhead_bytes);
   EXPECT_EQ(kMaxAllocatedBytes,
             data->last_phase_snapshot()->death_data.max_allocated_bytes);
 
   EXPECT_EQ(nullptr, data->last_phase_snapshot()->prev);
 
-  const int32_t run_ms1 = 21;
-  const int32_t queue_ms1 = 4;
+  const base::TimeDelta run_duration1 = base::TimeDelta::FromMilliseconds(21);
+  const base::TimeDelta queue_duration1 = base::TimeDelta::FromMilliseconds(4);
 
-  data->RecordDurations(queue_ms1, run_ms1, kUnrandomInt);
+  data->RecordDurations(queue_duration1, run_duration1, kUnrandomInt);
   data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes,
                           kAllocOverheadBytes, kMaxAllocatedBytes);
 
-  EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms + run_ms1);
-  EXPECT_EQ(data->run_duration_max(), run_ms1);
-  EXPECT_EQ(data->run_duration_sample(), run_ms1);
-  EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms + queue_ms1);
-  EXPECT_EQ(data->queue_duration_max(), queue_ms1);
-  EXPECT_EQ(data->queue_duration_sample(), queue_ms1);
+  EXPECT_EQ(data->run_duration_sum(),
+            (run_duration + run_duration + run_duration1).InMilliseconds());
+  EXPECT_EQ(data->run_duration_max(), run_duration1.InMilliseconds());
+  EXPECT_EQ(data->run_duration_sample(), run_duration1.InMilliseconds());
+  EXPECT_EQ(
+      data->queue_duration_sum(),
+      (queue_duration + queue_duration + queue_duration1).InMilliseconds());
+  EXPECT_EQ(data->queue_duration_max(), queue_duration1.InMilliseconds());
+  EXPECT_EQ(data->queue_duration_sample(), queue_duration1.InMilliseconds());
   EXPECT_EQ(data->count(), 3);
 
   EXPECT_EQ(data->alloc_ops(), 2 * kAllocOps);
   EXPECT_EQ(data->free_ops(), 2 * kFreeOps);
   EXPECT_EQ(data->allocated_bytes(), 2 * kAllocatedBytes);
   EXPECT_EQ(data->freed_bytes(), 2 * kFreedBytes);
   EXPECT_EQ(data->alloc_overhead_bytes(), 2 * kAllocOverheadBytes);
   EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes);
 
   ASSERT_NE(nullptr, data->last_phase_snapshot());
   EXPECT_EQ(123, data->last_phase_snapshot()->profiling_phase);
   EXPECT_EQ(2, data->last_phase_snapshot()->death_data.count);
-  EXPECT_EQ(2 * run_ms,
+  EXPECT_EQ(2 * run_duration.InMilliseconds(),
             data->last_phase_snapshot()->death_data.run_duration_sum);
-  EXPECT_EQ(run_ms, data->last_phase_snapshot()->death_data.run_duration_max);
-  EXPECT_EQ(run_ms,
+  EXPECT_EQ(run_duration.InMilliseconds(),
+            data->last_phase_snapshot()->death_data.run_duration_max);
+  EXPECT_EQ(run_duration.InMilliseconds(),
             data->last_phase_snapshot()->death_data.run_duration_sample);
-  EXPECT_EQ(2 * queue_ms,
+  EXPECT_EQ(2 * queue_duration.InMilliseconds(),
             data->last_phase_snapshot()->death_data.queue_duration_sum);
-  EXPECT_EQ(queue_ms,
+  EXPECT_EQ(queue_duration.InMilliseconds(),
             data->last_phase_snapshot()->death_data.queue_duration_max);
-  EXPECT_EQ(queue_ms,
+  EXPECT_EQ(queue_duration.InMilliseconds(),
             data->last_phase_snapshot()->death_data.queue_duration_sample);
 
   EXPECT_EQ(kAllocOps, data->last_phase_snapshot()->death_data.alloc_ops);
   EXPECT_EQ(kFreeOps, data->last_phase_snapshot()->death_data.free_ops);
   EXPECT_EQ(kAllocatedBytes,
             data->last_phase_snapshot()->death_data.allocated_bytes);
   EXPECT_EQ(kFreedBytes, data->last_phase_snapshot()->death_data.freed_bytes);
   EXPECT_EQ(kAllocOverheadBytes,
             data->last_phase_snapshot()->death_data.alloc_overhead_bytes);
   EXPECT_EQ(kMaxAllocatedBytes,
@@ skipping 124 matching lines @@
                           1, 0, 0);
 }
 
 TEST_F(TrackedObjectsTest, LifeCycleToSnapshotMainThread) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "LifeCycleToSnapshotMainThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
-  const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks::FromInternalValue(1000);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   const unsigned int kStartOfRun = 5;
   const unsigned int kEndOfRun = 7;
   SetTestTime(kStartOfRun);
   TaskStopwatch stopwatch;
   stopwatch.Start();
   SetTestTime(kEndOfRun);
   stopwatch.Stop();
 
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, stopwatch);
 
   ProcessDataSnapshot process_data;
   ThreadData::Snapshot(0, &process_data);
   ExpectSimpleProcessData(process_data, kFunction, kMainThreadName,
                           kMainThreadName, 1, 2, 4);
 }
 
 TEST_F(TrackedObjectsTest, TwoPhases) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "TwoPhases";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
-  const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks::FromInternalValue(1000);

[gab, 2017/06/26 21:48:12]

Why FromIntervalValue() here and elsewhere in this file?

[tdresser, 2017/06/27 13:21:56]

Switched to base::TimeTicks() + base::TimeDelta::FromMilliseconds(1) throughout.

   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   const unsigned int kStartOfRun = 5;
   const unsigned int kEndOfRun = 7;
   SetTestTime(kStartOfRun);
   TaskStopwatch stopwatch;
   stopwatch.Start();
   SetTestTime(kEndOfRun);
   stopwatch.Stop();
 
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, stopwatch);
 
   ThreadData::OnProfilingPhaseCompleted(0);
 
   TallyABirth(location, kMainThreadName);
 
-  const TrackedTime kTimePosted1 = TrackedTime::FromMilliseconds(9);
+  const base::TimeTicks kTimePosted1 = base::TimeTicks::FromInternalValue(9000);
   const base::TimeTicks kDelayedStartTime1 = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task1(location, kDelayedStartTime1);
   pending_task1.time_posted = kTimePosted1;  // Overwrite implied Now().
 
   const unsigned int kStartOfRun1 = 11;
   const unsigned int kEndOfRun1 = 21;
   SetTestTime(kStartOfRun1);
   TaskStopwatch stopwatch1;
   stopwatch1.Start();
@@ skipping 209 matching lines @@
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 TEST_F(TrackedObjectsTest, TwoPhasesSecondEmpty) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "TwoPhasesSecondEmpty";
   Location location(kFunction, kFile, kLineNumber, NULL);
   ThreadData::InitializeThreadContext(kMainThreadName);
 
-  const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks::FromInternalValue(1000);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   const unsigned int kStartOfRun = 5;
   const unsigned int kEndOfRun = 7;
   SetTestTime(kStartOfRun);
   TaskStopwatch stopwatch;
   stopwatch.Start();
@@ skipping 46 matching lines @@
 
 TEST_F(TrackedObjectsTest, TwoPhasesFirstEmpty) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   ThreadData::OnProfilingPhaseCompleted(0);
 
   const char kFunction[] = "TwoPhasesSecondEmpty";
   Location location(kFunction, kFile, kLineNumber, NULL);
   ThreadData::InitializeThreadContext(kMainThreadName);
 
-  const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks::FromInternalValue(1000);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   const unsigned int kStartOfRun = 5;
   const unsigned int kEndOfRun = 7;
   SetTestTime(kStartOfRun);
   TaskStopwatch stopwatch;
   stopwatch.Start();
@@ skipping 40 matching lines @@
 // demonstrate that the lifecycle is completely tallied. This ensures that
 // our tallied births are matched by tallied deaths (except for when the
 // task is still running, or is queued).
 TEST_F(TrackedObjectsTest, LifeCycleMidDeactivatedToSnapshotMainThread) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "LifeCycleMidDeactivatedToSnapshotMainThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
-  const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks::FromInternalValue(1000);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   // Turn off tracking now that we have births.
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED);
 
   const unsigned int kStartOfRun = 5;
   const unsigned int kEndOfRun = 7;
@@ skipping 14 matching lines @@
 // We will deactivate tracking before starting a life cycle, and neither
 // the birth nor the death will be recorded.
 TEST_F(TrackedObjectsTest, LifeCyclePreDeactivatedToSnapshotMainThread) {
   // Start in the deactivated state.
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED);
 
   const char kFunction[] = "LifeCyclePreDeactivatedToSnapshotMainThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
-  const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks::FromInternalValue(1000);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   const unsigned int kStartOfRun = 5;
   const unsigned int kEndOfRun = 7;
   SetTestTime(kStartOfRun);
   TaskStopwatch stopwatch;
   stopwatch.Start();
@@ skipping 16 matching lines @@
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 TEST_F(TrackedObjectsTest, TwoLives) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "TwoLives";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
-  const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks::FromInternalValue(1000);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   const unsigned int kStartOfRun = 5;
   const unsigned int kEndOfRun = 7;
   SetTestTime(kStartOfRun);
   TaskStopwatch stopwatch;
   stopwatch.Start();
@@ skipping 20 matching lines @@
 }
 
 TEST_F(TrackedObjectsTest, DifferentLives) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext(kMainThreadName);
   const char kFunction[] = "DifferentLives";
   Location location(kFunction, kFile, kLineNumber, NULL);
 
-  const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks::FromInternalValue(1000);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   const unsigned int kStartOfRun = 5;
   const unsigned int kEndOfRun = 7;
   SetTestTime(kStartOfRun);
   TaskStopwatch stopwatch;
   stopwatch.Start();
@@ skipping 54 matching lines @@
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 TEST_F(TrackedObjectsTest, TaskWithNestedExclusion) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "TaskWithNestedExclusion";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
-  const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks::FromInternalValue(1000);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   SetTestTime(5);
   TaskStopwatch task_stopwatch;
   task_stopwatch.Start();
   {
     SetTestTime(8);
@@ skipping 13 matching lines @@
                           kMainThreadName, 1, 6, 4);
 }
 
 TEST_F(TrackedObjectsTest, TaskWith2NestedExclusions) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "TaskWith2NestedExclusions";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, kMainThreadName);
 
-  const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks::FromInternalValue(1000);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   SetTestTime(5);
   TaskStopwatch task_stopwatch;
   task_stopwatch.Start();
   {
     SetTestTime(8);
@@ skipping 22 matching lines @@
 TEST_F(TrackedObjectsTest, TaskWithNestedExclusionWithNestedTask) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "TaskWithNestedExclusionWithNestedTask";
   Location location(kFunction, kFile, kLineNumber, NULL);
 
   const int kSecondFakeLineNumber = 999;
 
   TallyABirth(location, kMainThreadName);
 
-  const TrackedTime kTimePosted = TrackedTime::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks::FromInternalValue(1000);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   SetTestTime(5);
   TaskStopwatch task_stopwatch;
   task_stopwatch.Start();
   {
     SetTestTime(8);
     TaskStopwatch exclusion_stopwatch;
     exclusion_stopwatch.Start();
     {
       Location second_location(kFunction, kFile, kSecondFakeLineNumber, NULL);
       base::TrackingInfo nested_task(second_location, kDelayedStartTime);
        // Overwrite implied Now().
-      nested_task.time_posted = TrackedTime::FromMilliseconds(8);
+      nested_task.time_posted = base::TimeTicks::FromInternalValue(8000);
       SetTestTime(9);
       TaskStopwatch nested_task_stopwatch;
       nested_task_stopwatch.Start();
       SetTestTime(11);
       nested_task_stopwatch.Stop();
       ThreadData::TallyRunOnNamedThreadIfTracking(
           nested_task, nested_task_stopwatch);
     }
     SetTestTime(12);
     exclusion_stopwatch.Stop();
@@ skipping 69 matching lines @@
       EXPECT_TRUE(thread.Start());
     }
   }
 
   // Expect one ThreadData instance for each element in |kThreadNames| and one
   // ThreadData instance for the main thread.
   EXPECT_EQ(static_cast<int>(arraysize(kThreadNames) + 1), GetNumThreadData());
 }
 
 }  // namespace tracked_objects