task posting v3: Remove task runner handles from codebase entirely

As the last CL of the task runner handle refactor, this CL removes
Single and Thread task runner handles from the codebase entirely. The
new API for this functionality can be found under
(SingleThread|Sequenced)TaskRunner::CurrentDefaultHandle,
::GetCurrentDefault(), ::HasCurrentDefault(), and
::CurrentHandleOverride(ForTesting).

Bug: 1026641
Change-Id: Iac1e15ad215e1806b5c787939de0abdacd1da713
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4150928
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Gabriel Charette <gab@chromium.org>
Reviewed-by: Ian Kilpatrick <ikilpatrick@chromium.org>
Commit-Queue: Gabriel Charette <gab@chromium.org>
Owners-Override: Gabriel Charette <gab@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1091839}

base/BUILD.gn

@@ -906,8 +906,6 @@ component("base") {
     "threading/sequence_local_storage_map.h",
     "threading/sequence_local_storage_slot.cc",
     "threading/sequence_local_storage_slot.h",
-    "threading/sequenced_task_runner_handle.cc",
-    "threading/sequenced_task_runner_handle.h",
     "threading/simple_thread.cc",
     "threading/simple_thread.h",
     "threading/thread.cc",
@@ -926,8 +924,6 @@ component("base") {
     "threading/thread_local_storage.h",
     "threading/thread_restrictions.cc",
     "threading/thread_restrictions.h",
-    "threading/thread_task_runner_handle.cc",
-    "threading/thread_task_runner_handle.h",
     "threading/threading_features.h",
     "threading/watchdog.cc",
     "threading/watchdog.h",
@@ -3406,7 +3402,6 @@ test("base_unittests") {
     "threading/sequence_bound_unittest.cc",
     "threading/sequence_local_storage_map_unittest.cc",
     "threading/sequence_local_storage_slot_unittest.cc",
-    "threading/sequenced_task_runner_handle_unittest.cc",
     "threading/simple_thread_unittest.cc",
     "threading/thread_checker_unittest.cc",
     "threading/thread_collision_warner_unittest.cc",
@@ -3414,7 +3409,6 @@ test("base_unittests") {
     "threading/thread_local_storage_unittest.cc",
     "threading/thread_local_unittest.cc",
     "threading/thread_restrictions_unittest.cc",
-    "threading/thread_task_runner_handle_unittest.cc",
     "threading/thread_unittest.cc",
     "threading/watchdog_unittest.cc",
     "time/pr_time_unittest.cc",

base/task/deferred_sequenced_task_runner_unittest.cc

@@ -13,7 +13,6 @@
 #include "base/task/single_thread_task_runner.h"
 #include "base/test/task_environment.h"
 #include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 

base/task/single_thread_task_runner.cc

@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 
 #include "base/task/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
 
 #include <memory>
 #include <utility>
@@ -15,7 +14,6 @@
 #include "base/lazy_instance.h"
 #include "base/no_destructor.h"
 #include "base/run_loop.h"
-#include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_local.h"
 
 namespace base {

base/task/single_thread_task_runner.h

@@ -107,10 +107,6 @@ class BASE_EXPORT SingleThreadTaskRunner : public SequencedTaskRunner {
     FRIEND_TEST_ALL_PREFIXES(SingleThreadTaskRunnerCurrentDefaultHandleTest,
                              NestedRunLoop);
 
-    // This is in order for ThreadTaskRunnerHandleOverride to call this private
-    // constructor during migration.
-    friend class ThreadTaskRunnerHandleOverride;
-
     // We expect SingleThreadTaskRunner::CurrentHandleOverride to be only needed
     // under special circumstances. Require them to be enumerated as friends to
     // require //base/OWNERS review. Use

base/task/thread_pool/task_tracker.cc

@@ -469,21 +469,21 @@ void TaskTracker::RunTask(Task task,
     // Set up TaskRunner CurrentDefaultHandle as expected for the scope of the
     // task.
     absl::optional<SequencedTaskRunner::CurrentDefaultHandle>
-        sequenced_task_runner_handle;
+        sequenced_task_runner_current_default_handle;
     absl::optional<SingleThreadTaskRunner::CurrentDefaultHandle>
-        single_thread_task_runner_handle;
+        single_thread_task_runner_current_default_handle;
     switch (task_source->execution_mode()) {
       case TaskSourceExecutionMode::kJob:
       case TaskSourceExecutionMode::kParallel:
         break;
       case TaskSourceExecutionMode::kSequenced:
         DCHECK(task_source->task_runner());
-        sequenced_task_runner_handle.emplace(
+        sequenced_task_runner_current_default_handle.emplace(
             static_cast<SequencedTaskRunner*>(task_source->task_runner()));
         break;
       case TaskSourceExecutionMode::kSingleThread:
         DCHECK(task_source->task_runner());
-        single_thread_task_runner_handle.emplace(
+        single_thread_task_runner_current_default_handle.emplace(
             static_cast<SingleThreadTaskRunner*>(task_source->task_runner()));
         break;
     }

base/task/thread_pool/task_tracker_unittest.cc

@@ -545,8 +545,8 @@ static void RunTaskRunnerCurrentDefaultHandleVerificationTask(
   // Pretend |verify_task| is posted to respect TaskTracker's contract.
   EXPECT_TRUE(tracker->WillPostTask(&verify_task, traits.shutdown_behavior()));
 
-  // Confirm that the test conditions are right (no TaskRunnerHandles set
-  // already).
+  // Confirm that the test conditions are right (no
+  // task runner CurrentDefaultHandles set already).
   EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
   EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
 
@@ -555,12 +555,12 @@ static void RunTaskRunnerCurrentDefaultHandleVerificationTask(
       test::CreateSequenceWithTask(std::move(verify_task), traits,
                                    std::move(task_runner), execution_mode));
 
-  // TaskRunnerHandle state is reset outside of task's scope.
+  // task runner CurrentDefaultHandle state is reset outside of task's scope.
   EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
   EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
 }
 
-static void VerifyNoTaskRunnerHandle() {
+static void VerifyNoTaskRunnerCurrentDefaultHandle() {
   EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
   EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
 }
@@ -568,7 +568,7 @@ static void VerifyNoTaskRunnerHandle() {
 TEST_P(ThreadPoolTaskTrackerTest, TaskRunnerHandleIsNotSetOnParallel) {
   // Create a task that will verify that TaskRunnerHandles are not set in its
   // scope per no TaskRunner ref being set to it.
-  Task verify_task(FROM_HERE, BindOnce(&VerifyNoTaskRunnerHandle),
+  Task verify_task(FROM_HERE, BindOnce(&VerifyNoTaskRunnerCurrentDefaultHandle),
                    TimeTicks::Now(), TimeDelta());
 
   RunTaskRunnerCurrentDefaultHandleVerificationTask(

base/task/thread_pool/test_task_factory.cc

@@ -59,7 +59,8 @@ void TestTaskFactory::RunTaskCallback(size_t task_index,
                     ->RunsTasksInCurrentSequence());
   }
 
-  // Verify TaskRunnerHandles are set as expected in the task's scope.
+  // Verify task runner CurrentDefaultHandles are set as expected in the task's
+  // scope.
   switch (execution_mode_) {
     case TaskSourceExecutionMode::kJob:
     case TaskSourceExecutionMode::kParallel:

base/task/thread_pool/test_task_factory.h

@@ -27,8 +27,8 @@ namespace test {
 // - 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 task runner CurrentDefaultHandles 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
 //   kSingleThread and Tasks don't run in posting order.
 // - The TaskSourceExecutionMode of the TaskRunner is kSingleThread and Tasks

base/threading/sequence_bound.h

@@ -52,9 +52,9 @@ namespace base {
 //     }
 //   };
 //
-//   // SequenceBound itself is owned on `SequencedTaskRunnerHandle::Get()`.
-//   // The managed Database instance managed by it is constructed and owned on
-//   // `GetDBTaskRunner()`.
+//   // SequenceBound itself is owned on
+//   // `SequencedTaskRunner::GetCurrentDefault()`. The managed Database
+//   // instance managed by it is constructed and owned on `GetDBTaskRunner()`.
 //   base::SequenceBound<Database> db(GetDBTaskRunner());
 //
 //   // `Database::Query()` runs on `GetDBTaskRunner()`, but

base/threading/sequenced_task_runner_handle.cc

@@ -1,21 +0,0 @@
-// Copyright 2015 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/threading/sequenced_task_runner_handle.h"
-
-namespace base {
-
-// DEPRECATED: Use SequencedTaskRunner::GetCurrentDefault instead
-// static
-const scoped_refptr<SequencedTaskRunner>& SequencedTaskRunnerHandle::Get() {
-  return SequencedTaskRunner::GetCurrentDefault();
-}
-
-// DEPRECATED: Use SequencedTaskRunner::HasCurrentDefault instead
-// static
-bool SequencedTaskRunnerHandle::IsSet() {
-  return SequencedTaskRunner::HasCurrentDefault();
-}
-
-}  // namespace base

base/threading/sequenced_task_runner_handle.h

@@ -1,49 +0,0 @@
-// Copyright 2015 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_THREADING_SEQUENCED_TASK_RUNNER_HANDLE_H_
-#define BASE_THREADING_SEQUENCED_TASK_RUNNER_HANDLE_H_
-
-#include "base/base_export.h"
-#include "base/memory/scoped_refptr.h"
-#include "base/task/sequenced_task_runner.h"
-
-namespace base {
-
-class ThreadTaskRunnerHandle;
-
-class BASE_EXPORT SequencedTaskRunnerHandle {
- public:
-  // DEPRECATED: Use SequencedTaskRunner::GetCurrentDefault() instead.
-  // Returns a SequencedTaskRunner which guarantees that posted tasks will only
-  // run after the current task is finished and will satisfy a SequenceChecker.
-  // It should only be called if IsSet() returns true (see the comment there for
-  // the requirements).
-  [[nodiscard]] static const scoped_refptr<SequencedTaskRunner>& Get();
-
-  // DEPRECATED: Use SequencedTaskRunner::HasCurrentDefault() instead.
-  // Returns true if one of the following conditions is fulfilled:
-  // a) A SequencedTaskRunner has been assigned to the current thread by
-  //    instantiating a SequencedTaskRunnerHandle.
-  // b) The current thread has a ThreadTaskRunnerHandle (which includes any
-  //    thread that has a MessageLoop associated with it).
-  [[nodiscard]] static bool IsSet();
-
-  explicit SequencedTaskRunnerHandle(
-      scoped_refptr<SequencedTaskRunner> task_runner)
-      : contained_current_default_(std::move(task_runner)) {}
-
-  SequencedTaskRunnerHandle(const SequencedTaskRunnerHandle&) = delete;
-  SequencedTaskRunnerHandle& operator=(const SequencedTaskRunnerHandle&) =
-      delete;
-
-  ~SequencedTaskRunnerHandle() = default;
-
- private:
-  SequencedTaskRunner::CurrentDefaultHandle contained_current_default_;
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_SEQUENCED_TASK_RUNNER_HANDLE_H_

base/threading/sequenced_task_runner_handle_unittest.cc

@@ -1,89 +0,0 @@
-// Copyright 2015 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/threading/sequenced_task_runner_handle.h"
-
-#include <memory>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/location.h"
-#include "base/memory/ref_counted.h"
-#include "base/run_loop.h"
-#include "base/sequence_checker_impl.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task/sequenced_task_runner.h"
-#include "base/task/thread_pool.h"
-#include "base/test/task_environment.h"
-#include "base/test/test_simple_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-class SequencedTaskRunnerHandleTest : public ::testing::Test {
- protected:
-  // Verifies that the context it runs on has a SequencedTaskRunnerHandle
-  // and that posting to it results in the posted task running in that same
-  // context (sequence).
-  static void VerifyCurrentSequencedTaskRunner() {
-    ASSERT_TRUE(SequencedTaskRunnerHandle::IsSet());
-    scoped_refptr<SequencedTaskRunner> task_runner =
-        SequencedTaskRunnerHandle::Get();
-    ASSERT_TRUE(task_runner);
-
-    // Use SequenceCheckerImpl to make sure it's not a no-op in Release builds.
-    std::unique_ptr<SequenceCheckerImpl> sequence_checker(
-        new SequenceCheckerImpl);
-    task_runner->PostTask(
-        FROM_HERE,
-        base::BindOnce(&SequencedTaskRunnerHandleTest::CheckValidSequence,
-                       std::move(sequence_checker)));
-  }
-
-  static void CheckValidSequence(
-      std::unique_ptr<SequenceCheckerImpl> sequence_checker) {
-    EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
-  }
-
-  base::test::TaskEnvironment task_environment_;
-};
-
-TEST_F(SequencedTaskRunnerHandleTest, FromTaskEnvironment) {
-  VerifyCurrentSequencedTaskRunner();
-  RunLoop().RunUntilIdle();
-}
-
-TEST_F(SequencedTaskRunnerHandleTest, FromThreadPoolSequencedTask) {
-  base::ThreadPool::CreateSequencedTaskRunner({})->PostTask(
-      FROM_HERE,
-      base::BindOnce(
-          &SequencedTaskRunnerHandleTest::VerifyCurrentSequencedTaskRunner));
-  task_environment_.RunUntilIdle();
-}
-
-TEST_F(SequencedTaskRunnerHandleTest, NoHandleFromUnsequencedTask) {
-  base::ThreadPool::PostTask(base::BindOnce(
-      []() { EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet()); }));
-  task_environment_.RunUntilIdle();
-}
-
-TEST(SequencedTaskRunnerHandleTestWithoutTaskEnvironment, FromHandleInScope) {
-  scoped_refptr<SequencedTaskRunner> test_task_runner(new TestSimpleTaskRunner);
-  EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
-  EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
-  {
-    SequencedTaskRunnerHandle handle(test_task_runner);
-    EXPECT_TRUE(SequencedTaskRunnerHandle::IsSet());
-    EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
-    EXPECT_EQ(test_task_runner, SequencedTaskRunnerHandle::Get());
-  }
-  EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
-  EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
-}
-
-}  // namespace
-}  // namespace base

base/threading/thread.cc

@@ -376,7 +376,7 @@ void Thread::ThreadMain() {
 
   // Lazily initialize the |message_loop| so that it can run on this thread.
   DCHECK(delegate_);
-  // This binds CurrentThread and ThreadTaskRunnerHandle.
+  // This binds CurrentThread and SingleThreadTaskRunner::CurrentDefaultHandle.
   delegate_->BindToCurrentThread(timer_slack_);
   DCHECK(CurrentThread::Get());
   DCHECK(SingleThreadTaskRunner::HasCurrentDefault());

base/threading/thread.h

@@ -64,9 +64,9 @@ class BASE_EXPORT Thread : PlatformThread::Delegate {
 
     virtual scoped_refptr<SingleThreadTaskRunner> GetDefaultTaskRunner() = 0;
 
-    // Binds a RunLoop::Delegate and TaskRunnerHandle to the thread. The
-    // underlying MessagePump will have its |timer_slack| set to the specified
-    // amount.
+    // Binds a RunLoop::Delegate and task runner CurrentDefaultHandle to the
+    // thread. The underlying MessagePump will have its |timer_slack| set to the
+    // specified amount.
     virtual void BindToCurrentThread(TimerSlack timer_slack) = 0;
   };
 

base/threading/thread_checker_impl.cc

@@ -86,8 +86,9 @@ bool ThreadCheckerImpl::CalledOnValidThread(
 
     // If this ThreadCheckerImpl is bound to a valid SequenceToken, it must be
     // equal to the current SequenceToken and there must be a registered
-    // ThreadTaskRunnerHandle. Otherwise, the fact that the current task runs on
-    // the thread to which this ThreadCheckerImpl is bound is fortuitous.
+    // SingleThreadTaskRunner::CurrentDefaultHandle. Otherwise, the fact that
+    // the current task runs on the thread to which this ThreadCheckerImpl is
+    // bound is fortuitous.
     if (sequence_token_.IsValid() &&
         (sequence_token_ != SequenceToken::GetForCurrentThread() ||
          !SingleThreadTaskRunner::HasCurrentDefault())) {

base/threading/thread_task_runner_handle.cc

@@ -1,21 +0,0 @@
-// Copyright 2016 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/threading/thread_task_runner_handle.h"
-
-namespace base {
-
-// DEPRECATED: Use SequencedTaskRunner::GetCurrentDefault instead
-// static
-const scoped_refptr<SingleThreadTaskRunner>& ThreadTaskRunnerHandle::Get() {
-  return SingleThreadTaskRunner::GetCurrentDefault();
-}
-
-// DEPRECATED: Use SequencedTaskRunner::HasCurrentDefault instead
-// static
-bool ThreadTaskRunnerHandle::IsSet() {
-  return SingleThreadTaskRunner::HasCurrentDefault();
-}
-
-}  // namespace base

base/threading/thread_task_runner_handle.h

@@ -1,116 +0,0 @@
-// Copyright 2016 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_THREADING_THREAD_TASK_RUNNER_HANDLE_H_
-#define BASE_THREADING_THREAD_TASK_RUNNER_HANDLE_H_
-
-#include "base/base_export.h"
-#include "base/dcheck_is_on.h"
-#include "base/gtest_prod_util.h"
-#include "base/memory/scoped_refptr.h"
-#include "base/task/single_thread_task_runner.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-#include "third_party/abseil-cpp/absl/types/optional.h"
-
-namespace base {
-
-// ThreadTaskRunnerHandle stores a reference to a thread's TaskRunner
-// in thread-local storage.  Callers can then retrieve the TaskRunner
-// for the current thread by calling ThreadTaskRunnerHandle::Get().
-// At most one TaskRunner may be bound to each thread at a time.
-// Prefer SequencedTaskRunnerHandle to this unless thread affinity is required.
-class BASE_EXPORT ThreadTaskRunnerHandle {
- public:
-  // DEPRECATED: use SingleThreadTaskRunner::GetCurrentDefault instead
-  // Gets the SingleThreadTaskRunner for the current thread.
-  [[nodiscard]] static const scoped_refptr<SingleThreadTaskRunner>& Get();
-
-  // DEPRECATED: Use SingleThreadTaskRunner::HasCurrentDefault
-  // Returns true if the SingleThreadTaskRunner is already created for
-  // the current thread.
-  [[nodiscard]] static bool IsSet();
-
-  // Binds |task_runner| to the current thread. |task_runner| must belong
-  // to the current thread for this to succeed.
-  explicit ThreadTaskRunnerHandle(
-      scoped_refptr<SingleThreadTaskRunner> task_runner)
-      : contained_current_default_(std::move(task_runner)) {}
-
-  ThreadTaskRunnerHandle(const ThreadTaskRunnerHandle&) = delete;
-  ThreadTaskRunnerHandle& operator=(const ThreadTaskRunnerHandle&) = delete;
-
-  ~ThreadTaskRunnerHandle() = default;
-
- private:
-  SingleThreadTaskRunner::CurrentDefaultHandle contained_current_default_;
-};
-
-// DEPRECATED: Use SingleThreadTaskRunner::CurrentHandleOverride instead.
-//
-// ThreadTaskRunnerHandleOverride overrides the task runner returned by
-// |ThreadTaskRunnerHandle::Get()| to point at |overriding_task_runner| until
-// the |ThreadTaskRunnerHandleOverride| goes out of scope.
-// ThreadTaskRunnerHandleOverride instantiates a new ThreadTaskRunnerHandle if
-// ThreadTaskRunnerHandle is not instantiated on the current thread. Nested
-// overrides are allowed but callers must ensure the
-// |ThreadTaskRunnerHandleOverride| expire in LIFO (stack) order.
-//
-// Note: nesting ThreadTaskRunnerHandle is subtle and should be done with care,
-// hence the need to friend and request a //base/OWNERS review for usage outside
-// of tests. Use ThreadTaskRunnerHandleOverrideForTesting to bypass the friend
-// requirement in tests.
-class BASE_EXPORT ThreadTaskRunnerHandleOverride {
- public:
-  ThreadTaskRunnerHandleOverride(const ThreadTaskRunnerHandleOverride&) =
-      delete;
-  ThreadTaskRunnerHandleOverride& operator=(
-      const ThreadTaskRunnerHandleOverride&) = delete;
-  ~ThreadTaskRunnerHandleOverride() = default;
-
- private:
-  friend class ThreadTaskRunnerHandleOverrideForTesting;
-  FRIEND_TEST_ALL_PREFIXES(ThreadTaskRunnerHandleTest, NestedRunLoop);
-
-  // We expect ThreadTaskRunnerHandleOverride to be only needed under special
-  // circumstances. Require them to be enumerated as friends to require
-  // //base/OWNERS review. Use ThreadTaskRunnerHandleOverrideForTesting
-  // in unit tests to avoid the friend requirement.
-
-  friend class blink::scheduler::MainThreadSchedulerImpl;
-
-  // Constructs a ThreadTaskRunnerHandleOverride which will make
-  // ThreadTaskRunnerHandle::Get() return |overriding_task_runner| for its
-  // lifetime. |allow_nested_loop| specifies whether RunLoop::Run() is allowed
-  // during this override's lifetime. It's not recommended to allow this unless
-  // the current thread's scheduler guarantees that only tasks which pertain to
-  // |overriding_task_runner|'s context will be run by nested RunLoops.
-  explicit ThreadTaskRunnerHandleOverride(
-      scoped_refptr<SingleThreadTaskRunner> overriding_task_runner,
-      bool allow_nested_runloop = false)
-      : contained_override_(std::move(overriding_task_runner),
-                            allow_nested_runloop) {}
-
-  SingleThreadTaskRunner::CurrentHandleOverride contained_override_;
-};
-
-// Note: nesting ThreadTaskRunnerHandles isn't generally desired but it's useful
-// in some unit tests where multiple task runners share the main thread for
-// simplicity and determinism. Only use this when no other constructs will work
-// (see base/test/task_environment.h and base/test/test_mock_time_task_runner.h
-// for preferred alternatives).
-class ThreadTaskRunnerHandleOverrideForTesting {
- public:
-  explicit ThreadTaskRunnerHandleOverrideForTesting(
-      scoped_refptr<SingleThreadTaskRunner> overriding_task_runner)
-      : contained_override_(std::move(overriding_task_runner)) {}
-
-  ~ThreadTaskRunnerHandleOverrideForTesting() = default;
-
- private:
-  SingleThreadTaskRunner::CurrentHandleOverrideForTesting contained_override_;
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_THREAD_TASK_RUNNER_HANDLE_H_

base/threading/thread_task_runner_handle_unittest.cc

@@ -1,141 +0,0 @@
-// Copyright 2017 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/threading/thread_task_runner_handle.h"
-
-#include "base/memory/ref_counted.h"
-#include "base/run_loop.h"
-#include "base/test/gtest_util.h"
-#include "base/test/task_environment.h"
-#include "base/test/test_simple_task_runner.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(ThreadTaskRunnerHandleTest, Basic) {
-  scoped_refptr<SingleThreadTaskRunner> task_runner(new TestSimpleTaskRunner);
-
-  EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
-  {
-    ThreadTaskRunnerHandle ttrh1(task_runner);
-    EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-    EXPECT_EQ(task_runner, ThreadTaskRunnerHandle::Get());
-  }
-  EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
-}
-
-TEST(ThreadTaskRunnerHandleTest, DeathOnImplicitOverride) {
-  scoped_refptr<SingleThreadTaskRunner> task_runner(new TestSimpleTaskRunner);
-  scoped_refptr<SingleThreadTaskRunner> overidding_task_runner(
-      new TestSimpleTaskRunner);
-
-  ThreadTaskRunnerHandle ttrh(task_runner);
-  EXPECT_DCHECK_DEATH(
-      { ThreadTaskRunnerHandle overriding_ttrh(overidding_task_runner); });
-}
-
-TEST(ThreadTaskRunnerHandleTest, OverrideExistingTTRH) {
-  scoped_refptr<SingleThreadTaskRunner> task_runner_1(new TestSimpleTaskRunner);
-  scoped_refptr<SingleThreadTaskRunner> task_runner_2(new TestSimpleTaskRunner);
-  scoped_refptr<SingleThreadTaskRunner> task_runner_3(new TestSimpleTaskRunner);
-  scoped_refptr<SingleThreadTaskRunner> task_runner_4(new TestSimpleTaskRunner);
-
-  EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
-  {
-    // TTRH in place prior to override.
-    ThreadTaskRunnerHandle ttrh1(task_runner_1);
-    EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-    EXPECT_EQ(task_runner_1, ThreadTaskRunnerHandle::Get());
-
-    {
-      // Override.
-      ThreadTaskRunnerHandleOverrideForTesting ttrh_override_2(task_runner_2);
-      EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-      EXPECT_EQ(task_runner_2, ThreadTaskRunnerHandle::Get());
-
-      {
-        // Nested override.
-        ThreadTaskRunnerHandleOverrideForTesting ttrh_override_3(task_runner_3);
-        EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-        EXPECT_EQ(task_runner_3, ThreadTaskRunnerHandle::Get());
-      }
-
-      // Back to single override.
-      EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-      EXPECT_EQ(task_runner_2, ThreadTaskRunnerHandle::Get());
-
-      {
-        // Backup to double override with another TTRH.
-        ThreadTaskRunnerHandleOverrideForTesting ttrh_override_4(task_runner_4);
-        EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-        EXPECT_EQ(task_runner_4, ThreadTaskRunnerHandle::Get());
-      }
-    }
-
-    // Back to simple TTRH.
-    EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-    EXPECT_EQ(task_runner_1, ThreadTaskRunnerHandle::Get());
-  }
-  EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
-}
-
-TEST(ThreadTaskRunnerHandleTest, OverrideNoExistingTTRH) {
-  scoped_refptr<SingleThreadTaskRunner> task_runner_1(new TestSimpleTaskRunner);
-  scoped_refptr<SingleThreadTaskRunner> task_runner_2(new TestSimpleTaskRunner);
-
-  EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
-  {
-    // Override with no TTRH in place.
-    ThreadTaskRunnerHandleOverrideForTesting ttrh_override_1(task_runner_1);
-    EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-    EXPECT_EQ(task_runner_1, ThreadTaskRunnerHandle::Get());
-
-    {
-      // Nested override works the same.
-      ThreadTaskRunnerHandleOverrideForTesting ttrh_override_2(task_runner_2);
-      EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-      EXPECT_EQ(task_runner_2, ThreadTaskRunnerHandle::Get());
-    }
-
-    // Back to single override.
-    EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-    EXPECT_EQ(task_runner_1, ThreadTaskRunnerHandle::Get());
-  }
-  EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
-}
-
-TEST(ThreadTaskRunnerHandleTest, DeathOnTTRHOverOverride) {
-  scoped_refptr<SingleThreadTaskRunner> task_runner(new TestSimpleTaskRunner);
-  scoped_refptr<SingleThreadTaskRunner> overidding_task_runner(
-      new TestSimpleTaskRunner);
-
-  ThreadTaskRunnerHandleOverrideForTesting ttrh_override(task_runner);
-  EXPECT_DCHECK_DEATH(
-      { ThreadTaskRunnerHandle overriding_ttrh(overidding_task_runner); });
-}
-
-TEST(ThreadTaskRunnerHandleTest, NestedRunLoop) {
-  test::SingleThreadTaskEnvironment task_environment;
-  EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-  scoped_refptr<SingleThreadTaskRunner> task_runner(new TestSimpleTaskRunner);
-  ThreadTaskRunnerHandleOverride ttrh_override(task_runner,
-                                               /*allow_nested_runloop=*/true);
-  EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-  EXPECT_EQ(task_runner, ThreadTaskRunnerHandle::Get());
-  EXPECT_EQ(task_runner, SequencedTaskRunnerHandle::Get());
-  RunLoop().RunUntilIdle();
-}
-
-TEST(ThreadTaskRunnerHandleTest, DeathOnNestedRunLoop) {
-  test::SingleThreadTaskEnvironment task_environment;
-  EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-  scoped_refptr<SingleThreadTaskRunner> task_runner(new TestSimpleTaskRunner);
-  ThreadTaskRunnerHandleOverrideForTesting ttrh_override(task_runner);
-  EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
-  EXPECT_EQ(task_runner, ThreadTaskRunnerHandle::Get());
-  EXPECT_EQ(task_runner, SequencedTaskRunnerHandle::Get());
-  EXPECT_DCHECK_DEATH({ RunLoop().RunUntilIdle(); });
-}
-
-}  // namespace base

codelabs/cpp101/README.md

@@ -241,7 +241,7 @@ Include `testonly=true` flag in the BUILD.gn file, along with
 #include "base/test/task_environment.h"
 #include "base/test/test_timeouts.h"
 #include "base/at_exit.h"
-#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/task/sequenced_task_runner.h"
 #include "base/time/time.h"
 #include "base/command_line.h"
 ```

components/cast/message_port/cast_core/message_port_core_with_task_runner.h

@@ -11,7 +11,8 @@
 
 namespace cast_api_bindings {
 
-// MessagePortCore serving users of base::SequenedTaskRunnerHandle
+// MessagePortCore serving users of
+// base::SequencedTaskRunner::CurrentDefaultHandle
 class MessagePortCoreWithTaskRunner : public MessagePortCore {
  public:
   explicit MessagePortCoreWithTaskRunner(uint32_t channel_id);

docs/memory-infra/adding_memory_infra_tracing.md

@@ -95,7 +95,7 @@ complex and may be a number of things:
  * If your component already uses a custom `base::SingleThreadTaskRunner` for
    executing tasks on a specific thread, you should likely use this runner.
 
-[task-runner-handle]: https://chromium.googlesource.com/chromium/src/+/main/base/thread_task_runner_handle.h
+[task-runner-current-default-handle]: https://chromium.googlesource.com/chromium/src/+/main/base/task/single_thread_task_runner.h
 
 ## Unregistration
 

services/tracing/public/cpp/perfetto/trace_event_data_source.cc

@@ -1179,9 +1179,10 @@ void TraceEventDataSource::ReturnTraceWriter(
 
   // Return the TraceWriter on the sequence that the PerfettoProducers run on.
   // Needed as the TrackEventThreadLocalEventSink gets deleted on thread
-  // shutdown and we can't safely call TaskRunnerHandle::Get() at that point
-  // (which can happen as the TraceWriter destructor might issue a Mojo call
-  // synchronously, which can trigger a call to TaskRunnerHandle::Get()).
+  // shutdown and we can't safely call task runner GetCurrentDefault() at that
+  // point (which can happen as the TraceWriter destructor might issue a Mojo
+  // call synchronously, which can trigger a call to
+  // task runner GetCurrentDefault()).
   auto* trace_writer_raw = trace_writer.release();
   ANNOTATE_LEAKING_OBJECT_PTR(trace_writer_raw);
   // Use PostTask() on PerfettoTaskRunner to ensure we comply with

services/tracing/public/cpp/stack_sampling/tracing_sampler_profiler.cc

@@ -432,8 +432,8 @@ TracingSamplerProfiler::TracingProfileBuilder::TracingProfileBuilder(
 TracingSamplerProfiler::TracingProfileBuilder::~TracingProfileBuilder() {
 #if !BUILDFLAG(USE_PERFETTO_CLIENT_LIBRARY)
   // Deleting a TraceWriter can end up triggering a Mojo call which calls
-  // TaskRunnerHandle::Get() and isn't safe on thread shutdown, which is when
-  // TracingProfileBuilder gets destructed, so we make sure this happens on
+  // task runner GetCurrentDefault() and isn't safe on thread shutdown, which is
+  // when TracingProfileBuilder gets destructed, so we make sure this happens on
   // a different sequence.
   if (base::ThreadPoolInstance::Get()) {
     PerfettoTracedProcess::GetTaskRunner()->GetOrCreateTaskRunner()->DeleteSoon(

third_party/blink/renderer/platform/exported/video_capture/DEPS

@@ -5,7 +5,7 @@ include_rules = [
 specific_include_rules = {
     "web_video_capture_impl_manager.cc": [
         "+base/task/bind_post_task.h",
-        "+base/threading/sequenced_task_runner_handle.h",
+        "+base/task/sequenced_task_runner.h",
         "+base/token.h",
         "+media/capture/mojom/video_capture_types.mojom-blink.h",
     ],

third_party/blink/renderer/platform/peerconnection/DEPS

@@ -20,7 +20,7 @@ include_rules = [
     "+base/strings/string_split.h",
     "+base/task/bind_post_task.h",
     "+base/task/task_traits.h",
-    "+base/threading/sequenced_task_runner_handle.h",
+    "+base/task/sequenced_task_runner.h",
     "+base/threading/thread_restrictions.h",
     "+media/base",
     "+media/capture/capture_switches.h",

third_party/leveldatabase/leveldb_chrome.cc

@@ -19,7 +19,6 @@
 #include "base/no_destructor.h"
 #include "base/strings/stringprintf.h"
 #include "base/system/sys_info.h"
-#include "base/threading/sequenced_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/process_memory_dump.h"

third_party/webrtc_overrides/metronome_source.cc

@@ -16,7 +16,6 @@
 #include "base/task/sequenced_task_runner.h"
 #include "base/task/thread_pool.h"
 #include "base/thread_annotations.h"
-#include "base/threading/sequenced_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/typed_macros.h"
 #include "third_party/webrtc/api/metronome/metronome.h"