Revert of [scheduler] Teach scheduler about audio state

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"
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "base/strings/stringprintf.h"
 #include "platform/scheduler/base/real_time_domain.h"
 #include "platform/scheduler/child/scheduler_tqm_delegate.h"
+#include "platform/scheduler/renderer/auto_advancing_virtual_time_domain.h"
 #include "platform/scheduler/renderer/renderer_scheduler_impl.h"
 #include "platform/scheduler/renderer/throttled_time_domain.h"
 #include "platform/scheduler/renderer/web_frame_scheduler_impl.h"
 #include "public/platform/WebFrameScheduler.h"
 
 namespace blink {
 namespace scheduler {
 
 namespace {
 constexpr base::TimeDelta kMaxBudgetLevel = base::TimeDelta::FromSeconds(1);
@@ skipping 116 matching lines @@
     return;
   is_enabled_ = false;
 
   for (TaskQueue* queue : associated_task_queues_) {
     if (!task_queue_throttler_->IsThrottled(queue))
       continue;
 
     task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, lazy_now->Now(),
                                                   queue, base::nullopt);
   }
-
-  // TODO(altimin): We need to disable TimeBudgetQueues here or they will
-  // regenerate extra time budget when they are disabled.
 }
 
 bool TaskQueueThrottler::TimeBudgetPool::IsThrottlingEnabled() const {
   return is_enabled_;
 }
 
 void TaskQueueThrottler::TimeBudgetPool::Close() {
   DCHECK_EQ(0u, associated_task_queues_.size());
 
   task_queue_throttler_->time_budget_pools_.erase(this);
@@ skipping 91 matching lines @@
 TaskQueueThrottler::TaskQueueThrottler(
     RendererSchedulerImpl* renderer_scheduler,
     const char* tracing_category)
     : task_runner_(renderer_scheduler->ControlTaskRunner()),
       renderer_scheduler_(renderer_scheduler),
       tick_clock_(renderer_scheduler->tick_clock()),
       tracing_category_(tracing_category),
       time_domain_(new ThrottledTimeDomain(this, tracing_category)),
       max_budget_level_(kMaxBudgetLevel),
       max_throttling_duration_(kMaxThrottlingDuration),
-      allow_throttling_(true),
+      virtual_time_(false),
       weak_factory_(this) {
   pump_throttled_tasks_closure_.Reset(base::Bind(
       &TaskQueueThrottler::PumpThrottledTasks, weak_factory_.GetWeakPtr()));
   forward_immediate_work_callback_ =
       base::Bind(&TaskQueueThrottler::OnTimeDomainHasImmediateWork,
                  weak_factory_.GetWeakPtr());
 
   renderer_scheduler_->RegisterTimeDomain(time_domain_.get());
 }
 
@@ skipping 32 matching lines @@
   if (!enabled) {
     task_queue->SetQueueEnabled(false);
     MaybeSchedulePumpQueue(FROM_HERE, tick_clock_->NowTicks(), task_queue,
                            base::nullopt);
   }
 }
 
 void TaskQueueThrottler::IncreaseThrottleRefCount(TaskQueue* task_queue) {
   DCHECK_NE(task_queue, task_runner_.get());
 
+  if (virtual_time_)
+    return;
+
   std::pair<TaskQueueMap::iterator, bool> insert_result =
       queue_details_.insert(std::make_pair(task_queue, Metadata()));
 
   if (!insert_result.first->second.IsThrottled()) {
     // The insert was successful so we need to throttle the queue.
     insert_result.first->second.enabled = task_queue->IsQueueEnabled();
 
-    if (allow_throttling_) {
-      task_queue->SetTimeDomain(time_domain_.get());
-      task_queue->RemoveFence();
-      task_queue->SetQueueEnabled(false);
+    task_queue->SetTimeDomain(time_domain_.get());
+    task_queue->RemoveFence();
+    task_queue->SetQueueEnabled(false);
 
-      if (!task_queue->IsEmpty()) {
-        if (task_queue->HasPendingImmediateWork()) {
-          OnTimeDomainHasImmediateWork(task_queue);
-        } else {
-          OnTimeDomainHasDelayedWork(task_queue);
-        }
+    if (!task_queue->IsEmpty()) {
+      if (task_queue->HasPendingImmediateWork()) {
+        OnTimeDomainHasImmediateWork(task_queue);
+      } else {
+        OnTimeDomainHasDelayedWork(task_queue);
       }
     }
 
     TRACE_EVENT1(tracing_category_, "TaskQueueThrottler_TaskQueueThrottled",
                  "task_queue", task_queue);
   }
 
   insert_result.first->second.throttling_ref_count++;
 }
 
 void TaskQueueThrottler::DecreaseThrottleRefCount(TaskQueue* task_queue) {
+  if (virtual_time_)
+    return;
+
   TaskQueueMap::iterator iter = queue_details_.find(task_queue);
 
   if (iter != queue_details_.end() &&
       --iter->second.throttling_ref_count == 0) {
     bool enabled = iter->second.enabled;
 
     MaybeDeleteQueueMetadata(iter);
 
-    if (allow_throttling_) {
-      task_queue->SetTimeDomain(renderer_scheduler_->real_time_domain());
-      task_queue->RemoveFence();
-      task_queue->SetQueueEnabled(enabled);
-    }
+    task_queue->SetTimeDomain(renderer_scheduler_->real_time_domain());
+    task_queue->RemoveFence();
+    task_queue->SetQueueEnabled(enabled);
 
     TRACE_EVENT1(tracing_category_, "TaskQueueThrottler_TaskQueueUntrottled",
                  "task_queue", task_queue);
   }
 }
 
 bool TaskQueueThrottler::IsThrottled(TaskQueue* task_queue) const {
   auto find_it = queue_details_.find(task_queue);
   if (find_it == queue_details_.end())
     return false;
@@ skipping 100 matching lines @@
     base::TimeTicks unthrottled_runtime) {
   const base::TimeDelta one_second = base::TimeDelta::FromSeconds(1);
   return unthrottled_runtime + one_second -
          ((unthrottled_runtime - base::TimeTicks()) % one_second);
 }
 
 void TaskQueueThrottler::MaybeSchedulePumpThrottledTasks(
     const tracked_objects::Location& from_here,
     base::TimeTicks now,
     base::TimeTicks unaligned_runtime) {
-  if (!allow_throttling_)
+  if (virtual_time_)
     return;
 
   base::TimeTicks runtime =
       std::max(now, AlignedThrottledRunTime(unaligned_runtime));
 
   // If there is a pending call to PumpThrottledTasks and it's sooner than
   // |runtime| then return.
   if (pending_pump_throttled_tasks_runtime_ &&
       runtime >= pending_pump_throttled_tasks_runtime_.value()) {
     return;
   }
 
   pending_pump_throttled_tasks_runtime_ = runtime;
 
   pump_throttled_tasks_closure_.Cancel();
 
   base::TimeDelta delay = pending_pump_throttled_tasks_runtime_.value() - now;
   TRACE_EVENT1(tracing_category_,
                "TaskQueueThrottler::MaybeSchedulePumpThrottledTasks",
                "delay_till_next_pump_ms", delay.InMilliseconds());
   task_runner_->PostDelayedTask(
       from_here, pump_throttled_tasks_closure_.callback(), delay);
 }
 
+void TaskQueueThrottler::EnableVirtualTime() {
+  virtual_time_ = true;
+
+  pump_throttled_tasks_closure_.Cancel();
+
+  for (auto it = queue_details_.begin(); it != queue_details_.end();) {
+    TaskQueue* task_queue = it->first;
+    bool enabled = it->second.enabled;
+
+    if (!it->second.time_budget_pool) {
+      it = queue_details_.erase(it);
+    } else {
+      // Fall back to default values.
+      it->second.throttling_ref_count = 0;
+      it->second.enabled = false;
+      it++;
+    }
+
+    task_queue->SetTimeDomain(renderer_scheduler_->GetVirtualTimeDomain());
+    task_queue->RemoveFence();
+    task_queue->SetQueueEnabled(enabled);
+  }
+}
+
 TaskQueueThrottler::TimeBudgetPool* TaskQueueThrottler::CreateTimeBudgetPool(
     const char* name) {
   TimeBudgetPool* time_budget_pool =
       new TimeBudgetPool(name, this, tick_clock_->NowTicks(), max_budget_level_,
                          max_throttling_duration_);
   time_budget_pools_[time_budget_pool] = base::WrapUnique(time_budget_pool);
   return time_budget_pool;
 }
 
 void TaskQueueThrottler::OnTaskRunTimeReported(TaskQueue* task_queue,
@@ skipping 57 matching lines @@
   if (!time_budget_pool)
     return now;
   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);
 }
 
-void TaskQueueThrottler::DisableThrottling() {
-  if (!allow_throttling_)
-    return;
-
-  allow_throttling_ = false;
-
-  for (const auto& map_entry : queue_details_) {
-    if (!map_entry.second.IsThrottled())
-      continue;
-
-    TaskQueue* queue = map_entry.first;
-
-    queue->SetTimeDomain(renderer_scheduler_->GetActiveTimeDomain());
-
-    queue->RemoveFence();
-    queue->SetQueueEnabled(map_entry.second.enabled);
-  }
-}
-
-void TaskQueueThrottler::EnableThrottling() {
-  if (allow_throttling_)
-    return;
-
-  allow_throttling_ = true;
-
-  LazyNow lazy_now(tick_clock_);
-
-  for (const auto& map_entry : queue_details_) {
-    if (!map_entry.second.IsThrottled())
-      continue;
-
-    TaskQueue* queue = map_entry.first;
-
-    queue->SetQueueEnabled(false);
-    queue->SetTimeDomain(time_domain_.get());
-    MaybeSchedulePumpQueue(FROM_HERE, lazy_now.Now(), queue,
-                           GetNextAllowedRunTime(lazy_now.Now(), queue));
-  }
-}
-
 }  // namespace scheduler
 }  // namespace blink