[scheduling] Remove QueueClass::kTimer.

This queue class name is not accurate to the way that it is currently
used and it can be merged with QueueClass::kNone. This class encompasses
all of the 'kFrame' QueueTypes that are non-loading (kFrameThrottleable,
kFramePausabale, kFrameDeferrable, etc.). Removing this QueueClass
will prevent confusion when differentiating between queues with this
class and JavaScriptTimer queues.

Change-Id: I847eb5d1635eb2932a0399369e982f7a709ece0c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2341394Reviewed-by: Sami Kyöstilä <skyostil@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Reviewed-by: Scott Haseley <shaseley@chromium.org>
Commit-Queue: Katie Dillon <kdillon@chromium.org>
Cr-Commit-Position: refs/heads/master@{#800594}

third_party/blink/renderer/platform/scheduler/common/throttling/budget_pool_unittest.cc

@@ -129,8 +129,7 @@ TEST_F(BudgetPoolTest, WakeUpBudgetPool) {
       task_queue_throttler_->CreateWakeUpBudgetPool("test");
 
   scoped_refptr<base::sequence_manager::TaskQueue> queue =
-      scheduler_->NewTimerTaskQueue(
-          MainThreadTaskQueue::QueueType::kFrameThrottleable, nullptr);
+      scheduler_->NewThrottleableTaskQueueForTest(nullptr);
 
   pool->SetWakeUpInterval(base::TimeTicks(), base::TimeDelta::FromSeconds(10));
   pool->SetWakeUpDuration(base::TimeDelta::FromMilliseconds(10));

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.cc

@@ -714,7 +714,7 @@ scoped_refptr<MainThreadTaskQueue> MainThreadSchedulerImpl::NewTaskQueue(
   return task_queue;
 }
 
-// TODO(sreejakshetty): Cleanup NewLoadingTaskQueue and NewTimerTaskQueue.
+// TODO(sreejakshetty): Cleanup NewLoadingTaskQueue.
 scoped_refptr<MainThreadTaskQueue> MainThreadSchedulerImpl::NewLoadingTaskQueue(
     MainThreadTaskQueue::QueueType queue_type,
     FrameSchedulerImpl* frame_scheduler) {
@@ -727,12 +727,11 @@ scoped_refptr<MainThreadTaskQueue> MainThreadSchedulerImpl::NewLoadingTaskQueue(
                           .SetFrameScheduler(frame_scheduler));
 }
 
-scoped_refptr<MainThreadTaskQueue> MainThreadSchedulerImpl::NewTimerTaskQueue(
-    MainThreadTaskQueue::QueueType queue_type,
+scoped_refptr<MainThreadTaskQueue>
+MainThreadSchedulerImpl::NewThrottleableTaskQueueForTest(
     FrameSchedulerImpl* frame_scheduler) {
-  DCHECK_EQ(MainThreadTaskQueue::QueueClassForQueueType(queue_type),
-            MainThreadTaskQueue::QueueClass::kTimer);
-  return NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(queue_type)
+  return NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
+                          MainThreadTaskQueue::QueueType::kFrameThrottleable)
                           .SetCanBePaused(true)
                           .SetCanBeFrozen(true)
                           .SetCanBeDeferred(true)
@@ -1456,7 +1455,7 @@ void MainThreadSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
     case UseCase::kTouchstart:
       new_policy.rail_mode() = RAILMode::kResponse;
       new_policy.loading_queue_policy().is_deferred = true;
-      new_policy.timer_queue_policy().is_deferred = true;
+      new_policy.default_queue_policy().is_deferred = true;
       break;
 
     case UseCase::kNone:
@@ -1487,17 +1486,16 @@ void MainThreadSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
 
   if (main_thread_only().renderer_pause_count != 0) {
     new_policy.loading_queue_policy().is_paused = true;
-    new_policy.timer_queue_policy().is_paused = true;
+    new_policy.default_queue_policy().is_paused = true;
   }
   if (main_thread_only().pause_timers_for_webview) {
-    new_policy.timer_queue_policy().is_paused = true;
+    new_policy.default_queue_policy().is_paused = true;
   }
 
   if (main_thread_only().use_virtual_time) {
     new_policy.compositor_queue_policy().use_virtual_time = true;
     new_policy.default_queue_policy().use_virtual_time = true;
     new_policy.loading_queue_policy().use_virtual_time = true;
-    new_policy.timer_queue_policy().use_virtual_time = true;
   }
 
   if (scheduling_settings_
@@ -2096,10 +2094,6 @@ void MainThreadSchedulerImpl::Policy::AsValueInto(
   loading_queue_policy().AsValueInto(state);
   state->EndDictionary();
 
-  state->BeginDictionary("timer_queue_policy");
-  timer_queue_policy().AsValueInto(state);
-  state->EndDictionary();
-
   state->BeginDictionary("default_queue_policy");
   default_queue_policy().AsValueInto(state);
   state->EndDictionary();

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h

@@ -273,9 +273,8 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
       MainThreadTaskQueue::QueueType queue_type,
       FrameSchedulerImpl* frame_scheduler);
 
-  // Returns a new timer task queue. This queue is intended for DOM Timers.
-  scoped_refptr<MainThreadTaskQueue> NewTimerTaskQueue(
-      MainThreadTaskQueue::QueueType queue_type,
+  // Returns a new throttleable task queue to be used for tests.
+  scoped_refptr<MainThreadTaskQueue> NewThrottleableTaskQueueForTest(
       FrameSchedulerImpl* frame_scheduler);
 
   using VirtualTimePolicy = PageScheduler::VirtualTimePolicy;
@@ -527,15 +526,6 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
           MainThreadTaskQueue::QueueClass::kLoading)];
     }
 
-    TaskQueuePolicy& timer_queue_policy() {
-      return policies_[static_cast<size_t>(
-          MainThreadTaskQueue::QueueClass::kTimer)];
-    }
-    const TaskQueuePolicy& timer_queue_policy() const {
-      return policies_[static_cast<size_t>(
-          MainThreadTaskQueue::QueueClass::kTimer)];
-    }
-
     TaskQueuePolicy& default_queue_policy() {
       return policies_[static_cast<size_t>(
           MainThreadTaskQueue::QueueClass::kNone)];

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.cc

@@ -109,16 +109,15 @@ MainThreadTaskQueue::QueueClass MainThreadTaskQueue::QueueClassForQueueType(
     case QueueType::kTest:
     case QueueType::kV8:
     case QueueType::kNonWaking:
-      return QueueClass::kNone;
-    case QueueType::kFrameLoading:
-    case QueueType::kFrameLoadingControl:
-      return QueueClass::kLoading;
     case QueueType::kFrameThrottleable:
     case QueueType::kFrameDeferrable:
     case QueueType::kFramePausable:
     case QueueType::kFrameUnpausable:
     case QueueType::kWebScheduling:
-      return QueueClass::kTimer;
+      return QueueClass::kNone;
+    case QueueType::kFrameLoading:
+    case QueueType::kFrameLoadingControl:
+      return QueueClass::kLoading;
     case QueueType::kCompositor:
     case QueueType::kInput:
       return QueueClass::kCompositor;

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.h

@@ -97,7 +97,6 @@ class PLATFORM_EXPORT MainThreadTaskQueue
   enum class QueueClass {
     kNone = 0,
     kLoading = 1,
-    kTimer = 2,
     kCompositor = 4,
 
     kCount = 5,

third_party/blink/renderer/platform/timer_test.cc

@@ -599,8 +599,7 @@ class TimerForTest : public TaskRunnerTimer<TimerFiredClass> {
 
 TEST_F(TimerTest, UserSuppliedTaskRunner) {
   scoped_refptr<MainThreadTaskQueue> task_queue(
-      platform_->GetMainThreadScheduler()->NewTimerTaskQueue(
-          scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable,
+      platform_->GetMainThreadScheduler()->NewThrottleableTaskQueueForTest(
           nullptr));
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       task_queue->CreateTaskRunner(TaskType::kInternalTest);
@@ -696,8 +695,7 @@ TEST_F(TimerTest, MoveToNewTaskRunnerOneShot) {
   Vector<scoped_refptr<base::SingleThreadTaskRunner>> run_order;
 
   scoped_refptr<MainThreadTaskQueue> task_queue1(
-      platform_->GetMainThreadScheduler()->NewTimerTaskQueue(
-          scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable,
+      platform_->GetMainThreadScheduler()->NewThrottleableTaskQueueForTest(
           nullptr));
   scoped_refptr<base::SingleThreadTaskRunner> task_runner1 =
       task_queue1->CreateTaskRunner(TaskType::kInternalTest);
@@ -705,8 +703,7 @@ TEST_F(TimerTest, MoveToNewTaskRunnerOneShot) {
   task_queue1->AddTaskObserver(&task_observer1);
 
   scoped_refptr<MainThreadTaskQueue> task_queue2(
-      platform_->GetMainThreadScheduler()->NewTimerTaskQueue(
-          scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable,
+      platform_->GetMainThreadScheduler()->NewThrottleableTaskQueueForTest(
           nullptr));
   scoped_refptr<base::SingleThreadTaskRunner> task_runner2 =
       task_queue2->CreateTaskRunner(TaskType::kInternalTest);
@@ -738,8 +735,7 @@ TEST_F(TimerTest, MoveToNewTaskRunnerRepeating) {
   Vector<scoped_refptr<base::SingleThreadTaskRunner>> run_order;
 
   scoped_refptr<MainThreadTaskQueue> task_queue1(
-      platform_->GetMainThreadScheduler()->NewTimerTaskQueue(
-          scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable,
+      platform_->GetMainThreadScheduler()->NewThrottleableTaskQueueForTest(
           nullptr));
   scoped_refptr<base::SingleThreadTaskRunner> task_runner1 =
       task_queue1->CreateTaskRunner(TaskType::kInternalTest);
@@ -747,8 +743,7 @@ TEST_F(TimerTest, MoveToNewTaskRunnerRepeating) {
   task_queue1->AddTaskObserver(&task_observer1);
 
   scoped_refptr<MainThreadTaskQueue> task_queue2(
-      platform_->GetMainThreadScheduler()->NewTimerTaskQueue(
-          scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable,
+      platform_->GetMainThreadScheduler()->NewThrottleableTaskQueueForTest(
           nullptr));
   scoped_refptr<base::SingleThreadTaskRunner> task_runner2 =
       task_queue2->CreateTaskRunner(TaskType::kInternalTest);
@@ -784,15 +779,13 @@ TEST_F(TimerTest, MoveToNewTaskRunnerRepeating) {
 // runner it isn't activated.
 TEST_F(TimerTest, MoveToNewTaskRunnerWithoutTasks) {
   scoped_refptr<MainThreadTaskQueue> task_queue1(
-      platform_->GetMainThreadScheduler()->NewTimerTaskQueue(
-          scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable,
+      platform_->GetMainThreadScheduler()->NewThrottleableTaskQueueForTest(
           nullptr));
   scoped_refptr<base::SingleThreadTaskRunner> task_runner1 =
       task_queue1->CreateTaskRunner(TaskType::kInternalTest);
 
   scoped_refptr<MainThreadTaskQueue> task_queue2(
-      platform_->GetMainThreadScheduler()->NewTimerTaskQueue(
-          scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable,
+      platform_->GetMainThreadScheduler()->NewThrottleableTaskQueueForTest(
           nullptr));
   scoped_refptr<base::SingleThreadTaskRunner> task_runner2 =
       task_queue2->CreateTaskRunner(TaskType::kInternalTest);