[scheduler] Refactor common code into BudgetPool.

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

Index: third_party/WebKit/Source/platform/scheduler/renderer/budget_pool.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool.cc b/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool.cc
index 79f632565378ae94c53621f1ebb3b7b3e18d36e6..0c68389330d7536300990bcd877a32a3f2acf551 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool.cc
@@ -32,51 +32,19 @@ std::string PointerToId(void* pointer) {
 
 }  // namespace
 
-BudgetPool::~BudgetPool() {}
-
-CPUTimeBudgetPool::CPUTimeBudgetPool(
-    const char* name,
-    BudgetPoolController* budget_pool_controller,
-    base::TimeTicks now)
+BudgetPool::BudgetPool(const char* name,
+                       BudgetPoolController* budget_pool_controller)
     : name_(name),
       budget_pool_controller_(budget_pool_controller),
-      last_checkpoint_(now),
-      cpu_percentage_(1),
       is_enabled_(true) {}
 
-CPUTimeBudgetPool::~CPUTimeBudgetPool() {}
-
-void CPUTimeBudgetPool::SetMaxBudgetLevel(
-    base::TimeTicks now,
-    base::Optional<base::TimeDelta> max_budget_level) {
-  Advance(now);
-  max_budget_level_ = max_budget_level;
-  EnforceBudgetLevelRestrictions();
-}
-
-void CPUTimeBudgetPool::SetMaxThrottlingDelay(
-    base::TimeTicks now,
-    base::Optional<base::TimeDelta> max_throttling_delay) {
-  Advance(now);
-  max_throttling_delay_ = max_throttling_delay;
-  EnforceBudgetLevelRestrictions();
-}
-
-void CPUTimeBudgetPool::SetMinBudgetLevelToRun(
-    base::TimeTicks now,
-    base::TimeDelta min_budget_level_to_run) {
-  Advance(now);
-  min_budget_level_to_run_ = min_budget_level_to_run;
-}
+BudgetPool::~BudgetPool() {}
 
-void CPUTimeBudgetPool::SetTimeBudgetRecoveryRate(base::TimeTicks now,
-                                                  double cpu_percentage) {
-  Advance(now);
-  cpu_percentage_ = cpu_percentage;
-  EnforceBudgetLevelRestrictions();
+const char* BudgetPool::Name() const {
+  return name_;
 }
 
-void CPUTimeBudgetPool::AddQueue(base::TimeTicks now, TaskQueue* queue) {
+void BudgetPool::AddQueue(base::TimeTicks now, TaskQueue* queue) {
   budget_pool_controller_->AddQueueToBudgetPool(queue, this);
   associated_task_queues_.insert(queue);
 
@@ -86,7 +54,7 @@ void CPUTimeBudgetPool::AddQueue(base::TimeTicks now, TaskQueue* queue) {
   budget_pool_controller_->BlockQueue(now, queue);
 }
 
-void CPUTimeBudgetPool::RemoveQueue(base::TimeTicks now, TaskQueue* queue) {
+void BudgetPool::RemoveQueue(base::TimeTicks now, TaskQueue* queue) {
   budget_pool_controller_->RemoveQueueFromBudgetPool(queue, this);
   associated_task_queues_.erase(queue);
 
@@ -96,22 +64,22 @@ void CPUTimeBudgetPool::RemoveQueue(base::TimeTicks now, TaskQueue* queue) {
   budget_pool_controller_->UnblockQueue(now, queue);
 }
 
-void CPUTimeBudgetPool::EnableThrottling(LazyNow* lazy_now) {
+void BudgetPool::EnableThrottling(LazyNow* lazy_now) {
   if (is_enabled_)
     return;
   is_enabled_ = true;
 
-  TRACE_EVENT0("renderer.scheduler", "CPUTimeBudgetPool_EnableThrottling");
+  TRACE_EVENT0("renderer.scheduler", "BudgetPool_EnableThrottling");
 
   BlockThrottledQueues(lazy_now->Now());
 }
 
-void CPUTimeBudgetPool::DisableThrottling(LazyNow* lazy_now) {
+void BudgetPool::DisableThrottling(LazyNow* lazy_now) {
   if (!is_enabled_)
     return;
   is_enabled_ = false;
 
-  TRACE_EVENT0("renderer.scheduler", "CPUTimeBudgetPool_DisableThrottling");
+  TRACE_EVENT0("renderer.scheduler", "BudgetPool_DisableThrottling");
 
   for (TaskQueue* queue : associated_task_queues_) {
     if (!budget_pool_controller_->IsThrottled(queue))
@@ -124,10 +92,61 @@ void CPUTimeBudgetPool::DisableThrottling(LazyNow* lazy_now) {
   // regenerate extra time budget when they are disabled.
 }
 
-bool CPUTimeBudgetPool::IsThrottlingEnabled() const {
+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,
+    base::TimeTicks now)
+    : BudgetPool(name, budget_pool_controller),
+      last_checkpoint_(now),
+      cpu_percentage_(1) {}
+
+CPUTimeBudgetPool::~CPUTimeBudgetPool() {}
+
+void CPUTimeBudgetPool::SetMaxBudgetLevel(
+    base::TimeTicks now,
+    base::Optional<base::TimeDelta> max_budget_level) {
+  Advance(now);
+  max_budget_level_ = max_budget_level;
+  EnforceBudgetLevelRestrictions();
+}
+
+void CPUTimeBudgetPool::SetMaxThrottlingDelay(
+    base::TimeTicks now,
+    base::Optional<base::TimeDelta> max_throttling_delay) {
+  Advance(now);
+  max_throttling_delay_ = max_throttling_delay;
+  EnforceBudgetLevelRestrictions();
+}
+
+void CPUTimeBudgetPool::SetMinBudgetLevelToRun(
+    base::TimeTicks now,
+    base::TimeDelta min_budget_level_to_run) {
+  Advance(now);
+  min_budget_level_to_run_ = min_budget_level_to_run;
+}
+
+void CPUTimeBudgetPool::SetTimeBudgetRecoveryRate(base::TimeTicks now,
+                                                  double cpu_percentage) {
+  Advance(now);
+  cpu_percentage_ = cpu_percentage;
+  EnforceBudgetLevelRestrictions();
+}
+
 void CPUTimeBudgetPool::GrantAdditionalBudget(base::TimeTicks now,
                                               base::TimeDelta budget_level) {
   Advance(now);
@@ -140,12 +159,6 @@ void CPUTimeBudgetPool::SetReportingCallback(
   reporting_callback_ = reporting_callback;
 }
 
-void CPUTimeBudgetPool::Close() {
-  DCHECK_EQ(0u, associated_task_queues_.size());
-
-  budget_pool_controller_->UnregisterBudgetPool(this);
-}
-
 bool CPUTimeBudgetPool::HasEnoughBudgetToRun(base::TimeTicks now) {
   return now >= GetNextAllowedRunTime();
 }
@@ -177,10 +190,6 @@ void CPUTimeBudgetPool::RecordTaskRunTime(base::TimeTicks start_time,
   }
 }
 
-const char* CPUTimeBudgetPool::Name() const {
-  return name_;
-}
-
 void CPUTimeBudgetPool::AsValueInto(base::trace_event::TracedValue* state,
                                     base::TimeTicks now) const {
   state->BeginDictionary(name_);
@@ -223,11 +232,6 @@ void CPUTimeBudgetPool::Advance(base::TimeTicks now) {
   }
 }
 
-void CPUTimeBudgetPool::BlockThrottledQueues(base::TimeTicks now) {
-  for (TaskQueue* queue : associated_task_queues_)
-    budget_pool_controller_->BlockQueue(now, queue);
-}
-
 void CPUTimeBudgetPool::EnforceBudgetLevelRestrictions() {
   if (max_budget_level_) {
     current_budget_level_ =