Scheduler: Switch from high to low latency mode if possible.

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/debug/trace_event.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
@@ skipping 23 matching lines @@
       main_thread_needs_layer_textures_(false),
       inside_poll_for_anticipated_draw_triggers_(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),
       draw_if_possible_failed_(false),
       did_create_and_initialize_first_output_surface_(false),
-      smoothness_takes_priority_(false) {}
+      smoothness_takes_priority_(false),
+      skip_begin_main_frame_to_reduce_latency_(false) {}
 
 const char* SchedulerStateMachine::OutputSurfaceStateToString(
     OutputSurfaceState state) {
   switch (state) {
     case OUTPUT_SURFACE_ACTIVE:
       return "OUTPUT_SURFACE_ACTIVE";
     case OUTPUT_SURFACE_LOST:
       return "OUTPUT_SURFACE_LOST";
     case OUTPUT_SURFACE_CREATING:
       return "OUTPUT_SURFACE_CREATING";
@@ skipping 197 matching lines @@
   minor_state->SetBoolean("has_pending_tree", has_pending_tree_);
   minor_state->SetBoolean("pending_tree_is_ready_for_activation",
                           pending_tree_is_ready_for_activation_);
   minor_state->SetBoolean("active_tree_needs_first_draw",
                           active_tree_needs_first_draw_);
   minor_state->SetBoolean("draw_if_possible_failed", draw_if_possible_failed_);
   minor_state->SetBoolean("did_create_and_initialize_first_output_surface",
                           did_create_and_initialize_first_output_surface_);
   minor_state->SetBoolean("smoothness_takes_priority",
                           smoothness_takes_priority_);
+  minor_state->SetBoolean("skip_begin_main_frame_to_reduce_latency",
+                          skip_begin_main_frame_to_reduce_latency_);
   state->Set("minor_state", minor_state.release());
 
   return state.PassAs<base::Value>();
 }
 
 bool SchedulerStateMachine::HasSentBeginMainFrameThisFrame() const {
   return current_frame_number_ ==
          last_frame_number_begin_main_frame_sent_;
 }
 
@@ skipping 206 matching lines @@
     return true;
 
   // After this point, we only start a commit once per frame.
   if (HasSentBeginMainFrameThisFrame())
     return false;
 
   // We shouldn't normally accept commits if there isn't an OutputSurface.
   if (!HasInitializedOutputSurface())
     return false;
 
+  if (skip_begin_main_frame_to_reduce_latency_)
+    return false;
+
   return true;
 }
 
 bool SchedulerStateMachine::ShouldCommit() const {
   return commit_state_ == COMMIT_STATE_READY_TO_COMMIT;
 }
 
 bool SchedulerStateMachine::ShouldManageTiles() const {
   // Limiting to once per-frame is not enough, since we only want to
   // manage tiles _after_ draws. Polling for draw triggers and
@@ skipping 251 matching lines @@
 void SchedulerStateMachine::UpdateStateOnManageTiles() {
   needs_manage_tiles_ = false;
 }
 
 void SchedulerStateMachine::SetMainThreadNeedsLayerTextures() {
   DCHECK(!main_thread_needs_layer_textures_);
   DCHECK_NE(texture_state_, LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD);
   main_thread_needs_layer_textures_ = true;
 }
 
+void SchedulerStateMachine::SetSkipBeginMainFrameToReduceLatency(bool skip) {
+  skip_begin_main_frame_to_reduce_latency_ = skip;
+}
+
 bool SchedulerStateMachine::BeginImplFrameNeeded() const {
   // Proactive BeginImplFrames are bad for the synchronous compositor because we
   // have to draw when we get the BeginImplFrame and could end up drawing many
   // duplicate frames if our new frame isn't ready in time.
   // To poll for state with the synchronous compositor without having to draw,
   // we rely on ShouldPollForAnticipatedDrawTriggers instead.
   if (!SupportsProactiveBeginImplFrame())
     return BeginImplFrameNeededToDraw();
 
   return BeginImplFrameNeededToDraw() ||
@@ skipping 143 matching lines @@
   if (commit_state_ == COMMIT_STATE_IDLE && !has_pending_tree_)
     return true;
 
   // Prioritize impl-thread draws in smoothness mode.
   if (smoothness_takes_priority_)
     return true;
 
   return false;
 }
 
+bool SchedulerStateMachine::InHighLatencyMode() const {

[brianderson, 2013/11/01 21:18:30]

Maybe rename this to MainThreadIsInHighLatencyMode?

+  // We're in high latency mode if there's something to draw from the previous
+  // frame at the start of BeginImplFrame.
+  if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING)

[brianderson, 2013/11/01 21:18:30]

Can you add the result of this method to the output of AsValue? It would be good
to make this method return a valid result regardless of the state we are in, in
which case I think you can change this if to read:

// If we just sent a BeginMainFrame and haven't hit the deadline yet, the main
// thread is in a low latency mode.
if (last_frame_number_begin_main_frame_sent_ == current_frame_number_ &&
    (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING ||
     begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME))
  return false;

+    return false;
+
+  // There's an ongoing commit at the start of BeginImplFrame whose output needs
+  // to be drawn before another commit from the main thread.
+  if (commit_state_ != COMMIT_STATE_IDLE)
+    return true;
+
+  // There is a pending tree from the previous frame which needs to be activated
+  // and drawn before producing a new tree.
+  if (has_pending_tree_ )
+    return true;
+
+  // A newly activated tree from the previous frame needs to be drawn.
+  if (active_tree_needs_first_draw_)

[brianderson, 2013/11/01 21:18:30]

To make this method valid regardless of the state we are in, I think you'd also
need to add the following if statement here:

if (begin_impl_frame_state == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) {
  // Even if there's a new active tree to draw at the deadline it may have
  // been triggered by a previous BeginImplFrame, in which case the main thread
  // is in a high latency mode.
  return active_tree_needs_first_draw_ &&
         last_frame_number_begin_main_frame_sent_ != current_frame_number_;
} else {
  // If the active tree needs it's first draw in any other state, we know
  // the main thread is in a high latency mode.
  return active_tree_needs_first_draw_;
}

+    return true;
+
+  return false;
+}
+
 void SchedulerStateMachine::DidEnterPollForAnticipatedDrawTriggers() {
   current_frame_number_++;
   inside_poll_for_anticipated_draw_triggers_ = true;
 }
 
 void SchedulerStateMachine::DidLeavePollForAnticipatedDrawTriggers() {
   inside_poll_for_anticipated_draw_triggers_ = false;
 }
 
 void SchedulerStateMachine::SetVisible(bool visible) { visible_ = visible; }
@@ skipping 121 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