[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..340a6cb14aded78a806651fab08b6c490c92e8a1 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
@@ -141,6 +141,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 +234,9 @@ TaskQueueThrottler::TaskQueueThrottler(
       tick_clock_(renderer_scheduler->tick_clock()),
       tracing_category_(tracing_category),
       time_domain_(new ThrottledTimeDomain(this, tracing_category)),
+      is_throttling_disabled_(false),
       virtual_time_(false),
+      is_audio_active_(false),
       weak_factory_(this) {
   pump_throttled_tasks_closure_.Reset(base::Bind(
       &TaskQueueThrottler::PumpThrottledTasks, weak_factory_.GetWeakPtr()));
@@ -282,9 +287,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 +294,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 (!is_throttling_disabled_) {
+      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 +316,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 +324,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 (!is_throttling_disabled_) {
+      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 +449,7 @@ void TaskQueueThrottler::MaybeSchedulePumpThrottledTasks(
     const tracked_objects::Location& from_here,
     base::TimeTicks now,
     base::TimeTicks unaligned_runtime) {
-  if (virtual_time_)
+  if (is_throttling_disabled_)
     return;
 
   base::TimeTicks runtime =
@@ -473,26 +476,12 @@ void TaskQueueThrottler::MaybeSchedulePumpThrottledTasks(
 
 void TaskQueueThrottler::EnableVirtualTime() {
   virtual_time_ = true;
+  UpdateGlobalThrottlingSetting();
+}
 
-  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);
-  }
+void TaskQueueThrottler::SetIsAudioActive(bool is_audio_active) {
+  is_audio_active_ = is_audio_active;
+  UpdateGlobalThrottlingSetting();
 }
 
 TaskQueueThrottler::TimeBudgetPool* TaskQueueThrottler::CreateTimeBudgetPool(
@@ -571,5 +560,56 @@ void TaskQueueThrottler::MaybeDeleteQueueMetadata(TaskQueueMap::iterator it) {
     queue_details_.erase(it);
 }
 
+void TaskQueueThrottler::DisableThrottling() {
+  is_throttling_disabled_ = true;
+
+  for (const auto& map_entry : queue_details_) {
+    if (!map_entry.second.IsThrottled())
+      continue;
+
+    TaskQueue* queue = map_entry.first;
+
+    if (virtual_time_) {
+      queue->SetTimeDomain(renderer_scheduler_->GetVirtualTimeDomain());
+    } else {
+      queue->SetTimeDomain(renderer_scheduler_->real_time_domain());
+    }
+    queue->RemoveFence();
+    queue->SetQueueEnabled(map_entry.second.enabled);
+  }
+}
+
+void TaskQueueThrottler::EnableThrottling() {
+  is_throttling_disabled_ = false;
+
+  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));
+  }
+}
+
+void TaskQueueThrottler::UpdateGlobalThrottlingSetting() {
+  pump_throttled_tasks_closure_.Cancel();
+
+  bool should_disable_throttling = virtual_time_ || is_audio_active_;
+  if (should_disable_throttling == is_throttling_disabled_)
+    return;
+
+  if (should_disable_throttling) {
+    DisableThrottling();
+  } else {
+    EnableThrottling();
+  }
+}
+
 }  // namespace scheduler
 }  // namespace blink