Convert some audio code to OnceCallback.

media/audio/audio_system_impl.cc

 // Copyright 2017 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_system_impl.h"
 
+#include <memory>
+#include <string>
+#include <utility>
+
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/audio_manager.h"
 #include "media/base/bind_to_current_loop.h"
 
 // Using base::Unretained for |audio_manager_| is safe since it is deleted after
 // its task runner, and AudioSystemImpl is deleted on the UI thread after the IO
 // thread has been stopped and before |audio_manager_| deletion is scheduled.
@@ skipping 20 matching lines @@
     OnAudioParamsCallback on_params_cb) const {
   if (GetTaskRunner()->BelongsToCurrentThread()) {
     GetTaskRunner()->PostTask(FROM_HERE,
                               base::BindOnce(std::move(on_params_cb),
                                              GetInputParametersOnDeviceThread(
                                                  audio_manager_, device_id)));
     return;
   }
   base::PostTaskAndReplyWithResult(
       GetTaskRunner(), FROM_HERE,
-      base::Bind(&AudioSystemImpl::GetInputParametersOnDeviceThread,
-                 base::Unretained(audio_manager_), device_id),
+      base::BindOnce(&AudioSystemImpl::GetInputParametersOnDeviceThread,
+                     base::Unretained(audio_manager_), device_id),
       std::move(on_params_cb));
 }
 
 void AudioSystemImpl::GetOutputStreamParameters(
     const std::string& device_id,
     OnAudioParamsCallback on_params_cb) const {
   if (GetTaskRunner()->BelongsToCurrentThread()) {
     GetTaskRunner()->PostTask(FROM_HERE,
                               base::BindOnce(std::move(on_params_cb),
                                              GetOutputParametersOnDeviceThread(
                                                  audio_manager_, device_id)));
     return;
   }
   base::PostTaskAndReplyWithResult(
       GetTaskRunner(), FROM_HERE,
-      base::Bind(&AudioSystemImpl::GetOutputParametersOnDeviceThread,
-                 base::Unretained(audio_manager_), device_id),
+      base::BindOnce(&AudioSystemImpl::GetOutputParametersOnDeviceThread,
+                     base::Unretained(audio_manager_), device_id),
       std::move(on_params_cb));
 }
 
 void AudioSystemImpl::HasInputDevices(OnBoolCallback on_has_devices_cb) const {
   if (GetTaskRunner()->BelongsToCurrentThread()) {
     GetTaskRunner()->PostTask(
         FROM_HERE, base::BindOnce(std::move(on_has_devices_cb),
                                   audio_manager_->HasAudioInputDevices()));
     return;
   }
   base::PostTaskAndReplyWithResult(
       GetTaskRunner(), FROM_HERE,
-      base::Bind(&AudioManager::HasAudioInputDevices,
-                 base::Unretained(audio_manager_)),
+      base::BindOnce(&AudioManager::HasAudioInputDevices,
+                     base::Unretained(audio_manager_)),
       std::move(on_has_devices_cb));
 }
 
 void AudioSystemImpl::HasOutputDevices(OnBoolCallback on_has_devices_cb) const {
   if (GetTaskRunner()->BelongsToCurrentThread()) {
     GetTaskRunner()->PostTask(
         FROM_HERE, base::BindOnce(std::move(on_has_devices_cb),
                                   audio_manager_->HasAudioOutputDevices()));
     return;
   }
   base::PostTaskAndReplyWithResult(
       GetTaskRunner(), FROM_HERE,
-      base::Bind(&AudioManager::HasAudioOutputDevices,
-                 base::Unretained(audio_manager_)),
+      base::BindOnce(&AudioManager::HasAudioOutputDevices,
+                     base::Unretained(audio_manager_)),
       std::move(on_has_devices_cb));
 }
 
 void AudioSystemImpl::GetDeviceDescriptions(
     OnDeviceDescriptionsCallback on_descriptions_cb,
     bool for_input) {
   if (GetTaskRunner()->BelongsToCurrentThread()) {
     GetTaskRunner()->PostTask(
         FROM_HERE,
         base::BindOnce(std::move(on_descriptions_cb),
                        base::Passed(GetDeviceDescriptionsOnDeviceThread(
                            audio_manager_, for_input))));
     return;
   }
 
   base::PostTaskAndReplyWithResult(
       GetTaskRunner(), FROM_HERE,
-      base::Bind(&AudioSystemImpl::GetDeviceDescriptionsOnDeviceThread,
-                 base::Unretained(audio_manager_), for_input),
+      base::BindOnce(&AudioSystemImpl::GetDeviceDescriptionsOnDeviceThread,
+                     base::Unretained(audio_manager_), for_input),
       std::move(on_descriptions_cb));
 }
 
 void AudioSystemImpl::GetAssociatedOutputDeviceID(
     const std::string& input_device_id,
     OnDeviceIdCallback on_device_id_cb) {
   if (GetTaskRunner()->BelongsToCurrentThread()) {
     GetTaskRunner()->PostTask(
         FROM_HERE, base::BindOnce(std::move(on_device_id_cb),
                                   audio_manager_->GetAssociatedOutputDeviceID(
                                       input_device_id)));
     return;
   }
   base::PostTaskAndReplyWithResult(
       GetTaskRunner(), FROM_HERE,
-      base::Bind(&AudioManager::GetAssociatedOutputDeviceID,
-                 base::Unretained(audio_manager_), input_device_id),
+      base::BindOnce(&AudioManager::GetAssociatedOutputDeviceID,
+                     base::Unretained(audio_manager_), input_device_id),
       std::move(on_device_id_cb));
 }
 
 void AudioSystemImpl::GetInputDeviceInfo(
     const std::string& input_device_id,
     OnInputDeviceInfoCallback on_input_device_info_cb) {
   // No need to bind |on_input_device_info_cb| to the current loop if we are on
   // the audio thread. However, the client still expect to receive the reply
   // asynchronously, so we always post GetInputDeviceInfoOnDeviceThread(), which
   // will syncronously call the (bound to current loop or not) callback.
@@ skipping 57 matching lines @@
 
 // static
 void AudioSystemImpl::GetInputDeviceInfoOnDeviceThread(
     AudioManager* audio_manager,
     const std::string& input_device_id,
     AudioSystem::OnInputDeviceInfoCallback on_input_device_info_cb) {
   DCHECK(audio_manager->GetTaskRunner()->BelongsToCurrentThread());
   const std::string associated_output_device_id =
       audio_manager->GetAssociatedOutputDeviceID(input_device_id);
 
-  on_input_device_info_cb.Run(
-      GetInputParametersOnDeviceThread(audio_manager, input_device_id),
-      associated_output_device_id.empty()
-          ? AudioParameters()
-          : GetOutputParametersOnDeviceThread(audio_manager,
-                                              associated_output_device_id),
-      associated_output_device_id);
+  std::move(on_input_device_info_cb)
+      .Run(GetInputParametersOnDeviceThread(audio_manager, input_device_id),
+           associated_output_device_id.empty()
+               ? AudioParameters()
+               : GetOutputParametersOnDeviceThread(audio_manager,
+                                                   associated_output_device_id),
+           associated_output_device_id);
 }
 
 }  // namespace media