[content]: Add support for long idle times in the Blink Scheduler.

content/renderer/scheduler/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 CONTENT_RENDERER_SCHEDULER_RENDERER_SCHEDULER_IMPL_H_
 #define CONTENT_RENDERER_SCHEDULER_RENDERER_SCHEDULER_IMPL_H_
 
 #include "base/atomicops.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
@@ skipping 93 matching lines @@
   static const char* InputStreamStateToString(InputStreamState state);
 
   static InputStreamState ComputeNewInputStreamState(
       InputStreamState current_state,
       blink::WebInputEvent::Type new_input_event,
       blink::WebInputEvent::Type last_input_event);
 
   // The time we should stay in a priority-escalated mode after an input event.
   static const int kPriorityEscalationAfterInputMillis = 100;
 
+  // The maximum length of an idle period.
+  static const int kMaximumIdlePeriodMillis = 50;
+
   // IdleTaskDeadlineSupplier Implementation:
   void CurrentIdleTaskDeadlineCallback(base::TimeTicks* deadline_out) const;
 
   // Returns the current scheduler policy. Must be called from the main thread.
   Policy SchedulerPolicy() const;
 
   // Posts a call to UpdatePolicy on the control runner to be run after |delay|
   void PostUpdatePolicyOnControlRunner(base::TimeDelta delay);
 
   // Update the policy if a new signal has arrived. Must be called from the main
   // thread.
   void MaybeUpdatePolicy();
 
   // Updates the scheduler policy. Must be called from the main thread.
   void UpdatePolicy();
 
+  // Returns the amount of time left in the current input escalated priority
+  // policy.
+  base::TimeDelta TimeLeftInInputEscalatedPolicy();

[Sami, 2015/03/03 16:55:36]

Can this be const?

[rmcilroy, 2015/03/04 14:23:12]

Yes - done.

+
   // Helper for computing the new policy. |new_policy_duration| will be filled
   // with the amount of time after which the policy should be updated again. If
   // the duration is zero, a new policy update will not be scheduled. Must be
   // called with |incoming_signals_lock_| held.
   Policy ComputeNewPolicy(base::TimeDelta* new_policy_duration);
 
   // An input event of some sort happened, the policy may need updating.
   void UpdateForInputEvent(blink::WebInputEvent::Type type);
 
   // Called when a previously queued input event was processed.
   // |begin_frame_time|, if non-zero, identifies the frame time at which the
   // input was processed.
   void DidProcessInputEvent(base::TimeTicks begin_frame_time);
 
+  // Returns true if we should initiate a long idle time now. Fills in
+  // |next_long_idle_period_delay_out| with the next time we should try to
+  // initiate the next idle period.
+  bool ShouldStartLongIdlePeriod(
+      const base::TimeTicks& now,

[Sami, 2015/03/03 16:55:36]

nit: pass TimeTicks by value.

[rmcilroy, 2015/03/04 14:23:12]

Done.

+      base::TimeDelta* next_long_idle_period_delay_out);
+
+  // Initiate a long idle period.
+  void InitiateLongIdlePeriod();
+  void AfterWakeupInitiateLongIdlePeriod();

[Sami, 2015/03/03 16:55:36]

InitiateLongIdlePeriodAfterWakeup to make this less yoda?

[rmcilroy, 2015/03/04 14:23:12]

mmh, I originally had this but thought it sounded like it would initiate the
idle period after the next wakeup (not initiate the period now that we have
woken up).  But yeah, this is still probably better - done.

[rmcilroy, 2015/03/04 14:23:12]

Done.

+
   // Start and end an idle period.
   void StartIdlePeriod();
   void EndIdlePeriod();
 
   base::TimeTicks Now() const;
 
   base::ThreadChecker main_thread_checker_;
   scoped_ptr<RendererTaskQueueSelector> renderer_task_queue_selector_;
   scoped_ptr<TaskQueueManager> task_queue_manager_;
   scoped_refptr<base::SingleThreadTaskRunner> control_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> control_task_after_wakeup_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
 
   base::Closure update_policy_closure_;
   CancelableClosureHolder end_idle_period_closure_;
+  CancelableClosureHolder initiate_next_long_idle_period_closure_;
+  CancelableClosureHolder after_wakeup_initiate_next_long_idle_period_closure_;
 
   // Don't access current_policy_ directly, instead use SchedulerPolicy().
   Policy current_policy_;
 
   base::TimeTicks estimated_next_frame_begin_;
 
   // The incoming_signals_lock_ mutex protects access to all variables in the
   // (contiguous) block below.
   base::Lock incoming_signals_lock_;
   base::TimeTicks last_input_receipt_time_on_compositor_;
   base::TimeTicks last_input_process_time_on_main_;
   blink::WebInputEvent::Type last_input_type_;
   InputStreamState input_stream_state_;
   PollableNeedsUpdateFlag policy_may_need_update_;
 
   scoped_refptr<cc::TestNowSource> time_source_;
 
   base::WeakPtr<RendererSchedulerImpl> weak_renderer_scheduler_ptr_;
   base::WeakPtrFactory<RendererSchedulerImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_SCHEDULER_RENDERER_SCHEDULER_IMPL_H_