scheduler: Convert enums to enum classes

content/renderer/scheduler/task_queue_manager_unittest.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 "base/test/test_simple_task_runner.h"
 #include "base/threading/thread.h"
 #include "cc/test/test_now_source.h"
 #include "content/renderer/scheduler/task_queue_selector.h"
@@ skipping 267 matching lines @@
   EXPECT_TRUE(selector_->work_queues()[0]->front().delayed_run_time.is_null());
 
   // Let the task run normally.
   selector_->AppendQueueToService(0);
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, ManualPumping) {
   Initialize(1u);
-  manager_->SetPumpPolicy(0, TaskQueueManager::MANUAL_PUMP_POLICY);
+  manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 
   std::vector<int> run_order;
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       manager_->TaskRunnerForQueue(0);
 
   // Posting a task when pumping is disabled doesn't result in work getting
   // posted.
   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   EXPECT_FALSE(test_task_runner_->HasPendingTask());
 
   // However polling still works.
   EXPECT_FALSE(manager_->IsQueueEmpty(0));
 
   // After pumping the task runs normally.
   manager_->PumpQueue(0);
   EXPECT_TRUE(test_task_runner_->HasPendingTask());
   selector_->AppendQueueToService(0);
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, ManualPumpingToggle) {
   Initialize(1u);
-  manager_->SetPumpPolicy(0, TaskQueueManager::MANUAL_PUMP_POLICY);
+  manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 
   std::vector<int> run_order;
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       manager_->TaskRunnerForQueue(0);
 
   // Posting a task when pumping is disabled doesn't result in work getting
   // posted.
   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   EXPECT_FALSE(test_task_runner_->HasPendingTask());
 
   // When pumping is enabled the task runs normally.
-  manager_->SetPumpPolicy(0, TaskQueueManager::AUTO_PUMP_POLICY);
+  manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AUTO);
   EXPECT_TRUE(test_task_runner_->HasPendingTask());
   selector_->AppendQueueToService(0);
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, DenyRunning) {
   Initialize(1u);
 
   std::vector<int> run_order;
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       manager_->TaskRunnerForQueue(0);
   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 
   // Since we haven't appended a work queue to be selected, the task doesn't
   // run.
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   // Pumping the queue again with a selected work queue runs the task.
   manager_->PumpQueue(0);
   selector_->AppendQueueToService(0);
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, ManualPumpingWithDelayedTask) {
   Initialize(1u);
-  manager_->SetPumpPolicy(0, TaskQueueManager::MANUAL_PUMP_POLICY);
+  manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 
   std::vector<int> run_order;
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       manager_->TaskRunnerForQueue(0);
 
   // Posting a delayed task when pumping will apply the delay, but won't cause
   // work to executed afterwards.
   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
   runner->PostDelayedTask(
       FROM_HERE, base::Bind(&TestTask, 1, &run_order), delay);
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   // After pumping the task runs normally.
   manager_->PumpQueue(0);
   EXPECT_TRUE(test_task_runner_->HasPendingTask());
   selector_->AppendQueueToService(0);
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, ManualPumpingWithNonEmptyWorkQueue) {
   Initialize(1u);
-  manager_->SetPumpPolicy(0, TaskQueueManager::MANUAL_PUMP_POLICY);
+  manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 
   std::vector<int> run_order;
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       manager_->TaskRunnerForQueue(0);
 
   // Posting two tasks and pumping twice should result in two tasks in the work
   // queue.
   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   manager_->PumpQueue(0);
   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
@@ skipping 191 matching lines @@
   EXPECT_THAT(run_order, ElementsAre(2));
 
   // Running all remaining tasks should execute both pending tasks.
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(2, 3, 1));
 }
 
 TEST_F(TaskQueueManagerTest, AutoPumpOnWakeup) {
   Initialize(2u);
   EXPECT_EQ(2u, selector_->work_queues().size());
-  manager_->SetPumpPolicy(0, TaskQueueManager::AUTO_PUMP_AFTER_WAKEUP_POLICY);
+  manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 
   std::vector<int> run_order;
   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 
   selector_->AppendQueueToService(1);
   selector_->AppendQueueToService(0);
   selector_->AppendQueueToService(0);
 
   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());  // Shouldn't run - no other task to wake TQM.
 
   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());  // Still shouldn't wake TQM.
 
   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
   test_task_runner_->RunUntilIdle();
   // Executing a task on an auto pumped queue should wake the TQM.
   EXPECT_THAT(run_order, ElementsAre(3, 1, 2));
 }
 
 TEST_F(TaskQueueManagerTest, AutoPumpOnWakeupWhenAlreadyAwake) {
   Initialize(2u);
   EXPECT_EQ(2u, selector_->work_queues().size());
-  manager_->SetPumpPolicy(0, TaskQueueManager::AUTO_PUMP_AFTER_WAKEUP_POLICY);
+  manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 
   std::vector<int> run_order;
   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 
   selector_->AppendQueueToService(1);
   selector_->AppendQueueToService(0);
 
   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1, 2));  // TQM was already awake.
 }
 
 TEST_F(TaskQueueManagerTest, AutoPumpOnWakeupTriggeredByManuallyPumpedQueue) {
   Initialize(2u);
   EXPECT_EQ(2u, selector_->work_queues().size());
-  manager_->SetPumpPolicy(0, TaskQueueManager::AUTO_PUMP_AFTER_WAKEUP_POLICY);
-  manager_->SetPumpPolicy(1, TaskQueueManager::MANUAL_PUMP_POLICY);
+  manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
+  manager_->SetPumpPolicy(1, TaskQueueManager::PumpPolicy::MANUAL);
 
   std::vector<int> run_order;
   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 
   selector_->AppendQueueToService(1);
   selector_->AppendQueueToService(0);
 
   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   test_task_runner_->RunUntilIdle();
@@ skipping 79 matching lines @@
   selector_->AppendQueueToService(0);
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(1);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
   message_loop_->RunUntilIdle();
 }
 
 }  // namespace
 }  // namespace content