Introduce TaskRunner::RunsTasksInCurrentSequence()

base/threading/sequenced_worker_pool.cc

 // Copyright (c) 2012 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 "base/threading/sequenced_worker_pool.h"
 
 #include <stdint.h>
 
 #include <list>
 #include <map>
@@ skipping 127 matching lines @@
 class SequencedWorkerPoolTaskRunner : public TaskRunner {
  public:
   SequencedWorkerPoolTaskRunner(
       scoped_refptr<SequencedWorkerPool> pool,
       SequencedWorkerPool::WorkerShutdown shutdown_behavior);
 
   // TaskRunner implementation
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        OnceClosure task,
                        TimeDelta delay) override;
-  bool RunsTasksOnCurrentThread() const override;
+  bool RunsTasksInCurrentSequence() const override;
 
  private:
   ~SequencedWorkerPoolTaskRunner() override;
 
   const scoped_refptr<SequencedWorkerPool> pool_;
 
   const SequencedWorkerPool::WorkerShutdown shutdown_behavior_;
 
   DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPoolTaskRunner);
 };
@@ skipping 10 matching lines @@
     const tracked_objects::Location& from_here,
     OnceClosure task,
     TimeDelta delay) {
   if (delay.is_zero()) {
     return pool_->PostWorkerTaskWithShutdownBehavior(from_here, std::move(task),
                                                      shutdown_behavior_);
   }
   return pool_->PostDelayedWorkerTask(from_here, std::move(task), delay);
 }
 
-bool SequencedWorkerPoolTaskRunner::RunsTasksOnCurrentThread() const {
-  return pool_->RunsTasksOnCurrentThread();
+bool SequencedWorkerPoolTaskRunner::RunsTasksInCurrentSequence() const {
+  return pool_->RunsTasksInCurrentSequence();
 }
 
 }  // namespace
 
 // SequencedWorkerPool::PoolSequencedTaskRunner ------------------------------
 // A SequencedTaskRunner which posts tasks to a SequencedWorkerPool with a
 // fixed sequence token.
 //
 // Note that this class is RefCountedThreadSafe (inherited from TaskRunner).
 class SequencedWorkerPool::PoolSequencedTaskRunner
     : public SequencedTaskRunner {
  public:
   PoolSequencedTaskRunner(
       scoped_refptr<SequencedWorkerPool> pool,
       SequencedWorkerPool::SequenceToken token,
       SequencedWorkerPool::WorkerShutdown shutdown_behavior);
 
   // TaskRunner implementation
   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,
                                   OnceClosure task,
                                   TimeDelta delay) override;
 
  private:
   ~PoolSequencedTaskRunner() override;
 
   const scoped_refptr<SequencedWorkerPool> pool_;
@@ skipping 23 matching lines @@
     TimeDelta delay) {
   if (delay.is_zero()) {
     return pool_->PostSequencedWorkerTaskWithShutdownBehavior(
         token_, from_here, std::move(task), shutdown_behavior_);
   }
   return pool_->PostDelayedSequencedWorkerTask(token_, from_here,
                                                std::move(task), delay);
 }
 
 bool SequencedWorkerPool::PoolSequencedTaskRunner::
-    RunsTasksOnCurrentThread() const {
+    RunsTasksInCurrentSequence() const {
   return pool_->IsRunningSequenceOnCurrentThread(token_);
 }
 
 bool SequencedWorkerPool::PoolSequencedTaskRunner::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
     OnceClosure task,
     TimeDelta delay) {
   // There's no way to run nested tasks, so simply forward to
   // PostDelayedTask.
   return PostDelayedTask(from_here, std::move(task), delay);
@@ skipping 91 matching lines @@
   // This function accepts a name and an ID. If the name is null, the
   // token ID is used. This allows us to implement the optional name lookup
   // from a single function without having to enter the lock a separate time.
   bool PostTask(const std::string* optional_token_name,
                 SequenceToken sequence_token,
                 WorkerShutdown shutdown_behavior,
                 const tracked_objects::Location& from_here,
                 OnceClosure task,
                 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;
 
   void CleanupForTesting();
 
   void SignalHasWorkForTesting();
 
   int GetWorkSignalCountForTesting() const;
 
   void Shutdown(int max_blocking_tasks_after_shutdown);
@@ skipping 497 matching lines @@
 
   if (!task_runner) {
     task_runner = sequence_token_id
                       ? CreateSequencedTaskRunnerWithTraits(traits)
                       : CreateTaskRunnerWithTraits(traits);
   }
 
   return task_runner;
 }
 
 bool SequencedWorkerPool::Inner::RunsTasksOnCurrentThread() const {

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

Same with this impl?

   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_->RunsTasksOnCurrentThread();
   } else {
     return ContainsKey(threads_, PlatformThread::CurrentId());
   }
 }
 
+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());
 
   AutoLock lock(lock_);
 
   if (g_all_pools_state == AllPoolsState::REDIRECTED_TO_TASK_SCHEDULER) {
     const auto sequenced_task_runner_it =
         sequenced_task_runner_map_.find(sequence_token.id_);
     return sequenced_task_runner_it != sequenced_task_runner_map_.end() &&
@@ skipping 708 matching lines @@
                           std::move(task), TimeDelta());
 }
 
 bool SequencedWorkerPool::PostDelayedTask(
     const tracked_objects::Location& from_here,
     OnceClosure task,
     TimeDelta delay) {
   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() {
   DCHECK(!RunsTasksOnCurrentThread());
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   if (g_all_pools_state == AllPoolsState::REDIRECTED_TO_TASK_SCHEDULER) {
     // TODO(gab): Remove this if http://crbug.com/622400 fails.
     TaskScheduler::GetInstance()->FlushForTesting();
   } else {
     inner_->CleanupForTesting();
@@ skipping 12 matching lines @@
 bool SequencedWorkerPool::IsShutdownInProgress() {
   return inner_->IsShutdownInProgress();
 }
 
 bool SequencedWorkerPool::IsRunningSequenceOnCurrentThread(
     SequenceToken sequence_token) const {
   return inner_->IsRunningSequenceOnCurrentThread(sequence_token);
 }
 
 }  // namespace base