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

Split directories [p* - z*] (%third_party)
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: I15a3fe157390bf24d04bd37024b3420c0740683d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2074917
Reviewed-by: François Doray <fdoray@chromium.org>
Reviewed-by: Gabriel Charette <gab@chromium.org>
Commit-Queue: Gabriel Charette <gab@chromium.org>
Cr-Commit-Position: refs/heads/master@{#744694}

printing/printed_document.cc

@@ -23,6 +23,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/time/time.h"
 #include "base/values.h"
 #include "printing/metafile.h"
@@ -98,9 +99,8 @@ void DebugDumpSettings(const base::string16& doc_name,
       job_settings, base::JSONWriter::OPTIONS_PRETTY_PRINT, &settings_str);
   scoped_refptr<base::RefCountedMemory> data =
       base::RefCountedString::TakeString(&settings_str);
-  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(&DebugDumpDataTask, doc_name, FILE_PATH_LITERAL(".json"),
                      base::RetainedRef(data)));
 }
@@ -143,9 +143,8 @@ void PrintedDocument::SetPage(int page_number,
   }
 
   if (HasDebugDumpPath()) {
-    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(&DebugDumpPageTask, name(), base::RetainedRef(page)));
   }
 }
@@ -183,9 +182,8 @@ void PrintedDocument::SetDocument(std::unique_ptr<MetafilePlayer> metafile,
   }
 
   if (HasDebugDumpPath()) {
-    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(&DebugDumpTask, name(), mutable_.metafile_.get()));
   }
 }
@@ -281,9 +279,8 @@ void PrintedDocument::DebugDumpData(
     const base::RefCountedMemory* data,
     const base::FilePath::StringType& extension) {
   DCHECK(HasDebugDumpPath());
-  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(&DebugDumpDataTask, name(), extension,
                      base::RetainedRef(data)));
 }

remoting/host/file_transfer/local_file_operations.cc

@@ -17,6 +17,7 @@
 #include "base/sequenced_task_runner.h"
 #include "base/strings/stringprintf.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 "build/build_config.h"
@@ -50,12 +51,12 @@ scoped_refptr<base::SequencedTaskRunner> CreateFileTaskRunner() {
   // logged-in user, while the process as a whole runs as SYSTEM. Since user
   // impersonation is per-thread on Windows, we need a dedicated thread to
   // ensure that no other code is accidentally run with the wrong privileges.
-  return base::CreateSingleThreadTaskRunner(
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT},
+  return base::ThreadPool::CreateSingleThreadTaskRunner(
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
       base::SingleThreadTaskRunnerThreadMode::DEDICATED);
 #else
-  return base::CreateSequencedTaskRunner(
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT});
+  return base::ThreadPool::CreateSequencedTaskRunner(
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT});
 #endif
 }
 

remoting/host/it2me/it2me_native_messaging_host_chromeos.cc

@@ -9,6 +9,7 @@
 #include "base/lazy_instance.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/it2me/it2me_native_messaging_host.h"
@@ -25,9 +26,8 @@ CreateIt2MeNativeMessagingHostForChromeOS(
   std::unique_ptr<ChromotingHostContext> context =
       ChromotingHostContext::CreateForChromeOS(
           io_runnner, ui_runnner,
-          base::CreateSingleThreadTaskRunner(
-              {base::ThreadPool(), base::MayBlock(),
-               base::TaskPriority::BEST_EFFORT}));
+          base::ThreadPool::CreateSingleThreadTaskRunner(
+              {base::MayBlock(), base::TaskPriority::BEST_EFFORT}));
   std::unique_ptr<PolicyWatcher> policy_watcher =
       PolicyWatcher::CreateWithPolicyService(policy_service);
   std::unique_ptr<extensions::NativeMessageHost> host(

remoting/protocol/webrtc_video_renderer_adapter.cc

@@ -14,6 +14,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/threading/thread_task_runner_handle.h"
 #include "remoting/protocol/client_video_stats_dispatcher.h"
 #include "remoting/protocol/frame_consumer.h"
@@ -175,9 +176,8 @@ void WebrtcVideoRendererAdapter::HandleFrameOnMainThread(
       video_renderer_->GetFrameConsumer()->AllocateFrame(
           webrtc::DesktopSize(frame->width(), frame->height()));
 
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE,
-      {base::ThreadPool(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(&ConvertYuvToRgb, base::Passed(&frame),
                      base::Passed(&rgb_frame),
                      video_renderer_->GetFrameConsumer()->GetPixelFormat()),

remoting/signaling/ftl_messaging_client_unittest.cc

@@ -15,6 +15,7 @@
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/test/bind_test_util.h"
 #include "base/test/mock_callback.h"
 #include "base/test/task_environment.h"
@@ -171,7 +172,7 @@ class FtlMessagingClientTest : public testing::Test {
 
 void FtlMessagingClientTest::SetUp() {
   server_task_runner_ =
-      base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock()});
+      base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
   server_ = std::make_unique<test::GrpcAsyncTestServer>(
       std::make_unique<Messaging::AsyncService>());
   FtlGrpcContext::SetChannelForTesting(server_->CreateInProcessChannel());

remoting/test/cli_util.cc

@@ -10,6 +10,7 @@
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 
 namespace {
 
@@ -92,9 +93,9 @@ std::string ReadStringFromCommandLineOrStdin(const std::string& switch_name,
 }
 
 void WaitForEnterKey(base::OnceClosure on_done) {
-  base::PostTaskAndReply(FROM_HERE, {base::ThreadPool(), base::MayBlock()},
-                         base::BindOnce([]() { getchar(); }),
-                         std::move(on_done));
+  base::ThreadPool::PostTaskAndReply(FROM_HERE, {base::MayBlock()},
+                                     base::BindOnce([]() { getchar(); }),
+                                     std::move(on_done));
 }
 
 }  // namespace test

rlz/lib/financial_ping.cc

@@ -20,6 +20,7 @@
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.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 "build/build_config.h"
@@ -261,9 +262,9 @@ void ShutdownCheck(scoped_refptr<RefCountedWaitableEvent> event) {
   // How frequently the financial ping thread should check
   // the shutdown condition?
   const base::TimeDelta kInterval = base::TimeDelta::FromMilliseconds(500);
-  base::PostDelayedTask(FROM_HERE,
-                        {base::ThreadPool(), base::TaskPriority::BEST_EFFORT},
-                        base::BindOnce(&ShutdownCheck, event), kInterval);
+  base::ThreadPool::PostDelayedTask(
+      FROM_HERE, {base::TaskPriority::BEST_EFFORT},
+      base::BindOnce(&ShutdownCheck, event), kInterval);
 }
 #endif
 
@@ -391,16 +392,15 @@ FinancialPing::PingResponse FinancialPing::PingServer(const char* request,
 
   base::subtle::Release_Store(&g_cancelShutdownCheck, 0);
 
-  base::PostTask(FROM_HERE,
-                 {base::ThreadPool(), base::TaskPriority::BEST_EFFORT},
-                 base::BindOnce(&ShutdownCheck, event));
+  base::ThreadPool::PostTask(FROM_HERE, {base::TaskPriority::BEST_EFFORT},
+                             base::BindOnce(&ShutdownCheck, event));
 
   // PingRlzServer must be run in a separate sequence so that the TimedWait()
   // call below does not block the URL fetch response from being handled by
   // the URL delegate.
   scoped_refptr<base::SequencedTaskRunner> background_runner(
-      base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
            base::TaskPriority::BEST_EFFORT}));
   background_runner->PostTask(FROM_HERE,
                               base::BindOnce(&PingRlzServer, url, event));

services/audio/public/cpp/debug_recording_session.cc

@@ -9,6 +9,7 @@
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/task/thread_pool.h"
 #include "build/build_config.h"
 #include "media/audio/audio_debug_recording_manager.h"
 
@@ -48,9 +49,9 @@ void DebugRecordingSession::DebugRecordingFileProvider::CreateWavFile(
     media::AudioDebugRecordingStreamType stream_type,
     uint32_t id,
     CreateWavFileCallback reply_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(
           [](const base::FilePath& file_name) {

services/data_decoder/public/cpp/data_decoder.cc

@@ -6,6 +6,7 @@
 
 #include "base/memory/ref_counted.h"
 #include "base/no_destructor.h"
+#include "base/task/thread_pool.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "services/data_decoder/public/mojom/json_parser.mojom.h"
@@ -105,7 +106,7 @@ class ValueParseRequest : public base::RefCounted<ValueParseRequest<T>> {
 void BindInProcessService(
     mojo::PendingReceiver<mojom::DataDecoderService> receiver) {
   static base::NoDestructor<scoped_refptr<base::SequencedTaskRunner>>
-      task_runner{base::CreateSequencedTaskRunner({base::ThreadPool()})};
+      task_runner{base::ThreadPool::CreateSequencedTaskRunner({})};
   if (!(*task_runner)->RunsTasksInCurrentSequence()) {
     (*task_runner)
         ->PostTask(FROM_HERE,

services/device/device_service.cc

@@ -10,6 +10,7 @@
 #include "base/memory/weak_ptr.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 "build/build_config.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
@@ -134,8 +135,9 @@ DeviceService::DeviceService(
   serial_port_manager_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 #else
   // On other platforms it must be allowed to do blocking IO.
-  serial_port_manager_task_runner_ = base::CreateSequencedTaskRunner(
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT});
+  serial_port_manager_task_runner_ =
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::BEST_EFFORT});
 #endif
 #endif
   // Ensure that the battery backend is initialized now; otherwise it may end up

services/device/device_service_test_base.cc

@@ -11,6 +11,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "services/device/device_service.h"
 #include "services/device/public/cpp/geolocation/location_provider.h"
 #include "services/network/public/cpp/weak_wrapper_shared_url_loader_factory.h"
@@ -50,11 +51,10 @@ std::unique_ptr<DeviceService> CreateTestDeviceService(
 }  // namespace
 
 DeviceServiceTestBase::DeviceServiceTestBase()
-    : file_task_runner_(base::CreateSingleThreadTaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
-           base::TaskPriority::BEST_EFFORT})),
-      io_task_runner_(base::CreateSingleThreadTaskRunner(
-          {base::ThreadPool(), base::TaskPriority::USER_VISIBLE})),
+    : file_task_runner_(base::ThreadPool::CreateSingleThreadTaskRunner(
+          {base::MayBlock(), base::TaskPriority::BEST_EFFORT})),
+      io_task_runner_(base::ThreadPool::CreateSingleThreadTaskRunner(
+          {base::TaskPriority::USER_VISIBLE})),
       network_connection_tracker_(
           network::TestNetworkConnectionTracker::CreateInstance()) {}
 

services/device/generic_sensor/platform_sensor_provider_win.cc

@@ -12,6 +12,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 "base/threading/thread.h"
 #include "services/device/generic_sensor/linear_acceleration_fusion_algorithm_using_accelerometer.h"
@@ -22,8 +23,8 @@
 namespace device {
 
 PlatformSensorProviderWin::PlatformSensorProviderWin()
-    : com_sta_task_runner_(base::CreateCOMSTATaskRunner(
-          {base::ThreadPool(), base::TaskPriority::USER_VISIBLE})) {}
+    : com_sta_task_runner_(base::ThreadPool::CreateCOMSTATaskRunner(
+          {base::TaskPriority::USER_VISIBLE})) {}
 
 PlatformSensorProviderWin::~PlatformSensorProviderWin() = default;
 

services/device/generic_sensor/platform_sensor_provider_winrt.cc

@@ -7,6 +7,7 @@
 #include <comdef.h>
 
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "services/device/generic_sensor/linear_acceleration_fusion_algorithm_using_accelerometer.h"
 #include "services/device/generic_sensor/orientation_euler_angles_fusion_algorithm_using_quaternion.h"
@@ -22,8 +23,8 @@ SensorReaderFactory::CreateSensorReader(mojom::SensorType type) {
 }
 
 PlatformSensorProviderWinrt::PlatformSensorProviderWinrt()
-    : com_sta_task_runner_(base::CreateCOMSTATaskRunner(
-          {base::ThreadPool(), base::TaskPriority::USER_VISIBLE})),
+    : com_sta_task_runner_(base::ThreadPool::CreateCOMSTATaskRunner(
+          {base::TaskPriority::USER_VISIBLE})),
       sensor_reader_factory_(std::make_unique<SensorReaderFactory>()) {}
 
 PlatformSensorProviderWinrt::~PlatformSensorProviderWinrt() = default;

services/device/generic_sensor/platform_sensor_reader_linux.cc

@@ -15,6 +15,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/timer/timer.h"
 #include "services/device/generic_sensor/linux/sensor_data_linux.h"
 #include "services/device/generic_sensor/platform_sensor_linux.h"
@@ -91,9 +92,8 @@ class PollingSensorReader : public SensorReader {
   SEQUENCE_CHECKER(sequence_checker_);
 
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_ =
-      base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
-           base::TaskPriority::USER_VISIBLE,
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
            base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN});
 
   std::unique_ptr<BlockingTaskRunnerHelper, base::OnTaskRunnerDeleter>

services/device/serial/serial_io_handler.cc

@@ -14,6 +14,7 @@
 #include "base/strings/string_util.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "build/build_config.h"
 
 #if defined(OS_CHROMEOS)
@@ -65,11 +66,11 @@ void SerialIoHandler::Open(const mojom::SerialConnectionOptions& options,
                      base::BindRepeating(&SerialIoHandler::OnPathOpenError,
                                          this, task_runner)));
 #else
-  base::PostTask(FROM_HERE,
-                 {base::ThreadPool(), base::MayBlock(),
-                  base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
-                 base::BindOnce(&SerialIoHandler::StartOpen, this,
-                                base::ThreadTaskRunnerHandle::Get()));
+  base::ThreadPool::PostTask(
+      FROM_HERE,
+      {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+      base::BindOnce(&SerialIoHandler::StartOpen, this,
+                     base::ThreadTaskRunnerHandle::Get()));
 #endif  // defined(OS_CHROMEOS)
 }
 
@@ -165,10 +166,9 @@ void SerialIoHandler::Close(base::OnceClosure callback) {
   if (file_.IsValid()) {
     CancelRead(mojom::SerialReceiveError::DISCONNECTED);
     CancelWrite(mojom::SerialSendError::DISCONNECTED);
-    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(&SerialIoHandler::DoClose, std::move(file_)),
         std::move(callback));
   }

services/image_annotation/public/cpp/image_processor.cc

@@ -6,6 +6,7 @@
 
 #include "base/bind.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "services/image_annotation/image_annotation_metrics.h"
@@ -79,9 +80,8 @@ constexpr int ImageProcessor::kJpgQuality;
 
 ImageProcessor::ImageProcessor(base::RepeatingCallback<SkBitmap()> get_pixels)
     : get_pixels_(std::move(get_pixels)),
-      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})) {}
 
 ImageProcessor::~ImageProcessor() = default;
 

services/network/cookie_manager_unittest.cc

@@ -12,6 +12,7 @@
 #include "base/stl_util.h"
 #include "base/strings/strcat.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/bind_test_util.h"
 #include "base/test/task_environment.h"
@@ -2248,7 +2249,7 @@ class SessionCleanupCookieManagerTest : public CookieManagerTest {
 
  private:
   const scoped_refptr<base::SequencedTaskRunner> background_task_runner_ =
-      base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock()});
+      base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
 };
 
 TEST_F(SessionCleanupCookieManagerTest, PersistSessionCookies) {

services/network/crl_set_distributor.cc

@@ -11,6 +11,7 @@
 #include "base/location.h"
 #include "base/strings/string_piece.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 
 namespace network {
 
@@ -57,8 +58,8 @@ void CRLSetDistributor::OnNewCRLSet(base::span<const uint8_t> crl_set,
   std::string crl_set_string(reinterpret_cast<const char*>(crl_set.data()),
                              crl_set.size());
 
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE, {base::ThreadPool(), base::TaskPriority::BEST_EFFORT},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::TaskPriority::BEST_EFFORT},
       base::BindOnce(&ParseCRLSet, std::move(crl_set_string)),
       base::BindOnce(&ProcessParsedCRLSet,
                      base::BindOnce(&CRLSetDistributor::OnCRLSetParsed,

services/network/legacy_tls_config_distributor.cc

@@ -15,6 +15,7 @@
 #include "base/strings/string_util.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "crypto/sha2.h"
 
 namespace network {
@@ -82,8 +83,8 @@ void LegacyTLSConfigDistributor::OnNewLegacyTLSConfig(
   std::string config_string(reinterpret_cast<const char*>(config.data()),
                             config.size());
 
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE, {base::ThreadPool(), base::TaskPriority::USER_VISIBLE},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::TaskPriority::USER_VISIBLE},
       base::BindOnce(&LegacyTLSExperimentConfig::Parse,
                      std::move(config_string)),
       base::BindOnce(
@@ -105,4 +106,4 @@ void LegacyTLSConfigDistributor::OnLegacyTLSConfigParsed(
   }
 }
 
-}  // namespace network
+}  // namespace network

services/network/net_log_exporter.cc

@@ -12,6 +12,7 @@
 #include "base/files/scoped_temp_dir.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/values.h"
 #include "net/log/file_net_log_observer.h"
 #include "net/log/net_log_util.h"
@@ -60,10 +61,9 @@ void NetLogExporter::Start(base::File destination,
   static_assert(kUnlimitedFileSize == net::FileNetLogObserver::kNoLimit,
                 "Inconsistent unbounded size constants");
   if (max_file_size != kUnlimitedFileSize) {
-    base::PostTaskAndReplyWithResult(
+    base::ThreadPool::PostTaskAndReplyWithResult(
         FROM_HERE,
-        {base::ThreadPool(), base::MayBlock(),
-         base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
+        {base::MayBlock(), base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
         base::BindOnce(&NetLogExporter::CreateScratchDir,
                        scratch_dir_create_handler_for_tests_),
 
@@ -112,10 +112,9 @@ void NetLogExporter::CloseFileOffThread(base::File file) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   if (file.IsValid()) {
-    base::PostTask(
+    base::ThreadPool::PostTask(
         FROM_HERE,
-        {base::ThreadPool(), base::MayBlock(),
-         base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
+        {base::MayBlock(), base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
         base::BindOnce([](base::File f) { f.Close(); }, std::move(file)));
   }
 }
@@ -148,17 +147,17 @@ void NetLogExporter::StartWithScratchDirOrCleanup(
   } else if (!scratch_dir_path.empty()) {
     // An NetLogExporter got destroyed while it was trying to create a scratch
     // dir.
-    base::PostTask(FROM_HERE,
-                   {base::ThreadPool(), base::MayBlock(),
-                    base::TaskShutdownBehavior::BLOCK_SHUTDOWN},
-                   base::BindOnce(
-                       [](const base::FilePath& dir) {
-                         // The delete is non-recursive (2nd argument
-                         // false) since the only time this is invoked
-                         // the directory is expected to be empty.
-                         base::DeleteFile(dir, false);
-                       },
-                       scratch_dir_path));
+    base::ThreadPool::PostTask(
+        FROM_HERE,
+        {base::MayBlock(), base::TaskShutdownBehavior::BLOCK_SHUTDOWN},
+        base::BindOnce(
+            [](const base::FilePath& dir) {
+              // The delete is non-recursive (2nd argument
+              // false) since the only time this is invoked
+              // the directory is expected to be empty.
+              base::DeleteFile(dir, false);
+            },
+            scratch_dir_path));
   }
 }
 

services/network/network_context.cc

@@ -25,6 +25,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 "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "build/chromecast_buildflags.h"
@@ -1778,9 +1779,8 @@ URLRequestContextOwner NetworkContext::MakeURLRequestContext() {
     scoped_refptr<base::SequencedTaskRunner> client_task_runner =
         base::ThreadTaskRunnerHandle::Get();
     scoped_refptr<base::SequencedTaskRunner> background_task_runner =
-        base::CreateSequencedTaskRunner(
-            {base::ThreadPool(), base::MayBlock(),
-             net::GetCookieStoreBackgroundSequencePriority(),
+        base::ThreadPool::CreateSequencedTaskRunner(
+            {base::MayBlock(), net::GetCookieStoreBackgroundSequencePriority(),
              base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
 
     net::CookieCryptoDelegate* crypto_delegate = nullptr;
@@ -1817,9 +1817,8 @@ URLRequestContextOwner NetworkContext::MakeURLRequestContext() {
   if (base::FeatureList::IsEnabled(features::kTrustTokens)) {
     if (params_->trust_token_path) {
       SQLiteTrustTokenPersister::CreateForFilePath(
-          base::CreateSequencedTaskRunner(
-              {base::ThreadPool(), base::MayBlock(),
-               kTrustTokenDatabaseTaskPriority,
+          base::ThreadPool::CreateSequencedTaskRunner(
+              {base::MayBlock(), kTrustTokenDatabaseTaskPriority,
                base::TaskShutdownBehavior::BLOCK_SHUTDOWN}),
           *params_->trust_token_path, kTrustTokenWriteBufferingWindow,
           base::BindOnce(&NetworkContext::FinishConstructingTrustTokenStore,
@@ -1894,12 +1893,11 @@ URLRequestContextOwner NetworkContext::MakeURLRequestContext() {
 
   std::unique_ptr<PrefService> pref_service;
   if (params_->http_server_properties_path) {
-    scoped_refptr<JsonPrefStore> json_pref_store(
-        new JsonPrefStore(*params_->http_server_properties_path, nullptr,
-                          base::CreateSequencedTaskRunner(
-                              {base::ThreadPool(), base::MayBlock(),
-                               base::TaskShutdownBehavior::BLOCK_SHUTDOWN,
-                               base::TaskPriority::BEST_EFFORT})));
+    scoped_refptr<JsonPrefStore> json_pref_store(new JsonPrefStore(
+        *params_->http_server_properties_path, nullptr,
+        base::ThreadPool::CreateSequencedTaskRunner(
+            {base::MayBlock(), base::TaskShutdownBehavior::BLOCK_SHUTDOWN,
+             base::TaskPriority::BEST_EFFORT})));
     PrefServiceFactory pref_service_factory;
     pref_service_factory.set_user_prefs(json_pref_store);
     pref_service_factory.set_async(true);
@@ -1951,8 +1949,8 @@ URLRequestContextOwner NetworkContext::MakeURLRequestContext() {
     scoped_refptr<base::SequencedTaskRunner> client_task_runner =
         base::ThreadTaskRunnerHandle::Get();
     scoped_refptr<base::SequencedTaskRunner> background_task_runner =
-        base::CreateSequencedTaskRunner(
-            {base::ThreadPool(), base::MayBlock(),
+        base::ThreadPool::CreateSequencedTaskRunner(
+            {base::MayBlock(),
              net::GetReportingAndNelStoreBackgroundSequencePriority(),
              base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
     std::unique_ptr<net::SQLitePersistentReportingAndNelStore> sqlite_store(

services/network/network_service.cc

@@ -20,6 +20,7 @@
 #include "base/numerics/ranges.h"
 #include "base/stl_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "build/chromecast_buildflags.h"
@@ -604,8 +605,8 @@ void NetworkService::GetNetworkList(
   auto networks = std::make_unique<net::NetworkInterfaceList>();
   auto* raw_networks = networks.get();
   // net::GetNetworkList may block depending on platform.
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE, {base::ThreadPool(), base::MayBlock()},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::MayBlock()},
       base::BindOnce(&net::GetNetworkList, raw_networks, policy),
       base::BindOnce(&OnGetNetworkList, std::move(networks),
                      std::move(callback)));

services/network/p2p/socket_manager.cc

@@ -10,6 +10,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 "net/base/address_list.h"
 #include "net/base/net_errors.h"
@@ -152,9 +153,8 @@ P2PSocketManager::P2PSocketManager(
     net::URLRequestContext* url_request_context)
     : delete_callback_(std::move(delete_callback)),
       url_request_context_(url_request_context),
-      network_list_task_runner_(
-          base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                           base::TaskPriority::USER_VISIBLE})),
+      network_list_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE})),
       trusted_socket_manager_client_(std::move(trusted_socket_manager_client)),
       trusted_socket_manager_receiver_(
           this,

services/network/proxy_resolver_factory_mojo.cc

@@ -17,6 +17,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 "base/task_runner.h"
 #include "base/values.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
@@ -155,9 +156,8 @@ class ClientMixin : public ClientInterface {
     //
     // However the better place to focus on is de-duplication and caching on the
     // proxy service side (which currently caches but doesn't de-duplicate).
-    return base::CreateSequencedTaskRunner(
-        {base::ThreadPool(), base::MayBlock(),
-         base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN,
+    return base::ThreadPool::CreateSequencedTaskRunner(
+        {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN,
          base::TaskPriority::USER_VISIBLE});
   }
 

services/network/public/cpp/cert_verifier/nss_ocsp_session_url_loader_unittest.cc

@@ -23,6 +23,7 @@
 #include "base/synchronization/lock.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/test/bind_test_util.h"
 #include "base/test/task_environment.h"
 #include "base/threading/scoped_blocking_call.h"
@@ -149,8 +150,8 @@ class OCSPRequestSessionDelegateURLLoaderTest : public ::testing::Test {
   // returns the nth one.
   scoped_refptr<base::SequencedTaskRunner> worker_thread(size_t n) {
     while (worker_threads_.size() <= n) {
-      worker_threads_.push_back(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock()}));
+      worker_threads_.push_back(
+          base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()}));
     }
     return worker_threads_[n];
   }

services/network/public/cpp/cross_thread_pending_shared_url_loader_factory_unittest.cc

@@ -12,6 +12,7 @@
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/test/bind_test_util.h"
 #include "base/test/task_environment.h"
 #include "base/threading/sequenced_task_runner_handle.h"
@@ -54,8 +55,8 @@ class CrossThreadPendingSharedURLLoaderFactoryTest : public ::testing::Test {
  protected:
   void SetUp() override {
     main_thread_ = base::SequencedTaskRunnerHandle::Get();
-    loader_thread_ = base::CreateSequencedTaskRunner(
-        {base::ThreadPool(), base::MayBlock(), base::WithBaseSyncPrimitives()});
+    loader_thread_ = base::ThreadPool::CreateSequencedTaskRunner(
+        {base::MayBlock(), base::WithBaseSyncPrimitives()});
 
     test_url_loader_factory_ =
         std::make_unique<CloneCheckingURLLoaderFactory>(loader_thread_);
@@ -182,8 +183,8 @@ TEST_F(CrossThreadPendingSharedURLLoaderFactoryTest, FurtherClone) {
 TEST_F(CrossThreadPendingSharedURLLoaderFactoryTest, CloneThirdThread) {
   // Clone to a third thread.
   scoped_refptr<base::SequencedTaskRunner> third_thread =
-      base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                       base::WithBaseSyncPrimitives()});
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::WithBaseSyncPrimitives()});
 
   scoped_refptr<SharedURLLoaderFactory> main_thread_factory =
       SharedURLLoaderFactory::Create(std::move(pending_factory_));

services/network/public/cpp/simple_url_loader.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/threading/sequenced_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
@@ -853,8 +854,8 @@ class SaveToFileBodyHandler : public BodyHandler {
                base::TaskPriority priority,
                base::RepeatingCallback<void(int64_t)> progress_callback)
         : body_handler_task_runner_(base::SequencedTaskRunnerHandle::Get()),
-          file_writer_task_runner_(base::CreateSequencedTaskRunner(
-              {base::ThreadPool(), base::MayBlock(), priority,
+          file_writer_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+              {base::MayBlock(), priority,
                base::TaskShutdownBehavior::BLOCK_SHUTDOWN})),
           path_(path),
           create_temp_file_(create_temp_file),

services/network/session_cleanup_cookie_store_unittest.cc

@@ -11,6 +11,7 @@
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.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/time/time.h"
@@ -55,7 +56,7 @@ class SessionCleanupCookieStoreTest : public testing::Test {
   CanonicalCookieVector CreateAndLoad() {
     auto sqlite_store = base::MakeRefCounted<net::SQLitePersistentCookieStore>(
         temp_dir_.GetPath().Append(kTestCookiesFilename),
-        base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock()}),
+        base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()}),
         background_task_runner_, true, nullptr);
     store_ =
         base::MakeRefCounted<SessionCleanupCookieStore>(sqlite_store.get());
@@ -86,7 +87,7 @@ class SessionCleanupCookieStoreTest : public testing::Test {
 
   base::test::TaskEnvironment task_environment_;
   const scoped_refptr<base::SequencedTaskRunner> background_task_runner_ =
-      base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock()});
+      base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
   base::ScopedTempDir temp_dir_;
   scoped_refptr<SessionCleanupCookieStore> store_;
   net::RecordingBoundTestNetLog net_log_;

services/network/url_loader.cc

@@ -20,6 +20,7 @@
 #include "base/optional.h"
 #include "base/strings/strcat.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "mojo/public/cpp/system/simple_watcher.h"
@@ -692,10 +693,8 @@ class URLLoader::FileOpenerForUpload {
   // |opened_files| vector onto a sequence that can block so it gets destroyed
   // there.
   static void PostCloseFiles(std::vector<base::File> opened_files) {
-    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(base::DoNothing::Once<std::vector<base::File>>(),
                        std::move(opened_files)));
   }
@@ -777,8 +776,8 @@ void URLLoader::SetUpUpload(const ResourceRequest& request,
     return;
   }
   scoped_refptr<base::SequencedTaskRunner> task_runner =
-      base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                       base::TaskPriority::USER_VISIBLE});
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE});
   url_request_->set_upload(CreateUploadDataStream(
       request.request_body.get(), opened_files, task_runner.get()));
 

services/service_manager/service_process_launcher.cc

@@ -23,6 +23,7 @@
 #include "base/strings/string_number_conversions.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/thread.h"
 #include "build/build_config.h"
@@ -81,9 +82,9 @@ ServiceProcessLauncher::ServiceProcessLauncher(
       service_path_(service_path.empty()
                         ? base::CommandLine::ForCurrentProcess()->GetProgram()
                         : service_path),
-      background_task_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::TaskPriority::USER_VISIBLE,
-           base::WithBaseSyncPrimitives(), base::MayBlock()})) {}
+      background_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::TaskPriority::USER_VISIBLE, base::WithBaseSyncPrimitives(),
+           base::MayBlock()})) {}
 
 ServiceProcessLauncher::~ServiceProcessLauncher() {
   // We don't really need to wait for the process to be joined, as long as it

services/tracing/perfetto/consumer_host.cc

@@ -18,6 +18,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/trace_event/trace_log.h"
 #include "base/values.h"
 #include "build/build_config.h"
@@ -87,9 +88,8 @@ class ConsumerHost::StreamWriter {
   using Slice = std::string;
 
   static scoped_refptr<base::SequencedTaskRunner> CreateTaskRunner() {
-    return base::CreateSequencedTaskRunner({base::ThreadPool(),
-                                            base::WithBaseSyncPrimitives(),
-                                            base::TaskPriority::BEST_EFFORT});
+    return base::ThreadPool::CreateSequencedTaskRunner(
+        {base::WithBaseSyncPrimitives(), base::TaskPriority::BEST_EFFORT});
   }
 
   StreamWriter(mojo::ScopedDataPipeProducerHandle stream,

services/tracing/perfetto/consumer_host_unittest.cc

@@ -16,6 +16,7 @@
 #include "base/strings/strcat.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/test/bind_test_util.h"
 #include "base/test/task_environment.h"
 #include "mojo/public/cpp/bindings/receiver.h"
@@ -41,9 +42,8 @@ constexpr base::ProcessId kProducerPid = 1234;
 class ThreadedPerfettoService : public mojom::TracingSessionClient {
  public:
   ThreadedPerfettoService()
-      : task_runner_(base::CreateSequencedTaskRunner(
-            {base::ThreadPool(), base::MayBlock(),
-             base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN,
+      : task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+            {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN,
              base::WithBaseSyncPrimitives(),
              base::TaskPriority::BEST_EFFORT})) {
     perfetto_service_ = std::make_unique<PerfettoService>(task_runner_);

services/tracing/public/cpp/perfetto/task_runner.cc

@@ -13,6 +13,7 @@
 #include "base/task/common/checked_lock_impl.h"
 #include "base/task/common/scoped_defer_task_posting.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task/thread_pool/thread_pool_instance.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_local.h"
@@ -139,9 +140,8 @@ scoped_refptr<base::SequencedTaskRunner>
 PerfettoTaskRunner::GetOrCreateTaskRunner() {
   if (!task_runner_) {
     DCHECK(base::ThreadPoolInstance::Get());
-    task_runner_ =
-        base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                         base::TaskPriority::USER_BLOCKING});
+    task_runner_ = base::ThreadPool::CreateSequencedTaskRunner(
+        {base::MayBlock(), base::TaskPriority::USER_BLOCKING});
   }
 
   return task_runner_;

services/tracing/public/cpp/perfetto/task_runner_unittest.cc

@@ -10,6 +10,7 @@
 
 #include "base/memory/weak_ptr.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/test/task_environment.h"
 #include "base/threading/simple_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -95,9 +96,8 @@ class PerfettoTaskRunnerTest : public testing::Test {
   }
 
   scoped_refptr<base::SequencedTaskRunner> CreateNewTaskrunner() {
-    return base::CreateSingleThreadTaskRunner(
-        {base::ThreadPool(), base::MayBlock()},
-        base::SingleThreadTaskRunnerThreadMode::DEDICATED);
+    return base::ThreadPool::CreateSingleThreadTaskRunner(
+        {base::MayBlock()}, base::SingleThreadTaskRunnerThreadMode::DEDICATED);
   }
   void SetTaskExpectations(base::OnceClosure on_complete,
                            size_t expected_tasks,

services/tracing/public/cpp/perfetto/trace_event_data_source_unittest.cc

@@ -20,6 +20,7 @@
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/test/task_environment.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_id_name_manager.h"
@@ -1491,8 +1492,8 @@ TEST_F(TraceEventDataSourceTest, StartupTracingTimeout) {
   // deleting startup registry and setting the producer.
   auto wait_for_start_tracing = std::make_unique<base::WaitableEvent>();
   base::WaitableEvent* wait_ptr = wait_for_start_tracing.get();
-  base::PostTask(
-      FROM_HERE, {base::ThreadPool(), base::TaskPriority::BEST_EFFORT},
+  base::ThreadPool::PostTask(
+      FROM_HERE, {base::TaskPriority::BEST_EFFORT},
       base::BindOnce(
           [](std::unique_ptr<base::WaitableEvent> wait_for_start_tracing) {
             // This event can be hit anytime before startup registry is

services/tracing/public/cpp/stack_sampling/stack_unwinder_android_unittest.cc

@@ -9,6 +9,7 @@
 #include "base/profiler/stack_buffer.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/test/task_environment.h"
 #include "base/trace_event/cfi_backtrace_android.h"
 #include "services/tracing/jni_headers/UnwindTestHelper_jni.h"
@@ -61,8 +62,8 @@ TEST_F(StackUnwinderTest, UnwindCurrentThread) {
 
 TEST_F(StackUnwinderTest, UnwindOtherThread) {
   base::WaitableEvent unwind_finished_event;
-  auto task_runner = base::CreateSingleThreadTaskRunner(
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT});
+  auto task_runner = base::ThreadPool::CreateSingleThreadTaskRunner(
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT});
 
   auto callback = [](StackUnwinderAndroid* unwinder, base::PlatformThreadId tid,
                      base::WaitableEvent* unwind_finished_event,
@@ -106,8 +107,8 @@ TEST_F(StackUnwinderTest, UnwindOtherThread) {
 }
 
 TEST_F(StackUnwinderTest, UnwindOtherThreadOnJNICall) {
-  auto task_runner = base::CreateSingleThreadTaskRunner(
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT});
+  auto task_runner = base::ThreadPool::CreateSingleThreadTaskRunner(
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT});
 
   auto callback = [](StackUnwinderAndroid* unwinder, base::PlatformThreadId tid,
                      uintptr_t test_pc) {

services/video_capture/video_capture_service_impl.cc

@@ -8,6 +8,7 @@
 
 #include "base/bind.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "media/capture/video/create_video_capture_device_factory.h"
@@ -39,9 +40,8 @@ namespace video_capture {
 class VideoCaptureServiceImpl::GpuDependenciesContext {
  public:
   GpuDependenciesContext() {
-    gpu_io_task_runner_ = base::CreateSequencedTaskRunner(
-        {base::ThreadPool(), base::TaskPriority::BEST_EFFORT,
-         base::MayBlock()});
+    gpu_io_task_runner_ = base::ThreadPool::CreateSequencedTaskRunner(
+        {base::TaskPriority::BEST_EFFORT, base::MayBlock()});
   }
 
   ~GpuDependenciesContext() {

storage/browser/blob/blob_builder_from_stream.cc

@@ -9,6 +9,7 @@
 #include "base/guid.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "mojo/public/cpp/bindings/associated_remote.h"
 #include "storage/browser/blob/blob_data_item.h"
 #include "storage/browser/blob/blob_storage_context.h"
@@ -160,7 +161,7 @@ class BlobBuilderFromStream::WritePipeToFileHelper
       base::FilePath file_path,
       uint64_t max_file_size,
       DoneCallback callback) {
-    base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock()})
+    base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()})
         ->PostTask(
             FROM_HERE,
             base::BindOnce(
@@ -177,7 +178,7 @@ class BlobBuilderFromStream::WritePipeToFileHelper
       base::File file,
       uint64_t max_file_size,
       DoneCallback callback) {
-    base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock()})
+    base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()})
         ->PostTask(
             FROM_HERE,
             base::BindOnce(&WritePipeToFileHelper::CreateAndStartOnFileSequence,

storage/browser/blob/blob_builder_from_stream_unittest.cc

@@ -13,6 +13,7 @@
 #include "base/rand_util.h"
 #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/bind_test_util.h"
 #include "base/test/task_environment.h"
@@ -53,7 +54,7 @@ class BlobBuilderFromStreamTestWithDelayedLimits
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     context_ = std::make_unique<BlobStorageContext>(
         data_dir_.GetPath(), data_dir_.GetPath(),
-        base::CreateTaskRunner({base::ThreadPool(), base::MayBlock()}));
+        base::ThreadPool::CreateTaskRunner({base::MayBlock()}));
 
     limits_.max_ipc_memory_size = kTestBlobStorageMaxBytesDataItemSize;
     limits_.max_shared_memory_size = kTestBlobStorageMaxBytesDataItemSize;

storage/browser/blob/blob_impl.cc

@@ -13,6 +13,7 @@
 #include "base/containers/span.h"
 #include "base/files/file_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "net/base/io_buffer.h"
 #include "storage/browser/blob/blob_data_handle.h"
@@ -212,10 +213,8 @@ void BlobImpl::CaptureSnapshot(CaptureSnapshotCallback callback) {
           uint64_t size;
           base::Optional<base::Time> time;
         };
-        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(
                 [](const base::FilePath& path) {
                   base::File::Info info;

storage/browser/blob/blob_reader.cc

@@ -16,6 +16,7 @@
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "net/base/io_buffer.h"
@@ -72,9 +73,8 @@ int ConvertBlobErrorToNetError(BlobStatus reason) {
 BlobReader::FileStreamReaderProvider::~FileStreamReaderProvider() = default;
 
 BlobReader::BlobReader(const BlobDataHandle* blob_handle)
-    : file_task_runner_(
-          base::CreateTaskRunner({base::ThreadPool(), base::MayBlock(),
-                                  base::TaskPriority::USER_VISIBLE})),
+    : file_task_runner_(base::ThreadPool::CreateTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE})),
       net_error_(net::OK) {
   if (blob_handle) {
     if (blob_handle->IsBroken()) {

storage/browser/blob/blob_registry_impl_unittest.cc

@@ -17,6 +17,7 @@
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/test/bind_test_util.h"
 #include "base/test/task_environment.h"
 #include "base/threading/thread_restrictions.h"
@@ -66,7 +67,7 @@ class BlobRegistryImplTest : public testing::Test {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     context_ = std::make_unique<BlobStorageContext>(
         data_dir_.GetPath(), data_dir_.GetPath(),
-        base::CreateTaskRunner({base::ThreadPool(), base::MayBlock()}));
+        base::ThreadPool::CreateTaskRunner({base::MayBlock()}));
     auto storage_policy = base::MakeRefCounted<MockSpecialStoragePolicy>();
     file_system_context_ = base::MakeRefCounted<FileSystemContext>(
         base::ThreadTaskRunnerHandle::Get().get(),
@@ -149,8 +150,8 @@ class BlobRegistryImplTest : public testing::Test {
   mojo::PendingRemote<blink::mojom::BytesProvider> CreateBytesProvider(
       const std::string& bytes) {
     if (!bytes_provider_runner_) {
-      bytes_provider_runner_ = base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock()});
+      bytes_provider_runner_ =
+          base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
     }
     mojo::PendingRemote<blink::mojom::BytesProvider> result;
     auto provider = std::make_unique<MockBytesProvider>(
@@ -166,8 +167,8 @@ class BlobRegistryImplTest : public testing::Test {
       const std::string& bytes,
       mojo::PendingReceiver<blink::mojom::BytesProvider> receiver) {
     if (!bytes_provider_runner_) {
-      bytes_provider_runner_ = base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock()});
+      bytes_provider_runner_ =
+          base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
     }
     auto provider = std::make_unique<MockBytesProvider>(
         std::vector<uint8_t>(bytes.begin(), bytes.end()), &reply_request_count_,

storage/browser/blob/blob_storage_context.cc

@@ -22,6 +22,7 @@
 #include "base/numerics/safe_math.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 "base/trace_event/memory_dump_manager.h"
@@ -260,8 +261,8 @@ std::unique_ptr<BlobDataHandle> BlobStorageContext::BuildBlobInternal(
     // blob will be fully functional whether or not timestamps are set. When
     // the timestamp isn't set the blob just won't be able to detect the file
     // on disk changing after the blob is created.
-    base::PostTaskAndReplyWithResult(
-        FROM_HERE, {base::ThreadPool(), base::MayBlock()},
+    base::ThreadPool::PostTaskAndReplyWithResult(
+        FROM_HERE, {base::MayBlock()},
         base::BindOnce(
             [](std::vector<base::FilePath> paths) {
               std::vector<base::Time> result;

storage/browser/blob/blob_storage_context_mojo_unittest.cc

@@ -13,6 +13,7 @@
 #include "base/files/scoped_temp_dir.h"
 #include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/test/bind_test_util.h"
 #include "base/test/task_environment.h"
 #include "base/test/test_simple_task_runner.h"
@@ -76,8 +77,8 @@ class BlobStorageContextMojoTest : public testing::Test {
 
   void SetUpOnDiskContext() {
     if (!file_runner_) {
-      file_runner_ = base::CreateSequencedTaskRunner(
-          {base::MayBlock(), base::ThreadPool()});
+      file_runner_ =
+          base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
     }
     context_ = std::make_unique<BlobStorageContext>(
         temp_dir_.GetPath(), temp_dir_.GetPath(), file_runner_);

storage/browser/blob/blob_transport_strategy_unittest.cc

@@ -17,6 +17,7 @@
 #include "base/run_loop.h"
 #include "base/sequenced_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_restrictions.h"
 #include "mojo/core/embedder/embedder.h"
@@ -56,7 +57,7 @@ class BlobTransportStrategyTest : public testing::Test {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
 
     bytes_provider_runner_ =
-        base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock()});
+        base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
     mock_time_ = base::Time::Now();
 
     limits_.max_ipc_memory_size = kTestBlobStorageIPCThresholdBytes;

storage/browser/blob/write_blob_to_file.cc

@@ -18,6 +18,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 "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_data_item.h"
 #include "storage/browser/blob/blob_data_snapshot.h"
@@ -237,10 +238,8 @@ void HandleModifiedTimeOnBlobFileWriteComplete(
     // Special Case 1: Success but no bytes were written, so just create
     // an empty file (LocalFileStreamWriter only creates a file
     // if data is actually written).
-    base::PostTaskAndReplyWithResult(
-        FROM_HERE,
-        {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
-         base::ThreadPool()},
+    base::ThreadPool::PostTaskAndReplyWithResult(
+        FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
         base::BindOnce(CreateEmptyFileAndMaybeSetModifiedTime,
                        std::move(file_path), last_modified, flush_on_write),
         std::move(callback));
@@ -248,10 +247,8 @@ void HandleModifiedTimeOnBlobFileWriteComplete(
   } else if (success && last_modified) {
     // Special Case 2: Success and |last_modified| needs to be set. Set
     // that before reporting write completion.
-    base::PostTaskAndReplyWithResult(
-        FROM_HERE,
-        {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
-         base::ThreadPool()},
+    base::ThreadPool::PostTaskAndReplyWithResult(
+        FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
         base::BindOnce(
             [](int64_t bytes_written, base::FilePath file_path,
                base::Optional<base::Time> last_modified) {
@@ -307,10 +304,8 @@ void WriteConstructedBlobToFile(
         return;
       }
 
-      base::PostTaskAndReplyWithResult(
-          FROM_HERE,
-          {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
-           base::ThreadPool()},
+      base::ThreadPool::PostTaskAndReplyWithResult(
+          FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
           base::BindOnce(CopyFileAndMaybeWriteTimeModified, item.path(),
                          item.expected_modification_time(), file_path,
                          item.offset(), optional_size, last_modified,
@@ -323,8 +318,8 @@ void WriteConstructedBlobToFile(
   // If not, copy the BlobReader and FileStreamWriter.
   std::unique_ptr<FileStreamWriter> writer =
       FileStreamWriter::CreateForLocalFile(
-          base::CreateTaskRunner({base::MayBlock(), base::ThreadPool(),
-                                  base::TaskPriority::USER_VISIBLE})
+          base::ThreadPool::CreateTaskRunner(
+              {base::MayBlock(), base::TaskPriority::USER_VISIBLE})
               .get(),
           file_path, /*initial_offset=*/0,
           FileStreamWriter::CREATE_NEW_FILE_ALWAYS);

storage/browser/database/database_tracker.cc

@@ -14,6 +14,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "net/base/net_errors.h"
 #include "sql/database.h"
 #include "sql/meta_table.h"
@@ -95,9 +96,8 @@ DatabaseTracker::DatabaseTracker(const base::FilePath& profile_path,
       db_(new sql::Database()),
       special_storage_policy_(special_storage_policy),
       quota_manager_proxy_(quota_manager_proxy),
-      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 (quota_manager_proxy) {
     quota_manager_proxy->RegisterClient(

storage/browser/quota/quota_manager.cc

@@ -28,6 +28,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/system/sys_info.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -890,9 +891,8 @@ QuotaManager::QuotaManager(
       db_disabled_(false),
       eviction_disabled_(false),
       io_thread_(io_thread),
-      db_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
-           base::TaskPriority::USER_VISIBLE,
+      db_runner_(base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
            base::TaskShutdownBehavior::BLOCK_SHUTDOWN})),
       get_settings_function_(get_settings_function),
       is_getting_eviction_origin_(false),

storage/browser/quota/quota_settings.cc

@@ -13,6 +13,7 @@
 #include "base/rand_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 "build/build_config.h"
 #include "storage/browser/quota/quota_device_info_helper.h"
@@ -152,9 +153,9 @@ void GetNominalDynamicSettings(const base::FilePath& partition_path,
                                bool is_incognito,
                                QuotaDeviceInfoHelper* device_info_helper,
                                OptionalQuotaSettingsCallback callback) {
-  base::PostTaskAndReplyWithResult(
+  base::ThreadPool::PostTaskAndReplyWithResult(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::USER_VISIBLE,
+      {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
        base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(&CalculateNominalDynamicSettings, partition_path,
                      is_incognito, base::Unretained(device_info_helper)),

ui/aura/native_window_occlusion_tracker_win.cc

@@ -12,6 +12,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/threading/thread_task_runner_handle.h"
 #include "base/win/scoped_gdi_object.h"
@@ -110,8 +111,8 @@ NativeWindowOcclusionTrackerWin::NativeWindowOcclusionTrackerWin()
        // event hooks will happen on the same thread, as required by Windows,
        // and the task runner will have a message loop to call
        // EventHookCallback.
-      update_occlusion_task_runner_(base::CreateCOMSTATaskRunner(
-          {base::ThreadPool(), base::MayBlock(),
+      update_occlusion_task_runner_(base::ThreadPool::CreateCOMSTATaskRunner(
+          {base::MayBlock(),
            // This may be needed to determine that a window is no longer
            // occluded.
            base::TaskPriority::USER_VISIBLE,

ui/base/clipboard/clipboard_util_win.cc

@@ -20,6 +20,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 "base/threading/scoped_blocking_call.h"
 #include "base/win/scoped_hglobal.h"
 #include "base/win/shlwapi.h"
@@ -625,9 +626,8 @@ bool ClipboardUtil::GetVirtualFilesAsTempFiles(
   }
 
   // Queue a task to actually write the temp files on a worker thread.
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::USER_BLOCKING},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_BLOCKING},
       base::BindOnce(&WriteAllFileContentsToTempFiles, display_names,
                      memory_backed_contents),
       std::move(callback));  // callback on the UI thread

ui/base/ime/win/on_screen_keyboard_display_manager_input_pane.cc

@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/win/com_init_util.h"
 #include "base/win/core_winrt_util.h"
 #include "base/win/windows_version.h"
@@ -179,7 +180,7 @@ OnScreenKeyboardDisplayManagerInputPane::
     : hwnd_(hwnd),
       main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       background_task_runner_(
-          base::CreateCOMSTATaskRunner({base::ThreadPool(), base::MayBlock()})),
+          base::ThreadPool::CreateCOMSTATaskRunner({base::MayBlock()})),
       virtual_keyboard_input_pane_(
           base::MakeRefCounted<OnScreenKeyboardDisplayManagerInputPane::
                                    VirtualKeyboardInputPane>(
@@ -239,7 +240,7 @@ bool OnScreenKeyboardDisplayManagerInputPane::IsKeyboardVisible() {
 void OnScreenKeyboardDisplayManagerInputPane::SetInputPaneForTesting(
     Microsoft::WRL::ComPtr<ABI::Windows::UI::ViewManagement::IInputPane> pane) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
-  base::CreateCOMSTATaskRunner({base::ThreadPool(), base::MayBlock()})
+  base::ThreadPool::CreateCOMSTATaskRunner({base::MayBlock()})
       ->PostTask(FROM_HERE,
                  base::BindOnce(
                      &OnScreenKeyboardDisplayManagerInputPane::

ui/base/win/session_change_observer.cc

@@ -17,6 +17,7 @@
 #include "base/memory/singleton.h"
 #include "base/observer_list.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "ui/gfx/win/singleton_hwnd.h"
 #include "ui/gfx/win/singleton_hwnd_observer.h"
 
@@ -38,8 +39,8 @@ class SessionChangeObserver::WtsRegistrationNotificationManager {
         base::IgnoreResult(&WTSRegisterSessionNotification),
         gfx::SingletonHwnd::GetInstance()->hwnd(), NOTIFY_FOR_THIS_SESSION);
 
-    base::CreateCOMSTATaskRunner({base::ThreadPool()})
-        ->PostTask(FROM_HERE, std::move(wts_register));
+    base::ThreadPool::CreateCOMSTATaskRunner({})->PostTask(
+        FROM_HERE, std::move(wts_register));
   }
 
   ~WtsRegistrationNotificationManager() { RemoveSingletonHwndObserver(); }

ui/display/win/color_profile_reader.cc

@@ -10,6 +10,7 @@
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "ui/display/win/display_info.h"
 #include "ui/gfx/icc_profile.h"
 
@@ -67,9 +68,8 @@ void ColorProfileReader::UpdateIfNeeded() {
   // Enumerate device profile paths on a background thread.  When this
   // completes it will run another task on a background thread to read
   // the profiles.
-  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(
           &ColorProfileReader::BuildDeviceToPathMapOnBackgroundThread),
       base::BindOnce(&ColorProfileReader::BuildDeviceToPathMapCompleted,
@@ -97,9 +97,8 @@ void ColorProfileReader::BuildDeviceToPathMapCompleted(
 
   device_to_path_map_ = new_device_to_path_map;
 
-  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(&ColorProfileReader::ReadProfilesOnBackgroundThread,
                      new_device_to_path_map),
       base::BindOnce(&ColorProfileReader::ReadProfilesCompleted,

ui/events/ozone/device/device_manager_manual.cc

@@ -11,6 +11,7 @@
 #include "base/logging.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 "ui/events/ozone/device/device_event.h"
@@ -34,8 +35,8 @@ void ScanDevicesOnWorkerThread(std::vector<base::FilePath>* result) {
 }  // namespace
 
 DeviceManagerManual::DeviceManagerManual()
-    : blocking_task_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock()})),
+    : blocking_task_runner_(
+          base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()})),
       watcher_(new base::FilePathWatcher,
                base::OnTaskRunnerDeleter(blocking_task_runner_)) {}
 
@@ -80,10 +81,9 @@ void DeviceManagerManual::StartWatching() {
 
 void DeviceManagerManual::InitiateScanDevices() {
   std::vector<base::FilePath>* result = new std::vector<base::FilePath>();
-  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(&ScanDevicesOnWorkerThread, result),
       base::BindOnce(&DeviceManagerManual::OnDevicesScanned,
                      weak_ptr_factory_.GetWeakPtr(), base::Owned(result)));

ui/events/ozone/evdev/libgestures_glue/gesture_feedback.cc

@@ -16,6 +16,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 "ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.h"
 
 namespace ui {
@@ -237,9 +238,9 @@ void DumpTouchEventLog(
   }
 
   // Compress touchpad/mouse logs asynchronously
-  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(&CompressDumpedLog,
                      base::Passed(&log_paths_to_be_compressed)),

ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine.cc

@@ -17,6 +17,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/task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
@@ -687,12 +688,12 @@ bool XkbKeyboardLayoutEngine::SetCurrentLayoutByName(
   }
   LoadKeymapCallback reply_callback = base::BindOnce(
       &XkbKeyboardLayoutEngine::OnKeymapLoaded, weak_ptr_factory_.GetWeakPtr());
-  base::PostTask(FROM_HERE,
-                 {base::ThreadPool(), base::MayBlock(),
-                  base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
-                 base::BindOnce(&LoadKeymap, layout_name,
-                                base::ThreadTaskRunnerHandle::Get(),
-                                std::move(reply_callback)));
+  base::ThreadPool::PostTask(
+      FROM_HERE,
+      {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+      base::BindOnce(&LoadKeymap, layout_name,
+                     base::ThreadTaskRunnerHandle::Get(),
+                     std::move(reply_callback)));
 #else
   NOTIMPLEMENTED();
 #endif  // defined(OS_CHROMEOS)

ui/events/platform/x11/x11_hotplug_event_handler.cc

@@ -21,6 +21,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 "ui/events/devices/device_data_manager.h"
 #include "ui/events/devices/device_hotplug_event_observer.h"
@@ -448,10 +449,9 @@ void X11HotplugEventHandler::OnHotplugEvent() {
   // Parse the device information asynchronously since this operation may block.
   // Once the device information is extracted the parsed devices will be
   // returned via the callbacks.
-  base::PostTask(
+  base::ThreadPool::PostTask(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(),
-       base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+      {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(&HandleHotplugEventInWorker, device_infos, display_state,
                      base::ThreadTaskRunnerHandle::Get(),
                      std::move(callbacks)));

ui/ozone/platform/drm/gpu/gbm_surfaceless.cc

@@ -10,6 +10,7 @@
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gfx/gpu_fence.h"
 #include "ui/gfx/presentation_feedback.h"
@@ -154,11 +155,10 @@ void GbmSurfaceless::SwapBuffersAsync(
   base::OnceClosure fence_retired_callback = base::BindOnce(
       &GbmSurfaceless::FenceRetired, weak_factory_.GetWeakPtr(), frame);
 
-  base::PostTaskAndReply(FROM_HERE,
-                         {base::ThreadPool(), base::MayBlock(),
-                          base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
-                         std::move(fence_wait_task),
-                         std::move(fence_retired_callback));
+  base::ThreadPool::PostTaskAndReply(
+      FROM_HERE,
+      {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+      std::move(fence_wait_task), std::move(fence_retired_callback));
 }
 
 void GbmSurfaceless::PostSubBufferAsync(

ui/ozone/platform/drm/gpu/hardware_display_plane_manager_legacy.cc

@@ -12,6 +12,7 @@
 #include "base/bind.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "ui/gfx/gpu_fence.h"
 #include "ui/gfx/presentation_feedback.h"
 #include "ui/ozone/platform/drm/gpu/crtc_controller.h"
@@ -139,10 +140,9 @@ bool HardwareDisplayPlaneManagerLegacy::ValidatePrimarySize(
 void HardwareDisplayPlaneManagerLegacy::RequestPlanesReadyCallback(
     DrmOverlayPlaneList planes,
     base::OnceCallback<void(DrmOverlayPlaneList planes)> callback) {
-  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(&WaitForPlaneFences, std::move(planes)),
       std::move(callback));
 }

ui/ozone/platform/drm/host/drm_display_host_manager.cc

@@ -15,6 +15,7 @@
 #include "base/files/file_util.h"
 #include "base/strings/stringprintf.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 "ui/display/types/display_snapshot.h"
@@ -248,9 +249,9 @@ void DrmDisplayHostManager::ProcessEvent() {
     switch (event.action_type) {
       case DeviceEvent::ADD:
         if (drm_devices_.find(event.path) == drm_devices_.end()) {
-          base::PostTask(
+          base::ThreadPool::PostTask(
               FROM_HERE,
-              {base::ThreadPool(), base::MayBlock(),
+              {base::MayBlock(),
                base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
               base::BindOnce(
                   &OpenDeviceAsync, event.path,

ui/ozone/platform/headless/headless_surface_factory.cc

@@ -12,6 +12,7 @@
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "build/build_config.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkSurface.h"
@@ -85,10 +86,10 @@ class FileSurface : public SurfaceOzoneCanvas {
     // TODO(dnicoara) Use SkImage instead to potentially avoid a copy.
     // See crbug.com/361605 for details.
     if (surface_->getCanvas()->readPixels(bitmap, 0, 0)) {
-      base::PostTask(FROM_HERE,
-                     {base::ThreadPool(), base::MayBlock(),
-                      base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
-                     base::BindOnce(&WriteDataToFile, base_path_, bitmap));
+      base::ThreadPool::PostTask(
+          FROM_HERE,
+          {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+          base::BindOnce(&WriteDataToFile, base_path_, bitmap));
     }
   }
   std::unique_ptr<gfx::VSyncProvider> CreateVSyncProvider() override {
@@ -122,10 +123,10 @@ class FileGLSurface : public GLSurfaceEglReadback {
     if (!bitmap.writePixels(pixmap))
       return false;
 
-    base::PostTask(FROM_HERE,
-                   {base::ThreadPool(), base::MayBlock(),
-                    base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
-                   base::BindOnce(&WriteDataToFile, location_, bitmap));
+    base::ThreadPool::PostTask(
+        FROM_HERE,
+        {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+        base::BindOnce(&WriteDataToFile, location_, bitmap));
     return true;
   }
 

ui/ozone/platform/wayland/gpu/gbm_surfaceless_wayland.cc

@@ -8,6 +8,7 @@
 
 #include "base/bind.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gfx/gpu_fence.h"
 #include "ui/ozone/common/egl_util.h"
@@ -119,11 +120,10 @@ void GbmSurfacelessWayland::SwapBuffersAsync(
   base::OnceClosure fence_retired_callback = base::BindOnce(
       &GbmSurfacelessWayland::FenceRetired, weak_factory_.GetWeakPtr(), frame);
 
-  base::PostTaskAndReply(FROM_HERE,
-                         {base::ThreadPool(), base::MayBlock(),
-                          base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
-                         std::move(fence_wait_task),
-                         std::move(fence_retired_callback));
+  base::ThreadPool::PostTaskAndReply(
+      FROM_HERE,
+      {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+      std::move(fence_wait_task), std::move(fence_retired_callback));
 }
 
 void GbmSurfacelessWayland::PostSubBufferAsync(

ui/ozone/platform/wayland/test/test_data_offer.cc

@@ -13,6 +13,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 "ui/ozone/platform/wayland/test/constants.h"
 
 namespace wl {
@@ -65,8 +66,8 @@ const struct wl_data_offer_interface kTestDataOfferImpl = {
 
 TestDataOffer::TestDataOffer(wl_resource* resource)
     : ServerObject(resource),
-      task_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock()})),
+      task_runner_(
+          base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()})),
       write_data_weak_ptr_factory_(this) {}
 
 TestDataOffer::~TestDataOffer() {}

ui/ozone/platform/wayland/test/test_data_source.cc

@@ -14,6 +14,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/task_runner_util.h"
 #include "ui/ozone/platform/wayland/test/constants.h"
 
@@ -63,8 +64,8 @@ const struct wl_data_source_interface kTestDataSourceImpl = {
 
 TestDataSource::TestDataSource(wl_resource* resource)
     : ServerObject(resource),
-      task_runner_(base::CreateSequencedTaskRunner(
-          {base::ThreadPool(), base::MayBlock()})) {}
+      task_runner_(
+          base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()})) {}
 
 TestDataSource::~TestDataSource() {}
 

ui/snapshot/snapshot.cc

@@ -9,6 +9,7 @@
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image.h"
@@ -42,9 +43,8 @@ void EncodeImageAndScheduleCallback(
     base::OnceCallback<void(scoped_refptr<base::RefCountedMemory> data)>
         callback,
     gfx::Image image) {
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE,
-      {base::ThreadPool(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(encode_func, std::move(image)), std::move(callback));
 }
 

ui/snapshot/snapshot_async.cc

@@ -8,6 +8,7 @@
 #include "base/location.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/image/image.h"
@@ -48,9 +49,8 @@ void SnapshotAsync::ScaleCopyOutputResult(
   // from GPU. Image scaling is implemented in content::GlHelper, but it's can't
   // be used here because it's not in content/public. Move the scaling code
   // somewhere so that it can be reused here.
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE,
-      {base::ThreadPool(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(ScaleBitmap, bitmap, target_size),
       base::BindOnce(&OnFrameScalingFinished, std::move(callback)));
 }

weblayer/browser/download_manager_delegate_impl.cc

@@ -6,6 +6,7 @@
 
 #include "base/files/file_util.h"
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "components/download/public/common/download_item.h"
 #include "content/public/browser/browser_task_traits.h"
@@ -80,15 +81,14 @@ bool DownloadManagerDelegateImpl::DetermineDownloadTarget(
   base::FilePath default_download_path;
   GetSaveDir(browser_context, nullptr, &default_download_path);
 
-  base::PostTask(FROM_HERE,
-                 {base::ThreadPool(), base::MayBlock(),
-                  base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
-                  base::TaskPriority::USER_VISIBLE},
-                 base::BindOnce(GenerateFilename, item->GetURL(),
-                                item->GetContentDisposition(),
-                                item->GetSuggestedFilename(),
-                                item->GetMimeType(), default_download_path,
-                                std::move(filename_determined_callback)));
+  base::ThreadPool::PostTask(
+      FROM_HERE,
+      {base::MayBlock(), base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
+       base::TaskPriority::USER_VISIBLE},
+      base::BindOnce(
+          GenerateFilename, item->GetURL(), item->GetContentDisposition(),
+          item->GetSuggestedFilename(), item->GetMimeType(),
+          default_download_path, std::move(filename_determined_callback)));
   return true;
 }
 

weblayer/browser/i18n_util.cc

@@ -6,6 +6,7 @@
 
 #include "base/i18n/rtl.h"
 #include "base/no_destructor.h"
+#include "base/task/thread_pool.h"
 #include "build/build_config.h"
 #include "net/http/http_util.h"
 
@@ -49,9 +50,8 @@ std::unique_ptr<LocaleChangeSubscription> RegisterLocaleChangeCallback(
 
 #if defined(OS_ANDROID)
 static void JNI_LocaleChangedBroadcastReceiver_LocaleChanged(JNIEnv* env) {
-  base::PostTaskAndReply(
-      FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::USER_VISIBLE},
+  base::ThreadPool::PostTaskAndReply(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
       base::BindOnce([]() {
         // Passing an empty |pref_locale| means the Android system locale will
         // be used (base::android::GetDefaultLocaleString()).

weblayer/browser/profile_impl.cc

@@ -220,9 +220,9 @@ content::BrowserContext* ProfileImpl::GetBrowserContext() {
 bool ProfileImpl::DeleteDataFromDisk(base::OnceClosure done_callback) {
   if (num_browser_impl_ > 0)
     return false;
-  base::PostTaskAndReply(
+  base::ThreadPool::PostTaskAndReply(
       FROM_HERE,
-      {base::ThreadPool(), base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+      {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
       base::BindOnce(&NukeProfileFromDisk, name_, data_path_),
       std::move(done_callback));
@@ -311,9 +311,9 @@ static void JNI_ProfileImpl_DeleteProfile(JNIEnv* env, jlong profile) {
 static void JNI_ProfileImpl_EnumerateAllProfileNames(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& 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(&ListProfileNames),
       base::BindOnce(&PassFilePathsToJavaCallback,

weblayer/browser/ssl_error_controller_client.cc

@@ -5,6 +5,7 @@
 #include "weblayer/browser/ssl_error_controller_client.h"
 
 #include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "build/build_config.h"
 #include "components/security_interstitials/content/utils.h"
 #include "components/security_interstitials/core/metrics_helper.h"
@@ -62,9 +63,8 @@ bool SSLErrorControllerClient::CanLaunchDateAndTimeSettings() {
 void SSLErrorControllerClient::LaunchDateAndTimeSettings() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  base::PostTask(
-      FROM_HERE,
-      {base::ThreadPool(), base::TaskPriority::USER_VISIBLE, base::MayBlock()},
+  base::ThreadPool::PostTask(
+      FROM_HERE, {base::TaskPriority::USER_VISIBLE, base::MayBlock()},
       base::BindOnce(&security_interstitials::LaunchDateAndTimeSettings));
 }