Add an idle task to periodically sweep canceled delayed tasks

third_party/WebKit/Source/platform/scheduler/child/idle_helper_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/scheduler/child/idle_helper.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
@@ skipping 148 matching lines @@
       base::TimeDelta required_quiescence_duration_before_long_idle_period)
       : IdleHelper(scheduler_helper,
                    this,
                    "test.idle",
                    TRACE_DISABLED_BY_DEFAULT("test.idle"),
                    "TestSchedulerIdlePeriod",
                    required_quiescence_duration_before_long_idle_period) {}
 
   ~IdleHelperForTest() override {}
 
-  // SchedulerHelperDelegate implementation:
+  // IdleHelper::Delegate implementation:
   MOCK_METHOD2(CanEnterLongIdlePeriod,
                bool(base::TimeTicks now,
                     base::TimeDelta* next_long_idle_period_delay_out));
 
   MOCK_METHOD0(IsNotQuiescent, void());
   MOCK_METHOD0(OnIdlePeriodStarted, void());
   MOCK_METHOD0(OnIdlePeriodEnded, void());
 };
 
 class BaseIdleHelperTest : public testing::Test {
@@ skipping 97 matching lines @@
 
   base::TimeTicks CurrentIdleTaskDeadline() {
     return idle_helper_->CurrentIdleTaskDeadline();
   }
 
   void CheckIdlePeriodStateIs(const char* expected) {
     EXPECT_STREQ(expected, IdleHelper::IdlePeriodStateToString(
                                idle_helper_->SchedulerIdlePeriodState()));
   }
 
+  const scoped_refptr<TaskQueue>& idle_queue() const {
+    return idle_helper_->idle_queue_;
+  }
+
   std::unique_ptr<base::SimpleTestTickClock> clock_;
   // Only one of mock_task_runner_ or message_loop_ will be set.
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
   std::unique_ptr<base::MessageLoop> message_loop_;
 
   scoped_refptr<SchedulerTqmDelegate> main_task_runner_;
   std::unique_ptr<SchedulerHelper> scheduler_helper_;
   std::unique_ptr<IdleHelperForTest> idle_helper_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
@@ skipping 776 matching lines @@
   EXPECT_TRUE(shutdown_task_run);
   EXPECT_EQ(0, run_count);
 
   // Shutdown immediately after idle period started should prevent the idle
   // task from running.
   idle_helper_->Shutdown();
   mock_task_runner_->RunUntilIdle();
   EXPECT_EQ(0, run_count);
 }
 
+TEST_F(IdleHelperTest, TestPostDelayedIdleTask) {
+  int run_count = 0;
+  base::TimeTicks expected_deadline =
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(2300);
+  base::TimeTicks deadline_in_task;
+
+  // Posting a delayed idle task should not post anything on the underlying
+  // task queue until the delay is up.
+  idle_task_runner_->PostDelayedIdleTask(
+      FROM_HERE, base::TimeDelta::FromMilliseconds(200),
+      base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
+  EXPECT_EQ(0u, idle_queue()->GetNumberOfPendingTasks());
+
+  clock_->Advance(base::TimeDelta::FromMilliseconds(100));
+
+  // It shouldn't run until the delay is over even though we went idle.
+  idle_helper_->StartIdlePeriod(
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      expected_deadline);
+  EXPECT_EQ(0u, idle_queue()->GetNumberOfPendingTasks());
+  RunUntilIdle();
+  EXPECT_EQ(0, run_count);
+
+  clock_->Advance(base::TimeDelta::FromMilliseconds(100));
+  idle_helper_->StartIdlePeriod(
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      expected_deadline);
+  EXPECT_EQ(1u, idle_queue()->GetNumberOfPendingTasks());
+  RunUntilIdle();
+
+  EXPECT_EQ(1, run_count);
+  EXPECT_EQ(expected_deadline, deadline_in_task);
+}
+
 }  // namespace scheduler
 }  // namespace blink