[base] Move TaskRunner::RunsTasksInCurrentSequence() to SequencedTaskRunner

The vast majority of this CL is about changing code that used
base::TaskRunner and invoked RunsTasksInCurrentSequence() on it.

For the most part this CL is a logical no-op and a semantical
improvement as almost all APIs who loosely took a TaskRunner in fact
required a SequencedTaskRunner (e.g. were accessing unsynchronized
state) but it "worked" because their callers already happened to provide
task runners that were Sequenced/SingleThreadTaskRunners.

Some impls even used single-threaded APIs such as MessageLoopCurrent or
declaring methods invoked from that TaskRunner as "must run on the UI
thread". Those were changed to use SingleThreadTaskRunner (again, all
callers already were providing one but the API was too loose).

In a few cases where a parallel TaskRunner was actually intended, some
DCHECK(task_runner->RunsTasksInCurrentSequence()) were simply removed as
they were mere impl details, already obvious by the context. There was a
single case where it made sense to assert "doesn't run on a core thread"
in wallpaper_resizer.cc; that was migrated to
base::AssertLongCPUWorkAllowed().

Implementations of base::TaskRunner were either promoted to
Sequenced/SingleThreadTaskRunner when that's what it was actually used
as or the RunsTasksInCurrentSequence() override was removed.

The few actual logic changes:
 - ash/.../wallpaper_resizer.cc : base::AssertLongCPUWorkAllowed()
 - base/android/.../task_runner_android.h : TODO to make the same change
       on the Java side, for now things seem happy when always returning
       false from parallel TaskRunnerImpl.

Removed dead code:
 - base::debug::ActivityTracker::SetBackgroundTaskRunner()
 - AfterStartupTaskUtils::Runner
 - net/url_request/test_url_request_interceptor.(h|cc)

Includes were mostly kept as-is (fwd-decls as fwd-decls and
includes-as-includes) except where it was outright wrong or necessary to
make callers happy (remember that foo.h is required in order to have
scoped_refptr<Foo> be fully defined -- and hence required by IWYU if you
have such a member and arguably if taking/returning one by value as part
of your core API).

Pointer semantics are also intentionally unchanged unless 100% incorrect
and easy to update in place (e.g. in some cases raw pointers are used to
return refcounted objects; that should probably be fixed, but not in this
CL).

Bug: 1026641
Change-Id: I1b33744d3a30a05fdb091d3f976270cd59917873
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1957211
Reviewed-by: Anton Bikineev <bikineev@chromium.org>
Reviewed-by: Miguel Casas <mcasas@chromium.org>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Reviewed-by: Brian White <bcwhite@chromium.org>
Reviewed-by: Brad Nelson <bradnelson@chromium.org>
Reviewed-by: Nico Weber <thakis@chromium.org>
Reviewed-by: Achuith Bhandarkar <achuith@chromium.org>
Reviewed-by: Yaron Friedman <yfriedman@chromium.org>
Reviewed-by: Maksim Orlovich <morlovich@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Istiaque Ahmed <lazyboy@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Reviewed-by: Sorin Jianu <sorin@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Reviewed-by: Victor Costan <pwnall@chromium.org>
Reviewed-by: François Doray <fdoray@chromium.org>
Reviewed-by: Bill Budge <bbudge@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Commit-Queue: Gabriel Charette <gab@chromium.org>
Cr-Commit-Position: refs/heads/master@{#725203}

ash/wallpaper/wallpaper_utils/wallpaper_resizer.cc

@@ -11,7 +11,7 @@
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/task_runner.h"
+#include "base/threading/thread_restrictions.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/image/image_skia_rep.h"
@@ -28,9 +28,8 @@ namespace {
 void Resize(const gfx::ImageSkia image,
             const gfx::Size& target_size,
             WallpaperLayout layout,
-            SkBitmap* resized_bitmap_out,
-            base::TaskRunner* task_runner) {
-  DCHECK(task_runner->RunsTasksInCurrentSequence());
+            SkBitmap* resized_bitmap_out) {
+  base::AssertLongCPUWorkAllowed();
 
   SkBitmap orig_bitmap = *image.bitmap();
   SkBitmap new_bitmap = orig_bitmap;
@@ -124,7 +123,7 @@ void WallpaperResizer::StartResize() {
   if (!task_runner_->PostTaskAndReply(
           FROM_HERE,
           base::BindOnce(&Resize, image_, target_size_, wallpaper_info_.layout,
-                         resized_bitmap, base::RetainedRef(task_runner_)),
+                         resized_bitmap),
           base::BindOnce(&WallpaperResizer::OnResizeFinished,
                          weak_ptr_factory_.GetWeakPtr(),
                          base::Owned(resized_bitmap)))) {

ash/wallpaper/wallpaper_utils/wallpaper_resizer.h

@@ -14,6 +14,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
+#include "base/task_runner.h"
 #include "base/time/time.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ -21,10 +22,6 @@
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image_skia.h"
 
-namespace base {
-class TaskRunner;
-}
-
 namespace ash {
 
 class WallpaperResizerObserver;

base/android/task_scheduler/task_runner_android.cc

@@ -38,11 +38,13 @@ jlong JNI_TaskRunnerImpl_Init(
       task_runner = CreateSingleThreadTaskRunner(task_traits);
       break;
   }
-  return reinterpret_cast<intptr_t>(new TaskRunnerAndroid(task_runner));
+  return reinterpret_cast<intptr_t>(new TaskRunnerAndroid(
+      task_runner, static_cast<TaskRunnerType>(task_runner_type)));
 }
 
-TaskRunnerAndroid::TaskRunnerAndroid(scoped_refptr<TaskRunner> task_runner)
-    : task_runner_(std::move(task_runner)) {}
+TaskRunnerAndroid::TaskRunnerAndroid(scoped_refptr<TaskRunner> task_runner,
+                                     TaskRunnerType type)
+    : task_runner_(std::move(task_runner)), type_(type) {}
 
 TaskRunnerAndroid::~TaskRunnerAndroid() = default;
 
@@ -63,7 +65,12 @@ void TaskRunnerAndroid::PostDelayedTask(
 }
 
 bool TaskRunnerAndroid::BelongsToCurrentThread(JNIEnv* env) {
-  return task_runner_->RunsTasksInCurrentSequence();
+  // TODO(crbug.com/1026641): Move BelongsToCurrentThread from TaskRunnerImpl to
+  // SequencedTaskRunnerImpl on the Java side too.
+  if (type_ == TaskRunnerType::BASE)
+    return false;
+  return static_cast<SequencedTaskRunner*>(task_runner_.get())
+      ->RunsTasksInCurrentSequence();
 }
 
 }  // namespace base

base/android/task_scheduler/task_runner_android.h

@@ -17,7 +17,8 @@ enum class TaskRunnerType { BASE, SEQUENCED, SINGLE_THREAD };
 // a C++ TaskRunner.
 class TaskRunnerAndroid {
  public:
-  explicit TaskRunnerAndroid(scoped_refptr<TaskRunner> task_runner);
+  explicit TaskRunnerAndroid(scoped_refptr<TaskRunner> task_runner,
+                             TaskRunnerType type);
   ~TaskRunnerAndroid();
 
   void Destroy(JNIEnv* env);
@@ -30,6 +31,7 @@ class TaskRunnerAndroid {
 
  private:
   const scoped_refptr<TaskRunner> task_runner_;
+  const TaskRunnerType type_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskRunnerAndroid);
 };

base/debug/activity_tracker.cc

@@ -1396,9 +1396,9 @@ void GlobalActivityTracker::ReleaseTrackerForCurrentThreadForTesting() {
 }
 
 void GlobalActivityTracker::SetBackgroundTaskRunner(
-    const scoped_refptr<TaskRunner>& runner) {
+    const scoped_refptr<SequencedTaskRunner>& runner) {
   AutoLock lock(global_tracker_lock_);
-  background_task_runner_ = runner;
+  background_task_runner_ = std::move(runner);
 }
 
 void GlobalActivityTracker::SetProcessExitCallback(
@@ -1450,7 +1450,7 @@ void GlobalActivityTracker::RecordProcessExit(ProcessId process_id,
   DCHECK_NE(GetProcessId(), pid);
   DCHECK_NE(0, pid);
 
-  scoped_refptr<TaskRunner> task_runner;
+  scoped_refptr<SequencedTaskRunner> task_runner;
   std::string command_line;
   {
     base::AutoLock lock(global_tracker_lock_);

base/debug/activity_tracker.h

@@ -30,9 +30,9 @@
 #include "base/memory/shared_memory_mapping.h"
 #include "base/metrics/persistent_memory_allocator.h"
 #include "base/process/process_handle.h"
+#include "base/sequenced_task_runner.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_local.h"
 
@@ -965,7 +965,8 @@ class BASE_EXPORT GlobalActivityTracker {
   void ReleaseTrackerForCurrentThreadForTesting();
 
   // Sets a task-runner that can be used for background work.
-  void SetBackgroundTaskRunner(const scoped_refptr<TaskRunner>& runner);
+  void SetBackgroundTaskRunner(
+      const scoped_refptr<SequencedTaskRunner>& runner);
 
   // Sets an optional callback to be called when a process exits.
   void SetProcessExitCallback(ProcessExitCallback callback);
@@ -1222,7 +1223,7 @@ class BASE_EXPORT GlobalActivityTracker {
   std::map<int64_t, std::string> known_processes_;
 
   // A task-runner that can be used for doing background processing.
-  scoped_refptr<TaskRunner> background_task_runner_;
+  scoped_refptr<SequencedTaskRunner> background_task_runner_;
 
   // A callback performed when a subprocess exits, including its exit-code
   // and the phase it was in when that occurred. This will be called via

base/sequenced_task_runner.h

@@ -152,6 +152,19 @@ class BASE_EXPORT SequencedTaskRunner : public TaskRunner {
                                 object.release());
   }
 
+  // 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.
+  virtual bool RunsTasksInCurrentSequence() const = 0;
+
  protected:
   ~SequencedTaskRunner() override = default;
 

base/task/cancelable_task_tracker.cc

@@ -14,6 +14,7 @@
 #include "base/feature_list.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
+#include "base/sequenced_task_runner.h"
 #include "base/task_runner.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 
@@ -21,7 +22,7 @@ namespace base {
 
 namespace {
 
-void RunOrPostToTaskRunner(scoped_refptr<TaskRunner> task_runner,
+void RunOrPostToTaskRunner(scoped_refptr<SequencedTaskRunner> task_runner,
                            OnceClosure closure) {
   if (task_runner->RunsTasksInCurrentSequence())
     std::move(closure).Run();
@@ -163,13 +164,14 @@ bool CancelableTaskTracker::HasTrackedTasks() const {
 
 // static
 void CancelableTaskTracker::RunIfNotCanceled(
-    const scoped_refptr<TaskRunner>& task_runner,
+    const scoped_refptr<SequencedTaskRunner>& origin_task_runner,
     const scoped_refptr<TaskCancellationFlag>& flag,
     OnceClosure task) {
   // TODO(https://crbug.com/1009795): Ignore off-sequence cancellation, to
   // evaluate whether it is a worthwhile optimization.
-  if (flag->data.IsSet() && (AllowOffSequenceTaskCancelation() ||
-                             task_runner->RunsTasksInCurrentSequence())) {
+  if (flag->data.IsSet() &&
+      (AllowOffSequenceTaskCancelation() ||
+       origin_task_runner->RunsTasksInCurrentSequence())) {
     return;
   }
   std::move(task).Run();
@@ -177,21 +179,22 @@ void CancelableTaskTracker::RunIfNotCanceled(
 
 // static
 void CancelableTaskTracker::RunThenUntrackIfNotCanceled(
-    const scoped_refptr<TaskRunner>& task_runner,
+    const scoped_refptr<SequencedTaskRunner>& origin_task_runner,
     const scoped_refptr<TaskCancellationFlag>& flag,
     OnceClosure task,
     OnceClosure untrack) {
-  RunIfNotCanceled(task_runner, flag, std::move(task));
-  RunIfNotCanceled(task_runner, flag, std::move(untrack));
+  RunIfNotCanceled(origin_task_runner, flag, std::move(task));
+  RunIfNotCanceled(origin_task_runner, flag, std::move(untrack));
 }
 
 // static
 bool CancelableTaskTracker::IsCanceled(
-    const scoped_refptr<TaskRunner>& task_runner,
+    const scoped_refptr<SequencedTaskRunner>& origin_task_runner,
     const scoped_refptr<TaskCancellationFlag>& flag,
     const ScopedClosureRunner& cleanup_runner) {
-  return flag->data.IsSet() && (AllowOffSequenceTaskCancelation() ||
-                                task_runner->RunsTasksInCurrentSequence());
+  return flag->data.IsSet() &&
+         (AllowOffSequenceTaskCancelation() ||
+          origin_task_runner->RunsTasksInCurrentSequence());
 }
 
 void CancelableTaskTracker::Track(TaskId id,

base/task/cancelable_task_tracker.h

@@ -138,17 +138,19 @@ class BASE_EXPORT CancelableTaskTracker {
   // See https://crbug.com/918948.
   using TaskCancellationFlag = RefCountedData<AtomicFlag>;
 
-  static void RunIfNotCanceled(const scoped_refptr<TaskRunner>& task_runner,
-                               const scoped_refptr<TaskCancellationFlag>& flag,
-                               OnceClosure task);
+  static void RunIfNotCanceled(
+      const scoped_refptr<SequencedTaskRunner>& origin_task_runner,
+      const scoped_refptr<TaskCancellationFlag>& flag,
+      OnceClosure task);
   static void RunThenUntrackIfNotCanceled(
-      const scoped_refptr<TaskRunner>& task_runner,
+      const scoped_refptr<SequencedTaskRunner>& origin_task_runner,
       const scoped_refptr<TaskCancellationFlag>& flag,
       OnceClosure task,
       OnceClosure untrack);
-  static bool IsCanceled(const scoped_refptr<TaskRunner>& task_runner,
-                         const scoped_refptr<TaskCancellationFlag>& flag,
-                         const ScopedClosureRunner& cleanup_runner);
+  static bool IsCanceled(
+      const scoped_refptr<SequencedTaskRunner>& origin_task_runner,
+      const scoped_refptr<TaskCancellationFlag>& flag,
+      const ScopedClosureRunner& cleanup_runner);
 
   void Track(TaskId id, scoped_refptr<TaskCancellationFlag> flag);
   void Untrack(TaskId id);

base/task/thread_pool/delayed_task_manager.cc

@@ -8,6 +8,7 @@
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/sequenced_task_runner.h"
 #include "base/task/post_task.h"
 #include "base/task/thread_pool/task.h"
 #include "base/task_runner.h"
@@ -60,7 +61,7 @@ DelayedTaskManager::DelayedTaskManager(const TickClock* tick_clock)
 DelayedTaskManager::~DelayedTaskManager() = default;
 
 void DelayedTaskManager::Start(
-    scoped_refptr<TaskRunner> service_thread_task_runner) {
+    scoped_refptr<SequencedTaskRunner> service_thread_task_runner) {
   DCHECK(service_thread_task_runner);
 
   TimeTicks process_ripe_tasks_time;

base/task/thread_pool/delayed_task_manager.h

@@ -24,7 +24,7 @@
 
 namespace base {
 
-class TaskRunner;
+class SequencedTaskRunner;
 
 namespace internal {
 
@@ -45,7 +45,7 @@ class BASE_EXPORT DelayedTaskManager {
   // forwarded to their callbacks as they become ripe for execution.
   // |service_thread_task_runner| posts tasks to the ThreadPool service
   // thread.
-  void Start(scoped_refptr<TaskRunner> service_thread_task_runner);
+  void Start(scoped_refptr<SequencedTaskRunner> service_thread_task_runner);
 
   // Schedules a call to |post_task_now_callback| with |task| as argument when
   // |task| is ripe for execution. |task_runner| is passed to retain a
@@ -123,7 +123,7 @@ class BASE_EXPORT DelayedTaskManager {
   // that it is non-null.
   mutable CheckedLock queue_lock_;
 
-  scoped_refptr<TaskRunner> service_thread_task_runner_;
+  scoped_refptr<SequencedTaskRunner> service_thread_task_runner_;
 
   IntrusiveHeap<DelayedTask> delayed_task_queue_ GUARDED_BY(queue_lock_);
 

base/task/thread_pool/pooled_parallel_task_runner.cc

@@ -37,10 +37,6 @@ bool PooledParallelTaskRunner::PostDelayedTask(const Location& from_here,
       Task(from_here, std::move(closure), delay), std::move(sequence));
 }
 
-bool PooledParallelTaskRunner::RunsTasksInCurrentSequence() const {
-  return pooled_task_runner_delegate_->IsRunningPoolWithTraits(traits_);
-}
-
 void PooledParallelTaskRunner::UnregisterSequence(Sequence* sequence) {
   DCHECK(sequence);
 

base/task/thread_pool/pooled_parallel_task_runner.h

@@ -34,8 +34,6 @@ class BASE_EXPORT PooledParallelTaskRunner : public TaskRunner {
                        OnceClosure closure,
                        TimeDelta delay) override;
 
-  bool RunsTasksInCurrentSequence() const override;
-
   // Removes |sequence| from |sequences_|.
   void UnregisterSequence(Sequence* sequence);
 

base/task/thread_pool/pooled_task_runner_delegate.h

@@ -50,11 +50,6 @@ class BASE_EXPORT PooledTaskRunnerDelegate {
   virtual void RemoveJobTaskSource(
       scoped_refptr<JobTaskSource> task_source) = 0;
 
-  // Invoked when RunsTasksInCurrentSequence() is called on a
-  // PooledParallelTaskRunner. Returns true if the current thread is part of the
-  // ThreadGroup associated with |traits|.
-  virtual bool IsRunningPoolWithTraits(const TaskTraits& traits) const = 0;
-
   // Invoked when the priority of |sequence|'s TaskRunner is updated. The
   // implementation must update |sequence|'s priority to |priority|, then place
   // |sequence| in the correct priority-queue position within the appropriate

base/task/thread_pool/test_task_factory.cc

@@ -53,7 +53,11 @@ void TestTaskFactory::RunTaskCallback(size_t task_index,
   if (post_nested_task == PostNestedTask::YES)
     PostTask(PostNestedTask::NO, OnceClosure());
 
-  EXPECT_TRUE(task_runner_->RunsTasksInCurrentSequence());
+  if (execution_mode_ == TaskSourceExecutionMode::kSingleThread ||
+      execution_mode_ == TaskSourceExecutionMode::kSequenced) {
+    EXPECT_TRUE(static_cast<SequencedTaskRunner*>(task_runner_.get())
+                    ->RunsTasksInCurrentSequence());
+  }
 
   // Verify TaskRunnerHandles are set as expected in the task's scope.
   switch (execution_mode_) {

base/task/thread_pool/test_task_factory.h

@@ -25,8 +25,9 @@ namespace test {
 
 // A TestTaskFactory posts tasks to a TaskRunner and verifies that they run as
 // expected. Generates a test failure when:
-// - The RunsTasksInCurrentSequence() method of the TaskRunner returns false on
-//   a thread on which a Task is run.
+// - The RunsTasksInCurrentSequence() method of the SequencedTaskRunner
+//   (kSequenced or kSingleThread modes) returns false on a thread on which a
+//   Task is run.
 // - The TaskRunnerHandles set in the context of the task don't match what's
 //   expected for the tested TaskSourceExecutionMode.
 // - The TaskSourceExecutionMode of the TaskRunner is kSequenced or

base/task/thread_pool/test_utils.cc

@@ -36,8 +36,6 @@ class MockJobTaskRunner : public TaskRunner {
                        OnceClosure closure,
                        TimeDelta delay) override;
 
-  bool RunsTasksInCurrentSequence() const override;
-
  private:
   ~MockJobTaskRunner() override;
 
@@ -62,10 +60,6 @@ bool MockJobTaskRunner::PostDelayedTask(const Location& from_here,
       std::move(task_source));
 }
 
-bool MockJobTaskRunner::RunsTasksInCurrentSequence() const {
-  return pooled_task_runner_delegate_->IsRunningPoolWithTraits(traits_);
-}
-
 MockJobTaskRunner::~MockJobTaskRunner() = default;
 
 scoped_refptr<TaskRunner> CreateJobTaskRunner(
@@ -244,15 +238,6 @@ void MockPooledTaskRunnerDelegate::RemoveJobTaskSource(
   thread_group_->RemoveTaskSource(*task_source);
 }
 
-bool MockPooledTaskRunnerDelegate::IsRunningPoolWithTraits(
-    const TaskTraits& traits) const {
-  // |thread_group_| must be initialized with SetThreadGroup() before
-  // proceeding.
-  DCHECK(thread_group_);
-
-  return thread_group_->IsBoundToCurrentThread();
-}
-
 void MockPooledTaskRunnerDelegate::UpdatePriority(
     scoped_refptr<TaskSource> task_source,
     TaskPriority priority) {

base/task/thread_pool/test_utils.h

@@ -64,7 +64,6 @@ class MockPooledTaskRunnerDelegate : public PooledTaskRunnerDelegate {
   bool EnqueueJobTaskSource(scoped_refptr<JobTaskSource> task_source) override;
   void RemoveJobTaskSource(scoped_refptr<JobTaskSource> task_source) override;
   bool ShouldYield(const TaskSource* task_source) const override;
-  bool IsRunningPoolWithTraits(const TaskTraits& traits) const override;
   void UpdatePriority(scoped_refptr<TaskSource> task_source,
                       TaskPriority priority) override;
 

base/task/thread_pool/thread_group_impl.cc

@@ -409,7 +409,7 @@ void ThreadGroupImpl::Start(
     int max_tasks,
     int max_best_effort_tasks,
     TimeDelta suggested_reclaim_time,
-    scoped_refptr<TaskRunner> service_thread_task_runner,
+    scoped_refptr<SequencedTaskRunner> service_thread_task_runner,
     WorkerThreadObserver* worker_thread_observer,
     WorkerEnvironment worker_environment,
     Optional<TimeDelta> may_block_threshold) {

base/task/thread_pool/thread_group_impl.h

@@ -19,6 +19,7 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/optional.h"
+#include "base/sequenced_task_runner.h"
 #include "base/strings/string_piece.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/waitable_event.h"
@@ -28,7 +29,6 @@
 #include "base/task/thread_pool/tracked_ref.h"
 #include "base/task/thread_pool/worker_thread.h"
 #include "base/task/thread_pool/worker_thread_stack.h"
-#include "base/task_runner.h"
 #include "base/time/time.h"
 
 namespace base {
@@ -77,7 +77,7 @@ class BASE_EXPORT ThreadGroupImpl : public ThreadGroup {
   void Start(int max_tasks,
              int max_best_effort_tasks,
              TimeDelta suggested_reclaim_time,
-             scoped_refptr<TaskRunner> service_thread_task_runner,
+             scoped_refptr<SequencedTaskRunner> service_thread_task_runner,
              WorkerThreadObserver* worker_thread_observer,
              WorkerEnvironment worker_environment,
              Optional<TimeDelta> may_block_threshold = Optional<TimeDelta>());
@@ -239,7 +239,7 @@ class BASE_EXPORT ThreadGroupImpl : public ThreadGroup {
     // Environment to be initialized per worker.
     WorkerEnvironment worker_environment = WorkerEnvironment::NONE;
 
-    scoped_refptr<TaskRunner> service_thread_task_runner;
+    scoped_refptr<SequencedTaskRunner> service_thread_task_runner;
 
     // Optional observer notified when a worker enters and exits its main.
     WorkerThreadObserver* worker_thread_observer = nullptr;

base/task/thread_pool/thread_group_impl_unittest.cc

@@ -186,8 +186,6 @@ class ThreadPostingTasksWaitIdle : public SimpleThread {
 
  private:
   void Run() override {
-    EXPECT_FALSE(factory_.task_runner()->RunsTasksInCurrentSequence());
-
     for (size_t i = 0; i < kNumTasksPostedPerThread; ++i) {
       thread_group_->WaitForAllWorkersIdleForTesting();
       EXPECT_TRUE(factory_.PostTask(PostNestedTask::NO, OnceClosure()));

base/task/thread_pool/thread_group_unittest.cc

@@ -83,8 +83,6 @@ class ThreadPostingTasks : public SimpleThread {
 
  private:
   void Run() override {
-    EXPECT_FALSE(factory_.task_runner()->RunsTasksInCurrentSequence());
-
     for (size_t i = 0; i < kNumTasksPostedPerThread; ++i)
       EXPECT_TRUE(factory_.PostTask(post_nested_task_, OnceClosure()));
   }
@@ -328,7 +326,7 @@ TEST_P(ThreadGroupTestAllExecutionModes, SequencedRunsTasksInCurrentSequence) {
   task_runner->PostTask(
       FROM_HERE,
       BindOnce(
-          [](scoped_refptr<TaskRunner> sequenced_task_runner,
+          [](scoped_refptr<SequencedTaskRunner> sequenced_task_runner,
              WaitableEvent* task_ran) {
             EXPECT_FALSE(sequenced_task_runner->RunsTasksInCurrentSequence());
             task_ran->Signal();

base/task/thread_pool/thread_pool_impl.cc

@@ -171,8 +171,7 @@ void ThreadPoolImpl::Start(const ThreadPoolInstance::InitParams& init_params,
   UpdateCanRunPolicy();
 
   // Needs to happen after starting the service thread to get its task_runner().
-  scoped_refptr<TaskRunner> service_thread_task_runner =
-      service_thread_->task_runner();
+  auto service_thread_task_runner = service_thread_->task_runner();
   delayed_task_manager_.Start(service_thread_task_runner);
 
   single_thread_task_runner_manager_.Start(worker_thread_observer);
@@ -467,10 +466,6 @@ void ThreadPoolImpl::RemoveJobTaskSource(
   current_thread_group->RemoveTaskSource(*task_source);
 }
 
-bool ThreadPoolImpl::IsRunningPoolWithTraits(const TaskTraits& traits) const {
-  return GetThreadGroupForTraits(traits)->IsBoundToCurrentThread();
-}
-
 void ThreadPoolImpl::UpdatePriority(scoped_refptr<TaskSource> task_source,
                                     TaskPriority priority) {
   auto transaction = task_source->BeginTransaction();

base/task/thread_pool/thread_pool_impl.h

@@ -145,7 +145,6 @@ class BASE_EXPORT ThreadPoolImpl : public ThreadPoolInstance,
   // PooledTaskRunnerDelegate:
   bool PostTaskWithSequence(Task task,
                             scoped_refptr<Sequence> sequence) override;
-  bool IsRunningPoolWithTraits(const TaskTraits& traits) const override;
   bool ShouldYield(const TaskSource* task_source) const override;
 
   const std::unique_ptr<TaskTrackerImpl> task_tracker_;

base/task/thread_pool/thread_pool_impl_unittest.cc

@@ -204,8 +204,6 @@ class ThreadPostingTasks : public SimpleThread {
 
  private:
   void Run() override {
-    EXPECT_FALSE(factory_.task_runner()->RunsTasksInCurrentSequence());
-
     const size_t kNumTasksPerThread = 150;
     for (size_t i = 0; i < kNumTasksPerThread; ++i) {
       factory_.PostTask(test::TestTaskFactory::PostNestedTask::NO,
@@ -402,7 +400,6 @@ TEST_P(ThreadPoolImplTest_CoverAllSchedulingOptions, PostTasksViaTaskRunner) {
       CreateTaskRunnerAndExecutionMode(thread_pool_.get(), GetTraits(),
                                        GetExecutionMode()),
       GetExecutionMode());
-  EXPECT_FALSE(factory.task_runner()->RunsTasksInCurrentSequence());
 
   const size_t kNumTasksPerTest = 150;
   for (size_t i = 0; i < kNumTasksPerTest; ++i) {
@@ -826,7 +823,7 @@ TEST_P(ThreadPoolImplTest, SequencedRunsTasksInCurrentSequence) {
   single_thread_task_runner->PostTask(
       FROM_HERE,
       BindOnce(
-          [](scoped_refptr<TaskRunner> sequenced_task_runner,
+          [](scoped_refptr<SequencedTaskRunner> sequenced_task_runner,
              WaitableEvent* task_ran) {
             EXPECT_FALSE(sequenced_task_runner->RunsTasksInCurrentSequence());
             task_ran->Signal();
@@ -849,7 +846,7 @@ TEST_P(ThreadPoolImplTest, SingleThreadRunsTasksInCurrentSequence) {
   sequenced_task_runner->PostTask(
       FROM_HERE,
       BindOnce(
-          [](scoped_refptr<TaskRunner> single_thread_task_runner,
+          [](scoped_refptr<SingleThreadTaskRunner> single_thread_task_runner,
              WaitableEvent* task_ran) {
             EXPECT_FALSE(
                 single_thread_task_runner->RunsTasksInCurrentSequence());

base/task_runner.h

@@ -70,24 +70,6 @@ class BASE_EXPORT TaskRunner
                                OnceClosure task,
                                base::TimeDelta delay) = 0;
 
-  // 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.
-  // 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

base/test/task_runner_test_template.cc

@@ -37,11 +37,6 @@ void TaskTracker::WaitForCompletedTasks(int count) {
     task_runs_cv_.Wait();
 }
 
-void ExpectRunsTasksInCurrentSequence(bool expected_value,
-                                      TaskRunner* task_runner) {
-  EXPECT_EQ(expected_value, task_runner->RunsTasksInCurrentSequence());
-}
-
 }  // namespace test
 
 }  // namespace base

base/trace_event/memory_dump_scheduler_unittest.cc

@@ -169,7 +169,7 @@ TEST_F(MemoryDumpSchedulerTest, StopAndStartOnAnotherThread) {
   config.callback =
       BindRepeating(&CallbackWrapper::OnTick, Unretained(&on_tick_));
 
-  scoped_refptr<TaskRunner> expected_task_runner = bg_thread_.task_runner();
+  auto expected_task_runner = bg_thread_.task_runner();
   testing::InSequence sequence;
   EXPECT_CALL(on_tick_, OnTick(_)).Times(kTicks - 1);
   EXPECT_CALL(on_tick_, OnTick(_))

chrome/browser/after_startup_task_utils.cc

@@ -15,9 +15,9 @@
 #include "base/process/process.h"
 #include "base/rand_util.h"
 #include "base/sequence_checker.h"
+#include "base/sequenced_task_runner.h"
 #include "base/synchronization/atomic_flag.h"
 #include "base/task/post_task.h"
-#include "base/task_runner.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
@@ -45,13 +45,13 @@ namespace {
 
 struct AfterStartupTask {
   AfterStartupTask(const base::Location& from_here,
-                   const scoped_refptr<base::TaskRunner>& task_runner,
+                   const scoped_refptr<base::SequencedTaskRunner>& task_runner,
                    base::OnceClosure task)
       : from_here(from_here), task_runner(task_runner), task(std::move(task)) {}
   ~AfterStartupTask() {}
 
   const base::Location from_here;
-  const scoped_refptr<base::TaskRunner> task_runner;
+  const scoped_refptr<base::SequencedTaskRunner> task_runner;
   base::OnceClosure task;
 };
 
@@ -82,7 +82,8 @@ void ScheduleTask(std::unique_ptr<AfterStartupTask> queued_task) {
   // Spread their execution over a brief time.
   constexpr int kMinDelaySec = 0;
   constexpr int kMaxDelaySec = 10;
-  scoped_refptr<base::TaskRunner> target_runner = queued_task->task_runner;
+  scoped_refptr<base::SequencedTaskRunner> target_runner =
+      queued_task->task_runner;
   base::Location from_here = queued_task->from_here;
   int delay_in_seconds = g_schedule_tasks_with_delay
                              ? base::RandInt(kMinDelaySec, kMaxDelaySec)
@@ -235,28 +236,6 @@ void StartupObserver::Start() {
 
 }  // namespace
 
-AfterStartupTaskUtils::Runner::Runner(
-    scoped_refptr<base::TaskRunner> destination_runner)
-    : destination_runner_(std::move(destination_runner)) {
-  DCHECK(destination_runner_);
-}
-
-AfterStartupTaskUtils::Runner::~Runner() = default;
-
-bool AfterStartupTaskUtils::Runner::PostDelayedTask(
-    const base::Location& from_here,
-    base::OnceClosure task,
-    base::TimeDelta delay) {
-  DCHECK(delay.is_zero());
-  AfterStartupTaskUtils::PostTask(from_here, destination_runner_,
-                                  std::move(task));
-  return true;
-}
-
-bool AfterStartupTaskUtils::Runner::RunsTasksInCurrentSequence() const {
-  return destination_runner_->RunsTasksInCurrentSequence();
-}
-
 void AfterStartupTaskUtils::StartMonitoringStartup() {
   // The observer is self-deleting.
   (new StartupObserver)->Start();
@@ -264,7 +243,7 @@ void AfterStartupTaskUtils::StartMonitoringStartup() {
 
 void AfterStartupTaskUtils::PostTask(
     const base::Location& from_here,
-    const scoped_refptr<base::TaskRunner>& destination_runner,
+    const scoped_refptr<base::SequencedTaskRunner>& destination_runner,
     base::OnceClosure task) {
   if (IsBrowserStartupComplete()) {
     destination_runner->PostTask(from_here, std::move(task));

chrome/browser/after_startup_task_utils.h

@@ -7,37 +7,20 @@
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/task_runner.h"
 
 namespace android {
 class AfterStartupTaskUtilsJNI;
 }
 
+namespace base {
+class SequencedTaskRunner;
+}
+
 class AfterStartupTaskUtils {
  public:
-  // A helper TaskRunner which merely forwards to
-  // AfterStartupTaskUtils::PostTask(). Doesn't support tasks with a non-zero
-  // delay.
-  class Runner : public base::TaskRunner {
-   public:
-    explicit Runner(scoped_refptr<base::TaskRunner> destination_runner);
-
-    // Overrides from base::TaskRunner:
-    bool PostDelayedTask(const base::Location& from_here,
-                         base::OnceClosure task,
-                         base::TimeDelta delay) override;
-    bool RunsTasksInCurrentSequence() const override;
-
-   private:
-    ~Runner() override;
-
-    const scoped_refptr<base::TaskRunner> destination_runner_;
-
-    DISALLOW_COPY_AND_ASSIGN(Runner);
-  };
-
   // Observes startup and when complete runs tasks that have accrued.
   static void StartMonitoringStartup();
 
@@ -46,7 +29,7 @@ class AfterStartupTaskUtils {
   // Note: see browser_thread.h
   static void PostTask(
       const base::Location& from_here,
-      const scoped_refptr<base::TaskRunner>& destination_runner,
+      const scoped_refptr<base::SequencedTaskRunner>& destination_runner,
       base::OnceClosure task);
 
   // Returns true if browser startup is complete. Only use this on a one-off

chrome/browser/after_startup_task_utils_unittest.cc

@@ -11,6 +11,7 @@
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
+#include "base/sequenced_task_runner.h"
 #include "base/task/post_task.h"
 #include "base/task_runner_util.h"
 #include "content/public/browser/browser_task_traits.h"
@@ -20,9 +21,9 @@
 
 namespace {
 
-class WrappedTaskRunner : public base::TaskRunner {
+class WrappedTaskRunner : public base::SequencedTaskRunner {
  public:
-  explicit WrappedTaskRunner(scoped_refptr<TaskRunner> real_runner)
+  explicit WrappedTaskRunner(scoped_refptr<SequencedTaskRunner> real_runner)
       : real_task_runner_(std::move(real_runner)) {}
 
   bool PostDelayedTask(const base::Location& from_here,
@@ -36,11 +37,21 @@ class WrappedTaskRunner : public base::TaskRunner {
         base::TimeDelta());  // Squash all delays so our tests complete asap.
   }
 
+  bool PostNonNestableDelayedTask(const base::Location& from_here,
+                                  base::OnceClosure task,
+                                  base::TimeDelta delay) override {
+    // Not implemented.
+    NOTREACHED();
+    return false;
+  }
+
   bool RunsTasksInCurrentSequence() const override {
     return real_task_runner_->RunsTasksInCurrentSequence();
   }
 
-  base::TaskRunner* real_runner() const { return real_task_runner_.get(); }
+  base::SequencedTaskRunner* real_runner() const {
+    return real_task_runner_.get();
+  }
 
   int total_task_count() const { return posted_task_count_ + ran_task_count_; }
   int posted_task_count() const { return posted_task_count_; }
@@ -59,7 +70,7 @@ class WrappedTaskRunner : public base::TaskRunner {
     std::move(task).Run();
   }
 
-  scoped_refptr<TaskRunner> real_task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> real_task_runner_;
   int posted_task_count_ = 0;
   int ran_task_count_ = 0;
 };
@@ -92,7 +103,7 @@ class AfterStartupTaskTest : public testing::Test {
   // Hop to the background sequence and call PostAfterStartupTask.
   void PostAfterStartupTaskFromBackgroundSequence(
       const base::Location& from_here,
-      scoped_refptr<base::TaskRunner> task_runner,
+      scoped_refptr<base::SequencedTaskRunner> task_runner,
       base::OnceClosure task) {
     base::RunLoop run_loop;
     background_sequence_->real_runner()->PostTaskAndReply(
@@ -112,7 +123,7 @@ class AfterStartupTaskTest : public testing::Test {
     run_loop.Run();
   }
 
-  static void VerifyExpectedSequence(base::TaskRunner* task_runner) {
+  static void VerifyExpectedSequence(base::SequencedTaskRunner* task_runner) {
     EXPECT_TRUE(task_runner->RunsTasksInCurrentSequence());
   }
 
@@ -197,29 +208,3 @@ TEST_F(AfterStartupTaskTest, PostTask) {
   EXPECT_EQ(2, background_sequence_->ran_task_count());
   EXPECT_EQ(2, ui_thread_->ran_task_count());
 }
-
-// Verify that posting to an AfterStartupTaskUtils::Runner bound to
-// |background_sequence_| results in the same behavior as posting via
-// AfterStartupTaskUtils::PostTask(..., background_sequence_, ...).
-TEST_F(AfterStartupTaskTest, AfterStartupTaskUtilsRunner) {
-  scoped_refptr<base::TaskRunner> after_startup_runner =
-      base::MakeRefCounted<AfterStartupTaskUtils::Runner>(background_sequence_);
-
-  EXPECT_FALSE(AfterStartupTaskUtils::IsBrowserStartupComplete());
-  after_startup_runner->PostTask(
-      FROM_HERE, base::BindOnce(&AfterStartupTaskTest::VerifyExpectedSequence,
-                                base::RetainedRef(background_sequence_)));
-
-  base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(AfterStartupTaskUtils::IsBrowserStartupComplete());
-  EXPECT_EQ(0, background_sequence_->total_task_count());
-
-  AfterStartupTaskUtils::SetBrowserStartupIsCompleteForTesting();
-  EXPECT_EQ(1, background_sequence_->posted_task_count());
-
-  FlushBackgroundSequence();
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(1, background_sequence_->ran_task_count());
-
-  EXPECT_EQ(0, ui_thread_->total_task_count());
-}

chrome/browser/chrome_content_browser_client.cc

@@ -24,6 +24,7 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/no_destructor.h"
 #include "base/path_service.h"
+#include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ -1282,7 +1283,7 @@ ChromeContentBrowserClient::CreateBrowserMainParts(
 
 void ChromeContentBrowserClient::PostAfterStartupTask(
     const base::Location& from_here,
-    const scoped_refptr<base::TaskRunner>& task_runner,
+    const scoped_refptr<base::SequencedTaskRunner>& task_runner,
     base::OnceClosure task) {
   AfterStartupTaskUtils::PostTask(from_here, task_runner, std::move(task));
 

chrome/browser/chrome_content_browser_client.h

@@ -111,9 +111,10 @@ class ChromeContentBrowserClient : public content::ContentBrowserClient {
   // content::ContentBrowserClient:
   std::unique_ptr<content::BrowserMainParts> CreateBrowserMainParts(
       const content::MainFunctionParams& parameters) override;
-  void PostAfterStartupTask(const base::Location& from_here,
-                            const scoped_refptr<base::TaskRunner>& task_runner,
-                            base::OnceClosure task) override;
+  void PostAfterStartupTask(
+      const base::Location& from_here,
+      const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+      base::OnceClosure task) override;
   bool IsBrowserStartupComplete() override;
   void SetBrowserStartupIsCompleteForTesting() override;
   std::string GetStoragePartitionIdForSite(

chrome/browser/chromeos/login/users/chrome_user_manager.cc

@@ -21,8 +21,8 @@
 namespace chromeos {
 
 ChromeUserManager::ChromeUserManager(
-    scoped_refptr<base::TaskRunner> task_runner)
-    : UserManagerBase(task_runner) {}
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    : UserManagerBase(std::move(task_runner)) {}
 
 ChromeUserManager::~ChromeUserManager() {}
 

chrome/browser/chromeos/login/users/chrome_user_manager.h

@@ -7,7 +7,7 @@
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/task_runner.h"
+#include "base/single_thread_task_runner.h"
 #include "chrome/browser/chromeos/login/users/affiliation.h"
 #include "chrome/browser/chromeos/login/users/user_manager_interface.h"
 #include "chrome/browser/chromeos/policy/device_local_account_policy_service.h"
@@ -22,7 +22,8 @@ namespace chromeos {
 class ChromeUserManager : public user_manager::UserManagerBase,
                           public UserManagerInterface {
  public:
-  explicit ChromeUserManager(scoped_refptr<base::TaskRunner> task_runner);
+  explicit ChromeUserManager(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~ChromeUserManager() override;
 
   // user_manager::UserManagerBase:

chrome/browser/chromeos/login/users/chrome_user_manager_impl.cc

@@ -29,7 +29,6 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
-#include "base/task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
@@ -355,7 +354,7 @@ void ChromeUserManagerImpl::ResetPublicAccountDelegatesForTesting() {
 ChromeUserManagerImpl::ChromeUserManagerImpl()
     : ChromeUserManager(base::ThreadTaskRunnerHandle::IsSet()
                             ? base::ThreadTaskRunnerHandle::Get()
-                            : scoped_refptr<base::TaskRunner>()),
+                            : nullptr),
       cros_settings_(CrosSettings::Get()),
       device_local_account_policy_service_(NULL),
       supervised_user_manager_(new SupervisedUserManagerImpl(this)) {

chrome/browser/chromeos/login/users/fake_chrome_user_manager.cc

@@ -9,6 +9,7 @@
 
 #include "base/callback.h"
 #include "base/command_line.h"
+#include "base/single_thread_task_runner.h"
 #include "base/system/sys_info.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
@@ -33,7 +34,7 @@
 
 namespace {
 
-class FakeTaskRunner : public base::TaskRunner {
+class FakeTaskRunner : public base::SingleThreadTaskRunner {
  public:
   FakeTaskRunner() = default;
 
@@ -41,13 +42,18 @@ class FakeTaskRunner : public base::TaskRunner {
   ~FakeTaskRunner() override {}
 
  private:
-  // base::TaskRunner overrides.
+  // base::SingleThreadTaskRunner:
   bool PostDelayedTask(const base::Location& from_here,
                        base::OnceClosure task,
                        base::TimeDelta delay) override {
     std::move(task).Run();
     return true;
   }
+  bool PostNonNestableDelayedTask(const base::Location& from_here,
+                                  base::OnceClosure task,
+                                  base::TimeDelta delay) override {
+    return PostDelayedTask(from_here, std::move(task), delay);
+  }
   bool RunsTasksInCurrentSequence() const override { return true; }
 
   DISALLOW_COPY_AND_ASSIGN(FakeTaskRunner);

chrome/browser/chromeos/login/users/mock_user_manager.cc

@@ -6,20 +6,26 @@
 
 #include <utility>
 
-#include "base/task_runner.h"
+#include "base/single_thread_task_runner.h"
 #include "chrome/browser/chromeos/login/users/fake_supervised_user_manager.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 
 namespace {
 
-class FakeTaskRunner : public base::TaskRunner {
+class FakeTaskRunner : public base::SingleThreadTaskRunner {
  public:
+  // base::SingleThreadTaskRunner:
   bool PostDelayedTask(const base::Location& from_here,
                        base::OnceClosure task,
                        base::TimeDelta delay) override {
     std::move(task).Run();
     return true;
   }
+  bool PostNonNestableDelayedTask(const base::Location& from_here,
+                                  base::OnceClosure task,
+                                  base::TimeDelta delay) override {
+    return PostDelayedTask(from_here, std::move(task), delay);
+  }
   bool RunsTasksInCurrentSequence() const override { return true; }
 
  protected:

chrome/browser/extensions/api/management/management_browsertest.cc

@@ -42,7 +42,6 @@
 #include "extensions/browser/updater/extension_downloader.h"
 #include "extensions/test/extension_test_message_listener.h"
 #include "extensions/test/test_background_page_first_load_observer.h"
-#include "net/url_request/test_url_request_interceptor.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using content::BrowserThread;

chrome/browser/extensions/extension_disabled_ui_browsertest.cc

@@ -38,7 +38,6 @@
 #include "extensions/browser/test_extension_registry_observer.h"
 #include "extensions/common/extension.h"
 #include "extensions/test/extension_test_message_listener.h"
-#include "net/url_request/test_url_request_interceptor.h"
 
 using content::BrowserThread;
 using extensions::Extension;

chrome/browser/renderer_host/pepper/pepper_broker_message_filter.cc

@@ -34,7 +34,7 @@ PepperBrokerMessageFilter::PepperBrokerMessageFilter(PP_Instance instance,
 
 PepperBrokerMessageFilter::~PepperBrokerMessageFilter() {}
 
-scoped_refptr<base::TaskRunner>
+scoped_refptr<base::SequencedTaskRunner>
 PepperBrokerMessageFilter::OverrideTaskRunnerForMessage(
     const IPC::Message& message) {
   return base::CreateSingleThreadTaskRunner({BrowserThread::UI});

chrome/browser/renderer_host/pepper/pepper_broker_message_filter.h

@@ -33,7 +33,7 @@ class PepperBrokerMessageFilter : public ppapi::host::ResourceMessageFilter {
   ~PepperBrokerMessageFilter() override;
 
   // ppapi::host::ResourceMessageFilter overrides.
-  scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
+  scoped_refptr<base::SequencedTaskRunner> OverrideTaskRunnerForMessage(
       const IPC::Message& message) override;
   int32_t OnResourceMessageReceived(
       const IPC::Message& msg,

chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.cc

@@ -99,7 +99,7 @@ PepperFlashClipboardMessageFilter::PepperFlashClipboardMessageFilter() {}
 
 PepperFlashClipboardMessageFilter::~PepperFlashClipboardMessageFilter() {}
 
-scoped_refptr<base::TaskRunner>
+scoped_refptr<base::SequencedTaskRunner>
 PepperFlashClipboardMessageFilter::OverrideTaskRunnerForMessage(
     const IPC::Message& msg) {
   // Clipboard writes should always occur on the UI thread due to the

chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.h

@@ -39,7 +39,7 @@ class PepperFlashClipboardMessageFilter
 
  protected:
   // ppapi::host::ResourceMessageFilter overrides.
-  scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
+  scoped_refptr<base::SequencedTaskRunner> OverrideTaskRunnerForMessage(
       const IPC::Message& msg) override;
   int32_t OnResourceMessageReceived(
       const IPC::Message& msg,

chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.cc

@@ -76,7 +76,7 @@ PepperIsolatedFileSystemMessageFilter::PepperIsolatedFileSystemMessageFilter(
 PepperIsolatedFileSystemMessageFilter::
     ~PepperIsolatedFileSystemMessageFilter() {}
 
-scoped_refptr<base::TaskRunner>
+scoped_refptr<base::SequencedTaskRunner>
 PepperIsolatedFileSystemMessageFilter::OverrideTaskRunnerForMessage(
     const IPC::Message& msg) {
   // In order to reach ExtensionSystem, we need to get ProfileManager first.

chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.h

@@ -40,7 +40,7 @@ class PepperIsolatedFileSystemMessageFilter
       content::BrowserPpapiHost* host);
 
   // ppapi::host::ResourceMessageFilter implementation.
-  scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
+  scoped_refptr<base::SequencedTaskRunner> OverrideTaskRunnerForMessage(
       const IPC::Message& msg) override;
   int32_t OnResourceMessageReceived(
       const IPC::Message& msg,

chrome/browser/sync_file_system/drive_backend/callback_helper_unittest.cc

@@ -30,7 +30,7 @@ void CallbackWithPassed(bool* called, std::unique_ptr<int>) {
   *called = true;
 }
 
-void VerifyCalledOnTaskRunner(base::TaskRunner* task_runner,
+void VerifyCalledOnTaskRunner(base::SingleThreadTaskRunner* task_runner,
                               bool* called) {
   ASSERT_TRUE(called);
   ASSERT_TRUE(task_runner);

chrome/updater/win/install_app.cc

@@ -436,7 +436,7 @@ class InstallAppController : public ui::ProgressWndEvents,
 
   // Provides an execution environment for the UI code. Typically, it runs
   // a single task which is the UI run loop.
-  scoped_refptr<base::TaskRunner> ui_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 
   // The run loop associated with the updater main thread.
   base::RunLoop runloop_;

chromeos/dbus/blocking_method_caller_unittest.cc

@@ -11,7 +11,7 @@
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
-#include "base/task_runner.h"
+#include "base/single_thread_task_runner.h"
 #include "dbus/message.h"
 #include "dbus/mock_bus.h"
 #include "dbus/mock_object_proxy.h"
@@ -27,14 +27,20 @@ namespace chromeos {
 
 namespace {
 
-class FakeTaskRunner : public base::TaskRunner {
+class FakeTaskRunner : public base::SingleThreadTaskRunner {
  public:
+  // base::SingleThreadTaskRunner:
   bool PostDelayedTask(const base::Location& from_here,
                        base::OnceClosure task,
                        base::TimeDelta delay) override {
     std::move(task).Run();
     return true;
   }
+  bool PostNonNestableDelayedTask(const base::Location& from_here,
+                                  base::OnceClosure task,
+                                  base::TimeDelta delay) override {
+    return PostDelayedTask(from_here, std::move(task), delay);
+  }
   bool RunsTasksInCurrentSequence() const override { return true; }
 
  protected:

chromeos/login/auth/cryptohome_authenticator.cc

@@ -579,10 +579,10 @@ void CheckKey(const base::WeakPtr<AuthAttemptState>& attempt,
 }  // namespace
 
 CryptohomeAuthenticator::CryptohomeAuthenticator(
-    scoped_refptr<base::TaskRunner> task_runner,
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
     AuthStatusConsumer* consumer)
     : Authenticator(consumer),
-      task_runner_(task_runner),
+      task_runner_(std::move(task_runner)),
       migrate_attempted_(false),
       remove_attempted_(false),
       resync_attempted_(false),

chromeos/login/auth/cryptohome_authenticator.h

@@ -13,8 +13,8 @@
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/optional.h"
+#include "base/sequenced_task_runner.h"
 #include "base/synchronization/lock.h"
-#include "base/task_runner.h"
 #include "chromeos/login/auth/auth_attempt_state.h"
 #include "chromeos/login/auth/auth_attempt_state_resolver.h"
 #include "chromeos/login/auth/authenticator.h"
@@ -102,7 +102,7 @@ class COMPONENT_EXPORT(CHROMEOS_LOGIN_AUTH) CryptohomeAuthenticator
     OFFLINE_NO_MOUNT = 26,  // Offline login failed due to missing cryptohome.
   };
 
-  CryptohomeAuthenticator(scoped_refptr<base::TaskRunner> task_runner,
+  CryptohomeAuthenticator(scoped_refptr<base::SequencedTaskRunner> task_runner,
                           AuthStatusConsumer* consumer);
 
   // Authenticator overrides.
@@ -266,7 +266,7 @@ class COMPONENT_EXPORT(CHROMEOS_LOGIN_AUTH) CryptohomeAuthenticator
   // an external authentication provider (i.e. GAIA extension).
   void ResolveLoginCompletionStatus();
 
-  scoped_refptr<base::TaskRunner> task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   std::unique_ptr<AuthAttemptState> current_state_;
   bool migrate_attempted_;

chromeos/login/auth/login_performer.cc

@@ -29,10 +29,11 @@ using base::UserMetricsAction;
 
 namespace chromeos {
 
-LoginPerformer::LoginPerformer(scoped_refptr<base::TaskRunner> task_runner,
-                               Delegate* delegate)
+LoginPerformer::LoginPerformer(
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
+    Delegate* delegate)
     : delegate_(delegate),
-      task_runner_(task_runner),
+      task_runner_(std::move(task_runner)),
       last_login_failure_(AuthFailure::AuthFailureNone()) {}
 
 LoginPerformer::~LoginPerformer() {

chromeos/login/auth/login_performer.h

@@ -22,7 +22,7 @@
 class AccountId;
 
 namespace base {
-class TaskRunner;
+class SequencedTaskRunner;
 }
 
 namespace network {
@@ -63,7 +63,7 @@ class COMPONENT_EXPORT(CHROMEOS_LOGIN_AUTH) LoginPerformer
     virtual void SetAuthFlowOffline(bool offline) = 0;
   };
 
-  LoginPerformer(scoped_refptr<base::TaskRunner> task_runner,
+  LoginPerformer(scoped_refptr<base::SequencedTaskRunner> task_runner,
                  Delegate* delegate);
   ~LoginPerformer() override;
 
@@ -209,7 +209,7 @@ class COMPONENT_EXPORT(CHROMEOS_LOGIN_AUTH) LoginPerformer
   void DoPerformLogin(const UserContext& user_context,
                       AuthorizationMode auth_mode);
 
-  scoped_refptr<base::TaskRunner> task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   // Used for logging in.
   scoped_refptr<Authenticator> authenticator_;

chromeos/tpm/tpm_token_info_getter_unittest.cc

@@ -57,7 +57,6 @@ class FakeTaskRunner : public base::TaskRunner {
     base::ThreadTaskRunnerHandle::Get()->PostTask(from_here, std::move(task));
     return true;
   }
-  bool RunsTasksInCurrentSequence() const override { return true; }
 
  protected:
   ~FakeTaskRunner() override = default;

components/history/core/browser/top_sites_impl.cc

@@ -37,7 +37,7 @@ namespace history {
 namespace {
 
 void RunOrPostGetMostVisitedURLsCallback(
-    base::TaskRunner* task_runner,
+    base::SequencedTaskRunner* task_runner,
     const TopSitesImpl::GetMostVisitedURLsCallback& callback,
     const MostVisitedURLList& urls) {
   if (task_runner->RunsTasksInCurrentSequence())

components/nacl/common/nacl_service.cc

@@ -51,7 +51,7 @@ mojo::IncomingInvitation GetMojoInvitation() {
 }  // namespace
 
 NaClService::NaClService(
-    scoped_refptr<base::SequencedTaskRunner> ipc_task_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner)
     : ipc_support_(std::move(ipc_task_runner),
                    mojo::core::ScopedIPCSupport::ShutdownPolicy::FAST) {}
 

components/nacl/common/nacl_service.h

@@ -6,7 +6,7 @@
 #define COMPONENTS_NACL_COMMON_NACL_SERVICE_H_
 
 #include "base/memory/scoped_refptr.h"
-#include "base/sequenced_task_runner.h"
+#include "base/single_thread_task_runner.h"
 #include "mojo/core/embedder/scoped_ipc_support.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 
@@ -15,7 +15,7 @@
 class NaClService {
  public:
   explicit NaClService(
-      scoped_refptr<base::SequencedTaskRunner> ipc_task_runner);
+      scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner);
   ~NaClService();
 
   // Returns a message pipe to use for the client endpoint of a legacy IPC

components/sessions/core/base_session_service.cc

@@ -32,7 +32,7 @@ void RunIfNotCanceled(
 }
 
 void PostOrRunInternalGetCommandsCallback(
-    base::TaskRunner* task_runner,
+    base::SequencedTaskRunner* task_runner,
     const BaseSessionService::GetCommandsCallback& callback,
     std::vector<std::unique_ptr<SessionCommand>> commands) {
   if (task_runner->RunsTasksInCurrentSequence()) {

components/user_manager/fake_user_manager.cc

@@ -9,22 +9,28 @@
 
 #include "base/callback.h"
 #include "base/command_line.h"
+#include "base/single_thread_task_runner.h"
 #include "base/system/sys_info.h"
-#include "base/task_runner.h"
 #include "chromeos/constants/chromeos_switches.h"
 #include "components/user_manager/user_names.h"
 #include "components/user_manager/user_type.h"
 
 namespace {
 
-class FakeTaskRunner : public base::TaskRunner {
+class FakeTaskRunner : public base::SingleThreadTaskRunner {
  public:
+  // base::SingleThreadTaskRunner:
   bool PostDelayedTask(const base::Location& from_here,
                        base::OnceClosure task,
                        base::TimeDelta delay) override {
     std::move(task).Run();
     return true;
   }
+  bool PostNonNestableDelayedTask(const base::Location& from_here,
+                                  base::OnceClosure task,
+                                  base::TimeDelta delay) override {
+    return PostDelayedTask(from_here, std::move(task), delay);
+  }
   bool RunsTasksInCurrentSequence() const override { return true; }
 
  protected:

components/user_manager/user_manager_base.cc

@@ -18,10 +18,10 @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/task_runner.h"
 #include "base/values.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
@@ -107,8 +107,9 @@ void UserManagerBase::RegisterPrefs(PrefRegistrySimple* registry) {
   known_user::RegisterPrefs(registry);
 }
 
-UserManagerBase::UserManagerBase(scoped_refptr<base::TaskRunner> task_runner)
-    : task_runner_(task_runner) {}
+UserManagerBase::UserManagerBase(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    : task_runner_(std::move(task_runner)) {}
 
 UserManagerBase::~UserManagerBase() {
   // Can't use STLDeleteElements because of the private destructor of User.

components/user_manager/user_manager_base.h

@@ -13,6 +13,7 @@
 
 #include "base/feature_list.h"
 #include "base/macros.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/synchronization/lock.h"
@@ -27,7 +28,7 @@ class PrefRegistrySimple;
 
 namespace base {
 class ListValue;
-class TaskRunner;
+class SingleThreadTaskRunner;
 }
 
 namespace user_manager {
@@ -40,9 +41,9 @@ class RemoveUserDelegate;
 // Base implementation of the UserManager interface.
 class USER_MANAGER_EXPORT UserManagerBase : public UserManager {
  public:
-  // Creates UserManagerBase with |task_runner| for UI thread and
-  // |blocking_task_runner| for SequencedWorkerPool.
-  explicit UserManagerBase(scoped_refptr<base::TaskRunner> task_runner);
+  // Creates UserManagerBase with |task_runner| for UI thread.
+  explicit UserManagerBase(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~UserManagerBase() override;
 
   // Registers UserManagerBase preferences.
@@ -391,7 +392,7 @@ class USER_MANAGER_EXPORT UserManagerBase : public UserManager {
   bool last_session_active_account_id_initialized_ = false;
 
   // TaskRunner for UI thread.
-  scoped_refptr<base::TaskRunner> task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   base::WeakPtrFactory<UserManagerBase> weak_factory_{this};
 

components/viz/common/frame_sinks/copy_output_request.h

@@ -9,7 +9,7 @@
 
 #include "base/callback.h"
 #include "base/optional.h"
-#include "base/task_runner.h"
+#include "base/sequenced_task_runner.h"
 #include "base/unguessable_token.h"
 #include "components/viz/common/frame_sinks/copy_output_result.h"
 #include "components/viz/common/resources/single_release_callback.h"
@@ -59,7 +59,8 @@ class VIZ_COMMON_EXPORT CopyOutputRequest {
   // Requests that the result callback be run as a task posted to the given
   // |task_runner|. If this is not set, the result callback could be run from
   // any context.
-  void set_result_task_runner(scoped_refptr<base::TaskRunner> task_runner) {
+  void set_result_task_runner(
+      scoped_refptr<base::SequencedTaskRunner> task_runner) {
     result_task_runner_ = std::move(task_runner);
   }
   bool has_result_task_runner() const { return !!result_task_runner_; }
@@ -127,7 +128,7 @@ class VIZ_COMMON_EXPORT CopyOutputRequest {
 
   const ResultFormat result_format_;
   CopyOutputRequestCallback result_callback_;
-  scoped_refptr<base::TaskRunner> result_task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> result_task_runner_;
   gfx::Vector2d scale_from_;
   gfx::Vector2d scale_to_;
   base::Optional<base::UnguessableToken> source_;

components/viz/service/display_embedder/skia_output_surface_dependency_impl.cc

@@ -112,13 +112,12 @@ base::ScopedClosureRunner SkiaOutputSurfaceDependencyImpl::CacheGLSurface(
       FROM_HERE,
       base::BindOnce(&gl::GLSurface::AddRef, base::Unretained(surface)));
   auto release_callback = base::BindOnce(
-      [](const scoped_refptr<base::TaskRunner>& runner,
+      [](const scoped_refptr<base::SequencedTaskRunner>& runner,
          gl::GLSurface* surface) {
         runner->PostTask(FROM_HERE, base::BindOnce(&gl::GLSurface::Release,
                                                    base::Unretained(surface)));
       },
-      base::WrapRefCounted(gpu_service_impl_->main_runner()),
-      base::Unretained(surface));
+      gpu_service_impl_->main_runner(), base::Unretained(surface));
   return base::ScopedClosureRunner(std::move(release_callback));
 }
 

components/viz/service/display_embedder/software_output_device_x11.cc

@@ -25,10 +25,10 @@ namespace viz {
 
 SoftwareOutputDeviceX11::SoftwareOutputDeviceX11(
     gfx::AcceleratedWidget widget,
-    base::TaskRunner* gpu_task_runner)
+    scoped_refptr<base::SequencedTaskRunner> gpu_task_runner)
     : x11_software_bitmap_presenter_(widget,
                                      task_runner_.get(),
-                                     gpu_task_runner) {
+                                     std::move(gpu_task_runner)) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 }
 

components/viz/service/display_embedder/software_output_device_x11.h

@@ -19,8 +19,9 @@ namespace viz {
 
 class VIZ_SERVICE_EXPORT SoftwareOutputDeviceX11 : public SoftwareOutputDevice {
  public:
-  SoftwareOutputDeviceX11(gfx::AcceleratedWidget widget,
-                          base::TaskRunner* gpu_task_runner);
+  SoftwareOutputDeviceX11(
+      gfx::AcceleratedWidget widget,
+      scoped_refptr<base::SequencedTaskRunner> gpu_task_runner);
 
   ~SoftwareOutputDeviceX11() override;
 

components/viz/service/gl/gpu_service_impl.h

@@ -244,7 +244,9 @@ class VIZ_SERVICE_EXPORT GpuServiceImpl : public gpu::GpuChannelManagerDelegate,
     return gpu_channel_manager_->sync_point_manager();
   }
 
-  base::TaskRunner* main_runner() { return main_runner_.get(); }
+  scoped_refptr<base::SingleThreadTaskRunner>& main_runner() {
+    return main_runner_;
+  }
 
   gpu::GpuWatchdogThread* watchdog_thread() { return watchdog_thread_.get(); }
 

content/browser/renderer_host/pepper/pepper_browser_font_singleton_host.cc

@@ -25,7 +25,7 @@ class FontMessageFilter : public ppapi::host::ResourceMessageFilter {
   FontMessageFilter();
 
   // ppapi::host::ResourceMessageFilter implementation.
-  scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
+  scoped_refptr<base::SequencedTaskRunner> OverrideTaskRunnerForMessage(
       const IPC::Message& msg) override;
   int32_t OnResourceMessageReceived(
       const IPC::Message& msg,
@@ -44,8 +44,8 @@ FontMessageFilter::FontMessageFilter() {}
 
 FontMessageFilter::~FontMessageFilter() {}
 
-scoped_refptr<base::TaskRunner> FontMessageFilter::OverrideTaskRunnerForMessage(
-    const IPC::Message& msg) {
+scoped_refptr<base::SequencedTaskRunner>
+FontMessageFilter::OverrideTaskRunnerForMessage(const IPC::Message& msg) {
   // Use the font list SequencedTaskRunner to get the font list (currently the
   // only message) since getting the font list is non-threadsafe on Linux (for
   // versions of Pango predating 2013).

content/browser/renderer_host/pepper/pepper_flash_file_message_filter.cc

@@ -70,7 +70,7 @@ base::FilePath PepperFlashFileMessageFilter::GetDataDirName(
   return profile_path.Append(kPepperDataDirname);
 }
 
-scoped_refptr<base::TaskRunner>
+scoped_refptr<base::SequencedTaskRunner>
 PepperFlashFileMessageFilter::OverrideTaskRunnerForMessage(
     const IPC::Message& msg) {
   // The blocking pool provides a pool of threads to run file
@@ -81,9 +81,9 @@ PepperFlashFileMessageFilter::OverrideTaskRunnerForMessage(
   // the plugin has multiple threads, it cannot make assumptions about
   // ordering of IPC message sends, so it cannot make assumptions
   // about ordering of operations caused by those IPC messages.
-  return scoped_refptr<base::TaskRunner>(base::CreateSequencedTaskRunner(
+  return base::CreateSequencedTaskRunner(
       {base::ThreadPool(), base::MayBlock(), base::TaskPriority::USER_VISIBLE,
-       base::TaskShutdownBehavior::BLOCK_SHUTDOWN}));
+       base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
 }
 
 int32_t PepperFlashFileMessageFilter::OnResourceMessageReceived(

content/browser/renderer_host/pepper/pepper_flash_file_message_filter.h

@@ -49,7 +49,7 @@ class PepperFlashFileMessageFilter : public ppapi::host::ResourceMessageFilter {
   ~PepperFlashFileMessageFilter() override;
 
   // ppapi::host::ResourceMessageFilter overrides.
-  scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
+  scoped_refptr<base::SequencedTaskRunner> OverrideTaskRunnerForMessage(
       const IPC::Message& msg) override;
   int32_t OnResourceMessageReceived(
       const IPC::Message& msg,

content/browser/renderer_host/pepper/pepper_host_resolver_message_filter.cc

@@ -99,7 +99,7 @@ PepperHostResolverMessageFilter::PepperHostResolverMessageFilter(
 
 PepperHostResolverMessageFilter::~PepperHostResolverMessageFilter() {}
 
-scoped_refptr<base::TaskRunner>
+scoped_refptr<base::SequencedTaskRunner>
 PepperHostResolverMessageFilter::OverrideTaskRunnerForMessage(
     const IPC::Message& message) {
   if (message.type() == PpapiHostMsg_HostResolver_Resolve::ID)

content/browser/renderer_host/pepper/pepper_host_resolver_message_filter.h

@@ -54,7 +54,7 @@ class CONTENT_EXPORT PepperHostResolverMessageFilter
   typedef std::vector<PP_NetAddress_Private> NetAddressList;
 
   // ppapi::host::ResourceMessageFilter overrides.
-  scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
+  scoped_refptr<base::SequencedTaskRunner> OverrideTaskRunnerForMessage(
       const IPC::Message& message) override;
   int32_t OnResourceMessageReceived(
       const IPC::Message& msg,

content/browser/renderer_host/pepper/pepper_tcp_server_socket_message_filter.cc

@@ -104,7 +104,7 @@ void PepperTCPServerSocketMessageFilter::OnFilterDestroyed() {
       base::BindOnce(&PepperTCPServerSocketMessageFilter::Close, this));
 }
 
-scoped_refptr<base::TaskRunner>
+scoped_refptr<base::SequencedTaskRunner>
 PepperTCPServerSocketMessageFilter::OverrideTaskRunnerForMessage(
     const IPC::Message& message) {
   switch (message.type()) {

content/browser/renderer_host/pepper/pepper_tcp_server_socket_message_filter.h

@@ -80,7 +80,7 @@ class CONTENT_EXPORT PepperTCPServerSocketMessageFilter
 
   // ppapi::host::ResourceMessageFilter overrides.
   void OnFilterDestroyed() override;
-  scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
+  scoped_refptr<base::SequencedTaskRunner> OverrideTaskRunnerForMessage(
       const IPC::Message& message) override;
   int32_t OnResourceMessageReceived(
       const IPC::Message& msg,

content/browser/renderer_host/pepper/pepper_tcp_socket_message_filter.cc

@@ -175,7 +175,7 @@ void PepperTCPSocketMessageFilter::OnFilterDestroyed() {
                  base::BindOnce(&PepperTCPSocketMessageFilter::Close, this));
 }
 
-scoped_refptr<base::TaskRunner>
+scoped_refptr<base::SequencedTaskRunner>
 PepperTCPSocketMessageFilter::OverrideTaskRunnerForMessage(
     const IPC::Message& message) {
   switch (message.type()) {

content/browser/renderer_host/pepper/pepper_tcp_socket_message_filter.h

@@ -108,7 +108,7 @@ class CONTENT_EXPORT PepperTCPSocketMessageFilter
 
   // ppapi::host::ResourceMessageFilter overrides.
   void OnFilterDestroyed() override;
-  scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
+  scoped_refptr<base::SequencedTaskRunner> OverrideTaskRunnerForMessage(
       const IPC::Message& message) override;
   int32_t OnResourceMessageReceived(
       const IPC::Message& msg,

content/browser/renderer_host/pepper/pepper_truetype_font_list_host.cc

@@ -28,7 +28,7 @@ class TrueTypeFontMessageFilter : public ppapi::host::ResourceMessageFilter {
   TrueTypeFontMessageFilter();
 
   // ppapi::host::ResourceMessageFilter implementation.
-  scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
+  scoped_refptr<base::SequencedTaskRunner> OverrideTaskRunnerForMessage(
       const IPC::Message& msg) override;
   int32_t OnResourceMessageReceived(
       const IPC::Message& msg,
@@ -49,7 +49,7 @@ TrueTypeFontMessageFilter::TrueTypeFontMessageFilter() {}
 
 TrueTypeFontMessageFilter::~TrueTypeFontMessageFilter() {}
 
-scoped_refptr<base::TaskRunner>
+scoped_refptr<base::SequencedTaskRunner>
 TrueTypeFontMessageFilter::OverrideTaskRunnerForMessage(
     const IPC::Message& msg) {
   // Use the font list SequencedTaskRunner to get the font list (currently the

content/browser/renderer_host/pepper/pepper_udp_socket_message_filter.cc

@@ -131,7 +131,7 @@ void PepperUDPSocketMessageFilter::OnFilterDestroyed() {
                  base::BindOnce(&PepperUDPSocketMessageFilter::Close, this));
 }
 
-scoped_refptr<base::TaskRunner>
+scoped_refptr<base::SequencedTaskRunner>
 PepperUDPSocketMessageFilter::OverrideTaskRunnerForMessage(
     const IPC::Message& message) {
   switch (message.type()) {

content/browser/renderer_host/pepper/pepper_udp_socket_message_filter.h

@@ -106,7 +106,7 @@ class CONTENT_EXPORT PepperUDPSocketMessageFilter
 
   // ppapi::host::ResourceMessageFilter overrides.
   void OnFilterDestroyed() override;
-  scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
+  scoped_refptr<base::SequencedTaskRunner> OverrideTaskRunnerForMessage(
       const IPC::Message& message) override;
   int32_t OnResourceMessageReceived(
       const IPC::Message& msg,

content/browser/renderer_host/pepper/pepper_vpn_provider_message_filter_chromeos.cc

@@ -89,7 +89,7 @@ PepperVpnProviderMessageFilter::~PepperVpnProviderMessageFilter() {
   }
 }
 
-scoped_refptr<base::TaskRunner>
+scoped_refptr<base::SequencedTaskRunner>
 PepperVpnProviderMessageFilter::OverrideTaskRunnerForMessage(
     const IPC::Message& message) {
   switch (message.type()) {

content/browser/renderer_host/pepper/pepper_vpn_provider_message_filter_chromeos.h

@@ -16,7 +16,6 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
-#include "base/task_runner.h"
 #include "content/browser/renderer_host/pepper/browser_ppapi_host_impl.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/vpn_service_proxy.h"
@@ -41,7 +40,7 @@ class CONTENT_EXPORT PepperVpnProviderMessageFilter
                                  PP_Instance instance);
 
   // ppapi::host::ResourceMessageFilter overrides.
-  scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
+  scoped_refptr<base::SequencedTaskRunner> OverrideTaskRunnerForMessage(
       const IPC::Message& message) override;
   int32_t OnResourceMessageReceived(
       const IPC::Message& msg,

content/browser/webrtc/webrtc_video_capture_service_browsertest.cc

@@ -510,7 +510,7 @@ class WebRtcVideoCaptureServiceBrowserTest : public ContentBrowserTest {
   }
 
   base::Thread virtual_device_thread_;
-  scoped_refptr<base::TaskRunner> main_task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> main_task_runner_;
 
  private:
   base::TimeDelta CalculateTimeSinceFirstInvocation() {

content/browser/webrtc/webrtc_video_capture_shared_device_browsertest.cc

@@ -131,7 +131,7 @@ class WebRtcVideoCaptureSharedDeviceBrowserTest
             subscriber_.InitWithNewPipeAndPassReceiver());
   }
 
-  scoped_refptr<base::TaskRunner> main_task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> main_task_runner_;
   std::unique_ptr<video_capture::MockVideoFrameHandler>
       mock_video_frame_handler_;
 

content/public/browser/content_browser_client.cc

@@ -11,6 +11,7 @@
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/no_destructor.h"
+#include "base/sequenced_task_runner.h"
 #include "build/build_config.h"
 #include "content/public/browser/authenticator_request_client_delegate.h"
 #include "content/public/browser/browser_accessibility_state.h"
@@ -56,7 +57,7 @@ std::unique_ptr<BrowserMainParts> ContentBrowserClient::CreateBrowserMainParts(
 
 void ContentBrowserClient::PostAfterStartupTask(
     const base::Location& from_here,
-    const scoped_refptr<base::TaskRunner>& task_runner,
+    const scoped_refptr<base::SequencedTaskRunner>& task_runner,
     base::OnceClosure task) {
   task_runner->PostTask(from_here, std::move(task));
 }

content/public/browser/content_browser_client.h

@@ -69,6 +69,7 @@ using LoginAuthRequiredCallback =
 namespace base {
 class CommandLine;
 class FilePath;
+class SequencedTaskRunner;
 }  // namespace base
 
 namespace blink {
@@ -231,7 +232,7 @@ class CONTENT_EXPORT ContentBrowserClient {
   // Note: see related BrowserThread::PostAfterStartupTask.
   virtual void PostAfterStartupTask(
       const base::Location& from_here,
-      const scoped_refptr<base::TaskRunner>& task_runner,
+      const scoped_refptr<base::SequencedTaskRunner>& task_runner,
       base::OnceClosure task);
 
   // Allows the embedder to indicate whether it considers startup to be

content/renderer/categorized_worker_pool.cc

@@ -80,7 +80,6 @@ class CategorizedWorkerPool::CategorizedWorkerPoolSequencedTaskRunner
                        base::TimeDelta delay) override {
     return PostNonNestableDelayedTask(from_here, std::move(task), delay);
   }
-  bool RunsTasksInCurrentSequence() const override { return true; }
 
   // Overridden from base::SequencedTaskRunner:
   bool PostNonNestableDelayedTask(const base::Location& from_here,
@@ -121,6 +120,8 @@ class CategorizedWorkerPool::CategorizedWorkerPoolSequencedTaskRunner
     return true;
   }
 
+  bool RunsTasksInCurrentSequence() const override { return true; }
+
  private:
   ~CategorizedWorkerPoolSequencedTaskRunner() override {
     {
@@ -257,10 +258,6 @@ bool CategorizedWorkerPool::PostDelayedTask(const base::Location& from_here,
   return true;
 }
 
-bool CategorizedWorkerPool::RunsTasksInCurrentSequence() const {
-  return true;
-}
-
 void CategorizedWorkerPool::Run(
     const std::vector<cc::TaskCategory>& categories,
     base::ConditionVariable* has_ready_to_run_tasks_cv) {

content/renderer/categorized_worker_pool.h

@@ -41,7 +41,6 @@ class CONTENT_EXPORT CategorizedWorkerPool : public base::TaskRunner,
   bool PostDelayedTask(const base::Location& from_here,
                        base::OnceClosure task,
                        base::TimeDelta delay) override;
-  bool RunsTasksInCurrentSequence() const override;
 
   // Overridden from cc::TaskGraphRunner:
   cc::NamespaceToken GenerateNamespaceToken() override;

content/renderer/worker/worker_thread_registry.cc

@@ -42,7 +42,7 @@ base::LazyInstance<ThreadLocalWorkerThreadData>::DestructorAtExit
     g_worker_data_tls = LAZY_INSTANCE_INITIALIZER;
 
 // A task-runner that refuses to run any tasks.
-class DoNothingTaskRunner : public base::TaskRunner {
+class DoNothingTaskRunner : public base::SequencedTaskRunner {
  public:
   DoNothingTaskRunner() {}
 
@@ -55,6 +55,12 @@ class DoNothingTaskRunner : public base::TaskRunner {
     return false;
   }
 
+  bool PostNonNestableDelayedTask(const base::Location& from_here,
+                                  base::OnceClosure task,
+                                  base::TimeDelta delay) override {
+    return false;
+  }
+
   bool RunsTasksInCurrentSequence() const override { return false; }
 };
 
@@ -131,7 +137,8 @@ void WorkerThreadRegistry::WillStopCurrentWorkerThread() {
   g_worker_data_tls.Pointer()->Set(nullptr);
 }
 
-base::TaskRunner* WorkerThreadRegistry::GetTaskRunnerFor(int worker_id) {
+base::SequencedTaskRunner* WorkerThreadRegistry::GetTaskRunnerFor(
+    int worker_id) {
   base::AutoLock locker(task_runner_map_lock_);
   return base::Contains(task_runner_map_, worker_id)
              ? task_runner_map_[worker_id]

content/renderer/worker/worker_thread_registry.h

@@ -15,7 +15,7 @@
 #include "content/public/renderer/worker_thread.h"
 
 namespace base {
-class TaskRunner;
+class SequencedTaskRunner;
 }
 
 namespace content {
@@ -33,7 +33,7 @@ class CONTENT_EXPORT WorkerThreadRegistry {
   // Always returns a non-null task runner regardless of whether the
   // corresponding worker thread is gone or not. If the thread is already gone
   // the tasks posted onto the task runner will be silently discarded.
-  base::TaskRunner* GetTaskRunnerFor(int worker_id);
+  base::SequencedTaskRunner* GetTaskRunnerFor(int worker_id);
 
  private:
   friend class WorkerThread;
@@ -49,9 +49,10 @@ class CONTENT_EXPORT WorkerThreadRegistry {
   // end up being handled as per usual in the main-thread, causing incorrect
   // results. |task_runner_for_dead_worker_| is used to handle such messages,
   // which silently discards all the tasks it receives.
-  scoped_refptr<base::TaskRunner> task_runner_for_dead_worker_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_for_dead_worker_;
 
-  std::map<int /* worker_thread_id */, base::TaskRunner*> task_runner_map_;
+  std::map<int /* worker_thread_id */, base::SequencedTaskRunner*>
+      task_runner_map_;
   base::Lock task_runner_map_lock_;
 };
 

dbus/bus.cc

@@ -842,14 +842,14 @@ void Bus::ProcessAllIncomingDataIfAny() {
   }
 }
 
-base::TaskRunner* Bus::GetDBusTaskRunner() {
+base::SequencedTaskRunner* Bus::GetDBusTaskRunner() {
   if (dbus_task_runner_)
     return dbus_task_runner_.get();
   else
     return GetOriginTaskRunner();
 }
 
-base::TaskRunner* Bus::GetOriginTaskRunner() {
+base::SequencedTaskRunner* Bus::GetOriginTaskRunner() {
   DCHECK(origin_task_runner_);
   return origin_task_runner_.get();
 }

dbus/bus.h

@@ -24,7 +24,6 @@
 
 namespace base {
 class SequencedTaskRunner;
-class TaskRunner;
 }
 
 namespace dbus {
@@ -38,7 +37,7 @@ class ObjectProxy;
 //
 // For asynchronous operations such as an asynchronous method call, the
 // bus object will use a task runner to monitor the underlying file
-// descriptor used for D-Bus communication. By default, the bus will use
+// descriptor used for D-Bus communication. By default, the bus will usegi
 // the current thread's task runner. If |dbus_task_runner| option is
 // specified, the bus will use that task runner instead.
 //
@@ -547,10 +546,10 @@ class CHROME_DBUS_EXPORT Bus : public base::RefCountedThreadSafe<Bus> {
   virtual void UnregisterObjectPath(const ObjectPath& object_path);
 
   // Returns the task runner of the D-Bus thread.
-  virtual base::TaskRunner* GetDBusTaskRunner();
+  virtual base::SequencedTaskRunner* GetDBusTaskRunner();
 
   // Returns the task runner of the thread that created the bus.
-  virtual base::TaskRunner* GetOriginTaskRunner();
+  virtual base::SequencedTaskRunner* GetOriginTaskRunner();
 
   // Returns true if the bus has the D-Bus thread.
   virtual bool HasDBusThread();

dbus/exported_object.cc

@@ -11,6 +11,7 @@
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/sequenced_task_runner.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"

dbus/mock_bus.h

@@ -68,8 +68,8 @@ class MockBus : public Bus {
                     void* user_data,
                     DBusError* error));
   MOCK_METHOD1(UnregisterObjectPath, void(const ObjectPath& object_path));
-  MOCK_METHOD0(GetDBusTaskRunner, base::TaskRunner*());
-  MOCK_METHOD0(GetOriginTaskRunner, base::TaskRunner*());
+  MOCK_METHOD0(GetDBusTaskRunner, base::SequencedTaskRunner*());
+  MOCK_METHOD0(GetOriginTaskRunner, base::SequencedTaskRunner*());
   MOCK_METHOD0(HasDBusThread, bool());
   MOCK_METHOD0(AssertOnOriginThread, void());
   MOCK_METHOD0(AssertOnDBusThread, void());

dbus/object_proxy.cc

@@ -14,7 +14,6 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
-#include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "base/threading/thread.h"
@@ -53,9 +52,10 @@ constexpr char kNameOwnerChangedMember[] = "NameOwnerChanged";
 }  // namespace
 
 ObjectProxy::ReplyCallbackHolder::ReplyCallbackHolder(
-    scoped_refptr<base::TaskRunner> origin_task_runner,
+    scoped_refptr<base::SequencedTaskRunner> origin_task_runner,
     ResponseOrErrorCallback callback)
-    : origin_task_runner_(origin_task_runner), callback_(std::move(callback)) {
+    : origin_task_runner_(std::move(origin_task_runner)),
+      callback_(std::move(callback)) {
   DCHECK(origin_task_runner_.get());
   DCHECK(!callback_.is_null());
 }

dbus/object_proxy.h

@@ -16,15 +16,12 @@
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/sequenced_task_runner.h"
 #include "base/strings/string_piece.h"
 #include "base/time/time.h"
 #include "dbus/dbus_export.h"
 #include "dbus/object_path.h"
 
-namespace base {
-class TaskRunner;
-}  // namespace base
-
 namespace dbus {
 
 class Bus;
@@ -225,8 +222,9 @@ class CHROME_DBUS_EXPORT ObjectProxy
    public:
     // Designed to be created on the origin thread.
     // Both |origin_task_runner| and |callback| must not be null.
-    ReplyCallbackHolder(scoped_refptr<base::TaskRunner> origin_task_runner,
-                        ResponseOrErrorCallback callback);
+    ReplyCallbackHolder(
+        scoped_refptr<base::SequencedTaskRunner> origin_task_runner,
+        ResponseOrErrorCallback callback);
 
     // This is movable to be bound to an OnceCallback.
     ReplyCallbackHolder(ReplyCallbackHolder&& other);
@@ -241,7 +239,7 @@ class CHROME_DBUS_EXPORT ObjectProxy
     ResponseOrErrorCallback ReleaseCallback();
 
    private:
-    scoped_refptr<base::TaskRunner> origin_task_runner_;
+    scoped_refptr<base::SequencedTaskRunner> origin_task_runner_;
     ResponseOrErrorCallback callback_;
     DISALLOW_COPY_AND_ASSIGN(ReplyCallbackHolder);
   };

media/capture/video/chromeos/video_capture_device_chromeos_halv3.cc

@@ -95,7 +95,7 @@ class VideoCaptureDeviceChromeOSHalv3::PowerManagerClientProxy
 
   base::WeakPtr<VideoCaptureDeviceChromeOSHalv3> device_;
   scoped_refptr<base::SingleThreadTaskRunner> device_task_runner_;
-  scoped_refptr<base::TaskRunner> dbus_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> dbus_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerManagerClientProxy);
 };

mojo/core/channel.h

@@ -11,7 +11,7 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/process/process_handle.h"
-#include "base/task_runner.h"
+#include "base/single_thread_task_runner.h"
 #include "build/build_config.h"
 #include "mojo/core/connection_params.h"
 #include "mojo/core/platform_handle_in_transit.h"
@@ -273,7 +273,7 @@ class MOJO_SYSTEM_IMPL_EXPORT Channel
       Delegate* delegate,
       ConnectionParams connection_params,
       HandlePolicy handle_policy,
-      scoped_refptr<base::TaskRunner> io_task_runner);
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner);
 
   // Allows the caller to change the Channel's HandlePolicy after construction.
   void set_handle_policy(HandlePolicy policy) { handle_policy_ = policy; }

mojo/core/channel_fuchsia.cc

@@ -159,7 +159,7 @@ class ChannelFuchsia : public Channel,
   ChannelFuchsia(Delegate* delegate,
                  ConnectionParams connection_params,
                  HandlePolicy handle_policy,
-                 scoped_refptr<base::TaskRunner> io_task_runner)
+                 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
       : Channel(delegate, handle_policy),
         self_(this),
         handle_(
@@ -397,7 +397,7 @@ class ChannelFuchsia : public Channel,
   scoped_refptr<Channel> self_;
 
   zx::channel handle_;
-  scoped_refptr<base::TaskRunner> io_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // These members are only used on the IO thread.
   std::unique_ptr<base::MessagePumpForIO::ZxHandleWatchController> read_watch_;
@@ -417,7 +417,7 @@ scoped_refptr<Channel> Channel::Create(
     Delegate* delegate,
     ConnectionParams connection_params,
     HandlePolicy handle_policy,
-    scoped_refptr<base::TaskRunner> io_task_runner) {
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) {
   return new ChannelFuchsia(delegate, std::move(connection_params),
                             handle_policy, std::move(io_task_runner));
 }

mojo/core/channel_mac.cc

@@ -47,7 +47,7 @@ class ChannelMac : public Channel,
   ChannelMac(Delegate* delegate,
              ConnectionParams connection_params,
              HandlePolicy handle_policy,
-             scoped_refptr<base::TaskRunner> io_task_runner)
+             scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
       : Channel(delegate, handle_policy, DispatchBufferPolicy::kUnmanaged),
         self_(this),
         io_task_runner_(io_task_runner),
@@ -654,7 +654,7 @@ class ChannelMac : public Channel,
   // Keeps the Channel alive at least until explicit shutdown on the IO thread.
   scoped_refptr<ChannelMac> self_;
 
-  scoped_refptr<base::TaskRunner> io_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   base::mac::ScopedMachReceiveRight receive_port_;
   base::mac::ScopedMachSendRight send_port_;
@@ -709,7 +709,7 @@ scoped_refptr<Channel> Channel::Create(
     Channel::Delegate* delegate,
     ConnectionParams connection_params,
     Channel::HandlePolicy handle_policy,
-    scoped_refptr<base::TaskRunner> io_task_runner) {
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) {
   return new ChannelMac(delegate, std::move(connection_params), handle_policy,
                         io_task_runner);
 }

mojo/core/channel_posix.cc

@@ -98,7 +98,7 @@ class ChannelPosix : public Channel,
   ChannelPosix(Delegate* delegate,
                ConnectionParams connection_params,
                HandlePolicy handle_policy,
-               scoped_refptr<base::TaskRunner> io_task_runner)
+               scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
       : Channel(delegate, handle_policy),
         self_(this),
         io_task_runner_(io_task_runner) {
@@ -552,7 +552,7 @@ class ChannelPosix : public Channel,
   // or accepted over |server_|.
   base::ScopedFD socket_;
 
-  scoped_refptr<base::TaskRunner> io_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // These watchers must only be accessed on the IO thread.
   std::unique_ptr<base::MessagePumpForIO::FdWatchController> read_watcher_;
@@ -583,7 +583,7 @@ scoped_refptr<Channel> Channel::Create(
     Delegate* delegate,
     ConnectionParams connection_params,
     HandlePolicy handle_policy,
-    scoped_refptr<base::TaskRunner> io_task_runner) {
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) {
   return new ChannelPosix(delegate, std::move(connection_params), handle_policy,
                           io_task_runner);
 }

mojo/core/channel_unittest.cc

@@ -196,7 +196,7 @@ class ChannelTestShutdownAndWriteDelegate : public Channel::Delegate {
  public:
   ChannelTestShutdownAndWriteDelegate(
       PlatformChannelEndpoint endpoint,
-      scoped_refptr<base::TaskRunner> task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       scoped_refptr<Channel> client_channel,
       std::unique_ptr<base::Thread> client_thread,
       base::RepeatingClosure quit_closure)