OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/renderer/media/user_media_client_impl.h" | 5 #include "content/renderer/media/user_media_client_impl.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 #include <utility> | 10 #include <utility> |
11 #include <vector> | 11 #include <vector> |
12 | 12 |
13 #include "base/message_loop/message_loop.h" | 13 #include "base/message_loop/message_loop.h" |
14 #include "base/run_loop.h" | 14 #include "base/run_loop.h" |
15 #include "base/strings/utf_string_conversions.h" | 15 #include "base/strings/utf_string_conversions.h" |
| 16 #include "base/test/scoped_feature_list.h" |
16 #include "content/child/child_process.h" | 17 #include "content/child/child_process.h" |
17 #include "content/common/media/media_devices.h" | 18 #include "content/common/media/media_devices.h" |
| 19 #include "content/public/common/content_features.h" |
18 #include "content/renderer/media/media_stream.h" | 20 #include "content/renderer/media/media_stream.h" |
| 21 #include "content/renderer/media/media_stream_audio_processor_options.h" |
19 #include "content/renderer/media/media_stream_audio_source.h" | 22 #include "content/renderer/media/media_stream_audio_source.h" |
| 23 #include "content/renderer/media/media_stream_constraints_util.h" |
| 24 #include "content/renderer/media/media_stream_constraints_util_video_content.h" |
20 #include "content/renderer/media/media_stream_track.h" | 25 #include "content/renderer/media/media_stream_track.h" |
21 #include "content/renderer/media/mock_constraint_factory.h" | 26 #include "content/renderer/media/mock_constraint_factory.h" |
22 #include "content/renderer/media/mock_media_stream_dispatcher.h" | 27 #include "content/renderer/media/mock_media_stream_dispatcher.h" |
23 #include "content/renderer/media/mock_media_stream_video_source.h" | 28 #include "content/renderer/media/mock_media_stream_video_source.h" |
24 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.
h" | 29 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.
h" |
| 30 #include "media/audio/audio_device_description.h" |
25 #include "mojo/public/cpp/bindings/binding.h" | 31 #include "mojo/public/cpp/bindings/binding.h" |
26 #include "testing/gtest/include/gtest/gtest.h" | 32 #include "testing/gtest/include/gtest/gtest.h" |
27 #include "third_party/WebKit/public/platform/WebMediaDeviceInfo.h" | 33 #include "third_party/WebKit/public/platform/WebMediaDeviceInfo.h" |
28 #include "third_party/WebKit/public/platform/WebMediaStream.h" | 34 #include "third_party/WebKit/public/platform/WebMediaStream.h" |
29 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h" | 35 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h" |
30 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h" | 36 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h" |
31 #include "third_party/WebKit/public/platform/WebString.h" | 37 #include "third_party/WebKit/public/platform/WebString.h" |
32 #include "third_party/WebKit/public/platform/WebVector.h" | 38 #include "third_party/WebKit/public/platform/WebVector.h" |
33 #include "third_party/WebKit/public/web/WebHeap.h" | 39 #include "third_party/WebKit/public/web/WebHeap.h" |
34 | 40 |
35 using testing::_; | 41 using testing::_; |
36 | 42 |
37 namespace content { | 43 namespace content { |
38 | 44 |
39 blink::WebMediaConstraints CreateDefaultConstraints() { | 45 blink::WebMediaConstraints CreateDefaultConstraints() { |
40 MockConstraintFactory factory; | 46 MockConstraintFactory factory; |
41 factory.AddAdvanced(); | 47 factory.AddAdvanced(); |
42 return factory.CreateWebMediaConstraints(); | 48 return factory.CreateWebMediaConstraints(); |
43 } | 49 } |
44 | 50 |
45 blink::WebMediaConstraints CreateDeviceConstraints( | 51 blink::WebMediaConstraints CreateDeviceConstraints( |
46 const char* basic_exact_value, | 52 const char* basic_exact_value, |
47 const char* basic_ideal_value = nullptr, | 53 const char* basic_ideal_value = nullptr, |
48 const char* advanced_exact_value = nullptr) { | 54 const char* advanced_exact_value = nullptr) { |
49 MockConstraintFactory factory; | 55 MockConstraintFactory factory; |
50 blink::WebMediaTrackConstraintSet basic; | |
51 if (basic_exact_value) { | 56 if (basic_exact_value) { |
52 factory.basic().device_id.SetExact( | 57 factory.basic().device_id.SetExact( |
53 blink::WebString::FromUTF8(basic_exact_value)); | 58 blink::WebString::FromUTF8(basic_exact_value)); |
54 } | 59 } |
55 if (basic_ideal_value) { | 60 if (basic_ideal_value) { |
56 blink::WebString value = blink::WebString::FromUTF8(basic_ideal_value); | 61 blink::WebString value = blink::WebString::FromUTF8(basic_ideal_value); |
57 factory.basic().device_id.SetIdeal( | 62 factory.basic().device_id.SetIdeal( |
58 blink::WebVector<blink::WebString>(&value, 1)); | 63 blink::WebVector<blink::WebString>(&value, 1)); |
59 } | 64 } |
60 | 65 |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
154 device->facing_mode = ::mojom::FacingMode::ENVIRONMENT; | 159 device->facing_mode = ::mojom::FacingMode::ENVIRONMENT; |
155 device->formats.push_back(media::VideoCaptureFormat( | 160 device->formats.push_back(media::VideoCaptureFormat( |
156 gfx::Size(640, 480), 30.0f, media::PIXEL_FORMAT_I420)); | 161 gfx::Size(640, 480), 30.0f, media::PIXEL_FORMAT_I420)); |
157 result.push_back(std::move(device)); | 162 result.push_back(std::move(device)); |
158 | 163 |
159 std::move(client_callback).Run(std::move(result)); | 164 std::move(client_callback).Run(std::move(result)); |
160 } | 165 } |
161 | 166 |
162 void GetAudioInputCapabilities( | 167 void GetAudioInputCapabilities( |
163 GetAudioInputCapabilitiesCallback client_callback) override { | 168 GetAudioInputCapabilitiesCallback client_callback) override { |
164 NOTREACHED(); | 169 if (IsOldAudioConstraints()) |
| 170 NOTREACHED(); |
| 171 |
| 172 std::vector<::mojom::AudioInputDeviceCapabilitiesPtr> result; |
| 173 ::mojom::AudioInputDeviceCapabilitiesPtr device = |
| 174 ::mojom::AudioInputDeviceCapabilities::New(); |
| 175 device->device_id = media::AudioDeviceDescription::kDefaultDeviceId; |
| 176 device->parameters = audio_parameters_; |
| 177 result.push_back(std::move(device)); |
| 178 |
| 179 device = ::mojom::AudioInputDeviceCapabilities::New(); |
| 180 device->device_id = kFakeAudioInputDeviceId1; |
| 181 device->parameters = audio_parameters_; |
| 182 result.push_back(std::move(device)); |
| 183 |
| 184 device = ::mojom::AudioInputDeviceCapabilities::New(); |
| 185 device->device_id = kFakeAudioInputDeviceId2; |
| 186 device->parameters = audio_parameters_; |
| 187 result.push_back(std::move(device)); |
| 188 |
| 189 std::move(client_callback).Run(std::move(result)); |
| 190 } |
| 191 |
| 192 media::AudioParameters& AudioParameters() { return audio_parameters_; } |
| 193 |
| 194 void ResetAudioParameters() { |
| 195 audio_parameters_ = media::AudioParameters::UnavailableDeviceParams(); |
165 } | 196 } |
166 | 197 |
167 MOCK_METHOD2(SubscribeDeviceChangeNotifications, | 198 MOCK_METHOD2(SubscribeDeviceChangeNotifications, |
168 void(MediaDeviceType type, uint32_t subscription_id)); | 199 void(MediaDeviceType type, uint32_t subscription_id)); |
169 MOCK_METHOD2(UnsubscribeDeviceChangeNotifications, | 200 MOCK_METHOD2(UnsubscribeDeviceChangeNotifications, |
170 void(MediaDeviceType type, uint32_t subscription_id)); | 201 void(MediaDeviceType type, uint32_t subscription_id)); |
| 202 |
| 203 private: |
| 204 media::AudioParameters audio_parameters_ = |
| 205 media::AudioParameters::UnavailableDeviceParams(); |
171 }; | 206 }; |
172 | 207 |
173 class UserMediaClientImplUnderTest : public UserMediaClientImpl { | 208 class UserMediaClientImplUnderTest : public UserMediaClientImpl { |
174 public: | 209 public: |
175 enum RequestState { | 210 enum RequestState { |
176 REQUEST_NOT_STARTED, | 211 REQUEST_NOT_STARTED, |
177 REQUEST_NOT_COMPLETE, | 212 REQUEST_NOT_COMPLETE, |
178 REQUEST_SUCCEEDED, | 213 REQUEST_SUCCEEDED, |
179 REQUEST_FAILED, | 214 REQUEST_FAILED, |
180 }; | 215 }; |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
214 } | 249 } |
215 | 250 |
216 void GetUserMediaRequestSucceeded( | 251 void GetUserMediaRequestSucceeded( |
217 const blink::WebMediaStream& stream, | 252 const blink::WebMediaStream& stream, |
218 blink::WebUserMediaRequest request_info) override { | 253 blink::WebUserMediaRequest request_info) override { |
219 last_generated_stream_ = stream; | 254 last_generated_stream_ = stream; |
220 state_ = REQUEST_SUCCEEDED; | 255 state_ = REQUEST_SUCCEEDED; |
221 } | 256 } |
222 | 257 |
223 void GetUserMediaRequestFailed( | 258 void GetUserMediaRequestFailed( |
224 blink::WebUserMediaRequest request_info, | |
225 content::MediaStreamRequestResult result, | 259 content::MediaStreamRequestResult result, |
226 const blink::WebString& result_name) override { | 260 const blink::WebString& result_name) override { |
227 last_generated_stream_.Reset(); | 261 last_generated_stream_.Reset(); |
228 state_ = REQUEST_FAILED; | 262 state_ = REQUEST_FAILED; |
229 result_ = result; | 263 result_ = result; |
230 result_name_ = result_name; | 264 result_name_ = result_name; |
231 } | 265 } |
232 | 266 |
233 void EnumerateDevicesSucceded( | 267 void EnumerateDevicesSucceded( |
234 blink::WebMediaDevicesRequest* request, | 268 blink::WebMediaDevicesRequest* request, |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
299 void ClearLastGeneratedStream() { last_generated_stream_.Reset(); } | 333 void ClearLastGeneratedStream() { last_generated_stream_.Reset(); } |
300 | 334 |
301 MockMediaStreamVideoCapturerSource* last_created_video_source() const { | 335 MockMediaStreamVideoCapturerSource* last_created_video_source() const { |
302 return video_source_; | 336 return video_source_; |
303 } | 337 } |
304 | 338 |
305 RequestState request_state() const { return state_; } | 339 RequestState request_state() const { return state_; } |
306 content::MediaStreamRequestResult error_reason() const { return result_; } | 340 content::MediaStreamRequestResult error_reason() const { return result_; } |
307 blink::WebString error_name() const { return result_name_; } | 341 blink::WebString error_name() const { return result_name_; } |
308 | 342 |
| 343 AudioCaptureSettings AudioSettings() const { |
| 344 return AudioCaptureSettingsForTesting(); |
| 345 } |
| 346 VideoCaptureSettings VideoSettings() const { |
| 347 return VideoCaptureSettingsForTesting(); |
| 348 } |
| 349 |
309 // Access to the request queue for testing. | 350 // Access to the request queue for testing. |
| 351 // TODO(guidou): Remove this function. http://crbug.com/704608 |
310 bool UserMediaRequestHasAutomaticDeviceSelection() { | 352 bool UserMediaRequestHasAutomaticDeviceSelection() { |
311 base::Optional<bool> enabled = | 353 base::Optional<bool> enabled = |
312 AutomaticOutputDeviceSelectionEnabledForCurrentRequest(); | 354 AutomaticOutputDeviceSelectionEnabledForCurrentRequest(); |
313 EXPECT_TRUE(enabled); | 355 EXPECT_TRUE(enabled); |
314 return *enabled; | 356 return *enabled; |
315 } | 357 } |
316 | 358 |
317 private: | 359 private: |
318 blink::WebMediaStream last_generated_stream_; | 360 blink::WebMediaStream last_generated_stream_; |
319 RequestState state_; | 361 RequestState state_; |
320 content::MediaStreamRequestResult result_; | 362 content::MediaStreamRequestResult result_; |
321 blink::WebString result_name_; | 363 blink::WebString result_name_; |
322 blink::WebVector<blink::WebMediaDeviceInfo> last_devices_; | 364 blink::WebVector<blink::WebMediaDeviceInfo> last_devices_; |
323 PeerConnectionDependencyFactory* factory_; | 365 PeerConnectionDependencyFactory* factory_; |
324 bool create_source_that_fails_; | 366 bool create_source_that_fails_; |
325 MockMediaStreamVideoCapturerSource* video_source_; | 367 MockMediaStreamVideoCapturerSource* video_source_; |
326 }; | 368 }; |
327 | 369 |
328 class UserMediaClientImplTest : public ::testing::Test { | 370 class UserMediaClientImplTest : public ::testing::TestWithParam<bool> { |
329 public: | 371 public: |
330 UserMediaClientImplTest() | 372 UserMediaClientImplTest() |
331 : binding_user_media(&media_devices_dispatcher_), | 373 : binding_user_media(&media_devices_dispatcher_), |
332 binding_event_dispatcher_(&media_devices_dispatcher_) {} | 374 binding_event_dispatcher_(&media_devices_dispatcher_) { |
| 375 if (GetParam()) { |
| 376 scoped_feature_list_.InitAndEnableFeature( |
| 377 features::kMediaStreamOldAudioConstraints); |
| 378 } else { |
| 379 scoped_feature_list_.InitAndDisableFeature( |
| 380 features::kMediaStreamOldAudioConstraints); |
| 381 } |
| 382 } |
333 | 383 |
334 void SetUp() override { | 384 void SetUp() override { |
335 // Create our test object. | 385 // Create our test object. |
336 child_process_.reset(new ChildProcess()); | 386 child_process_.reset(new ChildProcess()); |
337 dependency_factory_.reset(new MockPeerConnectionDependencyFactory()); | 387 dependency_factory_.reset(new MockPeerConnectionDependencyFactory()); |
338 ms_dispatcher_ = new MockMediaStreamDispatcher(); | 388 ms_dispatcher_ = new MockMediaStreamDispatcher(); |
339 user_media_client_impl_.reset(new UserMediaClientImplUnderTest( | 389 user_media_client_impl_.reset(new UserMediaClientImplUnderTest( |
340 dependency_factory_.get(), | 390 dependency_factory_.get(), |
341 std::unique_ptr<MediaStreamDispatcher>(ms_dispatcher_))); | 391 std::unique_ptr<MediaStreamDispatcher>(ms_dispatcher_))); |
342 ::mojom::MediaDevicesDispatcherHostPtr user_media_host_proxy; | 392 ::mojom::MediaDevicesDispatcherHostPtr user_media_host_proxy; |
(...skipping 113 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
456 protected: | 506 protected: |
457 base::MessageLoop message_loop_; | 507 base::MessageLoop message_loop_; |
458 std::unique_ptr<ChildProcess> child_process_; | 508 std::unique_ptr<ChildProcess> child_process_; |
459 MockMediaStreamDispatcher* ms_dispatcher_; // Owned by |used_media_impl_|. | 509 MockMediaStreamDispatcher* ms_dispatcher_; // Owned by |used_media_impl_|. |
460 MockMediaDevicesDispatcherHost media_devices_dispatcher_; | 510 MockMediaDevicesDispatcherHost media_devices_dispatcher_; |
461 mojo::Binding<::mojom::MediaDevicesDispatcherHost> binding_user_media; | 511 mojo::Binding<::mojom::MediaDevicesDispatcherHost> binding_user_media; |
462 mojo::Binding<::mojom::MediaDevicesDispatcherHost> binding_event_dispatcher_; | 512 mojo::Binding<::mojom::MediaDevicesDispatcherHost> binding_event_dispatcher_; |
463 | 513 |
464 std::unique_ptr<UserMediaClientImplUnderTest> user_media_client_impl_; | 514 std::unique_ptr<UserMediaClientImplUnderTest> user_media_client_impl_; |
465 std::unique_ptr<MockPeerConnectionDependencyFactory> dependency_factory_; | 515 std::unique_ptr<MockPeerConnectionDependencyFactory> dependency_factory_; |
| 516 // TODO(guidou): Remove this field. http://crbug.com/706408 |
| 517 base::test::ScopedFeatureList scoped_feature_list_; |
466 }; | 518 }; |
467 | 519 |
468 TEST_F(UserMediaClientImplTest, GenerateMediaStream) { | 520 TEST_P(UserMediaClientImplTest, GenerateMediaStream) { |
469 // Generate a stream with both audio and video. | 521 // Generate a stream with both audio and video. |
470 blink::WebMediaStream mixed_desc = RequestLocalMediaStream(); | 522 blink::WebMediaStream mixed_desc = RequestLocalMediaStream(); |
471 } | 523 } |
472 | 524 |
473 // Test that the same source object is used if two MediaStreams are generated | 525 // Test that the same source object is used if two MediaStreams are generated |
474 // using the same source. | 526 // using the same source. |
475 TEST_F(UserMediaClientImplTest, GenerateTwoMediaStreamsWithSameSource) { | 527 TEST_P(UserMediaClientImplTest, GenerateTwoMediaStreamsWithSameSource) { |
476 blink::WebMediaStream desc1 = RequestLocalMediaStream(); | 528 blink::WebMediaStream desc1 = RequestLocalMediaStream(); |
477 blink::WebMediaStream desc2 = RequestLocalMediaStream(); | 529 blink::WebMediaStream desc2 = RequestLocalMediaStream(); |
478 | 530 |
479 blink::WebVector<blink::WebMediaStreamTrack> desc1_video_tracks; | 531 blink::WebVector<blink::WebMediaStreamTrack> desc1_video_tracks; |
480 desc1.VideoTracks(desc1_video_tracks); | 532 desc1.VideoTracks(desc1_video_tracks); |
481 blink::WebVector<blink::WebMediaStreamTrack> desc2_video_tracks; | 533 blink::WebVector<blink::WebMediaStreamTrack> desc2_video_tracks; |
482 desc2.VideoTracks(desc2_video_tracks); | 534 desc2.VideoTracks(desc2_video_tracks); |
483 EXPECT_EQ(desc1_video_tracks[0].Source().Id(), | 535 EXPECT_EQ(desc1_video_tracks[0].Source().Id(), |
484 desc2_video_tracks[0].Source().Id()); | 536 desc2_video_tracks[0].Source().Id()); |
485 | 537 |
486 EXPECT_EQ(desc1_video_tracks[0].Source().GetExtraData(), | 538 EXPECT_EQ(desc1_video_tracks[0].Source().GetExtraData(), |
487 desc2_video_tracks[0].Source().GetExtraData()); | 539 desc2_video_tracks[0].Source().GetExtraData()); |
488 | 540 |
489 blink::WebVector<blink::WebMediaStreamTrack> desc1_audio_tracks; | 541 blink::WebVector<blink::WebMediaStreamTrack> desc1_audio_tracks; |
490 desc1.AudioTracks(desc1_audio_tracks); | 542 desc1.AudioTracks(desc1_audio_tracks); |
491 blink::WebVector<blink::WebMediaStreamTrack> desc2_audio_tracks; | 543 blink::WebVector<blink::WebMediaStreamTrack> desc2_audio_tracks; |
492 desc2.AudioTracks(desc2_audio_tracks); | 544 desc2.AudioTracks(desc2_audio_tracks); |
493 EXPECT_EQ(desc1_audio_tracks[0].Source().Id(), | 545 EXPECT_EQ(desc1_audio_tracks[0].Source().Id(), |
494 desc2_audio_tracks[0].Source().Id()); | 546 desc2_audio_tracks[0].Source().Id()); |
495 | 547 |
496 EXPECT_EQ(MediaStreamAudioSource::From(desc1_audio_tracks[0].Source()), | 548 EXPECT_EQ(MediaStreamAudioSource::From(desc1_audio_tracks[0].Source()), |
497 MediaStreamAudioSource::From(desc2_audio_tracks[0].Source())); | 549 MediaStreamAudioSource::From(desc2_audio_tracks[0].Source())); |
498 } | 550 } |
499 | 551 |
500 // Test that the same source object is not used if two MediaStreams are | 552 // Test that the same source object is not used if two MediaStreams are |
501 // generated using different sources. | 553 // generated using different sources. |
502 TEST_F(UserMediaClientImplTest, GenerateTwoMediaStreamsWithDifferentSources) { | 554 TEST_P(UserMediaClientImplTest, GenerateTwoMediaStreamsWithDifferentSources) { |
503 blink::WebMediaStream desc1 = RequestLocalMediaStream(); | 555 blink::WebMediaStream desc1 = RequestLocalMediaStream(); |
504 // Make sure another device is selected (another |session_id|) in the next | 556 // Make sure another device is selected (another |session_id|) in the next |
505 // gUM request. | 557 // gUM request. |
506 ms_dispatcher_->IncrementSessionId(); | 558 ms_dispatcher_->IncrementSessionId(); |
507 blink::WebMediaStream desc2 = RequestLocalMediaStream(); | 559 blink::WebMediaStream desc2 = RequestLocalMediaStream(); |
508 | 560 |
509 blink::WebVector<blink::WebMediaStreamTrack> desc1_video_tracks; | 561 blink::WebVector<blink::WebMediaStreamTrack> desc1_video_tracks; |
510 desc1.VideoTracks(desc1_video_tracks); | 562 desc1.VideoTracks(desc1_video_tracks); |
511 blink::WebVector<blink::WebMediaStreamTrack> desc2_video_tracks; | 563 blink::WebVector<blink::WebMediaStreamTrack> desc2_video_tracks; |
512 desc2.VideoTracks(desc2_video_tracks); | 564 desc2.VideoTracks(desc2_video_tracks); |
513 EXPECT_NE(desc1_video_tracks[0].Source().Id(), | 565 EXPECT_NE(desc1_video_tracks[0].Source().Id(), |
514 desc2_video_tracks[0].Source().Id()); | 566 desc2_video_tracks[0].Source().Id()); |
515 | 567 |
516 EXPECT_NE(desc1_video_tracks[0].Source().GetExtraData(), | 568 EXPECT_NE(desc1_video_tracks[0].Source().GetExtraData(), |
517 desc2_video_tracks[0].Source().GetExtraData()); | 569 desc2_video_tracks[0].Source().GetExtraData()); |
518 | 570 |
519 blink::WebVector<blink::WebMediaStreamTrack> desc1_audio_tracks; | 571 blink::WebVector<blink::WebMediaStreamTrack> desc1_audio_tracks; |
520 desc1.AudioTracks(desc1_audio_tracks); | 572 desc1.AudioTracks(desc1_audio_tracks); |
521 blink::WebVector<blink::WebMediaStreamTrack> desc2_audio_tracks; | 573 blink::WebVector<blink::WebMediaStreamTrack> desc2_audio_tracks; |
522 desc2.AudioTracks(desc2_audio_tracks); | 574 desc2.AudioTracks(desc2_audio_tracks); |
523 EXPECT_NE(desc1_audio_tracks[0].Source().Id(), | 575 EXPECT_NE(desc1_audio_tracks[0].Source().Id(), |
524 desc2_audio_tracks[0].Source().Id()); | 576 desc2_audio_tracks[0].Source().Id()); |
525 | 577 |
526 EXPECT_NE(MediaStreamAudioSource::From(desc1_audio_tracks[0].Source()), | 578 EXPECT_NE(MediaStreamAudioSource::From(desc1_audio_tracks[0].Source()), |
527 MediaStreamAudioSource::From(desc2_audio_tracks[0].Source())); | 579 MediaStreamAudioSource::From(desc2_audio_tracks[0].Source())); |
528 } | 580 } |
529 | 581 |
530 TEST_F(UserMediaClientImplTest, StopLocalTracks) { | 582 TEST_P(UserMediaClientImplTest, StopLocalTracks) { |
531 // Generate a stream with both audio and video. | 583 // Generate a stream with both audio and video. |
532 blink::WebMediaStream mixed_desc = RequestLocalMediaStream(); | 584 blink::WebMediaStream mixed_desc = RequestLocalMediaStream(); |
533 | 585 |
534 blink::WebVector<blink::WebMediaStreamTrack> audio_tracks; | 586 blink::WebVector<blink::WebMediaStreamTrack> audio_tracks; |
535 mixed_desc.AudioTracks(audio_tracks); | 587 mixed_desc.AudioTracks(audio_tracks); |
536 MediaStreamTrack* audio_track = MediaStreamTrack::GetTrack(audio_tracks[0]); | 588 MediaStreamTrack* audio_track = MediaStreamTrack::GetTrack(audio_tracks[0]); |
537 audio_track->Stop(); | 589 audio_track->Stop(); |
538 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); | 590 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); |
539 | 591 |
540 blink::WebVector<blink::WebMediaStreamTrack> video_tracks; | 592 blink::WebVector<blink::WebMediaStreamTrack> video_tracks; |
541 mixed_desc.VideoTracks(video_tracks); | 593 mixed_desc.VideoTracks(video_tracks); |
542 MediaStreamTrack* video_track = MediaStreamTrack::GetTrack(video_tracks[0]); | 594 MediaStreamTrack* video_track = MediaStreamTrack::GetTrack(video_tracks[0]); |
543 video_track->Stop(); | 595 video_track->Stop(); |
544 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); | 596 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); |
545 } | 597 } |
546 | 598 |
547 // This test that a source is not stopped even if the tracks in a | 599 // This test that a source is not stopped even if the tracks in a |
548 // MediaStream is stopped if there are two MediaStreams with tracks using the | 600 // MediaStream is stopped if there are two MediaStreams with tracks using the |
549 // same device. The source is stopped | 601 // same device. The source is stopped |
550 // if there are no more MediaStream tracks using the device. | 602 // if there are no more MediaStream tracks using the device. |
551 TEST_F(UserMediaClientImplTest, StopLocalTracksWhenTwoStreamUseSameDevices) { | 603 TEST_P(UserMediaClientImplTest, StopLocalTracksWhenTwoStreamUseSameDevices) { |
552 // Generate a stream with both audio and video. | 604 // Generate a stream with both audio and video. |
553 blink::WebMediaStream desc1 = RequestLocalMediaStream(); | 605 blink::WebMediaStream desc1 = RequestLocalMediaStream(); |
554 blink::WebMediaStream desc2 = RequestLocalMediaStream(); | 606 blink::WebMediaStream desc2 = RequestLocalMediaStream(); |
555 | 607 |
556 blink::WebVector<blink::WebMediaStreamTrack> audio_tracks1; | 608 blink::WebVector<blink::WebMediaStreamTrack> audio_tracks1; |
557 desc1.AudioTracks(audio_tracks1); | 609 desc1.AudioTracks(audio_tracks1); |
558 MediaStreamTrack* audio_track1 = MediaStreamTrack::GetTrack(audio_tracks1[0]); | 610 MediaStreamTrack* audio_track1 = MediaStreamTrack::GetTrack(audio_tracks1[0]); |
559 audio_track1->Stop(); | 611 audio_track1->Stop(); |
560 EXPECT_EQ(0, ms_dispatcher_->stop_audio_device_counter()); | 612 EXPECT_EQ(0, ms_dispatcher_->stop_audio_device_counter()); |
561 | 613 |
562 blink::WebVector<blink::WebMediaStreamTrack> audio_tracks2; | 614 blink::WebVector<blink::WebMediaStreamTrack> audio_tracks2; |
563 desc2.AudioTracks(audio_tracks2); | 615 desc2.AudioTracks(audio_tracks2); |
564 MediaStreamTrack* audio_track2 = MediaStreamTrack::GetTrack(audio_tracks2[0]); | 616 MediaStreamTrack* audio_track2 = MediaStreamTrack::GetTrack(audio_tracks2[0]); |
565 audio_track2->Stop(); | 617 audio_track2->Stop(); |
566 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); | 618 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); |
567 | 619 |
568 blink::WebVector<blink::WebMediaStreamTrack> video_tracks1; | 620 blink::WebVector<blink::WebMediaStreamTrack> video_tracks1; |
569 desc1.VideoTracks(video_tracks1); | 621 desc1.VideoTracks(video_tracks1); |
570 MediaStreamTrack* video_track1 = MediaStreamTrack::GetTrack(video_tracks1[0]); | 622 MediaStreamTrack* video_track1 = MediaStreamTrack::GetTrack(video_tracks1[0]); |
571 video_track1->Stop(); | 623 video_track1->Stop(); |
572 EXPECT_EQ(0, ms_dispatcher_->stop_video_device_counter()); | 624 EXPECT_EQ(0, ms_dispatcher_->stop_video_device_counter()); |
573 | 625 |
574 blink::WebVector<blink::WebMediaStreamTrack> video_tracks2; | 626 blink::WebVector<blink::WebMediaStreamTrack> video_tracks2; |
575 desc2.VideoTracks(video_tracks2); | 627 desc2.VideoTracks(video_tracks2); |
576 MediaStreamTrack* video_track2 = MediaStreamTrack::GetTrack(video_tracks2[0]); | 628 MediaStreamTrack* video_track2 = MediaStreamTrack::GetTrack(video_tracks2[0]); |
577 video_track2->Stop(); | 629 video_track2->Stop(); |
578 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); | 630 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); |
579 } | 631 } |
580 | 632 |
581 TEST_F(UserMediaClientImplTest, StopSourceWhenMediaStreamGoesOutOfScope) { | 633 TEST_P(UserMediaClientImplTest, StopSourceWhenMediaStreamGoesOutOfScope) { |
582 // Generate a stream with both audio and video. | 634 // Generate a stream with both audio and video. |
583 RequestLocalMediaStream(); | 635 RequestLocalMediaStream(); |
584 // Makes sure the test itself don't hold a reference to the created | 636 // Makes sure the test itself don't hold a reference to the created |
585 // MediaStream. | 637 // MediaStream. |
586 user_media_client_impl_->ClearLastGeneratedStream(); | 638 user_media_client_impl_->ClearLastGeneratedStream(); |
587 blink::WebHeap::CollectAllGarbageForTesting(); | 639 blink::WebHeap::CollectAllGarbageForTesting(); |
588 | 640 |
589 // Expect the sources to be stopped when the MediaStream goes out of scope. | 641 // Expect the sources to be stopped when the MediaStream goes out of scope. |
590 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); | 642 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); |
591 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); | 643 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); |
592 } | 644 } |
593 | 645 |
594 // Test that the MediaStreams are deleted if a new document is loaded in the | 646 // Test that the MediaStreams are deleted if a new document is loaded in the |
595 // frame. | 647 // frame. |
596 TEST_F(UserMediaClientImplTest, LoadNewDocumentInFrame) { | 648 TEST_P(UserMediaClientImplTest, LoadNewDocumentInFrame) { |
597 // Test a stream with both audio and video. | 649 // Test a stream with both audio and video. |
598 blink::WebMediaStream mixed_desc = RequestLocalMediaStream(); | 650 blink::WebMediaStream mixed_desc = RequestLocalMediaStream(); |
599 blink::WebMediaStream desc2 = RequestLocalMediaStream(); | 651 blink::WebMediaStream desc2 = RequestLocalMediaStream(); |
600 LoadNewDocumentInFrame(); | 652 LoadNewDocumentInFrame(); |
601 blink::WebHeap::CollectAllGarbageForTesting(); | 653 blink::WebHeap::CollectAllGarbageForTesting(); |
602 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); | 654 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); |
603 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); | 655 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); |
604 } | 656 } |
605 | 657 |
606 // This test what happens if a video source to a MediaSteam fails to start. | 658 // This test what happens if a video source to a MediaSteam fails to start. |
607 TEST_F(UserMediaClientImplTest, MediaVideoSourceFailToStart) { | 659 TEST_P(UserMediaClientImplTest, MediaVideoSourceFailToStart) { |
608 user_media_client_impl_->RequestUserMediaForTest(); | 660 user_media_client_impl_->RequestUserMediaForTest(); |
609 FakeMediaStreamDispatcherRequestUserMediaComplete(); | 661 FakeMediaStreamDispatcherRequestUserMediaComplete(); |
610 FailToStartMockedVideoSource(); | 662 FailToStartMockedVideoSource(); |
611 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_FAILED, | 663 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_FAILED, |
612 user_media_client_impl_->request_state()); | 664 user_media_client_impl_->request_state()); |
613 EXPECT_EQ(MEDIA_DEVICE_TRACK_START_FAILURE, | 665 EXPECT_EQ(MEDIA_DEVICE_TRACK_START_FAILURE, |
614 user_media_client_impl_->error_reason()); | 666 user_media_client_impl_->error_reason()); |
615 blink::WebHeap::CollectAllGarbageForTesting(); | 667 blink::WebHeap::CollectAllGarbageForTesting(); |
616 EXPECT_EQ(1, ms_dispatcher_->request_stream_counter()); | 668 EXPECT_EQ(1, ms_dispatcher_->request_stream_counter()); |
617 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); | 669 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); |
618 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); | 670 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); |
619 } | 671 } |
620 | 672 |
621 // This test what happens if an audio source fail to initialize. | 673 // This test what happens if an audio source fail to initialize. |
622 TEST_F(UserMediaClientImplTest, MediaAudioSourceFailToInitialize) { | 674 TEST_P(UserMediaClientImplTest, MediaAudioSourceFailToInitialize) { |
623 user_media_client_impl_->SetCreateSourceThatFails(true); | 675 user_media_client_impl_->SetCreateSourceThatFails(true); |
624 user_media_client_impl_->RequestUserMediaForTest(); | 676 user_media_client_impl_->RequestUserMediaForTest(); |
625 FakeMediaStreamDispatcherRequestUserMediaComplete(); | 677 FakeMediaStreamDispatcherRequestUserMediaComplete(); |
626 StartMockedVideoSource(); | 678 StartMockedVideoSource(); |
627 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_FAILED, | 679 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_FAILED, |
628 user_media_client_impl_->request_state()); | 680 user_media_client_impl_->request_state()); |
629 EXPECT_EQ(MEDIA_DEVICE_TRACK_START_FAILURE, | 681 EXPECT_EQ(MEDIA_DEVICE_TRACK_START_FAILURE, |
630 user_media_client_impl_->error_reason()); | 682 user_media_client_impl_->error_reason()); |
631 blink::WebHeap::CollectAllGarbageForTesting(); | 683 blink::WebHeap::CollectAllGarbageForTesting(); |
632 EXPECT_EQ(1, ms_dispatcher_->request_stream_counter()); | 684 EXPECT_EQ(1, ms_dispatcher_->request_stream_counter()); |
633 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); | 685 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); |
634 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); | 686 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); |
635 } | 687 } |
636 | 688 |
637 // This test what happens if UserMediaClientImpl is deleted before a source has | 689 // This test what happens if UserMediaClientImpl is deleted before a source has |
638 // started. | 690 // started. |
639 TEST_F(UserMediaClientImplTest, MediaStreamImplShutDown) { | 691 TEST_P(UserMediaClientImplTest, MediaStreamImplShutDown) { |
640 user_media_client_impl_->RequestUserMediaForTest(); | 692 user_media_client_impl_->RequestUserMediaForTest(); |
641 FakeMediaStreamDispatcherRequestUserMediaComplete(); | 693 FakeMediaStreamDispatcherRequestUserMediaComplete(); |
642 EXPECT_EQ(1, ms_dispatcher_->request_stream_counter()); | 694 EXPECT_EQ(1, ms_dispatcher_->request_stream_counter()); |
643 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_NOT_COMPLETE, | 695 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_NOT_COMPLETE, |
644 user_media_client_impl_->request_state()); | 696 user_media_client_impl_->request_state()); |
645 user_media_client_impl_.reset(); | 697 user_media_client_impl_.reset(); |
646 } | 698 } |
647 | 699 |
648 // This test what happens if a new document is loaded in the frame while the | 700 // This test what happens if a new document is loaded in the frame while the |
649 // MediaStream is being generated by the MediaStreamDispatcher. | 701 // MediaStream is being generated by the MediaStreamDispatcher. |
650 TEST_F(UserMediaClientImplTest, ReloadFrameWhileGeneratingStream) { | 702 TEST_P(UserMediaClientImplTest, ReloadFrameWhileGeneratingStream) { |
651 user_media_client_impl_->RequestUserMediaForTest(); | 703 user_media_client_impl_->RequestUserMediaForTest(); |
652 LoadNewDocumentInFrame(); | 704 LoadNewDocumentInFrame(); |
653 EXPECT_EQ(1, ms_dispatcher_->request_stream_counter()); | 705 EXPECT_EQ(1, ms_dispatcher_->request_stream_counter()); |
654 EXPECT_EQ(0, ms_dispatcher_->stop_audio_device_counter()); | 706 EXPECT_EQ(0, ms_dispatcher_->stop_audio_device_counter()); |
655 EXPECT_EQ(0, ms_dispatcher_->stop_video_device_counter()); | 707 EXPECT_EQ(0, ms_dispatcher_->stop_video_device_counter()); |
656 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_NOT_COMPLETE, | 708 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_NOT_COMPLETE, |
657 user_media_client_impl_->request_state()); | 709 user_media_client_impl_->request_state()); |
658 } | 710 } |
659 | 711 |
660 // This test what happens if a newdocument is loaded in the frame while the | 712 // This test what happens if a newdocument is loaded in the frame while the |
661 // sources are being started. | 713 // sources are being started. |
662 TEST_F(UserMediaClientImplTest, ReloadFrameWhileGeneratingSources) { | 714 TEST_P(UserMediaClientImplTest, ReloadFrameWhileGeneratingSources) { |
663 user_media_client_impl_->RequestUserMediaForTest(); | 715 user_media_client_impl_->RequestUserMediaForTest(); |
664 FakeMediaStreamDispatcherRequestUserMediaComplete(); | 716 FakeMediaStreamDispatcherRequestUserMediaComplete(); |
665 EXPECT_EQ(1, ms_dispatcher_->request_stream_counter()); | 717 EXPECT_EQ(1, ms_dispatcher_->request_stream_counter()); |
666 LoadNewDocumentInFrame(); | 718 LoadNewDocumentInFrame(); |
667 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); | 719 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); |
668 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); | 720 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); |
669 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_NOT_COMPLETE, | 721 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_NOT_COMPLETE, |
670 user_media_client_impl_->request_state()); | 722 user_media_client_impl_->request_state()); |
671 } | 723 } |
672 | 724 |
673 // This test what happens if stop is called on a track after the frame has | 725 // This test what happens if stop is called on a track after the frame has |
674 // been reloaded. | 726 // been reloaded. |
675 TEST_F(UserMediaClientImplTest, StopTrackAfterReload) { | 727 TEST_P(UserMediaClientImplTest, StopTrackAfterReload) { |
676 blink::WebMediaStream mixed_desc = RequestLocalMediaStream(); | 728 blink::WebMediaStream mixed_desc = RequestLocalMediaStream(); |
677 EXPECT_EQ(1, ms_dispatcher_->request_stream_counter()); | 729 EXPECT_EQ(1, ms_dispatcher_->request_stream_counter()); |
678 LoadNewDocumentInFrame(); | 730 LoadNewDocumentInFrame(); |
679 blink::WebHeap::CollectAllGarbageForTesting(); | 731 blink::WebHeap::CollectAllGarbageForTesting(); |
680 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); | 732 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); |
681 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); | 733 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); |
682 | 734 |
683 blink::WebVector<blink::WebMediaStreamTrack> audio_tracks; | 735 blink::WebVector<blink::WebMediaStreamTrack> audio_tracks; |
684 mixed_desc.AudioTracks(audio_tracks); | 736 mixed_desc.AudioTracks(audio_tracks); |
685 MediaStreamTrack* audio_track = MediaStreamTrack::GetTrack(audio_tracks[0]); | 737 MediaStreamTrack* audio_track = MediaStreamTrack::GetTrack(audio_tracks[0]); |
686 audio_track->Stop(); | 738 audio_track->Stop(); |
687 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); | 739 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); |
688 | 740 |
689 blink::WebVector<blink::WebMediaStreamTrack> video_tracks; | 741 blink::WebVector<blink::WebMediaStreamTrack> video_tracks; |
690 mixed_desc.VideoTracks(video_tracks); | 742 mixed_desc.VideoTracks(video_tracks); |
691 MediaStreamTrack* video_track = MediaStreamTrack::GetTrack(video_tracks[0]); | 743 MediaStreamTrack* video_track = MediaStreamTrack::GetTrack(video_tracks[0]); |
692 video_track->Stop(); | 744 video_track->Stop(); |
693 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); | 745 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); |
694 } | 746 } |
695 | 747 |
696 TEST_F(UserMediaClientImplTest, EnumerateMediaDevices) { | 748 TEST_P(UserMediaClientImplTest, EnumerateMediaDevices) { |
697 user_media_client_impl_->RequestMediaDevicesForTest(); | 749 user_media_client_impl_->RequestMediaDevicesForTest(); |
698 base::RunLoop().RunUntilIdle(); | 750 base::RunLoop().RunUntilIdle(); |
699 | 751 |
700 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_SUCCEEDED, | 752 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_SUCCEEDED, |
701 user_media_client_impl_->request_state()); | 753 user_media_client_impl_->request_state()); |
702 EXPECT_EQ(static_cast<size_t>(5), | 754 EXPECT_EQ(static_cast<size_t>(5), |
703 user_media_client_impl_->last_devices().size()); | 755 user_media_client_impl_->last_devices().size()); |
704 | 756 |
705 // Audio input device with matched output ID. | 757 // Audio input device with matched output ID. |
706 const blink::WebMediaDeviceInfo* device = | 758 const blink::WebMediaDeviceInfo* device = |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
742 EXPECT_FALSE(device->Label().IsEmpty()); | 794 EXPECT_FALSE(device->Label().IsEmpty()); |
743 EXPECT_FALSE(device->GroupId().IsEmpty()); | 795 EXPECT_FALSE(device->GroupId().IsEmpty()); |
744 | 796 |
745 // Verfify group IDs. | 797 // Verfify group IDs. |
746 EXPECT_TRUE(user_media_client_impl_->last_devices()[0].GroupId().Equals( | 798 EXPECT_TRUE(user_media_client_impl_->last_devices()[0].GroupId().Equals( |
747 user_media_client_impl_->last_devices()[4].GroupId())); | 799 user_media_client_impl_->last_devices()[4].GroupId())); |
748 EXPECT_FALSE(user_media_client_impl_->last_devices()[1].GroupId().Equals( | 800 EXPECT_FALSE(user_media_client_impl_->last_devices()[1].GroupId().Equals( |
749 user_media_client_impl_->last_devices()[4].GroupId())); | 801 user_media_client_impl_->last_devices()[4].GroupId())); |
750 } | 802 } |
751 | 803 |
752 TEST_F(UserMediaClientImplTest, RenderToAssociatedSinkConstraint) { | 804 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 805 TEST_P(UserMediaClientImplTest, RenderToAssociatedSinkConstraint) { |
| 806 if (!IsOldAudioConstraints()) |
| 807 return; |
| 808 |
753 // For a UserMediaRequest without audio, we expect false. | 809 // For a UserMediaRequest without audio, we expect false. |
754 blink::WebUserMediaRequest request = | 810 blink::WebUserMediaRequest request = |
755 blink::WebUserMediaRequest::CreateForTesting(blink::WebMediaConstraints(), | 811 blink::WebUserMediaRequest::CreateForTesting(blink::WebMediaConstraints(), |
756 CreateDefaultConstraints()); | 812 CreateDefaultConstraints()); |
757 user_media_client_impl_->RequestUserMediaForTest(request); | 813 user_media_client_impl_->RequestUserMediaForTest(request); |
758 EXPECT_FALSE( | 814 EXPECT_FALSE( |
759 user_media_client_impl_->UserMediaRequestHasAutomaticDeviceSelection()); | 815 user_media_client_impl_->UserMediaRequestHasAutomaticDeviceSelection()); |
760 user_media_client_impl_->CancelUserMediaRequest(request); | 816 user_media_client_impl_->CancelUserMediaRequest(request); |
761 | 817 |
762 // If audio is requested, but no constraint, it should be true. | 818 // If audio is requested, but no constraint, it should be true. |
(...skipping 16 matching lines...) Expand all Loading... |
779 factory.AddAdvanced().render_to_associated_sink.SetExact(false); | 835 factory.AddAdvanced().render_to_associated_sink.SetExact(false); |
780 EXPECT_FALSE(AudioRequestHasAutomaticDeviceSelection( | 836 EXPECT_FALSE(AudioRequestHasAutomaticDeviceSelection( |
781 factory.CreateWebMediaConstraints())); | 837 factory.CreateWebMediaConstraints())); |
782 | 838 |
783 factory.Reset(); | 839 factory.Reset(); |
784 factory.basic().render_to_associated_sink.SetExact(false); | 840 factory.basic().render_to_associated_sink.SetExact(false); |
785 EXPECT_FALSE(AudioRequestHasAutomaticDeviceSelection( | 841 EXPECT_FALSE(AudioRequestHasAutomaticDeviceSelection( |
786 factory.CreateWebMediaConstraints())); | 842 factory.CreateWebMediaConstraints())); |
787 } | 843 } |
788 | 844 |
789 TEST_F(UserMediaClientImplTest, ObserveMediaDeviceChanges) { | 845 TEST_P(UserMediaClientImplTest, DefaultConstraintsPropagate) { |
| 846 if (IsOldAudioConstraints()) |
| 847 return; |
| 848 |
| 849 blink::WebUserMediaRequest request = |
| 850 blink::WebUserMediaRequest::CreateForTesting(CreateDefaultConstraints(), |
| 851 CreateDefaultConstraints()); |
| 852 user_media_client_impl_->RequestUserMediaForTest(request); |
| 853 AudioCaptureSettings audio_capture_settings = |
| 854 user_media_client_impl_->AudioSettings(); |
| 855 VideoCaptureSettings video_capture_settings = |
| 856 user_media_client_impl_->VideoSettings(); |
| 857 user_media_client_impl_->CancelUserMediaRequest(request); |
| 858 |
| 859 // Check default values selected by the constraints algorithm. |
| 860 EXPECT_TRUE(audio_capture_settings.HasValue()); |
| 861 EXPECT_EQ(media::AudioDeviceDescription::kDefaultDeviceId, |
| 862 audio_capture_settings.device_id()); |
| 863 EXPECT_FALSE(audio_capture_settings.hotword_enabled()); |
| 864 EXPECT_TRUE(audio_capture_settings.disable_local_echo()); |
| 865 EXPECT_FALSE(audio_capture_settings.render_to_associated_sink()); |
| 866 |
| 867 const AudioProcessingProperties& properties = |
| 868 audio_capture_settings.audio_processing_properties(); |
| 869 EXPECT_TRUE(properties.enable_sw_echo_cancellation); |
| 870 EXPECT_FALSE(properties.disable_hw_echo_cancellation); |
| 871 EXPECT_FALSE(properties.goog_audio_mirroring); |
| 872 EXPECT_TRUE(properties.goog_auto_gain_control); |
| 873 // The default value for goog_experimental_echo_cancellation is platform |
| 874 // dependent. |
| 875 EXPECT_EQ(AudioProcessingProperties().goog_experimental_echo_cancellation, |
| 876 properties.goog_experimental_echo_cancellation); |
| 877 EXPECT_TRUE(properties.goog_typing_noise_detection); |
| 878 EXPECT_TRUE(properties.goog_noise_suppression); |
| 879 EXPECT_TRUE(properties.goog_experimental_noise_suppression); |
| 880 EXPECT_TRUE(properties.goog_beamforming); |
| 881 EXPECT_TRUE(properties.goog_highpass_filter); |
| 882 EXPECT_TRUE(properties.goog_experimental_auto_gain_control); |
| 883 EXPECT_TRUE(properties.goog_array_geometry.empty()); |
| 884 |
| 885 EXPECT_TRUE(video_capture_settings.HasValue()); |
| 886 EXPECT_EQ(video_capture_settings.Width(), |
| 887 MediaStreamVideoSource::kDefaultWidth); |
| 888 EXPECT_EQ(video_capture_settings.Height(), |
| 889 MediaStreamVideoSource::kDefaultHeight); |
| 890 EXPECT_EQ(video_capture_settings.FrameRate(), |
| 891 MediaStreamVideoSource::kDefaultFrameRate); |
| 892 EXPECT_EQ(video_capture_settings.ResolutionChangePolicy(), |
| 893 media::RESOLUTION_POLICY_FIXED_RESOLUTION); |
| 894 EXPECT_EQ(video_capture_settings.PowerLineFrequency(), |
| 895 media::PowerLineFrequency::FREQUENCY_DEFAULT); |
| 896 EXPECT_FALSE(video_capture_settings.noise_reduction()); |
| 897 EXPECT_EQ(video_capture_settings.min_frame_rate(), 1.0); |
| 898 |
| 899 const VideoTrackAdapterSettings& track_settings = |
| 900 video_capture_settings.track_adapter_settings(); |
| 901 EXPECT_EQ(track_settings.max_width, MediaStreamVideoSource::kDefaultWidth); |
| 902 EXPECT_EQ(track_settings.max_height, MediaStreamVideoSource::kDefaultHeight); |
| 903 EXPECT_EQ(track_settings.min_aspect_ratio, |
| 904 1.0 / MediaStreamVideoSource::kDefaultHeight); |
| 905 EXPECT_EQ(track_settings.max_aspect_ratio, |
| 906 MediaStreamVideoSource::kDefaultWidth); |
| 907 // 0.0 is the default max_frame_rate and it indicates no frame-rate adjustment |
| 908 EXPECT_EQ(track_settings.max_frame_rate, 0.0); |
| 909 } |
| 910 |
| 911 TEST_P(UserMediaClientImplTest, DefaultTabCapturePropagate) { |
| 912 if (IsOldAudioConstraints()) |
| 913 return; |
| 914 |
| 915 MockConstraintFactory factory; |
| 916 factory.basic().media_stream_source.SetExact( |
| 917 blink::WebString::FromASCII(kMediaStreamSourceTab)); |
| 918 blink::WebMediaConstraints audio_constraints = |
| 919 factory.CreateWebMediaConstraints(); |
| 920 blink::WebMediaConstraints video_constraints = |
| 921 factory.CreateWebMediaConstraints(); |
| 922 blink::WebUserMediaRequest request = |
| 923 blink::WebUserMediaRequest::CreateForTesting(audio_constraints, |
| 924 video_constraints); |
| 925 user_media_client_impl_->RequestUserMediaForTest(request); |
| 926 AudioCaptureSettings audio_capture_settings = |
| 927 user_media_client_impl_->AudioSettings(); |
| 928 VideoCaptureSettings video_capture_settings = |
| 929 user_media_client_impl_->VideoSettings(); |
| 930 user_media_client_impl_->CancelUserMediaRequest(request); |
| 931 |
| 932 // Check default values selected by the constraints algorithm. |
| 933 EXPECT_TRUE(audio_capture_settings.HasValue()); |
| 934 EXPECT_EQ(std::string(), audio_capture_settings.device_id()); |
| 935 EXPECT_FALSE(audio_capture_settings.hotword_enabled()); |
| 936 EXPECT_TRUE(audio_capture_settings.disable_local_echo()); |
| 937 EXPECT_FALSE(audio_capture_settings.render_to_associated_sink()); |
| 938 |
| 939 const AudioProcessingProperties& properties = |
| 940 audio_capture_settings.audio_processing_properties(); |
| 941 EXPECT_FALSE(properties.enable_sw_echo_cancellation); |
| 942 EXPECT_FALSE(properties.disable_hw_echo_cancellation); |
| 943 EXPECT_FALSE(properties.goog_audio_mirroring); |
| 944 EXPECT_FALSE(properties.goog_auto_gain_control); |
| 945 EXPECT_FALSE(properties.goog_experimental_echo_cancellation); |
| 946 EXPECT_FALSE(properties.goog_typing_noise_detection); |
| 947 EXPECT_FALSE(properties.goog_noise_suppression); |
| 948 EXPECT_FALSE(properties.goog_experimental_noise_suppression); |
| 949 EXPECT_FALSE(properties.goog_beamforming); |
| 950 EXPECT_FALSE(properties.goog_highpass_filter); |
| 951 EXPECT_FALSE(properties.goog_experimental_auto_gain_control); |
| 952 EXPECT_TRUE(properties.goog_array_geometry.empty()); |
| 953 |
| 954 EXPECT_TRUE(video_capture_settings.HasValue()); |
| 955 EXPECT_EQ(video_capture_settings.Width(), kDefaultScreenCastWidth); |
| 956 EXPECT_EQ(video_capture_settings.Height(), kDefaultScreenCastHeight); |
| 957 EXPECT_EQ(video_capture_settings.FrameRate(), kDefaultScreenCastFrameRate); |
| 958 EXPECT_EQ(video_capture_settings.ResolutionChangePolicy(), |
| 959 media::RESOLUTION_POLICY_FIXED_RESOLUTION); |
| 960 EXPECT_EQ(video_capture_settings.PowerLineFrequency(), |
| 961 media::PowerLineFrequency::FREQUENCY_DEFAULT); |
| 962 EXPECT_FALSE(video_capture_settings.noise_reduction()); |
| 963 EXPECT_FALSE(video_capture_settings.min_frame_rate().has_value()); |
| 964 EXPECT_FALSE(video_capture_settings.max_frame_rate().has_value()); |
| 965 |
| 966 const VideoTrackAdapterSettings& track_settings = |
| 967 video_capture_settings.track_adapter_settings(); |
| 968 EXPECT_EQ(track_settings.max_width, kDefaultScreenCastWidth); |
| 969 EXPECT_EQ(track_settings.max_height, kDefaultScreenCastHeight); |
| 970 EXPECT_EQ(track_settings.min_aspect_ratio, 1.0 / kMaxScreenCastDimension); |
| 971 EXPECT_EQ(track_settings.max_aspect_ratio, kMaxScreenCastDimension); |
| 972 // 0.0 is the default max_frame_rate and it indicates no frame-rate adjustment |
| 973 EXPECT_EQ(track_settings.max_frame_rate, 0.0); |
| 974 } |
| 975 |
| 976 TEST_P(UserMediaClientImplTest, DefaultDesktopCapturePropagate) { |
| 977 if (IsOldAudioConstraints()) |
| 978 return; |
| 979 |
| 980 MockConstraintFactory factory; |
| 981 factory.basic().media_stream_source.SetExact( |
| 982 blink::WebString::FromASCII(kMediaStreamSourceDesktop)); |
| 983 blink::WebMediaConstraints audio_constraints = |
| 984 factory.CreateWebMediaConstraints(); |
| 985 blink::WebMediaConstraints video_constraints = |
| 986 factory.CreateWebMediaConstraints(); |
| 987 blink::WebUserMediaRequest request = |
| 988 blink::WebUserMediaRequest::CreateForTesting(audio_constraints, |
| 989 video_constraints); |
| 990 user_media_client_impl_->RequestUserMediaForTest(request); |
| 991 AudioCaptureSettings audio_capture_settings = |
| 992 user_media_client_impl_->AudioSettings(); |
| 993 VideoCaptureSettings video_capture_settings = |
| 994 user_media_client_impl_->VideoSettings(); |
| 995 user_media_client_impl_->CancelUserMediaRequest(request); |
| 996 |
| 997 // Check default values selected by the constraints algorithm. |
| 998 EXPECT_TRUE(audio_capture_settings.HasValue()); |
| 999 EXPECT_EQ(std::string(), audio_capture_settings.device_id()); |
| 1000 EXPECT_FALSE(audio_capture_settings.hotword_enabled()); |
| 1001 EXPECT_FALSE(audio_capture_settings.disable_local_echo()); |
| 1002 EXPECT_FALSE(audio_capture_settings.render_to_associated_sink()); |
| 1003 |
| 1004 const AudioProcessingProperties& properties = |
| 1005 audio_capture_settings.audio_processing_properties(); |
| 1006 EXPECT_FALSE(properties.enable_sw_echo_cancellation); |
| 1007 EXPECT_FALSE(properties.disable_hw_echo_cancellation); |
| 1008 EXPECT_FALSE(properties.goog_audio_mirroring); |
| 1009 EXPECT_FALSE(properties.goog_auto_gain_control); |
| 1010 EXPECT_FALSE(properties.goog_experimental_echo_cancellation); |
| 1011 EXPECT_FALSE(properties.goog_typing_noise_detection); |
| 1012 EXPECT_FALSE(properties.goog_noise_suppression); |
| 1013 EXPECT_FALSE(properties.goog_experimental_noise_suppression); |
| 1014 EXPECT_FALSE(properties.goog_beamforming); |
| 1015 EXPECT_FALSE(properties.goog_highpass_filter); |
| 1016 EXPECT_FALSE(properties.goog_experimental_auto_gain_control); |
| 1017 EXPECT_TRUE(properties.goog_array_geometry.empty()); |
| 1018 |
| 1019 EXPECT_TRUE(video_capture_settings.HasValue()); |
| 1020 EXPECT_EQ(video_capture_settings.Width(), kDefaultScreenCastWidth); |
| 1021 EXPECT_EQ(video_capture_settings.Height(), kDefaultScreenCastHeight); |
| 1022 EXPECT_EQ(video_capture_settings.FrameRate(), kDefaultScreenCastFrameRate); |
| 1023 EXPECT_EQ(video_capture_settings.ResolutionChangePolicy(), |
| 1024 media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT); |
| 1025 EXPECT_EQ(video_capture_settings.PowerLineFrequency(), |
| 1026 media::PowerLineFrequency::FREQUENCY_DEFAULT); |
| 1027 EXPECT_FALSE(video_capture_settings.noise_reduction()); |
| 1028 EXPECT_FALSE(video_capture_settings.min_frame_rate().has_value()); |
| 1029 EXPECT_FALSE(video_capture_settings.max_frame_rate().has_value()); |
| 1030 |
| 1031 const VideoTrackAdapterSettings& track_settings = |
| 1032 video_capture_settings.track_adapter_settings(); |
| 1033 EXPECT_EQ(track_settings.max_width, kDefaultScreenCastWidth); |
| 1034 EXPECT_EQ(track_settings.max_height, kDefaultScreenCastHeight); |
| 1035 EXPECT_EQ(track_settings.min_aspect_ratio, 1.0 / kMaxScreenCastDimension); |
| 1036 EXPECT_EQ(track_settings.max_aspect_ratio, kMaxScreenCastDimension); |
| 1037 // 0.0 is the default max_frame_rate and it indicates no frame-rate adjustment |
| 1038 EXPECT_EQ(track_settings.max_frame_rate, 0.0); |
| 1039 } |
| 1040 |
| 1041 TEST_P(UserMediaClientImplTest, NonDefaultAudioConstraintsPropagate) { |
| 1042 if (IsOldAudioConstraints()) |
| 1043 return; |
| 1044 |
| 1045 MockConstraintFactory factory; |
| 1046 factory.basic().device_id.SetExact( |
| 1047 blink::WebString::FromASCII(kFakeAudioInputDeviceId1)); |
| 1048 factory.basic().hotword_enabled.SetExact(true); |
| 1049 factory.basic().disable_local_echo.SetExact(true); |
| 1050 factory.basic().render_to_associated_sink.SetExact(true); |
| 1051 factory.basic().echo_cancellation.SetExact(false); |
| 1052 factory.basic().goog_audio_mirroring.SetExact(true); |
| 1053 factory.basic().goog_typing_noise_detection.SetExact(true); |
| 1054 factory.basic().goog_array_geometry.SetExact( |
| 1055 blink::WebString::FromASCII("1 1 1")); |
| 1056 blink::WebMediaConstraints audio_constraints = |
| 1057 factory.CreateWebMediaConstraints(); |
| 1058 // Request contains only audio |
| 1059 blink::WebUserMediaRequest request = |
| 1060 blink::WebUserMediaRequest::CreateForTesting( |
| 1061 audio_constraints, blink::WebMediaConstraints()); |
| 1062 user_media_client_impl_->RequestUserMediaForTest(request); |
| 1063 AudioCaptureSettings audio_capture_settings = |
| 1064 user_media_client_impl_->AudioSettings(); |
| 1065 VideoCaptureSettings video_capture_settings = |
| 1066 user_media_client_impl_->VideoSettings(); |
| 1067 user_media_client_impl_->CancelUserMediaRequest(request); |
| 1068 |
| 1069 EXPECT_FALSE(video_capture_settings.HasValue()); |
| 1070 |
| 1071 EXPECT_TRUE(audio_capture_settings.HasValue()); |
| 1072 EXPECT_EQ(kFakeAudioInputDeviceId1, audio_capture_settings.device_id()); |
| 1073 EXPECT_TRUE(audio_capture_settings.hotword_enabled()); |
| 1074 EXPECT_TRUE(audio_capture_settings.disable_local_echo()); |
| 1075 EXPECT_TRUE(audio_capture_settings.render_to_associated_sink()); |
| 1076 |
| 1077 const AudioProcessingProperties& properties = |
| 1078 audio_capture_settings.audio_processing_properties(); |
| 1079 EXPECT_FALSE(properties.enable_sw_echo_cancellation); |
| 1080 EXPECT_TRUE(properties.disable_hw_echo_cancellation); |
| 1081 EXPECT_TRUE(properties.goog_audio_mirroring); |
| 1082 EXPECT_FALSE(properties.goog_auto_gain_control); |
| 1083 EXPECT_FALSE(properties.goog_experimental_echo_cancellation); |
| 1084 EXPECT_TRUE(properties.goog_typing_noise_detection); |
| 1085 EXPECT_FALSE(properties.goog_noise_suppression); |
| 1086 EXPECT_FALSE(properties.goog_experimental_noise_suppression); |
| 1087 EXPECT_FALSE(properties.goog_beamforming); |
| 1088 EXPECT_FALSE(properties.goog_highpass_filter); |
| 1089 EXPECT_FALSE(properties.goog_experimental_auto_gain_control); |
| 1090 const std::vector<media::Point> kGeometry = {{1.0, 1.0, 1.0}}; |
| 1091 EXPECT_EQ(kGeometry, properties.goog_array_geometry); |
| 1092 } |
| 1093 |
| 1094 TEST_P(UserMediaClientImplTest, ObserveMediaDeviceChanges) { |
790 EXPECT_CALL(media_devices_dispatcher_, SubscribeDeviceChangeNotifications( | 1095 EXPECT_CALL(media_devices_dispatcher_, SubscribeDeviceChangeNotifications( |
791 MEDIA_DEVICE_TYPE_AUDIO_INPUT, _)); | 1096 MEDIA_DEVICE_TYPE_AUDIO_INPUT, _)); |
792 EXPECT_CALL(media_devices_dispatcher_, SubscribeDeviceChangeNotifications( | 1097 EXPECT_CALL(media_devices_dispatcher_, SubscribeDeviceChangeNotifications( |
793 MEDIA_DEVICE_TYPE_VIDEO_INPUT, _)); | 1098 MEDIA_DEVICE_TYPE_VIDEO_INPUT, _)); |
794 EXPECT_CALL( | 1099 EXPECT_CALL( |
795 media_devices_dispatcher_, | 1100 media_devices_dispatcher_, |
796 SubscribeDeviceChangeNotifications(MEDIA_DEVICE_TYPE_AUDIO_OUTPUT, _)); | 1101 SubscribeDeviceChangeNotifications(MEDIA_DEVICE_TYPE_AUDIO_OUTPUT, _)); |
797 user_media_client_impl_->SetMediaDeviceChangeObserver( | 1102 user_media_client_impl_->SetMediaDeviceChangeObserver( |
798 blink::WebMediaDeviceChangeObserver(true)); | 1103 blink::WebMediaDeviceChangeObserver(true)); |
799 base::RunLoop().RunUntilIdle(); | 1104 base::RunLoop().RunUntilIdle(); |
(...skipping 15 matching lines...) Expand all Loading... |
815 EXPECT_CALL( | 1120 EXPECT_CALL( |
816 media_devices_dispatcher_, | 1121 media_devices_dispatcher_, |
817 UnsubscribeDeviceChangeNotifications(MEDIA_DEVICE_TYPE_AUDIO_OUTPUT, _)); | 1122 UnsubscribeDeviceChangeNotifications(MEDIA_DEVICE_TYPE_AUDIO_OUTPUT, _)); |
818 | 1123 |
819 user_media_client_impl_->SetMediaDeviceChangeObserver( | 1124 user_media_client_impl_->SetMediaDeviceChangeObserver( |
820 blink::WebMediaDeviceChangeObserver()); | 1125 blink::WebMediaDeviceChangeObserver()); |
821 base::RunLoop().RunUntilIdle(); | 1126 base::RunLoop().RunUntilIdle(); |
822 } | 1127 } |
823 | 1128 |
824 // This test what happens if the audio stream has same id with video stream. | 1129 // This test what happens if the audio stream has same id with video stream. |
825 TEST_F(UserMediaClientImplTest, AudioVideoWithSameId) { | 1130 TEST_P(UserMediaClientImplTest, AudioVideoWithSameId) { |
826 ms_dispatcher_->TestSameId(); | 1131 ms_dispatcher_->TestSameId(); |
827 | 1132 |
828 // Generate a stream with both audio and video. | 1133 // Generate a stream with both audio and video. |
829 blink::WebMediaStream mixed_desc = RequestLocalMediaStream(); | 1134 blink::WebMediaStream mixed_desc = RequestLocalMediaStream(); |
830 | 1135 |
831 // Remove video track. This should trigger | 1136 // Remove video track. This should trigger |
832 // UserMediaClientImpl::OnLocalSourceStopped, and has video track to be | 1137 // UserMediaClientImpl::OnLocalSourceStopped, and has video track to be |
833 // removed from its |local_sources_|. | 1138 // removed from its |local_sources_|. |
834 blink::WebVector<blink::WebMediaStreamTrack> video_tracks; | 1139 blink::WebVector<blink::WebMediaStreamTrack> video_tracks; |
835 mixed_desc.VideoTracks(video_tracks); | 1140 mixed_desc.VideoTracks(video_tracks); |
836 MediaStreamTrack* video_track = MediaStreamTrack::GetTrack(video_tracks[0]); | 1141 MediaStreamTrack* video_track = MediaStreamTrack::GetTrack(video_tracks[0]); |
837 video_track->Stop(); | 1142 video_track->Stop(); |
838 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); | 1143 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); |
839 EXPECT_EQ(0, ms_dispatcher_->stop_audio_device_counter()); | 1144 EXPECT_EQ(0, ms_dispatcher_->stop_audio_device_counter()); |
840 | 1145 |
841 // Now we load a new document in the web frame. If in the above Stop() call, | 1146 // Now we load a new document in the web frame. If in the above Stop() call, |
842 // UserMediaClientImpl accidentally removed audio track, then video track will | 1147 // UserMediaClientImpl accidentally removed audio track, then video track will |
843 // be removed again here, which is incorrect. | 1148 // be removed again here, which is incorrect. |
844 LoadNewDocumentInFrame(); | 1149 LoadNewDocumentInFrame(); |
845 blink::WebHeap::CollectAllGarbageForTesting(); | 1150 blink::WebHeap::CollectAllGarbageForTesting(); |
846 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); | 1151 EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter()); |
847 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); | 1152 EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter()); |
848 } | 1153 } |
849 | 1154 |
850 TEST_F(UserMediaClientImplTest, CreateWithMandatoryInvalidAudioDeviceId) { | 1155 TEST_P(UserMediaClientImplTest, CreateWithMandatoryInvalidAudioDeviceId) { |
851 blink::WebMediaConstraints audio_constraints = | 1156 blink::WebMediaConstraints audio_constraints = |
852 CreateDeviceConstraints(kInvalidDeviceId); | 1157 CreateDeviceConstraints(kInvalidDeviceId); |
853 blink::WebUserMediaRequest request = | 1158 blink::WebUserMediaRequest request = |
854 blink::WebUserMediaRequest::CreateForTesting( | 1159 blink::WebUserMediaRequest::CreateForTesting( |
855 audio_constraints, blink::WebMediaConstraints()); | 1160 audio_constraints, blink::WebMediaConstraints()); |
856 user_media_client_impl_->RequestUserMediaForTest(request); | 1161 user_media_client_impl_->RequestUserMediaForTest(request); |
857 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_FAILED, | 1162 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_FAILED, |
858 user_media_client_impl_->request_state()); | 1163 user_media_client_impl_->request_state()); |
859 } | 1164 } |
860 | 1165 |
861 TEST_F(UserMediaClientImplTest, CreateWithMandatoryInvalidVideoDeviceId) { | 1166 TEST_P(UserMediaClientImplTest, CreateWithMandatoryInvalidVideoDeviceId) { |
862 blink::WebMediaConstraints video_constraints = | 1167 blink::WebMediaConstraints video_constraints = |
863 CreateDeviceConstraints(kInvalidDeviceId); | 1168 CreateDeviceConstraints(kInvalidDeviceId); |
864 blink::WebUserMediaRequest request = | 1169 blink::WebUserMediaRequest request = |
865 blink::WebUserMediaRequest::CreateForTesting(blink::WebMediaConstraints(), | 1170 blink::WebUserMediaRequest::CreateForTesting(blink::WebMediaConstraints(), |
866 video_constraints); | 1171 video_constraints); |
867 user_media_client_impl_->RequestUserMediaForTest(request); | 1172 user_media_client_impl_->RequestUserMediaForTest(request); |
868 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_FAILED, | 1173 EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_FAILED, |
869 user_media_client_impl_->request_state()); | 1174 user_media_client_impl_->request_state()); |
870 } | 1175 } |
871 | 1176 |
872 TEST_F(UserMediaClientImplTest, CreateWithMandatoryValidDeviceIds) { | 1177 TEST_P(UserMediaClientImplTest, CreateWithMandatoryValidDeviceIds) { |
873 blink::WebMediaConstraints audio_constraints = | 1178 blink::WebMediaConstraints audio_constraints = |
874 CreateDeviceConstraints(kFakeAudioInputDeviceId1); | 1179 CreateDeviceConstraints(kFakeAudioInputDeviceId1); |
875 blink::WebMediaConstraints video_constraints = | 1180 blink::WebMediaConstraints video_constraints = |
876 CreateDeviceConstraints(kFakeVideoInputDeviceId1); | 1181 CreateDeviceConstraints(kFakeVideoInputDeviceId1); |
877 TestValidRequestWithConstraints(audio_constraints, video_constraints, | 1182 TestValidRequestWithConstraints(audio_constraints, video_constraints, |
878 kFakeAudioInputDeviceId1, | 1183 kFakeAudioInputDeviceId1, |
879 kFakeVideoInputDeviceId1); | 1184 kFakeVideoInputDeviceId1); |
880 } | 1185 } |
881 | 1186 |
882 TEST_F(UserMediaClientImplTest, CreateWithBasicIdealValidDeviceId) { | 1187 TEST_P(UserMediaClientImplTest, CreateWithBasicIdealValidDeviceId) { |
883 blink::WebMediaConstraints audio_constraints = | 1188 blink::WebMediaConstraints audio_constraints = |
884 CreateDeviceConstraints(nullptr, kFakeAudioInputDeviceId1); | 1189 CreateDeviceConstraints(nullptr, kFakeAudioInputDeviceId1); |
885 blink::WebMediaConstraints video_constraints = | 1190 blink::WebMediaConstraints video_constraints = |
886 CreateDeviceConstraints(nullptr, kFakeVideoInputDeviceId1); | 1191 CreateDeviceConstraints(nullptr, kFakeVideoInputDeviceId1); |
887 TestValidRequestWithConstraints(audio_constraints, video_constraints, | 1192 TestValidRequestWithConstraints(audio_constraints, video_constraints, |
888 kFakeAudioInputDeviceId1, | 1193 kFakeAudioInputDeviceId1, |
889 kFakeVideoInputDeviceId1); | 1194 kFakeVideoInputDeviceId1); |
890 } | 1195 } |
891 | 1196 |
892 TEST_F(UserMediaClientImplTest, CreateWithAdvancedExactValidDeviceId) { | 1197 TEST_P(UserMediaClientImplTest, CreateWithAdvancedExactValidDeviceId) { |
893 blink::WebMediaConstraints audio_constraints = | 1198 blink::WebMediaConstraints audio_constraints = |
894 CreateDeviceConstraints(nullptr, nullptr, kFakeAudioInputDeviceId1); | 1199 CreateDeviceConstraints(nullptr, nullptr, kFakeAudioInputDeviceId1); |
895 blink::WebMediaConstraints video_constraints = CreateDeviceConstraints( | 1200 blink::WebMediaConstraints video_constraints = CreateDeviceConstraints( |
896 nullptr, nullptr, kFakeVideoInputDeviceId1); | 1201 nullptr, nullptr, kFakeVideoInputDeviceId1); |
897 TestValidRequestWithConstraints(audio_constraints, video_constraints, | 1202 TestValidRequestWithConstraints(audio_constraints, video_constraints, |
898 kFakeAudioInputDeviceId1, | 1203 kFakeAudioInputDeviceId1, |
899 kFakeVideoInputDeviceId1); | 1204 kFakeVideoInputDeviceId1); |
900 } | 1205 } |
901 | 1206 |
902 TEST_F(UserMediaClientImplTest, CreateWithAllOptionalInvalidDeviceId) { | 1207 TEST_P(UserMediaClientImplTest, CreateWithAllOptionalInvalidDeviceId) { |
903 blink::WebMediaConstraints audio_constraints = | 1208 blink::WebMediaConstraints audio_constraints = |
904 CreateDeviceConstraints(nullptr, kInvalidDeviceId, kInvalidDeviceId); | 1209 CreateDeviceConstraints(nullptr, kInvalidDeviceId, kInvalidDeviceId); |
905 blink::WebMediaConstraints video_constraints = | 1210 blink::WebMediaConstraints video_constraints = |
906 CreateDeviceConstraints(nullptr, kInvalidDeviceId, kInvalidDeviceId); | 1211 CreateDeviceConstraints(nullptr, kInvalidDeviceId, kInvalidDeviceId); |
907 // MockMediaStreamDispatcher uses empty string as default audio device ID. | 1212 // MockMediaStreamDispatcher uses empty string as default audio device ID. |
908 // MockMediaDevicesDispatcher uses the first device in the enumeration as | 1213 // MockMediaDevicesDispatcher uses the first device in the enumeration as |
909 // default video device ID. | 1214 // default audio or video device ID. |
| 1215 std::string expected_audio_device_id = |
| 1216 IsOldAudioConstraints() ? std::string() |
| 1217 : media::AudioDeviceDescription::kDefaultDeviceId; |
910 TestValidRequestWithConstraints(audio_constraints, video_constraints, | 1218 TestValidRequestWithConstraints(audio_constraints, video_constraints, |
911 std::string(), kFakeVideoInputDeviceId1); | 1219 expected_audio_device_id, |
| 1220 kFakeVideoInputDeviceId1); |
912 } | 1221 } |
913 | 1222 |
914 TEST_F(UserMediaClientImplTest, CreateWithFacingModeUser) { | 1223 TEST_P(UserMediaClientImplTest, CreateWithFacingModeUser) { |
915 blink::WebMediaConstraints audio_constraints = | 1224 blink::WebMediaConstraints audio_constraints = |
916 CreateDeviceConstraints(kFakeAudioInputDeviceId1); | 1225 CreateDeviceConstraints(kFakeAudioInputDeviceId1); |
917 blink::WebMediaConstraints video_constraints = | 1226 blink::WebMediaConstraints video_constraints = |
918 CreateFacingModeConstraints("user"); | 1227 CreateFacingModeConstraints("user"); |
919 // kFakeVideoInputDeviceId1 has user facing mode. | 1228 // kFakeVideoInputDeviceId1 has user facing mode. |
920 TestValidRequestWithConstraints(audio_constraints, video_constraints, | 1229 TestValidRequestWithConstraints(audio_constraints, video_constraints, |
921 kFakeAudioInputDeviceId1, | 1230 kFakeAudioInputDeviceId1, |
922 kFakeVideoInputDeviceId1); | 1231 kFakeVideoInputDeviceId1); |
923 } | 1232 } |
924 | 1233 |
925 TEST_F(UserMediaClientImplTest, CreateWithFacingModeEnvironment) { | 1234 TEST_P(UserMediaClientImplTest, CreateWithFacingModeEnvironment) { |
926 blink::WebMediaConstraints audio_constraints = | 1235 blink::WebMediaConstraints audio_constraints = |
927 CreateDeviceConstraints(kFakeAudioInputDeviceId1); | 1236 CreateDeviceConstraints(kFakeAudioInputDeviceId1); |
928 blink::WebMediaConstraints video_constraints = | 1237 blink::WebMediaConstraints video_constraints = |
929 CreateFacingModeConstraints("environment"); | 1238 CreateFacingModeConstraints("environment"); |
930 // kFakeVideoInputDeviceId2 has environment facing mode. | 1239 // kFakeVideoInputDeviceId2 has environment facing mode. |
931 TestValidRequestWithConstraints(audio_constraints, video_constraints, | 1240 TestValidRequestWithConstraints(audio_constraints, video_constraints, |
932 kFakeAudioInputDeviceId1, | 1241 kFakeAudioInputDeviceId1, |
933 kFakeVideoInputDeviceId2); | 1242 kFakeVideoInputDeviceId2); |
934 } | 1243 } |
935 | 1244 |
| 1245 INSTANTIATE_TEST_CASE_P(, |
| 1246 UserMediaClientImplTest, |
| 1247 testing::Values(true, false)); |
| 1248 |
936 } // namespace content | 1249 } // namespace content |
OLD | NEW |