scheduler: Convert enums to enum classes

content/renderer/scheduler/renderer_scheduler_impl.cc

 // Copyright 2014 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 "content/renderer/scheduler/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
@@ skipping 13 matching lines @@
       control_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(CONTROL_TASK_QUEUE)),
       control_task_after_wakeup_runner_(task_queue_manager_->TaskRunnerForQueue(
           CONTROL_TASK_AFTER_WAKEUP_QUEUE)),
       default_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(DEFAULT_TASK_QUEUE)),
       compositor_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(COMPOSITOR_TASK_QUEUE)),
       loading_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(LOADING_TASK_QUEUE)),
-      current_policy_(NORMAL_PRIORITY_POLICY),
+      current_policy_(Policy::NORMAL),
       last_input_type_(blink::WebInputEvent::Undefined),
-      input_stream_state_(INPUT_INACTIVE),
+      input_stream_state_(InputStreamState::INACTIVE),
       policy_may_need_update_(&incoming_signals_lock_),
       weak_factory_(this) {
   weak_renderer_scheduler_ptr_ = weak_factory_.GetWeakPtr();
   update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                                       weak_renderer_scheduler_ptr_);
   end_idle_period_closure_.Reset(base::Bind(
       &RendererSchedulerImpl::EndIdlePeriod, weak_renderer_scheduler_ptr_));
   idle_task_runner_ = make_scoped_refptr(new SingleThreadIdleTaskRunner(
       task_queue_manager_->TaskRunnerForQueue(IDLE_TASK_QUEUE),
       control_task_after_wakeup_runner_,
       base::Bind(&RendererSchedulerImpl::CurrentIdleTaskDeadlineCallback,
                  weak_renderer_scheduler_ptr_)));
 
   renderer_task_queue_selector_->SetQueuePriority(
       CONTROL_TASK_QUEUE, RendererTaskQueueSelector::CONTROL_PRIORITY);
 
   renderer_task_queue_selector_->SetQueuePriority(
       CONTROL_TASK_AFTER_WAKEUP_QUEUE,
       RendererTaskQueueSelector::CONTROL_PRIORITY);
   task_queue_manager_->SetPumpPolicy(
       CONTROL_TASK_AFTER_WAKEUP_QUEUE,
-      TaskQueueManager::AUTO_PUMP_AFTER_WAKEUP_POLICY);
+      TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 
   renderer_task_queue_selector_->DisableQueue(IDLE_TASK_QUEUE);
   task_queue_manager_->SetPumpPolicy(IDLE_TASK_QUEUE,
-                                     TaskQueueManager::MANUAL_PUMP_POLICY);
+                                     TaskQueueManager::PumpPolicy::MANUAL);
 
   // TODO(skyostil): Increase this to 4 (crbug.com/444764).
   task_queue_manager_->SetWorkBatchSize(1);
 
   for (size_t i = 0; i < TASK_QUEUE_COUNT; i++) {
     task_queue_manager_->SetQueueName(
         i, TaskQueueIdToString(static_cast<QueueId>(i)));
   }
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
@@ skipping 114 matching lines @@
 }
 
 bool RendererSchedulerImpl::IsHighPriorityWorkAnticipated() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return false;
 
   MaybeUpdatePolicy();
   // The touchstart and compositor policies indicate a strong likelihood of
   // high-priority work in the near future.
-  return SchedulerPolicy() == COMPOSITOR_PRIORITY_POLICY ||
-         SchedulerPolicy() == TOUCHSTART_PRIORITY_POLICY;
+  return SchedulerPolicy() == Policy::COMPOSITOR_PRIORITY ||
+         SchedulerPolicy() == Policy::TOUCHSTART_PRIORITY;
 }
 
 bool RendererSchedulerImpl::ShouldYieldForHighPriorityWork() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return false;
 
   MaybeUpdatePolicy();
   // We only yield if we are in the compositor priority and there is compositor
   // work outstanding, or if we are in the touchstart response priority.
   // Note: even though the control queue is higher priority we don't yield for
   // it since these tasks are not user-provided work and they are only intended
   // to run before the next task, not interrupt the tasks.
   switch (SchedulerPolicy()) {
-    case NORMAL_PRIORITY_POLICY:
+    case Policy::NORMAL:
       return false;
 
-    case COMPOSITOR_PRIORITY_POLICY:
+    case Policy::COMPOSITOR_PRIORITY:
       return !task_queue_manager_->IsQueueEmpty(COMPOSITOR_TASK_QUEUE);
 
-    case TOUCHSTART_PRIORITY_POLICY:
+    case Policy::TOUCHSTART_PRIORITY:
       return true;
 
     default:
       NOTREACHED();
       return false;
   }
 }
 
 void RendererSchedulerImpl::CurrentIdleTaskDeadlineCallback(
     base::TimeTicks* deadline_out) const {
@@ skipping 21 matching lines @@
 
 void RendererSchedulerImpl::UpdatePolicy() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return;
 
   base::AutoLock lock(incoming_signals_lock_);
   base::TimeTicks now;
   policy_may_need_update_.SetWhileLocked(false);
 
-  Policy new_policy = NORMAL_PRIORITY_POLICY;
-  if (input_stream_state_ != INPUT_INACTIVE) {
+  Policy new_policy = Policy::NORMAL;
+  if (input_stream_state_ != InputStreamState::INACTIVE) {
     base::TimeDelta new_priority_duration =
         base::TimeDelta::FromMilliseconds(kPriorityEscalationAfterInputMillis);
     base::TimeTicks new_priority_end(last_input_time_ + new_priority_duration);
     base::TimeDelta time_left_in_policy = new_priority_end - Now();
     if (time_left_in_policy > base::TimeDelta()) {
       PostUpdatePolicyOnControlRunner(time_left_in_policy);
       new_policy =
-          input_stream_state_ == INPUT_ACTIVE_AND_AWAITING_TOUCHSTART_RESPONSE
-              ? TOUCHSTART_PRIORITY_POLICY
-              : COMPOSITOR_PRIORITY_POLICY;
+          input_stream_state_ ==
+                  InputStreamState::ACTIVE_AND_AWAITING_TOUCHSTART_RESPONSE
+              ? Policy::TOUCHSTART_PRIORITY
+              : Policy::COMPOSITOR_PRIORITY;
     } else {
       // Reset |input_stream_state_| to ensure
       // DidReceiveInputEventOnCompositorThread will post an UpdatePolicy task
       // when it's next called.
-      input_stream_state_ = INPUT_INACTIVE;
+      input_stream_state_ = InputStreamState::INACTIVE;
     }
   }
 
   if (new_policy == current_policy_)
     return;
 
   switch (new_policy) {
-    case COMPOSITOR_PRIORITY_POLICY:
+    case Policy::COMPOSITOR_PRIORITY:
       renderer_task_queue_selector_->SetQueuePriority(
           COMPOSITOR_TASK_QUEUE, RendererTaskQueueSelector::HIGH_PRIORITY);
       // TODO(scheduler-dev): Add a task priority between HIGH and BEST_EFFORT
       // that still has some guarantee of running.
       renderer_task_queue_selector_->SetQueuePriority(
           LOADING_TASK_QUEUE, RendererTaskQueueSelector::BEST_EFFORT_PRIORITY);
       break;
-    case TOUCHSTART_PRIORITY_POLICY:
+    case Policy::TOUCHSTART_PRIORITY:
       renderer_task_queue_selector_->SetQueuePriority(
           COMPOSITOR_TASK_QUEUE, RendererTaskQueueSelector::HIGH_PRIORITY);
       renderer_task_queue_selector_->DisableQueue(LOADING_TASK_QUEUE);
       break;
-    case NORMAL_PRIORITY_POLICY:
+    case Policy::NORMAL:
       renderer_task_queue_selector_->SetQueuePriority(
           COMPOSITOR_TASK_QUEUE, RendererTaskQueueSelector::NORMAL_PRIORITY);
       renderer_task_queue_selector_->SetQueuePriority(
           LOADING_TASK_QUEUE, RendererTaskQueueSelector::NORMAL_PRIORITY);
       break;
   }
   DCHECK(renderer_task_queue_selector_->IsQueueEnabled(COMPOSITOR_TASK_QUEUE));
-  if (new_policy != TOUCHSTART_PRIORITY_POLICY)
+  if (new_policy != Policy::TOUCHSTART_PRIORITY)
     DCHECK(renderer_task_queue_selector_->IsQueueEnabled(LOADING_TASK_QUEUE));
 
   current_policy_ = new_policy;
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValueLocked(now));
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.policy", current_policy_);
 }
@@ skipping 77 matching lines @@
       return "control_after_wakeup_tq";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 // static
 const char* RendererSchedulerImpl::PolicyToString(Policy policy) {
   switch (policy) {
-    case NORMAL_PRIORITY_POLICY:
+    case Policy::NORMAL:
       return "normal";
-    case COMPOSITOR_PRIORITY_POLICY:
+    case Policy::COMPOSITOR_PRIORITY:
       return "compositor";
-    case TOUCHSTART_PRIORITY_POLICY:
+    case Policy::TOUCHSTART_PRIORITY:
       return "touchstart";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 const char* RendererSchedulerImpl::InputStreamStateToString(
     InputStreamState state) {
   switch (state) {
-    case INPUT_INACTIVE:
+    case InputStreamState::INACTIVE:
       return "inactive";
-    case INPUT_ACTIVE:
+    case InputStreamState::ACTIVE:
       return "active";
-    case INPUT_ACTIVE_AND_AWAITING_TOUCHSTART_RESPONSE:
+    case InputStreamState::ACTIVE_AND_AWAITING_TOUCHSTART_RESPONSE:
       return "active_and_awaiting_touchstart_response";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 RendererSchedulerImpl::AsValueLocked(base::TimeTicks optional_now) const {
   DCHECK(main_thread_checker_.CalledOnValidThread());
@@ skipping 17 matching lines @@
   return state;
 }
 
 RendererSchedulerImpl::InputStreamState
 RendererSchedulerImpl::ComputeNewInputStreamState(
     InputStreamState current_state,
     blink::WebInputEvent::Type new_input_type,
     blink::WebInputEvent::Type last_input_type) {
   switch (new_input_type) {
     case blink::WebInputEvent::TouchStart:
-      return INPUT_ACTIVE_AND_AWAITING_TOUCHSTART_RESPONSE;
+      return InputStreamState::ACTIVE_AND_AWAITING_TOUCHSTART_RESPONSE;
 
     case blink::WebInputEvent::TouchMove:
       // Observation of consecutive touchmoves is a strong signal that the page
       // is consuming the touch sequence, in which case touchstart response
       // prioritization is no longer necessary. Otherwise, the initial touchmove
       // should preserve the touchstart response pending state.
-      if (current_state == INPUT_ACTIVE_AND_AWAITING_TOUCHSTART_RESPONSE) {
+      if (current_state ==
+          InputStreamState::ACTIVE_AND_AWAITING_TOUCHSTART_RESPONSE) {
         return last_input_type == blink::WebInputEvent::TouchMove
-                   ? INPUT_ACTIVE
-                   : INPUT_ACTIVE_AND_AWAITING_TOUCHSTART_RESPONSE;
+                   ? InputStreamState::ACTIVE
+                   : InputStreamState::ACTIVE_AND_AWAITING_TOUCHSTART_RESPONSE;
       }
       break;
 
     case blink::WebInputEvent::GestureTapDown:
     case blink::WebInputEvent::GestureShowPress:
     case blink::WebInputEvent::GestureFlingCancel:
     case blink::WebInputEvent::GestureScrollEnd:
       // With no observable effect, these meta events do not indicate a
       // meaningful touchstart response and should not impact task priority.
       return current_state;
 
     default:
       break;
   }
-  return INPUT_ACTIVE;
+  return InputStreamState::ACTIVE;
 }
 
 void RendererSchedulerImpl::AddTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (task_queue_manager_)
     task_queue_manager_->AddTaskObserver(task_observer);
 }
 
 void RendererSchedulerImpl::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (task_queue_manager_)
     task_queue_manager_->RemoveTaskObserver(task_observer);
 }
 
 }  // namespace content