[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"
@@ skipping 19 matching lines @@
 // 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 100 matching lines @@
       idle_time_estimator(compositor_task_runner,
                           time_source,
                           kShortIdlePeriodDurationSampleCount,
                           kShortIdlePeriodDurationPercentile),
       background_main_thread_load_tracker(
           now,
           base::Bind(&ReportBackgroundRendererTaskLoad)),
       foreground_main_thread_load_tracker(
           now,
           base::Bind(&ReportForegroundRendererTaskLoad)),
+      audio_playback_switch(
+          renderer_scheduler_impl->ControlTaskRunner().get(),
+          base::TimeDelta::FromSeconds(
+              kThrottlingDelayAfterAudioIsPlayedInSeconds),
+          base::Bind(&RendererSchedulerImpl::OnAudioStartedImpl,
+                     // We can't get weak pointer to renderer_scheduler here
+                     // but this callback is guaranteed to be called while
+                     // |audio_playback_switch| is alive, which guarantees that
+                     // renderer_scheduler is still alive.
+                     base::Unretained(renderer_scheduler_impl)),

[Sami, 2016/09/29 13:36:07]

Could we instead change things so that we can get a weak pointer here?  We could
construct the factory earlier for instance.

[altimin, 2016/09/29 16:29:43]

Note: per Chromium style guide weak pointer factory should be last member of the
class and you will get a lot of complains from compiler.

+          base::Bind(&RendererSchedulerImpl::OnAudioStoppedImpl,
+                     base::Unretained(renderer_scheduler_impl))),
       current_use_case(UseCase::NONE),
       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),
@@ skipping 299 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::OnAudioStarted() {
+  MainThreadOnly().audio_playback_switch.Enable();

[Sami, 2016/09/29 13:36:07]

These could use trace events I think.

+}
+
+void RendererSchedulerImpl::OnAudioStopped() {
+  MainThreadOnly().audio_playback_switch.Disable();
+}
+
 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 699 matching lines @@
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValue(helper_.scheduler_tqm_delegate()->NowTicks()));
 }
 
 void RendererSchedulerImpl::CreateTraceEventObjectSnapshotLocked() const {
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValueLocked(helper_.scheduler_tqm_delegate()->NowTicks()));
 }
 
+void RendererSchedulerImpl::OnAudioStartedImpl() {

[alex clarke (OOO till 29th), 2016/09/29 11:16:53]

I don't think we need these two functions, why not bind
task_queue_throttler()->SetIsAudioActive directly?

[altimin, 2016/09/29 16:29:43]

Done.

+  task_queue_throttler()->SetIsAudioActive(true);
+}
+
+void RendererSchedulerImpl::OnAudioStoppedImpl() {
+  task_queue_throttler()->SetIsAudioActive(false);
+}
+
 // static
 const char* RendererSchedulerImpl::ExpensiveTaskPolicyToString(
     ExpensiveTaskPolicy expensive_task_policy) {
   switch (expensive_task_policy) {
     case ExpensiveTaskPolicy::RUN:
       return "RUN";
     case ExpensiveTaskPolicy::BLOCK:
       return "BLOCK";
     case ExpensiveTaskPolicy::THROTTLE:
       return "THROTTLE";
@@ skipping 370 matching lines @@
     case v8::PERFORMANCE_LOAD:
       return "load";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink