[Code Health] Convert Bind to BindOnce/Repeating

Update base::Bind to base::BindOnce/BindRepeating for
media/audio/android and media/audio/mac.

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

media/audio/android/audio_android_unittest.cc

@@ -441,7 +441,7 @@ class AudioAndroidOutputTest : public testing::Test {
   }
 
   // Synchronously runs the provided callback/closure on the audio thread.
-  void RunOnAudioThread(const base::Closure& closure) {
+  void RunOnAudioThread(base::OnceClosure closure) {
     if (!audio_manager()->GetTaskRunner()->BelongsToCurrentThread()) {
       base::WaitableEvent event(
           base::WaitableEvent::ResetPolicy::AUTOMATIC,
@@ -449,51 +449,45 @@ class AudioAndroidOutputTest : public testing::Test {
       audio_manager()->GetTaskRunner()->PostTask(
           FROM_HERE,
           base::BindOnce(&AudioAndroidOutputTest::RunOnAudioThreadImpl,
-                         base::Unretained(this), closure, &event));
+                         base::Unretained(this), std::move(closure), &event));
       event.Wait();
     } else {
-      closure.Run();
+      std::move(closure).Run();
     }
   }
 
-  void RunOnAudioThreadImpl(const base::Closure& closure,
+  void RunOnAudioThreadImpl(base::OnceClosure closure,
                             base::WaitableEvent* event) {
     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
-    closure.Run();
+    std::move(closure).Run();
     event->Signal();
   }
 
   void GetDefaultOutputStreamParametersOnAudioThread() {
-    RunOnAudioThread(
-        base::Bind(&AudioAndroidOutputTest::GetDefaultOutputStreamParameters,
-                   base::Unretained(this)));
+    RunOnAudioThread(base::BindOnce(
+        &AudioAndroidOutputTest::GetDefaultOutputStreamParameters,
+        base::Unretained(this)));
   }
 
   void MakeAudioOutputStreamOnAudioThread(const AudioParameters& params) {
-    RunOnAudioThread(
-        base::Bind(&AudioAndroidOutputTest::MakeOutputStream,
-                   base::Unretained(this),
-                   params));
+    RunOnAudioThread(base::BindOnce(&AudioAndroidOutputTest::MakeOutputStream,
+                                    base::Unretained(this), params));
   }
 
   void OpenAndCloseAudioOutputStreamOnAudioThread() {
-    RunOnAudioThread(
-        base::Bind(&AudioAndroidOutputTest::OpenAndClose,
-                   base::Unretained(this)));
+    RunOnAudioThread(base::BindOnce(&AudioAndroidOutputTest::OpenAndClose,
+                                    base::Unretained(this)));
   }
 
   void OpenAndStartAudioOutputStreamOnAudioThread(
       AudioOutputStream::AudioSourceCallback* source) {
-    RunOnAudioThread(
-        base::Bind(&AudioAndroidOutputTest::OpenAndStart,
-                   base::Unretained(this),
-                   source));
+    RunOnAudioThread(base::BindOnce(&AudioAndroidOutputTest::OpenAndStart,
+                                    base::Unretained(this), source));
   }
 
   void StopAndCloseAudioOutputStreamOnAudioThread() {
-    RunOnAudioThread(
-        base::Bind(&AudioAndroidOutputTest::StopAndClose,
-                   base::Unretained(this)));
+    RunOnAudioThread(base::BindOnce(&AudioAndroidOutputTest::StopAndClose,
+                                    base::Unretained(this)));
   }
 
   double AverageTimeBetweenCallbacks(int num_callbacks) const {
@@ -613,36 +607,30 @@ class AudioAndroidInputTest : public AudioAndroidOutputTest,
   }
 
   void GetDefaultInputStreamParametersOnAudioThread() {
-     RunOnAudioThread(
-        base::Bind(&AudioAndroidInputTest::GetDefaultInputStreamParameters,
-                   base::Unretained(this)));
+    RunOnAudioThread(
+        base::BindOnce(&AudioAndroidInputTest::GetDefaultInputStreamParameters,
+                       base::Unretained(this)));
   }
 
   void MakeAudioInputStreamOnAudioThread(const AudioParameters& params) {
-    RunOnAudioThread(
-        base::Bind(&AudioAndroidInputTest::MakeInputStream,
-                   base::Unretained(this),
-                   params));
+    RunOnAudioThread(base::BindOnce(&AudioAndroidInputTest::MakeInputStream,
+                                    base::Unretained(this), params));
   }
 
   void OpenAndCloseAudioInputStreamOnAudioThread() {
-    RunOnAudioThread(
-        base::Bind(&AudioAndroidInputTest::OpenAndClose,
-                   base::Unretained(this)));
+    RunOnAudioThread(base::BindOnce(&AudioAndroidInputTest::OpenAndClose,
+                                    base::Unretained(this)));
   }
 
   void OpenAndStartAudioInputStreamOnAudioThread(
       AudioInputStream::AudioInputCallback* sink) {
-    RunOnAudioThread(
-        base::Bind(&AudioAndroidInputTest::OpenAndStart,
-                   base::Unretained(this),
-                   sink));
+    RunOnAudioThread(base::BindOnce(&AudioAndroidInputTest::OpenAndStart,
+                                    base::Unretained(this), sink));
   }
 
   void StopAndCloseAudioInputStreamOnAudioThread() {
-    RunOnAudioThread(
-        base::Bind(&AudioAndroidInputTest::StopAndClose,
-                   base::Unretained(this)));
+    RunOnAudioThread(base::BindOnce(&AudioAndroidInputTest::StopAndClose,
+                                    base::Unretained(this)));
   }
 
   void StartInputStreamCallbacks(const AudioParameters& params) {
@@ -745,7 +733,7 @@ TEST_F(AudioAndroidOutputTest, GetDefaultOutputStreamParameters) {
 TEST_F(AudioAndroidInputTest, GetAudioInputDeviceDescriptions) {
   ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info()->HasAudioInputDevices());
   AudioDeviceDescriptions devices;
-  RunOnAudioThread(base::Bind(
+  RunOnAudioThread(base::BindOnce(
       &AudioDeviceInfoAccessorForTests::GetAudioInputDeviceDescriptions,
       base::Unretained(audio_manager_device_info()), &devices));
   CheckDeviceDescriptions(devices);
@@ -755,7 +743,7 @@ TEST_F(AudioAndroidInputTest, GetAudioInputDeviceDescriptions) {
 TEST_F(AudioAndroidOutputTest, GetAudioOutputDeviceDescriptions) {
   ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info()->HasAudioOutputDevices());
   AudioDeviceDescriptions devices;
-  RunOnAudioThread(base::Bind(
+  RunOnAudioThread(base::BindOnce(
       &AudioDeviceInfoAccessorForTests::GetAudioOutputDeviceDescriptions,
       base::Unretained(audio_manager_device_info()), &devices));
   CheckDeviceDescriptions(devices);
@@ -765,9 +753,8 @@ TEST_F(AudioAndroidOutputTest, GetAudioOutputDeviceDescriptions) {
 TEST_P(AudioAndroidInputTest, CreateAndCloseInputStream) {
   AudioParameters params = GetInputStreamParameters();
   MakeAudioInputStreamOnAudioThread(params);
-  RunOnAudioThread(
-      base::Bind(&AudioInputStream::Close,
-                 base::Unretained(audio_input_stream_)));
+  RunOnAudioThread(base::BindOnce(&AudioInputStream::Close,
+                                  base::Unretained(audio_input_stream_)));
 }
 
 // Ensure that a default output stream can be created and closed.
@@ -777,9 +764,8 @@ TEST_P(AudioAndroidInputTest, CreateAndCloseInputStream) {
 TEST_F(AudioAndroidOutputTest, CreateAndCloseOutputStream) {
   GetDefaultOutputStreamParametersOnAudioThread();
   MakeAudioOutputStreamOnAudioThread(audio_output_parameters());
-  RunOnAudioThread(
-      base::Bind(&AudioOutputStream::Close,
-                 base::Unretained(audio_output_stream_)));
+  RunOnAudioThread(base::BindOnce(&AudioOutputStream::Close,
+                                  base::Unretained(audio_output_stream_)));
 }
 
 // Ensure that a default input stream can be opened and closed.

media/audio/mac/audio_auhal_mac.cc

@@ -234,7 +234,7 @@ void AUHALStream::Start(AudioSourceCallback* callback) {
     // Use a cancellable closure so that if Stop() is called before Start()
     // actually runs, we can cancel the pending start.
     deferred_start_cb_.Reset(
-        base::Bind(&AUHALStream::Start, base::Unretained(this), callback));
+        base::BindOnce(&AUHALStream::Start, base::Unretained(this), callback));
     manager_->GetTaskRunner()->PostDelayedTask(
         FROM_HERE, deferred_start_cb_.callback(),
         base::TimeDelta::FromSeconds(
@@ -308,9 +308,10 @@ OSStatus AUHALStream::Render(AudioUnitRenderActionFlags* flags,
       number_of_frames_requested_ = number_of_frames;
       DVLOG(1) << "Audio frame size changed from " << number_of_frames_
                << " to " << number_of_frames << " adding FIFO to compensate.";
-      audio_fifo_.reset(new AudioPullFifo(
-          params_.channels(), number_of_frames_,
-          base::Bind(&AUHALStream::ProvideInput, base::Unretained(this))));
+      audio_fifo_.reset(
+          new AudioPullFifo(params_.channels(), number_of_frames_,
+                            base::BindRepeating(&AUHALStream::ProvideInput,
+                                                base::Unretained(this))));
     }
   }
 

media/audio/mac/audio_auhal_mac.h

@@ -198,7 +198,7 @@ class AUHALStream : public AudioOutputStream {
   int glitches_detected_;
 
   // Used to defer Start() to workaround http://crbug.com/160920.
-  base::CancelableClosure deferred_start_cb_;
+  base::CancelableOnceClosure deferred_start_cb_;
 
   // Callback to send statistics info.
   AudioManager::LogCallback log_callback_;

media/audio/mac/audio_input_mac.cc

@@ -89,8 +89,8 @@ void PCMQueueInAudioInputStream::Start(AudioInputCallback* callback) {
   if (manager_->ShouldDeferStreamStart()) {
     // Use a cancellable closure so that if Stop() is called before Start()
     // actually runs, we can cancel the pending start.
-    deferred_start_cb_.Reset(base::Bind(
-        &PCMQueueInAudioInputStream::Start, base::Unretained(this), callback));
+    deferred_start_cb_.Reset(base::BindOnce(&PCMQueueInAudioInputStream::Start,
+                                            base::Unretained(this), callback));
     manager_->GetTaskRunner()->PostDelayedTask(
         FROM_HERE,
         deferred_start_cb_.callback(),

media/audio/mac/audio_input_mac.h

@@ -99,7 +99,7 @@ class PCMQueueInAudioInputStream : public AudioInputStream {
   // Used to determine if we need to slow down |callback_| calls.
   base::TimeTicks last_fill_;
   // Used to defer Start() to workaround http://crbug.com/160920.
-  base::CancelableClosure deferred_start_cb_;
+  base::CancelableOnceClosure deferred_start_cb_;
 
   // Is set to true on the internal AUHAL IO thread in the first input callback
   // after Start() has bee called.

media/audio/mac/audio_low_latency_input_mac.cc

@@ -681,8 +681,8 @@ void AUAudioInputStream::Start(AudioInputCallback* callback) {
     LOG(WARNING) << "Start of input audio is deferred";
     // Use a cancellable closure so that if Stop() is called before Start()
     // actually runs, we can cancel the pending start.
-    deferred_start_cb_.Reset(base::Bind(&AUAudioInputStream::Start,
-                                        base::Unretained(this), callback));
+    deferred_start_cb_.Reset(base::BindOnce(&AUAudioInputStream::Start,
+                                            base::Unretained(this), callback));
     manager_->GetTaskRunner()->PostDelayedTask(
         FROM_HERE, deferred_start_cb_.callback(),
         base::TimeDelta::FromSeconds(

media/audio/mac/audio_low_latency_input_mac.h

@@ -213,7 +213,7 @@ class MEDIA_EXPORT AUAudioInputStream
   media::AudioBlockFifo fifo_;
 
   // Used to defer Start() to workaround http://crbug.com/160920.
-  base::CancelableClosure deferred_start_cb_;
+  base::CancelableOnceClosure deferred_start_cb_;
 
   // Contains time of last successful call to AudioUnitRender().
   // Initialized first time in Start() and then updated for each valid

media/audio/mac/audio_manager_mac.cc

@@ -715,7 +715,7 @@ AudioOutputStream* AudioManagerMac::MakeLowLatencyOutputStream(
     // fire the callbacks during stream creation, leading to re-entrancy issues
     // otherwise.  See http://crbug.com/349604
     output_device_listener_.reset(
-        new AudioDeviceListenerMac(BindToCurrentLoop(base::Bind(
+        new AudioDeviceListenerMac(BindToCurrentLoop(base::BindRepeating(
             &AudioManagerMac::HandleDeviceChanges, base::Unretained(this)))));
     device_listener_first_init = true;
   }