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 <utility>
 
 #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 {
 
 // IMPORTANT NOTE:
 //
 // Many of these tests have failure modes where they'll hang forever. These
 // tests should not be flaky, and hanging indicates a type of failure. Do not
 // mark as flaky if they're hanging, it's likely an actual bug.
 
 namespace {
 
-const size_t kNumWorkerThreads = 3;
+constexpr size_t kNumWorkerThreads = 3;
+constexpr size_t kNumAllowedBlockShutdownTasks = 1000;
 
 // Allows a number of threads to all be blocked on the same event, and
 // provides a way to unblock a certain number of them.
 class ThreadBlocker {
  public:
   ThreadBlocker() : lock_(), cond_var_(&lock_), unblock_counter_(0) {}
 
   void Block() {
     {
       base::AutoLock lock(lock_);
@@ skipping 174 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 };
+
+void StartRedirectionToTaskScheduler(size_t num_threads) {
+  std::vector<SchedulerWorkerPoolParams> worker_pool_params;
+  worker_pool_params.emplace_back(
+      "SchedulerWorkerPoolName", ThreadPriority::NORMAL,
+      SchedulerWorkerPoolParams::IORestriction::ALLOWED, num_threads,
+      TimeDelta::Max());
+  TaskScheduler::CreateAndSetDefaultTaskScheduler(
+      std::move(worker_pool_params),
+      base::Bind([](const TaskTraits&) -> size_t { return 0U; }));
+  SequencedWorkerPool::ResetRedirectToTaskSchedulerForProcessForTesting();
+  SequencedWorkerPool::RedirectToTaskSchedulerForProcess();
+}
+
+void StopRedirectionToTaskScheduler() {
+  SequencedWorkerPool::ResetRedirectToTaskSchedulerForProcessForTesting();
+  static_cast<internal::TaskSchedulerImpl*>(TaskScheduler::GetInstance())
+      ->JoinForTesting();
+  TaskScheduler::SetInstance(nullptr);
+}
+
+class SequencedWorkerPoolTest
+    : public testing::TestWithParam<SequencedWorkerPoolRedirection> {
  public:
   SequencedWorkerPoolTest()
       : tracker_(new TestTracker) {
     ResetPool();
   }
 
+  void SetUp() override {
+    if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+      StartRedirectionToTaskScheduler(kNumWorkerThreads);
+  }
+
+  void TearDown() override {
+    if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+      StopRedirectionToTaskScheduler();
+  }
+
   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"));
   }
@@ skipping 74 matching lines @@
   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) {
   ADD_FAILURE() << "Should never run";
 }
 
 // Tests that delayed tasks are deleted upon shutdown of the pool.
-TEST_F(SequencedWorkerPoolTest, DelayedTaskDuringShutdown) {
+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(),
                  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();
+  if (GetParam() == SequencedWorkerPoolRedirection::NONE) {
+    // Wait until the pool is fully shut down and destroyed.
+    ResetPool();
+  } else {
+    // Wait until the TaskScheduler is shut down.
+    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);
+  // If tasks aren't redirected to the TaskScheduler, verify that the deferred
+  // task has not only not run, but has also been destroyed. The TaskScheduler
+  // doesn't destroy its tasks on shutdown.
+  if (GetParam() == SequencedWorkerPoolRedirection::NONE)
+    ASSERT_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) {
+  // TaskScheduler supports posting new BLOCK_SHUTDOWN tasks during shutdown
+  // (see TaskSchedulerTaskTrackerTest.WillPostAndRunDuringShutdown). 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) {
+  // TaskScheduler supports posting new BLOCK_SHUTDOWN tasks during shutdown
+  // (see TaskSchedulerTaskTrackerTest.WillPostAndRunDuringShutdown). 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) {
+  // Since TaskScheduler 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.
+  // Shutting down the pool should not be blocked by CONTINUE_ON_SHUTDOWN tasks.
+  // If this test hangs, it means it failed.
+  // Note: This is a no-op when redirection to the TaskScheduler is enabled.
   pool()->Shutdown();
 
+  // Shutting down the TaskScheduler should not be blocked by
+  // CONTINUE_ON_SHUTDOWN tasks.
+  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) {
+  // Since TaskScheduler 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 IsRunningOnCurrentThreadTask(
     SequencedWorkerPool::SequenceToken test_positive_token,
     SequencedWorkerPool::SequenceToken test_negative_token,
     SequencedWorkerPool* pool,
-    SequencedWorkerPool* unused_pool) {
+    SequencedWorkerPool* unused_pool,
+    SequencedWorkerPoolRedirection redirection) {
   EXPECT_TRUE(pool->RunsTasksOnCurrentThread());
   EXPECT_TRUE(pool->IsRunningSequenceOnCurrentThread(test_positive_token));
-  EXPECT_FALSE(pool->IsRunningSequenceOnCurrentThread(test_negative_token));
-  EXPECT_FALSE(unused_pool->RunsTasksOnCurrentThread());
-  EXPECT_FALSE(
-      unused_pool->IsRunningSequenceOnCurrentThread(test_positive_token));
-  EXPECT_FALSE(
-      unused_pool->IsRunningSequenceOnCurrentThread(test_negative_token));
+
+  if (redirection == SequencedWorkerPoolRedirection::NONE) {
+    // Tasks posted to different pools may run on the same threads when
+    // redirection to the TaskScheduler is enabled.
+    EXPECT_FALSE(unused_pool->RunsTasksOnCurrentThread());
+
+    // TODO(gab): When redirection to the TaskScheduler is enabled,
+    // IsRunningSequenceOnCurrentThread() returns true if a task bound to the
+    // provided sequence token *could* run on the current thread. Once the
+    // method is fixed to return true only when called from a thread that is
+    // *currently running* a task bound to the provided sequence token, move
+    // these tests out of the conditional.
+    EXPECT_FALSE(pool->IsRunningSequenceOnCurrentThread(test_negative_token));
+    EXPECT_FALSE(
+        unused_pool->IsRunningSequenceOnCurrentThread(test_positive_token));
+    EXPECT_FALSE(
+        unused_pool->IsRunningSequenceOnCurrentThread(test_negative_token));
+  }
 }
 
 // Verify correctness of the IsRunningSequenceOnCurrentThread method.
-TEST_F(SequencedWorkerPoolTest, IsRunningOnCurrentThread) {
+TEST_P(SequencedWorkerPoolTest, IsRunningOnCurrentThread) {
   SequencedWorkerPool::SequenceToken token1 = pool()->GetSequenceToken();
   SequencedWorkerPool::SequenceToken token2 = pool()->GetSequenceToken();
   SequencedWorkerPool::SequenceToken unsequenced_token;
 
   SequencedWorkerPoolOwner unused_pool_owner(2, "unused_pool");
 
   EXPECT_FALSE(pool()->RunsTasksOnCurrentThread());
   EXPECT_FALSE(pool()->IsRunningSequenceOnCurrentThread(token1));
   EXPECT_FALSE(pool()->IsRunningSequenceOnCurrentThread(token2));
   EXPECT_FALSE(pool()->IsRunningSequenceOnCurrentThread(unsequenced_token));
   EXPECT_FALSE(unused_pool_owner.pool()->RunsTasksOnCurrentThread());
   EXPECT_FALSE(
       unused_pool_owner.pool()->IsRunningSequenceOnCurrentThread(token1));
   EXPECT_FALSE(
       unused_pool_owner.pool()->IsRunningSequenceOnCurrentThread(token2));
   EXPECT_FALSE(unused_pool_owner.pool()->IsRunningSequenceOnCurrentThread(
       unsequenced_token));
 
   pool()->PostSequencedWorkerTask(
       token1, FROM_HERE,
       base::Bind(&IsRunningOnCurrentThreadTask, token1, token2,
                  base::RetainedRef(pool()),
-                 base::RetainedRef(unused_pool_owner.pool())));
+                 base::RetainedRef(unused_pool_owner.pool()), GetParam()));
   pool()->PostSequencedWorkerTask(
       token2, FROM_HERE,
       base::Bind(&IsRunningOnCurrentThreadTask, token2, unsequenced_token,
                  base::RetainedRef(pool()),
-                 base::RetainedRef(unused_pool_owner.pool())));
+                 base::RetainedRef(unused_pool_owner.pool()), GetParam()));
   pool()->PostWorkerTask(
-      FROM_HERE, base::Bind(&IsRunningOnCurrentThreadTask, unsequenced_token,
-                            token1, base::RetainedRef(pool()),
-                            base::RetainedRef(unused_pool_owner.pool())));
+      FROM_HERE,
+      base::Bind(&IsRunningOnCurrentThreadTask, unsequenced_token, token1,
+                 base::RetainedRef(pool()),
+                 base::RetainedRef(unused_pool_owner.pool()), GetParam()));
 }
 
 // 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) {
+  // Since the TaskScheduler doesn't delete pending tasks on shutdown, this test
+  // doesn't apply when tasks are redirected to the TaskScheduler.
+  if (GetParam() == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+    return;
+
   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) {
+  // Since the TaskScheduler doesn't delete pending tasks on shutdown, this test
+  // doesn't apply when tasks are redirected to the TaskScheduler.
+  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 cannot 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 18 matching lines @@
   // Should be fine to call on an idle instance with all threads created, and
   // spamming the method shouldn't deadlock or confuse the class.
   pool()->FlushForTesting();
   pool()->FlushForTesting();
 
   // Should be fine to call after shutdown too.
   pool()->Shutdown();
   pool()->FlushForTesting();
 }
 
+INSTANTIATE_TEST_CASE_P(
+    NoRedirection,
+    SequencedWorkerPoolTest,
+    ::testing::Values(SequencedWorkerPoolRedirection::NONE));
+INSTANTIATE_TEST_CASE_P(
+    RedirectionToTaskScheduler,
+    SequencedWorkerPoolTest,
+    ::testing::Values(SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER));
+
 namespace {
 
 void CheckWorkerPoolAndSequenceToken(
       const scoped_refptr<SequencedWorkerPool>& expected_pool,
     SequencedWorkerPool::SequenceToken expected_token) {
   SequencedWorkerPool::SequenceToken token =
       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) {
+  // SequencedWorkerPool::GetSequenceTokenForCurrentThread() isn't supported
+  // when tasks are redirected to the TaskScheduler. It will never be supported
+  // since its only uses are in SequencedTaskRunnerHandle and
+  // SequenceCheckerImpl which don't need it when redirection is enabled.
+  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) {
-  scoped_refptr<SequencedTaskRunner> task_runner =
-      pool()->GetSequencedTaskRunnerWithShutdownBehavior(
-          pool()->GetSequenceToken(),
-          base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
-
-  // Upon test exit, should shut down without hanging.
-  pool()->Shutdown();
-}
-
+template <SequencedWorkerPoolRedirection redirection>
 class SequencedWorkerPoolTaskRunnerTestDelegate {
  public:
   SequencedWorkerPoolTaskRunnerTestDelegate() {}
 
   ~SequencedWorkerPoolTaskRunnerTestDelegate() {}
 
   void StartTaskRunner() {
-    pool_owner_.reset(
-        new SequencedWorkerPoolOwner(10, "SequencedWorkerPoolTaskRunnerTest"));
+    pool_owner_.reset(new SequencedWorkerPoolOwner(
+        kNumWorkerThreads, "SequencedWorkerPoolTaskRunnerTest"));
+
+    if (redirection == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+      StartRedirectionToTaskScheduler(kNumWorkerThreads);
   }
 
   scoped_refptr<SequencedWorkerPool> GetTaskRunner() {
     return pool_owner_->pool();
   }
 
   void StopTaskRunner() {
-    // Make sure all tasks are run before shutting down. Delayed tasks are
-    // not run, they're simply deleted.
-    pool_owner_->pool()->FlushForTesting();
-    pool_owner_->pool()->Shutdown();
-    // Don't reset |pool_owner_| here, as the test may still hold a
-    // reference to the pool.
+    pool_owner_->pool()->Shutdown(kNumAllowedBlockShutdownTasks);
+    if (redirection == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER) {
+      // When redirection to the TaskScheduler is enabled, shutting down the
+      // pool is a no-op. It is necessary to shut down the TaskScheduler to make
+      // sure that all tasks have been executed.
+      TaskScheduler::GetInstance()->Shutdown();
+      StopRedirectionToTaskScheduler();
+    }
+    // Don't reset |pool_owner_| here, as the test may still hold a reference to
+    // the pool.
   }
 
  private:
   MessageLoop message_loop_;
   std::unique_ptr<SequencedWorkerPoolOwner> pool_owner_;
 };
 
+INSTANTIATE_TYPED_TEST_CASE_P(SequencedWorkerPool,
+                              TaskRunnerTest,
+                              SequencedWorkerPoolTaskRunnerTestDelegate<
+                                  SequencedWorkerPoolRedirection::NONE>);
+INSTANTIATE_TYPED_TEST_CASE_P(SequencedWorkerPool,
+                              TaskRunnerAffinityTest,
+                              SequencedWorkerPoolTaskRunnerTestDelegate<
+                                  SequencedWorkerPoolRedirection::NONE>);
 INSTANTIATE_TYPED_TEST_CASE_P(
-    SequencedWorkerPool, TaskRunnerTest,
-    SequencedWorkerPoolTaskRunnerTestDelegate);
-INSTANTIATE_TYPED_TEST_CASE_P(SequencedWorkerPool, TaskRunnerAffinityTest,
-                              SequencedWorkerPoolTaskRunnerTestDelegate);
+    SequencedWorkerPoolToTaskScheduler,
+    TaskRunnerTest,
+    SequencedWorkerPoolTaskRunnerTestDelegate<
+        SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER>);
+INSTANTIATE_TYPED_TEST_CASE_P(
+    SequencedWorkerPoolToTaskScheduler,
+    TaskRunnerAffinityTest,
+    SequencedWorkerPoolTaskRunnerTestDelegate<
+        SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER>);
 
+template <SequencedWorkerPoolRedirection redirection>
 class SequencedWorkerPoolTaskRunnerWithShutdownBehaviorTestDelegate {
  public:
   SequencedWorkerPoolTaskRunnerWithShutdownBehaviorTestDelegate() {}
 
   ~SequencedWorkerPoolTaskRunnerWithShutdownBehaviorTestDelegate() {
   }
 
   void StartTaskRunner() {
-    pool_owner_.reset(
-        new SequencedWorkerPoolOwner(10, "SequencedWorkerPoolTaskRunnerTest"));
+    pool_owner_.reset(new SequencedWorkerPoolOwner(
+        kNumWorkerThreads, "SequencedWorkerPoolSequencedTaskRunnerTest"));
     task_runner_ = pool_owner_->pool()->GetTaskRunnerWithShutdownBehavior(
         SequencedWorkerPool::BLOCK_SHUTDOWN);
+
+    if (redirection == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+      StartRedirectionToTaskScheduler(kNumWorkerThreads);
   }
 
   scoped_refptr<TaskRunner> GetTaskRunner() {
     return task_runner_;
   }
 
   void StopTaskRunner() {
-    // Make sure all tasks are run before shutting down. Delayed tasks are
-    // not run, they're simply deleted.
-    pool_owner_->pool()->FlushForTesting();
-    pool_owner_->pool()->Shutdown();
-    // Don't reset |pool_owner_| here, as the test may still hold a
-    // reference to the pool.
+    pool_owner_->pool()->Shutdown(kNumAllowedBlockShutdownTasks);
+    if (redirection == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER) {
+      // When redirection to the TaskScheduler is enabled, shutting down the
+      // pool is a no-op. It is necessary to shut down the TaskScheduler to make
+      // sure that all tasks have been executed.
+      TaskScheduler::GetInstance()->Shutdown();
+      StopRedirectionToTaskScheduler();
+    }
+    // Don't reset |pool_owner_| here, as the test may still hold a reference to
+    // the pool.
   }
 
  private:
   MessageLoop message_loop_;
   std::unique_ptr<SequencedWorkerPoolOwner> pool_owner_;
   scoped_refptr<TaskRunner> task_runner_;
 };
 
 INSTANTIATE_TYPED_TEST_CASE_P(
-    SequencedWorkerPoolTaskRunner, TaskRunnerTest,
-    SequencedWorkerPoolTaskRunnerWithShutdownBehaviorTestDelegate);
+    SequencedWorkerPoolTaskRunner,
+    TaskRunnerTest,
+    SequencedWorkerPoolTaskRunnerWithShutdownBehaviorTestDelegate<
+        SequencedWorkerPoolRedirection::NONE>);
 INSTANTIATE_TYPED_TEST_CASE_P(
-    SequencedWorkerPoolTaskRunner, TaskRunnerAffinityTest,
-    SequencedWorkerPoolTaskRunnerWithShutdownBehaviorTestDelegate);
+    SequencedWorkerPoolTaskRunner,
+    TaskRunnerAffinityTest,
+    SequencedWorkerPoolTaskRunnerWithShutdownBehaviorTestDelegate<
+        SequencedWorkerPoolRedirection::NONE>);
+INSTANTIATE_TYPED_TEST_CASE_P(
+    SequencedWorkerPoolTaskRunnerToTaskScheduler,
+    TaskRunnerTest,
+    SequencedWorkerPoolTaskRunnerWithShutdownBehaviorTestDelegate<
+        SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER>);
+INSTANTIATE_TYPED_TEST_CASE_P(
+    SequencedWorkerPoolTaskRunnerToTaskScheduler,
+    TaskRunnerAffinityTest,
+    SequencedWorkerPoolTaskRunnerWithShutdownBehaviorTestDelegate<
+        SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER>);
 
+template <SequencedWorkerPoolRedirection redirection>
 class SequencedWorkerPoolSequencedTaskRunnerTestDelegate {
  public:
   SequencedWorkerPoolSequencedTaskRunnerTestDelegate() {}
 
   ~SequencedWorkerPoolSequencedTaskRunnerTestDelegate() {
   }
 
   void StartTaskRunner() {
     pool_owner_.reset(new SequencedWorkerPoolOwner(
-        10, "SequencedWorkerPoolSequencedTaskRunnerTest"));
+        kNumWorkerThreads, "SequencedWorkerPoolSequencedTaskRunnerTest"));
     task_runner_ = pool_owner_->pool()->GetSequencedTaskRunner(
         pool_owner_->pool()->GetSequenceToken());
+
+    if (redirection == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER)
+      StartRedirectionToTaskScheduler(kNumWorkerThreads);
   }
 
   scoped_refptr<SequencedTaskRunner> GetTaskRunner() {
     return task_runner_;
   }
 
   void StopTaskRunner() {
-    // Make sure all tasks are run before shutting down. Delayed tasks are
-    // not run, they're simply deleted.
-    pool_owner_->pool()->FlushForTesting();
-    pool_owner_->pool()->Shutdown();
-    // Don't reset |pool_owner_| here, as the test may still hold a
-    // reference to the pool.
+    pool_owner_->pool()->Shutdown(kNumAllowedBlockShutdownTasks);
+    if (redirection == SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER) {
+      // When redirection to the TaskScheduler is enabled, shutting down the
+      // pool is a no-op. It is necessary to shut down the TaskScheduler to make
+      // sure that all tasks have been executed.
+      TaskScheduler::GetInstance()->Shutdown();
+      StopRedirectionToTaskScheduler();
+    }
+    // Don't reset |pool_owner_| here, as the test may still hold a reference to
+    // the pool.
   }
 
  private:
   MessageLoop message_loop_;
   std::unique_ptr<SequencedWorkerPoolOwner> pool_owner_;
   scoped_refptr<SequencedTaskRunner> task_runner_;
 };
 
 INSTANTIATE_TYPED_TEST_CASE_P(
-    SequencedWorkerPoolSequencedTaskRunner, TaskRunnerTest,
-    SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
+    SequencedWorkerPoolSequencedTaskRunner,
+    TaskRunnerTest,
+    SequencedWorkerPoolSequencedTaskRunnerTestDelegate<
+        SequencedWorkerPoolRedirection::NONE>);
 INSTANTIATE_TYPED_TEST_CASE_P(
-    SequencedWorkerPoolSequencedTaskRunner, TaskRunnerAffinityTest,
-    SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
+    SequencedWorkerPoolSequencedTaskRunner,
+    TaskRunnerAffinityTest,
+    SequencedWorkerPoolSequencedTaskRunnerTestDelegate<
+        SequencedWorkerPoolRedirection::NONE>);
+INSTANTIATE_TYPED_TEST_CASE_P(
+    SequencedWorkerPoolSequencedTaskRunnerToTaskScheduler,
+    TaskRunnerAffinityTest,
+    SequencedWorkerPoolSequencedTaskRunnerTestDelegate<
+        SequencedWorkerPoolRedirection::TO_TASK_SCHEDULER>);
 
 INSTANTIATE_TYPED_TEST_CASE_P(
-    SequencedWorkerPoolSequencedTaskRunner, SequencedTaskRunnerTest,
-    SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
+    SequencedWorkerPoolSequencedTaskRunner,
+    SequencedTaskRunnerTest,
+    SequencedWorkerPoolSequencedTaskRunnerTestDelegate<
+        SequencedWorkerPoolRedirection::NONE>);
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolSequencedTaskRunner,
     SequencedTaskRunnerDelayedTest,
-    SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
+    SequencedWorkerPoolSequencedTaskRunnerTestDelegate<
+        SequencedWorkerPoolRedirection::NONE>);
+
+// Don't run TaskRunnerTest, SequencedTaskRunnerTest and
+// SequencedTaskRunnerDelayedTest with sequenced tasks redirected to the
+// TaskScheduler. These tests post tasks with and without delays which result in
+// getting tasks with different shutdown behaviors in the same sequence. That
+// isn't supported by the TaskScheduler.
 
 }  // namespace
 
 }  // namespace base