cc: Allow the main thread to cancel commits

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"
 
 namespace cc {
 
 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
     : settings_(settings),
       commit_state_(COMMIT_STATE_IDLE),
       commit_count_(0),
       current_frame_number_(0),
+      last_frame_number_where_commit_was_aborted_(-1),
       last_frame_number_where_draw_was_called_(-1),
       last_frame_number_where_tree_activation_attempted_(-1),
       last_frame_number_where_check_for_completed_tile_uploads_called_(-1),
       consecutive_failed_draws_(0),
       maximum_number_of_failed_draws_before_draw_is_forced_(3),
       needs_redraw_(false),
       swap_used_incomplete_tile_(false),
       needs_forced_redraw_(false),
       needs_forced_redraw_after_next_commit_(false),
       needs_commit_(false),
@@ skipping 149 matching lines @@
   if (!BeginFrameNeededToDrawByImplThread())
     return true;
   return false;
 }
 
 SchedulerStateMachine::Action SchedulerStateMachine::NextAction() const {
   if (ShouldAcquireLayerTexturesForMainThread())
     return ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD;
 
   switch (commit_state_) {
-    case COMMIT_STATE_IDLE:
+    case COMMIT_STATE_IDLE: {
       if (output_surface_state_ != OUTPUT_SURFACE_ACTIVE &&
           needs_forced_redraw_)
         return ACTION_DRAW_FORCED;
       if (output_surface_state_ != OUTPUT_SURFACE_ACTIVE &&
           needs_forced_commit_)
         // TODO(enne): Should probably drop the active tree on force commit.
         return has_pending_tree_ ? ACTION_NONE
                                  : ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD;
       if (output_surface_state_ == OUTPUT_SURFACE_LOST && can_start_)
         return ACTION_BEGIN_OUTPUT_SURFACE_CREATION;
       if (output_surface_state_ == OUTPUT_SURFACE_CREATING)
         return ACTION_NONE;
       if (ShouldCheckForCompletedTileUploads())
         return ACTION_CHECK_FOR_COMPLETED_TILE_UPLOADS;
       if (ShouldAttemptTreeActivation())
         return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED;
       if (ShouldDraw()) {
         return needs_forced_redraw_ ? ACTION_DRAW_FORCED
                                     : ACTION_DRAW_IF_POSSIBLE;
       }
-      if (needs_commit_ &&
-          ((visible_ && output_surface_state_ == OUTPUT_SURFACE_ACTIVE)
-           || needs_forced_commit_))
+      bool can_commit_this_frame = visible_ &&
+          current_frame_number_ > last_frame_number_where_commit_was_aborted_;
+      if (needs_commit_ && ((can_commit_this_frame &&
+                             output_surface_state_ == OUTPUT_SURFACE_ACTIVE) ||
+                            needs_forced_commit_))
         // TODO(enne): Should probably drop the active tree on force commit.
         return has_pending_tree_ ? ACTION_NONE
                                  : ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD;
       return ACTION_NONE;
-
+    }
     case COMMIT_STATE_FRAME_IN_PROGRESS:
       if (ShouldCheckForCompletedTileUploads())
         return ACTION_CHECK_FOR_COMPLETED_TILE_UPLOADS;
       if (ShouldAttemptTreeActivation())
         return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED;
       if (ShouldDraw()) {
         return needs_forced_redraw_ ? ACTION_DRAW_FORCED
                                     : ACTION_DRAW_IF_POSSIBLE;
       }
       return ACTION_NONE;
@@ skipping 43 matching lines @@
           current_frame_number_;
       return;
 
     case ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED:
       last_frame_number_where_tree_activation_attempted_ =
           current_frame_number_;
       return;
 
     case ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD:
       DCHECK(!has_pending_tree_);
-      DCHECK(visible_ || needs_forced_commit_);
+      if (!needs_forced_commit_) {
+        DCHECK(visible_);
+        DCHECK_GT(current_frame_number_,
+                  last_frame_number_where_commit_was_aborted_);
+      }
       commit_state_ = COMMIT_STATE_FRAME_IN_PROGRESS;
       needs_commit_ = false;
       needs_forced_commit_ = false;
       return;
 
     case ACTION_COMMIT:
       commit_count_++;
       if (expect_immediate_begin_frame_for_main_thread_)
         commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW;
       else
@@ skipping 125 matching lines @@
 }
 
 void SchedulerStateMachine::FinishCommit() {
   DCHECK(commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS ||
          (expect_immediate_begin_frame_for_main_thread_ &&
           commit_state_ != COMMIT_STATE_IDLE))
       << ToString();
   commit_state_ = COMMIT_STATE_READY_TO_COMMIT;
 }
 
-void SchedulerStateMachine::BeginFrameAbortedByMainThread() {
+void SchedulerStateMachine::BeginFrameAbortedByMainThread(bool cancel_commit) {
   DCHECK_EQ(commit_state_, COMMIT_STATE_FRAME_IN_PROGRESS);
+  last_frame_number_where_commit_was_aborted_ = current_frame_number_;
   if (expect_immediate_begin_frame_for_main_thread_) {
     expect_immediate_begin_frame_for_main_thread_ = false;
+  } else if (cancel_commit) {
+    commit_state_ = COMMIT_STATE_IDLE;
   } else {
     commit_state_ = COMMIT_STATE_IDLE;
     SetNeedsCommit();
   }
 }
 
 void SchedulerStateMachine::DidLoseOutputSurface() {
   if (output_surface_state_ == OUTPUT_SURFACE_LOST ||
       output_surface_state_ == OUTPUT_SURFACE_CREATING)
     return;
@@ skipping 25 matching lines @@
 bool SchedulerStateMachine::HasInitializedOutputSurface() const {
   return output_surface_state_ == OUTPUT_SURFACE_ACTIVE;
 }
 
 void SchedulerStateMachine::SetMaximumNumberOfFailedDrawsBeforeDrawIsForced(
     int num_draws) {
   maximum_number_of_failed_draws_before_draw_is_forced_ = num_draws;
 }
 
 }  // namespace cc