[scheduler] Support adding one queue to multiple budget pools

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

Index: third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc b/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc
index 4b49ef2afaaf0d99ff2b3f00f9d80b3e5ed05734..96cbe6b7179f30e462bbc91d58d38e8cfd89f161 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc
@@ -176,8 +176,9 @@ void TaskQueueThrottler::UnregisterTaskQueue(TaskQueue* task_queue) {
   if (find_it == queue_details_.end())
     return;
 
-  if (find_it->second.budget_pool)
-    find_it->second.budget_pool->RemoveQueue(lazy_now.Now(), task_queue);
+  for (BudgetPool* budget_pool : find_it->second.budget_pools) {

[Sami, 2017/03/17 11:18:39]

budget_pools is being modified while we iterate it -- is that okay?

[altimin, 2017/03/17 14:35:42]

Very well spotted, thanks. (Bigger problem is that iterator may have been
invalidated after the cycle).

+    budget_pool->RemoveQueue(lazy_now.Now(), task_queue);
+  }
 
   queue_details_.erase(find_it);
 }
@@ -325,13 +326,15 @@ void TaskQueueThrottler::OnTaskRunTimeReported(TaskQueue* task_queue,
   if (!IsThrottled(task_queue))
     return;
 
-  BudgetPool* budget_pool = GetBudgetPoolForQueue(task_queue);
-  if (!budget_pool)
+  auto find_it = queue_details_.find(task_queue);

[alex clarke (OOO till 29th), 2017/03/16 19:12:01]

I tend to write exactly that too but I wonder if this should really be const
auto& find_it = ...  or we may get unexpected copy operations.

[altimin, 2017/03/16 19:14:25]

It's an iterator, copying them is cheap.

+  if (find_it == queue_details_.end())
     return;
 
-  budget_pool->RecordTaskRunTime(start_time, end_time);
-  if (!budget_pool->HasEnoughBudgetToRun(end_time))
-    budget_pool->BlockThrottledQueues(end_time);
+  for (BudgetPool* budget_pool : find_it->second.budget_pools) {
+    budget_pool->RecordTaskRunTime(start_time, end_time);
+    if (!budget_pool->HasEnoughBudgetToRun(end_time))
+      budget_pool->BlockThrottledQueues(end_time);
+  }
 }
 
 void TaskQueueThrottler::BlockQueue(base::TimeTicks now, TaskQueue* queue) {
@@ -378,17 +381,20 @@ void TaskQueueThrottler::AddQueueToBudgetPool(TaskQueue* queue,
 
   Metadata& metadata = insert_result.first->second;
 
-  DCHECK(!metadata.budget_pool);
-  metadata.budget_pool = budget_pool;
+  DCHECK(metadata.budget_pools.find(budget_pool) ==
+         metadata.budget_pools.end());
+
+  metadata.budget_pools.insert(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_pools.find(budget_pool) !=
+             find_it->second.budget_pools.end());
 
-  find_it->second.budget_pool = nullptr;
+  find_it->second.budget_pools.erase(budget_pool);
 
   MaybeDeleteQueueMetadata(find_it);
 }
@@ -420,23 +426,24 @@ void TaskQueueThrottler::SchedulePumpQueue(
   MaybeSchedulePumpThrottledTasks(from_here, now, next_run_time.value());
 }
 
-BudgetPool* TaskQueueThrottler::GetBudgetPoolForQueue(TaskQueue* queue) {
+base::TimeTicks TaskQueueThrottler::GetNextAllowedRunTime(base::TimeTicks now,
+                                                          TaskQueue* queue) {
+  base::TimeTicks next_run_time = now;
+
   auto find_it = queue_details_.find(queue);
   if (find_it == queue_details_.end())
-    return nullptr;
-  return find_it->second.budget_pool;
-}
+    return next_run_time;
 
-base::TimeTicks TaskQueueThrottler::GetNextAllowedRunTime(base::TimeTicks now,
-                                                          TaskQueue* queue) {
-  BudgetPool* budget_pool = GetBudgetPoolForQueue(queue);
-  if (!budget_pool)
-    return now;
-  return std::max(now, budget_pool->GetNextAllowedRunTime());
+  for (BudgetPool* budget_pool : find_it->second.budget_pools) {
+    next_run_time =
+        std::max(next_run_time, budget_pool->GetNextAllowedRunTime());
+  }
+
+  return next_run_time;
 }
 
 void TaskQueueThrottler::MaybeDeleteQueueMetadata(TaskQueueMap::iterator it) {
-  if (it->second.throttling_ref_count == 0 && !it->second.budget_pool)
+  if (it->second.throttling_ref_count == 0 && it->second.budget_pools.empty())
     queue_details_.erase(it);
 }