Convert the enum objects in cc/scheduler/scheduler_state_machine.h to C++ "enum class" objects

cc/scheduler/scheduler.cc

Index: cc/scheduler/scheduler.cc
diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index 68571278fe31c18fe053fa7b33d091c399fad275..2dcaaef2a438033cfe57aa2749b7bcb5f809d0d1 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc
@@ -92,7 +92,7 @@ Scheduler::Scheduler(
       power_monitor_(power_monitor),
       state_machine_(scheduler_settings),
       inside_process_scheduled_actions_(false),
-      inside_action_(SchedulerStateMachine::ACTION_NONE),
+      inside_action_(SchedulerStateMachine::Action::NONE),
       weak_factory_(this) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                "Scheduler::Scheduler",
@@ -224,7 +224,7 @@ void Scheduler::SetNeedsAnimate() {
 }
 
 void Scheduler::SetNeedsPrepareTiles() {
-  DCHECK(!IsInsideAction(SchedulerStateMachine::ACTION_PREPARE_TILES));
+  DCHECK(!IsInsideAction(SchedulerStateMachine::Action::PREPARE_TILES));
   state_machine_.SetNeedsPrepareTiles();
   ProcessScheduledActions();
 }
@@ -239,7 +239,7 @@ void Scheduler::DidSwapBuffers() {
   // There is no need to call ProcessScheduledActions here because
   // swapping should not trigger any new actions.
   if (!inside_process_scheduled_actions_) {
-    DCHECK_EQ(state_machine_.NextAction(), SchedulerStateMachine::ACTION_NONE);
+    DCHECK_EQ(state_machine_.NextAction(), SchedulerStateMachine::Action::NONE);
   }
 }
 
@@ -317,7 +317,7 @@ void Scheduler::SetupNextBeginFrameIfNeeded() {
   }
 
   if (state_machine_.begin_impl_frame_state() ==
-      SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) {
+      SchedulerStateMachine::BeginImplFrameState::INSIDE_DEADLINE) {
     frame_source_->DidFinishFrame(begin_retro_frame_args_.size());
   }
 
@@ -417,7 +417,7 @@ bool Scheduler::OnBeginFrameMixInDelegate(const BeginFrameArgs& args) {
         !begin_retro_frame_task_.IsCancelled() ||
         !frame_source_->NeedsBeginFrames() ||
         (state_machine_.begin_impl_frame_state() !=
-         SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
+         SchedulerStateMachine::BeginImplFrameState::IDLE);
   }
 
   if (should_defer_begin_frame) {
@@ -445,7 +445,7 @@ void Scheduler::BeginRetroFrame() {
   DCHECK(!begin_retro_frame_args_.empty());
   DCHECK(!begin_retro_frame_task_.IsCancelled());
   DCHECK_EQ(state_machine_.begin_impl_frame_state(),
-            SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
+            SchedulerStateMachine::BeginImplFrameState::IDLE);
 
   begin_retro_frame_task_.Cancel();
 
@@ -502,7 +502,7 @@ void Scheduler::PostBeginRetroFrameIfNeeded() {
   DCHECK(!settings_.using_synchronous_renderer_compositor);
 
   if (state_machine_.begin_impl_frame_state() !=
-      SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE)
+      SchedulerStateMachine::BeginImplFrameState::IDLE)
     return;
 
   begin_retro_frame_task_.Reset(begin_retro_frame_closure_);
@@ -526,7 +526,7 @@ void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
                  "MainThreadLatency",
                  main_thread_is_in_high_latency_mode);
   DCHECK_EQ(state_machine_.begin_impl_frame_state(),
-            SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
+            SchedulerStateMachine::BeginImplFrameState::IDLE);
   DCHECK(state_machine_.HasInitializedOutputSurface());
 
   advance_commit_state_task_.Cancel();
@@ -572,16 +572,16 @@ void Scheduler::ScheduleBeginImplFrameDeadline() {
 
   base::TimeTicks deadline;
   switch (begin_impl_frame_deadline_mode_) {
-    case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_IMMEDIATE:
+    case SchedulerStateMachine::BeginImplFrameDeadlineMode::IMMEDIATE:
       // We are ready to draw a new active tree immediately.
       // We don't use Now() here because it's somewhat expensive to call.
       deadline = base::TimeTicks();
       break;
-    case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_REGULAR:
+    case SchedulerStateMachine::BeginImplFrameDeadlineMode::REGULAR:
       // We are animating on the impl thread but we can wait for some time.
       deadline = begin_impl_frame_args_.deadline;
       break;
-    case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_LATE:
+    case SchedulerStateMachine::BeginImplFrameDeadlineMode::LATE:
       // We are blocked for one reason or another and we should wait.
       // TODO(brianderson): Handle long deadlines (that are past the next
       // frame's frame time) properly instead of using this hack.
@@ -605,7 +605,7 @@ void Scheduler::RescheduleBeginImplFrameDeadlineIfNeeded() {
     return;
 
   if (state_machine_.begin_impl_frame_state() !=
-      SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME)
+      SchedulerStateMachine::BeginImplFrameState::INSIDE_BEGIN_FRAME)
     return;
 
   if (begin_impl_frame_deadline_mode_ !=
@@ -672,38 +672,38 @@ void Scheduler::ProcessScheduledActions() {
     base::AutoReset<SchedulerStateMachine::Action>
         mark_inside_action(&inside_action_, action);
     switch (action) {
-      case SchedulerStateMachine::ACTION_NONE:
+      case SchedulerStateMachine::Action::NONE:
         break;
-      case SchedulerStateMachine::ACTION_ANIMATE:
+      case SchedulerStateMachine::Action::ANIMATE:
         client_->ScheduledActionAnimate();
         break;
-      case SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME:
+      case SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME:
         client_->ScheduledActionSendBeginMainFrame();
         break;
-      case SchedulerStateMachine::ACTION_COMMIT:
+      case SchedulerStateMachine::Action::COMMIT:
         client_->ScheduledActionCommit();
         break;
-      case SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE:
+      case SchedulerStateMachine::Action::ACTIVATE_SYNC_TREE:
         client_->ScheduledActionActivateSyncTree();
         break;
-      case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE:
+      case SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE:
         DrawAndSwapIfPossible();
         break;
-      case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_FORCED:
+      case SchedulerStateMachine::Action::DRAW_AND_SWAP_FORCED:
         client_->ScheduledActionDrawAndSwapForced();
         break;
-      case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT:
+      case SchedulerStateMachine::Action::DRAW_AND_SWAP_ABORT:
         // No action is actually performed, but this allows the state machine to
         // advance out of its waiting to draw state without actually drawing.
         break;
-      case SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
+      case SchedulerStateMachine::Action::BEGIN_OUTPUT_SURFACE_CREATION:
         client_->ScheduledActionBeginOutputSurfaceCreation();
         break;
-      case SchedulerStateMachine::ACTION_PREPARE_TILES:
+      case SchedulerStateMachine::Action::PREPARE_TILES:
         client_->ScheduledActionPrepareTiles();
         break;
     }
-  } while (action != SchedulerStateMachine::ACTION_NONE);
+  } while (action != SchedulerStateMachine::Action::NONE);
 
   SetupNextBeginFrameIfNeeded();
   client_->DidAnticipatedDrawTimeChange(AnticipatedDrawTime());
@@ -790,9 +790,9 @@ bool Scheduler::CanCommitAndActivateBeforeDeadline() const {
 
 bool Scheduler::IsBeginMainFrameSentOrStarted() const {
   return (state_machine_.commit_state() ==
-              SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT ||
+              SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT ||
           state_machine_.commit_state() ==
-              SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED);
+              SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_STARTED);
 }
 
 }  // namespace cc