[scheduler] Throttle background frames with 1% CPU limit

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 70 matching lines @@
 TaskQueueThrottler::TimeBudgetPool::~TimeBudgetPool() {}
 
 void TaskQueueThrottler::TimeBudgetPool::SetTimeBudget(base::TimeTicks now,
                                                        double cpu_percentage) {
   Advance(now);
   cpu_percentage_ = cpu_percentage;
 }
 
 void TaskQueueThrottler::TimeBudgetPool::AddQueue(base::TimeTicks now,
                                                   TaskQueue* queue) {
-  Metadata& metadata = task_queue_throttler_->queue_details_[queue];
+  std::pair<TaskQueueMap::iterator, bool> insert_result =
+      task_queue_throttler_->queue_details_.insert(
+          std::make_pair(queue, Metadata(0, queue->IsQueueEnabled())));
+  Metadata& metadata = insert_result.first->second;
   DCHECK(!metadata.time_budget_pool);
   metadata.time_budget_pool = this;
 
   associated_task_queues_.insert(queue);
 
-  if (!metadata.IsThrottled())
+  if (!is_enabled_ || !metadata.IsThrottled())
     return;
 
   queue->SetQueueEnabled(false);
 
   task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, now, queue,
                                                 GetNextAllowedRunTime());
 }
 
 void TaskQueueThrottler::TimeBudgetPool::RemoveQueue(base::TimeTicks now,
                                                      TaskQueue* queue) {
   auto find_it = task_queue_throttler_->queue_details_.find(queue);
   DCHECK(find_it != task_queue_throttler_->queue_details_.end() &&
          find_it->second.time_budget_pool == this);
   find_it->second.time_budget_pool = nullptr;
   bool is_throttled = find_it->second.IsThrottled();
 
   task_queue_throttler_->MaybeDeleteQueueMetadata(find_it);
   associated_task_queues_.erase(queue);
 
-  if (is_throttled)
+  if (!is_enabled_ || !is_throttled)
     return;
 
   task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, now, queue,
                                                 base::nullopt);
 }
 
 void TaskQueueThrottler::TimeBudgetPool::EnableThrottling(LazyNow* lazy_now) {
   if (is_enabled_)
     return;
   is_enabled_ = true;
@@ skipping 131 matching lines @@
 void TaskQueueThrottler::SetQueueEnabled(TaskQueue* task_queue, bool enabled) {
   TaskQueueMap::iterator find_it = queue_details_.find(task_queue);
 
   if (find_it == queue_details_.end()) {
     task_queue->SetQueueEnabled(enabled);
     return;
   }
 
   find_it->second.enabled = enabled;
 
-  if (!find_it->second.IsThrottled())
+  if (!find_it->second.IsThrottled()) {
+    task_queue->SetQueueEnabled(enabled);
     return;
+  }
 
   // We don't enable the queue here because it's throttled and there might be
   // tasks in it's work queue that would execute immediatly rather than after
   // PumpThrottledTasks runs.
   if (!enabled) {
     task_queue->SetQueueEnabled(false);
     MaybeSchedulePumpQueue(FROM_HERE, tick_clock_->NowTicks(), task_queue,
                            base::nullopt);
   }
 }
@@ skipping 285 matching lines @@
   return std::max(now, time_budget_pool->GetNextAllowedRunTime());
 }
 
 void TaskQueueThrottler::MaybeDeleteQueueMetadata(TaskQueueMap::iterator it) {
   if (!it->second.IsThrottled() && !it->second.time_budget_pool)
     queue_details_.erase(it);
 }
 
 }  // namespace scheduler
 }  // namespace blink