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

Index: third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc
index 31adb7257af790faa8ed72b0ed0487afd98a3768..b5d865364adc73b21f87ca7258406652236b8ad5 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc
@@ -14,7 +14,6 @@
 #include "platform/scheduler/base/task_queue_impl.h"
 #include "platform/scheduler/base/task_queue_manager_delegate.h"
 #include "platform/scheduler/base/task_queue_selector.h"
-#include "platform/scheduler/base/task_time_tracker.h"
 #include "platform/scheduler/base/work_queue.h"
 #include "platform/scheduler/base/work_queue_sets.h"
 
@@ -34,6 +33,11 @@ void RecordImmediateTaskQueueingDuration(tracked_objects::Duration duration) {
       "RendererScheduler.TaskQueueManager.ImmediateTaskQueueingDuration",
       base::TimeDelta::FromMilliseconds(duration.InMilliseconds()));
 }
+
+double MonotonicTimeInSeconds(base::TimeTicks timeTicks) {

[caseq, 2016/08/22 18:48:49]

WTF::monotonicallyIncreasingTime()?

[panicker, 2016/08/22 23:14:14]

I'm trying to convert the provided timeTicks, not just seeking a time value

+  return (timeTicks.ToInternalValue() / static_cast<double>(
+      base::Time::kMicrosecondsPerSecond));
+}
 }
 
 TaskQueueManager::TaskQueueManager(
@@ -46,7 +50,6 @@ TaskQueueManager::TaskQueueManager(
       task_was_run_on_quiescence_monitored_queue_(false),
       work_batch_size_(1),
       task_count_(0),
-      task_time_tracker_(nullptr),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
@@ -197,7 +200,7 @@ void TaskQueueManager::DoWork(base::TimeTicks run_time, bool from_main_thread) {
   LazyNow lazy_now(real_time_domain()->CreateLazyNow());
   base::TimeTicks task_start_time;
 
-  if (!delegate_->IsNested() && task_time_tracker_)
+  if (!delegate_->IsNested() && task_time_observers_.might_have_observers() > 0)
     task_start_time = lazy_now.Now();
 
   // Pass false and nullptr to UpdateWorkQueues here to prevent waking up a
@@ -215,7 +218,19 @@ void TaskQueueManager::DoWork(base::TimeTicks run_time, bool from_main_thread) {
     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()) {
+        FOR_EACH_OBSERVER(WebThread::TaskTimeObserver, task_time_observers_,

[Sami, 2016/08/22 15:51:30]

(Indentation looks a little off -- git cl format should fix this)

[panicker, 2016/08/22 23:14:14]

Done.

+                          willProcessTask());
+    }
+    TaskQueueManager::ProcessTaskResult result = ProcessTaskFromWorkQueue(
+        work_queue, &previous_task);
+    if (!delegate_->IsNested()) {
+        FOR_EACH_OBSERVER(WebThread::TaskTimeObserver, task_time_observers_,

[caseq, 2016/08/22 18:48:49]

Have you considered moving this into ProcessTaskFromWorkQueue()? I don't think
we need any signals in case it bails out without running the task, and it will
also make this similar to other observers.

[panicker, 2016/08/22 23:14:14]

Addressed in new patch.
Sami had the same comment -- and it turns out that the additional set of
willProcess & didProcess wasn't strictly necessary.

+                          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
@@ -228,10 +243,13 @@ void TaskQueueManager::DoWork(base::TimeTicks run_time, bool from_main_thread) {
     }
 
     lazy_now = real_time_domain()->CreateLazyNow();
-    if (!delegate_->IsNested() && task_time_tracker_) {
+    if (!delegate_->IsNested() && task_time_observers_.might_have_observers()) {
       // Only report top level task durations.
       base::TimeTicks task_end_time = lazy_now.Now();
-      task_time_tracker_->ReportTaskTime(task_start_time, task_end_time);
+      FOR_EACH_OBSERVER(
+          WebThread::TaskTimeObserver, task_time_observers_, reportTaskTime(
+              MonotonicTimeInSeconds(task_start_time),
+              MonotonicTimeInSeconds(task_end_time)));
       task_start_time = task_end_time;
     }
 
@@ -374,6 +392,18 @@ void TaskQueueManager::RemoveTaskObserver(
   task_observers_.RemoveObserver(task_observer);
 }
 
+void TaskQueueManager::AddTaskTimeObserver(
+    WebThread::TaskTimeObserver* task_time_observer) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  task_time_observers_.AddObserver(task_time_observer);

[alph, 2016/08/22 22:21:27]

nit: You could also add it into task_observers_, so you don't need an extra code
that calls 'will...' and 'did...'

[panicker, 2016/08/22 23:14:14]

yep - done in new patch.

+}
+
+void TaskQueueManager::RemoveTaskTimeObserver(
+    WebThread::TaskTimeObserver* task_time_observer) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  task_time_observers_.RemoveObserver(task_time_observer);
+}
+
 bool TaskQueueManager::GetAndClearSystemIsQuiescentBit() {
   bool task_was_run = task_was_run_on_quiescence_monitored_queue_;
   task_was_run_on_quiescence_monitored_queue_ = false;