Test SequencedWorkerPool with redirection to the TaskScheduler.

base/threading/sequenced_worker_pool_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/threading/sequenced_worker_pool.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
+#include "base/task_scheduler/scheduler_worker_pool_params.h"
+#include "base/task_scheduler/task_scheduler.h"
+#include "base/task_scheduler/task_scheduler_impl.h"
 #include "base/test/sequenced_task_runner_test_template.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "base/test/task_runner_test_template.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "base/tracked_objects.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
@@ skipping 194 matching lines @@
 
   base::ConditionVariable cond_var_;
 
   // Protected by lock_.
   std::vector<int> complete_sequence_;
 
   // Counter of the number of "block" workers that have started.
   size_t started_events_;
 };
 
-class SequencedWorkerPoolTest : public testing::Test {
+enum class SequencedWorkerPoolRedirection { NONE, TO_TASK_SCHEDULER };
+
+class SequencedWorkerPoolTest
+    : public testing::TestWithParam<SequencedWorkerPoolRedirection> {
  public:
   SequencedWorkerPoolTest()
-      : tracker_(new TestTracker) {
-    ResetPool();
+      : pool_owner_(new SequencedWorkerPoolOwner(kNumWorkerThreads, "test")),
+        tracker_(new TestTracker) {}
+
+  void SetUp() override {
+    if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER) {
+      std::vector<SchedulerWorkerPoolParams> worker_pool_params;
+      worker_pool_params.emplace_back(
+          "SchedulerWorkerPoolName", ThreadPriority::NORMAL,
+          SchedulerWorkerPoolParams::IORestriction::ALLOWED, kNumWorkerThreads,
+          TimeDelta::Max());
+      TaskScheduler::CreateAndSetDefaultTaskScheduler(
+          std::move(worker_pool_params),
+          base::Bind([](const TaskTraits&) -> size_t { return 0U; }));
+      SequencedWorkerPool::ResetRedirectToTaskSchedulerForProcessForTesting();
+      SequencedWorkerPool::RedirectToTaskSchedulerForProcess();
+    }
+  }
+
+  void TearDown() override {
+    // Wait until all references to the SequencedWorkerPool are gone and destroy
+    // it. This must be done before destroying the TaskScheduler. Otherwise, the
+    // SequencedWorkerPool could try to redirect tasks to a destroyed
+    // TaskScheduler.
+    DeletePool();
+
+    if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER) {
+      SequencedWorkerPool::ResetRedirectToTaskSchedulerForProcessForTesting();
+      DeleteTaskScheduler();
+    }
   }
 
   const scoped_refptr<SequencedWorkerPool>& pool() {
     return pool_owner_->pool();
   }
   TestTracker* tracker() { return tracker_.get(); }
 
-  // Destroys the SequencedWorkerPool instance, blocking until it is fully shut
-  // down, and creates a new instance.
-  void ResetPool() {
-    pool_owner_.reset(new SequencedWorkerPoolOwner(kNumWorkerThreads, "test"));
+  // Waits until no tasks are running in the SequencedWorkerPool and no
+  // reference to it remain. Then, destroys the SequencedWorkerPool.
+  void DeletePool() { pool_owner_.reset(); }
+
+  // Destroys and unregisters the registered TaskScheduler, if any.
+  void DeleteTaskScheduler() {
+    if (TaskScheduler::GetInstance()) {
+      static_cast<internal::TaskSchedulerImpl*>(TaskScheduler::GetInstance())
+          ->JoinForTesting();
+      TaskScheduler::SetInstance(nullptr);
+    }
   }
 
   void SetWillWaitForShutdownCallback(const Closure& callback) {
     pool_owner_->SetWillWaitForShutdownCallback(callback);
   }
 
   // Ensures that the given number of worker threads is created by adding
   // tasks and waiting until they complete. Worker thread creation is
   // serialized, can happen on background threads asynchronously, and doesn't
   // happen any more at shutdown. This means that if a test posts a bunch of
@@ skipping 59 matching lines @@
   }
 
  private:
   friend class base::RefCountedThreadSafe<DeletionHelper>;
   virtual ~DeletionHelper() { deleted_flag_->data = true; }
 
   const scoped_refptr<base::RefCountedData<bool> > deleted_flag_;
   DISALLOW_COPY_AND_ASSIGN(DeletionHelper);
 };
 
-void HoldPoolReference(const scoped_refptr<base::SequencedWorkerPool>& pool,
-                       const scoped_refptr<DeletionHelper>& helper) {
+void ShouldNotRun(const scoped_refptr<DeletionHelper>& helper) {
   ADD_FAILURE() << "Should never run";
 }
 
-// Tests that delayed tasks are deleted upon shutdown of the pool.
-TEST_F(SequencedWorkerPoolTest, DelayedTaskDuringShutdown) {
+// Tests that shutdown does not wait for delayed tasks.
+TEST_P(SequencedWorkerPoolTest, DelayedTaskDuringShutdown) {
   // Post something to verify the pool is started up.
   EXPECT_TRUE(pool()->PostTask(
       FROM_HERE, base::Bind(&TestTracker::FastTask, tracker(), 1)));
 
   scoped_refptr<base::RefCountedData<bool> > deleted_flag(
       new base::RefCountedData<bool>(false));
 
   base::Time posted_at(base::Time::Now());
   // Post something that shouldn't run.
   EXPECT_TRUE(pool()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&HoldPoolReference,
-                 pool(),
+      base::Bind(&ShouldNotRun,
                  make_scoped_refptr(new DeletionHelper(deleted_flag))),
       TestTimeouts::action_timeout()));
 
   std::vector<int> completion_sequence = tracker()->WaitUntilTasksComplete(1);
   ASSERT_EQ(1u, completion_sequence.size());
   ASSERT_EQ(1, completion_sequence[0]);
 
-  // Shutdown is asynchronous, so use ResetPool() to block until the pool is
-  // fully destroyed (and thus shut down).
-  ResetPool();
+  // Shutdown the pool.
+  pool()->Shutdown();
+  if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+    TaskScheduler::GetInstance()->Shutdown();
 
   // Verify that we didn't block until the task was due.
   ASSERT_LT(base::Time::Now() - posted_at, TestTimeouts::action_timeout());
 
-  // Verify that the deferred task has not only not run, but has also been
-  // destroyed.
-  ASSERT_TRUE(deleted_flag->data);
+  // Verify that the delayed task is deleted when the SequencedWorkerPool (and
+  // the TaskScheduler when applicable) are deleted.
+  EXPECT_FALSE(deleted_flag->data);
+  DeletePool();
+  if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+    DeleteTaskScheduler();
+  EXPECT_TRUE(deleted_flag->data);
 }
 
 // Tests that same-named tokens have the same ID.
-TEST_F(SequencedWorkerPoolTest, NamedTokens) {
+TEST_P(SequencedWorkerPoolTest, NamedTokens) {
   const std::string name1("hello");
   SequencedWorkerPool::SequenceToken token1 =
       pool()->GetNamedSequenceToken(name1);
 
   SequencedWorkerPool::SequenceToken token2 = pool()->GetSequenceToken();
 
   const std::string name3("goodbye");
   SequencedWorkerPool::SequenceToken token3 =
       pool()->GetNamedSequenceToken(name3);
 
   // All 3 tokens should be different.
   EXPECT_FALSE(token1.Equals(token2));
   EXPECT_FALSE(token1.Equals(token3));
   EXPECT_FALSE(token2.Equals(token3));
 
   // Requesting the same name again should give the same value.
   SequencedWorkerPool::SequenceToken token1again =
       pool()->GetNamedSequenceToken(name1);
   EXPECT_TRUE(token1.Equals(token1again));
 
   SequencedWorkerPool::SequenceToken token3again =
       pool()->GetNamedSequenceToken(name3);
   EXPECT_TRUE(token3.Equals(token3again));
 }
 
 // Tests that posting a bunch of tasks (many more than the number of worker
 // threads) runs them all.
-TEST_F(SequencedWorkerPoolTest, LotsOfTasks) {
+TEST_P(SequencedWorkerPoolTest, LotsOfTasks) {
   pool()->PostWorkerTask(FROM_HERE,
                          base::Bind(&TestTracker::SlowTask, tracker(), 0));
 
   const size_t kNumTasks = 20;
   for (size_t i = 1; i < kNumTasks; i++) {
     pool()->PostWorkerTask(FROM_HERE,
                            base::Bind(&TestTracker::FastTask, tracker(), i));
   }
 
   std::vector<int> result = tracker()->WaitUntilTasksComplete(kNumTasks);
   EXPECT_EQ(kNumTasks, result.size());
 }
 
 // Tests that posting a bunch of tasks (many more than the number of
 // worker threads) to two pools simultaneously runs them all twice.
 // This test is meant to shake out any concurrency issues between
 // pools (like histograms).
-TEST_F(SequencedWorkerPoolTest, LotsOfTasksTwoPools) {
+TEST_P(SequencedWorkerPoolTest, LotsOfTasksTwoPools) {
   SequencedWorkerPoolOwner pool1(kNumWorkerThreads, "test1");
   SequencedWorkerPoolOwner pool2(kNumWorkerThreads, "test2");
 
   base::Closure slow_task = base::Bind(&TestTracker::SlowTask, tracker(), 0);
   pool1.pool()->PostWorkerTask(FROM_HERE, slow_task);
   pool2.pool()->PostWorkerTask(FROM_HERE, slow_task);
 
   const size_t kNumTasks = 20;
   for (size_t i = 1; i < kNumTasks; i++) {
     base::Closure fast_task =
         base::Bind(&TestTracker::FastTask, tracker(), i);
     pool1.pool()->PostWorkerTask(FROM_HERE, fast_task);
     pool2.pool()->PostWorkerTask(FROM_HERE, fast_task);
   }
 
   std::vector<int> result =
       tracker()->WaitUntilTasksComplete(2*kNumTasks);
   EXPECT_EQ(2 * kNumTasks, result.size());
 }
 
 // Test that tasks with the same sequence token are executed in order but don't
 // affect other tasks.
-TEST_F(SequencedWorkerPoolTest, Sequence) {
+TEST_P(SequencedWorkerPoolTest, Sequence) {
   // Fill all the worker threads except one.
   const size_t kNumBackgroundTasks = kNumWorkerThreads - 1;
   ThreadBlocker background_blocker;
   for (size_t i = 0; i < kNumBackgroundTasks; i++) {
     pool()->PostWorkerTask(FROM_HERE,
                            base::Bind(&TestTracker::BlockTask,
                                       tracker(), i, &background_blocker));
   }
   tracker()->WaitUntilTasksBlocked(kNumBackgroundTasks);
 
@@ skipping 40 matching lines @@
   // Allow the first task of token1 to complete. This should run the second.
   blocker.Unblock(1);
   result = tracker()->WaitUntilTasksComplete(kNumBackgroundTasks + 4);
   ASSERT_EQ(kNumBackgroundTasks + 4, result.size());
   EXPECT_EQ(100, result[result.size() - 2]);
   EXPECT_EQ(101, result[result.size() - 1]);
 }
 
 // Tests that any tasks posted after Shutdown are ignored.
 // Disabled for flakiness.  See http://crbug.com/166451.
-TEST_F(SequencedWorkerPoolTest, DISABLED_IgnoresAfterShutdown) {
+TEST_P(SequencedWorkerPoolTest, DISABLED_IgnoresAfterShutdown) {
   // Start tasks to take all the threads and block them.
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
   for (size_t i = 0; i < kNumWorkerThreads; i++) {
     pool()->PostWorkerTask(FROM_HERE,
                            base::Bind(&TestTracker::BlockTask,
                                       tracker(), i, &blocker));
   }
   tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
@@ skipping 26 matching lines @@
       base::Bind(&TestTracker::FastTask, tracker(), 101),
       SequencedWorkerPool::SKIP_ON_SHUTDOWN));
   EXPECT_FALSE(pool()->PostWorkerTaskWithShutdownBehavior(
       FROM_HERE,
       base::Bind(&TestTracker::FastTask, tracker(), 102),
       SequencedWorkerPool::BLOCK_SHUTDOWN));
 
   ASSERT_EQ(old_has_work_call_count, has_work_call_count());
 }
 
-TEST_F(SequencedWorkerPoolTest, AllowsAfterShutdown) {
+TEST_P(SequencedWorkerPoolTest, AllowsAfterShutdown) {
+  // As tested by TaskSchedulerTaskTrackerTest.WillPostAndRunDuringShutdown,
+  // TaskScheduler allows tasks to be posted during shutdown. However, since it
+  // doesn't provide a way to run a callback from inside its Shutdown() method,
+  // it would be hard to make this test work with redirection enabled.
+  if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+    return;
+
   // Test that <n> new blocking tasks are allowed provided they're posted
   // by a running tasks.
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
 
   // Start tasks to take all the threads and block them.
   const int kNumBlockTasks = static_cast<int>(kNumWorkerThreads);
   for (int i = 0; i < kNumBlockTasks; ++i) {
     EXPECT_TRUE(pool()->PostWorkerTask(
         FROM_HERE,
@@ skipping 25 matching lines @@
   // Ensure that the correct number of tasks actually got run.
   tracker()->WaitUntilTasksComplete(static_cast<size_t>(
       kNumBlockTasks + kNumQueuedTasks + kNumNewBlockingTasksToAllow));
 
   // Clean up the task IDs we added and go home.
   tracker()->ClearCompleteSequence();
 }
 
 // Tests that blocking tasks can still be posted during shutdown, as long as
 // the task is not being posted within the context of a running task.
-TEST_F(SequencedWorkerPoolTest,
+TEST_P(SequencedWorkerPoolTest,
        AllowsBlockingTasksDuringShutdownOutsideOfRunningTask) {
+  // As tested by TaskSchedulerTaskTrackerTest.WillPostAndRunDuringShutdown,
+  // TaskScheduler allows tasks to be posted during shutdown. However, since it
+  // doesn't provide a way to run a callback from inside its Shutdown() method,
+  // it would be hard to make this test work with redirection enabled.
+  if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+    return;
+
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
 
   // Start tasks to take all the threads and block them.
   const int kNumBlockTasks = static_cast<int>(kNumWorkerThreads);
   for (int i = 0; i < kNumBlockTasks; ++i) {
     EXPECT_TRUE(pool()->PostWorkerTask(
         FROM_HERE,
         base::Bind(&TestTracker::BlockTask, tracker(), i, &blocker)));
   }
   tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
   // Setup to open the floodgates from within Shutdown().
   SetWillWaitForShutdownCallback(
       base::Bind(&TestTracker::PostBlockingTaskThenUnblockThreads,
                  scoped_refptr<TestTracker>(tracker()), pool(), &blocker,
                  kNumWorkerThreads));
   pool()->Shutdown(kNumWorkerThreads + 1);
 
   // Ensure that the correct number of tasks actually got run.
   tracker()->WaitUntilTasksComplete(static_cast<size_t>(kNumWorkerThreads + 1));
   tracker()->ClearCompleteSequence();
 }
 
 // Tests that unrun tasks are discarded properly according to their shutdown
 // mode.
-TEST_F(SequencedWorkerPoolTest, DiscardOnShutdown) {
+TEST_P(SequencedWorkerPoolTest, DiscardOnShutdown) {
+  // As tested by
+  // TaskSchedulerTaskTrackerTest.WillPostBeforeShutdownRunDuringShutdown, on
+  // shutdown, the TaskScheduler discards SKIP_ON_SHUTDOWN and
+  // CONTINUE_ON_SHUTDOWN tasks and runs BLOCK_SHUTDOWN tasks. However, since it
+  // doesn't provide a way to run a callback from inside its Shutdown() method,
+  // it would be hard to make this test work with redirection enabled.
+  if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+    return;
+
   // Start tasks to take all the threads and block them.
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
   for (size_t i = 0; i < kNumWorkerThreads; i++) {
     pool()->PostWorkerTask(FROM_HERE,
                            base::Bind(&TestTracker::BlockTask,
                                       tracker(), i, &blocker));
   }
   tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
@@ skipping 23 matching lines @@
 
   // The kNumWorkerThread items should have completed, plus the BLOCK_SHUTDOWN
   // one, in no particular order.
   ASSERT_EQ(kNumWorkerThreads + 1, result.size());
   for (size_t i = 0; i < kNumWorkerThreads; i++)
     EXPECT_TRUE(ContainsValue(result, static_cast<int>(i)));
   EXPECT_TRUE(ContainsValue(result, 102));
 }
 
 // Tests that CONTINUE_ON_SHUTDOWN tasks don't block shutdown.
-TEST_F(SequencedWorkerPoolTest, ContinueOnShutdown) {
+TEST_P(SequencedWorkerPoolTest, ContinueOnShutdown) {
   scoped_refptr<TaskRunner> runner(pool()->GetTaskRunnerWithShutdownBehavior(
       SequencedWorkerPool::CONTINUE_ON_SHUTDOWN));
   scoped_refptr<SequencedTaskRunner> sequenced_runner(
       pool()->GetSequencedTaskRunnerWithShutdownBehavior(
           pool()->GetSequenceToken(),
           SequencedWorkerPool::CONTINUE_ON_SHUTDOWN));
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
   pool()->PostWorkerTaskWithShutdownBehavior(
       FROM_HERE,
       base::Bind(&TestTracker::BlockTask,
                  tracker(), 0, &blocker),
       SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
   runner->PostTask(
       FROM_HERE,
       base::Bind(&TestTracker::BlockTask,
                  tracker(), 1, &blocker));
   sequenced_runner->PostTask(
       FROM_HERE,
       base::Bind(&TestTracker::BlockTask,
                  tracker(), 2, &blocker));
 
   tracker()->WaitUntilTasksBlocked(3);
 
   // This should not block. If this test hangs, it means it failed.
   pool()->Shutdown();
+  if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+    TaskScheduler::GetInstance()->Shutdown();
 
   // The task should not have completed yet.
   EXPECT_EQ(0u, tracker()->WaitUntilTasksComplete(0).size());
 
   // Posting more tasks should fail.
   EXPECT_FALSE(pool()->PostWorkerTaskWithShutdownBehavior(
       FROM_HERE, base::Bind(&TestTracker::FastTask, tracker(), 0),
       SequencedWorkerPool::CONTINUE_ON_SHUTDOWN));
   EXPECT_FALSE(runner->PostTask(
       FROM_HERE, base::Bind(&TestTracker::FastTask, tracker(), 0)));
   EXPECT_FALSE(sequenced_runner->PostTask(
       FROM_HERE, base::Bind(&TestTracker::FastTask, tracker(), 0)));
 
   // Continue the background thread and make sure the tasks can complete.
   blocker.Unblock(3);
   std::vector<int> result = tracker()->WaitUntilTasksComplete(3);
   EXPECT_EQ(3u, result.size());
 }
 
 // Tests that SKIP_ON_SHUTDOWN tasks that have been started block Shutdown
 // until they stop, but tasks not yet started do not.
-TEST_F(SequencedWorkerPoolTest, SkipOnShutdown) {
+TEST_P(SequencedWorkerPoolTest, SkipOnShutdown) {
+  // As tested by
+  // TaskSchedulerTaskTrackerTest.WillPostAndRunLongTaskBeforeShutdown and
+  // TaskSchedulerTaskTrackerTest.WillPostBeforeShutdownRunDuringShutdown, the
+  // TaskScheduler correctly handles SKIP_ON_SHUTDOWN tasks. However, since it
+  // doesn't provide a way to run a callback from inside its Shutdown() method,
+  // it would be hard to make this test work with redirection enabled.
+  if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+    return;
+
   // Start tasks to take all the threads and block them.
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
 
   // Now block all the threads with SKIP_ON_SHUTDOWN. Shutdown() should not
   // return until these tasks have completed.
   for (size_t i = 0; i < kNumWorkerThreads; i++) {
     pool()->PostWorkerTaskWithShutdownBehavior(
         FROM_HERE,
         base::Bind(&TestTracker::BlockTask, tracker(), i, &blocker),
@@ skipping 30 matching lines @@
   // allowed to complete. No additional non-blocking tasks should have been
   // started.
   ASSERT_EQ(kNumWorkerThreads, result.size());
   for (size_t i = 0; i < kNumWorkerThreads; i++)
     EXPECT_TRUE(ContainsValue(result, static_cast<int>(i)));
 }
 
 // Ensure all worker threads are created, and then trigger a spurious
 // work signal. This shouldn't cause any other work signals to be
 // triggered. This is a regression test for http://crbug.com/117469.
-TEST_F(SequencedWorkerPoolTest, SpuriousWorkSignal) {
+TEST_P(SequencedWorkerPoolTest, SpuriousWorkSignal) {
+  // This test doesn't apply when tasks are redirected to the TaskScheduler.
+  if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+    return;
+
   EnsureAllWorkersCreated();
   int old_has_work_call_count = has_work_call_count();
   pool()->SignalHasWorkForTesting();
   // This is inherently racy, but can only produce false positives.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
   EXPECT_EQ(old_has_work_call_count + 1, has_work_call_count());
 }
 
 void VerifyRunsTasksOnCurrentThread(
+    SequencedWorkerPoolRedirection redirection,
     scoped_refptr<TaskRunner> test_positive_task_runner,
     scoped_refptr<TaskRunner> test_negative_task_runner,
     SequencedWorkerPool* pool,
     SequencedWorkerPool* unused_pool) {
   EXPECT_TRUE(test_positive_task_runner->RunsTasksOnCurrentThread());
   EXPECT_FALSE(test_negative_task_runner->RunsTasksOnCurrentThread());
   EXPECT_TRUE(pool->RunsTasksOnCurrentThread());
-  EXPECT_FALSE(unused_pool->RunsTasksOnCurrentThread());
+
+  // Tasks posted to different SequencedWorkerPools may run on the same
+  // TaskScheduler threads.
+  if (redirection == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+    EXPECT_TRUE(unused_pool->RunsTasksOnCurrentThread());
+  else
+    EXPECT_FALSE(unused_pool->RunsTasksOnCurrentThread());
 }
 
 // Verify correctness of the RunsTasksOnCurrentThread() method on
 // SequencedWorkerPool and on TaskRunners it returns.
-TEST_F(SequencedWorkerPoolTest, RunsTasksOnCurrentThread) {
+TEST_P(SequencedWorkerPoolTest, RunsTasksOnCurrentThread) {
   const scoped_refptr<SequencedTaskRunner> sequenced_task_runner_1 =
       pool()->GetSequencedTaskRunner(SequencedWorkerPool::GetSequenceToken());
   const scoped_refptr<SequencedTaskRunner> sequenced_task_runner_2 =
       pool()->GetSequencedTaskRunner(SequencedWorkerPool::GetSequenceToken());
   const scoped_refptr<TaskRunner> unsequenced_task_runner =
       pool()->GetTaskRunnerWithShutdownBehavior(
           SequencedWorkerPool::BLOCK_SHUTDOWN);
 
   SequencedWorkerPoolOwner unused_pool_owner(2, "unused_pool");
 
   EXPECT_FALSE(pool()->RunsTasksOnCurrentThread());
   EXPECT_FALSE(sequenced_task_runner_1->RunsTasksOnCurrentThread());
   EXPECT_FALSE(sequenced_task_runner_2->RunsTasksOnCurrentThread());
   EXPECT_FALSE(unsequenced_task_runner->RunsTasksOnCurrentThread());
   EXPECT_FALSE(unused_pool_owner.pool()->RunsTasksOnCurrentThread());
 
   // From a task posted to |sequenced_task_runner_1|:
   // - sequenced_task_runner_1->RunsTasksOnCurrentThread() returns true.
   // - sequenced_task_runner_2->RunsTasksOnCurrentThread() returns false.
   // - pool()->RunsTasksOnCurrentThread() returns true.
   // - unused_pool_owner.pool()->RunsTasksOnCurrentThread() returns false.
   sequenced_task_runner_1->PostTask(
-      FROM_HERE,
-      base::Bind(&VerifyRunsTasksOnCurrentThread, sequenced_task_runner_1,
-                 sequenced_task_runner_2, base::RetainedRef(pool()),
-                 base::RetainedRef(unused_pool_owner.pool())));
+      FROM_HERE, base::Bind(&VerifyRunsTasksOnCurrentThread, GetParam(),
+                            sequenced_task_runner_1, sequenced_task_runner_2,
+                            base::RetainedRef(pool()),
+                            base::RetainedRef(unused_pool_owner.pool())));
   // From a task posted to |unsequenced_task_runner|:
   // - unsequenced_task_runner->RunsTasksOnCurrentThread() returns true.
   // - sequenced_task_runner_1->RunsTasksOnCurrentThread() returns false.
   // - pool()->RunsTasksOnCurrentThread() returns true.
   // - unused_pool_owner.pool()->RunsTasksOnCurrentThread() returns false.
   unsequenced_task_runner->PostTask(
-      FROM_HERE,
-      base::Bind(&VerifyRunsTasksOnCurrentThread, unsequenced_task_runner,
-                 sequenced_task_runner_1, base::RetainedRef(pool()),
-                 base::RetainedRef(unused_pool_owner.pool())));
+      FROM_HERE, base::Bind(&VerifyRunsTasksOnCurrentThread, GetParam(),
+                            unsequenced_task_runner, sequenced_task_runner_1,
+                            base::RetainedRef(pool()),
+                            base::RetainedRef(unused_pool_owner.pool())));
 }
 
 // Checks that tasks are destroyed in the right context during shutdown. If a
 // task is destroyed while SequencedWorkerPool's global lock is held,
 // SequencedWorkerPool might deadlock.
-TEST_F(SequencedWorkerPoolTest, AvoidsDeadlockOnShutdown) {
+TEST_P(SequencedWorkerPoolTest, AvoidsDeadlockOnShutdown) {
+  // Note: TaskScheduler destroys tasks when it is deleted rather than on
+  // shutdown. In production, it should never be destroyed.
+
   for (int i = 0; i < 4; ++i) {
     scoped_refptr<DestructionDeadlockChecker> checker(
         new DestructionDeadlockChecker(pool()));
     tracker()->PostRepostingTask(pool(), checker);
   }
 
   // Shutting down the pool should destroy the DestructionDeadlockCheckers,
   // which in turn should not deadlock in their destructors.
   pool()->Shutdown();
 }
 
 // Similar to the test AvoidsDeadlockOnShutdown, but there are now also
 // sequenced, blocking tasks in the queue during shutdown.
-TEST_F(SequencedWorkerPoolTest,
+TEST_P(SequencedWorkerPoolTest,
        AvoidsDeadlockOnShutdownWithSequencedBlockingTasks) {
+  // This test continuously posts BLOCK_SHUTDOWN tasks
+  // (PostRepostingBlockingTask). It can't run when tasks are redirected to
+  // TaskScheduler because TaskScheduler doesn't provide a way to limit the
+  // number of BLOCK_SHUTDOWN tasks posted during shutdown.
+  if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+    return;
+
   const std::string sequence_token_name("name");
   for (int i = 0; i < 4; ++i) {
     scoped_refptr<DestructionDeadlockChecker> checker(
         new DestructionDeadlockChecker(pool()));
     tracker()->PostRepostingTask(pool(), checker);
 
     SequencedWorkerPool::SequenceToken token1 =
         pool()->GetNamedSequenceToken(sequence_token_name);
     tracker()->PostRepostingBlockingTask(pool(), token1);
   }
 
   // Shutting down the pool should destroy the DestructionDeadlockCheckers,
   // which in turn should not deadlock in their destructors.
   pool()->Shutdown();
 }
 
 // Verify that FlushForTesting works as intended.
-TEST_F(SequencedWorkerPoolTest, FlushForTesting) {
+TEST_P(SequencedWorkerPoolTest, FlushForTesting) {
+  // FlushForTesting() can't be called when tasks are redirected to the
+  // TaskScheduler.
+  if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+    return;
+
   // Should be fine to call on a new instance.
   pool()->FlushForTesting();
 
   // Queue up a bunch of work, including  a long delayed task and
   // a task that produces additional tasks as an artifact.
   pool()->PostDelayedWorkerTask(
       FROM_HERE,
       base::Bind(&TestTracker::FastTask, tracker(), 0),
       TimeDelta::FromMinutes(5));
   pool()->PostWorkerTask(FROM_HERE,
@@ skipping 34 matching lines @@
       SequencedWorkerPool::GetSequenceTokenForCurrentThread();
   EXPECT_EQ(expected_token.ToString(), token.ToString());
 
   scoped_refptr<SequencedWorkerPool> pool =
       SequencedWorkerPool::GetWorkerPoolForCurrentThread();
   EXPECT_EQ(expected_pool, pool);
 }
 
 }  // namespace
 
-TEST_F(SequencedWorkerPoolTest, GetWorkerPoolAndSequenceTokenForCurrentThread) {
+TEST_P(SequencedWorkerPoolTest, GetWorkerPoolAndSequenceTokenForCurrentThread) {
+  // GetSequenceTokenForCurrentThread() and GetWorkerPoolForCurrentThread()
+  // respectively return an invalid token and nullptr from a task posted to a
+  // SequencedWorkerPool when redirection to TaskScheduler is enabled. These
+  // methods are only used from SequencedTaskRunnerHandle and
+  // SequenceCheckerImpl which work fine in TaskScheduler.
+  if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+    return;
+
   EnsureAllWorkersCreated();
 
   // The current thread should have neither a worker pool nor a sequence token.
   SequencedWorkerPool::SequenceToken local_token =
       SequencedWorkerPool::GetSequenceTokenForCurrentThread();
   scoped_refptr<SequencedWorkerPool> local_pool =
       SequencedWorkerPool::GetWorkerPoolForCurrentThread();
   EXPECT_FALSE(local_token.IsValid()) << local_token.ToString();
   EXPECT_FALSE(local_pool);
 
   SequencedWorkerPool::SequenceToken token1 = pool()->GetSequenceToken();
   SequencedWorkerPool::SequenceToken token2 = pool()->GetSequenceToken();
   pool()->PostSequencedWorkerTask(
       token1, FROM_HERE,
       base::Bind(&CheckWorkerPoolAndSequenceToken, pool(), token1));
   pool()->PostSequencedWorkerTask(
       token2, FROM_HERE,
       base::Bind(&CheckWorkerPoolAndSequenceToken, pool(), token2));
 
   pool()->PostWorkerTask(FROM_HERE,
                          base::Bind(&CheckWorkerPoolAndSequenceToken, pool(),
                                     SequencedWorkerPool::SequenceToken()));
 
   pool()->FlushForTesting();
 }
 
-TEST_F(SequencedWorkerPoolTest, ShutsDownCleanWithContinueOnShutdown) {
+TEST_P(SequencedWorkerPoolTest, ShutsDownCleanWithContinueOnShutdown) {
   scoped_refptr<SequencedTaskRunner> task_runner =
       pool()->GetSequencedTaskRunnerWithShutdownBehavior(
           pool()->GetSequenceToken(),
           base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 
   // Upon test exit, should shut down without hanging.
   pool()->Shutdown();
 }
 
+INSTANTIATE_TEST_CASE_P(
+    NoRedirection,
+    SequencedWorkerPoolTest,
+    ::testing::Values(SequencedWorkerPoolRedirection::NONE));
+INSTANTIATE_TEST_CASE_P(
+    RedirectionToTaskScheduler,
+    SequencedWorkerPoolTest,
+    ::testing::Values(SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER));
+
 class SequencedWorkerPoolTaskRunnerTestDelegate {
  public:
   SequencedWorkerPoolTaskRunnerTestDelegate() {}
 
   ~SequencedWorkerPoolTaskRunnerTestDelegate() {}
 
   void StartTaskRunner() {
     pool_owner_.reset(
         new SequencedWorkerPoolOwner(10, "SequencedWorkerPoolTaskRunnerTest"));
   }
@@ skipping 106 matching lines @@
     SequencedWorkerPoolSequencedTaskRunner, SequencedTaskRunnerTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolSequencedTaskRunner,
     SequencedTaskRunnerDelayedTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 
 }  // namespace
 
 }  // namespace base