[Code Health] Convert Bind to BindOnce/Repeating

Change base::Bind to base::BindOnce or base::BindRepeating as
appropriate..

Bug: 1007798
Change-Id: I0bc1f2049624a4c4a1423139fd061ae84d6aa0ff
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1902269Reviewed-by: Olga Sharonova <olka@chromium.org>
Commit-Queue: Raymond Toy <rtoy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#713957}

media/audio/alive_checker.cc

@@ -63,16 +63,17 @@ AliveChecker::AliveChecker(
     if (power_observer_helper_factory_callback.is_null()) {
       power_observer_ = std::make_unique<PowerObserverHelper>(
           task_runner_, base::DoNothing(),
-          base::Bind(
+          base::BindRepeating(
               &AliveChecker::SetLastAliveNotificationTimeToNowOnTaskRunner,
               base::Unretained(this)));
     } else {
       power_observer_ =
           std::move(power_observer_helper_factory_callback)
               .Run(task_runner_, base::DoNothing(),
-                   base::Bind(&AliveChecker::
-                                  SetLastAliveNotificationTimeToNowOnTaskRunner,
-                              base::Unretained(this)));
+                   base::BindRepeating(
+                       &AliveChecker::
+                           SetLastAliveNotificationTimeToNowOnTaskRunner,
+                       base::Unretained(this)));
     }
   } else {
     // If |pause_check_during_suspend| is false, we expect an empty factory

media/audio/audio_debug_file_writer.cc

@@ -289,8 +289,9 @@ void AudioDebugFileWriter::Write(std::unique_ptr<AudioBus> data) {
   file_task_runner_->PostTask(
       FROM_HERE,
       // Callback takes ownership of |data|:
-      base::Bind(&AudioFileWriter::Write, base::Unretained(file_writer_.get()),
-                 base::Owned(data.release())));
+      base::BindOnce(&AudioFileWriter::Write,
+                     base::Unretained(file_writer_.get()),
+                     base::Owned(data.release())));
 }
 
 bool AudioDebugFileWriter::WillWrite() {

media/audio/audio_input_device.cc

@@ -256,7 +256,7 @@ void AudioInputDevice::OnStreamCreated(
   const bool pause_check_during_suspend = true;
 #endif
   alive_checker_ = std::make_unique<AliveChecker>(
-      base::Bind(&AudioInputDevice::DetectedDeadInputStream, this),
+      base::BindRepeating(&AudioInputDevice::DetectedDeadInputStream, this),
       base::TimeDelta::FromSeconds(kCheckMissingCallbacksIntervalSeconds),
       base::TimeDelta::FromSeconds(kMissingCallbacksTimeBeforeErrorSeconds),
       stop_at_first_alive_notification, pause_check_during_suspend);

media/audio/audio_input_unittest.cc

@@ -85,42 +85,35 @@ class AudioInputTest : public testing::Test {
   }
 
   void MakeAudioInputStreamOnAudioThread() {
-    RunOnAudioThread(
-        base::Bind(&AudioInputTest::MakeAudioInputStream,
-                   base::Unretained(this)));
+    RunOnAudioThread(base::BindOnce(&AudioInputTest::MakeAudioInputStream,
+                                    base::Unretained(this)));
   }
 
   void CloseAudioInputStreamOnAudioThread() {
-    RunOnAudioThread(
-        base::Bind(&AudioInputStream::Close,
-                   base::Unretained(audio_input_stream_)));
+    RunOnAudioThread(base::BindOnce(&AudioInputStream::Close,
+                                    base::Unretained(audio_input_stream_)));
     audio_input_stream_ = NULL;
   }
 
   void OpenAndCloseAudioInputStreamOnAudioThread() {
     RunOnAudioThread(
-        base::Bind(&AudioInputTest::OpenAndClose,
-                   base::Unretained(this)));
+        base::BindOnce(&AudioInputTest::OpenAndClose, base::Unretained(this)));
   }
 
   void OpenStopAndCloseAudioInputStreamOnAudioThread() {
-    RunOnAudioThread(
-        base::Bind(&AudioInputTest::OpenStopAndClose,
-                   base::Unretained(this)));
+    RunOnAudioThread(base::BindOnce(&AudioInputTest::OpenStopAndClose,
+                                    base::Unretained(this)));
   }
 
   void OpenAndStartAudioInputStreamOnAudioThread(
       AudioInputStream::AudioInputCallback* sink) {
-    RunOnAudioThread(
-        base::Bind(&AudioInputTest::OpenAndStart,
-                   base::Unretained(this),
-                   sink));
+    RunOnAudioThread(base::BindOnce(&AudioInputTest::OpenAndStart,
+                                    base::Unretained(this), sink));
   }
 
   void StopAndCloseAudioInputStreamOnAudioThread() {
     RunOnAudioThread(
-        base::Bind(&AudioInputTest::StopAndClose,
-                   base::Unretained(this)));
+        base::BindOnce(&AudioInputTest::StopAndClose, base::Unretained(this)));
   }
 
   void MakeAudioInputStream() {
@@ -163,9 +156,9 @@ class AudioInputTest : public testing::Test {
   }
 
   // Synchronously runs the provided callback/closure on the audio thread.
-  void RunOnAudioThread(const base::Closure& closure) {
+  void RunOnAudioThread(base::OnceClosure closure) {
     DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread());
-    closure.Run();
+    std::move(closure).Run();
   }
 
   void OnLogMessage(const std::string& message) {}

media/audio/audio_low_latency_input_output_unittest.cc

@@ -253,7 +253,7 @@ class AudioInputStreamTraits {
       const AudioParameters& params) {
     return audio_manager->MakeAudioInputStream(
         params, AudioDeviceDescription::kDefaultDeviceId,
-        base::Bind(&OnLogMessage));
+        base::BindRepeating(&OnLogMessage));
   }
 };
 
@@ -269,8 +269,8 @@ class AudioOutputStreamTraits {
 
   static StreamType* CreateStream(AudioManager* audio_manager,
       const AudioParameters& params) {
-    return audio_manager->MakeAudioOutputStream(params, std::string(),
-                                                base::Bind(&OnLogMessage));
+    return audio_manager->MakeAudioOutputStream(
+        params, std::string(), base::BindRepeating(&OnLogMessage));
   }
 };
 

media/audio/audio_output_resampler.cc

@@ -184,10 +184,11 @@ AudioOutputResampler::AudioOutputResampler(
       output_params_(output_params),
       original_output_params_(output_params),
       device_id_(output_device_id),
-      reinitialize_timer_(FROM_HERE,
-                          close_delay_,
-                          base::Bind(&AudioOutputResampler::Reinitialize,
-                                     base::Unretained(this))),
+      reinitialize_timer_(
+          FROM_HERE,
+          close_delay_,
+          base::BindRepeating(&AudioOutputResampler::Reinitialize,
+                              base::Unretained(this))),
       register_debug_recording_source_callback_(
           register_debug_recording_source_callback) {
   DCHECK(audio_manager->GetTaskRunner()->BelongsToCurrentThread());