chrome://profiler infrastructure uses base time types.

third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc

 // Copyright 2014 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 "platform/scheduler/base/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 11 matching lines @@
 namespace scheduler {
 
 namespace {
 const size_t kRecordRecordTaskDelayHistogramsEveryNTasks = 10;
 
 void RecordDelayedTaskLateness(base::TimeDelta lateness) {
   UMA_HISTOGRAM_TIMES("RendererScheduler.TaskQueueManager.DelayedTaskLateness",
                       lateness);
 }
 
-void RecordImmediateTaskQueueingDuration(tracked_objects::Duration duration) {
+void RecordImmediateTaskQueueingDuration(base::TimeDelta duration) {
   UMA_HISTOGRAM_TIMES(
       "RendererScheduler.TaskQueueManager.ImmediateTaskQueueingDuration",
-      base::TimeDelta::FromMilliseconds(duration.InMilliseconds()));
+      duration);
 }
 
 double MonotonicTimeInSeconds(base::TimeTicks time_ticks) {
   return (time_ticks - base::TimeTicks()).InSecondsF();
 }
 
 // Converts a OnceClosure to a RepeatingClosure. It hits CHECK failure to run
 // the resulting RepeatingClosure more than once.
 // TODO(tzik): This will be unneeded after the Closure-to-OnceClosure migration
 // on TaskRunner finished. Remove it once it gets unneeded.
@@ skipping 511 matching lines @@
     const internal::TaskQueueImpl::Task& pending_task,
     const internal::TaskQueueImpl* queue) {
   if ((task_count_++ % kRecordRecordTaskDelayHistogramsEveryNTasks) != 0)
     return;
 
   // Record delayed task lateness and immediate task queuing durations.
   if (!pending_task.delayed_run_time.is_null()) {
     RecordDelayedTaskLateness(delegate_->NowTicks() -
                               pending_task.delayed_run_time);
   } else if (!pending_task.time_posted.is_null()) {
-    RecordImmediateTaskQueueingDuration(tracked_objects::TrackedTime::Now() -
+    RecordImmediateTaskQueueingDuration(base::TimeTicks::Now() -
                                         pending_task.time_posted);
   }
 }
 
 bool TaskQueueManager::RunsTasksInCurrentSequence() const {
   return delegate_->RunsTasksInCurrentSequence();
 }
 
 void TaskQueueManager::SetWorkBatchSize(int work_batch_size) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
@@ skipping 126 matching lines @@
   for (const scoped_refptr<internal::TaskQueueImpl>& queue : queues_) {
     TimeDomain* time_domain = queue->GetTimeDomain();
     if (time_domain_now.find(time_domain) == time_domain_now.end())
       time_domain_now.insert(std::make_pair(time_domain, time_domain->Now()));
     queue->SweepCanceledDelayedTasks(time_domain_now[time_domain]);
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink