Convert base::Bind to base::Bind{Once,Repeating} in content/browser

This CL converts base::Bind to BindOnce or BindRepeating, and also changes
relevant base::Callbacks or base::Closures to appropriate types.

This CL is split from https://crrev.com/c/1831621.

This CL was uploaded by git cl split.

R=boliu@chromium.org

Bug: 1007760
Change-Id: I235ac01f30acce3df1ce9f8a59d6d0a9da73449e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1849476Reviewed-by: Bo <boliu@chromium.org>
Commit-Queue: Bo <boliu@chromium.org>
Auto-Submit: Makoto Shimazu <shimazu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#704626}

content/browser/battery_monitor_browsertest.cc

@@ -78,7 +78,7 @@ class BatteryMonitorTest : public ContentBrowserTest {
     // it.
     service_manager::ServiceBinding::OverrideInterfaceBinderForTesting(
         device::mojom::kServiceName,
-        base::Bind(&MockBatteryMonitor::Bind,
+        base::BindRepeating(&MockBatteryMonitor::Bind,
                             base::Unretained(mock_battery_monitor_.get())));
   }
 

content/browser/browser_main_loop.cc

@@ -890,23 +890,23 @@ void BrowserMainLoop::CreateStartupTasks() {
   startup_task_runner_ = std::make_unique<StartupTaskRunner>(
       base::OnceCallback<void(int)>(), base::ThreadTaskRunnerHandle::Get());
 #endif
-  StartupTask pre_create_threads =
-      base::Bind(&BrowserMainLoop::PreCreateThreads, base::Unretained(this));
+  StartupTask pre_create_threads = base::BindOnce(
+      &BrowserMainLoop::PreCreateThreads, base::Unretained(this));
   startup_task_runner_->AddTask(std::move(pre_create_threads));
 
   StartupTask create_threads =
-      base::Bind(&BrowserMainLoop::CreateThreads, base::Unretained(this));
+      base::BindOnce(&BrowserMainLoop::CreateThreads, base::Unretained(this));
   startup_task_runner_->AddTask(std::move(create_threads));
 
-  StartupTask post_create_threads =
-      base::Bind(&BrowserMainLoop::PostCreateThreads, base::Unretained(this));
+  StartupTask post_create_threads = base::BindOnce(
+      &BrowserMainLoop::PostCreateThreads, base::Unretained(this));
   startup_task_runner_->AddTask(std::move(post_create_threads));
 
-  StartupTask browser_thread_started = base::Bind(
+  StartupTask browser_thread_started = base::BindOnce(
       &BrowserMainLoop::BrowserThreadsStarted, base::Unretained(this));
   startup_task_runner_->AddTask(std::move(browser_thread_started));
 
-  StartupTask pre_main_message_loop_run = base::Bind(
+  StartupTask pre_main_message_loop_run = base::BindOnce(
       &BrowserMainLoop::PreMainMessageLoopRun, base::Unretained(this));
   startup_task_runner_->AddTask(std::move(pre_main_message_loop_run));
 

content/browser/byte_stream.h

@@ -75,7 +75,7 @@ namespace content {
 //          &reader);         // Presumed passed to FILE thread for reading.
 //
 //      // Setup callback for writing.
-//      writer->RegisterCallback(base::Bind(&SpaceAvailable, this));
+//      writer->RegisterCallback(base::BindRepeating(&SpaceAvailable, this));
 //
 //      // Do initial round of writing.
 //      SpaceAvailable();
@@ -102,7 +102,7 @@ namespace content {
 //
 //    void ReceivingClass::Initialize() {
 //      // Initialization
-//      reader->RegisterCallback(base::Bind(&DataAvailable, obj));
+//      reader->RegisterCallback(base::BindRepeating(&DataAvailable, obj));
 //    }
 //
 //    // Called whenever there's something to read.

content/browser/geolocation/geolocation_service_impl.cc

@@ -24,7 +24,7 @@ GeolocationServiceImplContext::~GeolocationServiceImplContext() {
 void GeolocationServiceImplContext::RequestPermission(
     RenderFrameHost* render_frame_host,
     bool user_gesture,
-    const base::Callback<void(blink::mojom::PermissionStatus)>& callback) {
+    base::OnceCallback<void(blink::mojom::PermissionStatus)> callback) {
   if (request_id_ != PermissionController::kNoPendingOperation) {
     mojo::ReportBadMessage(
         "GeolocationService client may only create one Geolocation at a "
@@ -35,15 +35,15 @@ void GeolocationServiceImplContext::RequestPermission(
   request_id_ = permission_controller_->RequestPermission(
       PermissionType::GEOLOCATION, render_frame_host,
       render_frame_host->GetLastCommittedOrigin().GetURL(), user_gesture,
-      base::Bind(&GeolocationServiceImplContext::HandlePermissionStatus,
+      base::BindOnce(&GeolocationServiceImplContext::HandlePermissionStatus,
                      weak_factory_.GetWeakPtr(), std::move(callback)));
 }
 
 void GeolocationServiceImplContext::HandlePermissionStatus(
-    const base::Callback<void(blink::mojom::PermissionStatus)>& callback,
+    base::OnceCallback<void(blink::mojom::PermissionStatus)> callback,
     blink::mojom::PermissionStatus permission_status) {
   request_id_ = PermissionController::kNoPendingOperation;
-  callback.Run(permission_status);
+  std::move(callback).Run(permission_status);
 }
 
 GeolocationServiceImpl::GeolocationServiceImpl(
@@ -86,7 +86,8 @@ void GeolocationServiceImpl::CreateGeolocation(
       render_frame_host_, user_gesture,
       // There is an assumption here that the GeolocationServiceImplContext will
       // outlive the GeolocationServiceImpl.
-      base::Bind(&GeolocationServiceImpl::CreateGeolocationWithPermissionStatus,
+      base::BindOnce(
+          &GeolocationServiceImpl::CreateGeolocationWithPermissionStatus,
           base::Unretained(this), base::Passed(&receiver),
           base::Passed(&scoped_callback)));
 }

content/browser/geolocation/geolocation_service_impl.h

@@ -30,14 +30,14 @@ class GeolocationServiceImplContext {
   void RequestPermission(
       RenderFrameHost* render_frame_host,
       bool user_gesture,
-      const base::Callback<void(blink::mojom::PermissionStatus)>& callback);
+      base::OnceCallback<void(blink::mojom::PermissionStatus)> callback);
 
  private:
   PermissionControllerImpl* permission_controller_;
   int request_id_;
 
   void HandlePermissionStatus(
-      const base::Callback<void(blink::mojom::PermissionStatus)>& callback,
+      base::OnceCallback<void(blink::mojom::PermissionStatus)> callback,
       blink::mojom::PermissionStatus permission_status);
 
   base::WeakPtrFactory<GeolocationServiceImplContext> weak_factory_{this};

content/browser/histogram_synchronizer.cc

@@ -47,12 +47,11 @@ class HistogramSynchronizer::RequestContext {
   // A map from sequence_number_ to the actual RequestContexts.
   typedef std::map<int, RequestContext*> RequestContextMap;
 
-  RequestContext(const base::Closure& callback, int sequence_number)
-      : callback_(callback),
+  RequestContext(base::OnceClosure callback, int sequence_number)
+      : callback_(std::move(callback)),
         sequence_number_(sequence_number),
         received_process_group_count_(0),
-        processes_pending_(0) {
-  }
+        processes_pending_(0) {}
   ~RequestContext() {}
 
   void SetReceivedProcessGroupCount(bool done) {
@@ -84,10 +83,11 @@ class HistogramSynchronizer::RequestContext {
 
   // Register |callback| in |outstanding_requests_| map for the given
   // |sequence_number|.
-  static void Register(const base::Closure& callback, int sequence_number) {
+  static void Register(base::OnceClosure callback, int sequence_number) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-    RequestContext* request = new RequestContext(callback, sequence_number);
+    RequestContext* request =
+        new RequestContext(std::move(callback), sequence_number);
     outstanding_requests_.Get()[sequence_number] = request;
   }
 
@@ -120,7 +120,7 @@ class HistogramSynchronizer::RequestContext {
     bool received_process_group_count = request->received_process_group_count_;
     int unresponsive_processes = request->processes_pending_;
 
-    request->callback_.Run();
+    std::move(request->callback_).Run();
 
     delete request;
     outstanding_requests_.Get().erase(it);
@@ -142,7 +142,7 @@ class HistogramSynchronizer::RequestContext {
   }
 
   // Requests are made to asynchronously send data to the |callback_|.
-  base::Closure callback_;
+  base::OnceClosure callback_;
 
   // The sequence number used by the most recent update request to contact all
   // processes.
@@ -236,10 +236,9 @@ void HistogramSynchronizer::RegisterAndNotifyAllProcesses(
 
   int sequence_number = GetNextAvailableSequenceNumber(requester);
 
-  base::Closure callback = base::Bind(
+  base::OnceClosure callback = base::BindOnce(
       &HistogramSynchronizer::ForceHistogramSynchronizationDoneCallback,
-      base::Unretained(this),
-      sequence_number);
+      base::Unretained(this), sequence_number);
 
   RequestContext::Register(std::move(callback), sequence_number);
 

content/browser/startup_task_runner.cc

@@ -18,7 +18,7 @@ StartupTaskRunner::StartupTaskRunner(
 StartupTaskRunner::~StartupTaskRunner() {}
 
 void StartupTaskRunner::AddTask(StartupTask callback) {
-  task_list_.push_back(callback);
+  task_list_.push_back(std::move(callback));
 }
 
 void StartupTaskRunner::StartRunningTasksAsync() {
@@ -29,16 +29,16 @@ void StartupTaskRunner::StartRunningTasksAsync() {
       std::move(startup_complete_callback_).Run(result);
     }
   } else {
-    const base::Closure next_task =
-        base::Bind(&StartupTaskRunner::WrappedTask, base::Unretained(this));
-    proxy_->PostNonNestableTask(FROM_HERE, next_task);
+    base::OnceClosure next_task =
+        base::BindOnce(&StartupTaskRunner::WrappedTask, base::Unretained(this));
+    proxy_->PostNonNestableTask(FROM_HERE, std::move(next_task));
   }
 }
 
 void StartupTaskRunner::RunAllTasksNow() {
   int result = 0;
   for (auto it = task_list_.begin(); it != task_list_.end(); it++) {
-    result = it->Run();
+    result = std::move(*it).Run();
     if (result > 0) break;
   }
   task_list_.clear();
@@ -54,7 +54,7 @@ void StartupTaskRunner::WrappedTask() {
     // so there is nothing to do
     return;
   }
-  int result = task_list_.front().Run();
+  int result = std::move(task_list_.front()).Run();
   task_list_.pop_front();
   if (result > 0) {
     // Stop now and throw away the remaining tasks
@@ -65,9 +65,9 @@ void StartupTaskRunner::WrappedTask() {
       std::move(startup_complete_callback_).Run(result);
     }
   } else {
-    const base::Closure next_task =
-        base::Bind(&StartupTaskRunner::WrappedTask, base::Unretained(this));
-    proxy_->PostNonNestableTask(FROM_HERE, next_task);
+    base::OnceClosure next_task =
+        base::BindOnce(&StartupTaskRunner::WrappedTask, base::Unretained(this));
+    proxy_->PostNonNestableTask(FROM_HERE, std::move(next_task));
   }
 }
 

content/browser/startup_task_runner.h

@@ -20,7 +20,7 @@ namespace content {
 // A startup task is a void function returning the status on completion.
 // a status of > 0 indicates a failure, and that no further startup tasks should
 // be run.
-typedef base::Callback<int(void)> StartupTask;
+typedef base::OnceCallback<int(void)> StartupTask;
 
 // This class runs startup tasks. The tasks are either run immediately inline,
 // or are queued one at a time on the UI thread's message loop. If the events