| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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/renderer/media/media_stream_impl.h" | |
| 6 | |
| 7 #include <utility> | |
| 8 | |
| 9 #include "base/hash.h" | |
| 10 #include "base/logging.h" | |
| 11 #include "base/strings/string_number_conversions.h" | |
| 12 #include "base/strings/string_util.h" | |
| 13 #include "base/strings/stringprintf.h" | |
| 14 #include "base/strings/utf_string_conversions.h" | |
| 15 #include "content/public/renderer/render_frame.h" | |
| 16 #include "content/renderer/media/media_stream.h" | |
| 17 #include "content/renderer/media/media_stream_audio_source.h" | |
| 18 #include "content/renderer/media/media_stream_dispatcher.h" | |
| 19 #include "content/renderer/media/media_stream_video_capturer_source.h" | |
| 20 #include "content/renderer/media/media_stream_video_track.h" | |
| 21 #include "content/renderer/media/peer_connection_tracker.h" | |
| 22 #include "content/renderer/media/webrtc/webrtc_video_capturer_adapter.h" | |
| 23 #include "content/renderer/media/webrtc_audio_capturer.h" | |
| 24 #include "content/renderer/media/webrtc_logging.h" | |
| 25 #include "content/renderer/media/webrtc_uma_histograms.h" | |
| 26 #include "content/renderer/render_thread_impl.h" | |
| 27 #include "third_party/WebKit/public/platform/WebMediaConstraints.h" | |
| 28 #include "third_party/WebKit/public/platform/WebMediaDeviceInfo.h" | |
| 29 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h" | |
| 30 #include "third_party/WebKit/public/web/WebDocument.h" | |
| 31 #include "third_party/WebKit/public/web/WebLocalFrame.h" | |
| 32 | |
| 33 namespace content { | |
| 34 namespace { | |
| 35 | |
| 36 void CopyStreamConstraints(const blink::WebMediaConstraints& constraints, | |
| 37 StreamOptions::Constraints* mandatory, | |
| 38 StreamOptions::Constraints* optional) { | |
| 39 blink::WebVector<blink::WebMediaConstraint> mandatory_constraints; | |
| 40 constraints.getMandatoryConstraints(mandatory_constraints); | |
| 41 for (size_t i = 0; i < mandatory_constraints.size(); i++) { | |
| 42 mandatory->push_back(StreamOptions::Constraint( | |
| 43 mandatory_constraints[i].m_name.utf8(), | |
| 44 mandatory_constraints[i].m_value.utf8())); | |
| 45 } | |
| 46 | |
| 47 blink::WebVector<blink::WebMediaConstraint> optional_constraints; | |
| 48 constraints.getOptionalConstraints(optional_constraints); | |
| 49 for (size_t i = 0; i < optional_constraints.size(); i++) { | |
| 50 optional->push_back(StreamOptions::Constraint( | |
| 51 optional_constraints[i].m_name.utf8(), | |
| 52 optional_constraints[i].m_value.utf8())); | |
| 53 } | |
| 54 } | |
| 55 | |
| 56 static int g_next_request_id = 0; | |
| 57 | |
| 58 } // namespace | |
| 59 | |
| 60 struct MediaStreamImpl::MediaDevicesRequestInfo { | |
| 61 MediaDevicesRequestInfo(const blink::WebMediaDevicesRequest& request, | |
| 62 int audio_input_request_id, | |
| 63 int video_input_request_id, | |
| 64 int audio_output_request_id) | |
| 65 : request(request), | |
| 66 audio_input_request_id(audio_input_request_id), | |
| 67 video_input_request_id(video_input_request_id), | |
| 68 audio_output_request_id(audio_output_request_id), | |
| 69 has_audio_input_returned(false), | |
| 70 has_video_input_returned(false), | |
| 71 has_audio_output_returned(false) {} | |
| 72 | |
| 73 blink::WebMediaDevicesRequest request; | |
| 74 int audio_input_request_id; | |
| 75 int video_input_request_id; | |
| 76 int audio_output_request_id; | |
| 77 bool has_audio_input_returned; | |
| 78 bool has_video_input_returned; | |
| 79 bool has_audio_output_returned; | |
| 80 StreamDeviceInfoArray audio_input_devices; | |
| 81 StreamDeviceInfoArray video_input_devices; | |
| 82 StreamDeviceInfoArray audio_output_devices; | |
| 83 }; | |
| 84 | |
| 85 MediaStreamImpl::MediaStreamImpl( | |
| 86 RenderFrame* render_frame, | |
| 87 PeerConnectionDependencyFactory* dependency_factory, | |
| 88 scoped_ptr<MediaStreamDispatcher> media_stream_dispatcher) | |
| 89 : RenderFrameObserver(render_frame), | |
| 90 dependency_factory_(dependency_factory), | |
| 91 media_stream_dispatcher_(media_stream_dispatcher.Pass()), | |
| 92 weak_factory_(this) { | |
| 93 DCHECK(dependency_factory_); | |
| 94 DCHECK(media_stream_dispatcher_.get()); | |
| 95 } | |
| 96 | |
| 97 MediaStreamImpl::~MediaStreamImpl() { | |
| 98 // Force-close all outstanding user media requests and local sources here, | |
| 99 // before the outstanding WeakPtrs are invalidated, to ensure a clean | |
| 100 // shutdown. | |
| 101 FrameWillClose(); | |
| 102 } | |
| 103 | |
| 104 void MediaStreamImpl::requestUserMedia( | |
| 105 const blink::WebUserMediaRequest& user_media_request) { | |
| 106 // Save histogram data so we can see how much GetUserMedia is used. | |
| 107 // The histogram counts the number of calls to the JS API | |
| 108 // webGetUserMedia. | |
| 109 UpdateWebRTCMethodCount(WEBKIT_GET_USER_MEDIA); | |
| 110 DCHECK(CalledOnValidThread()); | |
| 111 | |
| 112 if (RenderThreadImpl::current()) { | |
| 113 RenderThreadImpl::current()->peer_connection_tracker()->TrackGetUserMedia( | |
| 114 user_media_request); | |
| 115 } | |
| 116 | |
| 117 int request_id = g_next_request_id++; | |
| 118 StreamOptions options; | |
| 119 GURL security_origin; | |
| 120 bool enable_automatic_output_device_selection = false; | |
| 121 | |
| 122 // |user_media_request| can't be mocked. So in order to test at all we check | |
| 123 // if it isNull. | |
| 124 if (user_media_request.isNull()) { | |
| 125 // We are in a test. | |
| 126 options.audio_requested = true; | |
| 127 options.video_requested = true; | |
| 128 } else { | |
| 129 if (user_media_request.audio()) { | |
| 130 options.audio_requested = true; | |
| 131 CopyStreamConstraints(user_media_request.audioConstraints(), | |
| 132 &options.mandatory_audio, | |
| 133 &options.optional_audio); | |
| 134 | |
| 135 // Check if this input device should be used to select a matching output | |
| 136 // device for audio rendering. | |
| 137 std::string enable; | |
| 138 if (options.GetFirstAudioConstraintByName( | |
| 139 kMediaStreamRenderToAssociatedSink, &enable, NULL) && | |
| 140 LowerCaseEqualsASCII(enable, "true")) { | |
| 141 enable_automatic_output_device_selection = true; | |
| 142 } | |
| 143 } | |
| 144 if (user_media_request.video()) { | |
| 145 options.video_requested = true; | |
| 146 CopyStreamConstraints(user_media_request.videoConstraints(), | |
| 147 &options.mandatory_video, | |
| 148 &options.optional_video); | |
| 149 } | |
| 150 | |
| 151 security_origin = GURL(user_media_request.securityOrigin().toString()); | |
| 152 DCHECK(render_frame()->GetWebFrame() == | |
| 153 static_cast<blink::WebFrame*>( | |
| 154 user_media_request.ownerDocument().frame())); | |
| 155 } | |
| 156 | |
| 157 DVLOG(1) << "MediaStreamImpl::requestUserMedia(" << request_id << ", [ " | |
| 158 << "audio=" << (options.audio_requested) | |
| 159 << " select associated sink: " | |
| 160 << enable_automatic_output_device_selection | |
| 161 << ", video=" << (options.video_requested) << " ], " | |
| 162 << security_origin.spec() << ")"; | |
| 163 | |
| 164 std::string audio_device_id; | |
| 165 bool mandatory_audio; | |
| 166 options.GetFirstAudioConstraintByName(kMediaStreamSourceInfoId, | |
| 167 &audio_device_id, &mandatory_audio); | |
| 168 std::string video_device_id; | |
| 169 bool mandatory_video; | |
| 170 options.GetFirstVideoConstraintByName(kMediaStreamSourceInfoId, | |
| 171 &video_device_id, &mandatory_video); | |
| 172 | |
| 173 WebRtcLogMessage(base::StringPrintf( | |
| 174 "MSI::requestUserMedia. request_id=%d" | |
| 175 ", audio source id=%s mandatory= %s " | |
| 176 ", video source id=%s mandatory= %s", | |
| 177 request_id, | |
| 178 audio_device_id.c_str(), | |
| 179 mandatory_audio ? "true":"false", | |
| 180 video_device_id.c_str(), | |
| 181 mandatory_video ? "true":"false")); | |
| 182 | |
| 183 user_media_requests_.push_back( | |
| 184 new UserMediaRequestInfo(request_id, user_media_request, | |
| 185 enable_automatic_output_device_selection)); | |
| 186 | |
| 187 media_stream_dispatcher_->GenerateStream( | |
| 188 request_id, | |
| 189 weak_factory_.GetWeakPtr(), | |
| 190 options, | |
| 191 security_origin); | |
| 192 } | |
| 193 | |
| 194 void MediaStreamImpl::cancelUserMediaRequest( | |
| 195 const blink::WebUserMediaRequest& user_media_request) { | |
| 196 DCHECK(CalledOnValidThread()); | |
| 197 UserMediaRequestInfo* request = FindUserMediaRequestInfo(user_media_request); | |
| 198 if (request) { | |
| 199 // We can't abort the stream generation process. | |
| 200 // Instead, erase the request. Once the stream is generated we will stop the | |
| 201 // stream if the request does not exist. | |
| 202 LogUserMediaRequestWithNoResult(MEDIA_STREAM_REQUEST_EXPLICITLY_CANCELLED); | |
| 203 DeleteUserMediaRequestInfo(request); | |
| 204 } | |
| 205 } | |
| 206 | |
| 207 void MediaStreamImpl::requestMediaDevices( | |
| 208 const blink::WebMediaDevicesRequest& media_devices_request) { | |
| 209 UpdateWebRTCMethodCount(WEBKIT_GET_MEDIA_DEVICES); | |
| 210 DCHECK(CalledOnValidThread()); | |
| 211 | |
| 212 int audio_input_request_id = g_next_request_id++; | |
| 213 int video_input_request_id = g_next_request_id++; | |
| 214 int audio_output_request_id = g_next_request_id++; | |
| 215 | |
| 216 // |media_devices_request| can't be mocked, so in tests it will be empty (the | |
| 217 // underlying pointer is null). In order to use this function in a test we | |
| 218 // need to check if it isNull. | |
| 219 GURL security_origin; | |
| 220 if (!media_devices_request.isNull()) | |
| 221 security_origin = GURL(media_devices_request.securityOrigin().toString()); | |
| 222 | |
| 223 DVLOG(1) << "MediaStreamImpl::requestMediaDevices(" << audio_input_request_id | |
| 224 << ", " << video_input_request_id << ", " << audio_output_request_id | |
| 225 << ", " << security_origin.spec() << ")"; | |
| 226 | |
| 227 media_devices_requests_.push_back(new MediaDevicesRequestInfo( | |
| 228 media_devices_request, | |
| 229 audio_input_request_id, | |
| 230 video_input_request_id, | |
| 231 audio_output_request_id)); | |
| 232 | |
| 233 media_stream_dispatcher_->EnumerateDevices( | |
| 234 audio_input_request_id, | |
| 235 weak_factory_.GetWeakPtr(), | |
| 236 MEDIA_DEVICE_AUDIO_CAPTURE, | |
| 237 security_origin); | |
| 238 | |
| 239 media_stream_dispatcher_->EnumerateDevices( | |
| 240 video_input_request_id, | |
| 241 weak_factory_.GetWeakPtr(), | |
| 242 MEDIA_DEVICE_VIDEO_CAPTURE, | |
| 243 security_origin); | |
| 244 | |
| 245 media_stream_dispatcher_->EnumerateDevices( | |
| 246 audio_output_request_id, | |
| 247 weak_factory_.GetWeakPtr(), | |
| 248 MEDIA_DEVICE_AUDIO_OUTPUT, | |
| 249 security_origin); | |
| 250 } | |
| 251 | |
| 252 void MediaStreamImpl::cancelMediaDevicesRequest( | |
| 253 const blink::WebMediaDevicesRequest& media_devices_request) { | |
| 254 DCHECK(CalledOnValidThread()); | |
| 255 MediaDevicesRequestInfo* request = | |
| 256 FindMediaDevicesRequestInfo(media_devices_request); | |
| 257 if (!request) | |
| 258 return; | |
| 259 CancelAndDeleteMediaDevicesRequest(request); | |
| 260 } | |
| 261 | |
| 262 // Callback from MediaStreamDispatcher. | |
| 263 // The requested stream have been generated by the MediaStreamDispatcher. | |
| 264 void MediaStreamImpl::OnStreamGenerated( | |
| 265 int request_id, | |
| 266 const std::string& label, | |
| 267 const StreamDeviceInfoArray& audio_array, | |
| 268 const StreamDeviceInfoArray& video_array) { | |
| 269 DCHECK(CalledOnValidThread()); | |
| 270 DVLOG(1) << "MediaStreamImpl::OnStreamGenerated stream:" << label; | |
| 271 | |
| 272 UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(request_id); | |
| 273 if (!request_info) { | |
| 274 // This can happen if the request is canceled or the frame reloads while | |
| 275 // MediaStreamDispatcher is processing the request. | |
| 276 DVLOG(1) << "Request ID not found"; | |
| 277 OnStreamGeneratedForCancelledRequest(audio_array, video_array); | |
| 278 return; | |
| 279 } | |
| 280 request_info->generated = true; | |
| 281 | |
| 282 // WebUserMediaRequest don't have an implementation in unit tests. | |
| 283 // Therefore we need to check for isNull here and initialize the | |
| 284 // constraints. | |
| 285 blink::WebUserMediaRequest* request = &(request_info->request); | |
| 286 blink::WebMediaConstraints audio_constraints; | |
| 287 blink::WebMediaConstraints video_constraints; | |
| 288 if (request->isNull()) { | |
| 289 audio_constraints.initialize(); | |
| 290 video_constraints.initialize(); | |
| 291 } else { | |
| 292 audio_constraints = request->audioConstraints(); | |
| 293 video_constraints = request->videoConstraints(); | |
| 294 } | |
| 295 | |
| 296 blink::WebVector<blink::WebMediaStreamTrack> audio_track_vector( | |
| 297 audio_array.size()); | |
| 298 CreateAudioTracks(audio_array, audio_constraints, &audio_track_vector, | |
| 299 request_info); | |
| 300 | |
| 301 blink::WebVector<blink::WebMediaStreamTrack> video_track_vector( | |
| 302 video_array.size()); | |
| 303 CreateVideoTracks(video_array, video_constraints, &video_track_vector, | |
| 304 request_info); | |
| 305 | |
| 306 blink::WebString webkit_id = base::UTF8ToUTF16(label); | |
| 307 blink::WebMediaStream* web_stream = &(request_info->web_stream); | |
| 308 | |
| 309 web_stream->initialize(webkit_id, audio_track_vector, | |
| 310 video_track_vector); | |
| 311 web_stream->setExtraData( | |
| 312 new MediaStream( | |
| 313 *web_stream)); | |
| 314 | |
| 315 // Wait for the tracks to be started successfully or to fail. | |
| 316 request_info->CallbackOnTracksStarted( | |
| 317 base::Bind(&MediaStreamImpl::OnCreateNativeTracksCompleted, | |
| 318 weak_factory_.GetWeakPtr())); | |
| 319 } | |
| 320 | |
| 321 void MediaStreamImpl::OnStreamGeneratedForCancelledRequest( | |
| 322 const StreamDeviceInfoArray& audio_array, | |
| 323 const StreamDeviceInfoArray& video_array) { | |
| 324 // Only stop the device if the device is not used in another MediaStream. | |
| 325 for (StreamDeviceInfoArray::const_iterator device_it = audio_array.begin(); | |
| 326 device_it != audio_array.end(); ++device_it) { | |
| 327 if (!FindLocalSource(*device_it)) | |
| 328 media_stream_dispatcher_->StopStreamDevice(*device_it); | |
| 329 } | |
| 330 | |
| 331 for (StreamDeviceInfoArray::const_iterator device_it = video_array.begin(); | |
| 332 device_it != video_array.end(); ++device_it) { | |
| 333 if (!FindLocalSource(*device_it)) | |
| 334 media_stream_dispatcher_->StopStreamDevice(*device_it); | |
| 335 } | |
| 336 } | |
| 337 | |
| 338 // Callback from MediaStreamDispatcher. | |
| 339 // The requested stream failed to be generated. | |
| 340 void MediaStreamImpl::OnStreamGenerationFailed( | |
| 341 int request_id, | |
| 342 MediaStreamRequestResult result) { | |
| 343 DCHECK(CalledOnValidThread()); | |
| 344 DVLOG(1) << "MediaStreamImpl::OnStreamGenerationFailed(" | |
| 345 << request_id << ")"; | |
| 346 UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(request_id); | |
| 347 if (!request_info) { | |
| 348 // This can happen if the request is canceled or the frame reloads while | |
| 349 // MediaStreamDispatcher is processing the request. | |
| 350 DVLOG(1) << "Request ID not found"; | |
| 351 return; | |
| 352 } | |
| 353 | |
| 354 GetUserMediaRequestFailed(&request_info->request, result); | |
| 355 DeleteUserMediaRequestInfo(request_info); | |
| 356 } | |
| 357 | |
| 358 // Callback from MediaStreamDispatcher. | |
| 359 // The browser process has stopped a device used by a MediaStream. | |
| 360 void MediaStreamImpl::OnDeviceStopped( | |
| 361 const std::string& label, | |
| 362 const StreamDeviceInfo& device_info) { | |
| 363 DCHECK(CalledOnValidThread()); | |
| 364 DVLOG(1) << "MediaStreamImpl::OnDeviceStopped(" | |
| 365 << "{device_id = " << device_info.device.id << "})"; | |
| 366 | |
| 367 const blink::WebMediaStreamSource* source_ptr = FindLocalSource(device_info); | |
| 368 if (!source_ptr) { | |
| 369 // This happens if the same device is used in several guM requests or | |
| 370 // if a user happen stop a track from JS at the same time | |
| 371 // as the underlying media device is unplugged from the system. | |
| 372 return; | |
| 373 } | |
| 374 // By creating |source| it is guaranteed that the blink::WebMediaStreamSource | |
| 375 // object is valid during the cleanup. | |
| 376 blink::WebMediaStreamSource source(*source_ptr); | |
| 377 StopLocalSource(source, false); | |
| 378 | |
| 379 for (LocalStreamSources::iterator device_it = local_sources_.begin(); | |
| 380 device_it != local_sources_.end(); ++device_it) { | |
| 381 if (device_it->id() == source.id()) { | |
| 382 local_sources_.erase(device_it); | |
| 383 break; | |
| 384 } | |
| 385 } | |
| 386 } | |
| 387 | |
| 388 void MediaStreamImpl::InitializeSourceObject( | |
| 389 const StreamDeviceInfo& device, | |
| 390 blink::WebMediaStreamSource::Type type, | |
| 391 const blink::WebMediaConstraints& constraints, | |
| 392 blink::WebMediaStreamSource* webkit_source) { | |
| 393 const blink::WebMediaStreamSource* existing_source = | |
| 394 FindLocalSource(device); | |
| 395 if (existing_source) { | |
| 396 *webkit_source = *existing_source; | |
| 397 DVLOG(1) << "Source already exist. Reusing source with id " | |
| 398 << webkit_source->id().utf8(); | |
| 399 return; | |
| 400 } | |
| 401 | |
| 402 webkit_source->initialize( | |
| 403 base::UTF8ToUTF16(device.device.id), | |
| 404 type, | |
| 405 base::UTF8ToUTF16(device.device.name)); | |
| 406 | |
| 407 DVLOG(1) << "Initialize source object :" | |
| 408 << "id = " << webkit_source->id().utf8() | |
| 409 << ", name = " << webkit_source->name().utf8(); | |
| 410 | |
| 411 if (type == blink::WebMediaStreamSource::TypeVideo) { | |
| 412 webkit_source->setExtraData( | |
| 413 CreateVideoSource( | |
| 414 device, | |
| 415 base::Bind(&MediaStreamImpl::OnLocalSourceStopped, | |
| 416 weak_factory_.GetWeakPtr()))); | |
| 417 } else { | |
| 418 DCHECK_EQ(blink::WebMediaStreamSource::TypeAudio, type); | |
| 419 MediaStreamAudioSource* audio_source( | |
| 420 new MediaStreamAudioSource( | |
| 421 RenderFrameObserver::routing_id(), | |
| 422 device, | |
| 423 base::Bind(&MediaStreamImpl::OnLocalSourceStopped, | |
| 424 weak_factory_.GetWeakPtr()), | |
| 425 dependency_factory_)); | |
| 426 webkit_source->setExtraData(audio_source); | |
| 427 } | |
| 428 local_sources_.push_back(*webkit_source); | |
| 429 } | |
| 430 | |
| 431 MediaStreamVideoSource* MediaStreamImpl::CreateVideoSource( | |
| 432 const StreamDeviceInfo& device, | |
| 433 const MediaStreamSource::SourceStoppedCallback& stop_callback) { | |
| 434 return new content::MediaStreamVideoCapturerSource( | |
| 435 device, | |
| 436 stop_callback, | |
| 437 new VideoCapturerDelegate(device)); | |
| 438 } | |
| 439 | |
| 440 void MediaStreamImpl::CreateVideoTracks( | |
| 441 const StreamDeviceInfoArray& devices, | |
| 442 const blink::WebMediaConstraints& constraints, | |
| 443 blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks, | |
| 444 UserMediaRequestInfo* request) { | |
| 445 DCHECK_EQ(devices.size(), webkit_tracks->size()); | |
| 446 | |
| 447 for (size_t i = 0; i < devices.size(); ++i) { | |
| 448 blink::WebMediaStreamSource webkit_source; | |
| 449 InitializeSourceObject(devices[i], | |
| 450 blink::WebMediaStreamSource::TypeVideo, | |
| 451 constraints, | |
| 452 &webkit_source); | |
| 453 (*webkit_tracks)[i] = | |
| 454 request->CreateAndStartVideoTrack(webkit_source, constraints); | |
| 455 } | |
| 456 } | |
| 457 | |
| 458 void MediaStreamImpl::CreateAudioTracks( | |
| 459 const StreamDeviceInfoArray& devices, | |
| 460 const blink::WebMediaConstraints& constraints, | |
| 461 blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks, | |
| 462 UserMediaRequestInfo* request) { | |
| 463 DCHECK_EQ(devices.size(), webkit_tracks->size()); | |
| 464 | |
| 465 // Log the device names for this request. | |
| 466 for (StreamDeviceInfoArray::const_iterator it = devices.begin(); | |
| 467 it != devices.end(); ++it) { | |
| 468 WebRtcLogMessage(base::StringPrintf( | |
| 469 "Generated media stream for request id %d contains audio device name" | |
| 470 " \"%s\"", | |
| 471 request->request_id, | |
| 472 it->device.name.c_str())); | |
| 473 } | |
| 474 | |
| 475 StreamDeviceInfoArray overridden_audio_array = devices; | |
| 476 if (!request->enable_automatic_output_device_selection) { | |
| 477 // If the GetUserMedia request did not explicitly set the constraint | |
| 478 // kMediaStreamRenderToAssociatedSink, the output device parameters must | |
| 479 // be removed. | |
| 480 for (StreamDeviceInfoArray::iterator it = overridden_audio_array.begin(); | |
| 481 it != overridden_audio_array.end(); ++it) { | |
| 482 it->device.matched_output_device_id = ""; | |
| 483 it->device.matched_output = MediaStreamDevice::AudioDeviceParameters(); | |
| 484 } | |
| 485 } | |
| 486 | |
| 487 for (size_t i = 0; i < overridden_audio_array.size(); ++i) { | |
| 488 blink::WebMediaStreamSource webkit_source; | |
| 489 InitializeSourceObject(overridden_audio_array[i], | |
| 490 blink::WebMediaStreamSource::TypeAudio, | |
| 491 constraints, | |
| 492 &webkit_source); | |
| 493 (*webkit_tracks)[i].initialize(webkit_source); | |
| 494 request->StartAudioTrack((*webkit_tracks)[i], constraints); | |
| 495 } | |
| 496 } | |
| 497 | |
| 498 void MediaStreamImpl::OnCreateNativeTracksCompleted( | |
| 499 UserMediaRequestInfo* request, | |
| 500 MediaStreamRequestResult result, | |
| 501 const blink::WebString& result_name) { | |
| 502 DVLOG(1) << "MediaStreamImpl::OnCreateNativeTracksComplete(" | |
| 503 << "{request_id = " << request->request_id << "} " | |
| 504 << "{result = " << result << "})"; | |
| 505 if (result == content::MEDIA_DEVICE_OK) | |
| 506 GetUserMediaRequestSucceeded(request->web_stream, &request->request); | |
| 507 else | |
| 508 GetUserMediaRequestTrackStartedFailed(&request->request, | |
| 509 result, | |
| 510 result_name); | |
| 511 | |
| 512 DeleteUserMediaRequestInfo(request); | |
| 513 } | |
| 514 | |
| 515 void MediaStreamImpl::OnDevicesEnumerated( | |
| 516 int request_id, | |
| 517 const StreamDeviceInfoArray& device_array) { | |
| 518 DVLOG(1) << "MediaStreamImpl::OnDevicesEnumerated(" << request_id << ")"; | |
| 519 | |
| 520 MediaDevicesRequestInfo* request = FindMediaDevicesRequestInfo(request_id); | |
| 521 DCHECK(request); | |
| 522 | |
| 523 if (request_id == request->audio_input_request_id) { | |
| 524 request->has_audio_input_returned = true; | |
| 525 DCHECK(request->audio_input_devices.empty()); | |
| 526 request->audio_input_devices = device_array; | |
| 527 } else if (request_id == request->video_input_request_id) { | |
| 528 request->has_video_input_returned = true; | |
| 529 DCHECK(request->video_input_devices.empty()); | |
| 530 request->video_input_devices = device_array; | |
| 531 } else { | |
| 532 DCHECK_EQ(request->audio_output_request_id, request_id); | |
| 533 request->has_audio_output_returned = true; | |
| 534 DCHECK(request->audio_output_devices.empty()); | |
| 535 request->audio_output_devices = device_array; | |
| 536 } | |
| 537 | |
| 538 if (!request->has_audio_input_returned || | |
| 539 !request->has_video_input_returned || | |
| 540 !request->has_audio_output_returned) { | |
| 541 // Wait for the rest of the devices to complete. | |
| 542 return; | |
| 543 } | |
| 544 | |
| 545 // All devices are ready for copying. We use a hashed audio output device id | |
| 546 // as the group id for input and output audio devices. If an input device | |
| 547 // doesn't have an associated output device, we use the input device's own id. | |
| 548 // We don't support group id for video devices, that's left empty. | |
| 549 blink::WebVector<blink::WebMediaDeviceInfo> | |
| 550 devices(request->audio_input_devices.size() + | |
| 551 request->video_input_devices.size() + | |
| 552 request->audio_output_devices.size()); | |
| 553 for (size_t i = 0; i < request->audio_input_devices.size(); ++i) { | |
| 554 const MediaStreamDevice& device = request->audio_input_devices[i].device; | |
| 555 DCHECK_EQ(device.type, MEDIA_DEVICE_AUDIO_CAPTURE); | |
| 556 std::string group_id = base::UintToString(base::Hash( | |
| 557 !device.matched_output_device_id.empty() ? | |
| 558 device.matched_output_device_id : | |
| 559 device.id)); | |
| 560 devices[i].initialize( | |
| 561 blink::WebString::fromUTF8(device.id), | |
| 562 blink::WebMediaDeviceInfo::MediaDeviceKindAudioInput, | |
| 563 blink::WebString::fromUTF8(device.name), | |
| 564 blink::WebString::fromUTF8(group_id)); | |
| 565 } | |
| 566 size_t offset = request->audio_input_devices.size(); | |
| 567 for (size_t i = 0; i < request->video_input_devices.size(); ++i) { | |
| 568 const MediaStreamDevice& device = request->video_input_devices[i].device; | |
| 569 DCHECK_EQ(device.type, MEDIA_DEVICE_VIDEO_CAPTURE); | |
| 570 devices[offset + i].initialize( | |
| 571 blink::WebString::fromUTF8(device.id), | |
| 572 blink::WebMediaDeviceInfo::MediaDeviceKindVideoInput, | |
| 573 blink::WebString::fromUTF8(device.name), | |
| 574 blink::WebString()); | |
| 575 } | |
| 576 offset += request->video_input_devices.size(); | |
| 577 for (size_t i = 0; i < request->audio_output_devices.size(); ++i) { | |
| 578 const MediaStreamDevice& device = request->audio_output_devices[i].device; | |
| 579 DCHECK_EQ(device.type, MEDIA_DEVICE_AUDIO_OUTPUT); | |
| 580 devices[offset + i].initialize( | |
| 581 blink::WebString::fromUTF8(device.id), | |
| 582 blink::WebMediaDeviceInfo::MediaDeviceKindAudioOutput, | |
| 583 blink::WebString::fromUTF8(device.name), | |
| 584 blink::WebString::fromUTF8(base::UintToString(base::Hash(device.id)))); | |
| 585 } | |
| 586 | |
| 587 EnumerateDevicesSucceded(&request->request, devices); | |
| 588 CancelAndDeleteMediaDevicesRequest(request); | |
| 589 } | |
| 590 | |
| 591 void MediaStreamImpl::OnDeviceOpened( | |
| 592 int request_id, | |
| 593 const std::string& label, | |
| 594 const StreamDeviceInfo& video_device) { | |
| 595 DVLOG(1) << "MediaStreamImpl::OnDeviceOpened(" | |
| 596 << request_id << ", " << label << ")"; | |
| 597 NOTIMPLEMENTED(); | |
| 598 } | |
| 599 | |
| 600 void MediaStreamImpl::OnDeviceOpenFailed(int request_id) { | |
| 601 DVLOG(1) << "MediaStreamImpl::VideoDeviceOpenFailed(" | |
| 602 << request_id << ")"; | |
| 603 NOTIMPLEMENTED(); | |
| 604 } | |
| 605 | |
| 606 void MediaStreamImpl::GetUserMediaRequestSucceeded( | |
| 607 const blink::WebMediaStream& stream, | |
| 608 blink::WebUserMediaRequest* request_info) { | |
| 609 DVLOG(1) << "MediaStreamImpl::GetUserMediaRequestSucceeded"; | |
| 610 LogUserMediaRequestResult(MEDIA_DEVICE_OK); | |
| 611 request_info->requestSucceeded(stream); | |
| 612 } | |
| 613 | |
| 614 void MediaStreamImpl::GetUserMediaRequestFailed( | |
| 615 blink::WebUserMediaRequest* request_info, | |
| 616 MediaStreamRequestResult result) { | |
| 617 LogUserMediaRequestResult(result); | |
| 618 switch (result) { | |
| 619 case MEDIA_DEVICE_OK: | |
| 620 NOTREACHED(); | |
| 621 break; | |
| 622 case MEDIA_DEVICE_PERMISSION_DENIED: | |
| 623 request_info->requestDenied(); | |
| 624 break; | |
| 625 case MEDIA_DEVICE_PERMISSION_DISMISSED: | |
| 626 request_info->requestFailedUASpecific("PermissionDismissedError"); | |
| 627 break; | |
| 628 case MEDIA_DEVICE_INVALID_STATE: | |
| 629 request_info->requestFailedUASpecific("InvalidStateError"); | |
| 630 break; | |
| 631 case MEDIA_DEVICE_NO_HARDWARE: | |
| 632 request_info->requestFailedUASpecific("DevicesNotFoundError"); | |
| 633 break; | |
| 634 case MEDIA_DEVICE_INVALID_SECURITY_ORIGIN: | |
| 635 request_info->requestFailedUASpecific("InvalidSecurityOriginError"); | |
| 636 break; | |
| 637 case MEDIA_DEVICE_TAB_CAPTURE_FAILURE: | |
| 638 request_info->requestFailedUASpecific("TabCaptureError"); | |
| 639 break; | |
| 640 case MEDIA_DEVICE_SCREEN_CAPTURE_FAILURE: | |
| 641 request_info->requestFailedUASpecific("ScreenCaptureError"); | |
| 642 break; | |
| 643 case MEDIA_DEVICE_CAPTURE_FAILURE: | |
| 644 request_info->requestFailedUASpecific("DeviceCaptureError"); | |
| 645 break; | |
| 646 default: | |
| 647 NOTREACHED(); | |
| 648 request_info->requestFailed(); | |
| 649 break; | |
| 650 } | |
| 651 } | |
| 652 | |
| 653 void MediaStreamImpl::GetUserMediaRequestTrackStartedFailed( | |
| 654 blink::WebUserMediaRequest* request_info, | |
| 655 MediaStreamRequestResult result, | |
| 656 const blink::WebString& result_name) { | |
| 657 switch (result) { | |
| 658 case MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED: | |
| 659 request_info->requestFailedConstraint(result_name); | |
| 660 break; | |
| 661 case MEDIA_DEVICE_TRACK_START_FAILURE: | |
| 662 request_info->requestFailedUASpecific("TrackStartError"); | |
| 663 break; | |
| 664 default: | |
| 665 NOTREACHED(); | |
| 666 request_info->requestFailed(); | |
| 667 break; | |
| 668 } | |
| 669 } | |
| 670 | |
| 671 void MediaStreamImpl::EnumerateDevicesSucceded( | |
| 672 blink::WebMediaDevicesRequest* request, | |
| 673 blink::WebVector<blink::WebMediaDeviceInfo>& devices) { | |
| 674 request->requestSucceeded(devices); | |
| 675 } | |
| 676 | |
| 677 const blink::WebMediaStreamSource* MediaStreamImpl::FindLocalSource( | |
| 678 const StreamDeviceInfo& device) const { | |
| 679 for (LocalStreamSources::const_iterator it = local_sources_.begin(); | |
| 680 it != local_sources_.end(); ++it) { | |
| 681 MediaStreamSource* const source = | |
| 682 static_cast<MediaStreamSource*>(it->extraData()); | |
| 683 const StreamDeviceInfo& active_device = source->device_info(); | |
| 684 if (active_device.device.id == device.device.id && | |
| 685 active_device.device.type == device.device.type && | |
| 686 active_device.session_id == device.session_id) { | |
| 687 return &(*it); | |
| 688 } | |
| 689 } | |
| 690 return NULL; | |
| 691 } | |
| 692 | |
| 693 MediaStreamImpl::UserMediaRequestInfo* | |
| 694 MediaStreamImpl::FindUserMediaRequestInfo(int request_id) { | |
| 695 UserMediaRequests::iterator it = user_media_requests_.begin(); | |
| 696 for (; it != user_media_requests_.end(); ++it) { | |
| 697 if ((*it)->request_id == request_id) | |
| 698 return (*it); | |
| 699 } | |
| 700 return NULL; | |
| 701 } | |
| 702 | |
| 703 MediaStreamImpl::UserMediaRequestInfo* | |
| 704 MediaStreamImpl::FindUserMediaRequestInfo( | |
| 705 const blink::WebUserMediaRequest& request) { | |
| 706 UserMediaRequests::iterator it = user_media_requests_.begin(); | |
| 707 for (; it != user_media_requests_.end(); ++it) { | |
| 708 if ((*it)->request == request) | |
| 709 return (*it); | |
| 710 } | |
| 711 return NULL; | |
| 712 } | |
| 713 | |
| 714 void MediaStreamImpl::DeleteUserMediaRequestInfo( | |
| 715 UserMediaRequestInfo* request) { | |
| 716 UserMediaRequests::iterator it = user_media_requests_.begin(); | |
| 717 for (; it != user_media_requests_.end(); ++it) { | |
| 718 if ((*it) == request) { | |
| 719 user_media_requests_.erase(it); | |
| 720 return; | |
| 721 } | |
| 722 } | |
| 723 NOTREACHED(); | |
| 724 } | |
| 725 | |
| 726 void MediaStreamImpl::DeleteAllUserMediaRequests() { | |
| 727 UserMediaRequests::iterator request_it = user_media_requests_.begin(); | |
| 728 while (request_it != user_media_requests_.end()) { | |
| 729 DVLOG(1) << "MediaStreamImpl@" << this << "::DeleteAllUserMediaRequests: " | |
| 730 << "Cancel user media request " << (*request_it)->request_id; | |
| 731 // If the request is not generated, it means that a request | |
| 732 // has been sent to the MediaStreamDispatcher to generate a stream | |
| 733 // but MediaStreamDispatcher has not yet responded and we need to cancel | |
| 734 // the request. | |
| 735 if (!(*request_it)->generated) { | |
| 736 DCHECK(!(*request_it)->HasPendingSources()); | |
| 737 media_stream_dispatcher_->CancelGenerateStream( | |
| 738 (*request_it)->request_id, weak_factory_.GetWeakPtr()); | |
| 739 LogUserMediaRequestWithNoResult(MEDIA_STREAM_REQUEST_NOT_GENERATED); | |
| 740 } else { | |
| 741 DCHECK((*request_it)->HasPendingSources()); | |
| 742 LogUserMediaRequestWithNoResult( | |
| 743 MEDIA_STREAM_REQUEST_PENDING_MEDIA_TRACKS); | |
| 744 } | |
| 745 request_it = user_media_requests_.erase(request_it); | |
| 746 } | |
| 747 } | |
| 748 | |
| 749 MediaStreamImpl::MediaDevicesRequestInfo* | |
| 750 MediaStreamImpl::FindMediaDevicesRequestInfo( | |
| 751 int request_id) { | |
| 752 MediaDevicesRequests::iterator it = media_devices_requests_.begin(); | |
| 753 for (; it != media_devices_requests_.end(); ++it) { | |
| 754 if ((*it)->audio_input_request_id == request_id || | |
| 755 (*it)->video_input_request_id == request_id || | |
| 756 (*it)->audio_output_request_id == request_id) { | |
| 757 return (*it); | |
| 758 } | |
| 759 } | |
| 760 return NULL; | |
| 761 } | |
| 762 | |
| 763 MediaStreamImpl::MediaDevicesRequestInfo* | |
| 764 MediaStreamImpl::FindMediaDevicesRequestInfo( | |
| 765 const blink::WebMediaDevicesRequest& request) { | |
| 766 MediaDevicesRequests::iterator it = media_devices_requests_.begin(); | |
| 767 for (; it != media_devices_requests_.end(); ++it) { | |
| 768 if ((*it)->request == request) | |
| 769 return (*it); | |
| 770 } | |
| 771 return NULL; | |
| 772 } | |
| 773 | |
| 774 void MediaStreamImpl::CancelAndDeleteMediaDevicesRequest( | |
| 775 MediaDevicesRequestInfo* request) { | |
| 776 MediaDevicesRequests::iterator it = media_devices_requests_.begin(); | |
| 777 for (; it != media_devices_requests_.end(); ++it) { | |
| 778 if ((*it) == request) { | |
| 779 // Cancel device enumeration. | |
| 780 media_stream_dispatcher_->StopEnumerateDevices( | |
| 781 request->audio_input_request_id, weak_factory_.GetWeakPtr()); | |
| 782 media_stream_dispatcher_->StopEnumerateDevices( | |
| 783 request->video_input_request_id, weak_factory_.GetWeakPtr()); | |
| 784 media_stream_dispatcher_->StopEnumerateDevices( | |
| 785 request->audio_output_request_id, weak_factory_.GetWeakPtr()); | |
| 786 | |
| 787 media_devices_requests_.erase(it); | |
| 788 return; | |
| 789 } | |
| 790 } | |
| 791 NOTREACHED(); | |
| 792 } | |
| 793 | |
| 794 void MediaStreamImpl::FrameWillClose() { | |
| 795 // Cancel all outstanding UserMediaRequests. | |
| 796 DeleteAllUserMediaRequests(); | |
| 797 | |
| 798 // Loop through all current local sources and stop the sources. | |
| 799 LocalStreamSources::iterator sources_it = local_sources_.begin(); | |
| 800 while (sources_it != local_sources_.end()) { | |
| 801 StopLocalSource(*sources_it, true); | |
| 802 sources_it = local_sources_.erase(sources_it); | |
| 803 } | |
| 804 } | |
| 805 | |
| 806 void MediaStreamImpl::OnLocalSourceStopped( | |
| 807 const blink::WebMediaStreamSource& source) { | |
| 808 DCHECK(CalledOnValidThread()); | |
| 809 DVLOG(1) << "MediaStreamImpl::OnLocalSourceStopped"; | |
| 810 | |
| 811 bool device_found = false; | |
| 812 for (LocalStreamSources::iterator device_it = local_sources_.begin(); | |
| 813 device_it != local_sources_.end(); ++device_it) { | |
| 814 if (device_it->id() == source.id()) { | |
| 815 device_found = true; | |
| 816 local_sources_.erase(device_it); | |
| 817 break; | |
| 818 } | |
| 819 } | |
| 820 CHECK(device_found); | |
| 821 | |
| 822 MediaStreamSource* source_impl = | |
| 823 static_cast<MediaStreamSource*>(source.extraData()); | |
| 824 media_stream_dispatcher_->StopStreamDevice(source_impl->device_info()); | |
| 825 } | |
| 826 | |
| 827 void MediaStreamImpl::StopLocalSource( | |
| 828 const blink::WebMediaStreamSource& source, | |
| 829 bool notify_dispatcher) { | |
| 830 MediaStreamSource* source_impl = | |
| 831 static_cast<MediaStreamSource*>(source.extraData()); | |
| 832 DVLOG(1) << "MediaStreamImpl::StopLocalSource(" | |
| 833 << "{device_id = " << source_impl->device_info().device.id << "})"; | |
| 834 | |
| 835 if (notify_dispatcher) | |
| 836 media_stream_dispatcher_->StopStreamDevice(source_impl->device_info()); | |
| 837 | |
| 838 source_impl->ResetSourceStoppedCallback(); | |
| 839 source_impl->StopSource(); | |
| 840 } | |
| 841 | |
| 842 MediaStreamImpl::UserMediaRequestInfo::UserMediaRequestInfo( | |
| 843 int request_id, | |
| 844 const blink::WebUserMediaRequest& request, | |
| 845 bool enable_automatic_output_device_selection) | |
| 846 : request_id(request_id), | |
| 847 generated(false), | |
| 848 enable_automatic_output_device_selection( | |
| 849 enable_automatic_output_device_selection), | |
| 850 request(request), | |
| 851 request_result_(MEDIA_DEVICE_OK), | |
| 852 request_result_name_("") { | |
| 853 } | |
| 854 | |
| 855 MediaStreamImpl::UserMediaRequestInfo::~UserMediaRequestInfo() { | |
| 856 DVLOG(1) << "~UserMediaRequestInfo"; | |
| 857 } | |
| 858 | |
| 859 void MediaStreamImpl::UserMediaRequestInfo::StartAudioTrack( | |
| 860 const blink::WebMediaStreamTrack& track, | |
| 861 const blink::WebMediaConstraints& constraints) { | |
| 862 DCHECK(track.source().type() == blink::WebMediaStreamSource::TypeAudio); | |
| 863 MediaStreamAudioSource* native_source = | |
| 864 static_cast <MediaStreamAudioSource*>(track.source().extraData()); | |
| 865 DCHECK(native_source); | |
| 866 | |
| 867 sources_.push_back(track.source()); | |
| 868 sources_waiting_for_callback_.push_back(native_source); | |
| 869 native_source->AddTrack( | |
| 870 track, constraints, base::Bind( | |
| 871 &MediaStreamImpl::UserMediaRequestInfo::OnTrackStarted, | |
| 872 AsWeakPtr())); | |
| 873 } | |
| 874 | |
| 875 blink::WebMediaStreamTrack | |
| 876 MediaStreamImpl::UserMediaRequestInfo::CreateAndStartVideoTrack( | |
| 877 const blink::WebMediaStreamSource& source, | |
| 878 const blink::WebMediaConstraints& constraints) { | |
| 879 DCHECK(source.type() == blink::WebMediaStreamSource::TypeVideo); | |
| 880 MediaStreamVideoSource* native_source = | |
| 881 MediaStreamVideoSource::GetVideoSource(source); | |
| 882 DCHECK(native_source); | |
| 883 sources_.push_back(source); | |
| 884 sources_waiting_for_callback_.push_back(native_source); | |
| 885 return MediaStreamVideoTrack::CreateVideoTrack( | |
| 886 native_source, constraints, base::Bind( | |
| 887 &MediaStreamImpl::UserMediaRequestInfo::OnTrackStarted, | |
| 888 AsWeakPtr()), | |
| 889 true); | |
| 890 } | |
| 891 | |
| 892 void MediaStreamImpl::UserMediaRequestInfo::CallbackOnTracksStarted( | |
| 893 const ResourcesReady& callback) { | |
| 894 DCHECK(ready_callback_.is_null()); | |
| 895 ready_callback_ = callback; | |
| 896 CheckAllTracksStarted(); | |
| 897 } | |
| 898 | |
| 899 void MediaStreamImpl::UserMediaRequestInfo::OnTrackStarted( | |
| 900 MediaStreamSource* source, | |
| 901 MediaStreamRequestResult result, | |
| 902 const blink::WebString& result_name) { | |
| 903 DVLOG(1) << "OnTrackStarted result " << result; | |
| 904 std::vector<MediaStreamSource*>::iterator it = | |
| 905 std::find(sources_waiting_for_callback_.begin(), | |
| 906 sources_waiting_for_callback_.end(), | |
| 907 source); | |
| 908 DCHECK(it != sources_waiting_for_callback_.end()); | |
| 909 sources_waiting_for_callback_.erase(it); | |
| 910 // All tracks must be started successfully. Otherwise the request is a | |
| 911 // failure. | |
| 912 if (result != MEDIA_DEVICE_OK) { | |
| 913 request_result_ = result; | |
| 914 request_result_name_ = result_name; | |
| 915 } | |
| 916 | |
| 917 CheckAllTracksStarted(); | |
| 918 } | |
| 919 | |
| 920 void MediaStreamImpl::UserMediaRequestInfo::CheckAllTracksStarted() { | |
| 921 if (!ready_callback_.is_null() && sources_waiting_for_callback_.empty()) { | |
| 922 ready_callback_.Run(this, request_result_, request_result_name_); | |
| 923 } | |
| 924 } | |
| 925 | |
| 926 bool MediaStreamImpl::UserMediaRequestInfo::IsSourceUsed( | |
| 927 const blink::WebMediaStreamSource& source) const { | |
| 928 for (std::vector<blink::WebMediaStreamSource>::const_iterator source_it = | |
| 929 sources_.begin(); | |
| 930 source_it != sources_.end(); ++source_it) { | |
| 931 if (source_it->id() == source.id()) | |
| 932 return true; | |
| 933 } | |
| 934 return false; | |
| 935 } | |
| 936 | |
| 937 void MediaStreamImpl::UserMediaRequestInfo::RemoveSource( | |
| 938 const blink::WebMediaStreamSource& source) { | |
| 939 for (std::vector<blink::WebMediaStreamSource>::iterator it = | |
| 940 sources_.begin(); | |
| 941 it != sources_.end(); ++it) { | |
| 942 if (source.id() == it->id()) { | |
| 943 sources_.erase(it); | |
| 944 return; | |
| 945 } | |
| 946 } | |
| 947 } | |
| 948 | |
| 949 bool MediaStreamImpl::UserMediaRequestInfo::HasPendingSources() const { | |
| 950 return !sources_waiting_for_callback_.empty(); | |
| 951 } | |
| 952 | |
| 953 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 524363003:
Changed name of MediaStreamImpl to UserMediaClientImpl. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master