Adds a SHUTDOWN_TASK_QUEUE and a PreShutdown api to the scheduler.

components/scheduler/child/scheduler_helper.h

 // 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.
 
 #ifndef COMPONENTS_SCHEDULER_CHILD_SCHEDULER_HELPER_H_
 #define COMPONENTS_SCHEDULER_CHILD_SCHEDULER_HELPER_H_
 
 #include "components/scheduler/child/cancelable_closure_holder.h"
 #include "components/scheduler/child/single_thread_idle_task_runner.h"
 #include "components/scheduler/child/task_queue_manager.h"
@@ skipping 43 matching lines @@
   ~SchedulerHelper();
 
   // Returns the default task runner.
   scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner();
 
   // Returns the idle task runner. Tasks posted to this runner may be reordered
   // relative to other task types and may be starved for an arbitrarily long
   // time if no idle time is available.
   scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner();
 
+  // Returns the shutdown task runner.  Intended for tasks that must be able to
+  // run, even after PreShutdown() is called.
+  scoped_refptr<base::SingleThreadTaskRunner> ShutdownTaskRunner();
+
   // Returns the control task runner.  Tasks posted to this runner are executed
   // with the highest priority. Care must be taken to avoid starvation of other
   // task queues.
   scoped_refptr<base::SingleThreadTaskRunner> ControlTaskRunner();
 
   // Returns true if a currently running idle task could exceed its deadline
   // without impacting user experience too much. This should only be used if
   // there is a task which cannot be pre-empted and is likely to take longer
   // than the largest expected idle task deadline. It should NOT be polled to
   // check whether more work can be performed on the current idle task after
   // its deadline has expired - post a new idle task for the continuation of the
   // work in this case.
   // Must be called from the thread this class was created on.
   bool CanExceedIdleDeadlineIfRequired() const;
 
   // Adds or removes a task observer from the scheduler. The observer will be
   // notified before and after every executed task. These functions can only be
   // called on the thread this class was created on.
   void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer);
   void RemoveTaskObserver(base::MessageLoop::TaskObserver* task_observer);
 
+  // Optional. This stops all queues except for shutdown and control queues.
+  // Also ends any idle periods. If posted from a different thread, it blocks
+  // until the thread this class was created on has completed the pre-shutdown.
+  void PreShutdown();
+
   // Shuts down the scheduler by dropping any remaining pending work in the work
   // queues. After this call any work posted to the task runners will be
   // silently dropped.
   void Shutdown();
 
   // Returns true if Shutdown() has been called. Otherwise returns false.
   bool IsShutdown() const { return !task_queue_manager_.get(); }
 
   // Keep SchedulerHelper::TaskQueueIdToString in sync with this enum.
   enum QueueId {
     DEFAULT_TASK_QUEUE,
     IDLE_TASK_QUEUE,
+    SHUTDOWN_TASK_QUEUE,
     CONTROL_TASK_QUEUE,
     CONTROL_TASK_AFTER_WAKEUP_QUEUE,
     // Must be the last entry.
     TASK_QUEUE_COUNT,
   };
 
   // Keep SchedulerHelper::IdlePeriodStateToString in sync with this enum.
   enum class IdlePeriodState {
     NOT_IN_IDLE_PERIOD,
     IN_SHORT_IDLE_PERIOD,
@@ skipping 61 matching lines @@
   // Test helpers.
   void SetTimeSourceForTesting(scoped_ptr<TimeSource> time_source);
   void SetWorkBatchSizeForTesting(size_t work_batch_size);
   TaskQueueManager* GetTaskQueueManagerForTesting();
 
  private:
   friend class SchedulerHelperTest;
 
   bool ShouldWaitForQuiescence();
   void EnableLongIdlePeriodAfterWakeup();
+  void PreShutdownInternal(base::WaitableEvent* completion);
 
   base::ThreadChecker thread_checker_;
   scoped_ptr<PrioritizingTaskQueueSelector> task_queue_selector_;
   scoped_ptr<TaskQueueManager> task_queue_manager_;
 
   CancelableClosureHolder end_idle_period_closure_;
   CancelableClosureHolder enable_next_long_idle_period_closure_;
   CancelableClosureHolder enable_next_long_idle_period_after_wakeup_closure_;
 
   IdlePeriodState idle_period_state_;
   SchedulerHelperDelegate* scheduler_helper_delegate_;  // NOT OWNED
 
   scoped_refptr<base::SingleThreadTaskRunner> control_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> control_task_after_wakeup_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> shutdown_task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
 
+  size_t total_task_queue_count_;
+
   // A bitmap which controls the set of queues that are checked for quiescence
   // before triggering a long idle period.
   uint64 quiescence_monitored_task_queue_mask_;
   base::TimeDelta required_quiescence_duration_before_long_idle_period_;
 
   base::TimeTicks idle_period_deadline_;
   scoped_ptr<TimeSource> time_source_;
 
   const char* tracing_category_;
   const char* disabled_by_default_tracing_category_;
   const char* idle_period_tracing_name_;
 
   base::WeakPtr<SchedulerHelper> weak_scheduler_ptr_;
   base::WeakPtrFactory<SchedulerHelper> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerHelper);
 };
 
 }  // namespace scheduler
 
 #endif  // COMPONENTS_SCHEDULER_CHILD_SCHEDULER_HELPER_H_