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

components/scheduler/child/worker_scheduler_impl_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/worker_scheduler_impl.h"
 
 #include "base/callback.h"
 #include "base/strings/stringprintf.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"
 #include "components/scheduler/child/scheduler_message_loop_delegate.h"
 #include "components/scheduler/child/test_time_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::ElementsAreArray;
 
 namespace scheduler {
 
 namespace {
 void NopTask() {
 }
 
 int TimeTicksToIntMs(const base::TimeTicks& time) {
   return static_cast<int>((time - base::TimeTicks()).InMilliseconds());
 }
 
-void WakeUpTask(std::vector<std::string>* timeline, cc::TestNowSource* clock) {
-  if (timeline) {
-    timeline->push_back(base::StringPrintf("run WakeUpTask @ %d",
-                                           TimeTicksToIntMs(clock->Now())));
-  }
-}
-
 void RecordTimelineTask(std::vector<std::string>* timeline,
                         cc::TestNowSource* clock) {
   timeline->push_back(base::StringPrintf("run RecordTimelineTask @ %d",
                                          TimeTicksToIntMs(clock->Now())));
 }
 
 void AppendToVectorTestTask(std::vector<std::string>* vector,
                             std::string value) {
   vector->push_back(value);
 }
@@ skipping 91 matching lines @@
       timeline_->push_back(base::StringPrintf("RunUntilIdle begin @ %d",
                                               TimeTicksToIntMs(clock_->Now())));
     }
     mock_task_runner_->RunUntilIdle();
     if (timeline_) {
       timeline_->push_back(base::StringPrintf("RunUntilIdle end @ %d",
                                               TimeTicksToIntMs(clock_->Now())));
     }
   }
 
-  void InitAndPostDelayedWakeupTask() {
-    Init();
-    // WorkerSchedulerImpl::Init causes a delayed task to be posted on the
-    // after wakeup control runner.  We need a task to wake the system up
-    // AFTER the delay for this has expired.
-    default_task_runner_->PostDelayedTask(
-        FROM_HERE, base::Bind(&WakeUpTask, base::Unretained(timeline_),
-                              base::Unretained(clock_.get())),
-        base::TimeDelta::FromMilliseconds(100));
-  }
-
   // 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
   void PostTestTasks(std::vector<std::string>* run_order,
                      const std::string& task_descriptor) {
     std::istringstream stream(task_descriptor);
     while (!stream.eof()) {
       std::string task;
@@ skipping 27 matching lines @@
   scoped_refptr<NestableSingleThreadTaskRunner> nestable_task_runner_;
   scoped_ptr<WorkerSchedulerImplForTest> scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
   std::vector<std::string>* timeline_;  // NOT OWNED
 
   DISALLOW_COPY_AND_ASSIGN(WorkerSchedulerImplTest);
 };
 
 TEST_F(WorkerSchedulerImplTest, TestPostDefaultTask) {
-  InitAndPostDelayedWakeupTask();
+  Init();
 
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "D1 D2 D3 D4");
 
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D1"), std::string("D2"),
                                    std::string("D3"), std::string("D4")));
 }
 
 TEST_F(WorkerSchedulerImplTest, TestPostIdleTask) {
-  InitAndPostDelayedWakeupTask();
+  Init();
 
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1");
 
   RunUntilIdle();
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("I1")));
 }
 
-TEST_F(WorkerSchedulerImplTest, TestPostIdleTask_NoWakeup) {
+TEST_F(WorkerSchedulerImplTest, TestPostDefaultAndIdleTasks) {
   Init();
-  std::vector<std::string> run_order;
-  PostTestTasks(&run_order, "I1");
-
-  RunUntilIdle();
-  EXPECT_TRUE(run_order.empty());
-}
-
-TEST_F(WorkerSchedulerImplTest, TestPostDefaultAndIdleTasks) {
-  InitAndPostDelayedWakeupTask();
 
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D2 D3 D4");
 
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D2"), std::string("D3"),
                                    std::string("D4"), std::string("I1")));
 }
 
-TEST_F(WorkerSchedulerImplTest, TestPostIdleTaskWithWakeupNeeded_NoWakeup) {
-  InitAndPostDelayedWakeupTask();
-
-  RunUntilIdle();
-  // The delayed call to EnableLongIdlePeriod happened and it posted a call to
-  // EnableLongIdlePeriod on the after wakeup control queue.
-
-  std::vector<std::string> run_order;
-  PostTestTasks(&run_order, "I1");
-
-  RunUntilIdle();
-  EXPECT_TRUE(run_order.empty());
-}
-
 TEST_F(WorkerSchedulerImplTest, TestPostDefaultDelayedAndIdleTasks) {
-  InitAndPostDelayedWakeupTask();
+  Init();
 
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D2 D3 D4");
 
   default_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&AppendToVectorTestTask, &run_order, "DELAYED"),
       base::TimeDelta::FromMilliseconds(1000));
 
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D2"), std::string("D3"),
                                    std::string("D4"), std::string("I1"),
                                    std::string("DELAYED")));
 }
 
+TEST_F(WorkerSchedulerImplTest, TestIdleTaskWhenIsNotQuiescent) {
+  std::vector<std::string> timeline;
+  RecordTimelineEvents(&timeline);
+  Init();
+
+  timeline.push_back("Post default task");
+  // Post a delayed task timed to occur mid way during the long idle period.
+  default_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
+                            base::Unretained(clock_.get())));
+  RunUntilIdle();
+
+  timeline.push_back("Post idle task");
+  idle_task_runner_->PostIdleTask(FROM_HERE,
+                                  base::Bind(&TimelineIdleTestTask, &timeline));
+
+  RunUntilIdle();
+
+  std::string expected_timeline[] = {"CanEnterLongIdlePeriod @ 5",
+                                     "Post default task",
+                                     "run RecordTimelineTask @ 5",
+                                     "Post idle task",
+                                     "IsNotQuiescent @ 5",
+                                     "CanEnterLongIdlePeriod @ 305",
+                                     "run TimelineIdleTestTask deadline 355"};
+
+  EXPECT_THAT(timeline, ElementsAreArray(expected_timeline));
+}
+
 TEST_F(WorkerSchedulerImplTest, TestIdleDeadlineWithPendingDelayedTask) {
   std::vector<std::string> timeline;
   RecordTimelineEvents(&timeline);
-  InitAndPostDelayedWakeupTask();
+  Init();
 
   timeline.push_back("Post delayed and idle tasks");
   // Post a delayed task timed to occur mid way during the long idle period.
   default_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
                             base::Unretained(clock_.get())),
-      base::TimeDelta::FromMilliseconds(420));
+      base::TimeDelta::FromMilliseconds(20));
   idle_task_runner_->PostIdleTask(FROM_HERE,
                                   base::Bind(&TimelineIdleTestTask, &timeline));
 
   RunUntilIdle();
 
   std::string expected_timeline[] = {
       "CanEnterLongIdlePeriod @ 5",
       "Post delayed and idle tasks",
-      "IsNotQuiescent @ 105",
-      "CanEnterLongIdlePeriod @ 405",
-      "run TimelineIdleTestTask deadline 425",  // Note the short 20ms deadline.
-      "CanEnterLongIdlePeriod @ 425",
-      "run RecordTimelineTask @ 425"};
+      "CanEnterLongIdlePeriod @ 5",
+      "run TimelineIdleTestTask deadline 25",  // Note the short 20ms deadline.
+      "run RecordTimelineTask @ 25"};
 
   EXPECT_THAT(timeline, ElementsAreArray(expected_timeline));
 }
 
 TEST_F(WorkerSchedulerImplTest,
        TestIdleDeadlineWithPendingDelayedTaskFarInTheFuture) {
   std::vector<std::string> timeline;
   RecordTimelineEvents(&timeline);
-  InitAndPostDelayedWakeupTask();
+  Init();
 
   timeline.push_back("Post delayed and idle tasks");
   // Post a delayed task timed to occur well after the long idle period.
   default_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
                             base::Unretained(clock_.get())),
-      base::TimeDelta::FromMilliseconds(1000));
+      base::TimeDelta::FromMilliseconds(500));
   idle_task_runner_->PostIdleTask(FROM_HERE,
                                   base::Bind(&TimelineIdleTestTask, &timeline));
 
   RunUntilIdle();
 
   std::string expected_timeline[] = {
       "CanEnterLongIdlePeriod @ 5",
       "Post delayed and idle tasks",
-      "IsNotQuiescent @ 105",
-      "CanEnterLongIdlePeriod @ 405",
-      "run TimelineIdleTestTask deadline 455",  // Note the full 50ms deadline.
-      "CanEnterLongIdlePeriod @ 455",
-      "run RecordTimelineTask @ 1005"};
+      "CanEnterLongIdlePeriod @ 5",
+      "run TimelineIdleTestTask deadline 55",  // Note the full 50ms deadline.
+      "run RecordTimelineTask @ 505"};
 
   EXPECT_THAT(timeline, ElementsAreArray(expected_timeline));
 }
 
-TEST_F(WorkerSchedulerImplTest,
-       TestPostIdleTaskAfterRunningUntilIdle_NoWakeUp) {
-  InitAndPostDelayedWakeupTask();
+TEST_F(WorkerSchedulerImplTest, TestPostIdleTaskAfterRunningUntilIdle) {
+  Init();
 
   default_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&NopTask), base::TimeDelta::FromMilliseconds(1000));
   RunUntilIdle();
 
-  // The delayed call to EnableLongIdlePeriod happened and it posted a call to
-  // EnableLongIdlePeriod on the after wakeup control queue. Without an other
-  // non-idle task posted, the idle tasks won't run.
-  std::vector<std::string> run_order;
-  PostTestTasks(&run_order, "I1 I2");
-
-  RunUntilIdle();
-  EXPECT_TRUE(run_order.empty());
-}
-
-TEST_F(WorkerSchedulerImplTest,
-       TestPostIdleTaskAfterRunningUntilIdle_WithWakeUp) {
-  InitAndPostDelayedWakeupTask();
-
-  default_task_runner_->PostDelayedTask(
-      FROM_HERE, base::Bind(&NopTask), base::TimeDelta::FromMilliseconds(1000));
-  RunUntilIdle();
-  // The delayed call to EnableLongIdlePeriod happened and it posted a call to
-  // EnableLongIdlePeriod on the after wakeup control queue. Without an other
-  // non-idle task posted, the idle tasks won't run.
-
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 I2 D3");
 
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D3"), std::string("I1"),
                                    std::string("I2")));
 }
 
 TEST_F(WorkerSchedulerImplTest, TestLongIdlePeriodTimeline) {
@@ skipping 36 matching lines @@
       "RunUntilIdle end @ 55",
       "PostIdleTaskAfterWakeup",
       "RunUntilIdle begin @ 55",  // NOTE idle task doesn't run till later.
       "RunUntilIdle end @ 55",
       "Post RecordTimelineTask",
       "RunUntilIdle begin @ 55",
       "run RecordTimelineTask @ 55",
       "IsNotQuiescent @ 55",  // NOTE we have to wait for quiescence.
       "CanEnterLongIdlePeriod @ 355",
       "run TimelineIdleTestTask deadline 405",
-      "CanEnterLongIdlePeriod @ 405",
-      "RunUntilIdle end @ 455"};
+      "RunUntilIdle end @ 355"};
 
   EXPECT_THAT(timeline, ElementsAreArray(expected_timeline));
 }
 
 }  // namespace scheduler