[scheduler]: Avoid waking up the scheduler to end long idle periods.

components/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 "components/scheduler/child/idle_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 19 matching lines @@
 
 void AppendToVectorIdleTestTask(std::vector<std::string>* vector,
                                 std::string value,
                                 base::TimeTicks deadline) {
   AppendToVectorTestTask(vector, value);
 }
 
 void NullTask() {
 }
 
+void NullIdleTask(base::TimeTicks deadline) {
+}
+
 void AppendToVectorReentrantTask(base::SingleThreadTaskRunner* task_runner,
                                  std::vector<int>* vector,
                                  int* reentrant_count,
                                  int max_reentrant_count) {
   vector->push_back((*reentrant_count)++);
   if (*reentrant_count < max_reentrant_count) {
     task_runner->PostTask(
         FROM_HERE,
         base::Bind(AppendToVectorReentrantTask, base::Unretained(task_runner),
                    vector, reentrant_count, max_reentrant_count));
   }
 }
 
-void NullIdleTask(base::TimeTicks) {
-}
-
 void IdleTestTask(int* run_count,
                   base::TimeTicks* deadline_out,
                   base::TimeTicks deadline) {
   (*run_count)++;
   *deadline_out = deadline;
 }
 
 int max_idle_task_reposts = 2;
 
 void RepostingIdleTestTask(SingleThreadIdleTaskRunner* idle_task_runner,
                            int* run_count,
+                           base::TimeTicks* deadline_out,
                            base::TimeTicks deadline) {
   if ((*run_count + 1) < max_idle_task_reposts) {
     idle_task_runner->PostIdleTask(
-        FROM_HERE, base::Bind(&RepostingIdleTestTask,
-                              base::Unretained(idle_task_runner), run_count));
+        FROM_HERE,
+        base::Bind(&RepostingIdleTestTask, base::Unretained(idle_task_runner),
+                   run_count, deadline_out));
   }
+  *deadline_out = deadline;
   (*run_count)++;
 }
 
+void RepostingUpdateClockIdleTestTask(
+    SingleThreadIdleTaskRunner* idle_task_runner,
+    int* run_count,
+    scoped_refptr<cc::TestNowSource> clock,
+    base::TimeDelta advance_time,
+    std::vector<base::TimeTicks>* deadlines,
+    base::TimeTicks deadline) {
+  if ((*run_count + 1) < max_idle_task_reposts) {
+    idle_task_runner->PostIdleTask(
+        FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
+                              base::Unretained(idle_task_runner), run_count,
+                              clock, advance_time, deadlines));
+  }
+  deadlines->push_back(deadline);
+  (*run_count)++;
+  clock->AdvanceNow(advance_time);
+}
+
 void RepeatingTask(base::SingleThreadTaskRunner* task_runner,
                    int num_repeats,
                    base::TimeDelta delay) {
   if (num_repeats > 1) {
     task_runner->PostDelayedTask(
         FROM_HERE, base::Bind(&RepeatingTask, base::Unretained(task_runner),
                               num_repeats - 1, delay),
         delay);
   }
 }
 
-void UpdateClockToDeadlineIdleTestTask(
-    scoped_refptr<cc::TestNowSource> clock,
-    base::SingleThreadTaskRunner* task_runner,
-    int* run_count,
-    base::TimeTicks deadline) {
-  clock->SetNow(deadline);
-  // Due to the way in which OrderedSimpleTestRunner orders tasks and the fact
-  // that we updated the time within a task, the delayed pending task to call
-  // EndIdlePeriod will not happen until after a TaskQueueManager DoWork, so
-  // post a normal task here to ensure it runs before the next idle task.
-  task_runner->PostTask(FROM_HERE, base::Bind(NullTask));
+void UpdateClockIdleTestTask(scoped_refptr<cc::TestNowSource> clock,
+                             int* run_count,
+                             base::TimeTicks set_time,
+                             base::TimeTicks deadline) {
+  clock->SetNow(set_time);
   (*run_count)++;
 }
 
+void UpdateClockToDeadlineIdleTestTask(scoped_refptr<cc::TestNowSource> clock,
+                                       int* run_count,
+                                       base::TimeTicks deadline) {
+  UpdateClockIdleTestTask(clock, run_count, deadline, deadline);
+}
+
+void EndIdlePeriodIdleTask(IdleHelper* idle_helper, base::TimeTicks deadline) {
+  idle_helper->EndIdlePeriod();
+}
+
 scoped_refptr<NestableSingleThreadTaskRunner>
 CreateNestableSingleThreadTaskRunner(
     base::MessageLoop* message_loop,
     scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner) {
   if (message_loop)
     return SchedulerMessageLoopDelegate::Create(message_loop);
 
   return NestableTaskRunnerForTest::Create(mock_task_runner);
 }
 
@@ skipping 90 matching lines @@
         IdleHelper::IdlePeriodState::IDLE_PERIOD_STATE_COUNT,
         &IdleHelper::IdlePeriodStateToString);
   }
 
  protected:
   static base::TimeDelta maximum_idle_period_duration() {
     return base::TimeDelta::FromMilliseconds(
         IdleHelper::kMaximumIdlePeriodMillis);
   }
 
-  base::TimeTicks CurrentIdleTaskDeadlineForTesting() {
-    base::TimeTicks deadline;
-    idle_helper_->CurrentIdleTaskDeadlineCallback(&deadline);
-    return deadline;
+  static base::TimeDelta retry_enable_long_idle_period_delay() {
+    return base::TimeDelta::FromMilliseconds(
+        IdleHelper::kRetryEnableLongIdlePeriodDelayMillis);
+  }
+
+  base::TimeTicks CurrentIdleTaskDeadline() {
+    return idle_helper_->CurrentIdleTaskDeadline();
+  }
+
+  void CheckIdlePeriodStateIs(const char* expected) {
+    IdleHelper::IdlePeriodState actual =
+        idle_helper_->state_.idle_period_state();
+    EXPECT_STREQ(expected, IdleHelper::IdlePeriodStateToString(actual));
   }
 
   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<SchedulerHelper> scheduler_helper_;
   scoped_ptr<IdleHelperForTest> idle_helper_;
@@ skipping 25 matching lines @@
 
   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(100));
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      expected_deadline, true);
+      expected_deadline);
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(IdleHelperTest, TestPostIdleTask_EndIdlePeriod) {
   int run_count = 0;
   base::TimeTicks deadline_in_task;
 
   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(100));
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
   idle_helper_->EndIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 }
 
 TEST_F(IdleHelperTest, TestRepostingIdleTask) {
+  base::TimeTicks actual_deadline;
   int run_count = 0;
 
   max_idle_task_reposts = 2;
   idle_task_runner_->PostIdleTask(
-      FROM_HERE,
-      base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
+      FROM_HERE, base::Bind(&RepostingIdleTestTask, idle_task_runner_,
+                            &run_count, &actual_deadline));
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 
   // Reposted tasks shouldn't run until next idle period.
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
 }
 
 TEST_F(IdleHelperTest, TestIdleTaskExceedsDeadline) {
   int run_count = 0;
 
   // Post two UpdateClockToDeadlineIdleTestTask tasks.
   idle_task_runner_->PostIdleTask(
-      FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_,
-                            default_task_runner_, &run_count));
+      FROM_HERE,
+      base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_, &run_count));
   idle_task_runner_->PostIdleTask(
-      FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_,
-                            default_task_runner_, &run_count));
+      FROM_HERE,
+      base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_, &run_count));
 
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Only the first idle task should execute since it's used up the deadline.
   EXPECT_EQ(1, run_count);
 
   idle_helper_->EndIdlePeriod();
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Second task should be run on the next idle period.
   EXPECT_EQ(2, run_count);
 }
 
 TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeup) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTaskAfterWakeup(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Shouldn't run yet as no other task woke up the scheduler.
   EXPECT_EQ(0, run_count);
 
   idle_task_runner_->PostIdleTaskAfterWakeup(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Another after wakeup idle task shouldn't wake the scheduler.
   EXPECT_EQ(0, run_count);
 
   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
 
   RunUntilIdle();
   // Must start a new idle period before idle task runs.
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Execution of default task queue task should trigger execution of idle task.
   EXPECT_EQ(2, run_count);
 }
 
 TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeupWhileAwake) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTaskAfterWakeup(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
 
   RunUntilIdle();
   // Must start a new idle period before idle task runs.
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Should run as the scheduler was already awakened by the normal task.
   EXPECT_EQ(1, run_count);
 }
 
 TEST_F(IdleHelperTest, TestPostIdleTaskWakesAfterWakeupIdleTask) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTaskAfterWakeup(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Must start a new idle period before after-wakeup idle task runs.
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Normal idle task should wake up after-wakeup idle task.
   EXPECT_EQ(2, run_count);
 }
 
-TEST_F(IdleHelperTest, TestDelayedEndIdlePeriod) {
-  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
-
-  EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
-      .Times(2)
-      .WillRepeatedly(Return(true));
-
-  // We need an idle task posted or EnableLongIdlePeriod will use the
-  // control_task_after_wakeup_runner_ instead of the control_task_runner_.
-  idle_task_runner_->PostIdleTask(FROM_HERE, base::Bind(&NullIdleTask));
-  idle_helper_->EnableLongIdlePeriod();
-
-  // Check there is a pending delayed task.
-  EXPECT_GT(task_queue_manager()->NextPendingDelayedTaskRunTime(),
-            base::TimeTicks());
-
-  RunUntilIdle();
-
-  // If the delayed task ran, it will an EnableLongIdlePeriod on the control
-  // task after wake up queue.
-  EXPECT_FALSE(task_queue_manager()->IsQueueEmpty(
-      SchedulerHelper::CONTROL_TASK_AFTER_WAKEUP_QUEUE));
-}
-
-TEST_F(IdleHelperTest, TestDelayedEndIdlePeriodCanceled) {
-  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
-
-  EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
-      .Times(1)
-      .WillRepeatedly(Return(true));
-
-  // We need an idle task posted or EnableLongIdlePeriod will use the
-  // control_task_after_wakeup_runner_ instead of the control_task_runner_.
-  idle_task_runner_->PostIdleTask(FROM_HERE, base::Bind(&NullIdleTask));
-  idle_helper_->EnableLongIdlePeriod();
-
-  // Check there is a pending delayed task.
-  EXPECT_GT(task_queue_manager()->NextPendingDelayedTaskRunTime(),
-            base::TimeTicks());
-
-  idle_helper_->EndIdlePeriod();
-  RunUntilIdle();
-
-  // If the delayed task didn't run, there will be nothing on the control task
-  // after wake up queue.
-  EXPECT_TRUE(scheduler_helper_->IsQueueEmpty(
-      SchedulerHelper::CONTROL_TASK_AFTER_WAKEUP_QUEUE));
-}
-
 class IdleHelperWithMessageLoopTest : public BaseIdleHelperTest {
  public:
   IdleHelperWithMessageLoopTest()
       : BaseIdleHelperTest(new base::MessageLoop(), base::TimeDelta()) {}
   ~IdleHelperWithMessageLoopTest() override {}
 
   void PostFromNestedRunloop(std::vector<
       std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>>* tasks) {
     base::MessageLoop::ScopedNestableTaskAllower allow(message_loop_.get());
     for (std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>& pair : *tasks) {
       if (pair.second) {
         idle_task_runner_->PostIdleTask(FROM_HERE, pair.first);
       } else {
         idle_task_runner_->PostNonNestableIdleTask(FROM_HERE, pair.first);
       }
     }
     idle_helper_->StartIdlePeriod(
         IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-        clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+        clock_->Now() + base::TimeDelta::FromMilliseconds(10));
     message_loop_->RunUntilIdle();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IdleHelperWithMessageLoopTest);
 };
 
 TEST_F(IdleHelperWithMessageLoopTest,
        NonNestableIdleTaskDoesntExecuteInNestedLoop) {
   std::vector<std::string> order;
@@ skipping 15 matching lines @@
       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("5")), true));
 
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IdleHelperWithMessageLoopTest::PostFromNestedRunloop,
                  base::Unretained(this),
                  base::Unretained(&tasks_to_post_from_nested_loop)));
 
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Note we expect task 3 to run last because it's non-nestable.
   EXPECT_THAT(order, testing::ElementsAre(std::string("1"), std::string("2"),
                                           std::string("4"), std::string("5"),
                                           std::string("3")));
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriod) {
   base::TimeTicks expected_deadline =
       clock_->Now() + maximum_idle_period_duration();
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
-      .Times(2)
+      .Times(1)
       .WillRepeatedly(Return(true));
 
   RunUntilIdle();
   EXPECT_EQ(0, run_count);  // Shouldn't run yet as no idle period.
 
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);  // Should have run in a long idle time.
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodWithPendingDelayedTask) {
   base::TimeDelta pending_task_delay = base::TimeDelta::FromMilliseconds(30);
   base::TimeTicks expected_deadline = clock_->Now() + pending_task_delay;
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
-      .Times(2)
+      .Times(1)
       .WillRepeatedly(Return(true));
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
                                         pending_task_delay);
 
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);  // Should have run in a long idle time.
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodWithLatePendingDelayedTask) {
   base::TimeDelta pending_task_delay = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
-      .Times(3)
+      .Times(2)
       .WillRepeatedly(Return(true));
 
   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
                                         pending_task_delay);
 
   // Advance clock until after delayed task was meant to be run.
   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(20));
 
   // Post an idle task and then EnableLongIdlePeriod. Since there is a late
   // pending delayed task this shouldn't actually start an idle period.
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   // After the delayed task has been run we should trigger an idle period.
   clock_->AdvanceNow(maximum_idle_period_duration());
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodRepeating) {
+  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+  std::vector<base::TimeTicks> actual_deadlines;
   int run_count = 0;
 
   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
-      .Times(2)
+      .Times(4)
       .WillRepeatedly(Return(true));
 
   max_idle_task_reposts = 3;
+  base::TimeTicks clock_before(clock_->Now());
+  base::TimeDelta idle_task_runtime(base::TimeDelta::FromMilliseconds(10));
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
-      base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
+      base::Bind(&RepostingUpdateClockIdleTestTask, idle_task_runner_,
+                 &run_count, clock_, idle_task_runtime, &actual_deadlines));
 
+  // Check each idle task runs in their own idle period.
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
-  EXPECT_EQ(1, run_count);  // Should only run once per idle period.
+  EXPECT_EQ(3, run_count);
+  EXPECT_THAT(
+      actual_deadlines,
+      testing::ElementsAre(
+          clock_before + maximum_idle_period_duration(),
+          clock_before + idle_task_runtime + maximum_idle_period_duration(),
+          clock_before + (2 * idle_task_runtime) +
+              maximum_idle_period_duration()));
 
-  // Advance time to start of next long idle period and check task reposted task
-  // gets run.
-  clock_->AdvanceNow(maximum_idle_period_duration());
+  max_idle_task_reposts = 5;
+  idle_task_runner_->PostIdleTask(
+      FROM_HERE,
+      base::Bind(&RepostingUpdateClockIdleTestTask, idle_task_runner_,
+                 &run_count, clock_, idle_task_runtime, &actual_deadlines));
+  idle_task_runner_->PostIdleTask(
+      FROM_HERE,
+      base::Bind(&EndIdlePeriodIdleTask, base::Unretained(idle_helper_.get())));
+
+  // Ensure that reposting tasks stop after EndIdlePeriod is called.
   RunUntilIdle();
-  EXPECT_EQ(2, run_count);
-
-  // Advance time to start of next long idle period then end the idle period and
-  // check the task doesn't get run.
-  clock_->AdvanceNow(maximum_idle_period_duration());
-  idle_helper_->EndIdlePeriod();
-  RunUntilIdle();
-  EXPECT_EQ(2, run_count);
+  EXPECT_EQ(4, run_count);
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodDoesNotWakeScheduler) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
-      .Times(3)
+      .Times(2)
       .WillRepeatedly(Return(true));
 
   // Start a long idle period and get the time it should end.
   idle_helper_->EnableLongIdlePeriod();
-  // The scheduler should not run the initiate_next_long_idle_period task if
+  // The scheduler should not run the enable_next_long_idle_period task if
   // there are no idle tasks and no other task woke up the scheduler, thus
   // the idle period deadline shouldn't update at the end of the current long
   // idle period.
-  base::TimeTicks idle_period_deadline = CurrentIdleTaskDeadlineForTesting();
+  base::TimeTicks idle_period_deadline = CurrentIdleTaskDeadline();
   clock_->AdvanceNow(maximum_idle_period_duration());
   RunUntilIdle();
 
-  base::TimeTicks new_idle_period_deadline =
-      CurrentIdleTaskDeadlineForTesting();
+  base::TimeTicks new_idle_period_deadline = CurrentIdleTaskDeadline();
   EXPECT_EQ(idle_period_deadline, new_idle_period_deadline);
 
   // Posting a after-wakeup idle task also shouldn't wake the scheduler or
   // initiate the next long idle period.
   idle_task_runner_->PostIdleTaskAfterWakeup(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   RunUntilIdle();
-  new_idle_period_deadline = CurrentIdleTaskDeadlineForTesting();
+  new_idle_period_deadline = CurrentIdleTaskDeadline();
   EXPECT_EQ(idle_period_deadline, new_idle_period_deadline);
   EXPECT_EQ(0, run_count);
 
   // Running a normal task should initiate a new long idle period though.
   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
   RunUntilIdle();
-  new_idle_period_deadline = CurrentIdleTaskDeadlineForTesting();
+  new_idle_period_deadline = CurrentIdleTaskDeadline();
   EXPECT_EQ(idle_period_deadline + maximum_idle_period_duration(),
             new_idle_period_deadline);
 
   EXPECT_EQ(1, run_count);
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodWhenNotCanEnterLongIdlePeriod) {
   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta halfDelay = base::TimeDelta::FromMilliseconds(500);
   base::TimeTicks delayOver = clock_->Now() + delay;
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   ON_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
       .WillByDefault(Invoke(
           [delay, delayOver](base::TimeTicks now,
                              base::TimeDelta* next_long_idle_period_delay_out) {
             if (now >= delayOver)
               return true;
             *next_long_idle_period_delay_out = delay;
             return false;
           }));
 
-  EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)).Times(3);
+  EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)).Times(2);
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
-  // Make sure Idle tasks don't run until the delay has occured.
+  // Make sure Idle tasks don't run until the delay has occurred.
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   clock_->AdvanceNow(halfDelay);
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   // Delay is finished, idle task should run.
   clock_->AdvanceNow(halfDelay);
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 }
 
+TEST_F(IdleHelperTest, TestLongIdlePeriodImmediatelyRestartsIfMaxDeadline) {
+  base::TimeTicks actual_deadline;
+  int run_count = 0;
+
+  EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
+      .Times(2)
+      .WillRepeatedly(Return(true));
+
+  base::TimeDelta idle_task_duration(base::TimeDelta::FromMilliseconds(10));
+  base::TimeTicks expected_deadline_1(clock_->Now() +
+                                      maximum_idle_period_duration());
+  base::TimeTicks expected_deadline_2(clock_->Now() + idle_task_duration +
+                                      maximum_idle_period_duration());
+
+  // The second idle period should happen immediately after the first the
+  // they have max deadlines.
+  max_idle_task_reposts = 2;
+  idle_task_runner_->PostIdleTask(
+      FROM_HERE, base::Bind(&RepostingIdleTestTask, idle_task_runner_,
+                            &run_count, &actual_deadline));
+  idle_task_runner_->PostIdleTask(
+      FROM_HERE, base::Bind(UpdateClockIdleTestTask, clock_, &run_count,
+                            clock_->Now() + idle_task_duration));
+
+  idle_helper_->EnableLongIdlePeriod();
+  RunUntilIdle();
+  EXPECT_EQ(2, run_count);
+  EXPECT_EQ(expected_deadline_1, actual_deadline);
+
+  RunUntilIdle();
+  EXPECT_EQ(3, run_count);
+  EXPECT_EQ(expected_deadline_2, actual_deadline);
+}
+
+TEST_F(IdleHelperTest, TestLongIdlePeriodRestartWaitsIfNotMaxDeadline) {
+  base::TimeTicks actual_deadline;
+  int run_count = 0;
+
+  EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
+      .Times(3)
+      .WillRepeatedly(Return(true));
+
+  base::TimeDelta pending_task_delay(base::TimeDelta::FromMilliseconds(20));
+  base::TimeDelta idle_task_duration(base::TimeDelta::FromMilliseconds(10));
+  base::TimeTicks expected_deadline(clock_->Now() + pending_task_delay +
+                                    maximum_idle_period_duration() +
+                                    retry_enable_long_idle_period_delay());
+
+  // Post delayed task to ensure idle period doesn't have a max deadline.
+  default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
+                                        pending_task_delay);
+
+  max_idle_task_reposts = 2;
+  idle_task_runner_->PostIdleTask(
+      FROM_HERE, base::Bind(&RepostingIdleTestTask, idle_task_runner_,
+                            &run_count, &actual_deadline));
+  idle_helper_->EnableLongIdlePeriod();
+  RunUntilIdle();
+  EXPECT_EQ(1, run_count);
+  clock_->AdvanceNow(idle_task_duration);
+
+  // Next idle period shouldn't happen until the pending task has been run.
+  RunUntilIdle();
+  EXPECT_EQ(1, run_count);
+
+  // Once the pending task is run the new idle period should start.
+  clock_->AdvanceNow(pending_task_delay - idle_task_duration);
+  RunUntilIdle();
+  // Since the idle period tried to start before the pending task ran we have to
+  // wait for the idle helper to retry starting the long idle period.
+  clock_->AdvanceNow(retry_enable_long_idle_period_delay());
+  RunUntilIdle();
+
+  EXPECT_EQ(2, run_count);
+  EXPECT_EQ(expected_deadline, actual_deadline);
+}
+
+TEST_F(IdleHelperTest, TestLongIdlePeriodPaused) {
+  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+  std::vector<base::TimeTicks> actual_deadlines;
+  int run_count = 0;
+  EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
+      .Times(3)
+      .WillRepeatedly(Return(true));
+
+  // If there are no idle tasks posted we should start in the paused state.
+  idle_helper_->EnableLongIdlePeriod();
+  CheckIdlePeriodStateIs("in_long_idle_period_paused");
+  // There shouldn't be any delayed tasks posted by the idle helper when paused.
+  EXPECT_EQ(base::TimeTicks(),
+            scheduler_helper_->NextPendingDelayedTaskRunTime());
+
+  // Posting a task should transition us to the an active state.
+  max_idle_task_reposts = 2;
+  base::TimeTicks clock_before(clock_->Now());
+  base::TimeDelta idle_task_runtime(base::TimeDelta::FromMilliseconds(10));
+  idle_task_runner_->PostIdleTask(
+      FROM_HERE,
+      base::Bind(&RepostingUpdateClockIdleTestTask, idle_task_runner_,
+                 &run_count, clock_, idle_task_runtime, &actual_deadlines));
+  RunUntilIdle();
+  EXPECT_EQ(2, run_count);
+  EXPECT_THAT(
+      actual_deadlines,
+      testing::ElementsAre(
+          clock_before + maximum_idle_period_duration(),
+          clock_before + idle_task_runtime + maximum_idle_period_duration()));
+
+  // Once all task have been run we should go back to the paused state.
+  CheckIdlePeriodStateIs("in_long_idle_period_paused");
+  EXPECT_EQ(base::TimeTicks(),
+            scheduler_helper_->NextPendingDelayedTaskRunTime());
+
+  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();
+
+  // 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,
                                              int* run_count,
                                              base::TimeTicks deadline) {
   *can_exceed_idle_deadline_out =
       idle_helper->CanExceedIdleDeadlineIfRequired();
   (*run_count)++;
 }
 
 TEST_F(IdleHelperTest, CanExceedIdleDeadlineIfRequired) {
   int run_count = 0;
   bool can_exceed_idle_deadline = false;
 
   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
-      .Times(3)
+      .Times(2)
       .WillRepeatedly(Return(true));
 
   // Should return false if not in an idle period.
   EXPECT_FALSE(idle_helper_->CanExceedIdleDeadlineIfRequired());
 
   // Should return false for short idle periods.
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(),
                  &can_exceed_idle_deadline, &run_count));
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
   EXPECT_FALSE(can_exceed_idle_deadline);
 
   // Should return false for a long idle period which is shortened due to a
   // pending delayed task.
   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
                                         base::TimeDelta::FromMilliseconds(10));
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
@@ skipping 36 matching lines @@
     RunUntilIdle();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IdleHelperWithQuiescencePeriodTest);
 };
 
 TEST_F(IdleHelperWithQuiescencePeriodTest,
        LongIdlePeriodStartsImmediatelyIfQuiescent) {
   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
-      .Times(2)
+      .Times(1)
       .WillRepeatedly(Return(true));
 
+  base::TimeTicks actual_deadline;
   int run_count = 0;
   max_idle_task_reposts = 1;
   idle_task_runner_->PostIdleTask(
-      FROM_HERE,
-      base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
+      FROM_HERE, base::Bind(&RepostingIdleTestTask, idle_task_runner_,
+                            &run_count, &actual_deadline));
 
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
 
   EXPECT_EQ(1, run_count);
 }
 
 TEST_F(IdleHelperWithQuiescencePeriodTest,
        LongIdlePeriodDoesNotStartsImmediatelyIfBusy) {
   MakeNonQuiescent();
   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)).Times(0);
 
+  base::TimeTicks actual_deadline;
   int run_count = 0;
   max_idle_task_reposts = 1;
   idle_task_runner_->PostIdleTask(
-      FROM_HERE,
-      base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
+      FROM_HERE, base::Bind(&RepostingIdleTestTask, idle_task_runner_,
+                            &run_count, &actual_deadline));
 
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
 
   EXPECT_EQ(0, run_count);
 
   scheduler_helper_->Shutdown();
 }
 
 TEST_F(IdleHelperWithQuiescencePeriodTest,
@@ skipping 30 matching lines @@
        QuescienceCheckedForAfterLongIdlePeriodEnds) {
   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
       .Times(AnyNumber())
       .WillRepeatedly(Return(true));
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   idle_task_runner_->PostIdleTask(FROM_HERE, base::Bind(&NullIdleTask));
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
 
+  // Post a normal task to make the scheduler non-quiescent.
+  default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
+  RunUntilIdle();
+
+  // Post an idle task. The idle task won't run initially because the system is
+  // not judged to be quiescent, but should be run after the quiescence delay.
   int run_count = 0;
   base::TimeTicks deadline_in_task;
-  // Post an idle task, it won't run initially because the
-  // EnableLongIdlePeriod task was posted on an after wakeup runner.
-  idle_task_runner_->PostIdleTask(
-      FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
-  RunUntilIdle();
-  EXPECT_EQ(0, run_count);
-
-  // Post a normal task to wake the system up.  The idle task won't run
-  // immediately because the system isn't judged to be quiescent until the
-  // second time EnableLongIdlePeriod is run.
   base::TimeTicks expected_deadline =
       clock_->Now() +
       base::TimeDelta::FromMilliseconds(kQuiescenceDelayMs + kLongIdlePeriodMs);
-  default_task_runner_->PostTask(FROM_HERE, base::Bind(NullTask));
+  idle_task_runner_->PostIdleTask(
+      FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
+  idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
 
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 }  // namespace scheduler