Revert "[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) {
-  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;
+  Metadata& metadata = task_queue_throttler_->queue_details_[queue];
   DCHECK(!metadata.time_budget_pool);
   metadata.time_budget_pool = this;
 
   associated_task_queues_.insert(queue);
 
-  if (!is_enabled_ || !metadata.IsThrottled())
+  if (!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_enabled_ || !is_throttled)
+  if (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 438 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