[scheduler] Plumb task reference to RendererScheduler::OnTaskCompleted.

Make renderer scheduler aware of a completed task. This will enable
us to record per-task metrics.

R=alexclarke@chromium.org
BUG=702318

Change-Id: Iaff9ca2c8f8398847c854dfc569db90176cdb7c6
Reviewed-on: https://chromium-review.googlesource.com/574538Reviewed-by: Alex Clarke <alexclarke@chromium.org>
Commit-Queue: Alexander Timin <altimin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#487126}

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

@@ -14,6 +14,12 @@ TaskQueue::TaskQueue(std::unique_ptr<internal::TaskQueueImpl> impl)
 
 TaskQueue::~TaskQueue() {}
 
+TaskQueue::Task::Task(const tracked_objects::Location& posted_from,
+                      base::OnceClosure task,
+                      base::TimeTicks desired_run_time,
+                      bool nestable)
+    : PendingTask(posted_from, std::move(task), desired_run_time, nestable) {}
+
 void TaskQueue::UnregisterTaskQueue() {
   impl_->UnregisterTaskQueue(this);
 }

third_party/WebKit/Source/platform/scheduler/base/task_queue.h

@@ -115,6 +115,15 @@ class PLATFORM_EXPORT TaskQueue : public base::SingleThreadTaskRunner {
     bool should_report_when_execution_blocked;
   };
 
+  // Interface to pass per-task metadata to RendererScheduler.
+  class PLATFORM_EXPORT Task : public base::PendingTask {
+   public:
+    Task(const tracked_objects::Location& posted_from,
+         base::OnceClosure task,
+         base::TimeTicks desired_run_time,
+         bool nestable);
+  };
+
   // An interface that lets the owner vote on whether or not the associated
   // TaskQueue should be enabled.
   class QueueEnabledVoter {

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

@@ -67,10 +67,10 @@ TaskQueueImpl::~TaskQueueImpl() {
 }
 
 TaskQueueImpl::Task::Task()
-    : PendingTask(tracked_objects::Location(),
-                  base::Closure(),
-                  base::TimeTicks(),
-                  true),
+    : TaskQueue::Task(tracked_objects::Location(),
+                      base::Closure(),
+                      base::TimeTicks(),
+                      true),
 #ifndef NDEBUG
       enqueue_order_set_(false),
 #endif
@@ -83,7 +83,7 @@ TaskQueueImpl::Task::Task(const tracked_objects::Location& posted_from,
                           base::TimeTicks desired_run_time,
                           EnqueueOrder sequence_number,
                           bool nestable)
-    : PendingTask(posted_from, std::move(task), desired_run_time, nestable),
+    : TaskQueue::Task(posted_from, std::move(task), desired_run_time, nestable),
 #ifndef NDEBUG
       enqueue_order_set_(false),
 #endif
@@ -97,7 +97,7 @@ TaskQueueImpl::Task::Task(const tracked_objects::Location& posted_from,
                           EnqueueOrder sequence_number,
                           bool nestable,
                           EnqueueOrder enqueue_order)
-    : PendingTask(posted_from, std::move(task), desired_run_time, nestable),
+    : TaskQueue::Task(posted_from, std::move(task), desired_run_time, nestable),
 #ifndef NDEBUG
       enqueue_order_set_(true),
 #endif
@@ -906,10 +906,11 @@ void TaskQueueImpl::SetOnTaskCompletedHandler(
   main_thread_only().on_task_completed_handler = std::move(handler);
 }
 
-void TaskQueueImpl::OnTaskCompleted(base::TimeTicks start,
+void TaskQueueImpl::OnTaskCompleted(const TaskQueue::Task& task,
+                                    base::TimeTicks start,
                                     base::TimeTicks end) {
   if (!main_thread_only().on_task_completed_handler.is_null())
-    main_thread_only().on_task_completed_handler.Run(start, end);
+    main_thread_only().on_task_completed_handler.Run(task, start, end);
 }
 
 void TaskQueueImpl::SetQueueEnabledForTest(bool enabled) {

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.h

@@ -82,7 +82,7 @@ class PLATFORM_EXPORT TaskQueueImpl {
     }
   };
 
-  class PLATFORM_EXPORT Task : public base::PendingTask {
+  class PLATFORM_EXPORT Task : public TaskQueue::Task {
    public:
     Task();
     Task(const tracked_objects::Location& posted_from,
@@ -134,8 +134,8 @@ class PLATFORM_EXPORT TaskQueueImpl {
   };
 
   using OnNextWakeUpChangedCallback = base::Callback<void(base::TimeTicks)>;
-  using OnTaskCompletedHandler =
-      base::Callback<void(base::TimeTicks, base::TimeTicks)>;
+  using OnTaskCompletedHandler = base::Callback<
+      void(const TaskQueue::Task&, base::TimeTicks, base::TimeTicks)>;
 
   // TaskQueue implementation.
   const char* GetName() const;
@@ -262,7 +262,9 @@ class PLATFORM_EXPORT TaskQueueImpl {
   // Allows wrapping TaskQueue to set a handler to subscribe for notifications
   // about completed tasks.
   void SetOnTaskCompletedHandler(OnTaskCompletedHandler handler);
-  void OnTaskCompleted(base::TimeTicks start, base::TimeTicks end);
+  void OnTaskCompleted(const TaskQueue::Task& task,
+                       base::TimeTicks start,
+                       base::TimeTicks end);
 
   // Disables queue for testing purposes, when a QueueEnabledVoter can't be
   // constructed due to not having TaskQueue.

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

@@ -544,6 +544,7 @@ TaskQueueManager::ProcessTaskResult TaskQueueManager::ProcessTaskFromWorkQueue(
       task_end_time = MonotonicTimeInSeconds(*time_after_task);
 
       queue->OnTaskCompleted(
+          pending_task,
           base::TimeTicks() + base::TimeDelta::FromSecondsD(task_start_time),
           base::TimeTicks() + base::TimeDelta::FromSecondsD(task_end_time));
 

third_party/WebKit/Source/platform/scheduler/renderer/main_thread_task_queue.cc

@@ -89,9 +89,10 @@ MainThreadTaskQueue::MainThreadTaskQueue(
 
 MainThreadTaskQueue::~MainThreadTaskQueue() {}
 
-void MainThreadTaskQueue::OnTaskCompleted(base::TimeTicks start,
+void MainThreadTaskQueue::OnTaskCompleted(const TaskQueue::Task& task,
+                                          base::TimeTicks start,
                                           base::TimeTicks end) {
-  renderer_scheduler_->OnTaskCompleted(this, start, end);
+  renderer_scheduler_->OnTaskCompleted(this, task, start, end);
 }
 
 void MainThreadTaskQueue::UnregisterTaskQueue() {

third_party/WebKit/Source/platform/scheduler/renderer/main_thread_task_queue.h

@@ -113,7 +113,9 @@ class PLATFORM_EXPORT MainThreadTaskQueue : public TaskQueue {
 
   bool CanBeSuspended() const { return can_be_suspended_; }
 
-  void OnTaskCompleted(base::TimeTicks start, base::TimeTicks end);
+  void OnTaskCompleted(const TaskQueue::Task& task,
+                       base::TimeTicks start,
+                       base::TimeTicks end);
 
   // Override base method to notify RendererScheduler about unregistered queue.
   void UnregisterTaskQueue() override;

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc

@@ -1951,6 +1951,7 @@ void RendererSchedulerImpl::DidProcessTask(double start_time, double end_time) {
 }
 
 void RendererSchedulerImpl::OnTaskCompleted(MainThreadTaskQueue* queue,
+                                            const TaskQueue::Task& task,
                                             base::TimeTicks start,
                                             base::TimeTicks end) {
   task_queue_throttler()->OnTaskRunTimeReported(queue, start, end);

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.h

@@ -236,6 +236,7 @@ class PLATFORM_EXPORT RendererSchedulerImpl
   void OnUnregisterTaskQueue(const scoped_refptr<MainThreadTaskQueue>& queue);
 
   void OnTaskCompleted(MainThreadTaskQueue* queue,
+                       const TaskQueue::Task& task,
                        base::TimeTicks start,
                        base::TimeTicks end);