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

cc/scheduler/scheduler.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.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
@@ skipping 74 matching lines @@
       primary_frame_source_internal_(external_begin_frame_source.Pass()),
       background_frame_source_internal_(),
       vsync_observer_(NULL),
       settings_(scheduler_settings),
       client_(client),
       layer_tree_host_id_(layer_tree_host_id),
       task_runner_(task_runner),
       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",
                "settings",
                settings_.AsValue());
   DCHECK(client_);
   DCHECK(!state_machine_.BeginFrameNeeded());
 
   begin_retro_frame_closure_ =
       base::Bind(&Scheduler::BeginRetroFrame, weak_factory_.GetWeakPtr());
@@ skipping 111 matching lines @@
   state_machine_.SetNeedsRedraw();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetNeedsAnimate() {
   state_machine_.SetNeedsAnimate();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetNeedsPrepareTiles() {
-  DCHECK(!IsInsideAction(SchedulerStateMachine::ACTION_PREPARE_TILES));
+  DCHECK(!IsInsideAction(SchedulerStateMachine::Action::PREPARE_TILES));
   state_machine_.SetNeedsPrepareTiles();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetMaxSwapsPending(int max) {
   state_machine_.SetMaxSwapsPending(max);
 }
 
 void Scheduler::DidSwapBuffers() {
   state_machine_.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);
   }
 }
 
 void Scheduler::DidSwapBuffersComplete() {
   state_machine_.DidSwapBuffersComplete();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetImplLatencyTakesPriority(bool impl_latency_takes_priority) {
   state_machine_.SetImplLatencyTakesPriority(impl_latency_takes_priority);
@@ skipping 57 matching lines @@
 void Scheduler::SetupNextBeginFrameIfNeeded() {
   if (!task_runner_.get())
     return;
 
   if (state_machine_.ShouldSetNeedsBeginFrames(
           frame_source_->NeedsBeginFrames())) {
     frame_source_->SetNeedsBeginFrames(state_machine_.BeginFrameNeeded());
   }
 
   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());
   }
 
   PostBeginRetroFrameIfNeeded();
   SetupPollingMechanisms();
 }
 
 // We may need to poll when we can't rely on BeginFrame to advance certain
 // state or to avoid deadlock.
 void Scheduler::SetupPollingMechanisms() {
@@ skipping 79 matching lines @@
 
   bool should_defer_begin_frame;
   if (settings_.using_synchronous_renderer_compositor) {
     should_defer_begin_frame = false;
   } else {
     should_defer_begin_frame =
         !begin_retro_frame_args_.empty() ||
         !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) {
     begin_retro_frame_args_.push_back(adjusted_args);
     TRACE_EVENT_INSTANT0(
         "cc", "Scheduler::BeginFrame deferred", TRACE_EVENT_SCOPE_THREAD);
     // Queuing the frame counts as "using it", so we need to return true.
   } else {
     BeginImplFrame(adjusted_args);
   }
   return true;
 }
 
 void Scheduler::SetChildrenNeedBeginFrames(bool children_need_begin_frames) {
   DCHECK(settings_.forward_begin_frames_to_children);
   state_machine_.SetChildrenNeedBeginFrames(children_need_begin_frames);
   ProcessScheduledActions();
 }
 
 // BeginRetroFrame is called for BeginFrames that we've deferred because
 // the scheduler was in the middle of processing a previous BeginFrame.
 void Scheduler::BeginRetroFrame() {
   TRACE_EVENT0("cc", "Scheduler::BeginRetroFrame");
   DCHECK(!settings_.using_synchronous_renderer_compositor);
   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();
 
   // Discard expired BeginRetroFrames
   // Today, we should always end up with at most one un-expired BeginRetroFrame
   // because deadlines will not be greater than the next frame time. We don't
   // DCHECK though because some systems don't always have monotonic timestamps.
   // TODO(brianderson): In the future, long deadlines could result in us not
   // draining the queue if we don't catch up. If we consistently can't catch
   // up, our fallback should be to lower our frame rate.
@@ skipping 36 matching lines @@
     return;
 
   if (begin_retro_frame_args_.empty() || !begin_retro_frame_task_.IsCancelled())
     return;
 
   // begin_retro_frame_args_ should always be empty for the
   // synchronous compositor.
   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_);
 
   task_runner_->PostTask(FROM_HERE, begin_retro_frame_task_.callback());
 }
 
 // BeginImplFrame starts a compositor frame that will wait up until a deadline
 // for a BeginMainFrame+activation to complete before it times out and draws
 // any asynchronous animation and scroll/pinch updates.
 void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
   bool main_thread_is_in_high_latency_mode =
       state_machine_.MainThreadIsInHighLatencyMode();
   TRACE_EVENT2("cc",
                "Scheduler::BeginImplFrame",
                "args",
                args.AsValue(),
                "main_thread_is_high_latency",
                main_thread_is_in_high_latency_mode);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                  "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();
 
   begin_impl_frame_args_ = args;
   begin_impl_frame_args_.deadline -= client_->DrawDurationEstimate();
 
   if (!state_machine_.impl_latency_takes_priority() &&
       main_thread_is_in_high_latency_mode &&
       CanCommitAndActivateBeforeDeadline()) {
@@ skipping 25 matching lines @@
   DCHECK(!settings_.using_synchronous_renderer_compositor);
 
   begin_impl_frame_deadline_task_.Cancel();
   begin_impl_frame_deadline_task_.Reset(begin_impl_frame_deadline_closure_);
 
   begin_impl_frame_deadline_mode_ =
       state_machine_.CurrentBeginImplFrameDeadlineMode();
 
   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.
       deadline =
           begin_impl_frame_args_.frame_time + begin_impl_frame_args_.interval;
       break;
   }
 
   TRACE_EVENT1(
       "cc", "Scheduler::ScheduleBeginImplFrameDeadline", "deadline", deadline);
 
   base::TimeDelta delta = deadline - Now();
   if (delta <= base::TimeDelta())
     delta = base::TimeDelta();
   task_runner_->PostDelayedTask(
       FROM_HERE, begin_impl_frame_deadline_task_.callback(), delta);
 }
 
 void Scheduler::RescheduleBeginImplFrameDeadlineIfNeeded() {
   if (settings_.using_synchronous_renderer_compositor)
     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_ !=
       state_machine_.CurrentBeginImplFrameDeadlineMode())
     ScheduleBeginImplFrameDeadline();
 }
 
 void Scheduler::OnBeginImplFrameDeadline() {
   TRACE_EVENT0("cc", "Scheduler::OnBeginImplFrameDeadline");
   begin_impl_frame_deadline_task_.Cancel();
@@ skipping 46 matching lines @@
                  "SchedulerStateMachine",
                  "state",
                  AsValue());
     VLOG(2) << "Scheduler::ProcessScheduledActions: "
             << SchedulerStateMachine::ActionToString(action) << " "
             << state_machine_.GetStatesForDebugging();
     state_machine_.UpdateState(action);
     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());
 
   RescheduleBeginImplFrameDeadlineIfNeeded();
 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat> Scheduler::AsValue()
     const {
   scoped_refptr<base::debug::TracedValue> state =
@@ skipping 66 matching lines @@
       "time_left_after_drawing_ms",
       (begin_impl_frame_args_.deadline - estimated_draw_time).InMillisecondsF(),
       "state",
       AsValue());
 
   return estimated_draw_time < begin_impl_frame_args_.deadline;
 }
 
 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