[Android] Suspend shared timers for hidden renderers

components/scheduler/renderer/renderer_scheduler_impl.h

 // 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.
 
 #ifndef COMPONENTS_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_
 #define COMPONENTS_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_
 
 #include "base/atomicops.h"
 #include "base/synchronization/lock.h"
 #include "components/scheduler/child/idle_helper.h"
@@ skipping 29 matching lines @@
   void BeginFrameNotExpectedSoon() override;
   void DidCommitFrameToCompositor() override;
   void DidHandleInputEventOnCompositorThread(
       const blink::WebInputEvent& web_input_event,
       InputEventState event_state) override;
   void DidHandleInputEventOnMainThread(
       const blink::WebInputEvent& web_input_event) override;
   void DidAnimateForInputOnCompositorThread() override;
   void OnRendererHidden() override;
   void OnRendererVisible() override;
+  void OnRendererBackgrounded() override;
+  void OnRendererForegrounded() override;
   void OnPageLoadStarted() override;
   bool IsHighPriorityWorkAnticipated() override;
   bool ShouldYieldForHighPriorityWork() override;
   bool CanExceedIdleDeadlineIfRequired() const override;
   void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer) override;
   void RemoveTaskObserver(
       base::MessageLoop::TaskObserver* task_observer) override;
   void Shutdown() override;
   void SuspendTimerQueue() override;
   void ResumeTimerQueue() override;
@@ skipping 38 matching lines @@
   // IdleHelper::Delegate implementation:
   bool CanEnterLongIdlePeriod(
       base::TimeTicks now,
       base::TimeDelta* next_long_idle_period_delay_out) override;
   void IsNotQuiescent() override {}
   void OnIdlePeriodStarted() override;
   void OnIdlePeriodEnded() override;
 
   void EndIdlePeriod();
 
+  void SuspendTimerQueueWhenBackgrounded();
+  void ResumeTimerQueueWhenForegrounded();
+
   // Returns the serialized scheduler state for tracing.
   scoped_refptr<base::trace_event::ConvertableToTraceFormat> AsValue(
       base::TimeTicks optional_now) const;
   scoped_refptr<base::trace_event::ConvertableToTraceFormat> AsValueLocked(
       base::TimeTicks optional_now) const;
   static const char* PolicyToString(Policy policy);
 
   static bool ShouldPrioritizeInputEvent(
       const blink::WebInputEvent& web_input_event);
 
   // The time we should stay in a priority-escalated mode after an input event.
   static const int kPriorityEscalationAfterInputMillis = 100;
 
   // The amount of time which idle periods can continue being scheduled when the
   // renderer has been hidden, before going to sleep for good.
   static const int kEndIdleWhenHiddenDelayMillis = 10000;
 
   // The amount of time for which loading tasks will be prioritized over
   // other tasks during the initial page load.
   static const int kRailsInitialLoadingPrioritizationMillis = 1000;
 
   // For the purposes of deciding whether or not it's safe to turn timers and
   // loading tasks on only in idle periods, we regard the system as being as
   // being "idle period" starved if there hasn't been an idle period in the last
   // 10 seconds. This was chosen to be long enough to cover most anticipated
   // user gestures.
   static const int kIdlePeriodStarvationThresholdMillis = 10000;
 
+#if defined(OS_ANDROID)
+  // The amount of time to wait after suspending shared timers after the
+  // renderer has been backgrounded.
+  static const int kSuspendTimersWhenBackgroundedDelayMillis = 5 * 60 * 1000;

[Sami, 2015/08/28 14:15:01]

Just thinking ahead to testing this, perhaps it would be better to have a
boolean enable that we can call where the scheduler is created? That way the
tests can make sure this works on regardless of the platform they're running on.

[jdduke (slow), 2015/08/31 18:36:08]

Done.

+#else
+  static const int kSuspendTimersWhenBackgroundedDelayMillis = -1;
+#endif
+
   // Schedules an immediate PolicyUpdate, if there isn't one already pending and
   // sets |policy_may_need_update_|. Note |any_thread_lock_| must be
   // locked.
   void EnsureUrgentPolicyUpdatePostedOnMainThread(
       const tracked_objects::Location& from_here);
 
   // Update the policy if a new signal has arrived. Must be called from the main
   // thread.
   void MaybeUpdatePolicy();
 
@@ skipping 40 matching lines @@
   IdleHelper idle_helper_;
 
   const scoped_refptr<TaskQueue> control_task_runner_;
   const scoped_refptr<TaskQueue> compositor_task_runner_;
   const scoped_refptr<TaskQueue> loading_task_runner_;
   const scoped_refptr<TaskQueue> timer_task_runner_;
 
   base::Closure update_policy_closure_;
   DeadlineTaskRunner delayed_update_policy_runner_;
   CancelableClosureHolder end_renderer_hidden_idle_period_closure_;
+  CancelableClosureHolder suspend_timers_when_backgrounded_closure_;
 
   // We have decided to improve thread safety at the cost of some boilerplate
   // (the accessors) for the following data members.
 
   struct MainThreadOnly {
     MainThreadOnly();
     ~MainThreadOnly();
 
     TaskCostEstimator timer_task_cost_estimator_;
     cc::RollingTimeDeltaHistory short_idle_period_duration_;
     Policy current_policy_;
     base::TimeTicks current_policy_expiration_time_;
     base::TimeTicks estimated_next_frame_begin_;
     base::TimeDelta expected_short_idle_period_duration_;
     int timer_queue_suspend_count_;  // TIMER_TASK_QUEUE suspended if non-zero.
     bool renderer_hidden_;
+    bool renderer_backgrounded_;
+    bool timer_queue_suspended_for_backgrounded_renderer_;
     bool was_shutdown_;
   };
 
   struct AnyThread {
     AnyThread();
 
     base::TimeTicks last_input_signal_time_;
     base::TimeTicks last_idle_period_end_time_;
     base::TimeTicks rails_loading_priority_deadline_;
     int pending_main_thread_input_event_count_;
@@ skipping 53 matching lines @@
 
   PollableThreadSafeFlag policy_may_need_update_;
   base::WeakPtrFactory<RendererSchedulerImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImpl);
 };
 
 }  // namespace scheduler
 
 #endif  // COMPONENTS_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_