Make sure scheduler shutdown prevents idle tasks from running

third_party/WebKit/Source/platform/scheduler/child/idle_helper_unittest.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 "platform/scheduler/child/idle_helper.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
@@ skipping 125 matching lines @@
     scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner,
     std::unique_ptr<TestTimeSource> test_time_source) {
   if (message_loop)
     return SchedulerTqmDelegateImpl::Create(message_loop,
                                             std::move(test_time_source));
 
   return SchedulerTqmDelegateForTest::Create(mock_task_runner,
                                              std::move(test_time_source));
 }
 
+void ShutdownIdleTask(IdleHelper* helper,
+                      bool* shutdown_task_run,
+                      base::TimeTicks deadline) {
+  *shutdown_task_run = true;
+  helper->Shutdown();
+}
+
 };  // namespace
 
 class IdleHelperForTest : public IdleHelper, public IdleHelper::Delegate {
  public:
   explicit IdleHelperForTest(
       SchedulerHelper* scheduler_helper,
       base::TimeDelta required_quiescence_duration_before_long_idle_period)
       : IdleHelper(scheduler_helper,
                    this,
                    "test.idle",
@@ skipping 45 matching lines @@
 
   void SetUp() override {
     EXPECT_CALL(*idle_helper_, OnIdlePeriodStarted()).Times(AnyNumber());
     EXPECT_CALL(*idle_helper_, OnIdlePeriodEnded()).Times(AnyNumber());
     EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
         .Times(AnyNumber())
         .WillRepeatedly(Return(true));
   }
 
   void TearDown() override {
+    EXPECT_CALL(*idle_helper_, OnIdlePeriodEnded()).Times(AnyNumber());
+    idle_helper_->Shutdown();
     DCHECK(!mock_task_runner_.get() || !message_loop_.get());
     if (mock_task_runner_.get()) {
       // Check that all tests stop posting tasks.
       mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
       while (mock_task_runner_->RunUntilIdle()) {
       }
     } else {
       base::RunLoop().RunUntilIdle();
     }
   }
@@ skipping 551 matching lines @@
   idle_helper_->EndIdlePeriod();
   CheckIdlePeriodStateIs("not_in_idle_period");
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodWhenShutdown) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
-  scheduler_helper_->Shutdown();
+  idle_helper_->Shutdown();
 
   // We shouldn't be able to enter a long idle period when shutdown
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   CheckIdlePeriodStateIs("not_in_idle_period");
   EXPECT_EQ(0, run_count);
 }
 
 void TestCanExceedIdleDeadlineIfRequiredTask(IdleHelperForTest* idle_helper,
                                              bool* can_exceed_idle_deadline_out,
@@ skipping 243 matching lines @@
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
                                         more_than_min_deadline_duration);
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 }
 
+TEST_F(IdleHelperWithQuiescencePeriodTest,
+       PendingEnableLongIdlePeriodNotRunAfterShutdown) {
+  MakeNonQuiescent();
+
+  bool shutdown_task_run = false;
+  int run_count = 0;
+  base::TimeTicks deadline_in_task;
+  idle_task_runner_->PostIdleTask(
+      FROM_HERE,
+      base::Bind(&ShutdownIdleTask, base::Unretained(idle_helper_.get()),
+                 &shutdown_task_run));
+  idle_task_runner_->PostIdleTask(
+      FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
+
+  // Delayed call to IdleHelper::EnableLongIdlePeriod enables idle tasks.
+  idle_helper_->EnableLongIdlePeriod();
+  clock_->Advance(maximum_idle_period_duration() * 2.0);
+  mock_task_runner_->RunPendingTasks();
+  EXPECT_TRUE(shutdown_task_run);
+  EXPECT_EQ(0, run_count);
+
+  // Shutdown immediately after idle period started should prevent the idle
+  // task from running.
+  idle_helper_->Shutdown();
+  mock_task_runner_->RunUntilIdle();
+  EXPECT_EQ(0, run_count);
+}
+
 }  // namespace scheduler
 }  // namespace blink