Enable use_once_callback for //content/common/*.mojom

content/browser/renderer_host/media/media_devices_dispatcher_host.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/media_devices_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 124 matching lines @@
               static_cast<MediaDeviceType>(i), this);
     }
   }
 }
 
 void MediaDevicesDispatcherHost::EnumerateDevices(
     bool request_audio_input,
     bool request_video_input,
     bool request_audio_output,
     const url::Origin& security_origin,
-    const EnumerateDevicesCallback& client_callback) {
+    EnumerateDevicesCallback client_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!request_audio_input && !request_video_input && !request_audio_output) {
     bad_message::ReceivedBadMessage(
         render_process_id_, bad_message::MDDH_INVALID_DEVICE_TYPE_REQUEST);
     return;
   }
 
   // Ignore requests from unique origins, but do not crash the renderer.
   if (security_origin.unique())
     return;
 
   if (!MediaStreamManager::IsOriginAllowed(render_process_id_,
                                            security_origin)) {
     bad_message::ReceivedBadMessage(render_process_id_,
                                     bad_message::MDDH_UNAUTHORIZED_ORIGIN);
     return;
   }
 
   MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
   devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_INPUT] = request_audio_input;
   devices_to_enumerate[MEDIA_DEVICE_TYPE_VIDEO_INPUT] = request_video_input;
   devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = request_audio_output;
 
   permission_checker_->CheckPermissions(
       devices_to_enumerate, render_process_id_, render_frame_id_,
       security_origin,
       base::Bind(&MediaDevicesDispatcherHost::DoEnumerateDevices,
                  weak_factory_.GetWeakPtr(), devices_to_enumerate,
-                 security_origin, client_callback));
+                 security_origin, base::Passed(&client_callback)));
 }
 
 void MediaDevicesDispatcherHost::GetVideoInputCapabilities(
     const url::Origin& security_origin,
-    const GetVideoInputCapabilitiesCallback& client_callback) {
+    GetVideoInputCapabilitiesCallback client_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!MediaStreamManager::IsOriginAllowed(render_process_id_,
                                            security_origin)) {
     bad_message::ReceivedBadMessage(render_process_id_,
                                     bad_message::MDDH_UNAUTHORIZED_ORIGIN);
     return;
   }
 
   GetDefaultMediaDeviceID(
       MEDIA_DEVICE_TYPE_VIDEO_INPUT, render_process_id_, render_frame_id_,
       base::Bind(&MediaDevicesDispatcherHost::GotDefaultVideoInputDeviceID,
-                 weak_factory_.GetWeakPtr(), security_origin, client_callback));
+                 weak_factory_.GetWeakPtr(), security_origin,
+                 base::Passed(&client_callback)));
 }
 
 void MediaDevicesDispatcherHost::SubscribeDeviceChangeNotifications(
     MediaDeviceType type,
     uint32_t subscription_id,
     const url::Origin& security_origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(IsValidMediaDeviceType(type));
   if (!MediaStreamManager::IsOriginAllowed(render_process_id_,
                                            security_origin)) {
@@ skipping 102 matching lines @@
 
 void MediaDevicesDispatcherHost::SetDeviceChangeListenerForTesting(
     ::mojom::MediaDevicesListenerPtr listener) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   device_change_listener_ = std::move(listener);
 }
 
 void MediaDevicesDispatcherHost::DoEnumerateDevices(
     const MediaDevicesManager::BoolDeviceTypes& requested_types,
     const url::Origin& security_origin,
-    const EnumerateDevicesCallback& client_callback,
+    EnumerateDevicesCallback client_callback,
     const MediaDevicesManager::BoolDeviceTypes& has_permissions) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   media_stream_manager_->media_devices_manager()->EnumerateDevices(
       requested_types,
       base::Bind(&MediaDevicesDispatcherHost::DevicesEnumerated,
                  weak_factory_.GetWeakPtr(), requested_types, security_origin,
-                 client_callback, has_permissions));
+                 base::Passed(&client_callback), has_permissions));
 }
 
 void MediaDevicesDispatcherHost::DevicesEnumerated(
     const MediaDevicesManager::BoolDeviceTypes& requested_types,
     const url::Origin& security_origin,
-    const EnumerateDevicesCallback& client_callback,
+    EnumerateDevicesCallback client_callback,
     const MediaDevicesManager::BoolDeviceTypes& has_permissions,
     const MediaDeviceEnumeration& enumeration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   std::vector<std::vector<MediaDeviceInfo>> result(NUM_MEDIA_DEVICE_TYPES);
   for (size_t i = 0; i < NUM_MEDIA_DEVICE_TYPES; ++i) {
     if (!requested_types[i])
       continue;
 
     for (const auto& device_info : enumeration[i]) {
       result[i].push_back(TranslateDeviceInfo(has_permissions[i],
                                               device_id_salt_, group_id_salt_,
                                               security_origin, device_info));
     }
   }
-  client_callback.Run(result);
+  std::move(client_callback).Run(result);
 }
 
 void MediaDevicesDispatcherHost::GotDefaultVideoInputDeviceID(
     const url::Origin& security_origin,
-    const GetVideoInputCapabilitiesCallback& client_callback,
+    GetVideoInputCapabilitiesCallback client_callback,
     const std::string& default_device_id) {
   MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
   devices_to_enumerate[MEDIA_DEVICE_TYPE_VIDEO_INPUT] = true;
   media_stream_manager_->video_capture_manager()->EnumerateDevices(
       base::Bind(&MediaDevicesDispatcherHost::FinalizeGetVideoInputCapabilities,
-                 weak_factory_.GetWeakPtr(), security_origin, client_callback,
-                 default_device_id));
+                 weak_factory_.GetWeakPtr(), security_origin,
+                 base::Passed(&client_callback), default_device_id));
 }
 
 void MediaDevicesDispatcherHost::FinalizeGetVideoInputCapabilities(
     const url::Origin& security_origin,
-    const GetVideoInputCapabilitiesCallback& client_callback,
+    GetVideoInputCapabilitiesCallback client_callback,
     const std::string& default_device_id,
     const media::VideoCaptureDeviceDescriptors& device_descriptors) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   std::vector<::mojom::VideoInputDeviceCapabilitiesPtr>
       video_input_capabilities;
   for (const auto& descriptor : device_descriptors) {
     std::string hmac_device_id = GetHMACForMediaDeviceID(
         device_id_salt_, security_origin, descriptor.device_id);
     ::mojom::VideoInputDeviceCapabilitiesPtr capabilities =
         ::mojom::VideoInputDeviceCapabilities::New();
@@ skipping 22 matching lines @@
       capabilities->facing_mode = ::mojom::FacingMode::ENVIRONMENT;
 #endif
     if (descriptor.device_id == default_device_id) {
       video_input_capabilities.insert(video_input_capabilities.begin(),
                                       std::move(capabilities));
     } else {
       video_input_capabilities.push_back(std::move(capabilities));
     }
   }
 
-  client_callback.Run(std::move(video_input_capabilities));
+  std::move(client_callback).Run(std::move(video_input_capabilities));
 }
 
 media::VideoCaptureFormats MediaDevicesDispatcherHost::GetVideoInputFormats(
     const std::string& device_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   media::VideoCaptureFormats formats;
   base::Optional<media::VideoCaptureFormat> format =
       media_stream_manager_->video_capture_manager()->GetDeviceFormatInUse(
           MEDIA_DEVICE_VIDEO_CAPTURE, device_id);
   if (format.has_value()) {
     formats.push_back(format.value());
     return formats;
   }
 
   media_stream_manager_->video_capture_manager()->GetDeviceSupportedFormats(
       device_id, &formats);
   return formats;
 }
 
 }  // namespace content