[scheduler] Throttle default timer queue when renderer is backgrounded.

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 473 matching lines @@
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown() || MainThreadOnly().renderer_backgrounded)
     return;
 
   MainThreadOnly().renderer_backgrounded = true;
 
   base::TimeTicks now = tick_clock()->NowTicks();
   MainThreadOnly().foreground_main_thread_load_tracker.Pause(now);
   MainThreadOnly().background_main_thread_load_tracker.Resume(now);
 
+  task_queue_throttler()->IncreaseThrottleRefCount(

[alex clarke (OOO till 29th), 2016/12/06 18:20:12]

This is going to fight with UpdatePolicyLocked.

What you need to do (assuming Sami agrees this is a good idea - IIRC we
discussed this in the past and didn't do it for some reason) is:

1. Add this clause near the bottom of UpdatePolicyLocked:

if (MainThreadOnly().renderer_backgrounded) {
   new_policy.timer_queue_policy.time_domain_type = 
      TimeDomainType::THROTTLED;
}

2. Call ForceUpdatePolicy() in here and in OnRendererForegrounded

Note this needs to place nicely (i.e. not call ForceUpdatePolicy too often) with
SuspendTimerQueueWhenBackgrounded / ResumeTimerQueueWhenForegroundedOrResumed
which Jared added to suspend timers completely after 5 mins on android.

+      default_timer_task_runner_.get());
+
   if (!MainThreadOnly().timer_queue_suspension_when_backgrounded_enabled)
     return;
 
   suspend_timers_when_backgrounded_closure_.Cancel();
   base::TimeDelta suspend_timers_when_backgrounded_delay =
       base::TimeDelta::FromMilliseconds(
           kSuspendTimersWhenBackgroundedDelayMillis);
   control_task_runner_->PostDelayedTask(
       FROM_HERE, suspend_timers_when_backgrounded_closure_.callback(),
       suspend_timers_when_backgrounded_delay);
 }
 
 void RendererSchedulerImpl::OnRendererForegrounded() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnRendererForegrounded");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown() || !MainThreadOnly().renderer_backgrounded)
     return;
 
   MainThreadOnly().renderer_backgrounded = false;
   MainThreadOnly().renderer_suspended = false;
 
+  task_queue_throttler()->DecreaseThrottleRefCount(
+      default_timer_task_runner_.get());
+
   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();
   ResumeTimerQueueWhenForegroundedOrResumed();
 }
 
 void RendererSchedulerImpl::OnAudioStateChanged() {
   bool is_audio_playing = false;
@@ skipping 1282 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink