Move and rename TaskTimeTracker to public interface exposed to WebThread, use in WebPerf Agent.

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 16 matching lines @@
 void RecordDelayedTaskLateness(base::TimeDelta lateness) {
   UMA_HISTOGRAM_TIMES("RendererScheduler.TaskQueueManager.DelayedTaskLateness",
                       lateness);
 }
 
 void RecordImmediateTaskQueueingDuration(tracked_objects::Duration duration) {
   UMA_HISTOGRAM_TIMES(
       "RendererScheduler.TaskQueueManager.ImmediateTaskQueueingDuration",
       base::TimeDelta::FromMilliseconds(duration.InMilliseconds()));
 }
+
+double MonotonicTimeInSeconds(base::TimeTicks timeTicks) {
+  return (timeTicks.ToInternalValue() / static_cast<double>(
+      base::Time::kMicrosecondsPerSecond));
+}
 }
 
 TaskQueueManager::TaskQueueManager(
     scoped_refptr<TaskQueueManagerDelegate> delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     const char* disabled_by_default_verbose_tracing_category)
     : real_time_domain_(new RealTimeDomain(tracing_category)),
       delegate_(delegate),
       task_was_run_on_quiescence_monitored_queue_(false),
       work_batch_size_(1),
       task_count_(0),
       task_time_tracker_(nullptr),
+      task_time_observer_(nullptr),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
       disabled_by_default_verbose_tracing_category_(
           disabled_by_default_verbose_tracing_category),
       currently_executing_task_queue_(nullptr),
       observer_(nullptr),
       deletion_sentinel_(new DeletionSentinel()),
       weak_factory_(this) {
   DCHECK(delegate->RunsTasksOnCurrentThread());
@@ skipping 148 matching lines @@
 
   for (int i = 0; i < work_batch_size_; i++) {
     internal::WorkQueue* work_queue;
     if (!SelectWorkQueueToService(&work_queue)) {
       break;
     }
 
     bool should_trigger_wakeup = work_queue->task_queue()->wakeup_policy() ==
                                  TaskQueue::WakeupPolicy::CAN_WAKE_OTHER_QUEUES;
 
-    switch (ProcessTaskFromWorkQueue(work_queue, &previous_task)) {
+    if (!delegate_->IsNested() && task_time_observer_)
+      task_time_observer_->willProcessTask();
+    TaskQueueManager::ProcessTaskResult result = ProcessTaskFromWorkQueue(
+        work_queue, &previous_task);
+    if (!delegate_->IsNested() && task_time_observer_)
+      task_time_observer_->didProcessTask();
+
+    switch (result) {
       case ProcessTaskResult::DEFERRED:
         // If a task was deferred, try again with another task. Note that this
         // means deferred tasks (i.e. non-nestable tasks) will never trigger
         // queue wake-ups.
         continue;
       case ProcessTaskResult::EXECUTED:
         break;
       case ProcessTaskResult::TASK_QUEUE_MANAGER_DELETED:
         return;  // The TaskQueueManager got deleted, we must bail out.
     }
 
     lazy_now = real_time_domain()->CreateLazyNow();
     if (!delegate_->IsNested() && task_time_tracker_) {
       // Only report top level task durations.
       base::TimeTicks task_end_time = lazy_now.Now();
       task_time_tracker_->ReportTaskTime(task_start_time, task_end_time);
+      if (task_time_observer_)
+          task_time_observer_->reportTaskTime(
+              MonotonicTimeInSeconds(task_start_time),
+              MonotonicTimeInSeconds(task_end_time));
       task_start_time = task_end_time;
     }
 
     work_queue = nullptr;  // The queue may have been unregistered.
 
     UpdateWorkQueues(should_trigger_wakeup, &previous_task, lazy_now);
 
     // Only run a single task per batch in nested run loops so that we can
     // properly exit the nested loop when someone calls RunLoop::Quit().
     if (delegate_->IsNested())
@@ skipping 189 matching lines @@
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(!work_queue->Empty());
   if (observer_) {
     observer_->OnTriedToExecuteBlockedTask(*work_queue->task_queue(),
                                            *work_queue->GetFrontTask());
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink