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/prioritizing_task_queue_selector.h"
 #include "components/scheduler/child/time_source.h"
 
 namespace scheduler {
 
 SchedulerHelper::SchedulerHelper(
     scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
@@ skipping 10 matching lines @@
                                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),
       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 43 matching lines @@
 
 SchedulerHelper::~SchedulerHelper() {
 }
 
 SchedulerHelper::SchedulerHelperDelegate::SchedulerHelperDelegate() {
 }
 
 SchedulerHelper::SchedulerHelperDelegate::~SchedulerHelperDelegate() {
 }
 
+void SchedulerHelper::PreShutdown() {
+  CheckOnValidThread();
+  TRACE_EVENT0(disabled_by_default_tracing_category_, "PreShutdownInternal");
+  EndIdlePeriod();
+  task_queue_selector_->DisableQueue(QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE);
+  task_queue_manager_->FlushQueue(QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE);

[Sami, 2015/04/23 18:47:49]

Why do we need to flush again? Won't the selector ensure that no tasks will get
executed from these queues?

[alex clarke (OOO till 29th), 2015/04/24 09:32:36]

I was worried about crashes on shutdown.  I was able to fix these another way. 
We don't need this anymore.

+  task_queue_selector_->DisableQueue(QueueId::DEFAULT_TASK_QUEUE);
+  task_queue_manager_->FlushQueue(QueueId::DEFAULT_TASK_QUEUE);
+  for (size_t i = TASK_QUEUE_COUNT; i < total_task_queue_count_; i++) {
+    task_queue_selector_->DisableQueue(i);
+    task_queue_manager_->FlushQueue(i);
+  }
+}
+
 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 230 matching lines @@
   return task_queue_manager_->IsQueueEmpty(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