Convert some audio code to OnceCallback.

media/audio/audio_output_controller.cc

 // Copyright (c) 2012 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 "media/audio/audio_output_controller.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 53 matching lines @@
     SyncReader* sync_reader) {
   CHECK(audio_manager);
   CHECK_EQ(AudioManager::Get(), audio_manager);
   DCHECK(sync_reader);
 
   if (!params.IsValid())
     return NULL;
 
   scoped_refptr<AudioOutputController> controller(new AudioOutputController(
       audio_manager, event_handler, params, output_device_id, sync_reader));
-  controller->message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoCreate, controller, false));
+  controller->message_loop_->PostTask(
+      FROM_HERE,
+      base::BindOnce(&AudioOutputController::DoCreate, controller, false));
   return controller;
 }
 
 void AudioOutputController::Play() {
   CHECK_EQ(AudioManager::Get(), audio_manager_);
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoPlay, this));
+  message_loop_->PostTask(FROM_HERE,
+                          base::BindOnce(&AudioOutputController::DoPlay, this));
 }
 
 void AudioOutputController::Pause() {
   CHECK_EQ(AudioManager::Get(), audio_manager_);
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoPause, this));
+  message_loop_->PostTask(
+      FROM_HERE, base::BindOnce(&AudioOutputController::DoPause, this));
 }
 
-void AudioOutputController::Close(const base::Closure& closed_task) {
+void AudioOutputController::Close(base::OnceClosure closed_task) {
   CHECK_EQ(AudioManager::Get(), audio_manager_);
   DCHECK(!closed_task.is_null());
-  message_loop_->PostTaskAndReply(FROM_HERE, base::Bind(
-      &AudioOutputController::DoClose, this), closed_task);
+  message_loop_->PostTaskAndReply(
+      FROM_HERE, base::BindOnce(&AudioOutputController::DoClose, this),
+      std::move(closed_task));
 }
 
 void AudioOutputController::SetVolume(double volume) {
   CHECK_EQ(AudioManager::Get(), audio_manager_);
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoSetVolume, this, volume));
+  message_loop_->PostTask(
+      FROM_HERE,
+      base::BindOnce(&AudioOutputController::DoSetVolume, this, volume));
 }
 
 void AudioOutputController::DoCreate(bool is_for_device_change) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.CreateTime");
   TRACE_EVENT0("audio", "AudioOutputController::DoCreate");
 
   // Close() can be called before DoCreate() is executed.
   if (state_ == kClosed)
     return;
@@ skipping 161 matching lines @@
   {
     base::AutoLock lock(duplication_targets_lock_);
     need_to_duplicate = !duplication_targets_.empty();
   }
   if (need_to_duplicate) {
     const base::TimeTicks reference_time = delay_timestamp + delay;
     std::unique_ptr<AudioBus> copy(AudioBus::Create(params_));
     dest->CopyTo(copy.get());
     message_loop_->PostTask(
         FROM_HERE,
-        base::Bind(&AudioOutputController::BroadcastDataToDuplicationTargets,
-                   this, base::Passed(&copy), reference_time));
+        base::BindOnce(
+            &AudioOutputController::BroadcastDataToDuplicationTargets, this,
+            std::move(copy), reference_time));
   }
 
   if (will_monitor_audio_levels())
     power_monitor_.Scan(*dest, frames);
 
   return frames;
 }
 
 void AudioOutputController::BroadcastDataToDuplicationTargets(
     std::unique_ptr<AudioBus> audio_bus,
@@ skipping 15 matching lines @@
 }
 
 void AudioOutputController::OnError(AudioOutputStream* stream) {
   {
     base::AutoLock auto_lock(error_lock_);
     if (ignore_errors_during_stop_close_)
       return;
   }
 
   // Handle error on the audio controller thread.
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoReportError, this));
+  message_loop_->PostTask(
+      FROM_HERE, base::BindOnce(&AudioOutputController::DoReportError, this));
 }
 
 void AudioOutputController::DoStopCloseAndClearStream() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Allow calling unconditionally and bail if we don't have a stream_ to close.
   if (stream_) {
     {
       base::AutoLock auto_lock(error_lock_);
       ignore_errors_during_stop_close_ = true;
@@ skipping 47 matching lines @@
       NOTREACHED() << "Invalid original state.";
   }
 }
 
 const AudioParameters& AudioOutputController::GetAudioParameters() {
   return params_;
 }
 
 void AudioOutputController::StartDiverting(AudioOutputStream* to_stream) {
   message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&AudioOutputController::DoStartDiverting, this, to_stream));
+      FROM_HERE, base::BindOnce(&AudioOutputController::DoStartDiverting, this,
+                                to_stream));
 }
 
 void AudioOutputController::StopDiverting() {
   message_loop_->PostTask(
-      FROM_HERE, base::Bind(&AudioOutputController::DoStopDiverting, this));
+      FROM_HERE, base::BindOnce(&AudioOutputController::DoStopDiverting, this));
 }
 
 void AudioOutputController::StartDuplicating(AudioPushSink* sink) {
   message_loop_->PostTask(
       FROM_HERE,
-      base::Bind(&AudioOutputController::DoStartDuplicating, this, sink));
+      base::BindOnce(&AudioOutputController::DoStartDuplicating, this, sink));
 }
 
 void AudioOutputController::StopDuplicating(AudioPushSink* sink) {
   message_loop_->PostTask(
       FROM_HERE,
-      base::Bind(&AudioOutputController::DoStopDuplicating, this, sink));
+      base::BindOnce(&AudioOutputController::DoStopDuplicating, this, sink));
 }
 
 void AudioOutputController::DoStartDiverting(AudioOutputStream* to_stream) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (state_ == kClosed)
     return;
 
   DCHECK(!diverting_to_stream_);
   diverting_to_stream_ = to_stream;
@@ skipping 42 matching lines @@
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // If we should be playing and we haven't, that's a wedge.
   if (state_ == kPlaying) {
     UMA_HISTOGRAM_BOOLEAN("Media.AudioOutputControllerPlaybackStartupSuccess",
                           base::AtomicRefCountIsOne(&on_more_io_data_called_));
   }
 }
 
 }  // namespace media