Adds a SHUTDOWN_TASK_QUEUE and a PreShutdown api to the scheduler.

components/scheduler/child/scheduler_helper_unittest.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/scheduler_helper.h"
 
 #include "base/callback.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "cc/test/test_now_source.h"
 #include "components/scheduler/child/nestable_task_runner_for_test.h"
@@ skipping 112 matching lines @@
                         TASK_QUEUE_COUNT,
                         required_quiescence_duration_before_long_idle_period) {}
 
   ~SchedulerHelperForTest() override {}
 
   // SchedulerHelperDelegate implementation:
   MOCK_METHOD2(CanEnterLongIdlePeriod,
                bool(base::TimeTicks now,
                     base::TimeDelta* next_long_idle_period_delay_out));
 
-  MOCK_METHOD0(IsNotQuiescent, void());
+  void IsNotQuiescent() override {}
 };
 
 class BaseSchedulerHelperTest : public testing::Test {
  public:
   BaseSchedulerHelperTest(
       base::MessageLoop* message_loop,
       base::TimeDelta required_quiescence_duration_before_long_idle_period)
       : clock_(cc::TestNowSource::Create(5000)),
         mock_task_runner_(message_loop
                               ? nullptr
                               : new cc::OrderedSimpleTaskRunner(clock_, false)),
         message_loop_(message_loop),
         nestable_task_runner_(
             CreateNestableSingleThreadTaskRunner(message_loop,
                                                  mock_task_runner_)),
         scheduler_helper_(new SchedulerHelperForTest(
             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(
         make_scoped_ptr(new TestTimeSource(clock_)));
   }
 
   ~BaseSchedulerHelperTest() override {}
 
   void TearDown() override {
     DCHECK(!mock_task_runner_.get() || !message_loop_.get());
@@ skipping 14 matching lines @@
       mock_task_runner_->RunUntilIdle();
     else
       message_loop_->RunUntilIdle();
   }
 
   // Helper for posting several tasks of specific types. |task_descriptor| is a
   // string with space delimited task identifiers. The first letter of each
   // 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);
     while (!stream.eof()) {
       std::string task;
       stream >> task;
       switch (task[0]) {
         case 'D':
           default_task_runner_->PostTask(
               FROM_HERE, base::Bind(&AppendToVectorTestTask, run_order, task));
           break;
         case 'I':
           idle_task_runner_->PostIdleTask(
               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();
       }
     }
   }
 
  protected:
   static base::TimeDelta maximum_idle_period_duration() {
     return base::TimeDelta::FromMilliseconds(
         SchedulerHelper::kMaximumIdlePeriodMillis);
   }
 
   base::TimeTicks CurrentIdleTaskDeadlineForTesting() {
     base::TimeTicks deadline;
     scheduler_helper_->CurrentIdleTaskDeadlineCallback(&deadline);
     return deadline;
   }
 
   scoped_refptr<cc::TestNowSource> clock_;
   // Only one of mock_task_runner_ or message_loop_ will be set.
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
   scoped_ptr<base::MessageLoop> message_loop_;
 
   scoped_refptr<NestableSingleThreadTaskRunner> nestable_task_runner_;
   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);
 };
 
 class SchedulerHelperTest : public BaseSchedulerHelperTest {
  public:
   SchedulerHelperTest() : BaseSchedulerHelperTest(nullptr, base::TimeDelta()) {}
 
   ~SchedulerHelperTest() override {}
 
@@ skipping 664 matching lines @@
   base::TimeTicks expected_deadline =
       clock_->Now() +
       base::TimeDelta::FromMilliseconds(kQuiescenceDelayMs + kLongIdlePeriodMs);
   default_task_runner_->PostTask(FROM_HERE, base::Bind(NullTask));
   RunUntilIdle();
 
   EXPECT_EQ(1, run_count);
   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