Enable redirection of SequencedWorkerPool to TaskScheduler in TestBrowserThreadBundle.

content/public/test/test_browser_thread_bundle.cc

 // Copyright 2013 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 "content/public/test/test_browser_thread_bundle.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/task_scheduler/task_scheduler.h"
 #include "base/test/scoped_async_task_scheduler.h"
+#include "base/threading/sequenced_worker_pool.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_utils.h"
 
 namespace content {
 
 TestBrowserThreadBundle::TestBrowserThreadBundle()
     : TestBrowserThreadBundle(DEFAULT) {}
 
@@ skipping 48 matching lines @@
   // by flushing we guarantee it will blow up).
   RunAllBlockingPoolTasksUntilIdle();
 
   scoped_async_task_scheduler_.reset();
   CHECK(base::MessageLoop::current()->IsIdleForTesting());
 
   // |message_loop_| needs to explicitly go away before fake threads in order
   // for DestructionObservers hooked to |message_loop_| to be able to invoke
   // BrowserThread::CurrentlyOn() -- ref. ~TestBrowserThread().
   message_loop_.reset();
+
+  // Disable redirection of SequencedWorkerPools to TaskScheduler. This is
+  // required in order to reset global state so that tests following this one in
+  // this process can still manage their own SequencedWorkerPool without using
+  // TestBrowserThreadBundle.
+  base::SequencedWorkerPool::EnableForProcess();
 }
 
 void TestBrowserThreadBundle::Init() {
   // Check that the UI thread hasn't already been initialized. This will fail if
   // multiple TestBrowserThreadBundles are initialized in the same scope.
   CHECK(!BrowserThread::IsThreadInitialized(BrowserThread::UI));
 
   // Check for conflicting options can't have two IO threads.
   CHECK(!(options_ & IO_MAINLOOP) || !(options_ & REAL_IO_THREAD));
   // There must be a thread to start to use DONT_CREATE_THREADS
@@ skipping 25 matching lines @@
   // TaskScheduler can sometimes be externally provided by a
   // base::test::ScopedTaskEnvironment in a parent fixture. In that case it's
   // expected to have provided the MessageLoop as well (in which case
   // |message_loop_| remains null in Init()).
   CHECK(!base::TaskScheduler::GetInstance() || !message_loop_);
   if (!base::TaskScheduler::GetInstance()) {
     scoped_async_task_scheduler_ =
         base::MakeUnique<base::test::ScopedAsyncTaskScheduler>();
   }
 
+  // Enable redirection of SequencedWorkerPools to TaskScheduler.
+  base::SequencedWorkerPool::EnableWithRedirectionToTaskSchedulerForProcess();
+
   if (options_ & REAL_DB_THREAD) {
     db_thread_ = base::MakeUnique<TestBrowserThread>(BrowserThread::DB);
     db_thread_->Start();
   } else {
     db_thread_ = base::MakeUnique<TestBrowserThread>(
         BrowserThread::DB, base::MessageLoop::current());
   }
 
   if (options_ & REAL_FILE_THREAD) {
     file_thread_ = base::MakeUnique<TestBrowserThread>(BrowserThread::FILE);
@@ skipping 15 matching lines @@
     io_thread_->StartIOThread();
   } else {
     io_thread_ = base::MakeUnique<TestBrowserThread>(
         BrowserThread::IO, base::MessageLoop::current());
   }
 
   threads_created_ = true;
 }
 
 }  // namespace content