Adds a SHUTDOWN_TASK_QUEUE and a PreShutdown api to the scheduler.

components/scheduler/child/scheduler_helper_unittest.cc

Index: components/scheduler/child/scheduler_helper_unittest.cc
diff --git a/components/scheduler/child/scheduler_helper_unittest.cc b/components/scheduler/child/scheduler_helper_unittest.cc
index 0418c0be3250d172d00ad2ab9234bf1f5312a79d..d983dd19616a3345b5a4db937ed35fe142f95763 100644
--- a/components/scheduler/child/scheduler_helper_unittest.cc
+++ b/components/scheduler/child/scheduler_helper_unittest.cc
@@ -130,7 +130,7 @@ class SchedulerHelperForTest : public SchedulerHelper,
                bool(base::TimeTicks now,
                     base::TimeDelta* next_long_idle_period_delay_out));
 
-  MOCK_METHOD0(IsNotQuiescent, void());
+  void IsNotQuiescent() override {}
 };
 
 class BaseSchedulerHelperTest : public testing::Test {
@@ -150,7 +150,9 @@ class BaseSchedulerHelperTest : public testing::Test {
             nestable_task_runner_,
             required_quiescence_duration_before_long_idle_period)),
         default_task_runner_(scheduler_helper_->DefaultTaskRunner()),
-        idle_task_runner_(scheduler_helper_->IdleTaskRunner()) {
+        idle_task_runner_(scheduler_helper_->IdleTaskRunner()),
+        control_task_runner_(scheduler_helper_->ControlTaskRunner()),
+        shutdown_task_runner_(scheduler_helper_->ShutdownTaskRunner()) {
     scheduler_helper_->SetTimeSourceForTesting(
         make_scoped_ptr(new TestTimeSource(clock_)));
     scheduler_helper_->GetTaskQueueManagerForTesting()->SetTimeSourceForTesting(
@@ -185,6 +187,8 @@ class BaseSchedulerHelperTest : public testing::Test {
   // task identifier specifies the task type:
   // - 'D': Default task
   // - 'I': Idle task
+  // - 'S': Shutdown task
+  // - 'T': conTrol task  (to avoid confusion with compositor tasks)
   void PostTestTasks(std::vector<std::string>* run_order,
                      const std::string& task_descriptor) {
     std::istringstream stream(task_descriptor);
@@ -201,6 +205,14 @@ class BaseSchedulerHelperTest : public testing::Test {
               FROM_HERE,
               base::Bind(&AppendToVectorIdleTestTask, run_order, task));
           break;
+        case 'S':
+          shutdown_task_runner_->PostTask(
+              FROM_HERE, base::Bind(&AppendToVectorTestTask, run_order, task));
+          break;
+        case 'T':
+          control_task_runner_->PostTask(
+              FROM_HERE, base::Bind(&AppendToVectorTestTask, run_order, task));
+          break;
         default:
           NOTREACHED();
       }
@@ -228,6 +240,8 @@ class BaseSchedulerHelperTest : public testing::Test {
   scoped_ptr<SchedulerHelperForTest> scheduler_helper_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> control_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> shutdown_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(BaseSchedulerHelperTest);
 };
@@ -912,4 +926,42 @@ TEST_F(SchedulerHelperWithQuiescencePeriodTest,
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
+TEST_F(SchedulerHelperTest, TestPreShutdown_BlocksAllButShutdownTasks) {
+  std::vector<std::string> run_order;
+  PostTestTasks(&run_order, "D1 I1 T1 S1");
+
+  scheduler_helper_->PreShutdown();
+
+  RunUntilIdle();
+  EXPECT_THAT(run_order, testing::ElementsAre(std::string("S1")));
+}
+
+TEST_F(SchedulerHelperTest, TestPreShutdown_BlocksFutureLongIdleTasks) {
+  int run_count = 0;
+
+  EXPECT_CALL(*scheduler_helper_, CanEnterLongIdlePeriod(_, _))
+      .Times(1)
+      .WillRepeatedly(Return(true));
+
+  max_idle_task_reposts = 3;
+  idle_task_runner_->PostIdleTask(
+      FROM_HERE,
+      base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
+
+  scheduler_helper_->EnableLongIdlePeriod();
+  RunUntilIdle();
+  EXPECT_EQ(1, run_count);  // Should only run once per idle period.
+
+  // Advance time to start of next long idle period and check task reposted task
+  // does not get run (it should be blocked by PreShutdown).
+  scheduler_helper_->PreShutdown();
+  clock_->AdvanceNow(maximum_idle_period_duration());
+  RunUntilIdle();
+  EXPECT_EQ(1, run_count);
+
+  // Must destroy all tasks posted to scheduler_helper_ before run_count goes
+  // out of scope.
+  scheduler_helper_.reset();
+}
+
 }  // namespace scheduler