Adds a SHUTDOWN_TASK_QUEUE and a PreShutdown api to the scheduler.

components/scheduler/child/scheduler_helper.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 "components/scheduler/child/scheduler_helper.h"
 
+#include "base/synchronization/waitable_event.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "components/scheduler/child/nestable_single_thread_task_runner.h"
 #include "components/scheduler/child/time_source.h"
 
 namespace scheduler {
 
 SchedulerHelper::SchedulerHelper(
     scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
     SchedulerHelperDelegate* scheduler_helper_delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     const char* idle_period_tracing_name,
     size_t total_task_queue_count,
     base::TimeDelta required_quiescence_duration_before_long_idle_period)
     : task_queue_selector_(new PrioritizingTaskQueueSelector()),
       task_queue_manager_(
           new TaskQueueManager(total_task_queue_count,
                                main_task_runner,
                                task_queue_selector_.get(),
                                disabled_by_default_tracing_category)),
       idle_period_state_(IdlePeriodState::NOT_IN_IDLE_PERIOD),
       scheduler_helper_delegate_(scheduler_helper_delegate),
       control_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(QueueId::CONTROL_TASK_QUEUE)),
       control_task_after_wakeup_runner_(task_queue_manager_->TaskRunnerForQueue(
           QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE)),
       default_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(QueueId::DEFAULT_TASK_QUEUE)),
+      shutdown_task_runner_(task_queue_manager_->TaskRunnerForQueue(
+          QueueId::SHUTDOWN_TASK_QUEUE)),
+      total_task_queue_count_(total_task_queue_count),
+      in_preshutdown_(false),
       quiescence_monitored_task_queue_mask_(
           ((1ull << total_task_queue_count) - 1ull) &
           ~(1ull << QueueId::IDLE_TASK_QUEUE) &
           ~(1ull << QueueId::CONTROL_TASK_QUEUE) &
           ~(1ull << QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE)),
       required_quiescence_duration_before_long_idle_period_(
           required_quiescence_duration_before_long_idle_period),
       time_source_(new TimeSource),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
@@ skipping 10 matching lines @@
   enable_next_long_idle_period_after_wakeup_closure_.Reset(base::Bind(
       &SchedulerHelper::EnableLongIdlePeriodAfterWakeup, weak_scheduler_ptr_));
 
   idle_task_runner_ = make_scoped_refptr(new SingleThreadIdleTaskRunner(
       task_queue_manager_->TaskRunnerForQueue(QueueId::IDLE_TASK_QUEUE),
       control_task_after_wakeup_runner_,
       base::Bind(&SchedulerHelper::CurrentIdleTaskDeadlineCallback,
                  weak_scheduler_ptr_),
       tracing_category));
 
-  task_queue_selector_->SetQueuePriority(
-      QueueId::CONTROL_TASK_QUEUE,
-      PrioritizingTaskQueueSelector::CONTROL_PRIORITY);
+  SetQueuePriority(QueueId::CONTROL_TASK_QUEUE,
+                   PrioritizingTaskQueueSelector::CONTROL_PRIORITY);
 
-  task_queue_selector_->SetQueuePriority(
-      QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE,
-      PrioritizingTaskQueueSelector::CONTROL_PRIORITY);
+  SetQueuePriority(QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE,
+                   PrioritizingTaskQueueSelector::CONTROL_PRIORITY);
   task_queue_manager_->SetPumpPolicy(
       QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE,
       TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 
-  task_queue_selector_->DisableQueue(QueueId::IDLE_TASK_QUEUE);
+  DisableQueue(QueueId::IDLE_TASK_QUEUE);
   task_queue_manager_->SetPumpPolicy(QueueId::IDLE_TASK_QUEUE,
                                      TaskQueueManager::PumpPolicy::MANUAL);
 
   for (size_t i = 0; i < TASK_QUEUE_COUNT; i++) {
     task_queue_manager_->SetQueueName(
         i, TaskQueueIdToString(static_cast<QueueId>(i)));
   }
 
   // TODO(skyostil): Increase this to 4 (crbug.com/444764).
   task_queue_manager_->SetWorkBatchSize(1);
 }
 
 SchedulerHelper::~SchedulerHelper() {
 }
 
 SchedulerHelper::SchedulerHelperDelegate::SchedulerHelperDelegate() {
 }
 
 SchedulerHelper::SchedulerHelperDelegate::~SchedulerHelperDelegate() {
 }
 
+void SchedulerHelper::PreShutdown() {
+  CheckOnValidThread();
+  DCHECK(!in_preshutdown_);
+  TRACE_EVENT0(disabled_by_default_tracing_category_, "PreShutdown");
+  // Disable everything except the shutdown task queue.
+  for (size_t i = 0; i < total_task_queue_count_; i++) {
+    if (i == SHUTDOWN_TASK_QUEUE)
+      continue;
+    DisableQueue(i);
+  }
+  // Ensure that the queues don't get re-enabled.
+  in_preshutdown_ = true;
+}
+
 void SchedulerHelper::Shutdown() {
   CheckOnValidThread();
   task_queue_manager_.reset();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 SchedulerHelper::DefaultTaskRunner() {
   CheckOnValidThread();
   return default_task_runner_;
 }
 
 scoped_refptr<SingleThreadIdleTaskRunner> SchedulerHelper::IdleTaskRunner() {
   CheckOnValidThread();
   return idle_task_runner_;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
+SchedulerHelper::ShutdownTaskRunner() {
+  return shutdown_task_runner_;
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
 SchedulerHelper::ControlTaskRunner() {
   return control_task_runner_;
 }
 
 void SchedulerHelper::CurrentIdleTaskDeadlineCallback(
     base::TimeTicks* deadline_out) const {
   CheckOnValidThread();
   *deadline_out = idle_period_deadline_;
 }
 
@@ skipping 121 matching lines @@
 
 void SchedulerHelper::StartIdlePeriod(IdlePeriodState new_state,
                                       base::TimeTicks now,
                                       base::TimeTicks idle_period_deadline,
                                       bool post_end_idle_period) {
   DCHECK_GT(idle_period_deadline, now);
   TRACE_EVENT_ASYNC_BEGIN0(tracing_category_, idle_period_tracing_name_, this);
   CheckOnValidThread();
   DCHECK(IsInIdlePeriod(new_state));
 
-  task_queue_selector_->EnableQueue(
-      QueueId::IDLE_TASK_QUEUE,
-      PrioritizingTaskQueueSelector::BEST_EFFORT_PRIORITY);
+  EnableQueue(QueueId::IDLE_TASK_QUEUE,
+              PrioritizingTaskQueueSelector::BEST_EFFORT_PRIORITY);
   task_queue_manager_->PumpQueue(QueueId::IDLE_TASK_QUEUE);
   idle_period_state_ = new_state;
 
   idle_period_deadline_ = idle_period_deadline;
   if (post_end_idle_period) {
     control_task_runner_->PostDelayedTask(FROM_HERE,
                                           end_idle_period_closure_.callback(),
                                           idle_period_deadline_ - now);
   }
 }
@@ skipping 16 matching lines @@
     TRACE_EVENT_CATEGORY_GROUP_ENABLED(tracing_category_, &is_tracing);
     if (is_tracing && !idle_period_deadline_.is_null() &&
         base::TimeTicks::Now() > idle_period_deadline_) {
       TRACE_EVENT_ASYNC_STEP_INTO_WITH_TIMESTAMP0(
           tracing_category_, idle_period_tracing_name_, this, "DeadlineOverrun",
           idle_period_deadline_.ToInternalValue());
     }
     TRACE_EVENT_ASYNC_END0(tracing_category_, idle_period_tracing_name_, this);
   }
 
-  task_queue_selector_->DisableQueue(QueueId::IDLE_TASK_QUEUE);
+  DisableQueue(QueueId::IDLE_TASK_QUEUE);
   idle_period_state_ = IdlePeriodState::NOT_IN_IDLE_PERIOD;
   idle_period_deadline_ = base::TimeTicks();
 }
 
 // static
 bool SchedulerHelper::IsInIdlePeriod(IdlePeriodState state) {
   return state != IdlePeriodState::NOT_IN_IDLE_PERIOD;
 }
 
 bool SchedulerHelper::CanExceedIdleDeadlineIfRequired() const {
@@ skipping 41 matching lines @@
 
 bool SchedulerHelper::IsQueueEmpty(size_t queue_index) const {
   CheckOnValidThread();
   return task_queue_manager_->IsQueueEmpty(queue_index);
 }
 
 void SchedulerHelper::SetQueuePriority(
     size_t queue_index,
     PrioritizingTaskQueueSelector::QueuePriority priority) {
   CheckOnValidThread();
+  if (in_preshutdown_)
+    return;
   return task_queue_selector_->SetQueuePriority(queue_index, priority);
 }
 
 void SchedulerHelper::EnableQueue(
     size_t queue_index,
     PrioritizingTaskQueueSelector::QueuePriority priority) {
   CheckOnValidThread();
+  if (in_preshutdown_)
+    return;
   task_queue_selector_->EnableQueue(queue_index, priority);
 }
 
 void SchedulerHelper::DisableQueue(size_t queue_index) {
   CheckOnValidThread();
+  if (in_preshutdown_)
+    return;
   task_queue_selector_->DisableQueue(queue_index);
 }
 
 bool SchedulerHelper::IsQueueEnabled(size_t queue_index) const {
   CheckOnValidThread();
   return task_queue_selector_->IsQueueEnabled(queue_index);
 }
 
 // static
 const char* SchedulerHelper::TaskQueueIdToString(QueueId queue_id) {
   switch (queue_id) {
     case DEFAULT_TASK_QUEUE:
       return "default_tq";
     case IDLE_TASK_QUEUE:
       return "idle_tq";
+    case SHUTDOWN_TASK_QUEUE:
+      return "shutdown_tq";
     case CONTROL_TASK_QUEUE:
       return "control_tq";
     case CONTROL_TASK_AFTER_WAKEUP_QUEUE:
       return "control_after_wakeup_tq";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
@@ skipping 25 matching lines @@
 }
 
 void SchedulerHelper::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   CheckOnValidThread();
   if (task_queue_manager_)
     task_queue_manager_->RemoveTaskObserver(task_observer);
 }
 
 }  // namespace scheduler