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 30 matching lines @@
       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),
       did_create_and_initialize_first_output_surface_(false),
       impl_latency_takes_priority_(false),
       skip_next_begin_main_frame_to_reduce_latency_(false),
-      skip_begin_main_frame_to_reduce_latency_(false),
       continuous_painting_(false),
       children_need_begin_frames_(false),
       defer_commits_(false),
       video_needs_begin_frames_(false),
       last_commit_had_no_updates_(false),
       wait_for_active_tree_ready_to_draw_(false),
       did_request_swap_in_last_frame_(false),
       did_perform_swap_in_last_draw_(false) {
 }
 
@@ skipping 171 matching lines @@
   state->SetBoolean("active_tree_needs_first_draw",
                     active_tree_needs_first_draw_);
   state->SetBoolean("wait_for_active_tree_ready_to_draw",
                     wait_for_active_tree_ready_to_draw_);
   state->SetBoolean("did_create_and_initialize_first_output_surface",
                     did_create_and_initialize_first_output_surface_);
   state->SetBoolean("impl_latency_takes_priority",
                     impl_latency_takes_priority_);
   state->SetBoolean("main_thread_is_in_high_latency_mode",
                     MainThreadIsInHighLatencyMode());
-  state->SetBoolean("skip_begin_main_frame_to_reduce_latency",
-                    skip_begin_main_frame_to_reduce_latency_);
   state->SetBoolean("skip_next_begin_main_frame_to_reduce_latency",
                     skip_next_begin_main_frame_to_reduce_latency_);
   state->SetBoolean("continuous_painting", continuous_painting_);
   state->SetBoolean("children_need_begin_frames", children_need_begin_frames_);
   state->SetBoolean("video_needs_begin_frames", video_needs_begin_frames_);
   state->SetBoolean("defer_commits", defer_commits_);
   state->SetBoolean("last_commit_had_no_updates", last_commit_had_no_updates_);
   state->SetBoolean("did_request_swap_in_last_frame",
                     did_request_swap_in_last_frame_);
   state->SetBoolean("did_perform_swap_in_last_draw",
@@ skipping 77 matching lines @@
   // this before checking for aborted draws because aborted draws do not request
   // a swap.
   if (request_swap_funnel_)
     return false;
 
   // Don't draw if we are waiting on the first commit after a surface.
   if (output_surface_state_ != OUTPUT_SURFACE_ACTIVE)
     return false;
 
   // Do not queue too many swaps.
-  if (pending_swaps_ >= max_pending_swaps_)
+  if (SwapThrottled())
     return false;
 
   // Except for the cases above, do not draw outside of the BeginImplFrame
   // deadline.
   if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)
     return false;
 
   // Only handle forced redraws due to timeouts on the regular deadline.
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
     return true;
@@ skipping 53 matching lines @@
 
 bool SchedulerStateMachine::SendingBeginMainFrameMightCauseDeadlock() const {
   // NPAPI is the only case where the UI thread makes synchronous calls to the
   // Renderer main thread. During that synchronous call, we may not get a
   // SwapAck for the UI thread, which may prevent BeginMainFrame's from
   // completing if there's enough back pressure. If the BeginMainFrame can't
   // make progress, the Renderer can't service the UI thread's synchronous call
   // and we have deadlock.
   // This returns true if there's too much backpressure to finish a commit
   // if we were to initiate a BeginMainFrame.
-  return has_pending_tree_ && active_tree_needs_first_draw_ &&
-         pending_swaps_ >= max_pending_swaps_;
+  return has_pending_tree_ && active_tree_needs_first_draw_ && SwapThrottled();
 }
 
 bool SchedulerStateMachine::ShouldSendBeginMainFrame() const {
   if (!CouldSendBeginMainFrame())
     return false;
 
   // Do not send begin main frame too many times in a single frame.
   if (send_begin_main_frame_funnel_)
     return false;
 
@@ skipping 37 matching lines @@
     return false;
 
   if (!settings_.main_frame_while_swap_throttled_enabled) {
     // SwapAck throttle the BeginMainFrames unless we just swapped to
     // potentially improve impl-thread latency over main-thread throughput.
     // TODO(brianderson): Remove this restriction to improve throughput or
     // make it conditional on impl_latency_takes_priority_.
     bool just_swapped_in_deadline =
         begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE &&
         did_perform_swap_in_last_draw_;
-    if (pending_swaps_ >= max_pending_swaps_ && !just_swapped_in_deadline)
+    if (SwapThrottled() && !just_swapped_in_deadline)
       return false;
   }
 
-  if (skip_begin_main_frame_to_reduce_latency_)
+  if (skip_next_begin_main_frame_to_reduce_latency_)
     return false;
 
   return true;
 }
 
 bool SchedulerStateMachine::ShouldCommit() const {
   if (commit_state_ != COMMIT_STATE_READY_TO_COMMIT)
     return false;
 
   // We must not finish the commit until the pending tree is free.
@@ skipping 361 matching lines @@
   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;
   invalidate_output_surface_funnel_ = false;
 
   // "Drain" the PrepareTiles funnel.
   if (prepare_tiles_funnel_ > 0)
     prepare_tiles_funnel_--;
-
-  skip_begin_main_frame_to_reduce_latency_ =
-      skip_next_begin_main_frame_to_reduce_latency_;
-  skip_next_begin_main_frame_to_reduce_latency_ = false;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameDeadlinePending() {
   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;
 
   // Allow one PrepareTiles per draw for synchronous compositor.
   if (settings_.using_synchronous_renderer_compositor) {
     if (prepare_tiles_funnel_ > 0)
       prepare_tiles_funnel_--;
   }
 }
 
 void SchedulerStateMachine::OnBeginImplFrameIdle() {
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_IDLE;
+
+  skip_next_begin_main_frame_to_reduce_latency_ = false;

[sunnyps, 2015/07/08 22:37:12]

Why was this moved here?

[brianderson, 2015/07/09 01:28:11]

Resetting it here allowed me to get rid of the
skip_begin_main_frame_to_reduce_latency_ variable.

 }
 
 SchedulerStateMachine::BeginImplFrameDeadlineMode
 SchedulerStateMachine::CurrentBeginImplFrameDeadlineMode() const {
   if (settings_.using_synchronous_renderer_compositor) {
     // No deadline for synchronous compositor.
     return BEGIN_IMPL_FRAME_DEADLINE_MODE_NONE;
   } else if (wait_for_active_tree_ready_to_draw_) {
     // When we are waiting for ready to draw signal, we do not wait to post a
     // deadline yet.
     return BEGIN_IMPL_FRAME_DEADLINE_MODE_BLOCKED_ON_READY_TO_DRAW;
   } else if (ShouldTriggerBeginImplFrameDeadlineImmediately()) {
     return BEGIN_IMPL_FRAME_DEADLINE_MODE_IMMEDIATE;
-  } else if (needs_redraw_ && pending_swaps_ < max_pending_swaps_) {
+  } else if (needs_redraw_ && !SwapThrottled()) {
     // We have an animation or fast input path on the impl thread that wants
     // to draw, so don't wait too long for a new active tree.
     // If we are swap throttled we should wait until we are unblocked.
     return BEGIN_IMPL_FRAME_DEADLINE_MODE_REGULAR;
   } 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_)
+  if (SwapThrottled())
     return false;
 
   if (active_tree_needs_first_draw_)
     return true;
 
   if (!needs_redraw_)
     return false;
 
   // This is used to prioritize impl-thread draws when the main thread isn't
   // producing anything, e.g., after an aborted commit. We also check that we
@@ skipping 221 matching lines @@
     case OUTPUT_SURFACE_ACTIVE:
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT:
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION:
       return true;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace cc