POC: Instrument task time tracker

components/scheduler/child/scheduler_helper.cc

 // Copyright 2015 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 "components/scheduler/child/scheduler_helper.h"
 
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "components/scheduler/base/task_queue_impl.h"
 #include "components/scheduler/child/scheduler_tqm_delegate.h"
 
 namespace scheduler {
 
 SchedulerHelper::SchedulerHelper(
     scoped_refptr<SchedulerTqmDelegate> task_queue_manager_delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     const char* disabled_by_default_verbose_tracing_category)
     : task_queue_manager_delegate_(task_queue_manager_delegate),
+      task_time_tracker_(new TaskTimeTracker()),
       task_queue_manager_(
           new TaskQueueManager(task_queue_manager_delegate,
                                tracing_category,
                                disabled_by_default_tracing_category,
-                               disabled_by_default_verbose_tracing_category)),
+                               disabled_by_default_verbose_tracing_category,
+                               task_time_tracker_.get())),
       control_task_runner_(NewTaskQueue(
           TaskQueue::Spec("control_tq")
               .SetWakeupPolicy(TaskQueue::WakeupPolicy::DONT_WAKE_OTHER_QUEUES)
               .SetShouldNotifyObservers(false))),
       control_after_wakeup_task_runner_(NewTaskQueue(
           TaskQueue::Spec("control_after_wakeup_tq")
               .SetPumpPolicy(TaskQueue::PumpPolicy::AFTER_WAKEUP)
               .SetWakeupPolicy(TaskQueue::WakeupPolicy::DONT_WAKE_OTHER_QUEUES)
               .SetShouldNotifyObservers(false))),
       default_task_runner_(NewTaskQueue(TaskQueue::Spec("default_tq")
@@ skipping 78 matching lines @@
     base::MessageLoop::TaskObserver* task_observer) {
   CheckOnValidThread();
   if (task_queue_manager_)
     task_queue_manager_->RemoveTaskObserver(task_observer);
 }
 
 void SchedulerHelper::SetObserver(Observer* observer) {
   CheckOnValidThread();
   observer_ = observer;
   DCHECK(task_queue_manager_);
+  DCHECK(task_time_tracker_);
   task_queue_manager_->SetObserver(this);
+  task_time_tracker_->SetObserver(this);
 }
 
 RealTimeDomain* SchedulerHelper::real_time_domain() const {
   CheckOnValidThread();
   DCHECK(task_queue_manager_);
   return task_queue_manager_->real_time_domain();
 }
 
 void SchedulerHelper::RegisterTimeDomain(TimeDomain* time_domain) {
   CheckOnValidThread();
@@ skipping 19 matching lines @@
   if (observer_)
     observer_->OnTriedToExecuteBlockedTask(queue, task);
 }
 
 TaskQueue* SchedulerHelper::CurrentlyExecutingTaskQueue() const {
   if (!task_queue_manager_)
     return nullptr;
   return task_queue_manager_->currently_executing_task_queue();
 }
 
+// TaskTimeTracker::TaskTimeObserver implementation:
+void SchedulerHelper::OnLongTask(base::TimeDelta long_task_time) {
+  // Record long task
+  // will be queried from RendererSchedulerImpl in BeginMainFrame
+}
+
 }  // namespace scheduler