[scheduler] Add WakeupBudgetPool.

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

Index: third_party/WebKit/Source/platform/scheduler/renderer/budget_pool_unittest.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool_unittest.cc b/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool_unittest.cc
index a02778d4a2388e0e17f4f089aadf983a1bf8ada2..d31d49cb48dc22328bb506ae3bbd3456b6dc139a 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool_unittest.cc
@@ -17,7 +17,9 @@
 #include "platform/scheduler/base/test_time_source.h"
 #include "platform/scheduler/child/scheduler_tqm_delegate_for_test.h"
 #include "platform/scheduler/renderer/budget_pool.h"
+#include "platform/scheduler/renderer/cpu_time_budget_pool.h"
 #include "platform/scheduler/renderer/renderer_scheduler_impl.h"
+#include "platform/scheduler/renderer/wake_up_budget_pool.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -38,6 +40,7 @@ class BudgetPoolTest : public testing::Test {
         mock_task_runner_, base::MakeUnique<TestTimeSource>(clock_.get()));
     scheduler_.reset(new RendererSchedulerImpl(delegate_));
     task_queue_throttler_ = scheduler_->task_queue_throttler();
+    start_time_ = clock_->NowTicks();
   }
 
   void TearDown() override {
@@ -45,12 +48,21 @@ class BudgetPoolTest : public testing::Test {
     scheduler_.reset();
   }
 
+  base::TimeTicks MillisecondsAfterStart(int milliseconds) {
+    return start_time_ + base::TimeDelta::FromMilliseconds(milliseconds);
+  }
+
+  base::TimeTicks SecondsAfterStart(int seconds) {
+    return start_time_ + base::TimeDelta::FromSeconds(seconds);
+  }
+
  protected:
   std::unique_ptr<base::SimpleTestTickClock> clock_;
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
   scoped_refptr<SchedulerTqmDelegate> delegate_;
   std::unique_ptr<RendererSchedulerImpl> scheduler_;
   TaskQueueThrottler* task_queue_throttler_;  // NOT OWNED
+  base::TimeTicks start_time_;
 
   DISALLOW_COPY_AND_ASSIGN(BudgetPoolTest);
 };
@@ -59,33 +71,28 @@ TEST_F(BudgetPoolTest, CPUTimeBudgetPool) {
   CPUTimeBudgetPool* pool =
       task_queue_throttler_->CreateCPUTimeBudgetPool("test");
 
-  base::TimeTicks time_zero = clock_->NowTicks();
+  pool->SetTimeBudgetRecoveryRate(SecondsAfterStart(0), 0.1);
 
-  pool->SetTimeBudgetRecoveryRate(time_zero, 0.1);
-
-  EXPECT_TRUE(pool->HasEnoughBudgetToRun(time_zero));
-  EXPECT_EQ(time_zero, pool->GetNextAllowedRunTime());
+  EXPECT_TRUE(pool->CanRunTasksAt(SecondsAfterStart(0), false));
+  EXPECT_EQ(SecondsAfterStart(0),
+            pool->GetNextAllowedRunTime(SecondsAfterStart(0)));
 
   // Run an expensive task and make sure that we're throttled.
-  pool->RecordTaskRunTime(time_zero,
-                          time_zero + base::TimeDelta::FromMilliseconds(100));
+  pool->RecordTaskRunTime(nullptr, SecondsAfterStart(0),
+                          MillisecondsAfterStart(100));
 
-  EXPECT_FALSE(pool->HasEnoughBudgetToRun(
-      time_zero + base::TimeDelta::FromMilliseconds(500)));
-  EXPECT_EQ(time_zero + base::TimeDelta::FromMilliseconds(1000),
-            pool->GetNextAllowedRunTime());
-  EXPECT_TRUE(pool->HasEnoughBudgetToRun(
-      time_zero + base::TimeDelta::FromMilliseconds(1000)));
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(500), false));
+  EXPECT_EQ(MillisecondsAfterStart(1000),
+            pool->GetNextAllowedRunTime(SecondsAfterStart(0)));
+  EXPECT_TRUE(pool->CanRunTasksAt(MillisecondsAfterStart(1000), false));
 
   // Run a cheap task and make sure that it doesn't affect anything.
-  EXPECT_TRUE(pool->HasEnoughBudgetToRun(
-      time_zero + base::TimeDelta::FromMilliseconds(2000)));
-  pool->RecordTaskRunTime(time_zero + base::TimeDelta::FromMilliseconds(2000),
-                          time_zero + base::TimeDelta::FromMilliseconds(2020));
-  EXPECT_TRUE(pool->HasEnoughBudgetToRun(
-      time_zero + base::TimeDelta::FromMilliseconds(2020)));
-  EXPECT_EQ(time_zero + base::TimeDelta::FromMilliseconds(2020),
-            pool->GetNextAllowedRunTime());
+  EXPECT_TRUE(pool->CanRunTasksAt(MillisecondsAfterStart(2000), false));
+  pool->RecordTaskRunTime(nullptr, MillisecondsAfterStart(2000),
+                          MillisecondsAfterStart(2020));
+  EXPECT_TRUE(pool->CanRunTasksAt(MillisecondsAfterStart(2020), false));
+  EXPECT_EQ(MillisecondsAfterStart(2020),
+            pool->GetNextAllowedRunTime(SecondsAfterStart(0)));
 
   pool->Close();
 }
@@ -94,35 +101,90 @@ TEST_F(BudgetPoolTest, CPUTimeBudgetPoolMinBudgetLevelToRun) {
   CPUTimeBudgetPool* pool =
       task_queue_throttler_->CreateCPUTimeBudgetPool("test");
 
-  base::TimeTicks time_zero = clock_->NowTicks();
-
-  pool->SetMinBudgetLevelToRun(time_zero,
+  pool->SetMinBudgetLevelToRun(SecondsAfterStart(0),
                                base::TimeDelta::FromMilliseconds(10));
-  pool->SetTimeBudgetRecoveryRate(time_zero, 0.1);
+  pool->SetTimeBudgetRecoveryRate(SecondsAfterStart(0), 0.1);
 
-  EXPECT_TRUE(pool->HasEnoughBudgetToRun(time_zero));
-  EXPECT_EQ(time_zero, pool->GetNextAllowedRunTime());
+  EXPECT_TRUE(pool->CanRunTasksAt(SecondsAfterStart(0), false));
+  EXPECT_EQ(SecondsAfterStart(0),
+            pool->GetNextAllowedRunTime(SecondsAfterStart(0)));
 
-  pool->RecordTaskRunTime(time_zero,
-                          time_zero + base::TimeDelta::FromMilliseconds(10));
-  EXPECT_FALSE(pool->HasEnoughBudgetToRun(
-      time_zero + base::TimeDelta::FromMilliseconds(15)));
-  EXPECT_FALSE(pool->HasEnoughBudgetToRun(
-      time_zero + base::TimeDelta::FromMilliseconds(150)));
+  pool->RecordTaskRunTime(nullptr, SecondsAfterStart(0),
+                          MillisecondsAfterStart(10));
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(15), false));
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(150), false));
   // We need to wait extra 100ms to get budget of 10ms.
-  EXPECT_EQ(time_zero + base::TimeDelta::FromMilliseconds(200),
-            pool->GetNextAllowedRunTime());
+  EXPECT_EQ(MillisecondsAfterStart(200),
+            pool->GetNextAllowedRunTime(SecondsAfterStart(0)));
 
-  pool->RecordTaskRunTime(time_zero + base::TimeDelta::FromMilliseconds(200),
-                          time_zero + base::TimeDelta::FromMilliseconds(205));
+  pool->RecordTaskRunTime(nullptr, MillisecondsAfterStart(200),
+                          MillisecondsAfterStart(205));
   // We can run when budget is non-negative even when it less than 10ms.
-  EXPECT_EQ(time_zero + base::TimeDelta::FromMilliseconds(205),
-            pool->GetNextAllowedRunTime());
+  EXPECT_EQ(MillisecondsAfterStart(205),
+            pool->GetNextAllowedRunTime(SecondsAfterStart(0)));
+
+  pool->RecordTaskRunTime(nullptr, MillisecondsAfterStart(205),
+                          MillisecondsAfterStart(215));
+  EXPECT_EQ(MillisecondsAfterStart(350),
+            pool->GetNextAllowedRunTime(SecondsAfterStart(0)));
+}
 
-  pool->RecordTaskRunTime(time_zero + base::TimeDelta::FromMilliseconds(205),
-                          time_zero + base::TimeDelta::FromMilliseconds(215));
-  EXPECT_EQ(time_zero + base::TimeDelta::FromMilliseconds(350),
-            pool->GetNextAllowedRunTime());
+TEST_F(BudgetPoolTest, WakeUpBudgetPool) {
+  WakeUpBudgetPool* pool =
+      task_queue_throttler_->CreateWakeUpBudgetPool("test");
+
+  scoped_refptr<TaskQueue> queue =
+      scheduler_->NewTimerTaskQueue(TaskQueue::QueueType::TEST);
+
+  pool->SetWakeUpRate(0.1);
+  pool->SetWakeUpDuration(base::TimeDelta::FromMilliseconds(10));
+
+  // Can't run tasks until a wake-up.
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(0), false));
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(5), false));
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(9), false));
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(10), false));
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(11), false));
+
+  pool->OnWakeUp(MillisecondsAfterStart(0));
+
+  EXPECT_TRUE(pool->CanRunTasksAt(MillisecondsAfterStart(0), false));
+  EXPECT_TRUE(pool->CanRunTasksAt(MillisecondsAfterStart(5), false));
+  EXPECT_TRUE(pool->CanRunTasksAt(MillisecondsAfterStart(9), false));
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(10), false));
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(11), false));
+
+  // GetNextAllowedRunTime should return the desired time when in the
+  // wakeup window and return the next wakeup otherwise.
+  EXPECT_EQ(start_time_, pool->GetNextAllowedRunTime(start_time_));
+  EXPECT_EQ(SecondsAfterStart(10) - base::TimeDelta::FromMicroseconds(1),
+            pool->GetNextAllowedRunTime(MillisecondsAfterStart(15)));
+
+  pool->RecordTaskRunTime(queue.get(), MillisecondsAfterStart(5),
+                          MillisecondsAfterStart(7));
+
+  // Make sure that nothing changes after a task inside wakeup window.
+  EXPECT_TRUE(pool->CanRunTasksAt(MillisecondsAfterStart(0), false));
+  EXPECT_TRUE(pool->CanRunTasksAt(MillisecondsAfterStart(5), false));
+  EXPECT_TRUE(pool->CanRunTasksAt(MillisecondsAfterStart(9), false));
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(10), false));
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(11), false));
+  EXPECT_EQ(start_time_, pool->GetNextAllowedRunTime(start_time_));
+  EXPECT_EQ(SecondsAfterStart(10) - base::TimeDelta::FromMicroseconds(1),
+            pool->GetNextAllowedRunTime(MillisecondsAfterStart(15)));
+
+  pool->OnWakeUp(MillisecondsAfterStart(12005));
+  pool->RecordTaskRunTime(queue.get(), MillisecondsAfterStart(12005),
+                          MillisecondsAfterStart(12007));
+
+  EXPECT_TRUE(pool->CanRunTasksAt(MillisecondsAfterStart(12005), false));
+  EXPECT_TRUE(pool->CanRunTasksAt(MillisecondsAfterStart(12007), false));
+  EXPECT_TRUE(pool->CanRunTasksAt(MillisecondsAfterStart(12014), false));
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(12015), false));
+  EXPECT_FALSE(pool->CanRunTasksAt(MillisecondsAfterStart(12016), false));
+  EXPECT_EQ(
+      MillisecondsAfterStart(22005) - base::TimeDelta::FromMicroseconds(1),
+      pool->GetNextAllowedRunTime(SecondsAfterStart(13)));
 }
 
 }  // namespace scheduler