Convert some audio code to OnceCallback.

content/browser/renderer_host/media/audio_output_authorization_handler.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_authorization_handler.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/task_runner_util.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
@@ skipping 56 matching lines @@
 
 void AudioOutputAuthorizationHandler::RequestDeviceAuthorization(
     int render_frame_id,
     int session_id,
     const std::string& device_id,
     const url::Origin& security_origin,
     AuthorizationCompletedCallback cb) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!IsValidDeviceId(device_id)) {
-    cb.Run(media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND, false,
-           media::AudioParameters::UnavailableDeviceParams(), std::string());
+    std::move(cb).Run(media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND, false,
+                      media::AudioParameters::UnavailableDeviceParams(),
+                      std::string());
     return;
   }
 
   // If |session_id| should be used for output device selection and such an
   // output device is found, reuse the input device permissions.
   if (media::AudioDeviceDescription::UseSessionIdToSelectDevice(session_id,
                                                                 device_id)) {
     const StreamDeviceInfo* info =
         media_stream_manager_->audio_input_device_manager()
             ->GetOpenedDeviceInfoById(session_id);
@@ skipping 18 matching lines @@
 
   if (media::AudioDeviceDescription::IsDefaultDevice(device_id)) {
     // Default device doesn't need authorization.
     AccessChecked(std::move(cb), device_id, security_origin, true);
     return;
   }
 
   // Check security origin if nondefault device is requested.
   if (!MediaStreamManager::IsOriginAllowed(render_process_id_,
                                            security_origin)) {
-    cb.Run(media::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED, false,
-           media::AudioParameters::UnavailableDeviceParams(), std::string());
+    std::move(cb).Run(media::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED, false,
+                      media::AudioParameters::UnavailableDeviceParams(),
+                      std::string());
     bad_message::ReceivedBadMessage(render_process_id_,
                                     bad_message::AOAH_UNAUTHORIZED_URL);
     return;
   }
 
   // Check that MediaStream device permissions have been granted for
   // nondefault devices.
   permission_checker_->CheckPermission(
       MEDIA_DEVICE_TYPE_AUDIO_OUTPUT, render_process_id_, render_frame_id,
       security_origin,
-      base::Bind(&AudioOutputAuthorizationHandler::AccessChecked,
-                 weak_factory_.GetWeakPtr(), std::move(cb), device_id,
-                 security_origin));
+      base::BindOnce(&AudioOutputAuthorizationHandler::AccessChecked,
+                     weak_factory_.GetWeakPtr(), std::move(cb), device_id,
+                     security_origin));
 }
 
 void AudioOutputAuthorizationHandler::AccessChecked(
     AuthorizationCompletedCallback cb,
     const std::string& device_id,
     const url::Origin& security_origin,
     bool has_access) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!has_access) {
-    cb.Run(media::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED, false,
-           media::AudioParameters::UnavailableDeviceParams(), std::string());
+    std::move(cb).Run(media::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED, false,
+                      media::AudioParameters::UnavailableDeviceParams(),
+                      std::string());
     return;
   }
 
   // For default device, read output parameters directly. Nondefault
   // devices require translation first.
   if (media::AudioDeviceDescription::IsDefaultDevice(device_id)) {
     GetDeviceParameters(std::move(cb),
                         media::AudioDeviceDescription::kDefaultDeviceId);
-  } else {
-    MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
-    devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = true;
-    media_stream_manager_->media_devices_manager()->EnumerateDevices(
-        devices_to_enumerate,
-        base::Bind(&AudioOutputAuthorizationHandler::TranslateDeviceID,
-                   weak_factory_.GetWeakPtr(), std::move(cb), device_id,
-                   security_origin));
+    return;
   }
+  MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = true;
+  media_stream_manager_->media_devices_manager()->EnumerateDevices(
+      devices_to_enumerate,
+      base::Bind(&AudioOutputAuthorizationHandler::TranslateDeviceID,

[o1ka, 2017/05/10 08:03:02]

Once?

[Max Morin, 2017/05/10 10:39:59]

This would require messing around with MediaDevicesManager. Maybe for another
CL, but that stuff is scary :).

+                 weak_factory_.GetWeakPtr(), base::Passed(&cb), device_id,
+                 security_origin));
 }
 
 void AudioOutputAuthorizationHandler::TranslateDeviceID(
     AuthorizationCompletedCallback cb,
     const std::string& device_id,
     const url::Origin& security_origin,
     const MediaDeviceEnumeration& enumeration) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!media::AudioDeviceDescription::IsDefaultDevice(device_id));
   for (const MediaDeviceInfo& device_info :
        enumeration[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT]) {
     if (content::DoesMediaDeviceIDMatchHMAC(salt_, security_origin, device_id,
                                             device_info.device_id)) {
       GetDeviceParameters(std::move(cb), device_info.device_id);
       return;
     }
   }
-  cb.Run(media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND, false,
-         media::AudioParameters::UnavailableDeviceParams(), std::string());
+  std::move(cb).Run(media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND, false,
+                    media::AudioParameters::UnavailableDeviceParams(),
+                    std::string());
 }
 
 void AudioOutputAuthorizationHandler::GetDeviceParameters(
     AuthorizationCompletedCallback cb,
     const std::string& raw_device_id) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!raw_device_id.empty());
   audio_system_->GetOutputStreamParameters(
       raw_device_id,
-      base::Bind(&AudioOutputAuthorizationHandler::DeviceParametersReceived,
-                 weak_factory_.GetWeakPtr(), std::move(cb), false,
-                 raw_device_id));
+      base::BindOnce(&AudioOutputAuthorizationHandler::DeviceParametersReceived,
+                     weak_factory_.GetWeakPtr(), std::move(cb), false,
+                     raw_device_id));
 }
 
 void AudioOutputAuthorizationHandler::DeviceParametersReceived(
     AuthorizationCompletedCallback cb,
     bool should_send_id,
     const std::string& raw_device_id,
     const media::AudioParameters& output_params) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!raw_device_id.empty());
 
-  cb.Run(media::OUTPUT_DEVICE_STATUS_OK, should_send_id,
-         output_params.IsValid() ? output_params
-                                 : TryToFixAudioParameters(output_params),
-         raw_device_id);
+  std::move(cb).Run(media::OUTPUT_DEVICE_STATUS_OK, should_send_id,
+                    output_params.IsValid()
+                        ? output_params
+                        : TryToFixAudioParameters(output_params),
+                    raw_device_id);
 }
 
 }  // namespace content