base/task/sequenced_task_runner_unittest.cc - chromium/src.git - Git at Google

 // 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/task/sequenced_task_runner.h"

 #include <array>
 #include <utility>

 #include "base/barrier_closure.h"
 #include "base/functional/bind.h"
 #include "base/functional/callback.h"
 #include "base/functional/callback_helpers.h"
 #include "base/gtest_prod_util.h"
 #include "base/location.h"
 #include "base/memory/raw_ptr.h"
 #include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
 #include "base/sequence_checker_impl.h"
 #include "base/task/sequenced_task_runner.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/task/task_traits.h"
 #include "base/task/thread_pool.h"
 #include "base/test/bind.h"
 #include "base/test/gtest_util.h"
 #include "base/test/null_task_runner.h"
 #include "base/test/task_environment.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace base {
 namespace {

 class FlagOnDelete {
  public:
   FlagOnDelete(bool* deleted,
                scoped_refptr<SequencedTaskRunner> expected_deletion_sequence)
       : deleted_(deleted),
         expected_deletion_sequence_(std::move(expected_deletion_sequence)) {}
   FlagOnDelete(const FlagOnDelete&) = delete;
   FlagOnDelete& operator=(const FlagOnDelete&) = delete;

   ~FlagOnDelete() {
     EXPECT_FALSE(*deleted_);
     *deleted_ = true;
     if (expected_deletion_sequence_) {
       EXPECT_TRUE(expected_deletion_sequence_->RunsTasksInCurrentSequence());
     }
   }

  private:
   raw_ptr<bool> deleted_;
   const scoped_refptr<SequencedTaskRunner> expected_deletion_sequence_;
 };

 class SequencedTaskRunnerTest : public testing::Test {
  public:
   SequencedTaskRunnerTest(const SequencedTaskRunnerTest&) = delete;
   SequencedTaskRunnerTest& operator=(const SequencedTaskRunnerTest&) = delete;

  protected:
   SequencedTaskRunnerTest() : foreign_thread_("foreign") {}

   void SetUp() override {
     foreign_thread_.Start();
     foreign_runner_ = foreign_thread_.task_runner();
   }

   scoped_refptr<SequencedTaskRunner> foreign_runner_;

   Thread foreign_thread_;

  private:
   test::TaskEnvironment task_environment_;
 };

 }  // namespace

 using SequenceBoundUniquePtr =
     std::unique_ptr<FlagOnDelete, OnTaskRunnerDeleter>;

 TEST_F(SequencedTaskRunnerTest, OnTaskRunnerDeleterOnMainThread) {
   bool deleted_on_main_thread = false;
   SequenceBoundUniquePtr ptr(
       new FlagOnDelete(&deleted_on_main_thread,
                        SequencedTaskRunner::GetCurrentDefault()),
       OnTaskRunnerDeleter(SequencedTaskRunner::GetCurrentDefault()));
   EXPECT_FALSE(deleted_on_main_thread);
   foreign_runner_->PostTask(FROM_HERE, DoNothingWithBoundArgs(std::move(ptr)));

   {
     RunLoop run_loop;
     foreign_runner_->PostTaskAndReply(FROM_HERE, BindOnce([] {}),
                                       run_loop.QuitClosure());
     run_loop.Run();
   }
   EXPECT_TRUE(deleted_on_main_thread);
 }

 TEST_F(SequencedTaskRunnerTest, OnTaskRunnerDeleterTargetStoppedEarly) {
   bool deleted_on_main_thread = false;
   FlagOnDelete* raw = new FlagOnDelete(
       &deleted_on_main_thread, SequencedTaskRunner::GetCurrentDefault());
   SequenceBoundUniquePtr ptr(raw, OnTaskRunnerDeleter(foreign_runner_));
   EXPECT_FALSE(deleted_on_main_thread);

   // Stopping the target ahead of deleting |ptr| should make its
   // OnTaskRunnerDeleter no-op.
   foreign_thread_.Stop();
   ptr = nullptr;
   EXPECT_FALSE(deleted_on_main_thread);

   delete raw;
   EXPECT_TRUE(deleted_on_main_thread);
 }

 TEST_F(SequencedTaskRunnerTest, DelayedTaskHandle_RunTask) {
   auto task_runner = MakeRefCounted<TestMockTimeTaskRunner>();

   bool task_ran = false;
   DelayedTaskHandle delayed_task_handle =
       task_runner->PostCancelableDelayedTask(
           subtle::PostDelayedTaskPassKeyForTesting(), FROM_HERE,
           BindLambdaForTesting([&task_ran] { task_ran = true; }), Seconds(1));
   EXPECT_TRUE(delayed_task_handle.IsValid());
   EXPECT_TRUE(task_runner->HasPendingTask());

   // Run the delayed task.
   task_runner->FastForwardUntilNoTasksRemain();

   EXPECT_FALSE(delayed_task_handle.IsValid());
   EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_TRUE(task_ran);
 }

 TEST_F(SequencedTaskRunnerTest, DelayedTaskHandle_CancelTask) {
   auto task_runner = MakeRefCounted<TestMockTimeTaskRunner>();

   bool task_ran = false;
   DelayedTaskHandle delayed_task_handle =
       task_runner->PostCancelableDelayedTask(
           subtle::PostDelayedTaskPassKeyForTesting(), FROM_HERE,
           BindLambdaForTesting([&task_ran] { task_ran = true; }), Seconds(1));
   EXPECT_TRUE(delayed_task_handle.IsValid());
   EXPECT_TRUE(task_runner->HasPendingTask());

   // Cancel the delayed task.
   delayed_task_handle.CancelTask();

   EXPECT_FALSE(delayed_task_handle.IsValid());
   EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_FALSE(task_ran);
 }

 TEST_F(SequencedTaskRunnerTest, DelayedTaskHandle_DestroyTask) {
   auto task_runner = MakeRefCounted<TestMockTimeTaskRunner>();

   bool task_ran = false;
   DelayedTaskHandle delayed_task_handle =
       task_runner->PostCancelableDelayedTask(
           subtle::PostDelayedTaskPassKeyForTesting(), FROM_HERE,
           BindLambdaForTesting([&task_ran] { task_ran = true; }), Seconds(1));
   EXPECT_TRUE(delayed_task_handle.IsValid());
   EXPECT_TRUE(task_runner->HasPendingTask());

   // Destroy the pending task.
   task_runner->ClearPendingTasks();

   EXPECT_FALSE(delayed_task_handle.IsValid());
   EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_FALSE(task_ran);
 }

 // Tests that if PostCancelableDelayedTask() fails, the returned handle will be
 // invalid.
 TEST_F(SequencedTaskRunnerTest, DelayedTaskHandle_PostTaskFailed) {
   auto task_runner = MakeRefCounted<NullTaskRunner>();

   bool task_ran = false;
   DelayedTaskHandle delayed_task_handle =
       task_runner->PostCancelableDelayedTask(
           subtle::PostDelayedTaskPassKeyForTesting(), FROM_HERE,
           BindLambdaForTesting([&task_ran] { task_ran = true; }), Seconds(1));
   EXPECT_FALSE(delayed_task_handle.IsValid());
   EXPECT_FALSE(task_ran);
 }

 namespace {

 // Tests for the SequencedTaskRunner::CurrentDefaultHandle machinery.
 class SequencedTaskRunnerCurrentDefaultHandleTest : public ::testing::Test {
  protected:
   // Verifies that the context it runs on has a
   // SequencedTaskRunner::CurrentDefaultHandle and that posting to it results in
   // the posted task running in that same context (sequence).
   static void VerifyCurrentSequencedTaskRunner() {
     ASSERT_TRUE(SequencedTaskRunner::HasCurrentDefault());
     scoped_refptr<SequencedTaskRunner> task_runner =
         SequencedTaskRunner::GetCurrentDefault();
     ASSERT_TRUE(task_runner);

     // Use SequenceCheckerImpl to make sure it's not a no-op in Release builds.
     std::unique_ptr<SequenceCheckerImpl> sequence_checker =
         std::make_unique<SequenceCheckerImpl>();
     task_runner->PostTask(
         FROM_HERE,
         base::BindOnce(
             &SequencedTaskRunnerCurrentDefaultHandleTest::CheckValidSequence,
             std::move(sequence_checker)));
   }

   static void CheckValidSequence(
       std::unique_ptr<SequenceCheckerImpl> sequence_checker) {
     EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
   }

   test::TaskEnvironment task_environment_;
 };

 using SequencedTaskRunnerCurrentDefaultHandleDeathTest =
     SequencedTaskRunnerCurrentDefaultHandleTest;

 }  // namespace

 TEST_F(SequencedTaskRunnerCurrentDefaultHandleTest, FromTaskEnvironment) {
   VerifyCurrentSequencedTaskRunner();
   RunLoop().RunUntilIdle();
 }

 TEST_F(SequencedTaskRunnerCurrentDefaultHandleTest,
        FromThreadPoolSequencedTask) {
   base::ThreadPool::CreateSequencedTaskRunner({})->PostTask(
       FROM_HERE, base::BindOnce(&SequencedTaskRunnerCurrentDefaultHandleTest::
                                     VerifyCurrentSequencedTaskRunner));
   task_environment_.RunUntilIdle();
 }

 TEST_F(SequencedTaskRunnerCurrentDefaultHandleTest,
        NoHandleFromUnsequencedTask) {
   base::ThreadPool::PostTask(base::BindOnce(
       [] { EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault()); }));
   task_environment_.RunUntilIdle();
 }

 // Verify that `CurrentDefaultHandle` can be used to set the current default
 // `SequencedTaskRunner` to null in a scope that already has a default.
 TEST_F(SequencedTaskRunnerCurrentDefaultHandleDeathTest, OverrideWithNull) {
   EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
   auto tr1 = SequencedTaskRunner::GetCurrentDefault();
   EXPECT_TRUE(tr1);

   {
     SequencedTaskRunner::CurrentDefaultHandle handle(
         nullptr, SequencedTaskRunner::CurrentDefaultHandle::MayAlreadyExist{});
     EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
     EXPECT_CHECK_DEATH(
         { auto tr2 = SequencedTaskRunner::GetCurrentDefault(); });
   }

   EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
   EXPECT_EQ(tr1, SequencedTaskRunner::GetCurrentDefault());
 }

 // Verify that `CurrentDefaultHandle` can be used to set the current default
 // `SequencedTaskRunner` to a non-null value in a scope that already has a
 // default.
 TEST_F(SequencedTaskRunnerCurrentDefaultHandleTest, OverrideWithNonNull) {
   EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
   auto tr1 = SequencedTaskRunner::GetCurrentDefault();
   EXPECT_TRUE(tr1);

   {
     auto tr2 = MakeRefCounted<TestSimpleTaskRunner>();
     SequencedTaskRunner::CurrentDefaultHandle handle(
         tr2, SequencedTaskRunner::CurrentDefaultHandle::MayAlreadyExist{});
     EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
     EXPECT_EQ(tr2, SequencedTaskRunner::GetCurrentDefault());
   }

   EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
   EXPECT_EQ(tr1, SequencedTaskRunner::GetCurrentDefault());
 }

 TEST(SequencedTaskRunnerCurrentDefaultHandleTestWithoutTaskEnvironment,
      FromHandleInScope) {
   scoped_refptr<SequencedTaskRunner> test_task_runner =
       MakeRefCounted<TestSimpleTaskRunner>();
   EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
   EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
   {
     SequencedTaskRunner::CurrentDefaultHandle current_default(test_task_runner);
     EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
     EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
     EXPECT_EQ(test_task_runner, SequencedTaskRunner::GetCurrentDefault());
   }
   EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
   EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
 }

 TEST(SequencedTaskRunnerCurrentBestEffortTest, SequenceManagerSingleQueue) {
   // TaskEnvironment wraps a SequenceManager with a single default task queue.
   test::TaskEnvironment task_env;
   EXPECT_FALSE(SequencedTaskRunner::HasCurrentBestEffort());
   ASSERT_TRUE(SequencedTaskRunner::HasCurrentDefault());

   // Should fall back to returning the default task runner when no best-effort
   // task runner is set.
   EXPECT_EQ(SequencedTaskRunner::GetCurrentBestEffort(),
             SequencedTaskRunner::GetCurrentDefault());
 }

 TEST(SequencedTaskRunnerCurrentBestEffortTest, SequenceManagerManyQueues) {
   // TaskEnvironmentWithMainThreadPriorities wraps a SequenceManager with
   // several task queues.
   test::TaskEnvironmentWithMainThreadPriorities task_env;
   EXPECT_TRUE(SequencedTaskRunner::HasCurrentBestEffort());
   ASSERT_TRUE(SequencedTaskRunner::HasCurrentDefault());
   ASSERT_TRUE(SequencedTaskRunner::GetCurrentBestEffort());

   // The best-effort task runner should NOT be the default.
   EXPECT_NE(SequencedTaskRunner::GetCurrentBestEffort(),
             SequencedTaskRunner::GetCurrentDefault());

   // All should run tasks on the same sequence. They differ only in priority.

   // Use SequenceCheckerImpl to make sure it's not a no-op in Release builds.
   SequenceCheckerImpl sequence_checker;

   RunLoop run_loop;
   auto quit_closure = BarrierClosure(2, run_loop.QuitClosure());
   SequencedTaskRunner::GetCurrentBestEffort()->PostTask(
       FROM_HERE, BindLambdaForTesting([&] {
                    EXPECT_TRUE(sequence_checker.CalledOnValidSequence())
                        << "GetCurrentBestEffort";
                  }).Then(quit_closure));
   SequencedTaskRunner::GetCurrentDefault()->PostTask(
       FROM_HERE, BindLambdaForTesting([&] {
                    EXPECT_TRUE(sequence_checker.CalledOnValidSequence())
                        << "GetCurrentDefault";
                  }).Then(quit_closure));
   run_loop.Run();
 }

 TEST(SequencedTaskRunnerCurrentBestEffortTest, ThreadPoolSingleThreadTask) {
   test::TaskEnvironmentWithMainThreadPriorities task_env;

   EXPECT_TRUE(SequencedTaskRunner::HasCurrentBestEffort());
   auto task_env_best_effort_task_runner =
       SequencedTaskRunner::GetCurrentBestEffort();

   // Use SequenceCheckerImpl to make sure it's not a no-op in Release builds.
   SequenceCheckerImpl sequence_checker;

   // Test GetCurrentBestEffort() from a default-priority task and a BEST_EFFORT
   // task.
   constexpr auto kPriorities =
       std::to_array({TaskPriority::USER_BLOCKING, TaskPriority::BEST_EFFORT});

   for (auto priority : kPriorities) {
     ThreadPool::CreateSingleThreadTaskRunner({priority})
         ->PostTask(FROM_HERE,
                    BindLambdaForTesting([&] {
                      SCOPED_TRACE(priority);

                      // TODO(crbug.com/441949788): Even if this is on a
                      // BEST_EFFORT task runner, HasCurrentBestEffort() returns
                      // false because it only supports SequenceManager task
                      // queues.
                      EXPECT_FALSE(SequencedTaskRunner::HasCurrentBestEffort());
                      ASSERT_TRUE(SequencedTaskRunner::HasCurrentDefault());

                      // Should fall back to returning the default task runner
                      // when no best-effort task runner is set.
                      EXPECT_EQ(SequencedTaskRunner::GetCurrentBestEffort(),
                                SequencedTaskRunner::GetCurrentDefault());

                      // It should NOT be the TaskEnvironment's best-effort task
                      // runner.
                      EXPECT_NE(SequencedTaskRunner::GetCurrentBestEffort(),
                                task_env_best_effort_task_runner);
                      EXPECT_FALSE(sequence_checker.CalledOnValidSequence());
                    }).Then(task_env.QuitClosure()));
     task_env.RunUntilQuit();
   }
 }

 TEST(SequencedTaskRunnerCurrentBestEffortTest, ThreadPoolSequencedTask) {
   test::TaskEnvironmentWithMainThreadPriorities task_env;

   EXPECT_TRUE(SequencedTaskRunner::HasCurrentBestEffort());
   auto task_env_best_effort_task_runner =
       SequencedTaskRunner::GetCurrentBestEffort();

   // Use SequenceCheckerImpl to make sure it's not a no-op in Release builds.
   SequenceCheckerImpl sequence_checker;

   // Test GetCurrentBestEffort() from a default-priority task and a BEST_EFFORT
   // task.
   constexpr auto kPriorities =
       std::to_array({TaskPriority::USER_BLOCKING, TaskPriority::BEST_EFFORT});

   for (auto priority : kPriorities) {
     ThreadPool::CreateSequencedTaskRunner({priority})
         ->PostTask(FROM_HERE,
                    BindLambdaForTesting([&] {
                      SCOPED_TRACE(priority);

                      // TODO(crbug.com/441949788): Even if this is on a
                      // BEST_EFFORT task runner, HasCurrentBestEffort() returns
                      // false because it only supports SequenceManager task
                      // queues.
                      EXPECT_FALSE(SequencedTaskRunner::HasCurrentBestEffort());
                      ASSERT_TRUE(SequencedTaskRunner::HasCurrentDefault());

                      // Should fall back to returning the default task runner
                      // when no best-effort task runner is set.
                      EXPECT_EQ(SequencedTaskRunner::GetCurrentBestEffort(),
                                SequencedTaskRunner::GetCurrentDefault());

                      // It should NOT be the TaskEnvironment's best-effort task
                      // runner.
                      EXPECT_NE(SequencedTaskRunner::GetCurrentBestEffort(),
                                task_env_best_effort_task_runner);
                      EXPECT_FALSE(sequence_checker.CalledOnValidSequence());
                    }).Then(task_env.QuitClosure()));
     task_env.RunUntilQuit();
   }
 }

 TEST(SequencedTaskRunnerCurrentBestEffortTest, ThreadPoolUnsequencedTask) {
   test::TaskEnvironmentWithMainThreadPriorities task_env;

   EXPECT_TRUE(SequencedTaskRunner::HasCurrentBestEffort());

   // Test GetCurrentBestEffort() from a default-priority task and a BEST_EFFORT
   // task.
   constexpr auto kPriorities =
       std::to_array({TaskPriority::USER_BLOCKING, TaskPriority::BEST_EFFORT});

   for (auto priority : kPriorities) {
     ThreadPool::PostTask(
         FROM_HERE, {priority},
         BindLambdaForTesting([&] {
           SCOPED_TRACE(priority);

           // The current task isn't bound to a sequence.
           EXPECT_FALSE(SequencedTaskRunner::HasCurrentBestEffort());
           EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
         }).Then(task_env.QuitClosure()));
     task_env.RunUntilQuit();
   }
 }

 TEST(SequencedTaskRunnerCurrentBestEffortDeathTest, NoContext) {
   EXPECT_FALSE(SequencedTaskRunner::HasCurrentBestEffort());
   EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
   // Ensure that GetCurrentBestEffort() doesn't return a value when
   // HasCurrentDefault() is false.
   EXPECT_CHECK_DEATH(
       { auto task_runner = SequencedTaskRunner::GetCurrentBestEffort(); });
 }

 }  // namespace base
	// 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/task/sequenced_task_runner.h"

	#include <array>
	#include <utility>

	#include "base/barrier_closure.h"
	#include "base/functional/bind.h"
	#include "base/functional/callback.h"
	#include "base/functional/callback_helpers.h"
	#include "base/gtest_prod_util.h"
	#include "base/location.h"
	#include "base/memory/raw_ptr.h"
	#include "base/memory/scoped_refptr.h"
	#include "base/run_loop.h"
	#include "base/sequence_checker_impl.h"
	#include "base/task/sequenced_task_runner.h"
	#include "base/task/single_thread_task_runner.h"
	#include "base/task/task_traits.h"
	#include "base/task/thread_pool.h"
	#include "base/test/bind.h"
	#include "base/test/gtest_util.h"
	#include "base/test/null_task_runner.h"
	#include "base/test/task_environment.h"
	#include "base/test/test_mock_time_task_runner.h"
	#include "base/test/test_simple_task_runner.h"
	#include "base/threading/thread.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace base {
	namespace {

	class FlagOnDelete {
	public:
	FlagOnDelete(bool* deleted,
	scoped_refptr<SequencedTaskRunner> expected_deletion_sequence)
	: deleted_(deleted),
	expected_deletion_sequence_(std::move(expected_deletion_sequence)) {}
	FlagOnDelete(const FlagOnDelete&) = delete;
	FlagOnDelete& operator=(const FlagOnDelete&) = delete;

	~FlagOnDelete() {
	EXPECT_FALSE(*deleted_);
	*deleted_ = true;
	if (expected_deletion_sequence_) {
	EXPECT_TRUE(expected_deletion_sequence_->RunsTasksInCurrentSequence());
	}
	}

	private:
	raw_ptr<bool> deleted_;
	const scoped_refptr<SequencedTaskRunner> expected_deletion_sequence_;
	};

	class SequencedTaskRunnerTest : public testing::Test {
	public:
	SequencedTaskRunnerTest(const SequencedTaskRunnerTest&) = delete;
	SequencedTaskRunnerTest& operator=(const SequencedTaskRunnerTest&) = delete;

	protected:
	SequencedTaskRunnerTest() : foreign_thread_("foreign") {}

	void SetUp() override {
	foreign_thread_.Start();
	foreign_runner_ = foreign_thread_.task_runner();
	}

	scoped_refptr<SequencedTaskRunner> foreign_runner_;

	Thread foreign_thread_;

	private:
	test::TaskEnvironment task_environment_;
	};

	} // namespace

	using SequenceBoundUniquePtr =
	std::unique_ptr<FlagOnDelete, OnTaskRunnerDeleter>;

	TEST_F(SequencedTaskRunnerTest, OnTaskRunnerDeleterOnMainThread) {
	bool deleted_on_main_thread = false;
	SequenceBoundUniquePtr ptr(
	new FlagOnDelete(&deleted_on_main_thread,
	SequencedTaskRunner::GetCurrentDefault()),
	OnTaskRunnerDeleter(SequencedTaskRunner::GetCurrentDefault()));
	EXPECT_FALSE(deleted_on_main_thread);
	foreign_runner_->PostTask(FROM_HERE, DoNothingWithBoundArgs(std::move(ptr)));

	{
	RunLoop run_loop;
	foreign_runner_->PostTaskAndReply(FROM_HERE, BindOnce([] {}),
	run_loop.QuitClosure());
	run_loop.Run();
	}
	EXPECT_TRUE(deleted_on_main_thread);
	}

	TEST_F(SequencedTaskRunnerTest, OnTaskRunnerDeleterTargetStoppedEarly) {
	bool deleted_on_main_thread = false;
	FlagOnDelete* raw = new FlagOnDelete(
	&deleted_on_main_thread, SequencedTaskRunner::GetCurrentDefault());
	SequenceBoundUniquePtr ptr(raw, OnTaskRunnerDeleter(foreign_runner_));
	EXPECT_FALSE(deleted_on_main_thread);

	// Stopping the target ahead of deleting \|ptr\| should make its
	// OnTaskRunnerDeleter no-op.
	foreign_thread_.Stop();
	ptr = nullptr;
	EXPECT_FALSE(deleted_on_main_thread);

	delete raw;
	EXPECT_TRUE(deleted_on_main_thread);
	}

	TEST_F(SequencedTaskRunnerTest, DelayedTaskHandle_RunTask) {
	auto task_runner = MakeRefCounted<TestMockTimeTaskRunner>();

	bool task_ran = false;
	DelayedTaskHandle delayed_task_handle =
	task_runner->PostCancelableDelayedTask(
	subtle::PostDelayedTaskPassKeyForTesting(), FROM_HERE,
	BindLambdaForTesting([&task_ran] { task_ran = true; }), Seconds(1));
	EXPECT_TRUE(delayed_task_handle.IsValid());
	EXPECT_TRUE(task_runner->HasPendingTask());

	// Run the delayed task.
	task_runner->FastForwardUntilNoTasksRemain();

	EXPECT_FALSE(delayed_task_handle.IsValid());
	EXPECT_FALSE(task_runner->HasPendingTask());
	EXPECT_TRUE(task_ran);
	}

	TEST_F(SequencedTaskRunnerTest, DelayedTaskHandle_CancelTask) {
	auto task_runner = MakeRefCounted<TestMockTimeTaskRunner>();

	bool task_ran = false;
	DelayedTaskHandle delayed_task_handle =
	task_runner->PostCancelableDelayedTask(
	subtle::PostDelayedTaskPassKeyForTesting(), FROM_HERE,
	BindLambdaForTesting([&task_ran] { task_ran = true; }), Seconds(1));
	EXPECT_TRUE(delayed_task_handle.IsValid());
	EXPECT_TRUE(task_runner->HasPendingTask());

	// Cancel the delayed task.
	delayed_task_handle.CancelTask();

	EXPECT_FALSE(delayed_task_handle.IsValid());
	EXPECT_FALSE(task_runner->HasPendingTask());
	EXPECT_FALSE(task_ran);
	}

	TEST_F(SequencedTaskRunnerTest, DelayedTaskHandle_DestroyTask) {
	auto task_runner = MakeRefCounted<TestMockTimeTaskRunner>();

	bool task_ran = false;
	DelayedTaskHandle delayed_task_handle =
	task_runner->PostCancelableDelayedTask(
	subtle::PostDelayedTaskPassKeyForTesting(), FROM_HERE,
	BindLambdaForTesting([&task_ran] { task_ran = true; }), Seconds(1));
	EXPECT_TRUE(delayed_task_handle.IsValid());
	EXPECT_TRUE(task_runner->HasPendingTask());

	// Destroy the pending task.
	task_runner->ClearPendingTasks();

	EXPECT_FALSE(delayed_task_handle.IsValid());
	EXPECT_FALSE(task_runner->HasPendingTask());
	EXPECT_FALSE(task_ran);
	}

	// Tests that if PostCancelableDelayedTask() fails, the returned handle will be
	// invalid.
	TEST_F(SequencedTaskRunnerTest, DelayedTaskHandle_PostTaskFailed) {
	auto task_runner = MakeRefCounted<NullTaskRunner>();

	bool task_ran = false;
	DelayedTaskHandle delayed_task_handle =
	task_runner->PostCancelableDelayedTask(
	subtle::PostDelayedTaskPassKeyForTesting(), FROM_HERE,
	BindLambdaForTesting([&task_ran] { task_ran = true; }), Seconds(1));
	EXPECT_FALSE(delayed_task_handle.IsValid());
	EXPECT_FALSE(task_ran);
	}

	namespace {

	// Tests for the SequencedTaskRunner::CurrentDefaultHandle machinery.
	class SequencedTaskRunnerCurrentDefaultHandleTest : public ::testing::Test {
	protected:
	// Verifies that the context it runs on has a
	// SequencedTaskRunner::CurrentDefaultHandle and that posting to it results in
	// the posted task running in that same context (sequence).
	static void VerifyCurrentSequencedTaskRunner() {
	ASSERT_TRUE(SequencedTaskRunner::HasCurrentDefault());
	scoped_refptr<SequencedTaskRunner> task_runner =
	SequencedTaskRunner::GetCurrentDefault();
	ASSERT_TRUE(task_runner);

	// Use SequenceCheckerImpl to make sure it's not a no-op in Release builds.
	std::unique_ptr<SequenceCheckerImpl> sequence_checker =
	std::make_unique<SequenceCheckerImpl>();
	task_runner->PostTask(
	FROM_HERE,
	base::BindOnce(
	&SequencedTaskRunnerCurrentDefaultHandleTest::CheckValidSequence,
	std::move(sequence_checker)));
	}

	static void CheckValidSequence(
	std::unique_ptr<SequenceCheckerImpl> sequence_checker) {
	EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
	}

	test::TaskEnvironment task_environment_;
	};

	using SequencedTaskRunnerCurrentDefaultHandleDeathTest =
	SequencedTaskRunnerCurrentDefaultHandleTest;

	} // namespace

	TEST_F(SequencedTaskRunnerCurrentDefaultHandleTest, FromTaskEnvironment) {
	VerifyCurrentSequencedTaskRunner();
	RunLoop().RunUntilIdle();
	}

	TEST_F(SequencedTaskRunnerCurrentDefaultHandleTest,
	FromThreadPoolSequencedTask) {
	base::ThreadPool::CreateSequencedTaskRunner({})->PostTask(
	FROM_HERE, base::BindOnce(&SequencedTaskRunnerCurrentDefaultHandleTest::
	VerifyCurrentSequencedTaskRunner));
	task_environment_.RunUntilIdle();
	}

	TEST_F(SequencedTaskRunnerCurrentDefaultHandleTest,
	NoHandleFromUnsequencedTask) {
	base::ThreadPool::PostTask(base::BindOnce(
	[] { EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault()); }));
	task_environment_.RunUntilIdle();
	}

	// Verify that `CurrentDefaultHandle` can be used to set the current default
	// `SequencedTaskRunner` to null in a scope that already has a default.
	TEST_F(SequencedTaskRunnerCurrentDefaultHandleDeathTest, OverrideWithNull) {
	EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
	auto tr1 = SequencedTaskRunner::GetCurrentDefault();
	EXPECT_TRUE(tr1);

	{
	SequencedTaskRunner::CurrentDefaultHandle handle(
	nullptr, SequencedTaskRunner::CurrentDefaultHandle::MayAlreadyExist{});
	EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
	EXPECT_CHECK_DEATH(
	{ auto tr2 = SequencedTaskRunner::GetCurrentDefault(); });
	}

	EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
	EXPECT_EQ(tr1, SequencedTaskRunner::GetCurrentDefault());
	}

	// Verify that `CurrentDefaultHandle` can be used to set the current default
	// `SequencedTaskRunner` to a non-null value in a scope that already has a
	// default.
	TEST_F(SequencedTaskRunnerCurrentDefaultHandleTest, OverrideWithNonNull) {
	EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
	auto tr1 = SequencedTaskRunner::GetCurrentDefault();
	EXPECT_TRUE(tr1);

	{
	auto tr2 = MakeRefCounted<TestSimpleTaskRunner>();
	SequencedTaskRunner::CurrentDefaultHandle handle(
	tr2, SequencedTaskRunner::CurrentDefaultHandle::MayAlreadyExist{});
	EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
	EXPECT_EQ(tr2, SequencedTaskRunner::GetCurrentDefault());
	}

	EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
	EXPECT_EQ(tr1, SequencedTaskRunner::GetCurrentDefault());
	}

	TEST(SequencedTaskRunnerCurrentDefaultHandleTestWithoutTaskEnvironment,
	FromHandleInScope) {
	scoped_refptr<SequencedTaskRunner> test_task_runner =
	MakeRefCounted<TestSimpleTaskRunner>();
	EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
	EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
	{
	SequencedTaskRunner::CurrentDefaultHandle current_default(test_task_runner);
	EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
	EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
	EXPECT_EQ(test_task_runner, SequencedTaskRunner::GetCurrentDefault());
	}
	EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
	EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
	}

	TEST(SequencedTaskRunnerCurrentBestEffortTest, SequenceManagerSingleQueue) {
	// TaskEnvironment wraps a SequenceManager with a single default task queue.
	test::TaskEnvironment task_env;
	EXPECT_FALSE(SequencedTaskRunner::HasCurrentBestEffort());
	ASSERT_TRUE(SequencedTaskRunner::HasCurrentDefault());

	// Should fall back to returning the default task runner when no best-effort
	// task runner is set.
	EXPECT_EQ(SequencedTaskRunner::GetCurrentBestEffort(),
	SequencedTaskRunner::GetCurrentDefault());
	}

	TEST(SequencedTaskRunnerCurrentBestEffortTest, SequenceManagerManyQueues) {
	// TaskEnvironmentWithMainThreadPriorities wraps a SequenceManager with
	// several task queues.
	test::TaskEnvironmentWithMainThreadPriorities task_env;
	EXPECT_TRUE(SequencedTaskRunner::HasCurrentBestEffort());
	ASSERT_TRUE(SequencedTaskRunner::HasCurrentDefault());
	ASSERT_TRUE(SequencedTaskRunner::GetCurrentBestEffort());

	// The best-effort task runner should NOT be the default.
	EXPECT_NE(SequencedTaskRunner::GetCurrentBestEffort(),
	SequencedTaskRunner::GetCurrentDefault());

	// All should run tasks on the same sequence. They differ only in priority.

	// Use SequenceCheckerImpl to make sure it's not a no-op in Release builds.
	SequenceCheckerImpl sequence_checker;

	RunLoop run_loop;
	auto quit_closure = BarrierClosure(2, run_loop.QuitClosure());
	SequencedTaskRunner::GetCurrentBestEffort()->PostTask(
	FROM_HERE, BindLambdaForTesting([&] {
	EXPECT_TRUE(sequence_checker.CalledOnValidSequence())
	<< "GetCurrentBestEffort";
	}).Then(quit_closure));
	SequencedTaskRunner::GetCurrentDefault()->PostTask(
	FROM_HERE, BindLambdaForTesting([&] {
	EXPECT_TRUE(sequence_checker.CalledOnValidSequence())
	<< "GetCurrentDefault";
	}).Then(quit_closure));
	run_loop.Run();
	}

	TEST(SequencedTaskRunnerCurrentBestEffortTest, ThreadPoolSingleThreadTask) {
	test::TaskEnvironmentWithMainThreadPriorities task_env;

	EXPECT_TRUE(SequencedTaskRunner::HasCurrentBestEffort());
	auto task_env_best_effort_task_runner =
	SequencedTaskRunner::GetCurrentBestEffort();

	// Use SequenceCheckerImpl to make sure it's not a no-op in Release builds.
	SequenceCheckerImpl sequence_checker;

	// Test GetCurrentBestEffort() from a default-priority task and a BEST_EFFORT
	// task.
	constexpr auto kPriorities =
	std::to_array({TaskPriority::USER_BLOCKING, TaskPriority::BEST_EFFORT});

	for (auto priority : kPriorities) {
	ThreadPool::CreateSingleThreadTaskRunner({priority})
	->PostTask(FROM_HERE,
	BindLambdaForTesting([&] {
	SCOPED_TRACE(priority);

	// TODO(crbug.com/441949788): Even if this is on a
	// BEST_EFFORT task runner, HasCurrentBestEffort() returns
	// false because it only supports SequenceManager task
	// queues.
	EXPECT_FALSE(SequencedTaskRunner::HasCurrentBestEffort());
	ASSERT_TRUE(SequencedTaskRunner::HasCurrentDefault());

	// Should fall back to returning the default task runner
	// when no best-effort task runner is set.
	EXPECT_EQ(SequencedTaskRunner::GetCurrentBestEffort(),
	SequencedTaskRunner::GetCurrentDefault());

	// It should NOT be the TaskEnvironment's best-effort task
	// runner.
	EXPECT_NE(SequencedTaskRunner::GetCurrentBestEffort(),
	task_env_best_effort_task_runner);
	EXPECT_FALSE(sequence_checker.CalledOnValidSequence());
	}).Then(task_env.QuitClosure()));
	task_env.RunUntilQuit();
	}
	}

	TEST(SequencedTaskRunnerCurrentBestEffortTest, ThreadPoolSequencedTask) {
	test::TaskEnvironmentWithMainThreadPriorities task_env;

	EXPECT_TRUE(SequencedTaskRunner::HasCurrentBestEffort());
	auto task_env_best_effort_task_runner =
	SequencedTaskRunner::GetCurrentBestEffort();

	// Use SequenceCheckerImpl to make sure it's not a no-op in Release builds.
	SequenceCheckerImpl sequence_checker;

	// Test GetCurrentBestEffort() from a default-priority task and a BEST_EFFORT
	// task.
	constexpr auto kPriorities =
	std::to_array({TaskPriority::USER_BLOCKING, TaskPriority::BEST_EFFORT});

	for (auto priority : kPriorities) {
	ThreadPool::CreateSequencedTaskRunner({priority})
	->PostTask(FROM_HERE,
	BindLambdaForTesting([&] {
	SCOPED_TRACE(priority);

	// TODO(crbug.com/441949788): Even if this is on a
	// BEST_EFFORT task runner, HasCurrentBestEffort() returns
	// false because it only supports SequenceManager task
	// queues.
	EXPECT_FALSE(SequencedTaskRunner::HasCurrentBestEffort());
	ASSERT_TRUE(SequencedTaskRunner::HasCurrentDefault());

	// Should fall back to returning the default task runner
	// when no best-effort task runner is set.
	EXPECT_EQ(SequencedTaskRunner::GetCurrentBestEffort(),
	SequencedTaskRunner::GetCurrentDefault());

	// It should NOT be the TaskEnvironment's best-effort task
	// runner.
	EXPECT_NE(SequencedTaskRunner::GetCurrentBestEffort(),
	task_env_best_effort_task_runner);
	EXPECT_FALSE(sequence_checker.CalledOnValidSequence());
	}).Then(task_env.QuitClosure()));
	task_env.RunUntilQuit();
	}
	}

	TEST(SequencedTaskRunnerCurrentBestEffortTest, ThreadPoolUnsequencedTask) {
	test::TaskEnvironmentWithMainThreadPriorities task_env;

	EXPECT_TRUE(SequencedTaskRunner::HasCurrentBestEffort());

	// Test GetCurrentBestEffort() from a default-priority task and a BEST_EFFORT
	// task.
	constexpr auto kPriorities =
	std::to_array({TaskPriority::USER_BLOCKING, TaskPriority::BEST_EFFORT});

	for (auto priority : kPriorities) {
	ThreadPool::PostTask(
	FROM_HERE, {priority},
	BindLambdaForTesting([&] {
	SCOPED_TRACE(priority);

	// The current task isn't bound to a sequence.
	EXPECT_FALSE(SequencedTaskRunner::HasCurrentBestEffort());
	EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
	}).Then(task_env.QuitClosure()));
	task_env.RunUntilQuit();
	}
	}

	TEST(SequencedTaskRunnerCurrentBestEffortDeathTest, NoContext) {
	EXPECT_FALSE(SequencedTaskRunner::HasCurrentBestEffort());
	EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
	// Ensure that GetCurrentBestEffort() doesn't return a value when
	// HasCurrentDefault() is false.
	EXPECT_CHECK_DEATH(
	{ auto task_runner = SequencedTaskRunner::GetCurrentBestEffort(); });
	}

	} // namespace base