Introduce TaskRunner::RunsTasksInCurrentSequence()

base/task_runner.h

 // 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.
 
 #ifndef BASE_TASK_RUNNER_H_
 #define BASE_TASK_RUNNER_H_
 
 #include <stddef.h>
 
 #include "base/base_export.h"
@@ skipping 59 matching lines @@
   // to have PostDelayedTask behave the same as PostTask.
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                OnceClosure task,
                                base::TimeDelta delay) = 0;
 
   // Returns true if the current thread is a thread on which a task
   // may be run, and false if no task will be run on the current
   // thread.
   //
   // It is valid for an implementation to always return true, or in
   // general to use 'true' as a default value.

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

//
// Drepecated: favor RunsTasksInCurrentSequence().
// TODO(http://crbug.com/665062): mass redirect callers and remove this.

-  virtual bool RunsTasksOnCurrentThread() const = 0;
+  bool RunsTasksOnCurrentThread() const;
+
+  // Returns true iff tasks posted to this TaskRunner are sequenced
+  // with this call.
+  //
+  // In particular:
+  // - Returns true if this is a SequencedTaskRunner to which the
+  //   current task was posted.
+  // - Returns true if this is a SequencedTaskRunner bound to the
+  //   same sequence as the SequencedTaskRunner to which the current
+  //   task was posted.
+  // - Returns true if this is a SingleThreadTaskRunner bound to
+  //   the current thread.
+  // - Returns false if this is a TaskRunner that can run its tasks
+  //   in parallel.

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

This last statement isn't true yet (SchedulerParallelTaskRunner and
SequencedWorkerPool::Inner). We'd like it to be but it doesn't need to block
initiating this migration. Replace it with:

// TODO(http://crbug.com/665062): this API doesn't make sense for parallel
TaskRunners. Introduce alternate static APIs for documentation purposes of "this
runs in pool X", have RunsTasksInCurrentSequence() return false for parallel
TaskRunners, and ultimately move this method down to SequencedTaskRunner.

+  virtual bool RunsTasksInCurrentSequence() const = 0;
 
   // Posts |task| on the current TaskRunner.  On completion, |reply|
   // is posted to the thread that called PostTaskAndReply().  Both
   // |task| and |reply| are guaranteed to be deleted on the thread
   // from which PostTaskAndReply() is invoked.  This allows objects
   // that must be deleted on the originating thread to be bound into
   // the |task| and |reply| Closures.  In particular, it can be useful
   // to use WeakPtr<> in the |reply| Closure so that the reply
   // operation can be canceled. See the following pseudo-code:
   //
@@ skipping 49 matching lines @@
   virtual void OnDestruct() const;
 };
 
 struct BASE_EXPORT TaskRunnerTraits {
   static void Destruct(const TaskRunner* task_runner);
 };
 
 }  // namespace base
 
 #endif  // BASE_TASK_RUNNER_H_