Mass-migrate users of base::ThreadPool() as a trait to base::ThreadPool:: API [a-c]

Split directories [a* - components] (%chrome + fuchsia) from
https://chromium-review.googlesource.com/c/chromium/src/+/2026350
as it had trouble landing in one go.

The following script was used to generate this CL (run on every C++
file in the codebase; processing .h before matching .cc/.mm):
https://bugs.chromium.org/p/chromium/issues/detail?id=1026641#c22
(intentionally ignores cleaning post_task.h for now).

TBR=fdoray@chromium.org

Bug: 1026641
Change-Id: I611ee5abce6daf14f80fbbf41e1fc14b6a1411d8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2075097
Reviewed-by: Gabriel Charette <gab@chromium.org>
Reviewed-by: François Doray <fdoray@chromium.org>
Commit-Queue: Gabriel Charette <gab@chromium.org>
Cr-Commit-Position: refs/heads/master@{#744724}

android_webview/browser/aw_browser_process.cc

@@ -8,6 +8,7 @@
 #include "base/base_paths_posix.h"
 #include "base/path_service.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
 
@@ -95,8 +96,8 @@ void AwBrowserProcess::CreateSafeBrowsingUIManager() {
 
 void AwBrowserProcess::CreateSafeBrowsingWhitelistManager() {
   scoped_refptr<base::SequencedTaskRunner> background_task_runner =
-      base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                       base::TaskPriority::BEST_EFFORT});
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::BEST_EFFORT});
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner =
       base::CreateSingleThreadTaskRunner({BrowserThread::IO});
   safe_browsing_whitelist_manager_ =

android_webview/browser/aw_contents_io_thread_client.h

@@ -15,6 +15,7 @@
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 
 namespace content {
 class WebContents;
@@ -138,7 +139,7 @@ class AwContentsIoThreadClient {
   base::android::ScopedJavaGlobalRef<jobject> java_object_;
   base::android::ScopedJavaGlobalRef<jobject> bg_thread_client_object_;
   scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner_ =
-      base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock()});
+      base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
 
   DISALLOW_COPY_AND_ASSIGN(AwContentsIoThreadClient);
 };

android_webview/browser/aw_form_database_service.cc

@@ -9,6 +9,7 @@
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/autofill/core/browser/webdata/autofill_table.h"
@@ -38,8 +39,8 @@ AwFormDatabaseService::AwFormDatabaseService(const base::FilePath path)
   // TODO(pkasting): http://crbug.com/740773 This should likely be sequenced,
   // not single-threaded; it's also possible these objects can each use their
   // own sequences instead of sharing this one.
-  auto db_task_runner = base::CreateSingleThreadTaskRunner(
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::USER_VISIBLE,
+  auto db_task_runner = base::ThreadPool::CreateSingleThreadTaskRunner(
+      {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
        base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
   web_database_ = new WebDatabaseService(path.Append(kWebDataFilename),
                                          ui_task_runner, db_task_runner);

android_webview/browser/aw_print_manager.cc

@@ -13,6 +13,7 @@
 #include "base/numerics/safe_conversions.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "components/printing/browser/print_manager_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
@@ -127,9 +128,9 @@ void AwPrintManager::OnDidPrintDocument(
 
   DCHECK(pdf_writing_done_callback_);
   base::PostTaskAndReplyWithResult(
-      base::CreateTaskRunner({base::ThreadPool(), base::MayBlock(),
-                              base::TaskPriority::BEST_EFFORT,
-                              base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})
+      base::ThreadPool::CreateTaskRunner(
+          {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+           base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})
           .get(),
       FROM_HERE, base::BindOnce(&SaveDataToFd, fd_, number_pages_, data),
       base::BindOnce(&AwPrintManager::OnDidPrintDocumentWritingDone,

android_webview/browser/gfx/aw_attaching_to_window_recorder.cc

@@ -8,6 +8,7 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 
 namespace android_webview {
 
@@ -26,8 +27,8 @@ constexpr size_t kInterval3m = 2;
 
 AwAttachingToWindowRecorder::AwAttachingToWindowRecorder()
     : created_time_(base::TimeTicks::Now()),
-      thread_pool_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::TaskPriority::BEST_EFFORT,
+      thread_pool_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::TaskPriority::BEST_EFFORT,
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})) {
   DETACH_FROM_SEQUENCE(thread_pool_sequence_checker_);
 }

android_webview/browser/network_service/android_stream_reader_url_loader.cc

@@ -18,6 +18,7 @@
 #include "base/feature_list.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/public/browser/browser_thread.h"
@@ -138,8 +139,8 @@ void AndroidStreamReaderURLLoader::Start() {
     return;
   }
 
-  base::PostTask(
-      FROM_HERE, {base::ThreadPool(), base::MayBlock()},
+  base::ThreadPool::PostTask(
+      FROM_HERE, {base::MayBlock()},
       base::BindOnce(
           &OpenInputStreamOnWorkerThread, base::ThreadTaskRunnerHandle::Get(),
           // This is intentional - the loader could be deleted while the
@@ -190,8 +191,8 @@ void AndroidStreamReaderURLLoader::OnInputStreamOpened(
   input_stream_reader_wrapper_ = base::MakeRefCounted<InputStreamReaderWrapper>(
       std::move(input_stream), std::move(input_stream_reader));
 
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE, {base::ThreadPool(), base::MayBlock()},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::MayBlock()},
       base::BindOnce(&InputStreamReaderWrapper::Seek,
                      input_stream_reader_wrapper_, byte_range_),
       base::BindOnce(&AndroidStreamReaderURLLoader::OnReaderSeekCompleted,
@@ -335,8 +336,8 @@ void AndroidStreamReaderURLLoader::ReadMore() {
   }
 
   // TODO(timvolodine): consider using a sequenced task runner.
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE, {base::ThreadPool(), base::MayBlock()},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::MayBlock()},
       base::BindOnce(
           &InputStreamReaderWrapper::ReadRawData, input_stream_reader_wrapper_,
           base::RetainedRef(buffer.get()), base::checked_cast<int>(num_bytes)),

apps/launcher.cc

@@ -18,6 +18,7 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "components/services/app_service/public/cpp/file_handler_info.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_task_traits.h"
@@ -156,9 +157,9 @@ class PlatformAppPathLauncher
   }
 
   void LaunchWithRelativePath(const base::FilePath& current_directory) {
-    base::PostTask(
+    base::ThreadPool::PostTask(
         FROM_HERE,
-        {base::ThreadPool(), base::TaskPriority::USER_VISIBLE, base::MayBlock(),
+        {base::TaskPriority::USER_VISIBLE, base::MayBlock(),
          base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
         base::BindOnce(&PlatformAppPathLauncher::MakePathAbsolute, this,
                        current_directory));

ash/display/display_color_manager.cc

@@ -15,6 +15,7 @@
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "components/quirks/quirks_manager.h"
@@ -196,9 +197,8 @@ DisplayColorManager::DisplayColorManager(
     display::Screen* screen_to_observe)
     : configurator_(configurator),
       matrix_buffer_(9, 0.0f),  // 3x3 matrix.
-      sequenced_task_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
-           base::TaskPriority::USER_VISIBLE,
+      sequenced_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
       displays_ctm_support_(DisplayCtmSupport::kNone),
       screen_to_observe_(screen_to_observe) {

ash/fast_ink/cursor/cursor_view.cc

@@ -6,6 +6,7 @@
 
 #include "base/bind.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/paint/paint_canvas.h"
 #include "ui/aura/window.h"
@@ -64,8 +65,8 @@ CursorView::CursorView(aura::Window* container,
                               base::Unretained(this))),
       is_motion_blur_enabled_(is_motion_blur_enabled),
       ui_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      paint_task_runner_(base::CreateSingleThreadTaskRunner(
-          {base::ThreadPool(), base::TaskPriority::USER_BLOCKING,
+      paint_task_runner_(base::ThreadPool::CreateSingleThreadTaskRunner(
+          {base::TaskPriority::USER_BLOCKING,
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
       new_location_(initial_location),
       stationary_timer_(

ash/shell.cc

@@ -161,6 +161,7 @@
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/trace_event/trace_event.h"
 #include "chromeos/constants/chromeos_features.h"
 #include "chromeos/dbus/initialize_dbus_client.h"
@@ -554,9 +555,8 @@ Shell::Shell(std::unique_ptr<ShellDelegate> shell_delegate)
   // Use CONTINUE_ON_SHUTDOWN to avoid blocking shutdown since the data reading
   // could get blocked on certain devices. See https://crbug.com/1023989.
   AccelerometerReader::GetInstance()->Initialize(
-      base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
-           base::TaskPriority::USER_VISIBLE,
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
            base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN}));
 
   login_screen_controller_ =

ash/wallpaper/wallpaper_controller_impl.cc

@@ -41,6 +41,7 @@
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "base/values.h"
 #include "chromeos/constants/chromeos_switches.h"
@@ -479,9 +480,8 @@ const char WallpaperControllerImpl::kOriginalWallpaperSubDir[] = "original";
 WallpaperControllerImpl::WallpaperControllerImpl(PrefService* local_state)
     : color_profiles_(GetProminentColorProfiles()),
       wallpaper_reload_delay_(kWallpaperReloadDelay),
-      sequenced_task_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
-           base::TaskPriority::USER_VISIBLE,
+      sequenced_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
            base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN})),
       local_state_(local_state) {
   DCHECK(!g_instance_);
@@ -1542,9 +1542,9 @@ void WallpaperControllerImpl::RemoveUserWallpaperImpl(
   wallpaper_path = GetCustomWallpaperDir(kOriginalWallpaperSubDir);
   files_to_remove.push_back(wallpaper_path.Append(wallpaper_files_id));
 
-  base::PostTask(
+  base::ThreadPool::PostTask(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(&DeleteWallpaperInList, std::move(files_to_remove)));
 }
@@ -1851,9 +1851,8 @@ void WallpaperControllerImpl::SaveAndSetWallpaper(
     // Block shutdown on this task. Otherwise, we may lose the custom wallpaper
     // that the user selected.
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner =
-        base::CreateSequencedTaskRunner(
-            {base::ThreadPool(), base::MayBlock(),
-             base::TaskPriority::USER_BLOCKING,
+        base::ThreadPool::CreateSequencedTaskRunner(
+            {base::MayBlock(), base::TaskPriority::USER_BLOCKING,
              base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
     blocking_task_runner->PostTask(
         FROM_HERE, base::BindOnce(&SaveCustomWallpaper, wallpaper_files_id,

base/trace_event/cpufreq_monitor_android.cc

@@ -17,6 +17,7 @@
 #include "base/strings/stringprintf.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/trace_event/trace_event.h"
 
 namespace base {
@@ -109,9 +110,8 @@ void CPUFreqMonitorDelegate::RecordFrequency(unsigned int cpu_id,
 
 scoped_refptr<SingleThreadTaskRunner>
 CPUFreqMonitorDelegate::CreateTaskRunner() {
-  return base::CreateSingleThreadTaskRunner(
-      {base::ThreadPool(), base::MayBlock(),
-       base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
+  return base::ThreadPool::CreateSingleThreadTaskRunner(
+      {base::MayBlock(), base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
        base::TaskPriority::BEST_EFFORT},
       base::SingleThreadTaskRunnerThreadMode::SHARED);
 }

base/util/memory_pressure/system_memory_pressure_evaluator_chromeos.cc

@@ -20,6 +20,7 @@
 #include "base/strings/string_util.h"
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
@@ -293,10 +294,9 @@ void SystemMemoryPressureEvaluator::ScheduleEarlyCheck() {
 void SystemMemoryPressureEvaluator::ScheduleWaitForKernelNotification() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
-  base::PostTaskAndReplyWithResult(
+  base::ThreadPool::PostTaskAndReplyWithResult(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(),
-       base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+      {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(kernel_waiting_callback_),
       base::BindOnce(&SystemMemoryPressureEvaluator::HandleKernelNotification,
                      weak_ptr_factory_.GetWeakPtr()));

chromecast/browser/cast_browser_main_parts.cc

@@ -23,6 +23,7 @@
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
@@ -520,8 +521,8 @@ void CastBrowserMainParts::PreMainMessageLoopRun() {
 #endif  // !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
 
 #if defined(OS_ANDROID)
-  crash_reporter_runner_ = base::CreateSequencedTaskRunner(
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+  crash_reporter_runner_ = base::ThreadPool::CreateSequencedTaskRunner(
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN});
   crash_reporter_runner_->PostTask(
       FROM_HERE,

chromecast/browser/cast_extension_message_filter.cc

@@ -14,6 +14,7 @@
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/notification_service.h"
@@ -120,8 +121,8 @@ void CastExtensionMessageFilter::OnGetExtMessageBundle(
   }
 
   // This blocks tab loading. Priority is inherited from the calling context.
-  base::PostTask(
-      FROM_HERE, {base::ThreadPool(), base::MayBlock()},
+  base::ThreadPool::PostTask(
+      FROM_HERE, {base::MayBlock()},
       base::BindOnce(
           &CastExtensionMessageFilter::OnGetExtMessageBundleAsync, this,
           paths_to_load, extension_id, default_locale,

chromecast/browser/metrics/external_metrics.cc

@@ -19,6 +19,7 @@
 #include "base/sequenced_task_runner.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "chromecast/base/metrics/cast_histograms.h"
 #include "chromecast/base/metrics/cast_metrics_helper.h"
@@ -57,8 +58,8 @@ bool CheckLinearValues(const std::string& name, int maximum) {
 scoped_refptr<base::SequencedTaskRunner> CreateTaskRunner() {
   // Note that CollectEvents accesses a global singleton, and thus
   // scheduling with CONTINUE_ON_SHUTDOWN might not be safe.
-  return base::CreateSequencedTaskRunner(
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+  return base::ThreadPool::CreateSequencedTaskRunner(
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN});
 }
 

chromecast/device/bluetooth/le/le_scan_manager_impl_test.cc

@@ -9,6 +9,7 @@
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/test/task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chromecast/device/bluetooth/bluetooth_util.h"
@@ -49,9 +50,8 @@ class MockLeScanManagerObserver : public LeScanManager::Observer {
 class LeScanManagerTest : public ::testing::Test {
  protected:
   LeScanManagerTest()
-      : io_task_runner_(base::CreateSingleThreadTaskRunner(
-            {base::ThreadPool(), base::TaskPriority::BEST_EFFORT,
-             base::MayBlock()})),
+      : io_task_runner_(base::ThreadPool::CreateSingleThreadTaskRunner(
+            {base::TaskPriority::BEST_EFFORT, base::MayBlock()})),
         le_scan_manager_(&le_scanner_) {
     le_scan_manager_.Initialize(io_task_runner_);
     le_scan_manager_.AddObserver(&mock_observer_);

chromecast/media/audio/capture_service/capture_service_receiver_unittest.cc

@@ -10,6 +10,7 @@
 #include "base/big_endian.h"
 #include "base/run_loop.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/test/task_environment.h"
 #include "chromecast/media/audio/capture_service/message_parsing_utils.h"
 #include "chromecast/media/audio/capture_service/packet_header.h"
@@ -60,8 +61,8 @@ class CaptureServiceReceiverTest : public ::testing::Test {
                   kStreamInfo.sample_rate,
                   kStreamInfo.num_channels,
                   kStreamInfo.frames_per_buffer) {
-    receiver_.SetTaskRunnerForTest(base::CreateSequencedTaskRunner(
-        {base::ThreadPool(), base::TaskPriority::USER_BLOCKING}));
+    receiver_.SetTaskRunnerForTest(base::ThreadPool::CreateSequencedTaskRunner(
+        {base::TaskPriority::USER_BLOCKING}));
   }
   ~CaptureServiceReceiverTest() override = default;
 

chromecast/media/cma/backend/cast_audio_json.cc

@@ -14,6 +14,7 @@
 #include "base/logging.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/task/thread_pool/thread_pool_instance.h"
 #include "build/build_config.h"
 
@@ -70,8 +71,8 @@ base::FilePath CastAudioJson::GetFilePathForTuning() {
 CastAudioJsonProviderImpl::CastAudioJsonProviderImpl() {
   if (base::ThreadPoolInstance::Get()) {
     cast_audio_watcher_ = base::SequenceBound<FileWatcher>(
-        base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                         base::TaskPriority::LOWEST}));
+        base::ThreadPool::CreateSequencedTaskRunner(
+            {base::MayBlock(), base::TaskPriority::LOWEST}));
   }
 }
 

chromeos/components/account_manager/account_manager.cc

@@ -15,6 +15,7 @@
 #include "base/metrics/histogram_functions.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "chromeos/constants/chromeos_pref_names.h"
@@ -179,9 +180,8 @@ void AccountManager::Initialize(
     base::OnceClosure initialization_callback) {
   Initialize(
       home_dir, url_loader_factory, std::move(delay_network_call_runner),
-      base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::TaskShutdownBehavior::BLOCK_SHUTDOWN,
-           base::MayBlock()}),
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::TaskShutdownBehavior::BLOCK_SHUTDOWN, base::MayBlock()}),
       std::move(initialization_callback));
 }
 

chromeos/components/drivefs/fake_drivefs.cc

@@ -18,6 +18,7 @@
 #include "base/strings/strcat.h"
 #include "base/strings/string_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "chromeos/components/drivefs/drivefs_util.h"
 #include "chromeos/components/drivefs/mojom/drivefs.mojom.h"
@@ -110,10 +111,8 @@ class FakeDriveFs::SearchQuery : public mojom::SearchQuery {
     } else {
       // Default implementation: just search for a file name.
       callback_ = std::move(callback);
-      base::PostTaskAndReplyWithResult(
-          FROM_HERE,
-          {base::ThreadPool(), base::MayBlock(),
-           base::TaskPriority::BEST_EFFORT},
+      base::ThreadPool::PostTaskAndReplyWithResult(
+          FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
           base::BindOnce(&SearchQuery::SearchFiles, drive_fs_->mount_path()),
           base::BindOnce(&SearchQuery::GetMetadata,
                          weak_ptr_factory_.GetWeakPtr()));

chromeos/components/drivefs/fake_drivefs_launcher_client.cc

@@ -11,6 +11,7 @@
 #include "base/strings/strcat.h"
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "chromeos/components/mojo_bootstrap/pending_connection_manager.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_cros_disks_client.h"
@@ -57,9 +58,8 @@ FakeDriveFsLauncherClient::FakeDriveFsLauncherClient(
     const base::FilePath& socket_path)
     : chroot_path_(chroot_path),
       socket_path_(chroot_path_.Append(socket_path)) {
-  base::PostTask(
-      FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT},
+  base::ThreadPool::PostTask(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
       base::BindOnce(&ConnectAsync, launcher_.BindNewPipeAndPassReceiver(),
                      socket_path_.value()));
 

chromeos/components/nearby/count_down_latch_impl_unittest.cc

@@ -10,6 +10,7 @@
 #include "base/stl_util.h"
 #include "base/synchronization/lock.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task/thread_pool/thread_pool_instance.h"
 #include "base/test/task_environment.h"
 #include "base/test/test_timeouts.h"
@@ -39,8 +40,8 @@ class CountDownLatchImplTest : public testing::Test {
   base::UnguessableToken PostAwaitTask(
       const base::Optional<base::TimeDelta>& timeout_millis) {
     base::UnguessableToken unique_task_id = base::UnguessableToken::Create();
-    base::PostTask(
-        FROM_HERE, {base::ThreadPool(), base::MayBlock()},
+    base::ThreadPool::PostTask(
+        FROM_HERE, {base::MayBlock()},
         base::BindOnce(&CountDownLatchImplTest::AwaitTask,
                        base::Unretained(this), timeout_millis, unique_task_id));
     return unique_task_id;

chromeos/components/nearby/lock_impl_unittest.cc

@@ -11,6 +11,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/test/gtest_util.h"
 #include "base/test/task_environment.h"
 #include "base/test/test_timeouts.h"
@@ -26,8 +27,9 @@ class LockImplTest : public testing::Test {
  protected:
   LockImplTest()
       : lock_(std::make_unique<LockImpl>()),
-        different_thread_task_runner_(base::CreateSingleThreadTaskRunner(
-            {base::ThreadPool(), base::MayBlock()})) {}
+        different_thread_task_runner_(
+            base::ThreadPool::CreateSingleThreadTaskRunner(
+                {base::MayBlock()})) {}
 
   // testing::Test
   void SetUp() override {

chromeos/components/nearby/multi_thread_executor_impl.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "chromeos/components/nearby/multi_thread_executor_impl.h"
+#include "base/task/thread_pool.h"
 
 namespace chromeos {
 
@@ -10,7 +11,7 @@ namespace nearby {
 
 MultiThreadExecutorImpl::MultiThreadExecutorImpl()
     : SubmittableExecutorBase(
-          base::CreateTaskRunner({base::ThreadPool(), base::MayBlock()})) {}
+          base::ThreadPool::CreateTaskRunner({base::MayBlock()})) {}
 
 MultiThreadExecutorImpl::~MultiThreadExecutorImpl() = default;
 

chromeos/components/nearby/scheduled_executor_impl.h

@@ -13,6 +13,7 @@
 #include "base/sequence_checker.h"
 #include "base/synchronization/lock.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/timer/timer.h"
 #include "base/unguessable_token.h"
 #include "chromeos/components/nearby/library/atomic_boolean.h"
@@ -30,8 +31,7 @@ class ScheduledExecutorImpl : public location::nearby::ScheduledExecutor {
  public:
   ScheduledExecutorImpl(
       scoped_refptr<base::SequencedTaskRunner> timer_task_runner =
-          base::CreateSequencedTaskRunner({base::ThreadPool(),
-                                           base::MayBlock()}));
+          base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()}));
   ~ScheduledExecutorImpl() override;
 
  private:

chromeos/components/nearby/settable_future_impl_unittest.cc

@@ -12,6 +12,7 @@
 #include "base/stl_util.h"
 #include "base/synchronization/lock.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/test/task_environment.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
@@ -49,9 +50,10 @@ class SettableFutureImplTest : public testing::Test {
 
   base::UnguessableToken PostGetAsyncResult() {
     base::UnguessableToken id = base::UnguessableToken::Create();
-    base::PostTask(FROM_HERE, {base::ThreadPool(), base::MayBlock()},
-                   base::BindOnce(&SettableFutureImplTest::GetAsyncResult,
-                                  base::Unretained(this), id));
+    base::ThreadPool::PostTask(
+        FROM_HERE, {base::MayBlock()},
+        base::BindOnce(&SettableFutureImplTest::GetAsyncResult,
+                       base::Unretained(this), id));
     return id;
   }
 

chromeos/components/nearby/single_thread_executor_impl.cc

@@ -3,14 +3,15 @@
 // found in the LICENSE file.
 
 #include "chromeos/components/nearby/single_thread_executor_impl.h"
+#include "base/task/thread_pool.h"
 
 namespace chromeos {
 
 namespace nearby {
 
 SingleThreadExecutorImpl::SingleThreadExecutorImpl()
-    : SubmittableExecutorBase(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock()})) {}
+    : SubmittableExecutorBase(
+          base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()})) {}
 
 SingleThreadExecutorImpl::~SingleThreadExecutorImpl() = default;
 

chromeos/dbus/debug_daemon/debug_daemon_client.cc

@@ -27,6 +27,7 @@
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_config.h"
 #include "chromeos/dbus/pipe_reader.h"
@@ -53,8 +54,8 @@ const int kBigLogsDBusTimeoutMS = 120 * 1000;
 class PipeReaderWrapper : public base::SupportsWeakPtr<PipeReaderWrapper> {
  public:
   explicit PipeReaderWrapper(DebugDaemonClient::GetLogsCallback callback)
-      : pipe_reader_(base::CreateTaskRunner(
-            {base::ThreadPool(), base::MayBlock(),
+      : pipe_reader_(base::ThreadPool::CreateTaskRunner(
+            {base::MayBlock(),
              base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN})),
         callback_(std::move(callback)) {}
 

chromeos/dbus/debug_daemon/debug_daemon_client_provider.cc

@@ -5,6 +5,7 @@
 #include "chromeos/dbus/debug_daemon/debug_daemon_client_provider.h"
 
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "chromeos/dbus/debug_daemon/debug_daemon_client.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
@@ -15,9 +16,8 @@
 namespace chromeos {
 
 DebugDaemonClientProvider::DebugDaemonClientProvider()
-    : dbus_task_runner_(base::CreateSingleThreadTaskRunner(
-          {base::ThreadPool(), base::TaskPriority::BEST_EFFORT,
-           base::MayBlock()})),
+    : dbus_task_runner_(base::ThreadPool::CreateSingleThreadTaskRunner(
+          {base::TaskPriority::BEST_EFFORT, base::MayBlock()})),
       debug_daemon_client_(DebugDaemonClient::Create()) {
   dbus::Bus::Options dbus_options;
   dbus_options.bus_type = dbus::Bus::SYSTEM;

chromeos/dbus/fake_cros_disks_client.cc

@@ -12,6 +12,7 @@
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "url/gurl.h"
 
@@ -114,10 +115,9 @@ void FakeCrosDisksClient::Mount(const std::string& source_path,
   }
   mounted_paths_.insert(mounted_path);
 
-  base::PostTaskAndReplyWithResult(
+  base::ThreadPool::PostTaskAndReplyWithResult(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(),
-       base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+      {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(&PerformFakeMount, source_path, mounted_path, type),
       base::BindOnce(&FakeCrosDisksClient::DidMount,
                      weak_ptr_factory_.GetWeakPtr(), source_path, type,
@@ -149,9 +149,9 @@ void FakeCrosDisksClient::Unmount(const std::string& device_path,
 
   // Remove the dummy mounted directory if it exists.
   if (mounted_paths_.erase(base::FilePath::FromUTF8Unsafe(device_path))) {
-    base::PostTaskAndReply(
+    base::ThreadPool::PostTaskAndReply(
         FROM_HERE,
-        {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+        {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
          base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
         base::BindOnce(base::IgnoreResult(&base::DeleteFile),
                        base::FilePath::FromUTF8Unsafe(device_path),

chromeos/dbus/fake_oobe_configuration_client.cc

@@ -12,6 +12,7 @@
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "chromeos/dbus/constants/dbus_switches.h"
 
 namespace {
@@ -53,9 +54,8 @@ void FakeOobeConfigurationClient::CheckForOobeConfiguration(
       base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
           chromeos::switches::kFakeOobeConfiguration);
 
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE,
-      {base::ThreadPool(), base::TaskPriority::BEST_EFFORT, base::MayBlock()},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::TaskPriority::BEST_EFFORT, base::MayBlock()},
       base::BindOnce(&LoadConfigurationFile, path),
       base::BindOnce(&OnConfigurationLoaded, std::move(callback)));
 }

chromeos/dbus/lorgnette_manager_client.cc

@@ -16,6 +16,7 @@
 #include "base/macros.h"
 #include "base/optional.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "chromeos/dbus/pipe_reader.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
@@ -101,9 +102,9 @@ class LorgnetteManagerClientImpl : public LorgnetteManagerClient {
     base::ScopedFD Start() {
       DCHECK(!pipe_reader_.get());
       DCHECK(!data_.has_value());
-      pipe_reader_ =
-          std::make_unique<chromeos::PipeReader>(base::CreateTaskRunner(
-              {base::ThreadPool(), base::MayBlock(),
+      pipe_reader_ = std::make_unique<chromeos::PipeReader>(
+          base::ThreadPool::CreateTaskRunner(
+              {base::MayBlock(),
                base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN}));
 
       return pipe_reader_->StartIO(base::BindOnce(

chromeos/dbus/permission_broker/fake_permission_broker_client.cc

@@ -14,6 +14,7 @@
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/stringprintf.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 
 namespace chromeos {
@@ -75,12 +76,12 @@ void FakePermissionBrokerClient::CheckPathAccess(const std::string& path,
 void FakePermissionBrokerClient::OpenPath(const std::string& path,
                                           OpenPathCallback callback,
                                           ErrorCallback error_callback) {
-  base::PostTask(FROM_HERE,
-                 {base::ThreadPool(), base::MayBlock(),
-                  base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
-                 base::BindOnce(&chromeos::OpenPath, path, std::move(callback),
-                                std::move(error_callback),
-                                base::ThreadTaskRunnerHandle::Get()));
+  base::ThreadPool::PostTask(
+      FROM_HERE,
+      {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+      base::BindOnce(&chromeos::OpenPath, path, std::move(callback),
+                     std::move(error_callback),
+                     base::ThreadTaskRunnerHandle::Get()));
 }
 
 void FakePermissionBrokerClient::RequestTcpPortAccess(

chromeos/dbus/session_manager/fake_session_manager_client.cc

@@ -19,6 +19,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chromeos/dbus/constants/dbus_paths.h"
 #include "chromeos/dbus/cryptohome/account_identifier_operators.h"
@@ -451,10 +452,9 @@ void FakeSessionManagerClient::RetrievePolicy(
         GetStubPolicyFilePath(descriptor, nullptr /* key_path */);
     DCHECK(!policy_path.empty());
 
-    base::PostTaskAndReplyWithResult(
+    base::ThreadPool::PostTaskAndReplyWithResult(
         FROM_HERE,
-        {base::ThreadPool(), base::MayBlock(),
-         base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+        {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
         base::BindOnce(&GetFileContent, policy_path),
         base::BindOnce(std::move(callback),
                        RetrievePolicyResponseType::SUCCESS));
@@ -536,10 +536,9 @@ void FakeSessionManagerClient::StorePolicy(
     if (response.has_new_public_key())
       files_to_store[key_path] = response.new_public_key();
 
-    base::PostTaskAndReply(
+    base::ThreadPool::PostTaskAndReply(
         FROM_HERE,
-        {base::ThreadPool(), base::MayBlock(),
-         base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+        {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
         base::BindOnce(StoreFiles, std::move(files_to_store)),
         base::BindOnce(std::move(callback), true /* success */));
   } else {
@@ -551,9 +550,9 @@ void FakeSessionManagerClient::StorePolicy(
         GetStubPolicyFilePath(descriptor, &key_path);
         DCHECK(!key_path.empty());
 
-        base::PostTaskAndReply(
+        base::ThreadPool::PostTaskAndReply(
             FROM_HERE,
-            {base::ThreadPool(), base::MayBlock(),
+            {base::MayBlock(),
              base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
             base::BindOnce(StoreFiles,
                            std::map<base::FilePath, std::string>{
@@ -598,10 +597,9 @@ void FakeSessionManagerClient::GetServerBackedStateKeys(
     CHECK(base::PathService::Get(dbus_paths::FILE_OWNER_KEY, &owner_key_path));
     const base::FilePath state_keys_path =
         owner_key_path.DirName().AppendASCII(kStubStateKeysFileName);
-    base::PostTaskAndReplyWithResult(
+    base::ThreadPool::PostTaskAndReplyWithResult(
         FROM_HERE,
-        {base::ThreadPool(), base::MayBlock(),
-         base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+        {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
         base::BindOnce(&ReadCreateStateKeysStub, state_keys_path),
         std::move(callback));
   } else {

chromeos/network/client_cert_resolver.cc

@@ -19,6 +19,7 @@
 #include "base/optional.h"
 #include "base/stl_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/time/clock.h"
 #include "chromeos/dbus/shill/shill_service_client.h"
 #include "chromeos/network/certificate_helper.h"
@@ -658,10 +659,9 @@ void ClientCertResolver::ResolveNetworks(
 
   VLOG(2) << "Start task for resolving client cert patterns.";
   resolve_task_running_ = true;
-  base::PostTaskAndReplyWithResult(
+  base::ThreadPool::PostTaskAndReplyWithResult(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(),
-       base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+      {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(&FindCertificateMatches,
                      NetworkCertLoader::CloneNetworkCertList(
                          NetworkCertLoader::Get()->client_certs()),

chromeos/printing/ppd_cache.cc

@@ -16,6 +16,7 @@
 #include "base/strings/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "base/threading/sequenced_task_runner_handle.h"
@@ -177,14 +178,14 @@ class PpdCacheImpl : public PpdCache {
 
 // static
 scoped_refptr<PpdCache> PpdCache::Create(const base::FilePath& cache_base_dir) {
-  return scoped_refptr<PpdCache>(new PpdCacheImpl(
-      cache_base_dir,
-      base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::TaskPriority::USER_VISIBLE,
-           base::MayBlock(), base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}),
-      base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::TaskPriority::BEST_EFFORT,
-           base::MayBlock(), base::TaskShutdownBehavior::BLOCK_SHUTDOWN})));
+  return scoped_refptr<PpdCache>(
+      new PpdCacheImpl(cache_base_dir,
+                       base::ThreadPool::CreateSequencedTaskRunner(
+                           {base::TaskPriority::USER_VISIBLE, base::MayBlock(),
+                            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}),
+                       base::ThreadPool::CreateSequencedTaskRunner(
+                           {base::TaskPriority::BEST_EFFORT, base::MayBlock(),
+                            base::TaskShutdownBehavior::BLOCK_SHUTDOWN})));
 }
 
 scoped_refptr<PpdCache> PpdCache::CreateForTesting(

chromeos/printing/ppd_provider.cc

@@ -29,6 +29,7 @@
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "base/threading/sequenced_task_runner_handle.h"
@@ -449,9 +450,9 @@ class PpdProviderImpl : public PpdProvider {
       : browser_locale_(browser_locale),
         loader_factory_(loader_factory),
         ppd_cache_(ppd_cache),
-        disk_task_runner_(base::CreateSequencedTaskRunner(
-            {base::ThreadPool(), base::TaskPriority::USER_VISIBLE,
-             base::MayBlock(), base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
+        disk_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+            {base::TaskPriority::USER_VISIBLE, base::MayBlock(),
+             base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
         version_(current_version),
         options_(options) {}
 

chromeos/printing/ppd_provider_v3.cc

@@ -7,6 +7,7 @@
 #include "base/memory/scoped_refptr.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "chromeos/printing/ppd_provider.h"
 
 namespace chromeos {
@@ -21,9 +22,9 @@ class PpdProviderImpl : public PpdProvider {
                   const base::Version& current_version,
                   const PpdProvider::Options& options)
       : browser_locale_(browser_locale),
-        file_task_runner_(base::CreateSequencedTaskRunner(
-            {base::ThreadPool(), base::TaskPriority::USER_VISIBLE,
-             base::MayBlock(), base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
+        file_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+            {base::TaskPriority::USER_VISIBLE, base::MayBlock(),
+             base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
         version_(current_version),
         options_(options) {}
 

chromeos/services/assistant/chromium_http_connection.cc

@@ -12,6 +12,7 @@
 
 #include "base/logging.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "net/base/load_flags.h"
 #include "services/network/public/cpp/header_util.h"
@@ -45,7 +46,7 @@ ChromiumHttpConnection::ChromiumHttpConnection(
     std::unique_ptr<PendingSharedURLLoaderFactory> pending_url_loader_factory,
     Delegate* delegate)
     : delegate_(delegate),
-      task_runner_(base::CreateSequencedTaskRunner({base::ThreadPool()})),
+      task_runner_(base::ThreadPool::CreateSequencedTaskRunner({})),
       pending_url_loader_factory_(std::move(pending_url_loader_factory)) {
   DCHECK(delegate_);
   DCHECK(pending_url_loader_factory_);

chromeos/settings/timezone_settings.cc

@@ -23,6 +23,7 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner.h"
 #include "chromeos/settings/timezone_settings_helper.h"
 
@@ -393,11 +394,10 @@ void TimezoneSettingsImpl::SetTimezone(const icu::TimeZone& timezone) {
   VLOG(1) << "Setting timezone to " << id;
   // It's safe to change the timezone config files in the background as the
   // following operations don't depend on the completion of the config change.
-  base::PostTask(
-      FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT,
-       base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
-      base::BindOnce(&SetTimezoneIDFromString, id));
+  base::ThreadPool::PostTask(FROM_HERE,
+                             {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+                              base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+                             base::BindOnce(&SetTimezoneIDFromString, id));
   icu::TimeZone::setDefault(*known_timezone);
   for (auto& observer : observers_)
     observer.TimezoneChanged(*known_timezone);

chromeos/system/statistics_provider.cc

@@ -27,6 +27,7 @@
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
@@ -486,9 +487,9 @@ void StatisticsProviderImpl::StartLoadingMachineStatistics(
 
   // TaskPriority::USER_BLOCKING because this is on the critical path of
   // rendering the NTP on startup. https://crbug.com/831835
-  base::PostTask(
+  base::ThreadPool::PostTask(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::USER_BLOCKING,
+      {base::MayBlock(), base::TaskPriority::USER_BLOCKING,
        base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
       base::BindOnce(&StatisticsProviderImpl::LoadMachineStatistics,
                      base::Unretained(this), load_oem_manifest));

components/arc/arc_features_parser.cc

@@ -13,6 +13,7 @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "base/values.h"
 #include "components/arc/arc_util.h"
@@ -146,9 +147,8 @@ void ArcFeaturesParser::GetArcFeatures(
     base::OnceCallback<void(base::Optional<ArcFeatures>)> callback) {
   const auto* json_file =
       arc::IsArcVmEnabled() ? kArcVmFeaturesJsonFile : kArcFeaturesJsonFile;
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
       base::BindOnce(&ReadOnFileThread, base::FilePath(json_file)),
       std::move(callback));
 }

components/arc/crash_collector/arc_crash_collector_bridge.cc

@@ -16,6 +16,7 @@
 #include "base/process/launch.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "components/arc/arc_browser_context_keyed_service_factory_base.h"
 #include "components/arc/session/arc_bridge_service.h"
 #include "mojo/public/cpp/system/platform_handle.h"
@@ -97,8 +98,8 @@ ArcCrashCollectorBridge::~ArcCrashCollectorBridge() {
 
 void ArcCrashCollectorBridge::DumpCrash(const std::string& type,
                                         mojo::ScopedHandle pipe) {
-  base::PostTask(
-      FROM_HERE, {base::ThreadPool(), base::WithBaseSyncPrimitives()},
+  base::ThreadPool::PostTask(
+      FROM_HERE, {base::WithBaseSyncPrimitives()},
       base::BindOnce(&RunCrashReporter, type, device_, board_, cpu_abi_,
                      fingerprint_,
                      mojo::UnwrapPlatformHandle(std::move(pipe)).TakeFD()));

components/arc/session/arc_session_impl.cc

@@ -25,6 +25,7 @@
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "chromeos/constants/chromeos_switches.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/system/scheduler_configuration_manager_base.h"
@@ -141,8 +142,8 @@ ArcSessionDelegateImpl::ArcSessionDelegateImpl(
       channel_(channel) {}
 
 void ArcSessionDelegateImpl::CreateSocket(CreateSocketCallback callback) {
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE, {base::ThreadPool(), base::MayBlock()},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::MayBlock()},
       base::BindOnce(&ArcSessionDelegateImpl::CreateSocketInternal),
       std::move(callback));
 }
@@ -162,8 +163,8 @@ base::ScopedFD ArcSessionDelegateImpl::ConnectMojo(
   // For production, |socket_fd| passed from session_manager is either a valid
   // socket or a valid file descriptor (/dev/null). For testing, |socket_fd|
   // might be invalid.
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE, {base::ThreadPool(), base::MayBlock()},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::MayBlock()},
       base::BindOnce(&ArcSessionDelegateImpl::ConnectMojoInternal,
                      std::move(socket_fd), std::move(cancel_fd)),
       base::BindOnce(&ArcSessionDelegateImpl::OnMojoConnected,

components/arc/session/arc_vm_client_adapter.cc

@@ -28,6 +28,7 @@
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/time/time.h"
 #include "chromeos/dbus/concierge_client.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
@@ -306,10 +307,8 @@ class ArcVmClientAdapter : public ArcClientAdapter,
     // Save the parameters for the later call to UpgradeArc.
     start_params_ = std::move(params);
 
-    base::PostTaskAndReplyWithResult(
-        FROM_HERE,
-        {base::ThreadPool(), base::MayBlock(),
-         base::TaskPriority::USER_VISIBLE},
+    base::ThreadPool::PostTaskAndReplyWithResult(
+        FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
         base::BindOnce(
             []() { return GetSystemPropertyInt("cros_debug") == 1; }),
         base::BindOnce(&ArcVmClientAdapter::OnIsDevMode,
@@ -434,10 +433,8 @@ class ArcVmClientAdapter : public ArcClientAdapter,
     }
     // TODO(pliard): Export host-side /data to the VM, and remove the call. Note
     // that ArcSessionImpl checks low disk conditions before calling UpgradeArc.
-    base::PostTaskAndReplyWithResult(
-        FROM_HERE,
-        {base::ThreadPool(), base::MayBlock(),
-         base::TaskPriority::USER_VISIBLE},
+    base::ThreadPool::PostTaskAndReplyWithResult(
+        FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
         base::BindOnce(&base::SysInfo::AmountOfFreeDiskSpace,
                        base::FilePath(kHomeDirectory)),
         base::BindOnce(&ArcVmClientAdapter::CreateDiskImageAfterSizeCheck,
@@ -486,10 +483,8 @@ class ArcVmClientAdapter : public ArcClientAdapter,
     VLOG(1) << "Disk image for arcvm ready. status=" << response.status()
             << ", disk=" << response.disk_path();
 
-    base::PostTaskAndReplyWithResult(
-        FROM_HERE,
-        {base::ThreadPool(), base::MayBlock(),
-         base::TaskPriority::USER_VISIBLE},
+    base::ThreadPool::PostTaskAndReplyWithResult(
+        FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
         base::BindOnce(&FileSystemStatus::GetFileSystemStatusBlocking),
         base::BindOnce(&ArcVmClientAdapter::OnFileSystemStatus,
                        weak_factory_.GetWeakPtr(), std::move(params),

components/assist_ranker/ranker_model_loader_impl.cc

@@ -18,6 +18,7 @@
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "components/assist_ranker/proto/ranker_model.pb.h"
@@ -95,9 +96,8 @@ RankerModelLoaderImpl::RankerModelLoaderImpl(
     base::FilePath model_path,
     GURL model_url,
     std::string uma_prefix)
-    : background_task_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
-           base::TaskPriority::BEST_EFFORT,
+    : background_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
       validate_model_cb_(std::move(validate_model_cb)),
       on_model_available_cb_(std::move(on_model_available_cb)),

components/autofill/core/browser/address_normalizer_impl.cc

@@ -15,6 +15,7 @@
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/autofill/core/browser/autofill_data_util.h"
@@ -156,9 +157,8 @@ AddressNormalizerImpl::AddressNormalizerImpl(std::unique_ptr<Source> source,
   // shutdown. This is important to prevent an access race when the destructor
   // of |storage| accesses an ObserverList that lives on the current sequence.
   // https://crbug.com/829122
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
       base::BindOnce(
           &CreateAddressValidator, std::move(source),
           DeleteOnTaskRunnerStorageUniquePtr(

components/autofill/core/browser/payments/credit_card_access_manager.cc

@@ -16,6 +16,7 @@
 #include "base/synchronization/waitable_event.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
@@ -316,8 +317,7 @@ void CreditCardAccessManager::FetchCreditCard(
 
     // Wait for |ready_to_start_authentication_| to be signaled by
     // OnDidGetUnmaskDetails() or until timeout before calling Authenticate().
-    auto task_runner =
-        base::CreateTaskRunner({base::ThreadPool(), base::MayBlock()});
+    auto task_runner = base::ThreadPool::CreateTaskRunner({base::MayBlock()});
     cancelable_authenticate_task_tracker_.PostTaskAndReplyWithResult(
         task_runner.get(), FROM_HERE,
         base::BindOnce(&WaitForEvent, &ready_to_start_authentication_),

components/autofill/core/browser/payments/strike_database.cc

@@ -13,6 +13,7 @@
 #include "base/bind_helpers.h"
 #include "base/metrics/histogram_functions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/time/time.h"
 #include "components/autofill/core/browser/proto/strike_data.pb.h"
 #include "components/autofill/core/common/autofill_clock.h"
@@ -33,8 +34,8 @@ StrikeDatabase::StrikeDatabase(
   const auto strike_database_path =
       profile_path.Append(kStrikeDatabaseFileName);
 
-  const auto database_task_runner = base::CreateSequencedTaskRunner(
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+  const auto database_task_runner = base::ThreadPool::CreateSequencedTaskRunner(
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN});
 
   db_ = db_provider->GetDB<StrikeData>(

components/autofill/core/browser/webdata/web_data_service_unittest.cc

@@ -16,6 +16,7 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task/thread_pool/thread_pool_instance.h"
 #include "base/test/task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -103,8 +104,8 @@ class WebDataServiceTest : public testing::Test {
     // TODO(pkasting): http://crbug.com/740773 This should likely be sequenced,
     // not single-threaded; it's also possible the various uses of this below
     // should each use their own sequences instead of sharing this one.
-    auto db_task_runner = base::CreateSingleThreadTaskRunner(
-        {base::ThreadPool(), base::MayBlock()});
+    auto db_task_runner =
+        base::ThreadPool::CreateSingleThreadTaskRunner({base::MayBlock()});
     wdbs_ = new WebDatabaseService(path, base::ThreadTaskRunnerHandle::Get(),
                                    db_task_runner);
     wdbs_->AddTable(std::make_unique<AutofillTable>());

components/cdm/browser/cdm_message_filter_android.cc

@@ -13,6 +13,7 @@
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "components/cdm/common/cdm_messages_android.h"
 #include "content/public/browser/android/android_overlay_provider.h"
 #include "ipc/ipc_message_macros.h"
@@ -140,9 +141,8 @@ CdmMessageFilterAndroid::CdmMessageFilterAndroid(
     bool can_persist_data,
     bool force_to_support_secure_codecs)
     : BrowserMessageFilter(EncryptedMediaMsgStart),
-      task_runner_(
-          base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                           base::TaskPriority::USER_VISIBLE})),
+      task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE})),
       can_persist_data_(can_persist_data),
       force_to_support_secure_codecs_(force_to_support_secure_codecs) {}
 

components/component_updater/component_installer.cc

@@ -18,6 +18,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "base/version.h"
@@ -65,8 +66,8 @@ void ComponentInstaller::Register(ComponentUpdateService* cus,
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   // Some components may affect user visible features, hence USER_VISIBLE.
-  task_runner_ = base::CreateSequencedTaskRunner(
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::USER_VISIBLE,
+  task_runner_ = base::ThreadPool::CreateSequencedTaskRunner(
+      {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
        base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN});
 
   if (!installer_policy_) {

components/component_updater/crl_set_remover.cc

@@ -7,13 +7,13 @@
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 
 namespace component_updater {
 
 void DeleteLegacyCRLSet(const base::FilePath& user_data_dir) {
-  base::PostTask(
-      FROM_HERE,
-      {base::ThreadPool(), base::TaskPriority::BEST_EFFORT, base::MayBlock()},
+  base::ThreadPool::PostTask(
+      FROM_HERE, {base::TaskPriority::BEST_EFFORT, base::MayBlock()},
       base::BindOnce(base::IgnoreResult(&base::DeleteFile),
                      user_data_dir.Append(
                          FILE_PATH_LITERAL("Certificate Revocation Lists")),

components/crash/content/browser/child_process_crash_observer_android.cc

@@ -8,6 +8,7 @@
 #include "base/bind.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "components/crash/android/jni_headers/ChildProcessCrashObserver_jni.h"
 #include "components/crash/content/browser/crash_metrics_reporter_android.h"
@@ -15,8 +16,8 @@
 namespace crash_reporter {
 
 ChildProcessCrashObserver::ChildProcessCrashObserver() {
-  task_runner_ = base::CreateSequencedTaskRunner(
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT});
+  task_runner_ = base::ThreadPool::CreateSequencedTaskRunner(
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT});
 }
 
 ChildProcessCrashObserver::~ChildProcessCrashObserver() = default;

components/crash/content/browser/crash_handler_host_linux.cc

@@ -32,6 +32,7 @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -118,9 +119,8 @@ CrashHandlerHostLinux::CrashHandlerHostLinux(const std::string& process_type,
       upload_(upload),
 #endif
       fd_watch_controller_(FROM_HERE),
-      blocking_task_runner_(
-          base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                           base::TaskPriority::USER_VISIBLE})) {
+      blocking_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE})) {
   int fds[2];
   // We use SOCK_SEQPACKET rather than SOCK_DGRAM to prevent the process from
   // sending datagrams to other sockets on the system. The sandbox may prevent

components/cronet/cronet_global_state_stubs.cc

@@ -7,6 +7,7 @@
 #include "base/at_exit.h"
 #include "base/feature_list.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task/thread_pool/thread_pool_instance.h"
 #include "net/proxy_resolution/configured_proxy_resolution_service.h"
 #include "net/proxy_resolution/proxy_config_service.h"
@@ -34,7 +35,7 @@ scoped_refptr<base::SingleThreadTaskRunner> InitializeAndCreateTaskRunner() {
   // ThreadPoolInstance themselves.
   base::ThreadPoolInstance::CreateAndStartWithDefaultParams("cronet");
 
-  return base::CreateSingleThreadTaskRunner({base::ThreadPool()});
+  return base::ThreadPool::CreateSingleThreadTaskRunner({});
 }
 
 base::SingleThreadTaskRunner* InitTaskRunner() {

components/data_reduction_proxy/content/common/data_reduction_proxy_url_loader_throttle_unittest.cc

@@ -6,6 +6,7 @@
 
 #include "base/run_loop.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task/thread_pool/thread_pool_instance.h"
 #include "base/test/metrics/histogram_tester.h"
 #include "base/test/task_environment.h"
@@ -160,7 +161,7 @@ TEST_F(DataReductionProxyURLLoaderThrottleTest,
       (net::HttpRequestHeaders()), manager.get());
   throttle->DetachFromCurrentSequence();
 
-  auto task_runner = base::CreateSequencedTaskRunner({base::ThreadPool()});
+  auto task_runner = base::ThreadPool::CreateSequencedTaskRunner({});
   task_runner->DeleteSoon(FROM_HERE, throttle.release());
 }
 

components/download/database/download_db_impl.cc

@@ -9,6 +9,7 @@
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "components/download/database/download_db_conversions.h"
 #include "components/download/database/download_db_entry.h"
 #include "components/download/database/proto/download_entry.pb.h"
@@ -53,8 +54,8 @@ DownloadDBImpl::DownloadDBImpl(
   DCHECK(!database_dir.empty());
   db_ = db_provider->GetDB<download_pb::DownloadDBEntry>(
       leveldb_proto::ProtoDbType::DOWNLOAD_DB, database_dir,
-      base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(),
            // USER_VISIBLE because it is required to display chrome://downloads.
            // https://crbug.com/976223
            base::TaskPriority::USER_VISIBLE,

components/embedder_support/android/metrics/memory_metrics_logger.cc

@@ -12,6 +12,7 @@
 #include "base/metrics/histogram_functions.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
 #include "services/resource_coordinator/public/cpp/memory_instrumentation/browser_metrics.h"
@@ -103,7 +104,7 @@ struct MemoryMetricsLogger::State : public base::RefCountedThreadSafe<State> {
 MemoryMetricsLogger::MemoryMetricsLogger()
     : state_(base::MakeRefCounted<State>()) {
   g_instance = this;
-  state_->task_runner = base::CreateSequencedTaskRunner({base::ThreadPool()});
+  state_->task_runner = base::ThreadPool::CreateSequencedTaskRunner({});
   state_->task_runner->PostTask(
       FROM_HERE,
       base::BindOnce(&MemoryMetricsLogger::RecordMemoryMetricsAfterDelay,

components/exo/data_offer.cc

@@ -13,6 +13,7 @@
 #include "base/pickle.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "components/exo/data_offer_delegate.h"
 #include "components/exo/data_offer_observer.h"
 #include "components/exo/file_helper.h"
@@ -74,9 +75,8 @@ void WriteFileDescriptorOnWorkerThread(
 
 void WriteFileDescriptor(base::ScopedFD fd,
                          scoped_refptr<base::RefCountedMemory> memory) {
-  base::PostTask(
-      FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::USER_BLOCKING},
+  base::ThreadPool::PostTask(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_BLOCKING},
       base::BindOnce(&WriteFileDescriptorOnWorkerThread, std::move(fd),
                      std::move(memory)));
 }
@@ -158,9 +158,8 @@ void SendAsPNGOnWorkerThread(base::ScopedFD fd, const SkBitmap sk_bitmap) {
 void ReadPNGFromClipboard(base::ScopedFD fd) {
   const SkBitmap sk_bitmap = ui::Clipboard::GetForCurrentThread()->ReadImage(
       ui::ClipboardBuffer::kCopyPaste);
-  base::PostTask(
-      FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::USER_BLOCKING},
+  base::ThreadPool::PostTask(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_BLOCKING},
       base::BindOnce(&SendAsPNGOnWorkerThread, std::move(fd),
                      std::move(sk_bitmap)));
 }

components/exo/data_source.cc

@@ -15,6 +15,7 @@
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "components/exo/data_source_delegate.h"
 #include "components/exo/data_source_observer.h"
 #include "components/exo/mime_utils.h"
@@ -212,9 +213,9 @@ void DataSource::ReadData(const std::string& mime_type,
   PCHECK(base::CreatePipe(&read_fd, &write_fd));
   delegate_->OnSend(mime_type, std::move(write_fd));
 
-  base::PostTaskAndReplyWithResult(
+  base::ThreadPool::PostTaskAndReplyWithResult(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::USER_BLOCKING,
+      {base::MayBlock(), base::TaskPriority::USER_BLOCKING,
        base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
       base::BindOnce(&ReadDataOnWorkerThread, std::move(read_fd)),
       base::BindOnce(

components/favicon/core/large_icon_service_impl.cc

@@ -17,6 +17,7 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/favicon/core/favicon_service.h"
@@ -307,9 +308,8 @@ LargeIconWorker::LargeIconWorker(
       desired_size_in_pixel_(desired_size_in_pixel),
       raw_bitmap_callback_(std::move(raw_bitmap_callback)),
       image_callback_(std::move(image_callback)),
-      background_task_runner_(base::CreateTaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
-           base::TaskPriority::BEST_EFFORT,
+      background_task_runner_(base::ThreadPool::CreateTaskRunner(
+          {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
       tracker_(tracker),
       fallback_icon_style_(

components/feed/core/feed_content_database.cc

@@ -12,6 +12,7 @@
 #include "base/strings/string_util.h"
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/feed/core/feed_content_mutation.h"
 #include "components/feed/core/feed_content_operation.h"
@@ -53,9 +54,8 @@ FeedContentDatabase::FeedContentDatabase(
     leveldb_proto::ProtoDatabaseProvider* proto_database_provider,
     const base::FilePath& database_folder)
     : database_status_(InitStatus::kNotInitialized),
-      task_runner_(
-          base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                           base::TaskPriority::USER_VISIBLE})),
+      task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE})),
       storage_database_(proto_database_provider->GetDB<ContentStorageProto>(
           leveldb_proto::ProtoDbType::FEED_CONTENT_DATABASE,
           database_folder.AppendASCII(kContentDatabaseFolder),

components/feed/core/feed_content_database_unittest.cc

@@ -7,6 +7,7 @@
 #include <map>
 
 #include "base/bind.h"
+#include "base/task/thread_pool.h"
 #include "base/test/metrics/histogram_tester.h"
 #include "base/test/task_environment.h"
 #include "components/feed/core/feed_content_mutation.h"
@@ -57,9 +58,8 @@ class FeedContentDatabaseTest : public testing::Test {
     auto storage_db =
         std::make_unique<FakeDB<ContentStorageProto>>(&content_db_storage_);
 
-    task_runner_ =
-        base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                         base::TaskPriority::USER_VISIBLE});
+    task_runner_ = base::ThreadPool::CreateSequencedTaskRunner(
+        {base::MayBlock(), base::TaskPriority::USER_VISIBLE});
 
     content_db_ = storage_db.get();
     feed_db_ = std::make_unique<FeedContentDatabase>(std::move(storage_db),

components/feed/core/feed_journal_database.cc

@@ -10,6 +10,7 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/feed/core/feed_journal_mutation.h"
 #include "components/feed/core/feed_journal_operation.h"
@@ -38,9 +39,8 @@ FeedJournalDatabase::FeedJournalDatabase(
     leveldb_proto::ProtoDatabaseProvider* proto_database_provider,
     const base::FilePath& database_folder)
     : database_status_(InitStatus::kNotInitialized),
-      task_runner_(
-          base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                           base::TaskPriority::USER_VISIBLE})),
+      task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE})),
       storage_database_(proto_database_provider->GetDB<JournalStorageProto>(
           leveldb_proto::ProtoDbType::FEED_JOURNAL_DATABASE,
           database_folder.AppendASCII(kJournalDatabaseFolder),

components/feed/core/feed_journal_database_unittest.cc

@@ -8,6 +8,7 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/task/thread_pool.h"
 #include "base/test/metrics/histogram_tester.h"
 #include "base/test/task_environment.h"
 #include "components/feed/core/feed_journal_mutation.h"
@@ -63,9 +64,8 @@ class FeedJournalDatabaseTest : public testing::Test {
     auto storage_db =
         std::make_unique<FakeDB<JournalStorageProto>>(&journal_db_storage_);
 
-    task_runner_ =
-        base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                         base::TaskPriority::USER_VISIBLE});
+    task_runner_ = base::ThreadPool::CreateSequencedTaskRunner(
+        {base::MayBlock(), base::TaskPriority::USER_VISIBLE});
 
     journal_db_ = storage_db.get();
     feed_db_ = std::make_unique<FeedJournalDatabase>(std::move(storage_db),

components/feedback/feedback_data.cc

@@ -13,6 +13,7 @@
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/values.h"
 #include "components/feedback/feedback_util.h"
 #include "components/feedback/proto/extension.pb.h"
@@ -68,9 +69,8 @@ void FeedbackData::CompressSystemInfo() {
   }
 
   ++pending_op_count_;
-  base::PostTaskAndReply(
-      FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT},
+  base::ThreadPool::PostTaskAndReply(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
       base::BindOnce(&FeedbackData::CompressLogs, this),
       base::BindOnce(&FeedbackData::OnCompressComplete, this));
 }
@@ -79,9 +79,8 @@ void FeedbackData::SetAndCompressHistograms(std::string histograms) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ++pending_op_count_;
-  base::PostTaskAndReply(
-      FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT},
+  base::ThreadPool::PostTaskAndReply(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
       base::BindOnce(&FeedbackData::CompressFile, this,
                      base::FilePath(kHistogramsFilename),
                      kHistogramsAttachmentName, std::move(histograms)),
@@ -96,9 +95,8 @@ void FeedbackData::AttachAndCompressFileData(std::string attached_filedata) {
   ++pending_op_count_;
   base::FilePath attached_file =
                   base::FilePath::FromUTF8Unsafe(attached_filename_);
-  base::PostTaskAndReply(
-      FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT},
+  base::ThreadPool::PostTaskAndReply(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
       base::BindOnce(&FeedbackData::CompressFile, this, attached_file,
                      std::string(), std::move(attached_filedata)),
       base::BindOnce(&FeedbackData::OnCompressComplete, this));

components/feedback/feedback_uploader_factory.cc

@@ -8,6 +8,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "components/feedback/feedback_uploader.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "content/public/browser/browser_context.h"
@@ -31,8 +32,8 @@ scoped_refptr<base::SingleThreadTaskRunner>
 FeedbackUploaderFactory::CreateUploaderTaskRunner() {
   // Uses a BLOCK_SHUTDOWN file task runner because we really don't want to
   // lose reports or corrupt their files.
-  return base::CreateSingleThreadTaskRunner(
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+  return base::ThreadPool::CreateSingleThreadTaskRunner(
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
 }
 

components/games/core/catalog_store.cc

@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 
 namespace games {
@@ -16,10 +17,8 @@ CatalogStore::CatalogStore()
 
 CatalogStore::CatalogStore(std::unique_ptr<DataFilesParser> data_files_parser)
     : data_files_parser_(std::move(data_files_parser)),
-      task_runner_(
-          base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                           base::TaskPriority::USER_VISIBLE})) {
-}
+      task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE})) {}
 
 CatalogStore::~CatalogStore() = default;
 

components/games/core/highlighted_games_store.cc

@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "components/games/core/games_utils.h"
 #include "components/games/core/proto/date.pb.h"
@@ -27,9 +28,8 @@ HighlightedGamesStore::HighlightedGamesStore(
     std::unique_ptr<DataFilesParser> data_files_parser,
     base::Clock* clock)
     : data_files_parser_(std::move(data_files_parser)),
-      task_runner_(
-          base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                           base::TaskPriority::USER_BLOCKING})),
+      task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_BLOCKING})),
       clock_(clock) {}
 
 HighlightedGamesStore::~HighlightedGamesStore() = default;

components/history/core/browser/history_service.cc

@@ -28,6 +28,7 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -941,8 +942,8 @@ bool HistoryService::Init(
       }
       backend_task_runner_ = thread_->task_runner();
     } else {
-      backend_task_runner_ = base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock(), base::WithBaseSyncPrimitives(),
+      backend_task_runner_ = base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::WithBaseSyncPrimitives(),
            base::TaskPriority::USER_BLOCKING,
            base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
     }

components/history/core/browser/top_sites_backend.cc

@@ -16,6 +16,7 @@
 #include "base/task/cancelable_task_tracker.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "components/history/core/browser/top_sites_database.h"
@@ -25,8 +26,8 @@ namespace history {
 
 TopSitesBackend::TopSitesBackend()
     : db_(new TopSitesDatabase()),
-      db_task_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::TaskPriority::USER_VISIBLE,
+      db_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::TaskPriority::USER_VISIBLE,
            base::TaskShutdownBehavior::BLOCK_SHUTDOWN, base::MayBlock()})) {
   DCHECK(db_task_runner_);
 }

components/image_fetcher/core/cache/image_cache.cc

@@ -12,6 +12,7 @@
 #include "base/hash/sha1.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/time/clock.h"
@@ -143,11 +144,11 @@ void ImageCache::OnDependencyInitialized() {
       ImageFetcherEvent::kCacheStartupEvictionStarted);
 
   // Once all the queued requests are taken care of, run eviction.
-  base::PostTaskAndReply(FROM_HERE,
-                         {base::ThreadPool(), base::TaskPriority::BEST_EFFORT},
-                         base::BindOnce(OnStartupEvictionQueued),
-                         base::BindOnce(&ImageCache::RunEvictionOnStartup,
-                                        weak_ptr_factory_.GetWeakPtr()));
+  base::ThreadPool::PostTaskAndReply(
+      FROM_HERE, {base::TaskPriority::BEST_EFFORT},
+      base::BindOnce(OnStartupEvictionQueued),
+      base::BindOnce(&ImageCache::RunEvictionOnStartup,
+                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ImageCache::SaveImageImpl(const std::string& url,

components/image_fetcher/ios/ios_image_data_fetcher_wrapper.mm

@@ -6,6 +6,7 @@
 
 #include "base/bind.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #import "components/image_fetcher/ios/webp_decoder.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
@@ -66,10 +67,9 @@ IOSImageDataFetcherWrapper::CallbackForImageDataFetcher(
     // The image is a webp image.
     RequestMetadata webp_metadata = metadata;
 
-    base::PostTaskAndReplyWithResult(
+    base::ThreadPool::PostTaskAndReplyWithResult(
         FROM_HERE,
         {
-            base::ThreadPool(),
             base::TaskPriority::BEST_EFFORT,
             base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
         },

components/image_fetcher/ios/ios_image_decoder_impl.mm

@@ -13,6 +13,7 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #import "components/image_fetcher/ios/webp_decoder.h"
 #include "ios/web/public/thread/web_thread.h"
 #include "ui/gfx/geometry/size.h"
@@ -41,9 +42,8 @@ class IOSImageDecoderImpl : public ImageDecoder {
 
   // The task runner used to decode images if necessary.
   const scoped_refptr<base::TaskRunner> task_runner_ =
-      base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
-           base::TaskPriority::BEST_EFFORT,
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
            base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN});
 
   // The WeakPtrFactory is used to cancel callbacks if ImageFetcher is

components/language/content/browser/geo_language_provider.cc

@@ -8,6 +8,7 @@
 #include "base/memory/singleton.h"
 #include "base/no_destructor.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/language/content/browser/language_code_locator_provider.h"
@@ -36,9 +37,8 @@ const char GeoLanguageProvider::kCachedGeoLanguagesPref[] =
 
 GeoLanguageProvider::GeoLanguageProvider()
     : creation_task_runner_(base::SequencedTaskRunnerHandle::Get()),
-      background_task_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
-           base::TaskPriority::BEST_EFFORT,
+      background_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
       prefs_(nullptr) {
   // Constructor is not required to run on |background_task_runner_|:

components/leveldb_proto/internal/proto_database_impl_unittest.cc

@@ -8,6 +8,7 @@
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/task_environment.h"
 #include "components/leveldb_proto/internal/leveldb_proto_feature_list.h"
@@ -156,7 +157,7 @@ class ProtoDatabaseImplTest : public testing::Test {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(shared_db_temp_dir_.CreateUniqueTempDir());
     test_task_runner_ =
-        base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock()});
+        base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
     shared_db_ = base::WrapRefCounted(new SharedProtoDatabase(
         kDefaultClientName, shared_db_temp_dir_.GetPath()));
   }

components/leveldb_proto/internal/shared_proto_database.cc

@@ -10,6 +10,7 @@
 #include "base/bind_helpers.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "components/leveldb_proto/internal/leveldb_database.h"
 #include "components/leveldb_proto/internal/proto_database_selector.h"
 #include "components/leveldb_proto/internal/proto_leveldb_wrapper.h"
@@ -54,8 +55,8 @@ SharedProtoDatabase::InitRequest::~InitRequest() = default;
 
 SharedProtoDatabase::SharedProtoDatabase(const std::string& client_db_id,
                                          const base::FilePath& db_dir)
-    : task_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
+    : task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(),
            // crbug/1006954 and crbug/976223 explain why one of the clients
            // needs run in visible priority. Download DB is always loaded to
            // check for in progress downloads at startup. So, always load shared

components/login/secure_module_util_chromeos.cc

@@ -8,6 +8,7 @@
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 
 namespace login {
 
@@ -38,9 +39,8 @@ void GetSecureModuleUsed(GetSecureModuleUsedCallback callback) {
     return;
   }
 
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
       base::BindOnce(&GetSecureModuleInfoFromFilesAndCacheIt),
       std::move(callback));
 }

components/metal_util/test_shader.mm

@@ -16,6 +16,7 @@
 #include "base/strings/sys_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "components/crash/core/common/crash_key.h"
 #include "components/metal_util/device.h"
 
@@ -679,9 +680,9 @@ void TestRenderPipelineStateNow(base::scoped_nsprotocol<id<MTLDevice>> device,
   // calling into the Metal API.
   auto state =
       base::MakeRefCounted<TestShaderState>(std::move(callback), timeout);
-  base::PostDelayedTask(FROM_HERE, {base::ThreadPool()},
-                        base::BindOnce(&TestShaderState::OnTimeout, state),
-                        timeout);
+  base::ThreadPool::PostDelayedTask(
+      FROM_HERE, {}, base::BindOnce(&TestShaderState::OnTimeout, state),
+      timeout);
 
   // Request asynchronous compile of the RenderPipelineState.
   base::scoped_nsobject<MTLRenderPipelineDescriptor> descriptor(
@@ -716,9 +717,9 @@ void TestShaderNow(base::scoped_nsprotocol<id<MTLDevice>> device,
   // calling into the Metal API.
   auto state =
       base::MakeRefCounted<TestShaderState>(std::move(callback), timeout);
-  base::PostDelayedTask(FROM_HERE, {base::ThreadPool()},
-                        base::BindOnce(&TestShaderState::OnTimeout, state),
-                        timeout);
+  base::ThreadPool::PostDelayedTask(
+      FROM_HERE, {}, base::BindOnce(&TestShaderState::OnTimeout, state),
+      timeout);
 
   const std::string shader_source =
       base::StringPrintf(kTestShaderSource, base::RandDouble());

components/metrics/cloned_install_detector.cc

@@ -14,6 +14,7 @@
 #include "base/metrics/metrics_hashes.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "components/metrics/machine_id_provider.h"
 #include "components/metrics/metrics_pref_names.h"
@@ -54,9 +55,9 @@ ClonedInstallDetector::~ClonedInstallDetector() {
 }
 
 void ClonedInstallDetector::CheckForClonedInstall(PrefService* local_state) {
-  base::PostTaskAndReplyWithResult(
+  base::ThreadPool::PostTaskAndReplyWithResult(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(&MachineIdProvider::GetMachineId),
       base::BindOnce(&ClonedInstallDetector::SaveMachineId,

components/metrics/drive_metrics_provider.cc

@@ -13,6 +13,7 @@
 #include "base/path_service.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "base/time/time.h"
 
@@ -32,9 +33,9 @@ void DriveMetricsProvider::ProvideSystemProfileMetrics(
 }
 
 void DriveMetricsProvider::AsyncInit(base::OnceClosure done_callback) {
-  base::PostTaskAndReplyWithResult(
+  base::ThreadPool::PostTaskAndReplyWithResult(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
       base::BindOnce(&DriveMetricsProvider::GetDriveMetricsOnBackgroundThread,
                      local_state_path_key_),

components/metrics/file_metrics_provider.cc

@@ -23,6 +23,7 @@
 #include "base/strings/string_piece.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
@@ -97,9 +98,9 @@ scoped_refptr<base::TaskRunner> CreateBackgroundTaskRunner() {
   if (g_task_runner_for_testing)
     return scoped_refptr<base::TaskRunner>(g_task_runner_for_testing);
 
-  return base::CreateTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                 base::TaskPriority::BEST_EFFORT,
-                                 base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN});
+  return base::ThreadPool::CreateTaskRunner(
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+       base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN});
 }
 
 }  // namespace

components/metrics/net/network_metrics_provider.cc

@@ -21,6 +21,7 @@
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "net/base/net_errors.h"
@@ -301,9 +302,9 @@ NetworkMetricsProvider::GetWifiPHYLayerProtocol() const {
 
 void NetworkMetricsProvider::ProbeWifiPHYLayerProtocol() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  base::PostTaskAndReplyWithResult(
+  base::ThreadPool::PostTaskAndReplyWithResult(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(&net::GetWifiPHYLayerProtocol),
       base::BindOnce(&NetworkMetricsProvider::OnWifiPHYLayerProtocolResult,

components/metrics/persistent_histograms.cc

@@ -15,6 +15,7 @@
 #include "base/strings/string_util.h"
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "components/metrics/persistent_system_profile.h"
@@ -168,9 +169,9 @@ void InstantiatePersistentHistograms(const base::FilePath& metrics_dir) {
       }
     }
     // Schedule the creation of a "spare" file for use on the next run.
-    base::PostDelayedTask(
+    base::ThreadPool::PostDelayedTask(
         FROM_HERE,
-        {base::ThreadPool(), base::MayBlock(), base::TaskPriority::LOWEST,
+        {base::MayBlock(), base::TaskPriority::LOWEST,
          base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
         base::BindOnce(base::IgnoreResult(
                            &base::GlobalHistogramAllocator::CreateSpareFile),
@@ -211,9 +212,9 @@ void InstantiatePersistentHistograms(const base::FilePath& metrics_dir) {
   allocator->CreateTrackingHistograms(kBrowserMetricsName);
 
 #if defined(OS_WIN)
-  base::PostDelayedTask(
+  base::ThreadPool::PostDelayedTask(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::LOWEST,
+      {base::MayBlock(), base::TaskPriority::LOWEST,
        base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
       base::BindOnce(&DeleteOldWindowsTempFiles, std::move(metrics_dir)),
       kDeleteOldWindowsTempFilesDelay);

components/mirroring/service/session.cc

@@ -20,6 +20,7 @@
 #include "base/strings/string_util.h"
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
@@ -668,12 +669,12 @@ void Session::OnAnswer(const std::vector<FrameSenderConfig>& audio_configs,
   const bool initially_starting_session =
       !audio_encode_thread_ && !video_encode_thread_;
   if (initially_starting_session) {
-    audio_encode_thread_ = base::CreateSingleThreadTaskRunner(
-        {base::ThreadPool(), base::TaskPriority::USER_BLOCKING,
+    audio_encode_thread_ = base::ThreadPool::CreateSingleThreadTaskRunner(
+        {base::TaskPriority::USER_BLOCKING,
          base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
         base::SingleThreadTaskRunnerThreadMode::DEDICATED);
-    video_encode_thread_ = base::CreateSingleThreadTaskRunner(
-        {base::ThreadPool(), base::TaskPriority::USER_BLOCKING,
+    video_encode_thread_ = base::ThreadPool::CreateSingleThreadTaskRunner(
+        {base::TaskPriority::USER_BLOCKING,
          base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
         base::SingleThreadTaskRunnerThreadMode::DEDICATED);
   }

components/nacl/browser/nacl_browser.cc

@@ -283,8 +283,8 @@ void NaClBrowser::EnsureIrtAvailable() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (IsOk() && irt_state_ == NaClResourceUninitialized) {
     irt_state_ = NaClResourceRequested;
-    auto task_runner = base::CreateTaskRunner(
-        {base::ThreadPool(), base::MayBlock(), kUserBlocking,
+    auto task_runner = base::ThreadPool::CreateTaskRunner(
+        {base::MayBlock(), kUserBlocking,
          base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN});
     std::unique_ptr<base::FileProxy> file_proxy(
         new base::FileProxy(task_runner.get()));
@@ -377,10 +377,8 @@ void NaClBrowser::EnsureValidationCacheAvailable() {
       // We can get away not giving this a sequence ID because this is the first
       // task and further file access will not occur until after we get a
       // response.
-      base::PostTaskAndReply(
-          FROM_HERE,
-          {base::ThreadPool(), base::MayBlock(),
-           base::TaskPriority::BEST_EFFORT},
+      base::ThreadPool::PostTaskAndReply(
+          FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
           base::BindOnce(ReadCache, validation_cache_file_path_, data),
           base::BindOnce(&NaClBrowser::OnValidationCacheLoaded,
                          base::Unretained(this), base::Owned(data)));

components/nacl/browser/nacl_browser.h

@@ -15,6 +15,7 @@
 #include "base/files/file.h"
 #include "base/macros.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "components/nacl/browser/nacl_browser_delegate.h"
@@ -206,8 +207,8 @@ class NaClBrowser {
   base::circular_deque<base::Time> crash_times_;
 
   scoped_refptr<base::SequencedTaskRunner> file_task_runner_ =
-      base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                       base::TaskPriority::USER_VISIBLE});
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE});
 
   DISALLOW_COPY_AND_ASSIGN(NaClBrowser);
 };

components/nacl/browser/nacl_file_host.cc

@@ -14,6 +14,7 @@
 #include "base/files/file_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "components/nacl/browser/bad_message.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "components/nacl/browser/nacl_browser_delegate.h"
@@ -176,9 +177,10 @@ void GetReadonlyPnaclFd(
     const std::string& filename,
     bool is_executable,
     IPC::Message* reply_msg) {
-  base::PostTask(FROM_HERE, {base::ThreadPool(), base::MayBlock()},
-                 base::BindOnce(&DoOpenPnaclFile, nacl_host_message_filter,
-                                filename, is_executable, reply_msg));
+  base::ThreadPool::PostTask(
+      FROM_HERE, {base::MayBlock()},
+      base::BindOnce(&DoOpenPnaclFile, nacl_host_message_filter, filename,
+                     is_executable, reply_msg));
 }
 
 // This function is security sensitive.  Be sure to check with a security
@@ -253,8 +255,8 @@ void OpenNaClExecutable(
   // The URL is part of the current app. Now query the extension system for the
   // file path and convert that to a file descriptor. This should be done on a
   // blocking pool thread.
-  base::PostTask(
-      FROM_HERE, {base::ThreadPool(), base::MayBlock()},
+  base::ThreadPool::PostTask(
+      FROM_HERE, {base::MayBlock()},
       base::BindOnce(&DoOpenNaClExecutableOnThreadPool,
                      nacl_host_message_filter, file_url,
                      enable_validation_caching, map_url_callback, reply_msg));

components/nacl/browser/nacl_host_message_filter.cc

@@ -11,6 +11,7 @@
 #include "base/bind.h"
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "build/build_config.h"
 #include "components/nacl/browser/bad_message.h"
 #include "components/nacl/browser/nacl_browser.h"
@@ -205,9 +206,9 @@ void NaClHostMessageFilter::LaunchNaClContinuation(
 
   // Process a list of resource file URLs in
   // |launch_params.resource_files_to_prefetch|.
-  base::PostTask(
+  base::ThreadPool::PostTask(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::USER_BLOCKING,
+      {base::MayBlock(), base::TaskPriority::USER_BLOCKING,
        base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
       base::BindOnce(&NaClHostMessageFilter::BatchOpenResourceFiles, this,
                      safe_launch_params, reply_msg, permissions,

components/nacl/browser/nacl_process_host.cc

@@ -31,6 +31,7 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "components/nacl/browser/nacl_browser.h"
@@ -276,17 +277,15 @@ NaClProcessHost::~NaClProcessHost() {
     // handles.
     base::File file(IPC::PlatformFileForTransitToFile(
         prefetched_resource_files_[i].file));
-    base::PostTask(
-        FROM_HERE,
-        {base::ThreadPool(), base::TaskPriority::BEST_EFFORT, base::MayBlock()},
+    base::ThreadPool::PostTask(
+        FROM_HERE, {base::TaskPriority::BEST_EFFORT, base::MayBlock()},
         base::BindOnce(&CloseFile, std::move(file)));
   }
 #endif
   // Open files need to be closed on the blocking pool.
   if (nexe_file_.IsValid()) {
-    base::PostTask(
-        FROM_HERE,
-        {base::ThreadPool(), base::TaskPriority::BEST_EFFORT, base::MayBlock()},
+    base::ThreadPool::PostTask(
+        FROM_HERE, {base::TaskPriority::BEST_EFFORT, base::MayBlock()},
         base::BindOnce(&CloseFile, std::move(nexe_file_)));
   }
 
@@ -835,9 +834,8 @@ void NaClProcessHost::StartNaClFileResolved(
   if (checked_nexe_file.IsValid()) {
     // Release the file received from the renderer. This has to be done on a
     // thread where IO is permitted, though.
-    base::PostTask(
-        FROM_HERE,
-        {base::ThreadPool(), base::TaskPriority::BEST_EFFORT, base::MayBlock()},
+    base::ThreadPool::PostTask(
+        FROM_HERE, {base::TaskPriority::BEST_EFFORT, base::MayBlock()},
         base::BindOnce(&CloseFile, std::move(nexe_file_)));
     params.nexe_file_path_metadata = file_path;
     params.nexe_file =

components/nacl/browser/pnacl_host.cc

@@ -32,9 +32,9 @@ static const base::FilePath::CharType kTranslationCacheDirectoryName[] =
 static const int kTranslationCacheInitializationDelayMs = 20;
 
 void CloseBaseFile(base::File file) {
-  base::PostTask(
+  base::ThreadPool::PostTask(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(base::DoNothing::Once<base::File>(), std::move(file)));
 }
@@ -162,9 +162,8 @@ void PnaclHost::Init() {
 // and re-initializing file task runner.
 void PnaclHost::InitForTest(base::FilePath temp_dir, bool in_memory) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  file_task_runner_ =
-      base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                       base::TaskPriority::USER_VISIBLE});
+  file_task_runner_ = base::ThreadPool::CreateSequencedTaskRunner(
+      {base::MayBlock(), base::TaskPriority::USER_VISIBLE});
   disk_cache_.reset(new PnaclTranslationCache());
   cache_state_ = CacheInitializing;
   temp_dir_ = temp_dir;
@@ -376,9 +375,8 @@ void PnaclHost::CheckCacheQueryReady(
   pt->got_nexe_fd = false;
   FileProxy* proxy(new FileProxy(std::move(file), this));
 
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
       base::BindOnce(&FileProxy::Write, base::Unretained(proxy),
                      pt->nexe_read_buffer),
       base::BindOnce(&FileProxy::WriteDone, base::Owned(proxy), entry->first));
@@ -451,9 +449,8 @@ void PnaclHost::TranslationFinished(int render_process_id,
     entry->second.nexe_fd = NULL;
     entry->second.got_nexe_fd = false;
 
-    base::PostTaskAndReplyWithResult(
-        FROM_HERE,
-        {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT},
+    base::ThreadPool::PostTaskAndReplyWithResult(
+        FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
         base::BindOnce(&PnaclHost::CopyFileToBuffer, Passed(&file)),
         base::BindOnce(&PnaclHost::StoreTranslatedNexe, base::Unretained(this),
                        id));

components/nacl/browser/pnacl_host.h

@@ -15,6 +15,7 @@
 #include "base/macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_checker.h"
 #include "components/nacl/browser/nacl_file_host.h"
 #include "components/nacl/common/pnacl_types.h"
@@ -180,8 +181,8 @@ class PnaclHost {
   void DeInitIfSafe();
 
   scoped_refptr<base::SequencedTaskRunner> file_task_runner_ =
-      base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                       base::TaskPriority::USER_VISIBLE});
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE});
 
   // Operations which are pending with the cache backend, which we should
   // wait for before destroying it (see comment on DeInitIfSafe).

components/net_log/net_export_file_writer.cc

@@ -16,6 +16,7 @@
 #include "base/files/scoped_file.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
@@ -65,8 +66,8 @@ scoped_refptr<base::SequencedTaskRunner> CreateFileTaskRunner() {
   //
   // These operations can be skipped on shutdown since FileNetLogObserver's API
   // doesn't require things to have completed until notified of completion.
-  return base::CreateSequencedTaskRunner(
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::USER_VISIBLE,
+  return base::ThreadPool::CreateSequencedTaskRunner(
+      {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
        base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN});
 }
 

components/ntp_snippets/remote/remote_suggestions_database.cc

@@ -10,6 +10,7 @@
 #include "base/files/file_path.h"
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "components/leveldb_proto/public/proto_database_provider.h"
 #include "components/ntp_snippets/remote/proto/ntp_snippets.pb.h"
 
@@ -31,9 +32,8 @@ RemoteSuggestionsDatabase::RemoteSuggestionsDatabase(
     : RemoteSuggestionsDatabase(
           proto_database_provider,
           database_dir,
-          base::CreateSequencedTaskRunner(
-              {base::ThreadPool(), base::MayBlock(),
-               base::TaskPriority::BEST_EFFORT,
+          base::ThreadPool::CreateSequencedTaskRunner(
+              {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
                base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN})) {}
 
 RemoteSuggestionsDatabase::RemoteSuggestionsDatabase(

components/omnibox/browser/in_memory_url_index.cc

@@ -12,6 +12,7 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
@@ -94,9 +95,8 @@ InMemoryURLIndex::InMemoryURLIndex(bookmarks::BookmarkModel* bookmark_model,
       private_data_(new URLIndexPrivateData),
       restore_cache_observer_(nullptr),
       save_cache_observer_(nullptr),
-      task_runner_(
-          base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                           base::TaskPriority::BEST_EFFORT})),
+      task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::BEST_EFFORT})),
       shutdown_(false),
       restored_(false),
       needs_to_be_cached_(false),

components/omnibox/browser/on_device_head_provider.cc

@@ -13,6 +13,7 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
@@ -84,11 +85,10 @@ OnDeviceHeadProvider::OnDeviceHeadProvider(
     : AutocompleteProvider(AutocompleteProvider::TYPE_ON_DEVICE_HEAD),
       client_(client),
       listener_(listener),
-      worker_task_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::TaskPriority::BEST_EFFORT,
+      worker_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::TaskPriority::BEST_EFFORT,
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN, base::MayBlock()})),
-      on_device_search_request_id_(0) {
-}
+      on_device_search_request_id_(0) {}
 
 OnDeviceHeadProvider::~OnDeviceHeadProvider() {}
 

components/omnibox/browser/on_device_model_update_listener.cc

@@ -7,6 +7,7 @@
 #include "base/files/file_enumerator.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "build/build_config.h"
 
@@ -41,8 +42,8 @@ OnDeviceModelUpdateListener* OnDeviceModelUpdateListener::GetInstance() {
 }
 
 OnDeviceModelUpdateListener::OnDeviceModelUpdateListener()
-    : task_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::TaskPriority::BEST_EFFORT,
+    : task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::TaskPriority::BEST_EFFORT,
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN, base::MayBlock()})) {}
 
 OnDeviceModelUpdateListener::~OnDeviceModelUpdateListener() = default;

components/omnibox/browser/shortcuts_backend.cc

@@ -19,6 +19,7 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/omnibox/browser/autocomplete_input.h"
 #include "components/omnibox/browser/autocomplete_match.h"
@@ -75,9 +76,8 @@ ShortcutsBackend::ShortcutsBackend(
       search_terms_data_(std::move(search_terms_data)),
       current_state_(NOT_INITIALIZED),
       main_runner_(base::ThreadTaskRunnerHandle::Get()),
-      db_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
-           base::TaskPriority::BEST_EFFORT,
+      db_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
       no_db_access_(suppress_db) {
   if (!suppress_db)