cc: Allow SendBeginMainFrame in idle state for synchronous compositor.

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 10 matching lines @@
       forced_redraw_state_(FORCED_REDRAW_STATE_IDLE),
       commit_count_(0),
       current_frame_number_(0),
       last_frame_number_animate_performed_(-1),
       last_frame_number_swap_performed_(-1),
       last_frame_number_swap_requested_(-1),
       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),
+      send_begin_main_frame_funnel_(true),
       invalidate_output_surface_funnel_(false),
       prepare_tiles_funnel_(0),
       consecutive_checkerboard_animations_(0),
       max_pending_swaps_(1),
       pending_swaps_(0),
       swaps_with_current_output_surface_(0),
       needs_redraw_(false),
       needs_animate_(false),
       needs_prepare_tiles_(false),
       needs_commit_(false),
@@ skipping 368 matching lines @@
   // 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_ && SwapThrottled();
 }
 
 bool SchedulerStateMachine::ShouldSendBeginMainFrame() const {
   if (!CouldSendBeginMainFrame())
     return false;
 
-  // Do not send begin main frame too many times in a single frame.
+  // Do not send begin main frame too many times in a single frame or before
+  // the first BeginFrame.
   if (send_begin_main_frame_funnel_)
     return false;
 
   // Only send BeginMainFrame when there isn't another commit pending already.
   // Other parts of the state machine indirectly defer the BeginMainFrame
   // by transitioning to WAITING commit states rather than going
   // immediately to IDLE.
   if (commit_state_ != COMMIT_STATE_IDLE)
     return false;
 
   // Don't send BeginMainFrame early if we are prioritizing the active tree
   // because of impl_latency_takes_priority_.
   if (impl_latency_takes_priority_ &&
       (has_pending_tree_ || active_tree_needs_first_draw_)) {
     return false;
   }
 
-  // We should not send BeginMainFrame while we are in
-  // BEGIN_IMPL_FRAME_STATE_IDLE since we might have new
-  // user input arriving soon.
+  // We should not send BeginMainFrame while we are in the idle state since we
+  // might have new user input arriving soon. It's okay to send BeginMainFrame
+  // for the synchronous compositor because the main thread is always high
+  // latency in that case.
   // TODO(brianderson): Allow sending BeginMainFrame while idle when the main
-  // thread isn't consuming user input.
-  if (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_IDLE &&
-      BeginFrameNeeded())
+  // thread isn't consuming user input for non-synchronous compositor.
+  if (!settings_.using_synchronous_renderer_compositor &&
+      begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_IDLE) {
     return false;
+  }
 
   // We need a new commit for the forced redraw. This honors the
   // single commit per interval because the result will be swapped to screen.
   // TODO(brianderson): Remove this or move it below the
   // SendingBeginMainFrameMightCauseDeadlock check since  we want to avoid
   // ever returning true from this method if we might cause deadlock.
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_COMMIT)
     return true;
 
   // We shouldn't normally accept commits if there isn't an OutputSurface.
@@ skipping 416 matching lines @@
   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;
+
+  // If we're entering a state where we won't get BeginFrames set all the
+  // funnels so that we don't perform any actions that we shouldn't.
+  if (!BeginFrameNeeded())
+    send_begin_main_frame_funnel_ = true;
 }
 
 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.
@@ skipping 273 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