OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 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/browser/renderer_host/media/media_devices_dispatcher_host.h" | 5 #include "content/browser/renderer_host/media/media_devices_dispatcher_host.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 #include <queue> | 10 #include <queue> |
(...skipping 28 matching lines...) Expand all Loading... |
39 using testing::InvokeWithoutArgs; | 39 using testing::InvokeWithoutArgs; |
40 | 40 |
41 namespace content { | 41 namespace content { |
42 | 42 |
43 namespace { | 43 namespace { |
44 | 44 |
45 const int kProcessId = 5; | 45 const int kProcessId = 5; |
46 const int kRenderId = 6; | 46 const int kRenderId = 6; |
47 const size_t kNumFakeVideoDevices = 3; | 47 const size_t kNumFakeVideoDevices = 3; |
48 const char kDefaultVideoDeviceID[] = "/dev/video2"; | 48 const char kDefaultVideoDeviceID[] = "/dev/video2"; |
| 49 const char kDefaultAudioDeviceID[] = "fake_audio_input_2"; |
49 | 50 |
50 void PhysicalDevicesEnumerated(base::Closure quit_closure, | 51 void PhysicalDevicesEnumerated(base::Closure quit_closure, |
51 MediaDeviceEnumeration* out, | 52 MediaDeviceEnumeration* out, |
52 const MediaDeviceEnumeration& enumeration) { | 53 const MediaDeviceEnumeration& enumeration) { |
53 *out = enumeration; | 54 *out = enumeration; |
54 quit_closure.Run(); | 55 quit_closure.Run(); |
55 } | 56 } |
56 | 57 |
57 class MockMediaDevicesListener : public ::mojom::MediaDevicesListener { | 58 class MockMediaDevicesListener : public ::mojom::MediaDevicesListener { |
58 public: | 59 public: |
(...skipping 13 matching lines...) Expand all Loading... |
72 } // namespace | 73 } // namespace |
73 | 74 |
74 class MediaDevicesDispatcherHostTest : public testing::Test { | 75 class MediaDevicesDispatcherHostTest : public testing::Test { |
75 public: | 76 public: |
76 MediaDevicesDispatcherHostTest() | 77 MediaDevicesDispatcherHostTest() |
77 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), | 78 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), |
78 origin_(GURL("https://test.com")) { | 79 origin_(GURL("https://test.com")) { |
79 // Make sure we use fake devices to avoid long delays. | 80 // Make sure we use fake devices to avoid long delays. |
80 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 81 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
81 switches::kUseFakeDeviceForMediaStream, | 82 switches::kUseFakeDeviceForMediaStream, |
82 base::StringPrintf("device-count=%zu, video-input-default-id=%s", | 83 base::StringPrintf("device-count=%zu, video-input-default-id=%s, " |
83 kNumFakeVideoDevices, kDefaultVideoDeviceID)); | 84 "audio-input-default-id=%s", |
| 85 kNumFakeVideoDevices, kDefaultVideoDeviceID, |
| 86 kDefaultAudioDeviceID)); |
84 audio_manager_.reset( | 87 audio_manager_.reset( |
85 new media::MockAudioManager(base::ThreadTaskRunnerHandle::Get())); | 88 new media::MockAudioManager(base::ThreadTaskRunnerHandle::Get())); |
86 audio_system_ = media::AudioSystemImpl::Create(audio_manager_.get()); | 89 audio_system_ = media::AudioSystemImpl::Create(audio_manager_.get()); |
87 media_stream_manager_ = | 90 media_stream_manager_ = |
88 base::MakeUnique<MediaStreamManager>(audio_system_.get()); | 91 base::MakeUnique<MediaStreamManager>(audio_system_.get()); |
89 | 92 |
90 host_ = base::MakeUnique<MediaDevicesDispatcherHost>( | 93 host_ = base::MakeUnique<MediaDevicesDispatcherHost>( |
91 kProcessId, kRenderId, browser_context_.GetMediaDeviceIDSalt(), | 94 kProcessId, kRenderId, browser_context_.GetMediaDeviceIDSalt(), |
92 media_stream_manager_.get()); | 95 media_stream_manager_.get()); |
93 } | 96 } |
(...skipping 13 matching lines...) Expand all Loading... |
107 ASSERT_GT(physical_devices_[MEDIA_DEVICE_TYPE_AUDIO_INPUT].size(), 0u); | 110 ASSERT_GT(physical_devices_[MEDIA_DEVICE_TYPE_AUDIO_INPUT].size(), 0u); |
108 ASSERT_GT(physical_devices_[MEDIA_DEVICE_TYPE_VIDEO_INPUT].size(), 0u); | 111 ASSERT_GT(physical_devices_[MEDIA_DEVICE_TYPE_VIDEO_INPUT].size(), 0u); |
109 ASSERT_GT(physical_devices_[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT].size(), 0u); | 112 ASSERT_GT(physical_devices_[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT].size(), 0u); |
110 } | 113 } |
111 | 114 |
112 MOCK_METHOD1(UniqueOriginCallback, | 115 MOCK_METHOD1(UniqueOriginCallback, |
113 void(const std::vector<std::vector<MediaDeviceInfo>>&)); | 116 void(const std::vector<std::vector<MediaDeviceInfo>>&)); |
114 MOCK_METHOD1(ValidOriginCallback, | 117 MOCK_METHOD1(ValidOriginCallback, |
115 void(const std::vector<std::vector<MediaDeviceInfo>>&)); | 118 void(const std::vector<std::vector<MediaDeviceInfo>>&)); |
116 MOCK_METHOD0(MockVideoInputCapabilitiesCallback, void()); | 119 MOCK_METHOD0(MockVideoInputCapabilitiesCallback, void()); |
| 120 MOCK_METHOD0(MockAudioInputCapabilitiesCallback, void()); |
117 | 121 |
118 void VideoInputCapabilitiesCallback( | 122 void VideoInputCapabilitiesCallback( |
119 std::vector<::mojom::VideoInputDeviceCapabilitiesPtr> capabilities) { | 123 std::vector<::mojom::VideoInputDeviceCapabilitiesPtr> capabilities) { |
120 MockVideoInputCapabilitiesCallback(); | 124 MockVideoInputCapabilitiesCallback(); |
121 std::string expected_first_device_id = | 125 std::string expected_first_device_id = |
122 GetHMACForMediaDeviceID(browser_context_.GetMediaDeviceIDSalt(), | 126 GetHMACForMediaDeviceID(browser_context_.GetMediaDeviceIDSalt(), |
123 origin_, kDefaultVideoDeviceID); | 127 origin_, kDefaultVideoDeviceID); |
124 EXPECT_EQ(kNumFakeVideoDevices, capabilities.size()); | 128 EXPECT_EQ(kNumFakeVideoDevices, capabilities.size()); |
125 EXPECT_EQ(expected_first_device_id, capabilities[0]->device_id); | 129 EXPECT_EQ(expected_first_device_id, capabilities[0]->device_id); |
126 for (const auto& capability : capabilities) { | 130 for (const auto& capability : capabilities) { |
127 EXPECT_GT(capability->formats.size(), 1u); | 131 EXPECT_GT(capability->formats.size(), 1u); |
128 EXPECT_GT(capability->formats[0].frame_size.width(), 1); | 132 EXPECT_GT(capability->formats[0].frame_size.width(), 1); |
129 EXPECT_GT(capability->formats[0].frame_size.height(), 1); | 133 EXPECT_GT(capability->formats[0].frame_size.height(), 1); |
130 EXPECT_GT(capability->formats[0].frame_rate, 1); | 134 EXPECT_GT(capability->formats[0].frame_rate, 1); |
131 EXPECT_GT(capability->formats[1].frame_size.width(), 1); | 135 EXPECT_GT(capability->formats[1].frame_size.width(), 1); |
132 EXPECT_GT(capability->formats[1].frame_size.height(), 1); | 136 EXPECT_GT(capability->formats[1].frame_size.height(), 1); |
133 EXPECT_GT(capability->formats[1].frame_rate, 1); | 137 EXPECT_GT(capability->formats[1].frame_rate, 1); |
134 } | 138 } |
135 } | 139 } |
136 | 140 |
137 void VideoInputCapabilitiesUniqueOriginCallback( | 141 void VideoInputCapabilitiesUniqueOriginCallback( |
138 std::vector<::mojom::VideoInputDeviceCapabilitiesPtr> capabilities) { | 142 std::vector<::mojom::VideoInputDeviceCapabilitiesPtr> capabilities) { |
139 MockVideoInputCapabilitiesCallback(); | 143 MockVideoInputCapabilitiesCallback(); |
140 EXPECT_EQ(0U, capabilities.size()); | 144 EXPECT_EQ(0U, capabilities.size()); |
141 } | 145 } |
142 | 146 |
| 147 void AudioInputCapabilitiesCallback( |
| 148 std::vector<::mojom::AudioInputDeviceCapabilitiesPtr> capabilities) { |
| 149 MockAudioInputCapabilitiesCallback(); |
| 150 // MediaDevicesManager always returns 3 fake audio input devices. |
| 151 const size_t kNumExpectedEntries = 3; |
| 152 EXPECT_EQ(kNumExpectedEntries, capabilities.size()); |
| 153 std::string expected_first_device_id = |
| 154 GetHMACForMediaDeviceID(browser_context_.GetMediaDeviceIDSalt(), |
| 155 origin_, kDefaultAudioDeviceID); |
| 156 EXPECT_EQ(expected_first_device_id, capabilities[0]->device_id); |
| 157 for (const auto& capability : capabilities) |
| 158 EXPECT_TRUE(capability->parameters.IsValid()); |
| 159 } |
| 160 |
143 protected: | 161 protected: |
144 void DevicesEnumerated( | 162 void DevicesEnumerated( |
145 const base::Closure& closure, | 163 const base::Closure& closure, |
146 const std::vector<std::vector<MediaDeviceInfo>>& devices) { | 164 const std::vector<std::vector<MediaDeviceInfo>>& devices) { |
147 enumerated_devices_ = devices; | 165 enumerated_devices_ = devices; |
148 closure.Run(); | 166 closure.Run(); |
149 } | 167 } |
150 | 168 |
151 void EnumerateDevicesAndWaitForResult(bool enumerate_audio_input, | 169 void EnumerateDevicesAndWaitForResult(bool enumerate_audio_input, |
152 bool enumerate_video_input, | 170 bool enumerate_video_input, |
(...skipping 227 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
380 EXPECT_CALL(*this, MockVideoInputCapabilitiesCallback()) | 398 EXPECT_CALL(*this, MockVideoInputCapabilitiesCallback()) |
381 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 399 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
382 host_->GetVideoInputCapabilities( | 400 host_->GetVideoInputCapabilities( |
383 origin_, | 401 origin_, |
384 base::Bind( | 402 base::Bind( |
385 &MediaDevicesDispatcherHostTest::VideoInputCapabilitiesCallback, | 403 &MediaDevicesDispatcherHostTest::VideoInputCapabilitiesCallback, |
386 base::Unretained(this))); | 404 base::Unretained(this))); |
387 run_loop.Run(); | 405 run_loop.Run(); |
388 } | 406 } |
389 | 407 |
| 408 TEST_F(MediaDevicesDispatcherHostTest, GetAudioInputCapabilities) { |
| 409 base::RunLoop run_loop; |
| 410 EXPECT_CALL(*this, MockAudioInputCapabilitiesCallback()) |
| 411 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
| 412 host_->GetAudioInputCapabilities( |
| 413 origin_, |
| 414 base::Bind( |
| 415 &MediaDevicesDispatcherHostTest::AudioInputCapabilitiesCallback, |
| 416 base::Unretained(this))); |
| 417 run_loop.Run(); |
| 418 } |
| 419 |
390 TEST_F(MediaDevicesDispatcherHostTest, GetVideoInputCapabilitiesUniqueOrigin) { | 420 TEST_F(MediaDevicesDispatcherHostTest, GetVideoInputCapabilitiesUniqueOrigin) { |
391 base::RunLoop run_loop; | 421 base::RunLoop run_loop; |
392 EXPECT_CALL(*this, MockVideoInputCapabilitiesCallback()) | 422 EXPECT_CALL(*this, MockVideoInputCapabilitiesCallback()) |
393 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); | 423 .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })); |
394 host_->GetVideoInputCapabilities( | 424 host_->GetVideoInputCapabilities( |
395 url::Origin(), base::Bind(&MediaDevicesDispatcherHostTest:: | 425 url::Origin(), base::Bind(&MediaDevicesDispatcherHostTest:: |
396 VideoInputCapabilitiesUniqueOriginCallback, | 426 VideoInputCapabilitiesUniqueOriginCallback, |
397 base::Unretained(this))); | 427 base::Unretained(this))); |
398 run_loop.Run(); | 428 run_loop.Run(); |
399 } | 429 } |
400 | 430 |
401 }; // namespace content | 431 }; // namespace content |
OLD | NEW |