Optimize away updatable_queue_set_

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc

Index: third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
index a0bc14200139e176ee03b6dccefa0d8a29270d67..8e06874113eacc1cd036da122aa454beacacf936 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
@@ -154,8 +154,11 @@ TaskQueueImpl::MainThreadOnly::MainThreadOnly(
     TimeDomain* time_domain)
     : task_queue_manager(task_queue_manager),
       time_domain(time_domain),
-      delayed_work_queue(new WorkQueue(task_queue, "delayed")),
-      immediate_work_queue(new WorkQueue(task_queue, "immediate")),
+      delayed_work_queue(
+          new WorkQueue(task_queue, "delayed", WorkQueue::QueueType::DELAYED)),
+      immediate_work_queue(new WorkQueue(task_queue,
+                                         "immediate",
+                                         WorkQueue::QueueType::IMMEDIATE)),
       set_index(0),
       is_enabled_refcount(0),
       voter_refcount(0),
@@ -326,7 +329,7 @@ void TaskQueueImpl::PushOntoImmediateIncomingQueueLocked(
     EnqueueOrder sequence_number,
     bool nestable) {
   if (any_thread().immediate_incoming_queue.empty())
-    any_thread().time_domain->RegisterAsUpdatableTaskQueue(this);
+    any_thread().time_domain->OnQueueHasIncomingImmediateWork(this);
   // If the |immediate_incoming_queue| is empty we need a DoWork posted to make
   // it run.
   if (any_thread().immediate_incoming_queue.empty()) {
@@ -347,6 +350,20 @@ void TaskQueueImpl::PushOntoImmediateIncomingQueueLocked(
   TraceQueueSize(true);
 }
 
+void TaskQueueImpl::ReloadImmediateWorkQueueIfEmpty() {
+  if (!main_thread_only().immediate_work_queue->Empty())
+    return;
+
+  main_thread_only().immediate_work_queue->ReloadEmptyImmediateQueue();
+}
+
+WTF::Deque<TaskQueueImpl::Task> TaskQueueImpl::TakeImmediateIncomingQueue() {
+  base::AutoLock lock(any_thread_lock_);
+  WTF::Deque<TaskQueueImpl::Task> queue;
+  queue.swap(any_thread().immediate_incoming_queue);
+  return queue;
+}
+
 bool TaskQueueImpl::IsEmpty() const {
   if (!main_thread_only().delayed_work_queue->Empty() ||
       !main_thread_only().delayed_incoming_queue.empty() ||
@@ -422,20 +439,6 @@ void TaskQueueImpl::WakeUpForDelayedWork(LazyNow* lazy_now) {
   }
 }
 
-bool TaskQueueImpl::MaybeUpdateImmediateWorkQueues() {
-  if (!main_thread_only().task_queue_manager)
-    return false;
-
-  if (!main_thread_only().immediate_work_queue->Empty())
-    return true;
-
-  base::AutoLock lock(any_thread_lock_);
-  main_thread_only().immediate_work_queue->SwapLocked(
-      any_thread().immediate_incoming_queue);
-  // |immediate_work_queue| is now empty so updates are no longer required.
-  return false;
-}
-
 void TaskQueueImpl::TraceQueueSize(bool is_locked) const {
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(disabled_by_default_tracing_category_,
@@ -577,7 +580,7 @@ void TaskQueueImpl::SetTimeDomain(TimeDomain* time_domain) {
     any_thread().time_domain = time_domain;
   }
   // We rely here on TimeDomain::MigrateQueue being thread-safe to use with
-  // TimeDomain::Register/UnregisterAsUpdatableTaskQueue.
+  // TimeDomain::Register.
   main_thread_only().time_domain->MigrateQueue(this, time_domain);
   main_thread_only().time_domain = time_domain;
 }
@@ -799,8 +802,8 @@ void TaskQueueImpl::EnableOrDisableWithSelector(bool enable) {
     return;
 
   if (enable) {
-    // Note it's the job of the selector to tell the TaskQueueManager if
-    // a DoWork needs posting.
+    // Note the selector calls TaskQueueManager::OnTaskQueueEnabled which posts
+    // a DoWork if needed.
     main_thread_only().task_queue_manager->selector_.EnableQueue(this);
   } else {
     main_thread_only().task_queue_manager->selector_.DisableQueue(this);
@@ -836,6 +839,12 @@ void TaskQueueImpl::SweepCanceledDelayedTasks(base::TimeTicks now) {
   main_thread_only().delayed_incoming_queue = std::move(remaining_tasks);
 }
 
+void TaskQueueImpl::PushImmediateIncomingTaskForTest(
+    TaskQueueImpl::Task&& task) {
+  base::AutoLock lock(any_thread_lock_);
+  any_thread().immediate_incoming_queue.push_back(std::move(task));
+}
+
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink