[scheduler] Add type to scheduler::TaskQueue

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

 // Copyright 2014 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/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 61 matching lines @@
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler.debug")),
       idle_helper_(&helper_,
                    this,
                    "renderer.scheduler",
                    TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                    "RendererSchedulerIdlePeriod",
                    base::TimeDelta()),
       render_widget_scheduler_signals_(this),
       control_task_runner_(helper_.ControlTaskRunner()),
-      compositor_task_runner_(helper_.NewTaskQueue(
-          TaskQueue::Spec("compositor_tq").SetShouldMonitorQuiescence(true))),
+      compositor_task_runner_(
+          helper_.NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::COMPOSITOR)
+                                   .SetShouldMonitorQuiescence(true))),
       delayed_update_policy_runner_(
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
           helper_.ControlTaskRunner()),
       main_thread_only_(this,
                         compositor_task_runner_,
                         helper_.scheduler_tqm_delegate().get(),
                         helper_.scheduler_tqm_delegate()->NowTicks()),
       policy_may_need_update_(&any_thread_lock_),
       weak_factory_(this) {
   task_queue_throttler_.reset(
       new TaskQueueThrottler(this, "renderer.scheduler"));
   update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                                       weak_factory_.GetWeakPtr());
   end_renderer_hidden_idle_period_closure_.Reset(base::Bind(
       &RendererSchedulerImpl::EndIdlePeriod, weak_factory_.GetWeakPtr()));
 
   suspend_timers_when_backgrounded_closure_.Reset(
       base::Bind(&RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded,
                  weak_factory_.GetWeakPtr()));
 
-  default_loading_task_runner_ = NewLoadingTaskRunner("default_loading_tq");
-  default_timer_task_runner_ = NewTimerTaskRunner("default_timer_tq");
+  default_loading_task_runner_ =
+      NewLoadingTaskRunner(TaskQueue::QueueType::DEFAULT_LOADING);
+  default_timer_task_runner_ =
+      NewTimerTaskRunner(TaskQueue::QueueType::DEFAULT_TIMER);
 
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 
   helper_.SetObserver(this);
   helper_.AddTaskTimeObserver(this);
 }
 
 RendererSchedulerImpl::~RendererSchedulerImpl() {
@@ skipping 125 matching lines @@
   helper_.CheckOnValidThread();
   return default_timer_task_runner_;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::ControlTaskRunner() {
   helper_.CheckOnValidThread();
   return helper_.ControlTaskRunner();
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewLoadingTaskRunner(
-    const char* name) {
+    TaskQueue::QueueType queue_type) {
   helper_.CheckOnValidThread();
-  scoped_refptr<TaskQueue> loading_task_queue(helper_.NewTaskQueue(
-      TaskQueue::Spec(name).SetShouldMonitorQuiescence(true).SetTimeDomain(
-          MainThreadOnly().use_virtual_time ? GetVirtualTimeDomain()
-                                            : nullptr)));
+  scoped_refptr<TaskQueue> loading_task_queue(
+      helper_.NewTaskQueue(TaskQueue::Spec(queue_type)
+                               .SetShouldMonitorQuiescence(true)
+                               .SetTimeDomain(MainThreadOnly().use_virtual_time
+                                                  ? GetVirtualTimeDomain()
+                                                  : nullptr)));
   loading_task_runners_.insert(loading_task_queue);
   loading_task_queue->SetQueueEnabled(
       MainThreadOnly().current_policy.loading_queue_policy.is_enabled);
   loading_task_queue->SetQueuePriority(
       MainThreadOnly().current_policy.loading_queue_policy.priority);
   if (MainThreadOnly().current_policy.loading_queue_policy.time_domain_type ==
       TimeDomainType::THROTTLED) {
     task_queue_throttler_->IncreaseThrottleRefCount(loading_task_queue.get());
   }
   loading_task_queue->AddTaskObserver(
       &MainThreadOnly().loading_task_cost_estimator);
   return loading_task_queue;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewTimerTaskRunner(
-    const char* name) {
+    TaskQueue::QueueType queue_type) {
   helper_.CheckOnValidThread();
   // TODO(alexclarke): Consider using ApplyTaskQueuePolicy() for brevity.
   scoped_refptr<TaskQueue> timer_task_queue(
-      helper_.NewTaskQueue(TaskQueue::Spec(name)
+      helper_.NewTaskQueue(TaskQueue::Spec(queue_type)
                                .SetShouldMonitorQuiescence(true)
                                .SetShouldReportWhenExecutionBlocked(true)
                                .SetTimeDomain(MainThreadOnly().use_virtual_time
                                                   ? GetVirtualTimeDomain()
                                                   : nullptr)));
   timer_task_runners_.insert(timer_task_queue);
   timer_task_queue->SetQueueEnabled(
       MainThreadOnly().current_policy.timer_queue_policy.is_enabled);
   timer_task_queue->SetQueuePriority(
       MainThreadOnly().current_policy.timer_queue_policy.priority);
   if (MainThreadOnly().current_policy.timer_queue_policy.time_domain_type ==
       TimeDomainType::THROTTLED) {
     task_queue_throttler_->IncreaseThrottleRefCount(timer_task_queue.get());
   }
   timer_task_queue->AddTaskObserver(
       &MainThreadOnly().timer_task_cost_estimator);
   return timer_task_queue;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewUnthrottledTaskRunner(
-    const char* name) {
+    TaskQueue::QueueType queue_type) {
   helper_.CheckOnValidThread();
-  scoped_refptr<TaskQueue> unthrottled_task_queue(helper_.NewTaskQueue(
-      TaskQueue::Spec(name).SetShouldMonitorQuiescence(true).SetTimeDomain(
-          MainThreadOnly().use_virtual_time ? GetVirtualTimeDomain()
-                                            : nullptr)));
+  scoped_refptr<TaskQueue> unthrottled_task_queue(
+      helper_.NewTaskQueue(TaskQueue::Spec(queue_type)
+                               .SetShouldMonitorQuiescence(true)
+                               .SetTimeDomain(MainThreadOnly().use_virtual_time
+                                                  ? GetVirtualTimeDomain()
+                                                  : nullptr)));
   unthrottled_task_runners_.insert(unthrottled_task_queue);
   return unthrottled_task_queue;
 }
 
 std::unique_ptr<RenderWidgetSchedulingState>
 RendererSchedulerImpl::NewRenderWidgetSchedulingState() {
   return render_widget_scheduler_signals_.NewRenderWidgetSchedulingState();
 }
 
 void RendererSchedulerImpl::OnUnregisterTaskQueue(
@@ skipping 1191 matching lines @@
   // We want to measure thread time here, but for efficiency reasons
   // we stick with wall time.
   MainThreadOnly().foreground_main_thread_load_tracker.RecordTaskTime(
       start_time_ticks, end_time_ticks);
   MainThreadOnly().background_main_thread_load_tracker.RecordTaskTime(
       start_time_ticks, end_time_ticks);
   // TODO(altimin): Per-page metrics should also be considered.
   UMA_HISTOGRAM_CUSTOM_COUNTS("RendererScheduler.TaskTime",
                               (end_time_ticks - start_time_ticks).InMicroseconds(), 1,
                               1000000, 50);
+  UMA_HISTOGRAM_ENUMERATION("RendererScheduler.NumberOfTasksPerQueueType",
+                            static_cast<int>(task_queue->GetQueueType()),
+                            static_cast<int>(TaskQueue::QueueType::COUNT));
 }
 
 void RendererSchedulerImpl::AddTaskTimeObserver(
     TaskTimeObserver* task_time_observer) {
   helper_.AddTaskTimeObserver(task_time_observer);
 }
 
 void RendererSchedulerImpl::RemoveTaskTimeObserver(
     TaskTimeObserver* task_time_observer) {
   helper_.RemoveTaskTimeObserver(task_time_observer);
@@ skipping 65 matching lines @@
     case v8::PERFORMANCE_LOAD:
       return "load";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink