Introduce TaskRunner::RunsTasksInCurrentSequence()

base/threading/sequenced_worker_pool.cc

Index: base/threading/sequenced_worker_pool.cc
diff --git a/base/threading/sequenced_worker_pool.cc b/base/threading/sequenced_worker_pool.cc
index 64f1bbd0bc563bbf3fd67de3d8fc03f76a8dba9d..5c62e1e4432388ab17c272ca9ebe9534e97f65dc 100644
--- a/base/threading/sequenced_worker_pool.cc
+++ b/base/threading/sequenced_worker_pool.cc
@@ -145,7 +145,7 @@ class SequencedWorkerPoolTaskRunner : public TaskRunner {
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        OnceClosure task,
                        TimeDelta delay) override;
-  bool RunsTasksOnCurrentThread() const override;
+  bool RunsTasksInCurrentSequence() const override;
 
  private:
   ~SequencedWorkerPoolTaskRunner() override;
@@ -176,8 +176,8 @@ bool SequencedWorkerPoolTaskRunner::PostDelayedTask(
   return pool_->PostDelayedWorkerTask(from_here, std::move(task), delay);
 }
 
-bool SequencedWorkerPoolTaskRunner::RunsTasksOnCurrentThread() const {
-  return pool_->RunsTasksOnCurrentThread();
+bool SequencedWorkerPoolTaskRunner::RunsTasksInCurrentSequence() const {
+  return pool_->RunsTasksInCurrentSequence();
 }
 
 }  // namespace
@@ -199,7 +199,8 @@ class SequencedWorkerPool::PoolSequencedTaskRunner
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        OnceClosure task,
                        TimeDelta delay) override;
-  bool RunsTasksOnCurrentThread() const override;
+  bool RunsTasksInCurrentSequence() const override;
+
 
   // SequencedTaskRunner implementation
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
@@ -243,7 +244,7 @@ bool SequencedWorkerPool::PoolSequencedTaskRunner::PostDelayedTask(
 }
 
 bool SequencedWorkerPool::PoolSequencedTaskRunner::
-    RunsTasksOnCurrentThread() const {
+    RunsTasksInCurrentSequence() const {
   return pool_->IsRunningSequenceOnCurrentThread(token_);
 }
 
@@ -356,6 +357,7 @@ class SequencedWorkerPool::Inner {
                 TimeDelta delay);
 
   bool RunsTasksOnCurrentThread() const;

[gab, 2017/04/18 15:00:33]

We should be able to get rid of this one too? No external callers should be
using Inner.

+  bool RunsTasksInCurrentSequence() const;
 
   bool IsRunningSequenceOnCurrentThread(SequenceToken sequence_token) const;
 
@@ -887,6 +889,20 @@ bool SequencedWorkerPool::Inner::RunsTasksOnCurrentThread() const {
   }
 }
 
+bool SequencedWorkerPool::Inner::RunsTasksInCurrentSequence() const {
+  AutoLock lock(lock_);
+  if (g_all_pools_state == AllPoolsState::REDIRECTED_TO_TASK_SCHEDULER) {
+    if (!runs_tasks_on_verifier_) {
+      runs_tasks_on_verifier_ = CreateTaskRunnerWithTraits(
+          TaskTraits().MayBlock().WithBaseSyncPrimitives().WithPriority(
+              task_priority_));
+    }
+    return runs_tasks_on_verifier_->RunsTasksInCurrentSequence();
+  } else {
+    return ContainsKey(threads_, PlatformThread::CurrentId());
+  }
+}
+
 bool SequencedWorkerPool::Inner::IsRunningSequenceOnCurrentThread(
     SequenceToken sequence_token) const {
   DCHECK(sequence_token.IsValid());
@@ -1615,8 +1631,8 @@ bool SequencedWorkerPool::PostDelayedTask(
   return PostDelayedWorkerTask(from_here, std::move(task), delay);
 }
 
-bool SequencedWorkerPool::RunsTasksOnCurrentThread() const {
-  return inner_->RunsTasksOnCurrentThread();
+bool SequencedWorkerPool::RunsTasksInCurrentSequence() const {
+  return inner_->RunsTasksInCurrentSequence();
 }
 
 void SequencedWorkerPool::FlushForTesting() {