Convert some audio code to OnceCallback.

content/browser/renderer_host/media/audio_output_delegate_impl.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/media/audio_output_delegate_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 26 matching lines @@
   base::WeakPtr<AudioOutputDelegateImpl> delegate_;
 };
 
 AudioOutputDelegateImpl::ControllerEventHandler::ControllerEventHandler(
     base::WeakPtr<AudioOutputDelegateImpl> delegate)
     : delegate_(std::move(delegate)) {}
 
 void AudioOutputDelegateImpl::ControllerEventHandler::OnControllerCreated() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&AudioOutputDelegateImpl::SendCreatedNotification, delegate_));
+      base::BindOnce(&AudioOutputDelegateImpl::SendCreatedNotification,
+                     delegate_));
 }
 
 void AudioOutputDelegateImpl::ControllerEventHandler::OnControllerPlaying() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&AudioOutputDelegateImpl::UpdatePlayingState, delegate_,
-                 true));
+      base::BindOnce(&AudioOutputDelegateImpl::UpdatePlayingState, delegate_,
+                     true));
 }
 
 void AudioOutputDelegateImpl::ControllerEventHandler::OnControllerPaused() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&AudioOutputDelegateImpl::UpdatePlayingState, delegate_,
-                 false));
+      base::BindOnce(&AudioOutputDelegateImpl::UpdatePlayingState, delegate_,
+                     false));
 }
 
 void AudioOutputDelegateImpl::ControllerEventHandler::OnControllerError() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&AudioOutputDelegateImpl::OnError, delegate_));
+      base::BindOnce(&AudioOutputDelegateImpl::OnError, delegate_));
 }
 
 AudioOutputDelegateImpl::AudioOutputDelegateImpl(
     EventHandler* handler,
     media::AudioManager* audio_manager,
     std::unique_ptr<media::AudioLog> audio_log,
     AudioMirroringManager* mirroring_manager,
     MediaObserver* media_observer,
     int stream_id,
     int render_frame_id,
@@ skipping 33 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   UpdatePlayingState(false);
   audio_log_->OnClosed(stream_id_);
 
   // Since the ownership of |controller_| is shared, we instead use its Close
   // method to stop callbacks from it. |controller_| will call the closure (on
   // the IO thread) when it's done closing, and it is only after that call that
   // we can delete |controller_event_handler_| and |reader_|. By giving the
   // closure ownership of these, we keep them alive until |controller_| is
   // closed. |mirroring_manager_| is a lazy instance, so passing it is safe.
-  controller_->Close(base::Bind(
+  controller_->Close(base::BindOnce(
       [](AudioMirroringManager* mirroring_manager,
          std::unique_ptr<ControllerEventHandler> event_handler,
          std::unique_ptr<AudioSyncReader> reader,
          scoped_refptr<media::AudioOutputController> controller) {
         // De-register the controller from the AudioMirroringManager now that
         // the controller has closed the AudioOutputStream and shut itself down.
         // This ensures that calling RemoveDiverter() here won't trigger the
         // controller to re-start the default AudioOutputStream and cause a
         // brief audio blip to come out the user's speakers.
         // http://crbug.com/474432
@@ skipping 42 matching lines @@
   if (playing == playing_)
     return;
 
   playing_ = playing;
   if (playing) {
     // Note that this takes a reference to |controller_|, and
     // (Start|Stop)MonitoringStream calls are async, so we don't have a
     // guarantee for when the controller is destroyed.
     AudioStreamMonitor::StartMonitoringStream(
         render_process_id_, render_frame_id_, stream_id_,
-        base::Bind(&media::AudioOutputController::ReadCurrentPowerAndClip,
-                   controller_));
+        base::BindRepeating(
+            &media::AudioOutputController::ReadCurrentPowerAndClip,
+            controller_));
   } else {
     AudioStreamMonitor::StopMonitoringStream(render_process_id_,
                                              render_frame_id_, stream_id_);
   }
 }
 
 void AudioOutputDelegateImpl::OnError() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   audio_log_->OnError(stream_id_);
   subscriber_->OnStreamError(stream_id_);
 }
 
 media::AudioOutputController* AudioOutputDelegateImpl::GetControllerForTesting()
     const {
   return controller_.get();
 }
 
 }  // namespace content