[scheduler] Teach scheduler about audio state

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc

 // Copyright 2014 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/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/output/begin_frame_args.h"
+#include "platform/scheduler/base/real_time_domain.h"
 #include "platform/scheduler/base/task_queue_impl.h"
 #include "platform/scheduler/base/task_queue_selector.h"
 #include "platform/scheduler/base/virtual_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/task_queue_throttler.h"
 #include "platform/scheduler/renderer/web_view_scheduler_impl.h"
 #include "platform/scheduler/renderer/webthread_impl_for_renderer_scheduler.h"
 
 namespace blink {
 namespace scheduler {
 namespace {
 // The run time of loading tasks is strongly bimodal.  The vast majority are
 // very cheap, but there are usually a handful of very expensive tasks (e.g ~1
 // second on a mobile device) so we take a very pessimistic view when estimating
 // the cost of loading tasks.
 const int kLoadingTaskEstimationSampleCount = 1000;
 const double kLoadingTaskEstimationPercentile = 99;
 const int kTimerTaskEstimationSampleCount = 1000;
 const double kTimerTaskEstimationPercentile = 99;
 const int kShortIdlePeriodDurationSampleCount = 10;
 const double kShortIdlePeriodDurationPercentile = 50;
 // Amount of idle time left in a frame (as a ratio of the vsync interval) above
 // which main thread compositing can be considered fast.
 const double kFastCompositingIdleTimeThreshold = .2;
+// We do not throttle anything while audio is played and shortly after that.
+const int kThrottlingDelayAfterAudioIsPlayedInSeconds = 5;
 
 void ReportForegroundRendererTaskLoad(base::TimeTicks time, double load) {
   int load_percentage = static_cast<int>(load * 100);
   UMA_HISTOGRAM_PERCENTAGE("RendererScheduler.ForegroundRendererMainThreadLoad",
                            load_percentage);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.ForegroundRendererLoad", load_percentage);
 }
 
 void ReportBackgroundRendererTaskLoad(base::TimeTicks time, double load) {
@@ skipping 101 matching lines @@
                           time_source,
                           kShortIdlePeriodDurationSampleCount,
                           kShortIdlePeriodDurationPercentile),
       background_main_thread_load_tracker(
           now,
           base::Bind(&ReportBackgroundRendererTaskLoad)),
       foreground_main_thread_load_tracker(
           now,
           base::Bind(&ReportForegroundRendererTaskLoad)),
       current_use_case(UseCase::NONE),
+      throttling_delay_after_audio_is_played(base::TimeDelta::FromSeconds(
+          kThrottlingDelayAfterAudioIsPlayedInSeconds)),
       timer_queue_suspend_count(0),
       navigation_task_expected_count(0),
       expensive_task_policy(ExpensiveTaskPolicy::RUN),
       renderer_hidden(false),
       renderer_backgrounded(false),
       renderer_suspended(false),
       timer_queue_suspension_when_backgrounded_enabled(false),
       timer_queue_suspended_when_backgrounded(false),
       was_shutdown(false),
       loading_tasks_seem_expensive(false),
       timer_tasks_seem_expensive(false),
       touchstart_expected_soon(false),
       have_seen_a_begin_main_frame(false),
       have_reported_blocking_intervention_in_current_policy(false),
       have_reported_blocking_intervention_since_navigation(false),
       has_visible_render_widget_with_touch_handler(false),
       begin_frame_not_expected_soon(false),
       in_idle_period_for_testing(false),
       use_virtual_time(false),
+      is_audio_playing(false),
       rail_mode_observer(nullptr) {}
 
 RendererSchedulerImpl::MainThreadOnly::~MainThreadOnly() {}
 
 RendererSchedulerImpl::AnyThread::AnyThread()
     : awaiting_touch_start_response(false),
       in_idle_period(false),
       begin_main_frame_on_critical_path(false),
       last_gesture_was_compositor_driven(false),
       default_gesture_prevented(true),
@@ skipping 279 matching lines @@
   MainThreadOnly().renderer_suspended = false;
 
   base::TimeTicks now = tick_clock()->NowTicks();
   MainThreadOnly().foreground_main_thread_load_tracker.Resume(now);
   MainThreadOnly().background_main_thread_load_tracker.Pause(now);
 
   suspend_timers_when_backgrounded_closure_.Cancel();
   ResumeTimerQueueWhenForegrounded();
 }
 
+void RendererSchedulerImpl::OnAudioStateChanged() {
+  bool is_audio_playing = false;
+  for (WebViewSchedulerImpl* web_view_scheduler :
+       MainThreadOnly().web_view_schedulers) {
+    is_audio_playing = is_audio_playing || web_view_scheduler->IsAudioPlaying();
+  }
+
+  if (is_audio_playing == MainThreadOnly().is_audio_playing)
+    return;
+
+  MainThreadOnly().last_audio_state_change =
+      helper_.scheduler_tqm_delegate()->NowTicks();
+  MainThreadOnly().is_audio_playing = is_audio_playing;
+
+  UpdatePolicy();
+}
+
 void RendererSchedulerImpl::SuspendRenderer() {
   helper_.CheckOnValidThread();
   DCHECK(MainThreadOnly().renderer_backgrounded);
   if (helper_.IsShutdown())
     return;
   suspend_timers_when_backgrounded_closure_.Cancel();
   // TODO(hajimehoshi): We might need to suspend not only timer queue but also
   // e.g. loading tasks or postMessage.
   MainThreadOnly().renderer_suspended = true;
   SuspendTimerQueueWhenBackgrounded();
@@ skipping 310 matching lines @@
   // The |new_policy_duration| is the minimum of |expected_use_case_duration|
   // and |touchstart_expected_flag_valid_for_duration| unless one is zero in
   // which case we choose the other.
   base::TimeDelta new_policy_duration = expected_use_case_duration;
   if (new_policy_duration.is_zero() ||
       (touchstart_expected_flag_valid_for_duration > base::TimeDelta() &&
        new_policy_duration > touchstart_expected_flag_valid_for_duration)) {
     new_policy_duration = touchstart_expected_flag_valid_for_duration;
   }
 
+  // Do not throttle while audio is playing or for a short period after that
+  // to make sure that pages playing short audio clips powered by timers
+  // work.
+  if (MainThreadOnly().last_audio_state_change &&
+      !MainThreadOnly().is_audio_playing) {
+    base::TimeTicks audio_will_expire =
+        MainThreadOnly().last_audio_state_change.value() +
+        MainThreadOnly().throttling_delay_after_audio_is_played;
+
+    base::TimeDelta audio_will_expire_after = audio_will_expire - now;
+
+    if (audio_will_expire_after > base::TimeDelta()) {
+      if (new_policy_duration.is_zero()) {
+        new_policy_duration = audio_will_expire_after;
+      } else {
+        new_policy_duration =
+            std::min(new_policy_duration, audio_will_expire_after);
+      }
+    }
+  }
+
   if (new_policy_duration > base::TimeDelta()) {
     MainThreadOnly().current_policy_expiration_time = now + new_policy_duration;
     delayed_update_policy_runner_.SetDeadline(FROM_HERE, new_policy_duration,
                                               now);
   } else {
     MainThreadOnly().current_policy_expiration_time = base::TimeTicks();
   }
 
   // Avoid prioritizing main thread compositing (e.g., rAF) if it is extremely
   // slow, because that can cause starvation in other task sources.
@@ skipping 135 matching lines @@
   }
 
   if (MainThreadOnly().use_virtual_time) {
     new_policy.compositor_queue_policy.time_domain_type =
         TimeDomainType::VIRTUAL;
     new_policy.default_queue_policy.time_domain_type = TimeDomainType::VIRTUAL;
     new_policy.loading_queue_policy.time_domain_type = TimeDomainType::VIRTUAL;
     new_policy.timer_queue_policy.time_domain_type = TimeDomainType::VIRTUAL;
   }
 
+  new_policy.should_disable_throttling =
+      ShouldDisableThrottlingBecauseOfAudio(now) ||
+      MainThreadOnly().use_virtual_time;
+
   // Tracing is done before the early out check, because it's quite possible we
   // will otherwise miss this information in traces.
   CreateTraceEventObjectSnapshotLocked();
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "use_case",
                  use_case);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "rail_mode",
                  new_policy.rail_mode);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "touchstart_expected_soon",
                  MainThreadOnly().touchstart_expected_soon);
@@ skipping 35 matching lines @@
   // are mostly dispatched on the default queue) need to be preserved.
   ApplyTaskQueuePolicy(helper_.DefaultTaskRunner().get(),
                        MainThreadOnly().current_policy.default_queue_policy,
                        new_policy.default_queue_policy);
   if (MainThreadOnly().rail_mode_observer &&
       new_policy.rail_mode != MainThreadOnly().current_policy.rail_mode) {
     MainThreadOnly().rail_mode_observer->OnRAILModeChanged(
         new_policy.rail_mode);
   }
 
+  if (new_policy.should_disable_throttling !=
+      MainThreadOnly().current_policy.should_disable_throttling) {
+    if (new_policy.should_disable_throttling) {
+      task_queue_throttler()->DisableThrottling();
+    } else {
+      task_queue_throttler()->EnableThrottling();
+    }
+  }
+
   DCHECK(compositor_task_runner_->IsQueueEnabled());
   MainThreadOnly().current_policy = new_policy;
 }
 
 void RendererSchedulerImpl::ApplyTaskQueuePolicy(
     TaskQueue* task_queue,
     const TaskQueuePolicy& old_task_queue_policy,
     const TaskQueuePolicy& new_task_queue_policy) const {
   if (old_task_queue_policy.is_enabled != new_task_queue_policy.is_enabled) {
     task_queue_throttler_->SetQueueEnabled(task_queue,
@@ skipping 502 matching lines @@
 }
 
 void RendererSchedulerImpl::EnableVirtualTime() {
   MainThreadOnly().use_virtual_time = true;
 
   // The |unthrottled_task_runners_| are not actively managed by UpdatePolicy().
   AutoAdvancingVirtualTimeDomain* time_domain = GetVirtualTimeDomain();
   for (const scoped_refptr<TaskQueue>& task_queue : unthrottled_task_runners_)
     task_queue->SetTimeDomain(time_domain);
 
-  task_queue_throttler_->EnableVirtualTime();
+  ForceUpdatePolicy();
+}
 
-  ForceUpdatePolicy();
+bool RendererSchedulerImpl::ShouldDisableThrottlingBecauseOfAudio(
+    base::TimeTicks now) {
+  if (!MainThreadOnly().last_audio_state_change)
+    return false;
+
+  if (MainThreadOnly().is_audio_playing)
+    return true;
+
+  return MainThreadOnly().last_audio_state_change.value() +
+             MainThreadOnly().throttling_delay_after_audio_is_played >
+         now;
+}
+
+TimeDomain* RendererSchedulerImpl::GetActiveTimeDomain() {
+  if (MainThreadOnly().use_virtual_time) {
+    return GetVirtualTimeDomain();
+  } else {
+    return real_time_domain();
+  }
 }
 
 // static
 const char* RendererSchedulerImpl::UseCaseToString(UseCase use_case) {
   switch (use_case) {
     case UseCase::NONE:
       return "none";
     case UseCase::COMPOSITOR_GESTURE:
       return "compositor_gesture";
     case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING:
@@ skipping 24 matching lines @@
     case v8::PERFORMANCE_LOAD:
       return "load";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink