Adds a SHUTDOWN_TASK_QUEUE and a PreShutdown api to the scheduler.

components/scheduler/child/prioritizing_task_queue_selector.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 "components/scheduler/child/prioritizing_task_queue_selector.h"
 
 #include "base/logging.h"
 #include "base/pending_task.h"
 #include "base/trace_event/trace_event_argument.h"
 
 namespace scheduler {
 
 PrioritizingTaskQueueSelector::PrioritizingTaskQueueSelector()
-    : starvation_count_(0), task_queue_selector_observer_(nullptr) {
+    : starvation_count_(0), task_queue_selector_observer_(nullptr),
+      pre_shutdown_(false) {
 }
 
 PrioritizingTaskQueueSelector::~PrioritizingTaskQueueSelector() {
 }
 
+void PrioritizingTaskQueueSelector::PreShutdown() {
+  pre_shutdown_ = true;
+}
+
 void PrioritizingTaskQueueSelector::RegisterWorkQueues(
     const std::vector<const base::TaskQueue*>& work_queues) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   work_queues_ = work_queues;
   for (auto& queue_priority : queue_priorities_) {
     queue_priority.clear();
   }
 
   // By default, all work queues are set to normal priority.
   for (size_t i = 0; i < work_queues.size(); i++) {
     queue_priorities_[NORMAL_PRIORITY].insert(i);
   }
 }
 
 void PrioritizingTaskQueueSelector::SetQueuePriority(size_t queue_index,
                                                      QueuePriority priority) {
+  if (pre_shutdown_)
+    return;
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK_LT(queue_index, work_queues_.size());
   DCHECK_LT(priority, QUEUE_PRIORITY_COUNT);
   bool previously_enabled = DisableQueueInternal(queue_index);
   queue_priorities_[priority].insert(queue_index);
   if (task_queue_selector_observer_ && !previously_enabled)
     task_queue_selector_observer_->OnTaskQueueEnabled();
 }
 
 void PrioritizingTaskQueueSelector::EnableQueue(size_t queue_index,
                                                 QueuePriority priority) {
+  if (pre_shutdown_)
+    return;
   SetQueuePriority(queue_index, priority);
 }
 
 void PrioritizingTaskQueueSelector::DisableQueue(size_t queue_index) {
+  if (pre_shutdown_)
+    return;
   DisableQueueInternal(queue_index);
 }
 
 bool PrioritizingTaskQueueSelector::DisableQueueInternal(size_t queue_index) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK_LT(queue_index, work_queues_.size());
   bool previously_enabled = false;
   for (auto& queue_priority : queue_priorities_) {
     if (queue_priority.erase(queue_index))
       previously_enabled = true;
@@ skipping 122 matching lines @@
   state->EndDictionary();
   state->SetInteger("starvation_count", starvation_count_);
 }
 
 void PrioritizingTaskQueueSelector::SetTaskQueueSelectorObserver(
     Observer* observer) {
   task_queue_selector_observer_ = observer;
 }
 
 }  // namespace scheduler