scheduler: Convert enums to enum classes

content/renderer/scheduler/task_queue_manager.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/task_queue_manager.h"
 
 #include <queue>
 
 #include "base/bind.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 10 matching lines @@
 
 class TaskQueue : public base::SingleThreadTaskRunner {
  public:
   TaskQueue(TaskQueueManager* task_queue_manager);
 
   // base::SingleThreadTaskRunner implementation.
   bool RunsTasksOnCurrentThread() const override;
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
                        base::TimeDelta delay) override {
-    return PostDelayedTaskImpl(from_here, task, delay, NORMAL_TASK_TYPE);
+    return PostDelayedTaskImpl(from_here, task, delay, TaskType::NORMAL);
   }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   const base::Closure& task,
                                   base::TimeDelta delay) override {
-    return PostDelayedTaskImpl(from_here, task, delay, NON_NESTABLE_TASK_TYPE);
+    return PostDelayedTaskImpl(from_here, task, delay, TaskType::NON_NESTABLE);
   }
 
   bool IsQueueEmpty() const;
 
   void SetPumpPolicy(TaskQueueManager::PumpPolicy pump_policy);
   void PumpQueue();
 
   bool UpdateWorkQueue(base::TimeTicks* next_pending_delayed_task,
                        TaskQueueManager::WorkQueueUpdateEventType event_type);
   base::PendingTask TakeTaskFromWorkQueue();
 
   void WillDeleteTaskQueueManager();
 
   base::TaskQueue& work_queue() { return work_queue_; }
 
   void set_name(const char* name) { name_ = name; }
 
   void AsValueInto(base::trace_event::TracedValue* state) const;
 
  private:
-  enum TaskType {
-    NORMAL_TASK_TYPE,
-    NON_NESTABLE_TASK_TYPE,
+  enum class TaskType {
+    NORMAL,
+    NON_NESTABLE,
   };
 
   ~TaskQueue() override;
 
   bool PostDelayedTaskImpl(const tracked_objects::Location& from_here,
                            const base::Closure& task,
                            base::TimeDelta delay,
                            TaskType task_type);
 
   // Adds a task at the end of the incoming task queue and schedules a call to
@@ skipping 24 matching lines @@
                       std::vector<base::TimeTicks>,
                       std::greater<base::TimeTicks>> delayed_task_run_times_;
 
   base::TaskQueue work_queue_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueue);
 };
 
 TaskQueue::TaskQueue(TaskQueueManager* task_queue_manager)
     : task_queue_manager_(task_queue_manager),
-      pump_policy_(TaskQueueManager::AUTO_PUMP_POLICY),
+      pump_policy_(TaskQueueManager::PumpPolicy::AUTO),
       name_(nullptr) {
 }
 
 TaskQueue::~TaskQueue() {
 }
 
 void TaskQueue::WillDeleteTaskQueueManager() {
   base::AutoLock lock(lock_);
   task_queue_manager_ = nullptr;
 }
 
 bool TaskQueue::RunsTasksOnCurrentThread() const {
   base::AutoLock lock(lock_);
   if (!task_queue_manager_)
     return false;
   return task_queue_manager_->RunsTasksOnCurrentThread();
 }
 
 bool TaskQueue::PostDelayedTaskImpl(const tracked_objects::Location& from_here,
                                     const base::Closure& task,
                                     base::TimeDelta delay,
                                     TaskType task_type) {
   base::AutoLock lock(lock_);
   if (!task_queue_manager_)
     return false;
 
   base::PendingTask pending_task(from_here, task, base::TimeTicks(),
-                                 task_type != NON_NESTABLE_TASK_TYPE);
+                                 task_type != TaskType::NON_NESTABLE);
   task_queue_manager_->DidQueueTask(&pending_task);
 
   if (delay > base::TimeDelta()) {
     pending_task.delayed_run_time = task_queue_manager_->Now() + delay;
     delayed_task_run_times_.push(pending_task.delayed_run_time);
     return task_queue_manager_->PostDelayedTask(
         from_here, Bind(&TaskQueue::EnqueueTask, this, pending_task), delay);
   }
   EnqueueTaskLocked(pending_task);
   return true;
 }
 
 bool TaskQueue::IsQueueEmpty() const {
   if (!work_queue_.empty())
     return false;
 
   {
     base::AutoLock lock(lock_);
     return incoming_queue_.empty();
   }
 }
 
 bool TaskQueue::ShouldAutoPumpQueueLocked(
     TaskQueueManager::WorkQueueUpdateEventType event_type) {
   lock_.AssertAcquired();
-  if (pump_policy_ == TaskQueueManager::MANUAL_PUMP_POLICY)
+  if (pump_policy_ == TaskQueueManager::PumpPolicy::MANUAL)
     return false;
-  if (pump_policy_ == TaskQueueManager::AUTO_PUMP_AFTER_WAKEUP_POLICY &&
-      event_type != TaskQueueManager::AFTER_WAKEUP_EVENT_TYPE)
+  if (pump_policy_ == TaskQueueManager::PumpPolicy::AFTER_WAKEUP &&
+      event_type != TaskQueueManager::WorkQueueUpdateEventType::AFTER_WAKEUP)
     return false;
   if (incoming_queue_.empty())
     return false;
   return true;
 }
 
 bool TaskQueue::UpdateWorkQueue(
     base::TimeTicks* next_pending_delayed_task,
     TaskQueueManager::WorkQueueUpdateEventType event_type) {
   if (!work_queue_.empty())
@@ skipping 29 matching lines @@
 
 void TaskQueue::EnqueueTask(const base::PendingTask& pending_task) {
   base::AutoLock lock(lock_);
   EnqueueTaskLocked(pending_task);
 }
 
 void TaskQueue::EnqueueTaskLocked(const base::PendingTask& pending_task) {
   lock_.AssertAcquired();
   if (!task_queue_manager_)
     return;
-  if (pump_policy_ == TaskQueueManager::AUTO_PUMP_POLICY &&
+  if (pump_policy_ == TaskQueueManager::PumpPolicy::AUTO &&
       incoming_queue_.empty())
     task_queue_manager_->MaybePostDoWorkOnMainRunner();
   incoming_queue_.push(pending_task);
 
   if (!pending_task.delayed_run_time.is_null()) {
     // Update the time of the next pending delayed task.
     while (!delayed_task_run_times_.empty() &&
            delayed_task_run_times_.top() <= pending_task.delayed_run_time) {
       delayed_task_run_times_.pop();
     }
     // Clear the delayed run time because we've already applied the delay
     // before getting here.
     incoming_queue_.back().delayed_run_time = base::TimeTicks();
   }
 }
 
 void TaskQueue::SetPumpPolicy(TaskQueueManager::PumpPolicy pump_policy) {
   base::AutoLock lock(lock_);
-  if (pump_policy == TaskQueueManager::AUTO_PUMP_POLICY &&
-      pump_policy_ != TaskQueueManager::AUTO_PUMP_POLICY) {
+  if (pump_policy == TaskQueueManager::PumpPolicy::AUTO &&
+      pump_policy_ != TaskQueueManager::PumpPolicy::AUTO) {
     PumpQueueLocked();
   }
   pump_policy_ = pump_policy;
 }
 
 void TaskQueue::PumpQueueLocked() {
   lock_.AssertAcquired();
   while (!incoming_queue_.empty()) {
     work_queue_.push(incoming_queue_.front());
     incoming_queue_.pop();
@@ skipping 19 matching lines @@
   state->BeginArray("work_queue");
   QueueAsValueInto(work_queue_, state);
   state->EndArray();
   state->EndDictionary();
 }
 
 // static
 const char* TaskQueue::PumpPolicyToString(
     TaskQueueManager::PumpPolicy pump_policy) {
   switch (pump_policy) {
-    case TaskQueueManager::AUTO_PUMP_POLICY:
-      return "auto_pump";
-    case TaskQueueManager::AUTO_PUMP_AFTER_WAKEUP_POLICY:
-      return "auto_pump_after_wakeup";
-    case TaskQueueManager::MANUAL_PUMP_POLICY:
-      return "manual_pump";
+    case TaskQueueManager::PumpPolicy::AUTO:
+      return "auto";
+    case TaskQueueManager::PumpPolicy::AFTER_WAKEUP:
+      return "after_wakeup";
+    case TaskQueueManager::PumpPolicy::MANUAL:
+      return "manual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 // static
 void TaskQueue::QueueAsValueInto(const base::TaskQueue& queue,
                                  base::trace_event::TracedValue* state) {
   base::TaskQueue queue_copy(queue);
@@ skipping 121 matching lines @@
 void TaskQueueManager::DoWork(bool posted_from_main_thread) {
   if (posted_from_main_thread) {
     pending_dowork_count_--;
     DCHECK_GE(pending_dowork_count_, 0);
   }
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   base::TimeTicks next_pending_delayed_task(
       base::TimeTicks::FromInternalValue(kMaxTimeTicks));
 
-  if (!UpdateWorkQueues(&next_pending_delayed_task, BEFORE_WAKEUP_EVENT_TYPE))
+  if (!UpdateWorkQueues(&next_pending_delayed_task,
+                        WorkQueueUpdateEventType::BEFORE_WAKEUP))
     return;
 
   base::PendingTask previous_task((tracked_objects::Location()),
                                   (base::Closure()));
   for (int i = 0; i < work_batch_size_; i++) {
     // Interrupt the work batch if we should run the next delayed task.
     if (i > 0 && next_pending_delayed_task.ToInternalValue() != kMaxTimeTicks &&
         Now() >= next_pending_delayed_task)
       return;
 
     size_t queue_index;
     if (!SelectWorkQueueToService(&queue_index))
       return;
     // Note that this function won't post another call to DoWork if one is
     // already pending, so it is safe to call it in a loop.
     MaybePostDoWorkOnMainRunner();
     ProcessTaskFromWorkQueue(queue_index, i > 0, &previous_task);
 
-    if (!UpdateWorkQueues(&next_pending_delayed_task, AFTER_WAKEUP_EVENT_TYPE))
+    if (!UpdateWorkQueues(&next_pending_delayed_task,
+                          WorkQueueUpdateEventType::AFTER_WAKEUP))
       return;
   }
 }
 
 bool TaskQueueManager::SelectWorkQueueToService(size_t* out_queue_index) {
   bool should_run = selector_->SelectWorkQueueToService(out_queue_index);
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "TaskQueueManager", this,
       AsValueWithSelectorResult(should_run, *out_queue_index));
   return should_run;
@@ skipping 93 matching lines @@
   state->EndArray();
   state->BeginDictionary("selector");
   selector_->AsValueInto(state.get());
   state->EndDictionary();
   if (should_run)
     state->SetInteger("selected_queue", selected_queue);
   return state;
 }
 
 }  // namespace content