[scheduler] Add WakeupBudgetPool.

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc

Index: third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc b/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc
index 1814fbc11b6df73dcc1a8097b6e4b9ba3ec370a8..d0a67843e506fda4d30e15ff8f744993a7ef3e27 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc
@@ -201,7 +201,7 @@ TEST_F(TaskQueueThrottlerTest, TimerAlignment) {
 
   mock_task_runner_->RunUntilIdle();
 
-  // Times are aligned to a multipple of 1000 milliseconds.
+  // Times are aligned to a multiple of 1000 milliseconds.
   EXPECT_THAT(
       run_times,
       ElementsAre(
@@ -1055,5 +1055,131 @@ TEST_F(TaskQueueThrottlerTest, TwoBudgetPools) {
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(26000)));
 }
 
+namespace {
+void RunChainedTask(size_t run_times_count,
+                    scoped_refptr<TaskQueue> queue,
+                    base::SimpleTestTickClock* clock,
+                    base::TimeDelta task_duration,
+                    std::vector<base::TimeTicks>* run_times) {
+  run_times->push_back(clock->NowTicks());
+  clock->Advance(task_duration);
+
+  if (run_times_count <= 1)
+    return;
+
+  queue->PostTask(FROM_HERE,
+                  base::Bind(&RunChainedTask, run_times_count - 1, queue, clock,
+                             task_duration, run_times));
+}
+
+void RunChainedDelayedTask(size_t run_times_count,
+                           scoped_refptr<TaskQueue> queue,
+                           base::SimpleTestTickClock* clock,
+                           base::TimeDelta task_duration,
+                           std::vector<base::TimeTicks>* run_times,
+                           base::TimeDelta delay) {
+  run_times->push_back(clock->NowTicks());
+  clock->Advance(task_duration);
+
+  if (run_times_count <= 1)
+    return;
+
+  queue->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&RunChainedDelayedTask, run_times_count - 1, queue, clock,
+                 task_duration, run_times, delay),
+      delay);
+}
+}  // namespace
+
+TEST_F(TaskQueueThrottlerTest,
+       WakeUpBasedThrottling_ChainedTasks_Instantaneous) {
+  scheduler_->GetWakeUpBudgetPoolForTesting()->SetWakeUpDuration(
+      base::TimeDelta::FromMilliseconds(10));
+  std::vector<base::TimeTicks> run_times;
+
+  task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get());
+
+  timer_queue_->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&RunChainedTask, 10, timer_queue_, clock_.get(),

[Sami, 2017/04/26 13:09:08]

Should we make this 10 larger to check that we only run the allowed set of
tasks?

[altimin, 2017/04/26 14:31:30]

I'm not quite sure what you mean here. There tasks take 0 time and will not be
throttled. See the next test if it is the thing you want.

[Sami, 2017/04/27 12:12:30]

Ah yes, you're right.

+                 base::TimeDelta(), &run_times),
+      base::TimeDelta::FromMilliseconds(100));
+
+  mock_task_runner_->RunUntilIdle();
+
+  EXPECT_THAT(run_times,
+              ElementsAre(base::TimeTicks() + base::TimeDelta::FromSeconds(1),
+                          base::TimeTicks() + base::TimeDelta::FromSeconds(1),
+                          base::TimeTicks() + base::TimeDelta::FromSeconds(1),
+                          base::TimeTicks() + base::TimeDelta::FromSeconds(1),
+                          base::TimeTicks() + base::TimeDelta::FromSeconds(1),
+                          base::TimeTicks() + base::TimeDelta::FromSeconds(1),
+                          base::TimeTicks() + base::TimeDelta::FromSeconds(1),
+                          base::TimeTicks() + base::TimeDelta::FromSeconds(1),
+                          base::TimeTicks() + base::TimeDelta::FromSeconds(1),
+                          base::TimeTicks() + base::TimeDelta::FromSeconds(1)));
+}
+
+TEST_F(TaskQueueThrottlerTest, WakeUpBasedThrottling_ImmediateTasks_Fast) {
+  scheduler_->GetWakeUpBudgetPoolForTesting()->SetWakeUpDuration(
+      base::TimeDelta::FromMilliseconds(10));
+  std::vector<base::TimeTicks> run_times;
+
+  task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get());
+
+  timer_queue_->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&RunChainedTask, 10, timer_queue_, clock_.get(),
+                 base::TimeDelta::FromMilliseconds(3), &run_times),
+      base::TimeDelta::FromMilliseconds(100));
+
+  mock_task_runner_->RunUntilIdle();
+
+  // TODO(altimin): Add fence mechanism to block immediate tasks.

[Sami, 2017/04/26 13:09:08]

Just curious, how do interleaved immediate tasks work in the current design?
They just run immediately?

[altimin, 2017/04/26 14:31:30]

The fence is installed, but it is too late, so one immediate task can run (at
1012 and 2012 milliseconds in this example). 

+  EXPECT_THAT(
+      run_times,
+      ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(1000),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(1003),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(1006),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(1009),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(1012),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(2000),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(2003),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(2006),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(2009),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(2012)));
+}
+
+TEST_F(TaskQueueThrottlerTest, WakeUpBasedThrottling_DelayedTasks) {
+  scheduler_->GetWakeUpBudgetPoolForTesting()->SetWakeUpDuration(
+      base::TimeDelta::FromMilliseconds(10));
+  std::vector<base::TimeTicks> run_times;
+
+  task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get());
+
+  timer_queue_->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&RunChainedDelayedTask, 10, timer_queue_, clock_.get(),
+                 base::TimeDelta(), &run_times,
+                 base::TimeDelta::FromMilliseconds(3)),
+      base::TimeDelta::FromMilliseconds(100));
+
+  mock_task_runner_->RunUntilIdle();
+
+  EXPECT_THAT(
+      run_times,
+      ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(1000),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(1003),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(1006),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(1009),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(2000),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(2003),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(2006),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(2009),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(3000),
+                  base::TimeTicks() + base::TimeDelta::FromMilliseconds(3003)));
+}
+
 }  // namespace scheduler
 }  // namespace blink