Revert of [scheduler] Teach scheduler about audio state

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 551c6c5fc530f3a4e93021a9fe296cb2ed683fa0..63ecf665dd52ad710f1d59ce6a828b24ea712209 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
@@ -13,6 +13,7 @@
 #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"
@@ -149,9 +150,6 @@ void TaskQueueThrottler::TimeBudgetPool::DisableThrottling(LazyNow* lazy_now) {
     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 {
@@ -263,7 +261,7 @@ TaskQueueThrottler::TaskQueueThrottler(
       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()));
@@ -316,6 +314,9 @@ void TaskQueueThrottler::SetQueueEnabled(TaskQueue* task_queue, bool enabled) {
 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()));
 
@@ -323,17 +324,15 @@ void TaskQueueThrottler::IncreaseThrottleRefCount(TaskQueue* task_queue) {
     // 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);
-
-      if (!task_queue->IsEmpty()) {
-        if (task_queue->HasPendingImmediateWork()) {
-          OnTimeDomainHasImmediateWork(task_queue);
-        } else {
-          OnTimeDomainHasDelayedWork(task_queue);
-        }
+    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);
       }
     }
 
@@ -345,6 +344,9 @@ void TaskQueueThrottler::IncreaseThrottleRefCount(TaskQueue* task_queue) {
 }
 
 void TaskQueueThrottler::DecreaseThrottleRefCount(TaskQueue* task_queue) {
+  if (virtual_time_)
+    return;
+
   TaskQueueMap::iterator iter = queue_details_.find(task_queue);
 
   if (iter != queue_details_.end() &&
@@ -353,11 +355,9 @@ void TaskQueueThrottler::DecreaseThrottleRefCount(TaskQueue* task_queue) {
 
     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);
@@ -478,7 +478,7 @@ 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 =
@@ -503,6 +503,30 @@ void TaskQueueThrottler::MaybeSchedulePumpThrottledTasks(
       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 =
@@ -580,45 +604,5 @@ void TaskQueueThrottler::MaybeDeleteQueueMetadata(TaskQueueMap::iterator it) {
     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