[scheduler] Add WakeupBudgetPool.

third_party/WebKit/Source/platform/scheduler/renderer/budget_pool_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 20 matching lines @@
 
   void SetUp() override {
     clock_.reset(new base::SimpleTestTickClock());
     clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
     mock_task_runner_ =
         make_scoped_refptr(new cc::OrderedSimpleTaskRunner(clock_.get(), true));
     delegate_ = SchedulerTqmDelegateForTest::Create(
         mock_task_runner_, base::MakeUnique<TestTimeSource>(clock_.get()));
     scheduler_.reset(new RendererSchedulerImpl(delegate_));
     task_queue_throttler_ = scheduler_->task_queue_throttler();
+    time_zero_ = clock_->NowTicks();

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

I think start_time_  would be a better name.

[altimin, 2017/04/25 13:22:35]

Done.

   }
 
   void TearDown() override {
     scheduler_->Shutdown();
     scheduler_.reset();
   }
 
+  base::TimeTicks Milliseconds(int milliseconds) {

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

I'd prefer if this and the function below had  an AfterStart postfix.

[altimin, 2017/04/25 13:22:35]

Done.

+    return time_zero_ + base::TimeDelta::FromMilliseconds(milliseconds);
+  }
+
+  base::TimeTicks Seconds(int seconds) {
+    return time_zero_ + 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 time_zero_;
 
   DISALLOW_COPY_AND_ASSIGN(BudgetPoolTest);
 };
 
 TEST_F(BudgetPoolTest, CPUTimeBudgetPool) {
   CPUTimeBudgetPool* pool =
       task_queue_throttler_->CreateCPUTimeBudgetPool("test");
 
   base::TimeTicks time_zero = clock_->NowTicks();
 
   pool->SetTimeBudgetRecoveryRate(time_zero, 0.1);
 
-  EXPECT_TRUE(pool->HasEnoughBudgetToRun(time_zero));
-  EXPECT_EQ(time_zero, pool->GetNextAllowedRunTime());
+  EXPECT_TRUE(pool->CanRunTasksAt(time_zero));
+  EXPECT_EQ(time_zero, pool->GetNextAllowedRunTime(time_zero));
 
   // Run an expensive task and make sure that we're throttled.
-  pool->RecordTaskRunTime(time_zero,
+  pool->RecordTaskRunTime(nullptr, time_zero,
                           time_zero + base::TimeDelta::FromMilliseconds(100));
 
-  EXPECT_FALSE(pool->HasEnoughBudgetToRun(
-      time_zero + base::TimeDelta::FromMilliseconds(500)));
+  EXPECT_FALSE(
+      pool->CanRunTasksAt(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)));
+            pool->GetNextAllowedRunTime(time_zero));
+  EXPECT_TRUE(
+      pool->CanRunTasksAt(time_zero + base::TimeDelta::FromMilliseconds(1000)));
 
   // 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),
+  EXPECT_TRUE(
+      pool->CanRunTasksAt(time_zero + base::TimeDelta::FromMilliseconds(2000)));
+  pool->RecordTaskRunTime(nullptr,
+                          time_zero + base::TimeDelta::FromMilliseconds(2000),
                           time_zero + base::TimeDelta::FromMilliseconds(2020));
-  EXPECT_TRUE(pool->HasEnoughBudgetToRun(
-      time_zero + base::TimeDelta::FromMilliseconds(2020)));
+  EXPECT_TRUE(
+      pool->CanRunTasksAt(time_zero + base::TimeDelta::FromMilliseconds(2020)));
   EXPECT_EQ(time_zero + base::TimeDelta::FromMilliseconds(2020),
-            pool->GetNextAllowedRunTime());
+            pool->GetNextAllowedRunTime(time_zero));
 
   pool->Close();
 }
 
 TEST_F(BudgetPoolTest, CPUTimeBudgetPoolMinBudgetLevelToRun) {
   CPUTimeBudgetPool* pool =
       task_queue_throttler_->CreateCPUTimeBudgetPool("test");
 
   base::TimeTicks time_zero = clock_->NowTicks();
 
   pool->SetMinBudgetLevelToRun(time_zero,
                                base::TimeDelta::FromMilliseconds(10));
   pool->SetTimeBudgetRecoveryRate(time_zero, 0.1);
 
-  EXPECT_TRUE(pool->HasEnoughBudgetToRun(time_zero));
-  EXPECT_EQ(time_zero, pool->GetNextAllowedRunTime());
+  EXPECT_TRUE(pool->CanRunTasksAt(time_zero));
+  EXPECT_EQ(time_zero, pool->GetNextAllowedRunTime(time_zero));
 
-  pool->RecordTaskRunTime(time_zero,
+  pool->RecordTaskRunTime(nullptr, 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)));
+  EXPECT_FALSE(
+      pool->CanRunTasksAt(time_zero + base::TimeDelta::FromMilliseconds(15)));
+  EXPECT_FALSE(
+      pool->CanRunTasksAt(time_zero + base::TimeDelta::FromMilliseconds(150)));
   // We need to wait extra 100ms to get budget of 10ms.
   EXPECT_EQ(time_zero + base::TimeDelta::FromMilliseconds(200),
-            pool->GetNextAllowedRunTime());
+            pool->GetNextAllowedRunTime(time_zero));
 
-  pool->RecordTaskRunTime(time_zero + base::TimeDelta::FromMilliseconds(200),
+  pool->RecordTaskRunTime(nullptr,
+                          time_zero + base::TimeDelta::FromMilliseconds(200),
                           time_zero + base::TimeDelta::FromMilliseconds(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());
+            pool->GetNextAllowedRunTime(time_zero));
 
-  pool->RecordTaskRunTime(time_zero + base::TimeDelta::FromMilliseconds(205),
+  pool->RecordTaskRunTime(nullptr,
+                          time_zero + base::TimeDelta::FromMilliseconds(205),
                           time_zero + base::TimeDelta::FromMilliseconds(215));
   EXPECT_EQ(time_zero + base::TimeDelta::FromMilliseconds(350),
-            pool->GetNextAllowedRunTime());
+            pool->GetNextAllowedRunTime(time_zero));
+}
+
+TEST_F(BudgetPoolTest, WakeupBudgetPool) {
+  WakeupBudgetPool* pool =
+      task_queue_throttler_->CreateWakeupBudgetPool("test");
+
+  scoped_refptr<TaskQueue> queue =
+      scheduler_->NewTimerTaskRunner(TaskQueue::QueueType::TEST);
+
+  pool->SetWakeupRate(time_zero_, 0.1);
+  pool->SetWakeupDuration(time_zero_, base::TimeDelta::FromMilliseconds(10));
+
+  EXPECT_TRUE(pool->CanRunTasksAt(Milliseconds(0)));
+  EXPECT_TRUE(pool->CanRunTasksAt(Milliseconds(5)));
+  EXPECT_TRUE(pool->CanRunTasksAt(Milliseconds(9)));
+  EXPECT_FALSE(pool->CanRunTasksAt(Milliseconds(10)));
+  EXPECT_FALSE(pool->CanRunTasksAt(Milliseconds(11)));
+
+  // GetNextAllowedRunTime should return the desired time when in the
+  // wakeup window and return the next wakeup otherwise.
+  EXPECT_EQ(time_zero_, pool->GetNextAllowedRunTime(time_zero_));
+  EXPECT_EQ(Seconds(10) - base::TimeDelta::FromMicroseconds(1),
+            pool->GetNextAllowedRunTime(Milliseconds(15)));
+
+  pool->RecordTaskRunTime(queue.get(), Milliseconds(5), Milliseconds(7));
+
+  // Make sure that nothing changes after a task inside wakeup window.
+  EXPECT_TRUE(pool->CanRunTasksAt(Milliseconds(0)));
+  EXPECT_TRUE(pool->CanRunTasksAt(Milliseconds(5)));
+  EXPECT_TRUE(pool->CanRunTasksAt(Milliseconds(9)));
+  EXPECT_FALSE(pool->CanRunTasksAt(Milliseconds(10)));
+  EXPECT_FALSE(pool->CanRunTasksAt(Milliseconds(11)));
+  EXPECT_EQ(time_zero_, pool->GetNextAllowedRunTime(time_zero_));
+  EXPECT_EQ(Seconds(10) - base::TimeDelta::FromMicroseconds(1),
+            pool->GetNextAllowedRunTime(Milliseconds(15)));
+
+  pool->OnWakeup(Milliseconds(12005));
+  pool->RecordTaskRunTime(queue.get(), Milliseconds(12005),
+                          Milliseconds(12007));
+
+  EXPECT_TRUE(pool->CanRunTasksAt(Milliseconds(12005)));
+  EXPECT_TRUE(pool->CanRunTasksAt(Milliseconds(12007)));
+  EXPECT_TRUE(pool->CanRunTasksAt(Milliseconds(12014)));
+  EXPECT_FALSE(pool->CanRunTasksAt(Milliseconds(12015)));
+  EXPECT_FALSE(pool->CanRunTasksAt(Milliseconds(12016)));
+  EXPECT_EQ(Milliseconds(22005) - base::TimeDelta::FromMicroseconds(1),
+            pool->GetNextAllowedRunTime(Seconds(13)));
 }
 
 }  // namespace scheduler
 }  // namespace blink