cc: Add SchedulerStateMachine::DidDraw and use for forced draws

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 18 matching lines @@
       animate_funnel_(false),
       request_swap_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),
+      last_draw_result_(DRAW_SUCCESS),
       needs_animate_(false),
       needs_prepare_tiles_(false),
       needs_begin_main_frame_(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),
       did_create_and_initialize_first_output_surface_(false),
@@ skipping 528 matching lines @@
       WillSendBeginMainFrame();
       return;
 
     case ACTION_COMMIT: {
       bool commit_has_no_updates = false;
       WillCommit(commit_has_no_updates);
       return;
     }
 
     case ACTION_DRAW_AND_SWAP_FORCED:
-    case ACTION_DRAW_AND_SWAP_IF_POSSIBLE: {
-      bool did_request_swap = true;
-      WillDraw(did_request_swap);
+    case ACTION_DRAW_AND_SWAP_IF_POSSIBLE:
+    case ACTION_DRAW_AND_SWAP_ABORT:
+      WillDraw();
       return;
-    }
-
-    case ACTION_DRAW_AND_SWAP_ABORT: {
-      bool did_request_swap = false;
-      WillDraw(did_request_swap);
-      return;
-    }
 
     case ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
       WillBeginOutputSurfaceCreation();
       return;
 
     case ACTION_PREPARE_TILES:
       WillPrepareTiles();
       return;
 
     case ACTION_INVALIDATE_OUTPUT_SURFACE:
       WillInvalidateOutputSurface();
       return;
   }
 }
+
+void SchedulerStateMachine::DidAction(Action action) {
+  switch (action) {
+    case ACTION_NONE:
+      return;
+
+    case ACTION_ACTIVATE_SYNC_TREE:
+      return;
+
+    case ACTION_ANIMATE:
+      return;
+
+    case ACTION_SEND_BEGIN_MAIN_FRAME:
+      return;
+
+    case ACTION_COMMIT: {
+      return;
+    }
+
+    case ACTION_DRAW_AND_SWAP_FORCED:
+    case ACTION_DRAW_AND_SWAP_IF_POSSIBLE: {
+      bool did_request_swap = true;
+      DidDraw(did_request_swap);
+      return;
+    }
+
+    case ACTION_DRAW_AND_SWAP_ABORT: {
+      bool did_request_swap = false;
+      DidDraw(did_request_swap);
+      return;
+    }
+
+    case ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
+      return;
+
+    case ACTION_PREPARE_TILES:
+      return;
+
+    case ACTION_INVALIDATE_OUTPUT_SURFACE:
+      return;
+  }
+}
 
 void SchedulerStateMachine::WillAnimate() {
   DCHECK(!animate_funnel_);
   last_frame_number_animate_performed_ = current_frame_number_;
   animate_funnel_ = true;
   needs_animate_ = false;
   // TODO(skyostil): Instead of assuming this, require the client to tell us.
   SetNeedsRedraw();
 }
 
@@ skipping 74 matching lines @@
 
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION)
     forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_DRAW;
 
   has_pending_tree_ = false;
   pending_tree_is_ready_for_activation_ = false;
   active_tree_needs_first_draw_ = true;
   needs_redraw_ = true;
 }
 
-void SchedulerStateMachine::WillDraw(bool did_request_swap) {
+void SchedulerStateMachine::WillDraw() {
+  // We need to reset needs_redraw_ before we draw since the
+  // draw itself might request another draw.
+  needs_redraw_ = false;
+}
+
+void SchedulerStateMachine::DidDraw(bool did_request_swap) {
+  active_tree_needs_first_draw_ = false;
+
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
     forced_redraw_state_ = FORCED_REDRAW_STATE_IDLE;
 
   if (begin_main_frame_state_ == BEGIN_MAIN_FRAME_STATE_WAITING_FOR_DRAW)
     begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_IDLE;
 
-  needs_redraw_ = false;
-  active_tree_needs_first_draw_ = false;
-
   if (did_request_swap) {
     DCHECK(!request_swap_funnel_);
     request_swap_funnel_ = true;
     did_request_swap_in_last_frame_ = true;
     last_frame_number_swap_requested_ = current_frame_number_;
   }
+
+  switch (last_draw_result_) {
+    case INVALID_RESULT:
+      NOTREACHED() << "Uninitialized DrawResult.";
+      break;
+    case DRAW_ABORTED_CANT_DRAW:
+    case DRAW_ABORTED_CONTEXT_LOST:
+      NOTREACHED() << "Invalid return value from DrawAndSwapIfPossible:"
+                   << last_draw_result_;
+      break;
+    case DRAW_SUCCESS:
+      consecutive_checkerboard_animations_ = 0;
+      forced_redraw_state_ = FORCED_REDRAW_STATE_IDLE;
+      break;
+    case DRAW_ABORTED_CHECKERBOARD_ANIMATIONS:
+      needs_redraw_ = true;
+
+      // If we're already in the middle of a redraw, we don't need to
+      // restart it.
+      if (forced_redraw_state_ != FORCED_REDRAW_STATE_IDLE)
+        return;
+
+      needs_begin_main_frame_ = true;
+      consecutive_checkerboard_animations_++;
+      if (settings_.timeout_and_draw_when_animation_checkerboards &&
+          consecutive_checkerboard_animations_ >=
+              settings_.maximum_number_of_failed_draws_before_draw_is_forced) {
+        consecutive_checkerboard_animations_ = 0;
+        // We need to force a draw, but it doesn't make sense to do this until
+        // we've committed and have new textures.
+        forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_COMMIT;
+      }
+      break;
+    case DRAW_ABORTED_MISSING_HIGH_RES_CONTENT:
+      // It's not clear whether this missing content is because of missing
+      // pictures (which requires a commit) or because of memory pressure
+      // removing textures (which might not).  To be safe, request a commit
+      // anyway.
+      needs_begin_main_frame_ = true;
+      break;
+  }
+
+  last_draw_result_ = DRAW_SUCCESS;
 }
 
 void SchedulerStateMachine::WillPrepareTiles() {
   needs_prepare_tiles_ = false;
 }
 
 void SchedulerStateMachine::WillBeginOutputSurfaceCreation() {
   DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_LOST);
   output_surface_state_ = OUTPUT_SURFACE_CREATING;
 
@@ skipping 293 matching lines @@
 
 void SchedulerStateMachine::DidSwapBuffersComplete() {
   pending_swaps_--;
 }
 
 void SchedulerStateMachine::SetImplLatencyTakesPriority(
     bool impl_latency_takes_priority) {
   impl_latency_takes_priority_ = impl_latency_takes_priority;
 }
 
-void SchedulerStateMachine::DidDrawIfPossibleCompleted(DrawResult result) {
-  switch (result) {
-    case INVALID_RESULT:
-      NOTREACHED() << "Uninitialized DrawResult.";
-      break;
-    case DRAW_ABORTED_CANT_DRAW:
-    case DRAW_ABORTED_CONTEXT_LOST:
-      NOTREACHED() << "Invalid return value from DrawAndSwapIfPossible:"
-                   << result;
-      break;
-    case DRAW_SUCCESS:
-      consecutive_checkerboard_animations_ = 0;
-      forced_redraw_state_ = FORCED_REDRAW_STATE_IDLE;
-      break;
-    case DRAW_ABORTED_CHECKERBOARD_ANIMATIONS:
-      needs_redraw_ = true;
-
-      // If we're already in the middle of a redraw, we don't need to
-      // restart it.
-      if (forced_redraw_state_ != FORCED_REDRAW_STATE_IDLE)
-        return;
-
-      needs_begin_main_frame_ = true;
-      consecutive_checkerboard_animations_++;
-      if (settings_.timeout_and_draw_when_animation_checkerboards &&
-          consecutive_checkerboard_animations_ >=
-              settings_.maximum_number_of_failed_draws_before_draw_is_forced) {
-        consecutive_checkerboard_animations_ = 0;
-        // We need to force a draw, but it doesn't make sense to do this until
-        // we've committed and have new textures.
-        forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_COMMIT;
-      }
-      break;
-    case DRAW_ABORTED_MISSING_HIGH_RES_CONTENT:
-      // It's not clear whether this missing content is because of missing
-      // pictures (which requires a commit) or because of memory pressure
-      // removing textures (which might not).  To be safe, request a commit
-      // anyway.
-      needs_begin_main_frame_ = true;
-      break;
-  }
+void SchedulerStateMachine::SetDrawResult(DrawResult result) {
+  last_draw_result_ = result;
 }
 
 void SchedulerStateMachine::SetNeedsBeginMainFrame() {
   needs_begin_main_frame_ = true;
 }
 
 void SchedulerStateMachine::NotifyReadyToCommit() {
   DCHECK(begin_main_frame_state_ == BEGIN_MAIN_FRAME_STATE_STARTED)
       << AsValue()->ToString();
   begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_READY_TO_COMMIT;
@@ skipping 73 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