cc: Heuristic for Renderer latency recovery

cc/scheduler/scheduler_state_machine.cc

 // Copyright 2011 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 "cc/scheduler/scheduler_state_machine.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 17 matching lines @@
       last_frame_number_begin_main_frame_sent_(-1),
       last_frame_number_invalidate_output_surface_performed_(-1),
       animate_funnel_(false),
       request_swap_funnel_(false),
       send_begin_main_frame_funnel_(false),
       invalidate_output_surface_funnel_(false),
       prepare_tiles_funnel_(0),
       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),
       needs_commit_(false),
       visible_(false),
       can_start_(false),
       can_draw_(false),
       has_pending_tree_(false),
       pending_tree_is_ready_for_activation_(false),
       active_tree_needs_first_draw_(false),
@@ skipping 763 matching lines @@
     return true;
 
   // If the last commit was aborted because of early out (no updates), we should
   // still want a begin frame in case there is a commit coming again.
   if (last_commit_had_no_updates_)
     return true;
 
   return false;
 }
 
+void SchedulerStateMachine::DidSkipBeginImplFrameToReduceLatency() {
+  swaps_are_likely_high_latency_ = false;
+}
+
 void SchedulerStateMachine::OnBeginImplFrame() {
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING;
   current_frame_number_++;
 
   last_commit_had_no_updates_ = false;
   did_request_swap_in_last_frame_ = false;
 
   // Clear funnels for any actions we perform during the frame.
   animate_funnel_ = false;
   send_begin_main_frame_funnel_ = false;
@@ skipping 12 matching lines @@
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameDeadline() {
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE;
 
   did_perform_swap_in_last_draw_ = false;
 
   // 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() {
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_IDLE;
 }
 
 SchedulerStateMachine::BeginImplFrameDeadlineMode
 SchedulerStateMachine::CurrentBeginImplFrameDeadlineMode() const {
   if (settings_.using_synchronous_renderer_compositor) {
     // No deadline for synchronous compositor.
@@ skipping 12 matching lines @@
   } else {
     // The impl thread doesn't have anything it wants to draw and we are just
     // waiting for a new active tree or we are swap throttled. In short we are
     // blocked.
     return BEGIN_IMPL_FRAME_DEADLINE_MODE_LATE;
   }
 }
 
 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;
 
   // If we just forced activation, we should end the deadline right now.
   if (PendingActivationsShouldBeForced() && !has_pending_tree_)
     return true;
 
   // SwapAck throttle the deadline since we wont draw and swap anyway.
   if (pending_swaps_ >= max_pending_swaps_)
     return false;
@@ skipping 90 matching lines @@
   pending_swaps_++;
   DCHECK_LE(pending_swaps_, max_pending_swaps_);
 
   did_perform_swap_in_last_draw_ = true;
   last_frame_number_swap_performed_ = current_frame_number_;
 }
 
 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 ||
+      swap_throttled_in_last_deadline_;
 }
 
 void SchedulerStateMachine::SetImplLatencyTakesPriority(
     bool impl_latency_takes_priority) {
   impl_latency_takes_priority_ = impl_latency_takes_priority;
 }
 
 void SchedulerStateMachine::DidDrawIfPossibleCompleted(DrawResult result) {
   switch (result) {
     case INVALID_RESULT:
@@ skipping 132 matching lines @@
       static_cast<int>(begin_impl_frame_state_),
       static_cast<int>(commit_state_),
       has_pending_tree_ ? 'T' : 'F',
       pending_tree_is_ready_for_activation_ ? 'T' : 'F',
       active_tree_needs_first_draw_ ? 'T' : 'F',
       max_pending_swaps_,
       pending_swaps_);
 }
 
 }  // namespace cc