cc: Heuristic for Renderer latency recovery

cc/scheduler/scheduler_state_machine.cc

Index: cc/scheduler/scheduler_state_machine.cc
diff --git a/cc/scheduler/scheduler_state_machine.cc b/cc/scheduler/scheduler_state_machine.cc
index 2fbeca2d8a992d87cd118a09a78eeb5db8b61d3b..20c50753b48de08a81a1de631336b2bc2154e458 100644
--- a/cc/scheduler/scheduler_state_machine.cc
+++ b/cc/scheduler/scheduler_state_machine.cc
@@ -35,6 +35,8 @@ SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
       consecutive_checkerboard_animations_(0),
       max_pending_swaps_(1),
       pending_swaps_(0),
+      swaps_are_likely_high_latency_(false),
+      swap_throttled_in_last_deadline_(false),
       needs_redraw_(false),
       needs_animate_(false),
       needs_prepare_tiles_(false),
@@ -818,6 +820,13 @@ bool SchedulerStateMachine::ProactiveBeginFrameWanted() const {
   return false;
 }
 
+void SchedulerStateMachine::DidSkipBeginImplFrameToReduceLatency() {
+  // If there are no swap ack's pending to update swaps_are_likely_high_latency
+  // later, reset it now.
+  if (!pending_swaps_)
+    swaps_are_likely_high_latency_ = false;
+}
+
 void SchedulerStateMachine::OnBeginImplFrame() {
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING;
   current_frame_number_++;
@@ -850,6 +859,10 @@ void SchedulerStateMachine::OnBeginImplFrameDeadline() {
 
   // Clear funnels for any actions we perform during the deadline.
   request_swap_funnel_ = false;
+
+  swap_throttled_in_last_deadline_ = pending_swaps_ >= max_pending_swaps_;
+  swaps_are_likely_high_latency_ =
+      swaps_are_likely_high_latency_ || swap_throttled_in_last_deadline_;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameIdle() {
@@ -882,7 +895,6 @@ SchedulerStateMachine::CurrentBeginImplFrameDeadlineMode() const {
 
 bool SchedulerStateMachine::ShouldTriggerBeginImplFrameDeadlineImmediately()
     const {
-  // TODO(brianderson): This should take into account multiple commit sources.
   if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME)
     return false;
 
@@ -993,6 +1005,10 @@ void SchedulerStateMachine::DidSwapBuffers() {
 void SchedulerStateMachine::DidSwapBuffersComplete() {
   DCHECK_GT(pending_swaps_, 0);
   pending_swaps_--;
+
+  swaps_are_likely_high_latency_ =
+      begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME ||

[sunnyps, 2015/05/12 00:36:25]

I don't understand what the frame state has to do with the renderer being in
high latency mode. Consider a renderer that always goes for an immediate
deadline at the beginning of the frame. In that case DidSwapBuffersComplete will
almost always come in while the state is IDLE. That doesn't imply that we're not
in high latency mode.

[brianderson, 2015/05/12 19:25:17]

Regarding frame state:
The code is hard to follow. I think I can use an alternative approach that is
easier to follow by using a swap_throttled_at_last_on_begin_impl_frame_ instead
of a swap_throttled_in_last_deadline like the current code does. That would
remove the need to look at the begin_impl_frame_state here.

Regarding your specific concern:
The immediate deadline case is covered by the swap_throttled_in_last_deadline
logic above, which is used to differentiate between a DidSwapBuffersComplete
that came back quickly vs. one that came after the next BeginFrame's deadline
since the state is IDLE in both cases.
swap_throttled_at_last_on_begin_impl_frame_ could serve the same purpose.

+      swap_throttled_in_last_deadline_;
 }
 
 void SchedulerStateMachine::SetImplLatencyTakesPriority(