Add the concept of QueueEnabledVoters to blink 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 77 matching lines @@
                    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(TaskQueue::QueueType::COMPOSITOR)
                                    .SetShouldMonitorQuiescence(true))),
+      compositor_task_runner_enabled_voter_(
+          compositor_task_runner_->CreateQueueEnabledVoter()),
       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) {
@@ skipping 26 matching lines @@
     base::trace_event::TraceLog::GetInstance()->AddAsyncEnabledStateObserver(
         weak_factory_.GetWeakPtr());
   }
 }
 
 RendererSchedulerImpl::~RendererSchedulerImpl() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 
-  for (const scoped_refptr<TaskQueue>& loading_queue : loading_task_runners_) {
-    loading_queue->RemoveTaskObserver(
+  for (auto& pair : loading_task_runners_) {
+    pair.first->RemoveTaskObserver(
         &MainThreadOnly().loading_task_cost_estimator);
   }
-  for (const scoped_refptr<TaskQueue>& timer_queue : timer_task_runners_) {
-    timer_queue->RemoveTaskObserver(
-        &MainThreadOnly().timer_task_cost_estimator);
+  for (auto& pair : timer_task_runners_) {
+    pair.first->RemoveTaskObserver(&MainThreadOnly().timer_task_cost_estimator);
   }
 
   if (virtual_time_domain_)
     UnregisterTimeDomain(virtual_time_domain_.get());
 
   helper_.RemoveTaskTimeObserver(this);
 
   base::trace_event::TraceLog::GetInstance()->RemoveAsyncEnabledStateObserver(
       this);
 
@@ skipping 117 matching lines @@
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewLoadingTaskRunner(
     TaskQueue::QueueType queue_type) {
   helper_.CheckOnValidThread();
   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(
+  auto insert_result = loading_task_runners_.insert(std::make_pair(
+      loading_task_queue, loading_task_queue->CreateQueueEnabledVoter()));
+  insert_result.first->second->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(
     TaskQueue::QueueType queue_type) {
   helper_.CheckOnValidThread();
   // TODO(alexclarke): Consider using ApplyTaskQueuePolicy() for brevity.
   scoped_refptr<TaskQueue> timer_task_queue(
       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(
+  auto insert_result = timer_task_runners_.insert(std::make_pair(
+      timer_task_queue, timer_task_queue->CreateQueueEnabledVoter()));
+  insert_result.first->second->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;
@@ skipping 761 matching lines @@
                  "RendererScheduler.timer_tasks_seem_expensive",
                  MainThreadOnly().timer_tasks_seem_expensive);
 
   // TODO(alexclarke): Can we get rid of force update now?
   if (update_type == UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED &&
       new_policy == MainThreadOnly().current_policy) {
     return;
   }
 
   ApplyTaskQueuePolicy(compositor_task_runner_.get(),
+                       compositor_task_runner_enabled_voter_.get(),
                        MainThreadOnly().current_policy.compositor_queue_policy,
                        new_policy.compositor_queue_policy);
 
-  for (const scoped_refptr<TaskQueue>& loading_queue : loading_task_runners_) {
-    ApplyTaskQueuePolicy(loading_queue.get(),
+  for (const auto& pair : loading_task_runners_) {
+    ApplyTaskQueuePolicy(pair.first.get(), pair.second.get(),
                          MainThreadOnly().current_policy.loading_queue_policy,
                          new_policy.loading_queue_policy);
   }
 
-  for (const scoped_refptr<TaskQueue>& timer_queue : timer_task_runners_) {
-    ApplyTaskQueuePolicy(timer_queue.get(),
+  for (const auto& pair : timer_task_runners_) {
+    ApplyTaskQueuePolicy(pair.first.get(), pair.second.get(),
                          MainThreadOnly().current_policy.timer_queue_policy,
                          new_policy.timer_queue_policy);
   }
   MainThreadOnly().have_reported_blocking_intervention_in_current_policy =
       false;
 
   // TODO(alexclarke): We shouldn't have to prioritize the default queue, but it
   // appears to be necessary since the order of loading tasks and IPCs (which
   // are mostly dispatched on the default queue) need to be preserved.
-  ApplyTaskQueuePolicy(helper_.DefaultTaskRunner().get(),
+  ApplyTaskQueuePolicy(helper_.DefaultTaskRunner().get(), nullptr,
                        MainThreadOnly().current_policy.default_queue_policy,
                        new_policy.default_queue_policy);
   if (MainThreadOnly().rail_mode_observer &&
       new_policy.rail_mode != MainThreadOnly().current_policy.rail_mode) {
     MainThreadOnly().rail_mode_observer->OnRAILModeChanged(
         new_policy.rail_mode);
   }
 
   if (new_policy.should_disable_throttling !=
       MainThreadOnly().current_policy.should_disable_throttling) {
     if (new_policy.should_disable_throttling) {
       task_queue_throttler()->DisableThrottling();
     } else {
       task_queue_throttler()->EnableThrottling();
     }
   }
 
   DCHECK(compositor_task_runner_->IsQueueEnabled());
   MainThreadOnly().current_policy = new_policy;
 }
 
 void RendererSchedulerImpl::ApplyTaskQueuePolicy(
     TaskQueue* task_queue,
+    TaskQueue::QueueEnabledVoter* task_queue_enabled_voter,
     const TaskQueuePolicy& old_task_queue_policy,
     const TaskQueuePolicy& new_task_queue_policy) const {
-  if (old_task_queue_policy.is_enabled != new_task_queue_policy.is_enabled) {
-    task_queue->SetQueueEnabled(new_task_queue_policy.is_enabled);
+  if (task_queue_enabled_voter &&
+      old_task_queue_policy.is_enabled != new_task_queue_policy.is_enabled) {
+    task_queue_enabled_voter->SetQueueEnabled(new_task_queue_policy.is_enabled);
   }
 
+  // Make sure if there's no voter that the task queue is enabled.
+  DCHECK(task_queue_enabled_voter || old_task_queue_policy.is_enabled);
+
   if (old_task_queue_policy.priority != new_task_queue_policy.priority)
     task_queue->SetQueuePriority(new_task_queue_policy.priority);
 
   if (old_task_queue_policy.time_domain_type !=
       new_task_queue_policy.time_domain_type) {
     if (old_task_queue_policy.time_domain_type == TimeDomainType::THROTTLED) {
       task_queue_throttler_->DecreaseThrottleRefCount(task_queue);
     } else if (new_task_queue_policy.time_domain_type ==
                TimeDomainType::THROTTLED) {
       task_queue_throttler_->IncreaseThrottleRefCount(task_queue);
@@ skipping 111 matching lines @@
 IdleTimeEstimator* RendererSchedulerImpl::GetIdleTimeEstimatorForTesting() {
   return &MainThreadOnly().idle_time_estimator;
 }
 
 void RendererSchedulerImpl::SuspendTimerQueue() {
   MainThreadOnly().timer_queue_suspend_count++;
   ForceUpdatePolicy();
 #ifndef NDEBUG
   DCHECK(!default_timer_task_runner_->IsQueueEnabled());
   for (const auto& runner : timer_task_runners_) {
-    DCHECK(!runner->IsQueueEnabled());
+    DCHECK(!runner.first->IsQueueEnabled());
   }
 #endif
 }
 
 void RendererSchedulerImpl::ResumeTimerQueue() {
   MainThreadOnly().timer_queue_suspend_count--;
   DCHECK_GE(MainThreadOnly().timer_queue_suspend_count, 0);
   ForceUpdatePolicy();
 }
 
@@ skipping 497 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink