[scheduler] Add type to scheduler::TaskQueue

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.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 "platform/scheduler/base/task_queue_impl.h"
 
 #include "base/trace_event/blame_context.h"
 #include "platform/scheduler/base/task_queue_manager.h"
 #include "platform/scheduler/base/task_queue_manager_delegate.h"
 #include "platform/scheduler/base/time_domain.h"
 #include "platform/scheduler/base/work_queue.h"
 
 namespace blink {
 namespace scheduler {
 
+// static
+const char* TaskQueue::NameForQueueType(TaskQueue::QueueType queue_type) {
+  switch (queue_type) {
+    case TaskQueue::QueueType::CONTROL:
+      return "control_tq";
+    case TaskQueue::QueueType::DEFAULT:
+      return "default_tq";
+    case TaskQueue::QueueType::DEFAULT_LOADING:
+      return "default_loading_tq";
+    case TaskQueue::QueueType::DEFAULT_TIMER:
+      return "default_timer_tq";
+    case TaskQueue::QueueType::UNTHROTTLED:
+      return "unthrottled_tq";
+    case TaskQueue::QueueType::FRAME_LOADING:
+      return "frame_loading_tq";
+    case TaskQueue::QueueType::FRAME_TIMER:
+      return "frame_timer_tq";
+    case TaskQueue::QueueType::FRAME_UNTHROTTLED:
+      return "frame_unthrottled_tq";
+    case TaskQueue::QueueType::COMPOSITOR:
+      return "compositor_tq";
+    case TaskQueue::QueueType::IDLE:
+      return "idle_tq";
+    case TaskQueue::QueueType::TEST:
+      return "test_tq";
+    case TaskQueue::QueueType::COUNT:
+      DCHECK(false);
+      return nullptr;
+  }
+  DCHECK(false);
+  return nullptr;
+}
+
 namespace internal {
 
 TaskQueueImpl::TaskQueueImpl(
     TaskQueueManager* task_queue_manager,
     TimeDomain* time_domain,
     const Spec& spec,
     const char* disabled_by_default_tracing_category,
     const char* disabled_by_default_verbose_tracing_category)
     : thread_id_(base::PlatformThread::CurrentId()),
       any_thread_(task_queue_manager, time_domain),
-      name_(spec.name),
+      type_(spec.type),
+      name_(NameForQueueType(spec.type)),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
       disabled_by_default_verbose_tracing_category_(
           disabled_by_default_verbose_tracing_category),
       main_thread_only_(task_queue_manager, this, time_domain),
       should_monitor_quiescence_(spec.should_monitor_quiescence),
       should_notify_observers_(spec.should_notify_observers),
       should_report_when_execution_blocked_(
           spec.should_report_when_execution_blocked) {
   DCHECK(time_domain);
@@ skipping 384 matching lines @@
                      main_thread_only().delayed_work_queue->Size() +
                      main_thread_only().delayed_incoming_queue.size());
   if (!is_locked)
     any_thread_lock_.Release();
 }
 
 const char* TaskQueueImpl::GetName() const {
   return name_;
 }
 
+TaskQueue::QueueType TaskQueueImpl::GetQueueType() const {
+  return type_;
+}
+
 void TaskQueueImpl::SetQueuePriority(QueuePriority priority) {
   if (!main_thread_only().task_queue_manager || priority == GetQueuePriority())
     return;
   main_thread_only().task_queue_manager->selector_.SetQueuePriority(this,
                                                                     priority);
 }
 
 TaskQueueImpl::QueuePriority TaskQueueImpl::GetQueuePriority() const {
   size_t set_index = immediate_work_queue()->work_queue_set_index();
   DCHECK_EQ(set_index, delayed_work_queue()->work_queue_set_index());
@@ skipping 264 matching lines @@
   state->SetBoolean("is_cancelled", task.task.IsCancelled());
   state->SetDouble(
       "delayed_run_time",
       (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L);
   state->EndDictionary();
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink