components/scheduler/child/idle_helper_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/scheduler/child/idle_helper.h"
   6
   7 #include "base/callback.h"
   8 #include "base/test/simple_test_tick_clock.h"
   9 #include "cc/test/ordered_simple_task_runner.h"
  10 #include "components/scheduler/child/nestable_task_runner_for_test.h"
  11 #include "components/scheduler/child/scheduler_helper.h"
  12 #include "components/scheduler/child/scheduler_message_loop_delegate.h"
  13 #include "components/scheduler/child/task_queue_manager.h"
  14 #include "components/scheduler/child/test_time_source.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 using testing::_;
  19 using testing::AnyNumber;
  20 using testing::AtLeast;
  21 using testing::Exactly;
  22 using testing::Invoke;
  23 using testing::Return;
  24
  25 namespace scheduler {
  26
  27 namespace {
  28 void AppendToVectorTestTask(std::vector<std::string>* vector,
  29                             std::string value) {
  30   vector->push_back(value);
  31 }
  32
  33 void AppendToVectorIdleTestTask(std::vector<std::string>* vector,
  34                                 std::string value,
  35                                 base::TimeTicks deadline) {
  36   AppendToVectorTestTask(vector, value);
  37 }
  38
  39 void NullTask() {
  40 }
  41
  42 void NullIdleTask(base::TimeTicks deadline) {
  43 }
  44
  45 void AppendToVectorReentrantTask(base::SingleThreadTaskRunner* task_runner,
  46                                  std::vector<int>* vector,
  47                                  int* reentrant_count,
  48                                  int max_reentrant_count) {
  49   vector->push_back((*reentrant_count)++);
  50   if (*reentrant_count < max_reentrant_count) {
  51     task_runner->PostTask(
  52         FROM_HERE,
  53         base::Bind(AppendToVectorReentrantTask, base::Unretained(task_runner),
  54                    vector, reentrant_count, max_reentrant_count));
  55   }
  56 }
  57
  58 void IdleTestTask(int* run_count,
  59                   base::TimeTicks* deadline_out,
  60                   base::TimeTicks deadline) {
  61   (*run_count)++;
  62   *deadline_out = deadline;
  63 }
  64
  65 int max_idle_task_reposts = 2;
  66
  67 void RepostingIdleTestTask(SingleThreadIdleTaskRunner* idle_task_runner,
  68                            int* run_count,
  69                            base::TimeTicks* deadline_out,
  70                            base::TimeTicks deadline) {
  71   if ((*run_count + 1) < max_idle_task_reposts) {
  72     idle_task_runner->PostIdleTask(
  73         FROM_HERE,
  74         base::Bind(&RepostingIdleTestTask, base::Unretained(idle_task_runner),
  75                    run_count, deadline_out));
  76   }
  77   *deadline_out = deadline;
  78   (*run_count)++;
  79 }
  80
  81 void RepostingUpdateClockIdleTestTask(
  82     SingleThreadIdleTaskRunner* idle_task_runner,
  83     int* run_count,
  84     base::SimpleTestTickClock* clock,
  85     base::TimeDelta advance_time,
  86     std::vector<base::TimeTicks>* deadlines,
  87     base::TimeTicks deadline) {
  88   if ((*run_count + 1) < max_idle_task_reposts) {
  89     idle_task_runner->PostIdleTask(
  90         FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
  91                               base::Unretained(idle_task_runner), run_count,
  92                               clock, advance_time, deadlines));
  93   }
  94   deadlines->push_back(deadline);
  95   (*run_count)++;
  96   clock->Advance(advance_time);
  97 }
  98
  99 void RepeatingTask(base::SingleThreadTaskRunner* task_runner,
 100                    int num_repeats,
 101                    base::TimeDelta delay) {
 102   if (num_repeats > 1) {
 103     task_runner->PostDelayedTask(
 104         FROM_HERE, base::Bind(&RepeatingTask, base::Unretained(task_runner),
 105                               num_repeats - 1, delay),
 106         delay);
 107   }
 108 }
 109
 110 void UpdateClockIdleTestTask(base::SimpleTestTickClock* clock,
 111                              int* run_count,
 112                              base::TimeTicks set_time,
 113                              base::TimeTicks deadline) {
 114   clock->Advance(set_time - clock->NowTicks());
 115   (*run_count)++;
 116 }
 117
 118 void UpdateClockToDeadlineIdleTestTask(base::SimpleTestTickClock* clock,
 119                                        int* run_count,
 120                                        base::TimeTicks deadline) {
 121   UpdateClockIdleTestTask(clock, run_count, deadline, deadline);
 122 }
 123
 124 void EndIdlePeriodIdleTask(IdleHelper* idle_helper, base::TimeTicks deadline) {
 125   idle_helper->EndIdlePeriod();
 126 }
 127
 128 scoped_refptr<NestableSingleThreadTaskRunner>
 129 CreateNestableSingleThreadTaskRunner(
 130     base::MessageLoop* message_loop,
 131     scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner) {
 132   if (message_loop)
 133     return SchedulerMessageLoopDelegate::Create(message_loop);
 134
 135   return NestableTaskRunnerForTest::Create(mock_task_runner);
 136 }
 137
 138 };  // namespace
 139
 140 class IdleHelperForTest : public IdleHelper, public IdleHelper::Delegate {
 141  public:
 142   explicit IdleHelperForTest(
 143       SchedulerHelper* scheduler_helper,
 144       base::TimeDelta required_quiescence_duration_before_long_idle_period)
 145       : IdleHelper(scheduler_helper,
 146                    this,
 147                    SchedulerHelper::TASK_QUEUE_COUNT,
 148                    "test.idle",
 149                    TRACE_DISABLED_BY_DEFAULT("test.idle"),
 150                    "TestSchedulerIdlePeriod",
 151                    required_quiescence_duration_before_long_idle_period) {}
 152
 153   ~IdleHelperForTest() override {}
 154
 155   // SchedulerHelperDelegate implementation:
 156   MOCK_METHOD2(CanEnterLongIdlePeriod,
 157                bool(base::TimeTicks now,
 158                     base::TimeDelta* next_long_idle_period_delay_out));
 159
 160   MOCK_METHOD0(IsNotQuiescent, void());
 161   MOCK_METHOD0(OnIdlePeriodStarted, void());
 162   MOCK_METHOD0(OnIdlePeriodEnded, void());
 163 };
 164
 165 class BaseIdleHelperTest : public testing::Test {
 166  public:
 167   BaseIdleHelperTest(
 168       base::MessageLoop* message_loop,
 169       base::TimeDelta required_quiescence_duration_before_long_idle_period)
 170       : clock_(new base::SimpleTestTickClock()),
 171         mock_task_runner_(
 172             message_loop
 173                 ? nullptr
 174                 : new cc::OrderedSimpleTaskRunner(clock_.get(), false)),
 175         message_loop_(message_loop),
 176         nestable_task_runner_(
 177             CreateNestableSingleThreadTaskRunner(message_loop,
 178                                                  mock_task_runner_)),
 179         scheduler_helper_(
 180             new SchedulerHelper(nestable_task_runner_,
 181                                 "test.idle",
 182                                 TRACE_DISABLED_BY_DEFAULT("test.idle"),
 183                                 TRACE_DISABLED_BY_DEFAULT("test.idle.debug"),
 184                                 SchedulerHelper::TASK_QUEUE_COUNT + 1)),
 185         idle_helper_(new IdleHelperForTest(
 186             scheduler_helper_.get(),
 187             required_quiescence_duration_before_long_idle_period)),
 188         default_task_runner_(scheduler_helper_->DefaultTaskRunner()),
 189         idle_task_runner_(idle_helper_->IdleTaskRunner()) {
 190     clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
 191     scheduler_helper_->SetTimeSourceForTesting(
 192         make_scoped_ptr(new TestTimeSource(clock_.get())));
 193     scheduler_helper_->GetTaskQueueManagerForTesting()->SetTimeSourceForTesting(
 194         make_scoped_ptr(new TestTimeSource(clock_.get())));
 195   }
 196
 197   ~BaseIdleHelperTest() override {}
 198
 199   void SetUp() override {
 200     EXPECT_CALL(*idle_helper_, OnIdlePeriodStarted()).Times(AnyNumber());
 201     EXPECT_CALL(*idle_helper_, OnIdlePeriodEnded()).Times(AnyNumber());
 202     EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
 203         .Times(AnyNumber())
 204         .WillRepeatedly(Return(true));
 205   }
 206
 207   void TearDown() override {
 208     DCHECK(!mock_task_runner_.get() || !message_loop_.get());
 209     if (mock_task_runner_.get()) {
 210       // Check that all tests stop posting tasks.
 211       mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 212       while (mock_task_runner_->RunUntilIdle()) {
 213       }
 214     } else {
 215       message_loop_->RunUntilIdle();
 216     }
 217   }
 218
 219   void RunUntilIdle() {
 220     // Only one of mock_task_runner_ or message_loop_ should be set.
 221     DCHECK(!mock_task_runner_.get() || !message_loop_.get());
 222     if (mock_task_runner_.get())
 223       mock_task_runner_->RunUntilIdle();
 224     else
 225       message_loop_->RunUntilIdle();
 226   }
 227
 228   template <typename E>
 229   static void CallForEachEnumValue(E first,
 230                                    E last,
 231                                    const char* (*function)(E)) {
 232     for (E val = first; val < last;
 233          val = static_cast<E>(static_cast<int>(val) + 1)) {
 234       (*function)(val);
 235     }
 236   }
 237
 238   static void CheckAllTaskQueueIdToString() {
 239     CallForEachEnumValue<IdleHelper::IdlePeriodState>(
 240         IdleHelper::IdlePeriodState::FIRST_IDLE_PERIOD_STATE,
 241         IdleHelper::IdlePeriodState::IDLE_PERIOD_STATE_COUNT,
 242         &IdleHelper::IdlePeriodStateToString);
 243   }
 244
 245   bool IsInIdlePeriod() const {
 246     return idle_helper_->IsInIdlePeriod(
 247         idle_helper_->SchedulerIdlePeriodState());
 248   }
 249
 250  protected:
 251   static base::TimeDelta maximum_idle_period_duration() {
 252     return base::TimeDelta::FromMilliseconds(
 253         IdleHelper::kMaximumIdlePeriodMillis);
 254   }
 255
 256   static base::TimeDelta retry_enable_long_idle_period_delay() {
 257     return base::TimeDelta::FromMilliseconds(
 258         IdleHelper::kRetryEnableLongIdlePeriodDelayMillis);
 259   }
 260
 261   static base::TimeDelta minimum_idle_period_duration() {
 262     return base::TimeDelta::FromMilliseconds(
 263         IdleHelper::kMinimumIdlePeriodDurationMillis);
 264   }
 265
 266   base::TimeTicks CurrentIdleTaskDeadline() {
 267     return idle_helper_->CurrentIdleTaskDeadline();
 268   }
 269
 270   void CheckIdlePeriodStateIs(const char* expected) {
 271     EXPECT_STREQ(expected, IdleHelper::IdlePeriodStateToString(
 272                                idle_helper_->SchedulerIdlePeriodState()));
 273   }
 274
 275   scoped_ptr<base::SimpleTestTickClock> clock_;
 276   // Only one of mock_task_runner_ or message_loop_ will be set.
 277   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
 278   scoped_ptr<base::MessageLoop> message_loop_;
 279
 280   scoped_refptr<NestableSingleThreadTaskRunner> nestable_task_runner_;
 281   scoped_ptr<SchedulerHelper> scheduler_helper_;
 282   scoped_ptr<IdleHelperForTest> idle_helper_;
 283   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
 284   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
 285
 286   DISALLOW_COPY_AND_ASSIGN(BaseIdleHelperTest);
 287 };
 288
 289 class IdleHelperTest : public BaseIdleHelperTest {
 290  public:
 291   IdleHelperTest() : BaseIdleHelperTest(nullptr, base::TimeDelta()) {}
 292
 293   ~IdleHelperTest() override {}
 294
 295   TaskQueueManager* task_queue_manager() const {
 296     return scheduler_helper_->GetTaskQueueManagerForTesting();
 297   }
 298
 299  private:
 300   DISALLOW_COPY_AND_ASSIGN(IdleHelperTest);
 301 };
 302
 303 TEST_F(IdleHelperTest, TestPostIdleTask) {
 304   int run_count = 0;
 305   base::TimeTicks expected_deadline =
 306       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(2300);
 307   base::TimeTicks deadline_in_task;
 308
 309   clock_->Advance(base::TimeDelta::FromMilliseconds(100));
 310   idle_task_runner_->PostIdleTask(
 311       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 312
 313   RunUntilIdle();
 314   EXPECT_EQ(0, run_count);
 315
 316   idle_helper_->StartIdlePeriod(
 317       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 318       expected_deadline);
 319   RunUntilIdle();
 320   EXPECT_EQ(1, run_count);
 321   EXPECT_EQ(expected_deadline, deadline_in_task);
 322 }
 323
 324 TEST_F(IdleHelperTest, TestPostIdleTask_EndIdlePeriod) {
 325   int run_count = 0;
 326   base::TimeTicks deadline_in_task;
 327
 328   clock_->Advance(base::TimeDelta::FromMilliseconds(100));
 329   idle_task_runner_->PostIdleTask(
 330       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 331
 332   RunUntilIdle();
 333   EXPECT_EQ(0, run_count);
 334
 335   idle_helper_->StartIdlePeriod(
 336       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 337       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 338   idle_helper_->EndIdlePeriod();
 339   RunUntilIdle();
 340   EXPECT_EQ(0, run_count);
 341 }
 342
 343 TEST_F(IdleHelperTest, TestRepostingIdleTask) {
 344   base::TimeTicks actual_deadline;
 345   int run_count = 0;
 346
 347   max_idle_task_reposts = 2;
 348   idle_task_runner_->PostIdleTask(
 349       FROM_HERE, base::Bind(&RepostingIdleTestTask, idle_task_runner_,
 350                             &run_count, &actual_deadline));
 351   idle_helper_->StartIdlePeriod(
 352       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 353       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 354   RunUntilIdle();
 355   EXPECT_EQ(1, run_count);
 356
 357   // Reposted tasks shouldn't run until next idle period.
 358   RunUntilIdle();
 359   EXPECT_EQ(1, run_count);
 360
 361   idle_helper_->StartIdlePeriod(
 362       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 363       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 364   RunUntilIdle();
 365   EXPECT_EQ(2, run_count);
 366 }
 367
 368 TEST_F(IdleHelperTest, TestIdleTaskExceedsDeadline) {
 369   int run_count = 0;
 370
 371   // Post two UpdateClockToDeadlineIdleTestTask tasks.
 372   idle_task_runner_->PostIdleTask(
 373       FROM_HERE,
 374       base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_.get(), &run_count));
 375   idle_task_runner_->PostIdleTask(
 376       FROM_HERE,
 377       base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_.get(), &run_count));
 378
 379   idle_helper_->StartIdlePeriod(
 380       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 381       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 382   RunUntilIdle();
 383   // Only the first idle task should execute since it's used up the deadline.
 384   EXPECT_EQ(1, run_count);
 385
 386   idle_helper_->EndIdlePeriod();
 387   idle_helper_->StartIdlePeriod(
 388       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 389       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 390   RunUntilIdle();
 391   // Second task should be run on the next idle period.
 392   EXPECT_EQ(2, run_count);
 393 }
 394
 395 TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeup) {
 396   base::TimeTicks deadline_in_task;
 397   int run_count = 0;
 398
 399   idle_task_runner_->PostIdleTaskAfterWakeup(
 400       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 401
 402   idle_helper_->StartIdlePeriod(
 403       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 404       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 405   RunUntilIdle();
 406   // Shouldn't run yet as no other task woke up the scheduler.
 407   EXPECT_EQ(0, run_count);
 408
 409   // Must start a new idle period before idle task runs.
 410   idle_task_runner_->PostIdleTaskAfterWakeup(
 411       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 412
 413   idle_helper_->StartIdlePeriod(
 414       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 415       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 416   RunUntilIdle();
 417   // Another after wakeup idle task shouldn't wake the scheduler.
 418   EXPECT_EQ(0, run_count);
 419
 420   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
 421
 422   RunUntilIdle();
 423   idle_helper_->StartIdlePeriod(
 424       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 425       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 426   RunUntilIdle();
 427   // Execution of default task queue task should trigger execution of idle task.
 428   EXPECT_EQ(2, run_count);
 429 }
 430
 431 TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeupWhileAwake) {
 432   base::TimeTicks deadline_in_task;
 433   int run_count = 0;
 434
 435   idle_task_runner_->PostIdleTaskAfterWakeup(
 436       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 437   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
 438
 439   RunUntilIdle();
 440   // Must start a new idle period before idle task runs.
 441   idle_helper_->StartIdlePeriod(
 442       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 443       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 444   RunUntilIdle();
 445   // Should run as the scheduler was already awakened by the normal task.
 446   EXPECT_EQ(1, run_count);
 447 }
 448
 449 TEST_F(IdleHelperTest, TestPostIdleTaskWakesAfterWakeupIdleTask) {
 450   base::TimeTicks deadline_in_task;
 451   int run_count = 0;
 452
 453   idle_task_runner_->PostIdleTaskAfterWakeup(
 454       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 455   idle_task_runner_->PostIdleTask(
 456       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 457
 458   idle_helper_->StartIdlePeriod(
 459       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 460       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 461   RunUntilIdle();
 462   // Must start a new idle period before after-wakeup idle task runs.
 463   idle_helper_->StartIdlePeriod(
 464       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 465       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 466   RunUntilIdle();
 467   // Normal idle task should wake up after-wakeup idle task.
 468   EXPECT_EQ(2, run_count);
 469 }
 470
 471 class IdleHelperTestWithIdlePeriodObserver : public BaseIdleHelperTest {
 472  public:
 473   IdleHelperTestWithIdlePeriodObserver()
 474       : BaseIdleHelperTest(nullptr, base::TimeDelta()) {}
 475
 476   ~IdleHelperTestWithIdlePeriodObserver() override {}
 477
 478   void SetUp() override {
 479     // Don't set expectations on IdleHelper::Delegate.
 480   }
 481
 482   TaskQueueManager* task_queue_manager() const {
 483     return scheduler_helper_->GetTaskQueueManagerForTesting();
 484   }
 485
 486   void ExpectIdlePeriodStartsButNeverEnds() {
 487     EXPECT_CALL(*idle_helper_, OnIdlePeriodStarted()).Times(1);
 488     EXPECT_CALL(*idle_helper_, OnIdlePeriodEnded()).Times(0);
 489   }
 490
 491   void ExpectIdlePeriodStartsAndEnds(const testing::Cardinality& cardinality) {
 492     EXPECT_CALL(*idle_helper_, OnIdlePeriodStarted()).Times(cardinality);
 493     EXPECT_CALL(*idle_helper_, OnIdlePeriodEnded()).Times(cardinality);
 494   }
 495
 496  private:
 497   DISALLOW_COPY_AND_ASSIGN(IdleHelperTestWithIdlePeriodObserver);
 498 };
 499
 500 TEST_F(IdleHelperTestWithIdlePeriodObserver, TestEnterButNotExitIdlePeriod) {
 501   ExpectIdlePeriodStartsButNeverEnds();
 502
 503   idle_helper_->StartIdlePeriod(
 504       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 505       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 506 }
 507
 508 TEST_F(IdleHelperTestWithIdlePeriodObserver, TestEnterAndExitIdlePeriod) {
 509   BaseIdleHelperTest* fixture = this;
 510   ON_CALL(*idle_helper_, OnIdlePeriodStarted())
 511       .WillByDefault(
 512           Invoke([fixture]() { EXPECT_TRUE(fixture->IsInIdlePeriod()); }));
 513   ON_CALL(*idle_helper_, OnIdlePeriodEnded())
 514       .WillByDefault(
 515           Invoke([fixture]() { EXPECT_FALSE(fixture->IsInIdlePeriod()); }));
 516
 517   ExpectIdlePeriodStartsAndEnds(Exactly(1));
 518
 519   idle_helper_->StartIdlePeriod(
 520       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 521       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 522   idle_helper_->EndIdlePeriod();
 523 }
 524
 525 class IdleHelperWithMessageLoopTest : public BaseIdleHelperTest {
 526  public:
 527   IdleHelperWithMessageLoopTest()
 528       : BaseIdleHelperTest(new base::MessageLoop(), base::TimeDelta()) {}
 529   ~IdleHelperWithMessageLoopTest() override {}
 530
 531   void PostFromNestedRunloop(std::vector<
 532       std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>>* tasks) {
 533     base::MessageLoop::ScopedNestableTaskAllower allow(message_loop_.get());
 534     for (std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>& pair : *tasks) {
 535       if (pair.second) {
 536         idle_task_runner_->PostIdleTask(FROM_HERE, pair.first);
 537       } else {
 538         idle_task_runner_->PostNonNestableIdleTask(FROM_HERE, pair.first);
 539       }
 540     }
 541     idle_helper_->StartIdlePeriod(
 542         IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 543         clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 544     message_loop_->RunUntilIdle();
 545   }
 546
 547   void SetUp() override {
 548     EXPECT_CALL(*idle_helper_, OnIdlePeriodStarted()).Times(AnyNumber());
 549     EXPECT_CALL(*idle_helper_, OnIdlePeriodEnded()).Times(AnyNumber());
 550   }
 551
 552  private:
 553   DISALLOW_COPY_AND_ASSIGN(IdleHelperWithMessageLoopTest);
 554 };
 555
 556 TEST_F(IdleHelperWithMessageLoopTest,
 557        NonNestableIdleTaskDoesntExecuteInNestedLoop) {
 558   std::vector<std::string> order;
 559   idle_task_runner_->PostIdleTask(
 560       FROM_HERE,
 561       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("1")));
 562   idle_task_runner_->PostIdleTask(
 563       FROM_HERE,
 564       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("2")));
 565
 566   std::vector<std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>>
 567       tasks_to_post_from_nested_loop;
 568   tasks_to_post_from_nested_loop.push_back(std::make_pair(
 569       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("3")),
 570       false));
 571   tasks_to_post_from_nested_loop.push_back(std::make_pair(
 572       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("4")), true));
 573   tasks_to_post_from_nested_loop.push_back(std::make_pair(
 574       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("5")), true));
 575
 576   default_task_runner_->PostTask(
 577       FROM_HERE,
 578       base::Bind(&IdleHelperWithMessageLoopTest::PostFromNestedRunloop,
 579                  base::Unretained(this),
 580                  base::Unretained(&tasks_to_post_from_nested_loop)));
 581
 582   idle_helper_->StartIdlePeriod(
 583       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 584       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 585   RunUntilIdle();
 586   // Note we expect task 3 to run last because it's non-nestable.
 587   EXPECT_THAT(order, testing::ElementsAre(std::string("1"), std::string("2"),
 588                                           std::string("4"), std::string("5"),
 589                                           std::string("3")));
 590 }
 591
 592 TEST_F(IdleHelperTestWithIdlePeriodObserver, TestLongIdlePeriod) {
 593   base::TimeTicks expected_deadline =
 594       clock_->NowTicks() + maximum_idle_period_duration();
 595   base::TimeTicks deadline_in_task;
 596   int run_count = 0;
 597
 598   idle_task_runner_->PostIdleTask(
 599       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 600
 601   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
 602       .Times(1)
 603       .WillRepeatedly(Return(true));
 604   ExpectIdlePeriodStartsButNeverEnds();
 605
 606   RunUntilIdle();
 607   EXPECT_EQ(0, run_count);  // Shouldn't run yet as no idle period.
 608
 609   idle_helper_->EnableLongIdlePeriod();
 610   RunUntilIdle();
 611   EXPECT_EQ(1, run_count);  // Should have run in a long idle time.
 612   EXPECT_EQ(expected_deadline, deadline_in_task);
 613 }
 614
 615 TEST_F(IdleHelperTest, TestLongIdlePeriodWithPendingDelayedTask) {
 616   base::TimeDelta pending_task_delay = base::TimeDelta::FromMilliseconds(30);
 617   base::TimeTicks expected_deadline = clock_->NowTicks() + pending_task_delay;
 618   base::TimeTicks deadline_in_task;
 619   int run_count = 0;
 620
 621   idle_task_runner_->PostIdleTask(
 622       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 623   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
 624                                         pending_task_delay);
 625
 626   idle_helper_->EnableLongIdlePeriod();
 627   RunUntilIdle();
 628   EXPECT_EQ(1, run_count);  // Should have run in a long idle time.
 629   EXPECT_EQ(expected_deadline, deadline_in_task);
 630 }
 631
 632 TEST_F(IdleHelperTest, TestLongIdlePeriodWithLatePendingDelayedTask) {
 633   base::TimeDelta pending_task_delay = base::TimeDelta::FromMilliseconds(10);
 634   base::TimeTicks deadline_in_task;
 635   int run_count = 0;
 636
 637   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
 638                                         pending_task_delay);
 639
 640   // Advance clock until after delayed task was meant to be run.
 641   clock_->Advance(base::TimeDelta::FromMilliseconds(20));
 642
 643   // Post an idle task and then EnableLongIdlePeriod. Since there is a late
 644   // pending delayed task this shouldn't actually start an idle period.
 645   idle_task_runner_->PostIdleTask(
 646       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 647   idle_helper_->EnableLongIdlePeriod();
 648   RunUntilIdle();
 649   EXPECT_EQ(0, run_count);
 650
 651   // After the delayed task has been run we should trigger an idle period.
 652   clock_->Advance(maximum_idle_period_duration());
 653   RunUntilIdle();
 654   EXPECT_EQ(1, run_count);
 655 }
 656
 657 TEST_F(IdleHelperTestWithIdlePeriodObserver, TestLongIdlePeriodRepeating) {
 658   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 659   std::vector<base::TimeTicks> actual_deadlines;
 660   int run_count = 0;
 661
 662   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
 663       .Times(4)
 664       .WillRepeatedly(Return(true));
 665   ExpectIdlePeriodStartsAndEnds(AtLeast(2));
 666
 667   max_idle_task_reposts = 3;
 668   base::TimeTicks clock_before(clock_->NowTicks());
 669   base::TimeDelta idle_task_runtime(base::TimeDelta::FromMilliseconds(10));
 670   idle_task_runner_->PostIdleTask(
 671       FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
 672                             idle_task_runner_, &run_count, clock_.get(),
 673                             idle_task_runtime, &actual_deadlines));
 674
 675   // Check each idle task runs in their own idle period.
 676   idle_helper_->EnableLongIdlePeriod();
 677   RunUntilIdle();
 678   EXPECT_EQ(3, run_count);
 679   EXPECT_THAT(
 680       actual_deadlines,
 681       testing::ElementsAre(
 682           clock_before + maximum_idle_period_duration(),
 683           clock_before + idle_task_runtime + maximum_idle_period_duration(),
 684           clock_before + (2 * idle_task_runtime) +
 685               maximum_idle_period_duration()));
 686
 687   max_idle_task_reposts = 5;
 688   idle_task_runner_->PostIdleTask(
 689       FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
 690                             idle_task_runner_, &run_count, clock_.get(),
 691                             idle_task_runtime, &actual_deadlines));
 692   idle_task_runner_->PostIdleTask(
 693       FROM_HERE,
 694       base::Bind(&EndIdlePeriodIdleTask, base::Unretained(idle_helper_.get())));
 695
 696   // Ensure that reposting tasks stop after EndIdlePeriod is called.
 697   RunUntilIdle();
 698   EXPECT_EQ(4, run_count);
 699 }
 700
 701 TEST_F(IdleHelperTest, TestLongIdlePeriodDoesNotWakeScheduler) {
 702   base::TimeTicks deadline_in_task;
 703   int run_count = 0;
 704
 705   // Start a long idle period and get the time it should end.
 706   idle_helper_->EnableLongIdlePeriod();
 707   // The scheduler should not run the enable_next_long_idle_period task if
 708   // there are no idle tasks and no other task woke up the scheduler, thus
 709   // the idle period deadline shouldn't update at the end of the current long
 710   // idle period.
 711   base::TimeTicks idle_period_deadline = CurrentIdleTaskDeadline();
 712   clock_->Advance(maximum_idle_period_duration());
 713   RunUntilIdle();
 714
 715   base::TimeTicks new_idle_period_deadline = CurrentIdleTaskDeadline();
 716   EXPECT_EQ(idle_period_deadline, new_idle_period_deadline);
 717
 718   // Posting a after-wakeup idle task also shouldn't wake the scheduler or
 719   // initiate the next long idle period.
 720   idle_task_runner_->PostIdleTaskAfterWakeup(
 721       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 722   RunUntilIdle();
 723   new_idle_period_deadline = CurrentIdleTaskDeadline();
 724   EXPECT_EQ(idle_period_deadline, new_idle_period_deadline);
 725   EXPECT_EQ(0, run_count);
 726
 727   // Running a normal task should initiate a new long idle period though.
 728   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
 729   RunUntilIdle();
 730   new_idle_period_deadline = CurrentIdleTaskDeadline();
 731   EXPECT_EQ(idle_period_deadline + maximum_idle_period_duration(),
 732             new_idle_period_deadline);
 733
 734   EXPECT_EQ(1, run_count);
 735 }
 736
 737 TEST_F(IdleHelperTestWithIdlePeriodObserver,
 738        TestLongIdlePeriodWhenNotCanEnterLongIdlePeriod) {
 739   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(1000);
 740   base::TimeDelta halfDelay = base::TimeDelta::FromMilliseconds(500);
 741   base::TimeTicks delayOver = clock_->NowTicks() + delay;
 742   base::TimeTicks deadline_in_task;
 743   int run_count = 0;
 744
 745   ON_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
 746       .WillByDefault(Invoke(
 747           [delay, delayOver](base::TimeTicks now,
 748                              base::TimeDelta* next_long_idle_period_delay_out) {
 749             if (now >= delayOver)
 750               return true;
 751             *next_long_idle_period_delay_out = delay;
 752             return false;
 753           }));
 754
 755   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)).Times(2);
 756   EXPECT_CALL(*idle_helper_, OnIdlePeriodStarted()).Times(AnyNumber());
 757
 758   idle_task_runner_->PostIdleTask(
 759       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 760
 761   // Make sure Idle tasks don't run until the delay has occurred.
 762   idle_helper_->EnableLongIdlePeriod();
 763   RunUntilIdle();
 764   EXPECT_EQ(0, run_count);
 765
 766   clock_->Advance(halfDelay);
 767   RunUntilIdle();
 768   EXPECT_EQ(0, run_count);
 769
 770   // Delay is finished, idle task should run.
 771   clock_->Advance(halfDelay);
 772   RunUntilIdle();
 773   EXPECT_EQ(1, run_count);
 774 }
 775
 776 TEST_F(IdleHelperTest, TestLongIdlePeriodImmediatelyRestartsIfMaxDeadline) {
 777   std::vector<base::TimeTicks> actual_deadlines;
 778   int run_count = 0;
 779
 780   base::TimeTicks clock_before(clock_->NowTicks());
 781   base::TimeDelta idle_task_runtime(base::TimeDelta::FromMilliseconds(10));
 782
 783   // The second idle period should happen immediately after the first the
 784   // they have max deadlines.
 785   max_idle_task_reposts = 2;
 786   idle_task_runner_->PostIdleTask(
 787       FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
 788                             idle_task_runner_, &run_count, clock_.get(),
 789                             idle_task_runtime, &actual_deadlines));
 790
 791   idle_helper_->EnableLongIdlePeriod();
 792   RunUntilIdle();
 793   EXPECT_EQ(2, run_count);
 794   EXPECT_THAT(
 795       actual_deadlines,
 796       testing::ElementsAre(
 797           clock_before + maximum_idle_period_duration(),
 798           clock_before + idle_task_runtime + maximum_idle_period_duration()));
 799 }
 800
 801 TEST_F(IdleHelperTest, TestLongIdlePeriodRestartWaitsIfNotMaxDeadline) {
 802   base::TimeTicks actual_deadline;
 803   int run_count = 0;
 804
 805   base::TimeDelta pending_task_delay(base::TimeDelta::FromMilliseconds(20));
 806   base::TimeDelta idle_task_duration(base::TimeDelta::FromMilliseconds(10));
 807   base::TimeTicks expected_deadline(clock_->NowTicks() + pending_task_delay +
 808                                     maximum_idle_period_duration() +
 809                                     retry_enable_long_idle_period_delay());
 810
 811   // Post delayed task to ensure idle period doesn't have a max deadline.
 812   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
 813                                         pending_task_delay);
 814
 815   max_idle_task_reposts = 2;
 816   idle_task_runner_->PostIdleTask(
 817       FROM_HERE, base::Bind(&RepostingIdleTestTask, idle_task_runner_,
 818                             &run_count, &actual_deadline));
 819   idle_helper_->EnableLongIdlePeriod();
 820   RunUntilIdle();
 821   EXPECT_EQ(1, run_count);
 822   clock_->Advance(idle_task_duration);
 823
 824   // Next idle period shouldn't happen until the pending task has been run.
 825   RunUntilIdle();
 826   EXPECT_EQ(1, run_count);
 827
 828   // Once the pending task is run the new idle period should start.
 829   clock_->Advance(pending_task_delay - idle_task_duration);
 830   RunUntilIdle();
 831   // Since the idle period tried to start before the pending task ran we have to
 832   // wait for the idle helper to retry starting the long idle period.
 833   clock_->Advance(retry_enable_long_idle_period_delay());
 834   RunUntilIdle();
 835
 836   EXPECT_EQ(2, run_count);
 837   EXPECT_EQ(expected_deadline, actual_deadline);
 838 }
 839
 840 TEST_F(IdleHelperTest, TestLongIdlePeriodPaused) {
 841   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 842   std::vector<base::TimeTicks> actual_deadlines;
 843   int run_count = 0;
 844
 845   // If there are no idle tasks posted we should start in the paused state.
 846   idle_helper_->EnableLongIdlePeriod();
 847   CheckIdlePeriodStateIs("in_long_idle_period_paused");
 848   // There shouldn't be any delayed tasks posted by the idle helper when paused.
 849   EXPECT_EQ(base::TimeTicks(),
 850             scheduler_helper_->NextPendingDelayedTaskRunTime());
 851
 852   // Posting a task should transition us to the an active state.
 853   max_idle_task_reposts = 2;
 854   base::TimeTicks clock_before(clock_->NowTicks());
 855   base::TimeDelta idle_task_runtime(base::TimeDelta::FromMilliseconds(10));
 856   idle_task_runner_->PostIdleTask(
 857       FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
 858                             idle_task_runner_, &run_count, clock_.get(),
 859                             idle_task_runtime, &actual_deadlines));
 860   RunUntilIdle();
 861   EXPECT_EQ(2, run_count);
 862   EXPECT_THAT(
 863       actual_deadlines,
 864       testing::ElementsAre(
 865           clock_before + maximum_idle_period_duration(),
 866           clock_before + idle_task_runtime + maximum_idle_period_duration()));
 867
 868   // Once all task have been run we should go back to the paused state.
 869   CheckIdlePeriodStateIs("in_long_idle_period_paused");
 870   EXPECT_EQ(base::TimeTicks(),
 871             scheduler_helper_->NextPendingDelayedTaskRunTime());
 872
 873   idle_helper_->EndIdlePeriod();
 874   CheckIdlePeriodStateIs("not_in_idle_period");
 875 }
 876
 877 TEST_F(IdleHelperTest, TestLongIdlePeriodWhenShutdown) {
 878   base::TimeTicks deadline_in_task;
 879   int run_count = 0;
 880
 881   idle_task_runner_->PostIdleTask(
 882       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 883   scheduler_helper_->Shutdown();
 884
 885   // We shouldn't be able to enter a long idle period when shutdown
 886   idle_helper_->EnableLongIdlePeriod();
 887   RunUntilIdle();
 888   CheckIdlePeriodStateIs("not_in_idle_period");
 889   EXPECT_EQ(0, run_count);
 890 }
 891
 892 void TestCanExceedIdleDeadlineIfRequiredTask(IdleHelperForTest* idle_helper,
 893                                              bool* can_exceed_idle_deadline_out,
 894                                              int* run_count,
 895                                              base::TimeTicks deadline) {
 896   *can_exceed_idle_deadline_out =
 897       idle_helper->CanExceedIdleDeadlineIfRequired();
 898   (*run_count)++;
 899 }
 900
 901 TEST_F(IdleHelperTest, CanExceedIdleDeadlineIfRequired) {
 902   int run_count = 0;
 903   bool can_exceed_idle_deadline = false;
 904
 905   // Should return false if not in an idle period.
 906   EXPECT_FALSE(idle_helper_->CanExceedIdleDeadlineIfRequired());
 907
 908   // Should return false for short idle periods.
 909   idle_task_runner_->PostIdleTask(
 910       FROM_HERE,
 911       base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(),
 912                  &can_exceed_idle_deadline, &run_count));
 913   idle_helper_->StartIdlePeriod(
 914       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
 915       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 916   RunUntilIdle();
 917   EXPECT_EQ(1, run_count);
 918   EXPECT_FALSE(can_exceed_idle_deadline);
 919
 920   // Should return false for a long idle period which is shortened due to a
 921   // pending delayed task.
 922   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
 923                                         base::TimeDelta::FromMilliseconds(10));
 924   idle_task_runner_->PostIdleTask(
 925       FROM_HERE,
 926       base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(),
 927                  &can_exceed_idle_deadline, &run_count));
 928   idle_helper_->EnableLongIdlePeriod();
 929   RunUntilIdle();
 930   EXPECT_EQ(2, run_count);
 931   EXPECT_FALSE(can_exceed_idle_deadline);
 932
 933   // Next long idle period will be for the maximum time, so
 934   // CanExceedIdleDeadlineIfRequired should return true.
 935   clock_->Advance(maximum_idle_period_duration());
 936   idle_task_runner_->PostIdleTask(
 937       FROM_HERE,
 938       base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(),
 939                  &can_exceed_idle_deadline, &run_count));
 940   RunUntilIdle();
 941   EXPECT_EQ(3, run_count);
 942   EXPECT_TRUE(can_exceed_idle_deadline);
 943 }
 944
 945 class IdleHelperWithQuiescencePeriodTest : public BaseIdleHelperTest {
 946  public:
 947   enum {
 948     kQuiescenceDelayMs = 100,
 949     kLongIdlePeriodMs = 50,
 950   };
 951
 952   IdleHelperWithQuiescencePeriodTest()
 953       : BaseIdleHelperTest(
 954             nullptr,
 955             base::TimeDelta::FromMilliseconds(kQuiescenceDelayMs)) {}
 956
 957   ~IdleHelperWithQuiescencePeriodTest() override {}
 958
 959   void SetUp() override {
 960     EXPECT_CALL(*idle_helper_, OnIdlePeriodStarted()).Times(AnyNumber());
 961     EXPECT_CALL(*idle_helper_, OnIdlePeriodEnded()).Times(AnyNumber());
 962     EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
 963         .Times(AnyNumber())
 964         .WillRepeatedly(Return(true));
 965     EXPECT_CALL(*idle_helper_, IsNotQuiescent()).Times(AnyNumber());
 966   }
 967
 968   void MakeNonQuiescent() {
 969     // Run an arbitrary task so we're deemed to be not quiescent.
 970     default_task_runner_->PostTask(FROM_HERE, base::Bind(NullTask));
 971     RunUntilIdle();
 972   }
 973
 974  private:
 975   DISALLOW_COPY_AND_ASSIGN(IdleHelperWithQuiescencePeriodTest);
 976 };
 977
 978 class IdleHelperWithQuiescencePeriodTestWithIdlePeriodObserver :
 979     public IdleHelperWithQuiescencePeriodTest {
 980  public:
 981
 982   IdleHelperWithQuiescencePeriodTestWithIdlePeriodObserver()
 983       : IdleHelperWithQuiescencePeriodTest() {}
 984
 985   ~IdleHelperWithQuiescencePeriodTestWithIdlePeriodObserver() override {}
 986
 987   void SetUp() override {
 988     // Don't set expectations on IdleHelper::Delegate.
 989   }
 990
 991  private:
 992   DISALLOW_COPY_AND_ASSIGN(
 993       IdleHelperWithQuiescencePeriodTestWithIdlePeriodObserver);
 994 };
 995
 996
 997 TEST_F(IdleHelperWithQuiescencePeriodTest,
 998        LongIdlePeriodStartsImmediatelyIfQuiescent) {
 999   base::TimeTicks actual_deadline;
1000   int run_count = 0;
1001   max_idle_task_reposts = 1;
1002   idle_task_runner_->PostIdleTask(
1003       FROM_HERE, base::Bind(&RepostingIdleTestTask, idle_task_runner_,
1004                             &run_count, &actual_deadline));
1005
1006   idle_helper_->EnableLongIdlePeriod();
1007   RunUntilIdle();
1008
1009   EXPECT_EQ(1, run_count);
1010 }
1011
1012 TEST_F(IdleHelperWithQuiescencePeriodTestWithIdlePeriodObserver,
1013        LongIdlePeriodDoesNotStartsImmediatelyIfBusy) {
1014   MakeNonQuiescent();
1015   EXPECT_CALL(*idle_helper_, OnIdlePeriodStarted()).Times(0);
1016   EXPECT_CALL(*idle_helper_, OnIdlePeriodEnded()).Times(0);
1017   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)).Times(0);
1018   EXPECT_CALL(*idle_helper_, IsNotQuiescent()).Times(AtLeast(1));
1019
1020   base::TimeTicks actual_deadline;
1021   int run_count = 0;
1022   max_idle_task_reposts = 1;
1023   idle_task_runner_->PostIdleTask(
1024       FROM_HERE, base::Bind(&RepostingIdleTestTask, idle_task_runner_,
1025                             &run_count, &actual_deadline));
1026
1027   idle_helper_->EnableLongIdlePeriod();
1028   RunUntilIdle();
1029
1030   EXPECT_EQ(0, run_count);
1031
1032   scheduler_helper_->Shutdown();
1033 }
1034
1035 TEST_F(IdleHelperWithQuiescencePeriodTest,
1036        LongIdlePeriodStartsAfterQuiescence) {
1037   MakeNonQuiescent();
1038   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
1039
1040   // Run a repeating task so we're deemed to be busy for the next 400ms.
1041   default_task_runner_->PostTask(
1042       FROM_HERE,
1043       base::Bind(&RepeatingTask, base::Unretained(default_task_runner_.get()),
1044                  10, base::TimeDelta::FromMilliseconds(40)));
1045
1046   int run_count = 0;
1047   // In this scenario EnableLongIdlePeriod deems us not to be quiescent 5x in
1048   // a row.
1049   base::TimeTicks expected_deadline =
1050       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(
1051                                5 * kQuiescenceDelayMs + kLongIdlePeriodMs);
1052   base::TimeTicks deadline_in_task;
1053   idle_task_runner_->PostIdleTask(
1054       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
1055
1056   idle_helper_->EnableLongIdlePeriod();
1057   RunUntilIdle();
1058   EXPECT_EQ(1, run_count);
1059   EXPECT_EQ(expected_deadline, deadline_in_task);
1060 }
1061
1062 TEST_F(IdleHelperWithQuiescencePeriodTest,
1063        QuescienceCheckedForAfterLongIdlePeriodEnds) {
1064   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
1065
1066   idle_task_runner_->PostIdleTask(FROM_HERE, base::Bind(&NullIdleTask));
1067   idle_helper_->EnableLongIdlePeriod();
1068   RunUntilIdle();
1069
1070   // Post a normal task to make the scheduler non-quiescent.
1071   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
1072   RunUntilIdle();
1073
1074   // Post an idle task. The idle task won't run initially because the system is
1075   // not judged to be quiescent, but should be run after the quiescence delay.
1076   int run_count = 0;
1077   base::TimeTicks deadline_in_task;
1078   base::TimeTicks expected_deadline =
1079       clock_->NowTicks() +
1080       base::TimeDelta::FromMilliseconds(kQuiescenceDelayMs + kLongIdlePeriodMs);
1081   idle_task_runner_->PostIdleTask(
1082       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
1083   idle_helper_->EnableLongIdlePeriod();
1084   RunUntilIdle();
1085
1086   EXPECT_EQ(1, run_count);
1087   EXPECT_EQ(expected_deadline, deadline_in_task);
1088 }
1089
1090 TEST_F(IdleHelperTest, NoShortIdlePeriodWhenDeadlineTooClose) {
1091   int run_count = 0;
1092   base::TimeTicks deadline_in_task;
1093
1094   idle_task_runner_->PostIdleTask(
1095       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
1096
1097   base::TimeDelta half_a_ms(base::TimeDelta::FromMicroseconds(50));
1098   base::TimeTicks less_than_min_deadline(
1099       clock_->NowTicks() + minimum_idle_period_duration() - half_a_ms);
1100   base::TimeTicks more_than_min_deadline(
1101       clock_->NowTicks() + minimum_idle_period_duration() + half_a_ms);
1102
1103   idle_helper_->StartIdlePeriod(
1104       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
1105       less_than_min_deadline);
1106   RunUntilIdle();
1107   EXPECT_EQ(0, run_count);
1108
1109   idle_helper_->StartIdlePeriod(
1110       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
1111       more_than_min_deadline);
1112   RunUntilIdle();
1113   EXPECT_EQ(1, run_count);
1114 }
1115
1116 TEST_F(IdleHelperTest, NoLongIdlePeriodWhenDeadlineTooClose) {
1117   int run_count = 0;
1118   base::TimeTicks deadline_in_task;
1119
1120   base::TimeDelta half_a_ms(base::TimeDelta::FromMicroseconds(50));
1121   base::TimeDelta less_than_min_deadline_duration(
1122       minimum_idle_period_duration() - half_a_ms);
1123   base::TimeDelta more_than_min_deadline_duration(
1124       minimum_idle_period_duration() + half_a_ms);
1125
1126   idle_task_runner_->PostIdleTask(
1127       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
1128   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
1129                                         less_than_min_deadline_duration);
1130
1131   idle_helper_->EnableLongIdlePeriod();
1132   RunUntilIdle();
1133   EXPECT_EQ(0, run_count);
1134
1135   idle_helper_->EndIdlePeriod();
1136   clock_->Advance(maximum_idle_period_duration());
1137   RunUntilIdle();
1138   EXPECT_EQ(0, run_count);
1139
1140   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
1141                                         more_than_min_deadline_duration);
1142   idle_helper_->EnableLongIdlePeriod();
1143   RunUntilIdle();
1144   EXPECT_EQ(1, run_count);
1145 }
1146
1147 }  // namespace scheduler