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("main_thread_is_in_high_latency_mode",
+                          MainThreadIsInHighLatencyMode());
+  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::MainThreadIsInHighLatencyMode() const {
+  // 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;
+
+  // If there's a commit in progress it must either be from the previous frame
+  // or it started after the impl thread's deadline. In either case the main
+  // thread is in high latency mode.
+  if (commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS ||
+      commit_state_ == COMMIT_STATE_READY_TO_COMMIT)
+    return true;
+
+  // Similarly, if there's a pending tree the main thread is in high latency
+  // mode, because either
+  //   it's from the previous frame
+  // or
+  //   we're currently drawing the active tree and the pending tree will thus
+  //   only be drawn in the next frame.
+  if (has_pending_tree_)
+    return true;
+
+  if (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) {
+    // Even if there's a new active tree to draw at the deadline or we've just
+    // drawn it, 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_swap_performed_ == current_frame_number_) &&

[brianderson, 2013/11/05 00:24:17]

Ah, good catch here.

+           last_frame_number_begin_main_frame_sent_ != current_frame_number_;
+  } else {
+    // If the active tree needs its first draw in any other state, we know the
+    // main thread is in a high latency mode.
+    return active_tree_needs_first_draw_;
+  }
+
+  return false;

[brianderson, 2013/11/05 00:24:17]

Hmm, this will never be reached. Maybe we can just remove the else block above
and put it's body at the end of the method.

[Dominik Grewe, 2013/11/05 12:24:20]

Done.

+}
+
 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