[scheduler] Add WakeupBudgetPool.

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_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/renderer/task_queue_throttler.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 183 matching lines @@
                                 base::TimeDelta::FromMilliseconds(1200.0));
 
   timer_queue_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&TestTask, &run_times, clock_.get()),
                                 base::TimeDelta::FromMilliseconds(8300.0));
 
   task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get());
 
   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(
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(1000.0),
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(1000.0),
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(2000.0),
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(9000.0)));
 }
 
 TEST_F(TaskQueueThrottlerTest, TimerAlignment_Unthrottled) {
@@ skipping 833 matching lines @@
 
   EXPECT_THAT(
       run_times,
       ElementsAre(
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(1000),
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(3000),
           base::TimeTicks() + base::TimeDelta::FromMilliseconds(6000),
           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