Add TaskType::kWorkerThreadTaskQueueCompositor and use it for compositors

Before this CL, null was passed to Mojo binding as a compositor task
runner in offscreen canvas on worker thread as NonMainThreadTaskRunner::
CompositorTaskRunner() returns null. In this case,
SingleThreadTaskRunner::Get() was used internally Mojo.

This CL implements WorkerThreadScheduler::CompositorTaskRunner() with
a new task type kWorkerThreadTaskQueueCompositor so that we can know the
task runner's usage on UMA for task duration per task type.

Bug: 841172
Change-Id: I8caf3244169300aed45eeab4fcd01999bc823976
Reviewed-on: https://chromium-review.googlesource.com/1073169Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Commit-Queue: Hajime Hoshi <hajimehoshi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#561847}

third_party/blink/public/platform/task_type.h

@@ -172,7 +172,7 @@ enum class TaskType : unsigned {
   kInternalIntersectionObserver = 44,
 
   ///////////////////////////////////////
-  // The following task types are only for MainThreadTaskQueue.
+  // The following task types are only for thread-local queues.
   ///////////////////////////////////////
 
   kMainThreadTaskQueueV8 = 37,
@@ -185,6 +185,7 @@ enum class TaskType : unsigned {
   kCompositorThreadTaskQueueDefault = 45,
   kWorkerThreadTaskQueueDefault = 46,
   kWorkerThreadTaskQueueV8 = 47,
+  kWorkerThreadTaskQueueCompositor = 48,
 
   ///////////////////////////////////////
   // The following task types are DEPRECATED! Use kInternal* instead.
@@ -194,7 +195,7 @@ enum class TaskType : unsigned {
   // should be very limited.
   kUnthrottled = 25,
 
-  kCount = 48,
+  kCount = 49,
 };
 
 }  // namespace blink

third_party/blink/renderer/platform/scheduler/child/worker_scheduler.cc

@@ -107,6 +107,7 @@ scoped_refptr<base::SingleThreadTaskRunner> WorkerScheduler::GetTaskRunner(
     case TaskType::kCompositorThreadTaskQueueDefault:
     case TaskType::kWorkerThreadTaskQueueDefault:
     case TaskType::kWorkerThreadTaskQueueV8:
+    case TaskType::kWorkerThreadTaskQueueCompositor:
     case TaskType::kCount:
       NOTREACHED();
       break;

third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl.cc

@@ -346,6 +346,7 @@ scoped_refptr<base::SingleThreadTaskRunner> FrameSchedulerImpl::GetTaskRunner(
     case TaskType::kCompositorThreadTaskQueueDefault:
     case TaskType::kWorkerThreadTaskQueueDefault:
     case TaskType::kWorkerThreadTaskQueueV8:
+    case TaskType::kWorkerThreadTaskQueueCompositor:
     case TaskType::kCount:
       NOTREACHED();
       break;

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.cc

@@ -209,6 +209,8 @@ const char* TaskTypeToString(TaskType task_type) {
       return "WorkerThreadTaskQueueDefault";
     case TaskType::kWorkerThreadTaskQueueV8:
       return "WorkerThreadTaskQueueV8";
+    case TaskType::kWorkerThreadTaskQueueCompositor:
+      return "WorkerThreadTaskQueueCompositor";
     case TaskType::kCount:
       return "Count";
   }

third_party/blink/renderer/platform/scheduler/public/non_main_thread_scheduler.h

@@ -71,7 +71,6 @@ class PLATFORM_EXPORT NonMainThreadScheduler : public ThreadSchedulerImpl {
                     WebThread::IdleTask task) override;
   void PostNonNestableIdleTask(const base::Location& location,
                                WebThread::IdleTask task) override;
-  scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override;
   std::unique_ptr<PageScheduler> CreatePageScheduler(
       PageScheduler::Delegate*) override;
   std::unique_ptr<RendererPauseHandle> PauseScheduler() override

third_party/blink/renderer/platform/scheduler/worker/compositor_thread_scheduler.cc

@@ -71,6 +71,12 @@ CompositorThreadScheduler::V8TaskRunner() {
   return nullptr;
 }
 
+scoped_refptr<base::SingleThreadTaskRunner>
+CompositorThreadScheduler::CompositorTaskRunner() {
+  NOTREACHED();
+  return nullptr;
+}
+
 scoped_refptr<base::SingleThreadTaskRunner>
 CompositorThreadScheduler::IPCTaskRunner() {
   return base::ThreadTaskRunnerHandle::Get();

third_party/blink/renderer/platform/scheduler/worker/compositor_thread_scheduler.h

@@ -46,6 +46,7 @@ class PLATFORM_EXPORT CompositorThreadScheduler
   scoped_refptr<scheduler::SingleThreadIdleTaskRunner> IdleTaskRunner()
       override;
   scoped_refptr<base::SingleThreadTaskRunner> V8TaskRunner() override;
+  scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override;
   scoped_refptr<base::SingleThreadTaskRunner> IPCTaskRunner() override;
   bool ShouldYieldForHighPriorityWork() override;
   bool CanExceedIdleDeadlineIfRequired() const override;

third_party/blink/renderer/platform/scheduler/worker/non_main_thread_scheduler.cc

@@ -71,11 +71,6 @@ void NonMainThreadScheduler::PostNonNestableIdleTask(
       base::BindOnce(&NonMainThreadScheduler::RunIdleTask, std::move(task)));
 }
 
-scoped_refptr<base::SingleThreadTaskRunner>
-NonMainThreadScheduler::CompositorTaskRunner() {
-  return nullptr;
-}
-
 std::unique_ptr<blink::PageScheduler>
 NonMainThreadScheduler::CreatePageScheduler(PageScheduler::Delegate* delegate) {
   NOTREACHED();

third_party/blink/renderer/platform/scheduler/worker/worker_thread_scheduler.cc

@@ -119,6 +119,12 @@ WorkerThreadScheduler::V8TaskRunner() {
   return v8_task_runner_;
 }
 
+scoped_refptr<base::SingleThreadTaskRunner>
+WorkerThreadScheduler::CompositorTaskRunner() {
+  DCHECK(initialized_);
+  return compositor_task_runner_;
+}
+
 scoped_refptr<base::SingleThreadTaskRunner>
 WorkerThreadScheduler::IPCTaskRunner() {
   return base::ThreadTaskRunnerHandle::Get();
@@ -173,6 +179,8 @@ void WorkerThreadScheduler::InitImpl() {
 
   v8_task_runner_ = TaskQueueWithTaskType::Create(
       DefaultTaskQueue(), TaskType::kWorkerThreadTaskQueueV8);
+  compositor_task_runner_ = TaskQueueWithTaskType::Create(
+      DefaultTaskQueue(), TaskType::kWorkerThreadTaskQueueCompositor);
 }
 
 void WorkerThreadScheduler::OnTaskCompleted(

third_party/blink/renderer/platform/scheduler/worker/worker_thread_scheduler.h

@@ -46,6 +46,7 @@ class PLATFORM_EXPORT WorkerThreadScheduler
   scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override;
   scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() override;
   scoped_refptr<base::SingleThreadTaskRunner> V8TaskRunner() override;
+  scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override;
   scoped_refptr<base::SingleThreadTaskRunner> IPCTaskRunner() override;
   bool ShouldYieldForHighPriorityWork() override;
   bool CanExceedIdleDeadlineIfRequired() const override;
@@ -111,6 +112,7 @@ class PLATFORM_EXPORT WorkerThreadScheduler
   base::TimeTicks thread_start_time_;
   scoped_refptr<WorkerTaskQueue> control_task_queue_;
   scoped_refptr<base::SingleThreadTaskRunner> v8_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
   FrameScheduler::ThrottlingState throttling_state_;
 
   WorkerMetricsHelper worker_metrics_helper_;