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/test/scoped_async_task_scheduler.h"
+#include "base/threading/sequenced_worker_pool.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/public/test/test_browser_thread.h"
 
 namespace content {
 
 TestBrowserThreadBundle::TestBrowserThreadBundle()
     : TestBrowserThreadBundle(DEFAULT) {}
 
 TestBrowserThreadBundle::TestBrowserThreadBundle(int options)
     : options_(options), threads_created_(false) {
@@ skipping 29 matching lines @@
   // This is the point at which we normally shut down the thread pool. So flush
   // it again in case any shutdown tasks have been posted to the pool from the
   // threads above.
   BrowserThreadImpl::FlushThreadPoolHelperForTesting();
   base::RunLoop().RunUntilIdle();
   ui_thread_->Stop();
   base::RunLoop().RunUntilIdle();
 
   scoped_async_task_scheduler_.reset();
 
+  // Disable redirection of SequencedWorkerPools to TaskScheduler.
+  base::SequencedWorkerPool::EnableForProcess();

[gab, 2017/03/22 16:23:30]

Do we need this? Sounds better to have tasks be redirected in a void and explode
than lazily instantiating a very late SequencedWorkerPool w/ workers.

[fdoray, 2017/04/03 14:57:28]

In TestBrowserThreadBundle::CreateThreads(), we enable redirection of
SequencedWorkerPool to TaskScheduler. It is important to disable this
redirection here to bring back the process to its original state.

Some tests instantiate their own SequencedWorkerPool (e.g.
https://cs.chromium.org/chromium/src/components/update_client/update_client_u...).
Without this, they will try to redirect tasks to a non-existent TaskScheduler
and crash.

[gab, 2017/04/03 16:56:17]

I see expand comment here then, something like:

// 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.

+
   // |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().
   CHECK(message_loop_->IsIdleForTesting());
   message_loop_.reset();
 }
 
 void TestBrowserThreadBundle::Init() {
   // Check for conflicting options can't have two IO threads.
   CHECK(!(options_ & IO_MAINLOOP) || !(options_ & REAL_IO_THREAD));
@@ skipping 15 matching lines @@
     CreateThreads();
 }
 
 // This method mimics the work done in BrowserMainLoop::CreateThreads().
 void TestBrowserThreadBundle::CreateThreads() {
   DCHECK(!threads_created_);
 
   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_.reset(new TestBrowserThread(BrowserThread::DB));
     db_thread_->Start();
   } else {
     db_thread_.reset(
         new TestBrowserThread(BrowserThread::DB, message_loop_.get()));
   }
 
   if (options_ & REAL_FILE_THREAD) {
     file_thread_.reset(new TestBrowserThread(BrowserThread::FILE));
@@ skipping 15 matching lines @@
     io_thread_->StartIOThread();
   } else {
     io_thread_.reset(
         new TestBrowserThread(BrowserThread::IO, message_loop_.get()));
   }
 
   threads_created_ = true;
 }
 
 }  // namespace content