Remove usage of SequencedWorkerPoolOwner.

Replace usage with ScopedTaskEnvironment.

TBR=glider@chromium.org

Bug: 667892
Change-Id: I93d25b143a39f8966d425d98954bec28c710857a
Reviewed-on: https://chromium-review.googlesource.com/881532Reviewed-by: François Doray <fdoray@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Ahmed Fakhry <afakhry@chromium.org>
Reviewed-by: Pavel Yatsuk <pavely@chromium.org>
Reviewed-by: Gabriel Charette <gab@chromium.org>
Commit-Queue: Gabriel Charette <gab@chromium.org>
Cr-Commit-Position: refs/heads/master@{#532260}

ash/display/display_color_manager_chromeos_unittest.cc

@@ -10,9 +10,9 @@
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/pattern.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/test/scoped_path_override.h"
 #include "base/test/scoped_task_environment.h"
-#include "base/test/sequenced_worker_pool_owner.h"
 #include "chromeos/chromeos_paths.h"
 #include "components/quirks/quirks_manager.h"
 #include "net/url_request/url_request_context_getter.h"
@@ -104,8 +104,6 @@ class QuirksManagerDelegateTestImpl : public quirks::QuirksManager::Delegate {
 class DisplayColorManagerTest : public testing::Test {
  public:
   void SetUp() override {
-    pool_owner_.reset(
-        new base::SequencedWorkerPoolOwner(3, "DisplayColorManagerTest"));
     log_.reset(new display::test::ActionLogger());
 
     native_display_delegate_ =
@@ -128,12 +126,11 @@ class DisplayColorManagerTest : public testing::Test {
     quirks::QuirksManager::Initialize(
         std::unique_ptr<quirks::QuirksManager::Delegate>(
             new QuirksManagerDelegateTestImpl(color_path_)),
-        pool_owner_->pool().get(), nullptr, nullptr);
+        base::CreateTaskRunnerWithTraits({base::MayBlock()}), nullptr, nullptr);
   }
 
   void TearDown() override {
     quirks::QuirksManager::Shutdown();
-    pool_owner_->pool()->Shutdown();
   }
 
   void WaitOnColorCalibration() {
@@ -147,7 +144,6 @@ class DisplayColorManagerTest : public testing::Test {
 
  protected:
   base::test::ScopedTaskEnvironment scoped_task_environment_;
-  std::unique_ptr<base::SequencedWorkerPoolOwner> pool_owner_;
   std::unique_ptr<base::ScopedPathOverride> path_override_;
   base::FilePath color_path_;
   std::unique_ptr<display::test::ActionLogger> log_;

base/test/launcher/test_launcher.cc

@@ -38,14 +38,14 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/task_scheduler/task_scheduler.h"
 #include "base/test/gtest_util.h"
 #include "base/test/launcher/test_launcher_tracer.h"
 #include "base/test/launcher/test_results_tracker.h"
-#include "base/test/sequenced_worker_pool_owner.h"
 #include "base/test/test_switches.h"
 #include "base/test/test_timeouts.h"
-#include "base/threading/sequenced_worker_pool.h"
-#include "base/threading/thread.h"
+#include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
@@ -125,6 +125,27 @@ TestLauncherTracer* GetTestLauncherTracer() {
   return tracer;
 }
 
+// Creates and starts a TaskScheduler with |num_parallel_jobs| dedicated to
+// foreground blocking tasks (corresponds to the traits used to launch and wait
+// for child processes).
+void CreateAndStartTaskScheduler(int num_parallel_jobs) {
+  // These values are taken from TaskScheduler::StartWithDefaultParams(), which
+  // is not used directly to allow a custom number of threads in the foreground
+  // blocking pool.
+  constexpr int kMaxBackgroundThreads = 1;
+  constexpr int kMaxBackgroundBlockingThreads = 2;
+  const int max_foreground_threads =
+      std::max(1, base::SysInfo::NumberOfProcessors());
+  constexpr base::TimeDelta kSuggestedReclaimTime =
+      base::TimeDelta::FromSeconds(30);
+  base::TaskScheduler::Create("TestLauncher");
+  base::TaskScheduler::GetInstance()->Start(
+      {{kMaxBackgroundThreads, kSuggestedReclaimTime},
+       {kMaxBackgroundBlockingThreads, kSuggestedReclaimTime},
+       {max_foreground_threads, kSuggestedReclaimTime},
+       {num_parallel_jobs, kSuggestedReclaimTime}});
+}
+
 // TODO(fuchsia): Fuchsia does not have POSIX signals, but equivalent
 // functionality will probably be necessary eventually. See
 // https://crbug.com/706592.
@@ -358,7 +379,14 @@ int LaunchChildTestProcessWithOptions(const CommandLine& command_line,
     observer->OnLaunched(process.Handle(), process.Pid());
 
   int exit_code = 0;
-  if (!process.WaitForExitWithTimeout(timeout, &exit_code)) {
+  bool did_exit = false;
+
+  {
+    base::ScopedAllowBaseSyncPrimitivesForTesting allow_base_sync_primitives;
+    did_exit = process.WaitForExitWithTimeout(timeout, &exit_code);
+  }
+
+  if (!did_exit) {
     if (observer)
       observer->OnTimedOut(command_line);
 
@@ -545,7 +573,9 @@ TestLauncher::TestLauncher(TestLauncherDelegate* launcher_delegate,
                       &TestLauncher::OnOutputTimeout),
       parallel_jobs_(parallel_jobs) {}
 
-TestLauncher::~TestLauncher() = default;
+TestLauncher::~TestLauncher() {
+  base::TaskScheduler::GetInstance()->Shutdown();
+}
 
 bool TestLauncher::Run() {
   if (!Init())
@@ -607,8 +637,8 @@ void TestLauncher::LaunchChildGTestProcess(
   // JSON summary.
   bool redirect_stdio = (parallel_jobs_ > 1) || BotModeEnabled();
 
-  GetTaskRunner()->PostTask(
-      FROM_HERE,
+  PostTaskWithTraits(
+      FROM_HERE, {MayBlock(), TaskShutdownBehavior::BLOCK_SHUTDOWN},
       BindOnce(&DoLaunchChildTestProcess, new_command_line, timeout, options,
                redirect_stdio, RetainedRef(ThreadTaskRunnerHandle::Get()),
                base::Passed(std::move(observer))));
@@ -893,18 +923,8 @@ bool TestLauncher::Init() {
 
   fprintf(stdout, "Using %" PRIuS " parallel jobs.\n", parallel_jobs_);
   fflush(stdout);
-  if (parallel_jobs_ > 1U) {
-    // Allow usage of SequencedWorkerPool to launch test processes.
-    // TODO(fdoray): Remove this once the SequencedWorkerPool to TaskScheduler
-    // redirection experiment concludes https://crbug.com/622400.
-    SequencedWorkerPool::EnableForProcess();
-
-    worker_pool_owner_ = std::make_unique<SequencedWorkerPoolOwner>(
-        parallel_jobs_, "test_launcher");
-  } else {
-    worker_thread_ = std::make_unique<Thread>("test_launcher");
-    worker_thread_->Start();
-  }
+
+  CreateAndStartTaskScheduler(static_cast<int>(parallel_jobs_));
 
   std::vector<std::string> positive_file_filter;
   std::vector<std::string> positive_gtest_filter;
@@ -1258,17 +1278,6 @@ void TestLauncher::OnOutputTimeout() {
   watchdog_timer_.Reset();
 }
 
-scoped_refptr<TaskRunner> TestLauncher::GetTaskRunner() {
-  // One and only one of |worker_pool_owner_| or |worker_thread_| should be
-  // ready.
-  DCHECK_NE(!!worker_pool_owner_, !!worker_thread_);
-
-  if (worker_pool_owner_)
-    return worker_pool_owner_->pool();
-  DCHECK(worker_thread_->IsRunning());
-  return worker_thread_->task_runner();
-}
-
 size_t NumParallelJobs() {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kTestLauncherJobs)) {

base/test/launcher/test_launcher.h

@@ -28,10 +28,7 @@ namespace base {
 
 class CommandLine;
 struct LaunchOptions;
-class SequencedWorkerPoolOwner;
-class TaskRunner;
 class TestLauncher;
-class Thread;
 
 // Constants for GTest command-line flags.
 extern const char kGTestFilterFlag[];
@@ -188,10 +185,6 @@ class TestLauncher {
   // Called by the delay timer when no output was made for a while.
   void OnOutputTimeout();
 
-  // Returns the TaskRunner to be used to launch child test processes. This
-  // TaskRunner will have TaskShutdownBehavior::BLOCK_SHUTDOWN semantics.
-  scoped_refptr<TaskRunner> GetTaskRunner();
-
   // Make sure we don't accidentally call the wrong methods e.g. on the worker
   // pool thread.  Should be the first member so that it's destroyed last: when
   // destroying other members, especially the worker pool, we may check the code
@@ -254,11 +247,6 @@ class TestLauncher {
   // Number of jobs to run in parallel.
   size_t parallel_jobs_;
 
-  // Worker pool used to launch processes in parallel (|worker_thread_| is used
-  // instead if |parallel_jobs == 1|).
-  std::unique_ptr<SequencedWorkerPoolOwner> worker_pool_owner_;
-  std::unique_ptr<Thread> worker_thread_;
-
   DISALLOW_COPY_AND_ASSIGN(TestLauncher);
 };
 

base/timer/timer_unittest.cc

@@ -18,7 +18,8 @@
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/test/sequenced_worker_pool_owner.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/sequenced_task_runner_handle.h"
@@ -723,24 +724,15 @@ TEST(TimerTest, ContinuationReset) {
 
 namespace {
 
-const size_t kNumWorkerThreads = 3;
-
-// Fixture for tests requiring a worker pool. Includes a WaitableEvent so
-// that cases may Wait() on one thread and Signal() (explicitly, or implicitly
-// via helper methods) on another.
+// Fixture for tests requiring ScopedTaskEnvironment. Includes a WaitableEvent
+// so that cases may Wait() on one thread and Signal() (explicitly, or
+// implicitly via helper methods) on another.
 class TimerSequenceTest : public testing::Test {
  public:
   TimerSequenceTest()
       : event_(WaitableEvent::ResetPolicy::AUTOMATIC,
                WaitableEvent::InitialState::NOT_SIGNALED) {}
 
-  void SetUp() override {
-    pool1_owner_.reset(
-        new SequencedWorkerPoolOwner(kNumWorkerThreads, "test1"));
-    pool2_owner_.reset(
-        new SequencedWorkerPoolOwner(kNumWorkerThreads, "test2"));
-  }
-
   // Block until Signal() is called on another thread.
   void Wait() { event_.Wait(); }
 
@@ -780,26 +772,14 @@ class TimerSequenceTest : public testing::Test {
   // Delete the timer.
   void DeleteTimer() { timer_.reset(); }
 
- protected:
-  const scoped_refptr<SequencedWorkerPool>& pool1() {
-    return pool1_owner_->pool();
-  }
-  const scoped_refptr<SequencedWorkerPool>& pool2() {
-    return pool2_owner_->pool();
-  }
-
  private:
   void RunTaskAndSignal(const Closure& task) {
     task.Run();
     Signal();
   }
 
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
   WaitableEvent event_;
-
-  MessageLoop message_loop_;
-  std::unique_ptr<SequencedWorkerPoolOwner> pool1_owner_;
-  std::unique_ptr<SequencedWorkerPoolOwner> pool2_owner_;
-
   std::unique_ptr<OneShotTimer> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(TimerSequenceTest);
@@ -807,9 +787,9 @@ class TimerSequenceTest : public testing::Test {
 
 }  // namespace
 
-TEST_F(TimerSequenceTest, OneShotTimerTaskOnPoolThread) {
+TEST_F(TimerSequenceTest, OneShotTimerTaskOnPoolSequence) {
   scoped_refptr<SequencedTaskRunner> task_runner =
-      pool1()->GetSequencedTaskRunner(pool1()->GetSequenceToken());
+      base::CreateSequencedTaskRunnerWithTraits({});
 
   base::RunLoop run_loop_;
 
@@ -832,9 +812,9 @@ TEST_F(TimerSequenceTest, OneShotTimerTaskOnPoolThread) {
   DeleteTimer();
 }
 
-TEST_F(TimerSequenceTest, OneShotTimerUsedOnPoolThread) {
+TEST_F(TimerSequenceTest, OneShotTimerUsedOnPoolSequence) {
   scoped_refptr<SequencedTaskRunner> task_runner =
-      pool1()->GetSequencedTaskRunner(pool1()->GetSequenceToken());
+      base::CreateSequencedTaskRunnerWithTraits({});
 
   // Timer is created on this thread.
   CreateTimer();
@@ -853,61 +833,61 @@ TEST_F(TimerSequenceTest, OneShotTimerUsedOnPoolThread) {
   Wait();
 }
 
-TEST_F(TimerSequenceTest, OneShotTimerTwoPoolsAbandonTask) {
+TEST_F(TimerSequenceTest, OneShotTimerTwoSequencesAbandonTask) {
   scoped_refptr<SequencedTaskRunner> task_runner1 =
-      pool1()->GetSequencedTaskRunner(pool1()->GetSequenceToken());
+      base::CreateSequencedTaskRunnerWithTraits({});
   scoped_refptr<SequencedTaskRunner> task_runner2 =
-      pool2()->GetSequencedTaskRunner(pool2()->GetSequenceToken());
+      base::CreateSequencedTaskRunnerWithTraits({});
 
-  // Create timer on pool #1.
+  // Create timer on sequence #1.
   task_runner1->PostTask(
       FROM_HERE,
       TaskWithSignal(Bind(&TimerSequenceTest::CreateTimer, Unretained(this))));
   Wait();
 
-  // And tell it to execute on a different pool (#2).
+  // And tell it to execute on a different sequence (#2).
   task_runner1->PostTask(
       FROM_HERE, TaskWithSignal(Bind(&TimerSequenceTest::SetTaskRunnerForTimer,
                                      Unretained(this), task_runner2)));
   Wait();
 
-  // Task will be scheduled from pool #1.
+  // Task will be scheduled from sequence #1.
   task_runner1->PostTask(
       FROM_HERE, BindOnce(&TimerSequenceTest::StartTimer, Unretained(this),
                           TimeDelta::FromHours(1), Bind(&DoNothing)));
 
-  // Abandon task - must be called from scheduling pool (#1).
+  // Abandon task - must be called from scheduling sequence (#1).
   task_runner1->PostTask(
       FROM_HERE,
       TaskWithSignal(Bind(&TimerSequenceTest::AbandonTask, Unretained(this))));
   Wait();
 
-  // Timer must be destroyed on the pool it was scheduled from (#1).
+  // Timer must be destroyed on the sequence it was scheduled from (#1).
   task_runner1->PostTask(
       FROM_HERE,
       TaskWithSignal(Bind(&TimerSequenceTest::DeleteTimer, Unretained(this))));
   Wait();
 }
 
-TEST_F(TimerSequenceTest, OneShotTimerUsedAndTaskedOnDifferentPools) {
+TEST_F(TimerSequenceTest, OneShotTimerUsedAndTaskedOnDifferentSequences) {
   scoped_refptr<SequencedTaskRunner> task_runner1 =
-      pool1()->GetSequencedTaskRunner(pool1()->GetSequenceToken());
+      base::CreateSequencedTaskRunnerWithTraits({});
   scoped_refptr<SequencedTaskRunner> task_runner2 =
-      pool2()->GetSequencedTaskRunner(pool2()->GetSequenceToken());
+      base::CreateSequencedTaskRunnerWithTraits({});
 
-  // Create timer on pool #1.
+  // Create timer on sequence #1.
   task_runner1->PostTask(
       FROM_HERE,
       TaskWithSignal(Bind(&TimerSequenceTest::CreateTimer, Unretained(this))));
   Wait();
 
-  // And tell it to execute on a different pool (#2).
+  // And tell it to execute on a different sequence (#2).
   task_runner1->PostTask(
       FROM_HERE, TaskWithSignal(Bind(&TimerSequenceTest::SetTaskRunnerForTimer,
                                      Unretained(this), task_runner2)));
   Wait();
 
-  // Task will be scheduled from pool #1.
+  // Task will be scheduled from sequence #1.
   task_runner1->PostTask(
       FROM_HERE,
       BindOnce(&TimerSequenceTest::StartTimer, Unretained(this),
@@ -917,7 +897,7 @@ TEST_F(TimerSequenceTest, OneShotTimerUsedAndTaskedOnDifferentPools) {
 
   Wait();
 
-  // Timer must be destroyed on the pool it was scheduled from (#1).
+  // Timer must be destroyed on the sequence it was scheduled from (#1).
   task_runner1->PostTask(
       FROM_HERE,
       TaskWithSignal(Bind(&TimerSequenceTest::DeleteTimer, Unretained(this))));

base/trace_event/memory_dump_manager_unittest.cc

@@ -14,15 +14,14 @@
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/thread_heap_usage_tracker.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/test/sequenced_worker_pool_owner.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/test/test_io_thread.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/sequenced_task_runner_handle.h"
-#include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager_test_utils.h"
@@ -136,11 +135,7 @@ class MockMemoryDumpProvider : public MemoryDumpProvider {
 
 class TestSequencedTaskRunner : public SequencedTaskRunner {
  public:
-  TestSequencedTaskRunner()
-      : worker_pool_(2 /* max_threads */, "Test Task Runner"),
-        token_(worker_pool_.pool()->GetSequenceToken()),
-        enabled_(true),
-        num_of_post_tasks_(0) {}
+  TestSequencedTaskRunner() = default;
 
   void set_enabled(bool value) { enabled_ = value; }
   unsigned no_of_post_tasks() const { return num_of_post_tasks_; }
@@ -157,23 +152,22 @@ class TestSequencedTaskRunner : public SequencedTaskRunner {
                        TimeDelta delay) override {
     num_of_post_tasks_++;
     if (enabled_) {
-      return worker_pool_.pool()->PostSequencedWorkerTask(token_, from_here,
-                                                          std::move(task));
+      return task_runner_->PostDelayedTask(from_here, std::move(task), delay);
     }
     return false;
   }
 
   bool RunsTasksInCurrentSequence() const override {
-    return worker_pool_.pool()->RunsTasksInCurrentSequence();
+    return task_runner_->RunsTasksInCurrentSequence();
   }
 
  private:
   ~TestSequencedTaskRunner() override = default;
 
-  SequencedWorkerPoolOwner worker_pool_;
-  const SequencedWorkerPool::SequenceToken token_;
-  bool enabled_;
-  unsigned num_of_post_tasks_;
+  const scoped_refptr<SequencedTaskRunner> task_runner_ =
+      CreateSequencedTaskRunnerWithTraits({});
+  bool enabled_ = true;
+  unsigned num_of_post_tasks_ = 0;
 };
 
 class TestingThreadHeapUsageTracker : public debug::ThreadHeapUsageTracker {
@@ -188,14 +182,14 @@ class MemoryDumpManagerTest : public testing::Test {
   MemoryDumpManagerTest() : testing::Test(), kDefaultOptions() {}
 
   void SetUp() override {
-    message_loop_.reset(new MessageLoop());
+    scoped_task_environment_ = std::make_unique<test::ScopedTaskEnvironment>();
     mdm_ = MemoryDumpManager::CreateInstanceForTesting();
     ASSERT_EQ(mdm_.get(), MemoryDumpManager::GetInstance());
   }
 
   void TearDown() override {
     mdm_.reset();
-    message_loop_.reset();
+    scoped_task_environment_.reset();
     TraceLog::DeleteForTesting();
   }
 
@@ -254,7 +248,7 @@ class MemoryDumpManagerTest : public testing::Test {
   std::unique_ptr<MemoryDumpManager> mdm_;
 
  private:
-  std::unique_ptr<MessageLoop> message_loop_;
+  std::unique_ptr<test::ScopedTaskEnvironment> scoped_task_environment_;
 
   // To tear down the singleton instance after each test.
   ShadowingAtExitManager at_exit_manager_;

build/sanitizers/tsan_suppressions.cc

@@ -236,8 +236,10 @@ char kTSanDefaultSuppressions[] =
 
     // http://crbug.com/587199
     "race:base::TimerTest_OneShotTimer_CustomTaskRunner_Test::TestBody\n"
-    "race:base::TimerSequenceTest_OneShotTimerTaskOnPoolThread_Test::TestBody\n"
-    "race:base::TimerSequenceTest_OneShotTimerUsedAndTaskedOnDifferentPools\n"
+    "race:base::TimerSequenceTest_OneShotTimerTaskOnPoolSequence_Test::"
+    "TestBody\n"
+    "race:base::TimerSequenceTest_"
+    "OneShotTimerUsedAndTaskedOnDifferentSequences\n"
 
     // http://crbug.com/v8/6065
     "race:net::(anonymous namespace)::ProxyResolverV8TracingImpl::RequestImpl"

chrome/browser/extensions/updater/local_extension_cache_unittest.cc

@@ -16,10 +16,9 @@
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
-#include "base/test/sequenced_worker_pool_owner.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/values.h"
 #include "chrome/common/extensions/extension_constants.h"
-#include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "crypto/secure_hash.h"
@@ -41,18 +40,6 @@ class LocalExtensionCacheTest : public testing::Test {
   LocalExtensionCacheTest() {}
   ~LocalExtensionCacheTest() override {}
 
-  scoped_refptr<base::SequencedTaskRunner> background_task_runner() {
-    return background_task_runner_;
-  }
-
-  // testing::Test overrides:
-  void SetUp() override {
-    pool_owner_.reset(
-        new base::SequencedWorkerPoolOwner(3, "Background Pool"));
-    background_task_runner_ = pool_owner_->pool()->GetSequencedTaskRunner(
-        pool_owner_->pool()->GetNamedSequenceToken("background"));
-  }
-
   base::FilePath CreateCacheDir() {
     EXPECT_TRUE(cache_dir_.CreateUniqueTempDir());
     return cache_dir_.GetPath();
@@ -117,23 +104,9 @@ class LocalExtensionCacheTest : public testing::Test {
         extensions::LocalExtensionCache::ExtensionFileName(id, version, hash));
   }
 
-  void WaitForCompletion() {
-    // In the worst case you need to repeat this up to 3 times to make sure that
-    // all pending tasks we sent from UI thread to task runner and back to UI.
-    for (int i = 0; i < 3; i++) {
-      // Wait for background task completion that sends replay to UI thread.
-      pool_owner_->pool()->FlushForTesting();
-      // Wait for UI thread task completion.
-      base::RunLoop().RunUntilIdle();
-    }
-  }
-
  private:
   content::TestBrowserThreadBundle thread_bundle_;
 
-  std::unique_ptr<base::SequencedWorkerPoolOwner> pool_owner_;
-  scoped_refptr<base::SequencedTaskRunner> background_task_runner_;
-
   base::ScopedTempDir cache_dir_;
   base::ScopedTempDir temp_dir_;
 
@@ -147,10 +120,9 @@ static void SimpleCallback(bool* ptr) {
 TEST_F(LocalExtensionCacheTest, Basic) {
   base::FilePath cache_dir(CreateCacheDir());
 
-  LocalExtensionCache cache(cache_dir,
-                            1000,
-                            base::TimeDelta::FromDays(30),
-                            background_task_runner());
+  LocalExtensionCache cache(
+      cache_dir, 1000, base::TimeDelta::FromDays(30),
+      base::CreateSequencedTaskRunnerWithTraits({base::MayBlock()}));
   cache.SetCacheStatusPollingDelayForTests(base::TimeDelta());
 
   bool initialized = false;
@@ -170,7 +142,7 @@ TEST_F(LocalExtensionCacheTest, Basic) {
                       base::Time::Now() - base::TimeDelta::FromDays(41),
                       &file30);
 
-  WaitForCompletion();
+  content::RunAllTasksUntilIdle();
   ASSERT_TRUE(initialized);
 
   // Older version should be removed on cache initialization.
@@ -185,7 +157,7 @@ TEST_F(LocalExtensionCacheTest, Basic) {
 
   bool did_shutdown = false;
   cache.Shutdown(base::Bind(&SimpleCallback, &did_shutdown));
-  WaitForCompletion();
+  content::RunAllTasksUntilIdle();
   ASSERT_TRUE(did_shutdown);
 
   EXPECT_TRUE(base::PathExists(file10));
@@ -196,8 +168,9 @@ TEST_F(LocalExtensionCacheTest, Basic) {
 TEST_F(LocalExtensionCacheTest, KeepHashed) {
   base::FilePath cache_dir(CreateCacheDir());
 
-  LocalExtensionCache cache(cache_dir, 1000, base::TimeDelta::FromDays(30),
-                            background_task_runner());
+  LocalExtensionCache cache(
+      cache_dir, 1000, base::TimeDelta::FromDays(30),
+      base::CreateSequencedTaskRunnerWithTraits({base::MayBlock()}));
   cache.SetCacheStatusPollingDelayForTests(base::TimeDelta());
 
   bool initialized = false;
@@ -212,7 +185,7 @@ TEST_F(LocalExtensionCacheTest, KeepHashed) {
   const std::string hash2 = CreateSignedExtensionFile(
       cache_dir, kTestExtensionId1, "1.0", 123, time, &file2);
 
-  WaitForCompletion();
+  content::RunAllTasksUntilIdle();
   ASSERT_TRUE(initialized);
 
   // Unhashed version should be removed on cache initialization.
@@ -232,8 +205,9 @@ TEST_F(LocalExtensionCacheTest, KeepHashed) {
 TEST_F(LocalExtensionCacheTest, KeepLatest) {
   base::FilePath cache_dir(CreateCacheDir());
 
-  LocalExtensionCache cache(cache_dir, 1000, base::TimeDelta::FromDays(30),
-                            background_task_runner());
+  LocalExtensionCache cache(
+      cache_dir, 1000, base::TimeDelta::FromDays(30),
+      base::CreateSequencedTaskRunnerWithTraits({base::MayBlock()}));
   cache.SetCacheStatusPollingDelayForTests(base::TimeDelta());
 
   bool initialized = false;
@@ -249,7 +223,7 @@ TEST_F(LocalExtensionCacheTest, KeepLatest) {
   const std::string hash22 = CreateSignedExtensionFile(
       cache_dir, kTestExtensionId1, "2.0", 123, time, &file22);
 
-  WaitForCompletion();
+  content::RunAllTasksUntilIdle();
   ASSERT_TRUE(initialized);
 
   // Older version should be removed
@@ -267,8 +241,9 @@ TEST_F(LocalExtensionCacheTest, KeepLatest) {
 TEST_F(LocalExtensionCacheTest, Complex) {
   base::FilePath cache_dir(CreateCacheDir());
 
-  LocalExtensionCache cache(cache_dir, 1000, base::TimeDelta::FromDays(30),
-                            background_task_runner());
+  LocalExtensionCache cache(
+      cache_dir, 1000, base::TimeDelta::FromDays(30),
+      base::CreateSequencedTaskRunnerWithTraits({base::MayBlock()}));
   cache.SetCacheStatusPollingDelayForTests(base::TimeDelta());
 
   bool initialized = false;
@@ -288,7 +263,7 @@ TEST_F(LocalExtensionCacheTest, Complex) {
   const std::string hash22 = CreateSignedExtensionFile(
       cache_dir, kTestExtensionId1, "2.0", 105, time, &file22);
 
-  WaitForCompletion();
+  content::RunAllTasksUntilIdle();
   ASSERT_TRUE(initialized);
 
   // Older and unhashed versions should be removed
@@ -333,8 +308,9 @@ static void PutExtensionAndWait(LocalExtensionCache& cache,
 TEST_F(LocalExtensionCacheTest, PutExtensionCases) {
   base::FilePath cache_dir(CreateCacheDir());
 
-  LocalExtensionCache cache(cache_dir, 1000, base::TimeDelta::FromDays(30),
-                            background_task_runner());
+  LocalExtensionCache cache(
+      cache_dir, 1000, base::TimeDelta::FromDays(30),
+      base::CreateSequencedTaskRunnerWithTraits({base::MayBlock()}));
   cache.SetCacheStatusPollingDelayForTests(base::TimeDelta());
 
   bool initialized = false;
@@ -351,7 +327,7 @@ TEST_F(LocalExtensionCacheTest, PutExtensionCases) {
                             &file2);
   CreateExtensionFile(cache_dir, kTestExtensionId3, "0.3", 300, time, &file3);
 
-  WaitForCompletion();
+  content::RunAllTasksUntilIdle();
   ASSERT_TRUE(initialized);
 
   // Create and initialize installation source directory.

components/browser_sync/profile_sync_test_util.cc

@@ -229,7 +229,6 @@ ProfileSyncServiceBundle::SyncClientBuilder::Build() {
 
 ProfileSyncServiceBundle::ProfileSyncServiceBundle()
     : db_thread_(base::ThreadTaskRunnerHandle::Get()),
-      worker_pool_owner_(2, "sync test worker pool"),
       signin_client_(&pref_service_),
 #if defined(OS_CHROMEOS)
       signin_manager_(&signin_client_, &account_tracker_),

components/browser_sync/profile_sync_test_util.h

@@ -11,8 +11,6 @@
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop.h"
-#include "base/test/sequenced_worker_pool_owner.h"
 #include "base/time/time.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/invalidation/impl/fake_invalidation_service.h"
@@ -169,7 +167,6 @@ class ProfileSyncServiceBundle {
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> db_thread_;
-  base::SequencedWorkerPoolOwner worker_pool_owner_;
   sync_preferences::TestingPrefServiceSyncable pref_service_;
   TestSigninClient signin_client_;
   AccountTrackerService account_tracker_;

content/public/test/test_launcher.cc

@@ -29,7 +29,6 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/gtest_xml_util.h"
 #include "base/test/launcher/test_launcher.h"
-#include "base/test/scoped_task_environment.h"
 #include "base/test/test_suite.h"
 #include "base/test/test_switches.h"
 #include "base/test/test_timeouts.h"
@@ -644,12 +643,9 @@ int LaunchTests(TestLauncherDelegate* launcher_delegate,
       "--single-process (to do the above, and also run Chrome in single-"
           "process mode).\n");
 
-  base::test::ScopedTaskEnvironment task_environment(
-      base::test::ScopedTaskEnvironment::MainThreadType::IO);
-
+  base::MessageLoopForIO message_loop;
 #if defined(OS_POSIX)
-  base::FileDescriptorWatcher file_descriptor_watcher(
-      base::MessageLoopForIO::current());
+  base::FileDescriptorWatcher file_descriptor_watcher(&message_loop);
 #endif
 
   launcher_delegate->PreSharding();