[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 d3ef352f0bb74f49478fa55f5da49f9161e9c526..fc1f553f97207b7c07470748e1a70543d339c78b 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,7 +13,6 @@
 #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"
@@ -141,6 +140,9 @@ 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 {
@@ -231,7 +233,7 @@ TaskQueueThrottler::TaskQueueThrottler(
       tick_clock_(renderer_scheduler->tick_clock()),
       tracing_category_(tracing_category),
       time_domain_(new ThrottledTimeDomain(this, tracing_category)),
-      virtual_time_(false),
+      allow_throttling_(true),
       weak_factory_(this) {
   pump_throttled_tasks_closure_.Reset(base::Bind(
       &TaskQueueThrottler::PumpThrottledTasks, weak_factory_.GetWeakPtr()));
@@ -282,9 +284,6 @@ 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()));
 
@@ -292,15 +291,17 @@ 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();
 
-    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 (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);
+        }
       }
     }
 
@@ -312,9 +313,6 @@ 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() &&
@@ -323,9 +321,11 @@ void TaskQueueThrottler::DecreaseThrottleRefCount(TaskQueue* task_queue) {
 
     MaybeDeleteQueueMetadata(iter);
 
-    task_queue->SetTimeDomain(renderer_scheduler_->real_time_domain());
-    task_queue->RemoveFence();
-    task_queue->SetQueueEnabled(enabled);
+    if (allow_throttling_) {
+      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);
@@ -446,7 +446,7 @@ void TaskQueueThrottler::MaybeSchedulePumpThrottledTasks(
     const tracked_objects::Location& from_here,
     base::TimeTicks now,
     base::TimeTicks unaligned_runtime) {
-  if (virtual_time_)
+  if (!allow_throttling_)
     return;
 
   base::TimeTicks runtime =
@@ -471,30 +471,6 @@ 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 =
@@ -571,5 +547,45 @@ 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