OLD | NEW |
(Empty) | |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "content/browser/renderer_host/media/media_devices_dispatcher_host.h" |
| 6 |
| 7 #include <utility> |
| 8 #include <vector> |
| 9 |
| 10 #include "base/bind_helpers.h" |
| 11 #include "base/memory/ptr_util.h" |
| 12 #include "content/browser/bad_message.h" |
| 13 #include "content/browser/renderer_host/media/media_stream_manager.h" |
| 14 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h" |
| 15 #include "content/common/media/media_devices.h" |
| 16 #include "content/public/browser/browser_thread.h" |
| 17 #include "content/public/browser/media_device_id.h" |
| 18 #include "content/public/browser/render_frame_host.h" |
| 19 #include "content/public/browser/resource_context.h" |
| 20 #include "content/public/common/media_stream_request.h" |
| 21 #include "mojo/public/cpp/bindings/strong_binding.h" |
| 22 #include "services/shell/public/cpp/interface_provider.h" |
| 23 #include "url/origin.h" |
| 24 |
| 25 namespace content { |
| 26 |
| 27 namespace { |
| 28 |
| 29 MediaDeviceInfo TranslateDeviceInfo(bool has_permission, |
| 30 const std::string& device_id_salt, |
| 31 const std::string& group_id_salt, |
| 32 const url::Origin& security_origin, |
| 33 const MediaDeviceInfo& device_info) { |
| 34 return MediaDeviceInfo( |
| 35 GetHMACForMediaDeviceID(device_id_salt, security_origin, |
| 36 device_info.device_id), |
| 37 has_permission ? device_info.label : std::string(), |
| 38 device_info.group_id.empty() |
| 39 ? std::string() |
| 40 : GetHMACForMediaDeviceID(group_id_salt, security_origin, |
| 41 device_info.group_id)); |
| 42 } |
| 43 |
| 44 } // namespace |
| 45 |
| 46 // static |
| 47 void MediaDevicesDispatcherHost::Create( |
| 48 int render_process_id, |
| 49 int routing_id, |
| 50 const std::string& device_id_salt, |
| 51 MediaStreamManager* media_stream_manager, |
| 52 bool use_fake_ui, |
| 53 ::mojom::MediaDevicesDispatcherHostRequest request) { |
| 54 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 55 mojo::MakeStrongBinding(base::MakeUnique<MediaDevicesDispatcherHost>( |
| 56 render_process_id, routing_id, device_id_salt, |
| 57 media_stream_manager, use_fake_ui), |
| 58 std::move(request)); |
| 59 } |
| 60 |
| 61 MediaDevicesDispatcherHost::MediaDevicesDispatcherHost( |
| 62 int render_process_id, |
| 63 int routing_id, |
| 64 const std::string& device_id_salt, |
| 65 MediaStreamManager* media_stream_manager, |
| 66 bool use_fake_ui) |
| 67 : render_process_id_(render_process_id), |
| 68 routing_id_(routing_id), |
| 69 device_id_salt_(device_id_salt), |
| 70 group_id_salt_(ResourceContext::CreateRandomMediaDeviceIDSalt()), |
| 71 media_stream_manager_(media_stream_manager), |
| 72 use_fake_ui_(use_fake_ui), |
| 73 weak_factory_(this) { |
| 74 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 75 } |
| 76 |
| 77 MediaDevicesDispatcherHost::~MediaDevicesDispatcherHost() { |
| 78 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 79 } |
| 80 |
| 81 void MediaDevicesDispatcherHost::EnumerateDevices( |
| 82 bool request_audio_input, |
| 83 bool request_video_input, |
| 84 bool request_audio_output, |
| 85 const url::Origin& security_origin, |
| 86 const EnumerateDevicesCallback& client_callback) { |
| 87 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 88 |
| 89 if (!request_audio_input && !request_video_input && !request_audio_output) { |
| 90 bad_message::ReceivedBadMessage( |
| 91 render_process_id_, bad_message::MDDH_INVALID_DEVICE_TYPE_REQUEST); |
| 92 return; |
| 93 } |
| 94 |
| 95 if (!MediaStreamManager::IsOriginAllowed(render_process_id_, |
| 96 security_origin)) { |
| 97 bad_message::ReceivedBadMessage(render_process_id_, |
| 98 bad_message::MDDH_UNAUTHORIZED_ORIGIN); |
| 99 return; |
| 100 } |
| 101 |
| 102 MediaDevicesManager::BoolDeviceTypes devices_to_enumerate; |
| 103 devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_INPUT] = request_audio_input; |
| 104 devices_to_enumerate[MEDIA_DEVICE_TYPE_VIDEO_INPUT] = request_video_input; |
| 105 devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = request_audio_output; |
| 106 |
| 107 bool request_audio = request_audio_input || request_audio_output; |
| 108 CheckAccess(request_audio, request_video_input, security_origin, |
| 109 base::Bind(&MediaDevicesDispatcherHost::DoEnumerateDevices, |
| 110 weak_factory_.GetWeakPtr(), devices_to_enumerate, |
| 111 security_origin, client_callback)); |
| 112 } |
| 113 |
| 114 void MediaDevicesDispatcherHost::CheckAccess( |
| 115 bool check_audio, |
| 116 bool check_video_input, |
| 117 const url::Origin& security_origin, |
| 118 const AccessCheckedCallback& callback) { |
| 119 DCHECK(check_audio || check_video_input); |
| 120 std::unique_ptr<MediaStreamUIProxy> ui_proxy = GetUIProxy(); |
| 121 if (check_audio) { |
| 122 ui_proxy->CheckAccess( |
| 123 security_origin, MEDIA_DEVICE_AUDIO_CAPTURE, render_process_id_, |
| 124 routing_id_, |
| 125 base::Bind(&MediaDevicesDispatcherHost::AudioAccessChecked, |
| 126 weak_factory_.GetWeakPtr(), base::Passed(&ui_proxy), |
| 127 check_video_input, security_origin, callback)); |
| 128 return; |
| 129 } |
| 130 |
| 131 DCHECK(check_video_input); |
| 132 ui_proxy->CheckAccess( |
| 133 security_origin, MEDIA_DEVICE_VIDEO_CAPTURE, render_process_id_, |
| 134 routing_id_, |
| 135 base::Bind(&MediaDevicesDispatcherHost::VideoAccessChecked, |
| 136 weak_factory_.GetWeakPtr(), base::Passed(&ui_proxy), |
| 137 false /* has_audio_permission */, callback)); |
| 138 } |
| 139 |
| 140 void MediaDevicesDispatcherHost::AudioAccessChecked( |
| 141 std::unique_ptr<MediaStreamUIProxy> ui_proxy, |
| 142 bool check_video_permission, |
| 143 const url::Origin& security_origin, |
| 144 const AccessCheckedCallback& callback, |
| 145 bool has_audio_permission) { |
| 146 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 147 if (check_video_permission) { |
| 148 ui_proxy->CheckAccess( |
| 149 security_origin, MEDIA_DEVICE_VIDEO_CAPTURE, render_process_id_, |
| 150 routing_id_, |
| 151 base::Bind(&MediaDevicesDispatcherHost::VideoAccessChecked, |
| 152 weak_factory_.GetWeakPtr(), base::Passed(&ui_proxy), |
| 153 has_audio_permission, callback)); |
| 154 return; |
| 155 } |
| 156 |
| 157 MediaDevicesManager::BoolDeviceTypes permissions; |
| 158 permissions[MEDIA_DEVICE_TYPE_AUDIO_INPUT] = has_audio_permission; |
| 159 permissions[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = has_audio_permission; |
| 160 callback.Run(permissions); |
| 161 } |
| 162 |
| 163 void MediaDevicesDispatcherHost::VideoAccessChecked( |
| 164 std::unique_ptr<MediaStreamUIProxy> ui_proxy, |
| 165 bool has_audio_permission, |
| 166 const AccessCheckedCallback& callback, |
| 167 bool has_video_permission) { |
| 168 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 169 MediaDevicesManager::BoolDeviceTypes permissions; |
| 170 permissions[MEDIA_DEVICE_TYPE_AUDIO_INPUT] = has_audio_permission; |
| 171 permissions[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = has_audio_permission; |
| 172 permissions[MEDIA_DEVICE_TYPE_VIDEO_INPUT] = has_video_permission; |
| 173 callback.Run(permissions); |
| 174 } |
| 175 |
| 176 void MediaDevicesDispatcherHost::DoEnumerateDevices( |
| 177 const MediaDevicesManager::BoolDeviceTypes& requested_types, |
| 178 const url::Origin& security_origin, |
| 179 const EnumerateDevicesCallback& client_callback, |
| 180 const MediaDevicesManager::BoolDeviceTypes& has_permissions) { |
| 181 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 182 media_stream_manager_->media_devices_manager()->EnumerateDevices( |
| 183 requested_types, |
| 184 base::Bind(&MediaDevicesDispatcherHost::DevicesEnumerated, |
| 185 weak_factory_.GetWeakPtr(), requested_types, security_origin, |
| 186 client_callback, has_permissions)); |
| 187 } |
| 188 |
| 189 void MediaDevicesDispatcherHost::DevicesEnumerated( |
| 190 const MediaDevicesManager::BoolDeviceTypes& requested_types, |
| 191 const url::Origin& security_origin, |
| 192 const EnumerateDevicesCallback& client_callback, |
| 193 const MediaDevicesManager::BoolDeviceTypes& has_permissions, |
| 194 const MediaDeviceEnumeration& enumeration) { |
| 195 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 196 std::vector<std::vector<MediaDeviceInfo>> result(NUM_MEDIA_DEVICE_TYPES); |
| 197 for (size_t i = 0; i < NUM_MEDIA_DEVICE_TYPES; ++i) { |
| 198 if (!requested_types[i]) |
| 199 continue; |
| 200 |
| 201 for (const auto& device_info : enumeration[i]) { |
| 202 result[i].push_back(TranslateDeviceInfo(has_permissions[i], |
| 203 device_id_salt_, group_id_salt_, |
| 204 security_origin, device_info)); |
| 205 } |
| 206 } |
| 207 client_callback.Run(result); |
| 208 } |
| 209 |
| 210 std::unique_ptr<MediaStreamUIProxy> MediaDevicesDispatcherHost::GetUIProxy() { |
| 211 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 212 if (use_fake_ui_) { |
| 213 return fake_ui_proxy_ ? std::move(fake_ui_proxy_) |
| 214 : base::MakeUnique<FakeMediaStreamUIProxy>(); |
| 215 } |
| 216 return MediaStreamUIProxy::Create(); |
| 217 } |
| 218 |
| 219 void MediaDevicesDispatcherHost::SetFakeUIProxyForTesting( |
| 220 std::unique_ptr<MediaStreamUIProxy> fake_ui_proxy) { |
| 221 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 222 if (use_fake_ui_) |
| 223 fake_ui_proxy_ = std::move(fake_ui_proxy); |
| 224 } |
| 225 |
| 226 } // namespace content |
OLD | NEW |