[scheduler] Untangle BudgetPool from TaskQueueThrottler.

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.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 <cstdint>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 158 matching lines @@
   return find_it->second.throttling_ref_count > 0;
 }
 
 void TaskQueueThrottler::UnregisterTaskQueue(TaskQueue* task_queue) {
   LazyNow lazy_now(tick_clock_);
   auto find_it = queue_details_.find(task_queue);
 
   if (find_it == queue_details_.end())
     return;
 
-  if (find_it->second.time_budget_pool)
-    find_it->second.time_budget_pool->RemoveQueue(lazy_now.Now(), task_queue);
+  if (find_it->second.budget_pool)
+    find_it->second.budget_pool->RemoveQueue(lazy_now.Now(), task_queue);
 
   queue_details_.erase(find_it);
 }
 
 void TaskQueueThrottler::OnTimeDomainHasImmediateWork(TaskQueue* queue) {
   // Forward to the main thread if called from another thread
   if (!task_runner_->RunsTasksOnCurrentThread()) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(forward_immediate_work_callback_, queue));
     return;
@@ skipping 117 matching lines @@
       from_here, pump_throttled_tasks_closure_.callback(), delay);
 }
 
 CPUTimeBudgetPool* TaskQueueThrottler::CreateCPUTimeBudgetPool(
     const char* name,
     base::Optional<base::TimeDelta> max_budget_level,
     base::Optional<base::TimeDelta> max_throttling_duration) {
   CPUTimeBudgetPool* time_budget_pool =
       new CPUTimeBudgetPool(name, this, tick_clock_->NowTicks(),
                             max_budget_level, max_throttling_duration);
-  time_budget_pools_[time_budget_pool] = base::WrapUnique(time_budget_pool);
+  budget_pools_[time_budget_pool] = base::WrapUnique(time_budget_pool);
   return time_budget_pool;
 }
 
 void TaskQueueThrottler::OnTaskRunTimeReported(TaskQueue* task_queue,
                                                base::TimeTicks start_time,
                                                base::TimeTicks end_time) {
   if (!IsThrottled(task_queue))
     return;
 
-  CPUTimeBudgetPool* time_budget_pool = GetTimeBudgetPoolForQueue(task_queue);
-  if (!time_budget_pool)
+  BudgetPool* budget_pool = GetBudgetPoolForQueue(task_queue);
+  if (!budget_pool)
     return;
 
-  time_budget_pool->RecordTaskRunTime(start_time, end_time);
-  if (!time_budget_pool->HasEnoughBudgetToRun(end_time))
-    time_budget_pool->BlockThrottledQueues(end_time);
+  budget_pool->RecordTaskRunTime(start_time, end_time);
+  if (!budget_pool->HasEnoughBudgetToRun(end_time))
+    budget_pool->BlockThrottledQueues(end_time);
+}
+
+void TaskQueueThrottler::BlockThrottledQueue(base::TimeTicks now,
+                                             TaskQueue* queue) {
+  if (!IsThrottled(queue))
+    return;
+
+  queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
+  SchedulePumpQueue(FROM_HERE, now, queue);
 }
 
 void TaskQueueThrottler::AsValueInto(base::trace_event::TracedValue* state,
                                      base::TimeTicks now) const {
   if (pending_pump_throttled_tasks_runtime_) {
     state->SetDouble(
         "next_throttled_tasks_pump_in_seconds",
         (pending_pump_throttled_tasks_runtime_.value() - now).InSecondsF());
   }
 
   state->SetBoolean("allow_throttling", allow_throttling_);
 
   state->BeginDictionary("time_budget_pools");
-  for (const auto& map_entry : time_budget_pools_) {
+  for (const auto& map_entry : budget_pools_) {
     BudgetPool* pool = map_entry.first;
     pool->AsValueInto(state, now);
   }
   state->EndDictionary();
 
   state->BeginDictionary("queue_details");
   for (const auto& map_entry : queue_details_) {
     state->BeginDictionaryWithCopiedName(PointerToId(map_entry.first));
 
     state->SetInteger("throttling_ref_count",
                       map_entry.second.throttling_ref_count);
 
     state->EndDictionary();
   }
   state->EndDictionary();
 }
 
-CPUTimeBudgetPool* TaskQueueThrottler::GetTimeBudgetPoolForQueue(
+void TaskQueueThrottler::AddQueueToBudgetPool(TaskQueue* queue,
+                                              BudgetPool* budget_pool) {
+  std::pair<TaskQueueMap::iterator, bool> insert_result =
+      queue_details_.insert(std::make_pair(queue, Metadata()));
+
+  Metadata& metadata = insert_result.first->second;
+
+  DCHECK(!metadata.budget_pool);
+  metadata.budget_pool = budget_pool;
+}
+
+void TaskQueueThrottler::RemoveQueueFromBudgetPool(TaskQueue* queue,
+                                                   BudgetPool* budget_pool) {
+  auto find_it = queue_details_.find(queue);
+  DCHECK(find_it != queue_details_.end() &&
+         find_it->second.budget_pool == budget_pool);
+
+  find_it->second.budget_pool = nullptr;
+
+  MaybeDeleteQueueMetadata(find_it);
+}
+
+void TaskQueueThrottler::UnregisterBudgetPool(BudgetPool* budget_pool) {
+  budget_pools_.erase(budget_pool);
+}
+
+void TaskQueueThrottler::SchedulePumpQueue(
+    const tracked_objects::Location& from_here,
+    base::TimeTicks now,
     TaskQueue* queue) {
+  if (!IsThrottled(queue))
+    return;
+
+  LazyNow lazy_now(now);
+  base::Optional<base::TimeTicks> next_desired_run_time =
+      NextTaskRunTime(&lazy_now, queue);
+  if (!next_desired_run_time)
+    return;
+
+  base::Optional<base::TimeTicks> next_run_time =
+      Max(next_desired_run_time, GetNextAllowedRunTime(now, queue));
+
+  MaybeSchedulePumpThrottledTasks(from_here, now, next_run_time.value());
+}
+
+BudgetPool* TaskQueueThrottler::GetBudgetPoolForQueue(TaskQueue* queue) {
   auto find_it = queue_details_.find(queue);
   if (find_it == queue_details_.end())
     return nullptr;
-  return find_it->second.time_budget_pool;
-}
-
-void TaskQueueThrottler::MaybeSchedulePumpQueue(
-    const tracked_objects::Location& from_here,
-    base::TimeTicks now,
-    TaskQueue* queue,
-    base::Optional<base::TimeTicks> next_possible_run_time) {
-  LazyNow lazy_now(now);
-  base::Optional<base::TimeTicks> next_run_time =
-      Max(NextTaskRunTime(&lazy_now, queue), next_possible_run_time);
-
-  if (next_run_time) {
-    MaybeSchedulePumpThrottledTasks(from_here, now, next_run_time.value());
-  }
+  return find_it->second.budget_pool;
 }
 
 base::TimeTicks TaskQueueThrottler::GetNextAllowedRunTime(base::TimeTicks now,
                                                           TaskQueue* queue) {
-  CPUTimeBudgetPool* time_budget_pool = GetTimeBudgetPoolForQueue(queue);
-  if (!time_budget_pool)
+  BudgetPool* budget_pool = GetBudgetPoolForQueue(queue);
+  if (!budget_pool)
     return now;
-  return std::max(now, time_budget_pool->GetNextAllowedRunTime());
+  return std::max(now, budget_pool->GetNextAllowedRunTime());
 }
 
 void TaskQueueThrottler::MaybeDeleteQueueMetadata(TaskQueueMap::iterator it) {
-  if (it->second.throttling_ref_count == 0 && !it->second.time_budget_pool)
+  if (it->second.throttling_ref_count == 0 && !it->second.budget_pool)
     queue_details_.erase(it);
 }
 
 void TaskQueueThrottler::DisableThrottling() {
   if (!allow_throttling_)
     return;
 
   allow_throttling_ = false;
 
   for (const auto& map_entry : queue_details_) {
@@ skipping 24 matching lines @@
   for (const auto& map_entry : queue_details_) {
     if (map_entry.second.throttling_ref_count == 0)
       continue;
 
     TaskQueue* queue = map_entry.first;
 
     // Throttling is enabled and task queue should be blocked immediately
     // to enforce task alignment.
     queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
     queue->SetTimeDomain(time_domain_.get());
-    MaybeSchedulePumpQueue(FROM_HERE, lazy_now.Now(), queue,
-                           GetNextAllowedRunTime(lazy_now.Now(), queue));
+    SchedulePumpQueue(FROM_HERE, lazy_now.Now(), queue);
   }
 
   TRACE_EVENT0(tracing_category_, "TaskQueueThrottler_EnableThrottling");
 }
 
 }  // namespace scheduler
 }  // namespace blink