[scheduler] Add WakeupBudgetPool.

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

Index: third_party/WebKit/Source/platform/scheduler/renderer/cpu_time_budget_pool.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool.cc b/third_party/WebKit/Source/platform/scheduler/renderer/cpu_time_budget_pool.cc
similarity index 64%
copy from third_party/WebKit/Source/platform/scheduler/renderer/budget_pool.cc
copy to third_party/WebKit/Source/platform/scheduler/renderer/cpu_time_budget_pool.cc
index 0c68389330d7536300990bcd877a32a3f2acf551..1dca8de9028b7ff01db6798eb26e5b8516d6ae33 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/cpu_time_budget_pool.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "platform/scheduler/renderer/budget_pool.h"
+#include "platform/scheduler/renderer/cpu_time_budget_pool.h"
 
 #include <cstdint>
 
@@ -11,13 +11,7 @@
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "base/strings/stringprintf.h"
-#include "platform/WebFrameScheduler.h"
-#include "platform/scheduler/base/real_time_domain.h"
-#include "platform/scheduler/child/scheduler_tqm_delegate.h"
-#include "platform/scheduler/renderer/renderer_scheduler_impl.h"
 #include "platform/scheduler/renderer/task_queue_throttler.h"
-#include "platform/scheduler/renderer/throttled_time_domain.h"
-#include "platform/scheduler/renderer/web_frame_scheduler_impl.h"
 
 namespace blink {
 namespace scheduler {
@@ -32,81 +26,6 @@ std::string PointerToId(void* pointer) {
 
 }  // namespace
 
-BudgetPool::BudgetPool(const char* name,
-                       BudgetPoolController* budget_pool_controller)
-    : name_(name),
-      budget_pool_controller_(budget_pool_controller),
-      is_enabled_(true) {}
-
-BudgetPool::~BudgetPool() {}
-
-const char* BudgetPool::Name() const {
-  return name_;
-}
-
-void BudgetPool::AddQueue(base::TimeTicks now, TaskQueue* queue) {
-  budget_pool_controller_->AddQueueToBudgetPool(queue, this);
-  associated_task_queues_.insert(queue);
-
-  if (!is_enabled_ || !budget_pool_controller_->IsThrottled(queue))
-    return;
-
-  budget_pool_controller_->BlockQueue(now, queue);
-}
-
-void BudgetPool::RemoveQueue(base::TimeTicks now, TaskQueue* queue) {
-  budget_pool_controller_->RemoveQueueFromBudgetPool(queue, this);
-  associated_task_queues_.erase(queue);
-
-  if (!is_enabled_ || !budget_pool_controller_->IsThrottled(queue))
-    return;
-
-  budget_pool_controller_->UnblockQueue(now, queue);
-}
-
-void BudgetPool::EnableThrottling(LazyNow* lazy_now) {
-  if (is_enabled_)
-    return;
-  is_enabled_ = true;
-
-  TRACE_EVENT0("renderer.scheduler", "BudgetPool_EnableThrottling");
-
-  BlockThrottledQueues(lazy_now->Now());
-}
-
-void BudgetPool::DisableThrottling(LazyNow* lazy_now) {
-  if (!is_enabled_)
-    return;
-  is_enabled_ = false;
-
-  TRACE_EVENT0("renderer.scheduler", "BudgetPool_DisableThrottling");
-
-  for (TaskQueue* queue : associated_task_queues_) {
-    if (!budget_pool_controller_->IsThrottled(queue))
-      continue;
-
-    budget_pool_controller_->UnblockQueue(lazy_now->Now(), queue);
-  }
-
-  // TODO(altimin): We need to disable TimeBudgetQueues here or they will
-  // regenerate extra time budget when they are disabled.
-}
-
-bool BudgetPool::IsThrottlingEnabled() const {
-  return is_enabled_;
-}
-
-void BudgetPool::Close() {
-  DCHECK_EQ(0u, associated_task_queues_.size());
-
-  budget_pool_controller_->UnregisterBudgetPool(this);
-}
-
-void BudgetPool::BlockThrottledQueues(base::TimeTicks now) {
-  for (TaskQueue* queue : associated_task_queues_)
-    budget_pool_controller_->BlockQueue(now, queue);
-}
-
 CPUTimeBudgetPool::CPUTimeBudgetPool(
     const char* name,
     BudgetPoolController* budget_pool_controller,
@@ -117,6 +36,10 @@ CPUTimeBudgetPool::CPUTimeBudgetPool(
 
 CPUTimeBudgetPool::~CPUTimeBudgetPool() {}
 
+QueueBlockType CPUTimeBudgetPool::GetBlockType() const {
+  return QueueBlockType::kAllTasks;
+}
+
 void CPUTimeBudgetPool::SetMaxBudgetLevel(
     base::TimeTicks now,
     base::Optional<base::TimeDelta> max_budget_level) {
@@ -159,11 +82,18 @@ void CPUTimeBudgetPool::SetReportingCallback(
   reporting_callback_ = reporting_callback;
 }
 
-bool CPUTimeBudgetPool::HasEnoughBudgetToRun(base::TimeTicks now) {
-  return now >= GetNextAllowedRunTime();
+bool CPUTimeBudgetPool::CanRunTasksAt(base::TimeTicks now,
+                                      bool is_wake_up) const {
+  return now >= GetNextAllowedRunTime(now);
+}
+
+bool CPUTimeBudgetPool::CanRunTasksUntil(base::TimeTicks now,
+                                         base::TimeTicks moment) const {
+  return CanRunTasksAt(now, false);

[Sami, 2017/04/29 17:43:02]

I think this is slightly misleading: I would expect CanRanTasksUntil to return
true until the point at which the budget becomes negative. To do that we would
need to look at |moment| which we're not doing here. Should we do that?

[altimin, 2017/05/02 18:16:58]

Scrapped CanRunTasksUntil completely.

 }
 
-base::TimeTicks CPUTimeBudgetPool::GetNextAllowedRunTime() {
+base::TimeTicks CPUTimeBudgetPool::GetNextAllowedRunTime(
+    base::TimeTicks desired_run_time) const {
   if (!is_enabled_ || current_budget_level_.InMicroseconds() >= 0) {
     return last_checkpoint_;
   } else {
@@ -174,7 +104,8 @@ base::TimeTicks CPUTimeBudgetPool::GetNextAllowedRunTime() {
   }
 }
 
-void CPUTimeBudgetPool::RecordTaskRunTime(base::TimeTicks start_time,
+void CPUTimeBudgetPool::RecordTaskRunTime(TaskQueue* queue,
+                                          base::TimeTicks start_time,
                                           base::TimeTicks end_time) {
   DCHECK_LE(start_time, end_time);
   Advance(end_time);
@@ -188,8 +119,20 @@ void CPUTimeBudgetPool::RecordTaskRunTime(base::TimeTicks start_time,
       reporting_callback_.Run(-current_budget_level_ / cpu_percentage_);
     }
   }
+
+  if (current_budget_level_.InSecondsF() < 0)
+    BlockThrottledQueues(end_time);
 }
 
+void CPUTimeBudgetPool::OnQueueNextWakeUpChanged(
+    TaskQueue* queue,
+    base::TimeTicks now,
+    base::TimeTicks desired_run_time) {
+  budget_pool_controller_->UpdateQueueThrottlingState(now, queue);
+}
+
+void CPUTimeBudgetPool::OnWakeUp(base::TimeTicks now) {}
+
 void CPUTimeBudgetPool::AsValueInto(base::trace_event::TracedValue* state,
                                     base::TimeTicks now) const {
   state->BeginDictionary(name_);