Flush all TaskScheduler<->MainLoop tasks 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 "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) {}
 
 TestBrowserThreadBundle::TestBrowserThreadBundle(int options)
     : options_(options), threads_created_(false) {
   Init();
 }
@@ skipping 25 matching lines @@
   db_thread_->Stop();
   base::RunLoop().RunUntilIdle();
   // 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();
 
+  // This is required to ensure we run all remaining tasks in an atomic step
+  // (instead of ~ScopedAsyncTaskScheduler() followed by another
+  // RunLoop().RunUntilIdle()). Otherwise If a pending task in
+  // |scoped_async_task_scheduler_| posts to |message_loop_|, that task can then
+  // post back to |scoped_async_task_scheduler_| after the former was destroyed.
+  // This is a bit different than production where the main thread is not
+  // flushed after it's done running but this approach is preferred in unit
+  // tests as running more tasks can merely uncover more issues (e.g. if a bad
+  // tasks is posted but never blocked upon it could make a test flaky whereas
+  // by flushing we guarantee it will blow up).
+  RunAllBlockingPoolTasksUntilIdle();
+
   scoped_async_task_scheduler_.reset();
-
-  base::RunLoop().RunUntilIdle();
   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();
 }
 
 void TestBrowserThreadBundle::Init() {
   // Check that the UI thread hasn't already been initialized. This will fail if
@@ skipping 66 matching lines @@
     io_thread_->StartIOThread();
   } else {
     io_thread_ = base::MakeUnique<TestBrowserThread>(
         BrowserThread::IO, base::MessageLoop::current());
   }
 
   threads_created_ = true;
 }
 
 }  // namespace content