[base] Apply BindOnceRewriter in //chrome

This change applies the BindOnceRewriter in //chrome.
This rewriter replaces calls to base::Bind and base::BindRepeating with
calls to base::BindOnce, in case the result is immediately assigned to a
base::OnceCallback. Given that base::RepeatingCallback is implicitly
convertible to base::OnceCallback, there is no change in functionality.

Steps:
  1. run_tool.py --tool base_bind_rewriters \
                 --tool-arg='--rewriter=bind_to_bind_once'
  2. git cl format

This CL was uploaded by git cl split.

R=avi@chromium.org

Bug: 714018
Change-Id: I448d5a70b2027b4bbcaa91543cb6a1bd66c211cb
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2132369
Auto-Submit: Jan Wilken Dörrie <jdoerrie@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Commit-Queue: Avi Drissman <avi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#755423}

chrome/browser/chrome_browser_main_win.cc

@@ -447,7 +447,7 @@ void MaybePostSettingsResetPrompt() {
     base::PostTask(
         FROM_HERE,
         {content::BrowserThread::UI, base::TaskPriority::BEST_EFFORT},
-        base::Bind(safe_browsing::MaybeShowSettingsResetPromptWithDelay));
+        base::BindOnce(safe_browsing::MaybeShowSettingsResetPromptWithDelay));
   }
 }
 

chrome/browser/file_select_helper.cc

@@ -628,12 +628,13 @@ void FileSelectHelper::CheckDownloadRequestWithSafeBrowsing(
   GURL requestor_url = params->requestor;
   sb_service->download_protection_service()->CheckPPAPIDownloadRequest(
       requestor_url,
-      render_frame_host_? render_frame_host_->GetLastCommittedURL() : GURL(),
-      WebContents::FromRenderFrameHost(render_frame_host_),
-      default_file_path, alternate_extensions, profile_,
-      base::Bind(&InterpretSafeBrowsingVerdict,
-                 base::Bind(&FileSelectHelper::ProceedWithSafeBrowsingVerdict,
-                            this, default_file_path, base::Passed(&params))));
+      render_frame_host_ ? render_frame_host_->GetLastCommittedURL() : GURL(),
+      WebContents::FromRenderFrameHost(render_frame_host_), default_file_path,
+      alternate_extensions, profile_,
+      base::BindOnce(
+          &InterpretSafeBrowsingVerdict,
+          base::Bind(&FileSelectHelper::ProceedWithSafeBrowsingVerdict, this,
+                     default_file_path, base::Passed(&params))));
 #endif
 }
 

chrome/browser/intranet_redirect_detector.cc

@@ -248,7 +248,7 @@ void IntranetRedirectDetector::SetupDnsConfigClient() {
       manager_remote.BindNewPipeAndPassReceiver());
   manager_remote->RequestNotifications(
       dns_config_client_receiver_.BindNewPipeAndPassRemote());
-  dns_config_client_receiver_.set_disconnect_handler(base::BindRepeating(
+  dns_config_client_receiver_.set_disconnect_handler(base::BindOnce(
       &IntranetRedirectDetector::OnDnsConfigClientConnectionError,
       base::Unretained(this)));
 }

chrome/browser/process_resource_usage.cc

@@ -17,8 +17,8 @@ ProcessResourceUsage::ProcessResourceUsage(
     mojo::PendingRemote<content::mojom::ResourceUsageReporter> service)
     : service_(std::move(service)), update_in_progress_(false) {
   service_.set_disconnect_handler(
-      base::Bind(&ProcessResourceUsage::RunPendingRefreshCallbacks,
-                 base::Unretained(this)));
+      base::BindOnce(&ProcessResourceUsage::RunPendingRefreshCallbacks,
+                     base::Unretained(this)));
 }
 
 ProcessResourceUsage::~ProcessResourceUsage() {
@@ -46,8 +46,8 @@ void ProcessResourceUsage::Refresh(const base::Closure& callback) {
 
   if (!update_in_progress_) {
     update_in_progress_ = true;
-    service_->GetUsageData(base::Bind(&ProcessResourceUsage::OnRefreshDone,
-                                      base::Unretained(this)));
+    service_->GetUsageData(base::BindOnce(&ProcessResourceUsage::OnRefreshDone,
+                                          base::Unretained(this)));
   }
 }
 

chrome/chrome_cleaner/logging/pending_logs_service.cc

@@ -62,8 +62,8 @@ void PendingLogsService::ScheduleLogsUploadTask(
   }
 
   // To get rid of the temporary file if we are not going to use it.
-  base::ScopedClosureRunner delete_file_closure(base::BindRepeating(
-      IgnoreResult(&base::DeleteFile), temp_file_path, false));
+  base::ScopedClosureRunner delete_file_closure(
+      base::BindOnce(IgnoreResult(&base::DeleteFile), temp_file_path, false));
 
   if (base::WriteFile(temp_file_path, chrome_cleaner_report_string.c_str(),
                       chrome_cleaner_report_string.size()) <= 0) {

chrome/chrome_cleaner/logging/pending_logs_service_unittest.cc

@@ -101,8 +101,8 @@ class PendingLogsServiceTest : public testing::Test {
     PendingLogsService pending_logs_service;
     pending_logs_service.RetryNextPendingLogsUpload(
         TEST_PRODUCT_SHORTNAME_STRING,
-        base::BindRepeating(&PendingLogsServiceTest::LogsUploadCallback,
-                            base::Unretained(this), run_loop.QuitClosure()),
+        base::BindOnce(&PendingLogsServiceTest::LogsUploadCallback,
+                       base::Unretained(this), run_loop.QuitClosure()),
         registry_logger_.get());
     run_loop.Run();
 
@@ -227,8 +227,8 @@ TEST_F(PendingLogsServiceTest, UploadPendingLogs) {
   base::RunLoop run_loop;
   pending_logs_service.RetryNextPendingLogsUpload(
       TEST_PRODUCT_SHORTNAME_STRING,
-      base::BindRepeating(&PendingLogsServiceTest::LogsUploadCallback,
-                          base::Unretained(this), run_loop.QuitClosure()),
+      base::BindOnce(&PendingLogsServiceTest::LogsUploadCallback,
+                     base::Unretained(this), run_loop.QuitClosure()),
       registry_logger_.get());
   run_loop.Run();
 

chrome/chrome_cleaner/logging/safe_browsing_reporter.cc

@@ -115,7 +115,7 @@ class NetworkCheckerImpl : public NetworkChecker {
       return false;
     }
     base::ScopedClosureRunner close_event(
-        base::BindRepeating(base::IgnoreResult(&::CloseHandle), event));
+        base::BindOnce(base::IgnoreResult(&::CloseHandle), event));
 
     OVERLAPPED overlapped = {0};
     overlapped.hEvent = event;
@@ -126,7 +126,7 @@ class NetworkCheckerImpl : public NetworkChecker {
       PLOG(ERROR) << "Error in NotifyAddrChange (" << ret << ")";
       return false;
     }
-    base::ScopedClosureRunner cancel_ip_change_notify(base::BindRepeating(
+    base::ScopedClosureRunner cancel_ip_change_notify(base::BindOnce(
         base::IgnoreResult(&::CancelIPChangeNotify), &overlapped));
 
     // NotifyAddrChange will only notify when there are address changes to the
@@ -275,9 +275,8 @@ SafeBrowsingReporter::SafeBrowsingReporter(
   base::ThreadPool::PostTask(
       FROM_HERE,
       {base::MayBlock(), base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
-      base::BindRepeating(&SafeBrowsingReporter::UploadWithRetry,
-                          base::Owned(this), serialized_report,
-                          traffic_annotation));
+      base::BindOnce(&SafeBrowsingReporter::UploadWithRetry, base::Owned(this),
+                     serialized_report, traffic_annotation));
 }
 
 void SafeBrowsingReporter::UploadWithRetry(
@@ -299,8 +298,8 @@ void SafeBrowsingReporter::UploadWithRetry(
   LOG(INFO) << "Calling done_callback_ with result: "
             << static_cast<int>(result);
   done_callback_runner_->PostTask(
-      FROM_HERE, base::BindRepeating(done_callback_, result, serialized_report,
-                                     base::Passed(&response)));
+      FROM_HERE, base::BindOnce(done_callback_, result, serialized_report,
+                                base::Passed(&response)));
 }
 
 SafeBrowsingReporter::Result SafeBrowsingReporter::PerformUploadWithRetries(

chrome/chrome_cleaner/logging/scoped_timed_task_logger.cc

@@ -26,10 +26,9 @@ ScopedTimedTaskLogger::ScopedTimedTaskLogger(TimerCallback timer_callback)
       timer_callback_(std::move(timer_callback)) {}
 
 ScopedTimedTaskLogger::ScopedTimedTaskLogger(const char* logging_text)
-    : ScopedTimedTaskLogger(
-          base::BindRepeating(&LogIfExceedThreshold,
-                              logging_text,
-                              base::TimeDelta::FromSeconds(1))) {}
+    : ScopedTimedTaskLogger(base::BindOnce(&LogIfExceedThreshold,
+                                           logging_text,
+                                           base::TimeDelta::FromSeconds(1))) {}
 
 ScopedTimedTaskLogger::~ScopedTimedTaskLogger() {
   std::move(timer_callback_).Run(base::Time::NowFromSystemTime() - start_time_);

chrome/chrome_cleaner/logging/scoped_timed_task_logger_unittest.cc

@@ -66,7 +66,7 @@ std::vector<std::string>* ScopedTimedTaskLoggerTest::active_logging_messages_ =
 
 TEST_F(ScopedTimedTaskLoggerTest, CallbackCalled) {
   {
-    ScopedTimedTaskLogger timer(base::BindRepeating(
+    ScopedTimedTaskLogger timer(base::BindOnce(
         &ScopedTimedTaskLoggerTest::timer_callback, base::Unretained(this)));
   }
   EXPECT_TRUE(callback_called_);
@@ -76,8 +76,8 @@ TEST_F(ScopedTimedTaskLoggerTest, NoLog) {
   static const char kNoShow[] = "Should not show up";
   {
     ScopedTimedTaskLogger no_logs(
-        base::BindRepeating(ScopedTimedTaskLogger::LogIfExceedThreshold,
-                            kNoShow, base::TimeDelta::FromDays(1)));
+        base::BindOnce(ScopedTimedTaskLogger::LogIfExceedThreshold, kNoShow,
+                       base::TimeDelta::FromDays(1)));
   }
   EXPECT_FALSE(LoggingMessagesContain(kNoShow));
 }
@@ -86,8 +86,8 @@ TEST_F(ScopedTimedTaskLoggerTest, Log) {
   static const char kShow[] = "Should show up";
   {
     ScopedTimedTaskLogger logs(
-        base::BindRepeating(ScopedTimedTaskLogger::LogIfExceedThreshold, kShow,
-                            base::TimeDelta::FromMilliseconds(0)));
+        base::BindOnce(ScopedTimedTaskLogger::LogIfExceedThreshold, kShow,
+                       base::TimeDelta::FromMilliseconds(0)));
     ::Sleep(2);
   }
   EXPECT_TRUE(LoggingMessagesContain(kShow));

chrome/common/media_router/discovery/media_sink_service_base.cc

@@ -95,8 +95,8 @@ void MediaSinkServiceBase::StartTimer() {
 
   discovery_timer_->Start(
       FROM_HERE, kDiscoveryTimeout,
-      base::BindRepeating(&MediaSinkServiceBase::OnDiscoveryComplete,
-                          base::Unretained(this)));
+      base::BindOnce(&MediaSinkServiceBase::OnDiscoveryComplete,
+                     base::Unretained(this)));
 }
 
 void MediaSinkServiceBase::OnDiscoveryComplete() {

chrome/common/service_process_util_unittest.cc

@@ -240,7 +240,7 @@ MULTIPROCESS_TEST_MAIN(ServiceProcessStateTestShutdown) {
   ServiceProcessState state;
   EXPECT_TRUE(state.Initialize());
   EXPECT_TRUE(state.SignalReady(io_thread_.task_runner().get(),
-                                base::Bind(&ShutdownTask, &run_loop)));
+                                base::BindOnce(&ShutdownTask, &run_loop)));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, run_loop.QuitWhenIdleClosure(),
       TestTimeouts::action_max_timeout());

chrome/elevation_service/run_all_unittests.cc

@@ -29,6 +29,5 @@ int main(int argc, char** argv) {
 
   return base::LaunchUnitTestsSerially(
       argc, argv,
-      base::BindRepeating(&base::TestSuite::Run,
-                          base::Unretained(&test_suite)));
+      base::BindOnce(&base::TestSuite::Run, base::Unretained(&test_suite)));
 }

chrome/services/file_util/public/cpp/sandboxed_rar_analyzer_unittest.cc

@@ -105,8 +105,8 @@ class SandboxedRarAnalyzerTest : public testing::Test {
         : next_closure_(next_closure), results_(results) {}
 
     SandboxedRarAnalyzer::ResultCallback GetCallback() {
-      return base::BindRepeating(&ResultsGetter::ResultsCallback,
-                                 base::Unretained(this));
+      return base::BindOnce(&ResultsGetter::ResultsCallback,
+                            base::Unretained(this));
     }
 
    private:

chrome/test/base/chrome_test_launcher.cc

@@ -222,7 +222,7 @@ int LaunchChromeTests(size_t parallel_jobs,
       switches::kUtilityProcess) {
     network_service_test_helper =
         std::make_unique<content::NetworkServiceTestHelper>();
-    ChromeContentUtilityClient::SetNetworkBinderCreationCallback(base::Bind(
+    ChromeContentUtilityClient::SetNetworkBinderCreationCallback(base::BindOnce(
         [](content::NetworkServiceTestHelper* helper,
            service_manager::BinderRegistry* registry) {
           helper->RegisterNetworkBinders(registry);

chrome/test/base/memory_tracing_browsertest.cc

@@ -46,7 +46,7 @@ void OnStartTracingDoneCallback(
       ->RequestGlobalDumpAndAppendToTrace(
           MemoryDumpType::EXPLICITLY_TRIGGERED, explicit_dump_type,
           MemoryDumpDeterminism::NONE,
-          Bind(&RequestGlobalDumpCallback, quit_closure));
+          BindOnce(&RequestGlobalDumpCallback, quit_closure));
 }
 
 class MemoryTracingBrowserTest : public InProcessBrowserTest {

chrome/test/base/run_all_unittests.cc

@@ -32,7 +32,7 @@ int main(int argc, char **argv) {
   install_static::ScopedInstallDetails scoped_install_details;
 #endif
 
-  return base::LaunchUnitTests(
-      argc, argv, base::Bind(&content::UnitTestTestSuite::Run,
-                             base::Unretained(&test_suite)));
+  return base::LaunchUnitTests(argc, argv,
+                               base::BindOnce(&content::UnitTestTestSuite::Run,
+                                              base::Unretained(&test_suite)));
 }

chrome/test/chromedriver/net/adb_client_socket_unittest.cc

@@ -148,9 +148,9 @@ class AdbClientSocketTest : public testing::Test {
     buffer->SetCapacity(initial_capacity);
     int result = adb_socket.socket_->Read(
         buffer.get(), initial_capacity,
-        base::Bind(&AdbClientSocket::ReadUntilEOF,
-                   base::Unretained(&adb_socket), parse_callback.Get(),
-                   response_callback.Get(), buffer));
+        base::BindOnce(&AdbClientSocket::ReadUntilEOF,
+                       base::Unretained(&adb_socket), parse_callback.Get(),
+                       response_callback.Get(), buffer));
     if (result != net::ERR_IO_PENDING) {
       adb_socket.ReadUntilEOF(parse_callback.Get(), response_callback.Get(),
                               buffer, result);