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"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/values.h"
 
 namespace cc {
 
 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
     : settings_(settings),
       output_surface_state_(OUTPUT_SURFACE_LOST),
       begin_impl_frame_state_(BEGIN_IMPL_FRAME_STATE_IDLE),
       commit_state_(COMMIT_STATE_IDLE),
       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),
-      invalidate_output_surface_funnel_(false),
-      prepare_tiles_funnel_(0),
+      animate_funnel_(true),
+      request_swap_funnel_(true),
+      send_begin_main_frame_funnel_(true),
+      invalidate_output_surface_funnel_(true),
+      prepare_tiles_funnel_(1),

[mithro-old, 2015/07/08 03:26:33]

Why do these values change?

[sunnyps, 2015/07/13 23:56:11]

Only the value for send_begin_main_frame_funnel_ needs to change. The basic idea
is this: for webview we want to allow SendBeginMainFrame in the
BEGIN_IMPL_FRAME_STATE_IDLE state in between frames. However we do not want to
allow SendBeginMainFrame before we've received the first BeginFrame in a "run"
of BeginFrames. To do that we set the funnel to true initially and also when we
end a run of frames and to false on each new frame (as before).

       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),
       visible_(false),
       can_start_(false),
@@ skipping 370 matching lines @@
   // 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_;
 }
 
 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 697 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