Introduce TaskRunner::RunsTasksInCurrentSequence()

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

 // Copyright 2015 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 "platform/scheduler/base/task_queue_impl.h"
 
 #include <utility>
 
 #include "base/format_macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 175 matching lines @@
   any_thread().task_queue_manager = nullptr;
   main_thread_only().task_queue_manager = nullptr;
   any_thread().observer = nullptr;
   main_thread_only().observer = nullptr;
   main_thread_only().delayed_incoming_queue = std::priority_queue<Task>();
   immediate_incoming_queue().Clear();
   main_thread_only().immediate_work_queue.reset();
   main_thread_only().delayed_work_queue.reset();
 }
 
-bool TaskQueueImpl::RunsTasksOnCurrentThread() const {
+bool TaskQueueImpl::RunsTasksInCurrentSequence() const {
   return base::PlatformThread::CurrentId() == thread_id_;
 }
 
 bool TaskQueueImpl::PostDelayedTask(const tracked_objects::Location& from_here,
                                     base::OnceClosure task,
                                     base::TimeDelta delay) {
   if (delay.is_zero())
     return PostImmediateTaskImpl(from_here, std::move(task), TaskType::NORMAL);
 
   return PostDelayedTaskImpl(from_here, std::move(task), delay,
@@ skipping 144 matching lines @@
                                             desired_run_time, sequence_number,
                                             nestable, sequence_number);
     any_thread().task_queue_manager->DidQueueTask(
         immediate_incoming_queue().back());
   }
 
   if (was_immediate_incoming_queue_empty) {
     // However there's no point posting a DoWork for a blocked queue. NB we can
     // only tell if it's disabled from the main thread.
     bool queue_is_blocked =
-        RunsTasksOnCurrentThread() &&
+        RunsTasksInCurrentSequence() &&
         (!IsQueueEnabled() || main_thread_only().current_fence);
     any_thread().task_queue_manager->OnQueueHasIncomingImmediateWork(
         this, sequence_number, queue_is_blocked);
     if (any_thread().observer)
       any_thread().observer->OnQueueNextWakeUpChanged(this, desired_run_time);
   }
 
   TraceQueueSize();
 }
 
@@ skipping 527 matching lines @@
 }
 
 void TaskQueueImpl::NotifyWakeUpChangedOnMainThread(base::TimeTicks wake_up) {
   if (main_thread_only().observer)
     main_thread_only().observer->OnQueueNextWakeUpChanged(this, wake_up);
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink