AudioSystemImpl binding cleanup

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 "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"
@@ skipping 79 matching lines @@
 // static
 std::unique_ptr<AudioSystem> AudioSystemImpl::Create(
     AudioManager* audio_manager) {
   return base::WrapUnique(new AudioSystemImpl(audio_manager));
 }
 
 void AudioSystemImpl::GetInputStreamParameters(
     const std::string& device_id,
     OnAudioParamsCallback on_params_cb) const {
   if (GetTaskRunner()->BelongsToCurrentThread()) {
-    GetTaskRunner()->PostTask(
-        FROM_HERE, base::Bind(on_params_cb, GetInputParametersOnDeviceThread(
-                                                audio_manager_, device_id)));
+    GetTaskRunner()->PostTask(FROM_HERE,
+                              base::BindOnce(std::move(on_params_cb),
+                                             GetInputParametersOnDeviceThread(
+                                                 audio_manager_, device_id)));
     return;
   }
   base::PostTaskAndReplyWithResult(
       GetTaskRunner(), FROM_HERE,
       base::Bind(&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::Bind(on_params_cb, GetOutputParametersOnDeviceThread(
-                                                audio_manager_, device_id)));
+    GetTaskRunner()->PostTask(FROM_HERE,
+                              base::BindOnce(std::move(on_params_cb),
+                                             GetOutputParametersOnDeviceThread(
+                                                 audio_manager_, device_id)));
     return;
   }
   base::PostTaskAndReplyWithResult(
       GetTaskRunner(), FROM_HERE,
       base::Bind(&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::Bind(on_has_devices_cb, audio_manager_->HasAudioInputDevices()));
+        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_)),
       std::move(on_has_devices_cb));
 }
 
 void AudioSystemImpl::HasOutputDevices(OnBoolCallback on_has_devices_cb) const {
   if (GetTaskRunner()->BelongsToCurrentThread()) {
     GetTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(on_has_devices_cb, audio_manager_->HasAudioOutputDevices()));
+        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_)),
       std::move(on_has_devices_cb));
 }
 
 void AudioSystemImpl::GetDeviceDescriptions(
     OnDeviceDescriptionsCallback on_descriptions_cb,
     bool for_input) {
   if (GetTaskRunner()->BelongsToCurrentThread()) {
     GetTaskRunner()->PostTask(
-        FROM_HERE, base::Bind(on_descriptions_cb,
-                              base::Passed(GetDeviceDescriptionsOnDeviceThread(
-                                  audio_manager_, for_input))));
+        FROM_HERE,
+        base::BindOnce(std::move(on_descriptions_cb),
+                       base::Passed(GetDeviceDescriptionsOnDeviceThread(
+                           audio_manager_, for_input))));
     return;
   }
 
   base::PostTaskAndReplyWithResult(
       GetTaskRunner(), FROM_HERE,
       base::Bind(&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::Bind(on_device_id_cb, audio_manager_->GetAssociatedOutputDeviceID(
-                                        input_device_id)));
+        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),
       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.
   GetTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&GetInputDeviceInfoOnDeviceThread,
-                            base::Unretained(audio_manager_), input_device_id,
-                            GetTaskRunner()->BelongsToCurrentThread()
-                                ? std::move(on_input_device_info_cb)
-                                : media::BindToCurrentLoop(
-                                      std::move(on_input_device_info_cb))));
+      FROM_HERE,
+      base::BindOnce(
+          &GetInputDeviceInfoOnDeviceThread, base::Unretained(audio_manager_),
+          input_device_id,
+          GetTaskRunner()->BelongsToCurrentThread()
+              ? std::move(on_input_device_info_cb)
+              : media::BindToCurrentLoop(std::move(on_input_device_info_cb))));
 }
 
 base::SingleThreadTaskRunner* AudioSystemImpl::GetTaskRunner() const {
   return audio_manager_->GetTaskRunner();
 }
 
 }  // namespace media