cc: Remove SchedulerStateMachine::UpdateState

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 542 matching lines @@
     return ACTION_PREPARE_TILES;
   if (ShouldSendBeginMainFrame())
     return ACTION_SEND_BEGIN_MAIN_FRAME;
   if (ShouldInvalidateOutputSurface())
     return ACTION_INVALIDATE_OUTPUT_SURFACE;
   if (ShouldBeginOutputSurfaceCreation())
     return ACTION_BEGIN_OUTPUT_SURFACE_CREATION;
   return ACTION_NONE;
 }
 
-void SchedulerStateMachine::UpdateState(Action action) {
+void SchedulerStateMachine::WillAction(Action action) {
   switch (action) {
     case ACTION_NONE:
       return;
 
     case ACTION_ACTIVATE_SYNC_TREE:
-      UpdateStateOnActivation();
+      WillActivate();
       return;
 
     case ACTION_ANIMATE:
-      UpdateStateOnAnimate();
+      WillAnimate();
       return;
 
     case ACTION_SEND_BEGIN_MAIN_FRAME:
-      UpdateStateOnSendBeginMainFrame();
+      WillSendBeginMainFrame();
       return;
 
     case ACTION_COMMIT: {
       bool commit_has_no_updates = false;
-      UpdateStateOnCommit(commit_has_no_updates);
+      WillCommit(commit_has_no_updates);
       return;
     }
 
     case ACTION_DRAW_AND_SWAP_FORCED:
     case ACTION_DRAW_AND_SWAP_IF_POSSIBLE: {
       bool did_request_swap = true;
-      UpdateStateOnDraw(did_request_swap);
+      WillDraw(did_request_swap);
       return;
     }
 
     case ACTION_DRAW_AND_SWAP_ABORT: {
       bool did_request_swap = false;
-      UpdateStateOnDraw(did_request_swap);
+      WillDraw(did_request_swap);
       return;
     }
 
     case ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
-      UpdateStateOnBeginOutputSurfaceCreation();
+      WillBeginOutputSurfaceCreation();
       return;
 
     case ACTION_PREPARE_TILES:
-      UpdateStateOnPrepareTiles();
+      WillPrepareTiles();
       return;
 
     case ACTION_INVALIDATE_OUTPUT_SURFACE:
-      UpdateStateOnInvalidateOutputSurface();
+      WillInvalidateOutputSurface();
       return;
   }
 }
 
-void SchedulerStateMachine::UpdateStateOnAnimate() {
+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();
 }
 
-void SchedulerStateMachine::UpdateStateOnSendBeginMainFrame() {
+void SchedulerStateMachine::WillSendBeginMainFrame() {
   DCHECK(!has_pending_tree_ || settings_.main_frame_before_activation_enabled);
   DCHECK(visible_);
   DCHECK(!send_begin_main_frame_funnel_);
   begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_SENT;
   needs_begin_main_frame_ = false;
   send_begin_main_frame_funnel_ = true;
   last_frame_number_begin_main_frame_sent_ = current_frame_number_;
 }
 
-void SchedulerStateMachine::UpdateStateOnCommit(bool commit_has_no_updates) {
+void SchedulerStateMachine::WillCommit(bool commit_has_no_updates) {
   commit_count_++;
 
   // Animate after commit even if we've already animated.
   if (!commit_has_no_updates)
     animate_funnel_ = false;
 
   if (commit_has_no_updates || settings_.main_frame_before_activation_enabled) {
     begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_IDLE;
   } else {
     begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_WAITING_FOR_ACTIVATION;
@@ skipping 33 matching lines @@
   }
 
   // This post-commit work is common to both completed and aborted commits.
   pending_tree_is_ready_for_activation_ = false;
 
   if (continuous_painting_)
     needs_begin_main_frame_ = true;
   last_commit_had_no_updates_ = commit_has_no_updates;
 }
 
-void SchedulerStateMachine::UpdateStateOnActivation() {
+void SchedulerStateMachine::WillActivate() {
   if (begin_main_frame_state_ ==
       BEGIN_MAIN_FRAME_STATE_WAITING_FOR_ACTIVATION) {
     begin_main_frame_state_ = settings_.commit_to_active_tree
                                   ? BEGIN_MAIN_FRAME_STATE_WAITING_FOR_DRAW
                                   : BEGIN_MAIN_FRAME_STATE_IDLE;
   }
 
   if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION)
     output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
 
   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::UpdateStateOnDraw(bool did_request_swap) {
+void SchedulerStateMachine::WillDraw(bool did_request_swap) {
   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_;
   }
 }
 
-void SchedulerStateMachine::UpdateStateOnPrepareTiles() {
+void SchedulerStateMachine::WillPrepareTiles() {
   needs_prepare_tiles_ = false;
 }
 
-void SchedulerStateMachine::UpdateStateOnBeginOutputSurfaceCreation() {
+void SchedulerStateMachine::WillBeginOutputSurfaceCreation() {
   DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_LOST);
   output_surface_state_ = OUTPUT_SURFACE_CREATING;
 
   // The following DCHECKs make sure we are in the proper quiescent state.
   // The pipeline should be flushed entirely before we start output
   // surface creation to avoid complicated corner cases.
   DCHECK_EQ(begin_main_frame_state_, BEGIN_MAIN_FRAME_STATE_IDLE);
   DCHECK(!has_pending_tree_);
   DCHECK(!active_tree_needs_first_draw_);
 }
 
-void SchedulerStateMachine::UpdateStateOnInvalidateOutputSurface() {
+void SchedulerStateMachine::WillInvalidateOutputSurface() {
   DCHECK(!invalidate_output_surface_funnel_);
   invalidate_output_surface_funnel_ = true;
   last_frame_number_invalidate_output_surface_performed_ =
       current_frame_number_;
 
   // The synchronous compositor makes no guarantees about a draw coming in after
   // an invalidate so clear any flags that would cause the compositor's pipeline
   // to stall.
   active_tree_needs_first_draw_ = false;  // blocks commit if true
 }
@@ skipping 343 matching lines @@
   DCHECK_EQ(begin_main_frame_state_, BEGIN_MAIN_FRAME_STATE_SENT);
   switch (reason) {
     case CommitEarlyOutReason::ABORTED_OUTPUT_SURFACE_LOST:
     case CommitEarlyOutReason::ABORTED_NOT_VISIBLE:
     case CommitEarlyOutReason::ABORTED_DEFERRED_COMMIT:
       begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_IDLE;
       SetNeedsBeginMainFrame();
       return;
     case CommitEarlyOutReason::FINISHED_NO_UPDATES:
       bool commit_has_no_updates = true;
-      UpdateStateOnCommit(commit_has_no_updates);
+      WillCommit(commit_has_no_updates);
       return;
   }
 }
 
 void SchedulerStateMachine::DidPrepareTiles() {
   needs_prepare_tiles_ = false;
   // "Fill" the PrepareTiles funnel.
   prepare_tiles_funnel_++;
 }
 
@@ skipping 44 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