[scheduling] Remove fixed priority.

This CL removed fixed priority from the scheduler in favor of using
PrioritisationType to make priority decisions. This centralizes
priority to ComputePriority/PrioritisationType. Specifically, this CL
has kBestEffort queues use kBestEffort PrioritisationType and adds
kInput PrioritisationType for input queues.

Change-Id: Icaabc29ff6d3d8f5595c64741056899ffa474fff
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2376574
Commit-Queue: Katie Dillon <kdillon@chromium.org>
Reviewed-by: Scott Haseley <shaseley@chromium.org>
Cr-Commit-Position: refs/heads/master@{#808044}

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

@@ -1005,11 +1005,18 @@ TaskQueue::QueuePriority FrameSchedulerImpl::ComputePriority(
   if (queue_priority_pair != resource_loading_task_queue_priorities_.end())
     return queue_priority_pair->value;
 
-  base::Optional<TaskQueue::QueuePriority> fixed_priority =
-      task_queue->FixedPriority();
-
-  if (fixed_priority)
-    return fixed_priority.value();
+  // TODO(kdillon): Ordering here is relative to the experiments below. Cleanup
+  // unused experiment logic so that this switch can be merged with the
+  // prioritisation type decisions below.
+  switch (task_queue->GetPrioritisationType()) {
+    case MainThreadTaskQueue::QueueTraits::PrioritisationType::
+        kInternalScriptContinuation:
+      return TaskQueue::QueuePriority::kVeryHighPriority;
+    case MainThreadTaskQueue::QueueTraits::PrioritisationType::kBestEffort:
+      return TaskQueue::QueuePriority::kBestEffortPriority;
+    default:
+      break;
+  }
 
   // TODO(shaseley): This should use lower priorities if the frame is
   // deprioritized. Change this once we refactor and add frame policy/priorities

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

@@ -2428,9 +2428,8 @@ TEST_F(FrameSchedulerImplDatabaseAccessWithHighPriority,
 TEST_F(FrameSchedulerImplTest, ContentCaptureHasIdleTaskQueue) {
   auto task_queue = GetTaskQueue(TaskType::kInternalContentCapture);
 
-  EXPECT_TRUE(task_queue->FixedPriority().has_value());
   EXPECT_EQ(TaskQueue::QueuePriority::kBestEffortPriority,
-            task_queue->FixedPriority().value());
+            task_queue->GetQueuePriority());
 }
 
 TEST_F(FrameSchedulerImplTest, ComputePriorityForDetachedFrame) {

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

@@ -102,19 +102,6 @@ void FrameTaskQueueController::CreateTaskQueue(
           .SetFreezeWhenKeepActive(queue_traits.can_be_throttled)
           .SetFrameScheduler(frame_scheduler_impl_);
 
-  switch (queue_traits.prioritisation_type) {
-    case QueueTraits::PrioritisationType::kInternalScriptContinuation:
-      queue_creation_params = queue_creation_params.SetFixedPriority(
-        TaskQueue::QueuePriority::kVeryHighPriority);
-      break;
-    case QueueTraits::PrioritisationType::kBestEffort:
-      queue_creation_params = queue_creation_params.SetFixedPriority(
-        TaskQueue::QueuePriority::kBestEffortPriority);
-      break;
-    default:
-      break;
-  }
-
   scoped_refptr<MainThreadTaskQueue> task_queue =
       main_thread_scheduler_impl_->NewTaskQueue(queue_creation_params);
   TaskQueueCreated(task_queue);

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

@@ -332,7 +332,8 @@ INSTANTIATE_TEST_SUITE_P(
         QueueTraits::PrioritisationType::kFindInPage,
         QueueTraits::PrioritisationType::kExperimentalDatabase,
         QueueTraits::PrioritisationType::kJavaScriptTimer,
-        QueueTraits::PrioritisationType::kHighPriorityLocalFrame));
+        QueueTraits::PrioritisationType::kHighPriorityLocalFrame,
+        QueueTraits::PrioritisationType::kInput));
 
 TEST_P(TaskQueueCreationFromQueueTraitsTest,
         AddAndRetrieveAllTaskQueues) {

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

@@ -78,8 +78,6 @@ scoped_refptr<MainThreadTaskQueue> MainThreadSchedulerHelper::NewTaskQueue(
   scoped_refptr<MainThreadTaskQueue> task_queue =
       sequence_manager_->CreateTaskQueueWithType<MainThreadTaskQueue>(
           params.spec, params, main_thread_scheduler_);
-  if (params.fixed_priority)
-    task_queue->SetQueuePriority(params.fixed_priority.value());
   return task_queue;
 }
 

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

@@ -183,15 +183,16 @@ MainThreadSchedulerImpl::MainThreadSchedulerImpl(
     base::Optional<base::Time> initial_virtual_time)
     : sequence_manager_(std::move(sequence_manager)),
       helper_(sequence_manager_.get(), this),
-      idle_helper_(&helper_,
-                   this,
-                   "MainThreadSchedulerIdlePeriod",
-                   base::TimeDelta(),
-                   helper_.NewTaskQueue(
-                       MainThreadTaskQueue::QueueCreationParams(
-                           MainThreadTaskQueue::QueueType::kIdle)
-                           .SetFixedPriority(
-                               TaskQueue::QueuePriority::kBestEffortPriority))),
+      idle_helper_(
+          &helper_,
+          this,
+          "MainThreadSchedulerIdlePeriod",
+          base::TimeDelta(),
+          helper_.NewTaskQueue(
+              MainThreadTaskQueue::QueueCreationParams(
+                  MainThreadTaskQueue::QueueType::kIdle)
+                  .SetPrioritisationType(MainThreadTaskQueue::QueueTraits::
+                                             PrioritisationType::kBestEffort))),
       render_widget_scheduler_signals_(this),
       find_in_page_budget_pool_controller_(
           new FindInPageBudgetPoolController(this)),
@@ -207,8 +208,8 @@ MainThreadSchedulerImpl::MainThreadSchedulerImpl(
       memory_purge_task_queue_(helper_.NewTaskQueue(
           MainThreadTaskQueue::QueueCreationParams(
               MainThreadTaskQueue::QueueType::kIdle)
-              .SetFixedPriority(
-                  TaskQueue::QueuePriority::kBestEffortPriority))),
+              .SetPrioritisationType(MainThreadTaskQueue::QueueTraits::
+                                         PrioritisationType::kBestEffort))),
       memory_purge_manager_(memory_purge_task_queue_->CreateTaskRunner(
           TaskType::kMainThreadTaskQueueMemoryPurge)),
       non_waking_time_domain_(tick_clock()),
@@ -296,6 +297,11 @@ MainThreadSchedulerImpl::MainThreadSchedulerImpl(
       find_in_page_budget_pool_controller_->CurrentTaskPriority();
 
   g_main_thread_scheduler = this;
+
+  // Explicitly set the priority of this queue since it is not managed by
+  // the main thread scheduler.
+  memory_purge_task_queue_->SetQueuePriority(
+      ComputePriority(memory_purge_task_queue_.get()));
 }
 
 MainThreadSchedulerImpl::~MainThreadSchedulerImpl() {
@@ -2614,19 +2620,19 @@ TaskQueue::QueuePriority MainThreadSchedulerImpl::ComputePriority(
     return frame_scheduler->ComputePriority(task_queue);
   }
 
-  base::Optional<TaskQueue::QueuePriority> fixed_priority =
-      task_queue->FixedPriority();
-  if (fixed_priority) {
-    return fixed_priority.value();
-  }
-
-  if (task_queue->GetPrioritisationType() ==
-      MainThreadTaskQueue::QueueTraits::PrioritisationType::kCompositor) {
-    return main_thread_only().compositor_priority;
+  switch (task_queue->GetPrioritisationType()) {
+    case MainThreadTaskQueue::QueueTraits::PrioritisationType::kCompositor:
+      return main_thread_only().compositor_priority;
+    case MainThreadTaskQueue::QueueTraits::PrioritisationType::kInput:
+      return TaskQueue::QueuePriority::kHighestPriority;
+    case MainThreadTaskQueue::QueueTraits::PrioritisationType::kBestEffort:
+      return TaskQueue::QueuePriority::kBestEffortPriority;
+    case MainThreadTaskQueue::QueueTraits::PrioritisationType::kRegular:
+      return TaskQueue::QueuePriority::kNormalPriority;
+    default:
+      NOTREACHED();
+      return TaskQueue::QueuePriority::kNormalPriority;
   }
-
-  // Default priority.
-  return TaskQueue::QueuePriority::kNormalPriority;
 }
 
 void MainThreadSchedulerImpl::OnBeginNestedRunLoop() {

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

@@ -107,7 +107,6 @@ MainThreadTaskQueue::MainThreadTaskQueue(
     MainThreadSchedulerImpl* main_thread_scheduler)
     : TaskQueue(std::move(impl), spec),
       queue_type_(params.queue_type),
-      fixed_priority_(params.fixed_priority),
       queue_traits_(params.queue_traits),
       freeze_when_keep_active_(params.freeze_when_keep_active),
       web_scheduling_priority_(params.web_scheduling_priority),

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

@@ -121,8 +121,9 @@ class PLATFORM_EXPORT MainThreadTaskQueue
       kJavaScriptTimer = 7,
       kHighPriorityLocalFrame = 8,
       kCompositor = 9,  // Main-thread only.
+      kInput = 10,
 
-      kCount = 10
+      kCount = 11
     };
 
     // kPrioritisationTypeWidthBits is the number of bits required
@@ -226,13 +227,6 @@ class PLATFORM_EXPORT MainThreadTaskQueue
           frame_scheduler(nullptr),
           freeze_when_keep_active(false) {}
 
-    QueueCreationParams SetFixedPriority(
-        base::Optional<base::sequence_manager::TaskQueue::QueuePriority>
-            priority) {
-      fixed_priority = priority;
-      return *this;
-    }
-
     QueueCreationParams SetFreezeWhenKeepActive(bool value) {
       freeze_when_keep_active = value;
       return *this;
@@ -319,8 +313,6 @@ class PLATFORM_EXPORT MainThreadTaskQueue
 
     QueueType queue_type;
     base::sequence_manager::TaskQueue::Spec spec;
-    base::Optional<base::sequence_manager::TaskQueue::QueuePriority>
-        fixed_priority;
     FrameSchedulerImpl* frame_scheduler;
     QueueTraits queue_traits;
     bool freeze_when_keep_active;
@@ -336,11 +328,6 @@ class PLATFORM_EXPORT MainThreadTaskQueue
 
   QueueType queue_type() const { return queue_type_; }
 
-  base::Optional<base::sequence_manager::TaskQueue::QueuePriority>
-  FixedPriority() const {
-    return fixed_priority_;
-  }
-
   bool CanBeDeferred() const { return queue_traits_.can_be_deferred; }
 
   bool CanBeThrottled() const { return queue_traits_.can_be_throttled; }
@@ -437,8 +424,6 @@ class PLATFORM_EXPORT MainThreadTaskQueue
   void ClearReferencesToSchedulers();
 
   const QueueType queue_type_;
-  const base::Optional<base::sequence_manager::TaskQueue::QueuePriority>
-      fixed_priority_;
   const QueueTraits queue_traits_;
   const bool freeze_when_keep_active_;
 

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

@@ -15,8 +15,8 @@ WidgetScheduler::WidgetScheduler(
       MainThreadTaskQueue::QueueCreationParams(
           MainThreadTaskQueue::QueueType::kInput)
           .SetShouldMonitorQuiescence(true)
-          .SetFixedPriority(
-              base::make_optional(TaskQueue::QueuePriority::kHighestPriority)));
+          .SetPrioritisationType(
+              MainThreadTaskQueue::QueueTraits::PrioritisationType::kInput));
   input_task_runner_ =
       input_task_queue_->CreateTaskRunner(TaskType::kMainThreadTaskQueueInput);
   input_task_queue_enabled_voter_ =