1 // Copyright 2018 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 "chrome/browser/media/webrtc/display_media_access_handler.h"
6
7 #include <memory>
8 #include <string>
9 #include <utility>
10
11 #include "base/bind.h"
12 #include "base/macros.h"
13 #include "base/run_loop.h"
14 #include "base/strings/utf_string_conversions.h"
15 #include "build/build_config.h"
16 #include "chrome/browser/media/webrtc/fake_desktop_media_picker_factory.h"
17 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
18 #include "content/public/browser/browser_context.h"
19 #include "content/public/browser/desktop_media_id.h"
20 #include "content/public/browser/notification_service.h"
21 #include "content/public/browser/notification_types.h"
22 #include "content/public/browser/web_contents.h"
23 #include "content/public/test/navigation_simulator.h"
24 #include "testing/gtest/include/gtest/gtest.h"
25 #include "third_party/blink/public/common/mediastream/media_stream_request.h"
26 #include "third_party/blink/public/mojom/mediastream/media_stream.mojom-shared.h"
27
28 #if defined(OS_MAC)
29 #include "base/mac/mac_util.h"
30 #endif
31
32 #if defined(OS_CHROMEOS)
33 #include "chrome/browser/chromeos/policy/dlp/mock_dlp_content_manager.h"
34 #endif
35
36 class DisplayMediaAccessHandlerTest : public ChromeRenderViewHostTestHarness {
37 public:
DisplayMediaAccessHandlerTest()38 DisplayMediaAccessHandlerTest() {}
~DisplayMediaAccessHandlerTest()39 ~DisplayMediaAccessHandlerTest() override {}
40
SetUp()41 void SetUp() override {
42 ChromeRenderViewHostTestHarness::SetUp();
43 auto picker_factory = std::make_unique<FakeDesktopMediaPickerFactory>();
44 picker_factory_ = picker_factory.get();
45 access_handler_ = std::make_unique<DisplayMediaAccessHandler>(
46 std::move(picker_factory), false /* display_notification */);
47 }
48
ProcessRequest(const content::DesktopMediaID & fake_desktop_media_id_response,blink::mojom::MediaStreamRequestResult * request_result,blink::MediaStreamDevices * devices_result,bool request_audio)49 void ProcessRequest(
50 const content::DesktopMediaID& fake_desktop_media_id_response,
51 blink::mojom::MediaStreamRequestResult* request_result,
52 blink::MediaStreamDevices* devices_result,
53 bool request_audio) {
54 FakeDesktopMediaPickerFactory::TestFlags test_flags[] = {
55 {true /* expect_screens */, true /* expect_windows*/,
56 true /* expect_tabs */, request_audio,
57 fake_desktop_media_id_response /* selected_source */}};
58 picker_factory_->SetTestFlags(test_flags, base::size(test_flags));
59 content::MediaStreamRequest request(
60 0, 0, 0, GURL("http://origin/"), false, blink::MEDIA_GENERATE_STREAM,
61 std::string(), std::string(),
62 request_audio ? blink::mojom::MediaStreamType::DISPLAY_AUDIO_CAPTURE
63 : blink::mojom::MediaStreamType::NO_SERVICE,
64 blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE,
65 /*disable_local_echo=*/false,
66 /*request_pan_tilt_zoom_permission=*/false);
67
68 base::RunLoop wait_loop;
69 content::MediaResponseCallback callback = base::BindOnce(
70 [](base::RunLoop* wait_loop,
71 blink::mojom::MediaStreamRequestResult* request_result,
72 blink::MediaStreamDevices* devices_result,
73 const blink::MediaStreamDevices& devices,
74 blink::mojom::MediaStreamRequestResult result,
75 std::unique_ptr<content::MediaStreamUI> ui) {
76 *request_result = result;
77 *devices_result = devices;
78 wait_loop->Quit();
79 },
80 &wait_loop, request_result, devices_result);
81 access_handler_->HandleRequest(web_contents(), request, std::move(callback),
82 nullptr /* extension */);
83 wait_loop.Run();
84 EXPECT_TRUE(test_flags[0].picker_created);
85
86 access_handler_.reset();
87 EXPECT_TRUE(test_flags[0].picker_deleted);
88 }
89
NotifyWebContentsDestroyed()90 void NotifyWebContentsDestroyed() {
91 access_handler_->Observe(
92 content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
93 content::Source<content::WebContents>(web_contents()),
94 content::NotificationDetails());
95 }
96
GetParams()97 DesktopMediaPicker::Params GetParams() {
98 return picker_factory_->picker()->GetParams();
99 }
100
GetRequestQueues()101 const DisplayMediaAccessHandler::RequestsQueues& GetRequestQueues() {
102 return access_handler_->pending_requests_;
103 }
104
105 protected:
106 FakeDesktopMediaPickerFactory* picker_factory_;
107 std::unique_ptr<DisplayMediaAccessHandler> access_handler_;
108 };
109
TEST_F(DisplayMediaAccessHandlerTest,PermissionGiven)110 TEST_F(DisplayMediaAccessHandlerTest, PermissionGiven) {
111 blink::mojom::MediaStreamRequestResult result;
112 blink::MediaStreamDevices devices;
113 ProcessRequest(content::DesktopMediaID(content::DesktopMediaID::TYPE_SCREEN,
114 content::DesktopMediaID::kFakeId),
115 &result, &devices, false /* request_audio */);
116 #if defined(OS_MAC)
117 // Starting from macOS 10.15, screen capture requires system permissions
118 // that are disabled by default.
119 if (base::mac::IsAtLeastOS10_15()) {
120 EXPECT_EQ(blink::mojom::MediaStreamRequestResult::SYSTEM_PERMISSION_DENIED,
121 result);
122 return;
123 }
124 #endif
125
126 EXPECT_EQ(blink::mojom::MediaStreamRequestResult::OK, result);
127 EXPECT_EQ(1u, devices.size());
128 EXPECT_EQ(blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE,
129 devices[0].type);
130 EXPECT_TRUE(devices[0].display_media_info.has_value());
131 }
132
TEST_F(DisplayMediaAccessHandlerTest,PermissionGivenToRequestWithAudio)133 TEST_F(DisplayMediaAccessHandlerTest, PermissionGivenToRequestWithAudio) {
134 blink::mojom::MediaStreamRequestResult result;
135 blink::MediaStreamDevices devices;
136 content::DesktopMediaID fake_media_id(content::DesktopMediaID::TYPE_SCREEN,
137 content::DesktopMediaID::kFakeId,
138 true /* audio_share */);
139 ProcessRequest(fake_media_id, &result, &devices, true /* request_audio */);
140 #if defined(OS_MAC)
141 // Starting from macOS 10.15, screen capture requires system permissions
142 // that are disabled by default.
143 if (base::mac::IsAtLeastOS10_15()) {
144 EXPECT_EQ(blink::mojom::MediaStreamRequestResult::SYSTEM_PERMISSION_DENIED,
145 result);
146 return;
147 }
148 #endif
149 EXPECT_EQ(blink::mojom::MediaStreamRequestResult::OK, result);
150 EXPECT_EQ(2u, devices.size());
151 EXPECT_EQ(blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE,
152 devices[0].type);
153 EXPECT_TRUE(devices[0].display_media_info.has_value());
154 EXPECT_EQ(blink::mojom::MediaStreamType::DISPLAY_AUDIO_CAPTURE,
155 devices[1].type);
156 EXPECT_TRUE(devices[1].input.IsValid());
157 }
158
TEST_F(DisplayMediaAccessHandlerTest,PermissionDenied)159 TEST_F(DisplayMediaAccessHandlerTest, PermissionDenied) {
160 blink::mojom::MediaStreamRequestResult result;
161 blink::MediaStreamDevices devices;
162 ProcessRequest(content::DesktopMediaID(), &result, &devices,
163 true /* request_audio */);
164 EXPECT_EQ(blink::mojom::MediaStreamRequestResult::PERMISSION_DENIED, result);
165 EXPECT_EQ(0u, devices.size());
166 }
167
168 #if defined(OS_CHROMEOS)
TEST_F(DisplayMediaAccessHandlerTest,DlpRestricted)169 TEST_F(DisplayMediaAccessHandlerTest, DlpRestricted) {
170 const content::DesktopMediaID media_id(content::DesktopMediaID::TYPE_SCREEN,
171 content::DesktopMediaID::kFakeId);
172
173 // Setup Data Leak Prevention restriction.
174 policy::MockDlpContentManager mock_dlp_content_manager;
175 policy::DlpContentManager::SetDlpContentManagerForTesting(
176 &mock_dlp_content_manager);
177 EXPECT_CALL(mock_dlp_content_manager, IsScreenCaptureRestricted(media_id))
178 .Times(1)
179 .WillOnce(testing::Return(true));
180
181 blink::mojom::MediaStreamRequestResult result;
182 blink::MediaStreamDevices devices;
183 ProcessRequest(media_id, &result, &devices, /*request_audio=*/false);
184
185 EXPECT_EQ(blink::mojom::MediaStreamRequestResult::PERMISSION_DENIED, result);
186 EXPECT_EQ(0u, devices.size());
187
188 policy::DlpContentManager::ResetDlpContentManagerForTesting();
189 }
190 #endif
191
TEST_F(DisplayMediaAccessHandlerTest,UpdateMediaRequestStateWithClosing)192 TEST_F(DisplayMediaAccessHandlerTest, UpdateMediaRequestStateWithClosing) {
193 const int render_process_id = 0;
194 const int render_frame_id = 0;
195 const int page_request_id = 0;
196 const blink::mojom::MediaStreamType video_stream_type =
197 blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE;
198 const blink::mojom::MediaStreamType audio_stream_type =
199 blink::mojom::MediaStreamType::DISPLAY_AUDIO_CAPTURE;
200 FakeDesktopMediaPickerFactory::TestFlags test_flags[] = {
201 {true /* expect_screens */, true /* expect_windows*/,
202 true /* expect_tabs */, true /* expect_audio */,
203 content::DesktopMediaID(), true /* cancelled */}};
204 picker_factory_->SetTestFlags(test_flags, base::size(test_flags));
205 content::MediaStreamRequest request(
206 render_process_id, render_frame_id, page_request_id,
207 GURL("http://origin/"), false, blink::MEDIA_GENERATE_STREAM,
208 std::string(), std::string(), audio_stream_type, video_stream_type,
209 /*disable_local_echo=*/false, /*request_pan_tilt_zoom_permission=*/false);
210 content::MediaResponseCallback callback;
211 access_handler_->HandleRequest(web_contents(), request, std::move(callback),
212 nullptr /* extension */);
213 EXPECT_TRUE(test_flags[0].picker_created);
214 EXPECT_EQ(1u, GetRequestQueues().size());
215 auto queue_it = GetRequestQueues().find(web_contents());
216 EXPECT_TRUE(queue_it != GetRequestQueues().end());
217 EXPECT_EQ(1u, queue_it->second.size());
218
219 access_handler_->UpdateMediaRequestState(
220 render_process_id, render_frame_id, page_request_id, video_stream_type,
221 content::MEDIA_REQUEST_STATE_CLOSING);
222 EXPECT_EQ(1u, GetRequestQueues().size());
223 queue_it = GetRequestQueues().find(web_contents());
224 EXPECT_TRUE(queue_it != GetRequestQueues().end());
225 EXPECT_EQ(0u, queue_it->second.size());
226 EXPECT_TRUE(test_flags[0].picker_deleted);
227 access_handler_.reset();
228 }
229
TEST_F(DisplayMediaAccessHandlerTest,CorrectHostAsksForPermissions)230 TEST_F(DisplayMediaAccessHandlerTest, CorrectHostAsksForPermissions) {
231 const int render_process_id = 0;
232 const int render_frame_id = 0;
233 const int page_request_id = 0;
234 const blink::mojom::MediaStreamType video_stream_type =
235 blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE;
236 const blink::mojom::MediaStreamType audio_stream_type =
237 blink::mojom::MediaStreamType::DISPLAY_AUDIO_CAPTURE;
238 FakeDesktopMediaPickerFactory::TestFlags test_flags[] = {
239 {true /* expect_screens */, true /* expect_windows*/,
240 true /* expect_tabs */, true /* expect_audio */,
241 content::DesktopMediaID(), true /* cancelled */}};
242 picker_factory_->SetTestFlags(test_flags, base::size(test_flags));
243 content::MediaStreamRequest request(
244 render_process_id, render_frame_id, page_request_id,
245 GURL("http://origin/"), false, blink::MEDIA_GENERATE_STREAM,
246 std::string(), std::string(), audio_stream_type, video_stream_type,
247 /*disable_local_echo=*/false, /*request_pan_tilt_zoom_permission=*/false);
248 content::MediaResponseCallback callback;
249 content::WebContents* test_web_contents = web_contents();
250 std::unique_ptr<content::NavigationSimulator> navigation =
251 content::NavigationSimulator::CreateBrowserInitiated(
252 GURL("blob:http://127.0.0.1:8000/says: www.google.com"),
253 test_web_contents);
254 navigation->Commit();
255 access_handler_->HandleRequest(test_web_contents, request,
256 std::move(callback), nullptr /* extension */);
257 DesktopMediaPicker::Params params = GetParams();
258 access_handler_->UpdateMediaRequestState(
259 render_process_id, render_frame_id, page_request_id, video_stream_type,
260 content::MEDIA_REQUEST_STATE_CLOSING);
261 EXPECT_EQ(base::UTF8ToUTF16("http://127.0.0.1:8000"), params.app_name);
262 }
263
TEST_F(DisplayMediaAccessHandlerTest,CorrectHostAsksForPermissionsNormalURLs)264 TEST_F(DisplayMediaAccessHandlerTest, CorrectHostAsksForPermissionsNormalURLs) {
265 const int render_process_id = 0;
266 const int render_frame_id = 0;
267 const int page_request_id = 0;
268 const blink::mojom::MediaStreamType video_stream_type =
269 blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE;
270 const blink::mojom::MediaStreamType audio_stream_type =
271 blink::mojom::MediaStreamType::DISPLAY_AUDIO_CAPTURE;
272 FakeDesktopMediaPickerFactory::TestFlags test_flags[] = {
273 {true /* expect_screens */, true /* expect_windows*/,
274 true /* expect_tabs */, true /* expect_audio */,
275 content::DesktopMediaID(), true /* cancelled */}};
276 picker_factory_->SetTestFlags(test_flags, base::size(test_flags));
277 content::MediaStreamRequest request(
278 render_process_id, render_frame_id, page_request_id,
279 GURL("http://origin/"), false, blink::MEDIA_GENERATE_STREAM,
280 std::string(), std::string(), audio_stream_type, video_stream_type,
281 /*disable_local_echo=*/false, /*request_pan_tilt_zoom_permission=*/false);
282 content::MediaResponseCallback callback;
283 content::WebContents* test_web_contents = web_contents();
284 std::unique_ptr<content::NavigationSimulator> navigation =
285 content::NavigationSimulator::CreateBrowserInitiated(
286 GURL("https://www.google.com"), test_web_contents);
287 navigation->Commit();
288 access_handler_->HandleRequest(test_web_contents, request,
289 std::move(callback), nullptr /* extension */);
290 DesktopMediaPicker::Params params = GetParams();
291 access_handler_->UpdateMediaRequestState(
292 render_process_id, render_frame_id, page_request_id, video_stream_type,
293 content::MEDIA_REQUEST_STATE_CLOSING);
294 EXPECT_EQ(base::UTF8ToUTF16("www.google.com"), params.app_name);
295 }
296
TEST_F(DisplayMediaAccessHandlerTest,WebContentsDestroyed)297 TEST_F(DisplayMediaAccessHandlerTest, WebContentsDestroyed) {
298 FakeDesktopMediaPickerFactory::TestFlags test_flags[] = {
299 {true /* expect_screens */, true /* expect_windows*/,
300 true /* expect_tabs */, false /* expect_audio */,
301 content::DesktopMediaID(), true /* cancelled */}};
302 picker_factory_->SetTestFlags(test_flags, base::size(test_flags));
303 content::MediaStreamRequest request(
304 0, 0, 0, GURL("http://origin/"), false, blink::MEDIA_GENERATE_STREAM,
305 std::string(), std::string(), blink::mojom::MediaStreamType::NO_SERVICE,
306 blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE,
307 /*disable_local_echo=*/false, /*request_pan_tilt_zoom_permission=*/false);
308 content::MediaResponseCallback callback;
309 access_handler_->HandleRequest(web_contents(), request, std::move(callback),
310 nullptr /* extension */);
311 EXPECT_TRUE(test_flags[0].picker_created);
312 EXPECT_EQ(1u, GetRequestQueues().size());
313 auto queue_it = GetRequestQueues().find(web_contents());
314 EXPECT_TRUE(queue_it != GetRequestQueues().end());
315 EXPECT_EQ(1u, queue_it->second.size());
316
317 NotifyWebContentsDestroyed();
318 EXPECT_EQ(0u, GetRequestQueues().size());
319 access_handler_.reset();
320 }
321
TEST_F(DisplayMediaAccessHandlerTest,MultipleRequests)322 TEST_F(DisplayMediaAccessHandlerTest, MultipleRequests) {
323 FakeDesktopMediaPickerFactory::TestFlags test_flags[] = {
324 {true /* expect_screens */, true /* expect_windows*/,
325 true /* expect_tabs */, false /* expect_audio */,
326 content::DesktopMediaID(
327 content::DesktopMediaID::TYPE_SCREEN,
328 content::DesktopMediaID::kFakeId) /* selected_source */},
329 {true /* expect_screens */, true /* expect_windows*/,
330 true /* expect_tabs */, false /* expect_audio */,
331 content::DesktopMediaID(
332 content::DesktopMediaID::TYPE_WINDOW,
333 content::DesktopMediaID::kNullId) /* selected_source */}};
334 const size_t kTestFlagCount = 2;
335 picker_factory_->SetTestFlags(test_flags, kTestFlagCount);
336
337 blink::mojom::MediaStreamRequestResult result;
338 blink::MediaStreamDevices devices;
339 base::RunLoop wait_loop[kTestFlagCount];
340 for (size_t i = 0; i < kTestFlagCount; ++i) {
341 content::MediaStreamRequest request(
342 0, 0, 0, GURL("http://origin/"), false, blink::MEDIA_GENERATE_STREAM,
343 std::string(), std::string(), blink::mojom::MediaStreamType::NO_SERVICE,
344 blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE,
345 /*disable_local_echo=*/false,
346 /*request_pan_tilt_zoom_permission=*/false);
347 content::MediaResponseCallback callback = base::BindOnce(
348 [](base::RunLoop* wait_loop,
349 blink::mojom::MediaStreamRequestResult* request_result,
350 blink::MediaStreamDevices* devices_result,
351 const blink::MediaStreamDevices& devices,
352 blink::mojom::MediaStreamRequestResult result,
353 std::unique_ptr<content::MediaStreamUI> ui) {
354 *request_result = result;
355 *devices_result = devices;
356 wait_loop->Quit();
357 },
358 &wait_loop[i], &result, &devices);
359 access_handler_->HandleRequest(web_contents(), request, std::move(callback),
360 nullptr /* extension */);
361 }
362 wait_loop[0].Run();
363 EXPECT_TRUE(test_flags[0].picker_created);
364 EXPECT_TRUE(test_flags[0].picker_deleted);
365 #if defined(OS_MAC)
366 // Starting from macOS 10.15, screen capture requires system permissions
367 // that are disabled by default.
368 if (base::mac::IsAtLeastOS10_15()) {
369 EXPECT_EQ(blink::mojom::MediaStreamRequestResult::SYSTEM_PERMISSION_DENIED,
370 result);
371 access_handler_.reset();
372 return;
373 }
374 #endif
375 EXPECT_EQ(blink::mojom::MediaStreamRequestResult::OK, result);
376 EXPECT_EQ(1u, devices.size());
377 EXPECT_EQ(blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE,
378 devices[0].type);
379
380 blink::MediaStreamDevice first_device = devices[0];
381 EXPECT_TRUE(test_flags[1].picker_created);
382 EXPECT_FALSE(test_flags[1].picker_deleted);
383 wait_loop[1].Run();
384 EXPECT_TRUE(test_flags[1].picker_deleted);
385 EXPECT_EQ(blink::mojom::MediaStreamRequestResult::OK, result);
386 EXPECT_EQ(1u, devices.size());
387 EXPECT_EQ(blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE,
388 devices[0].type);
389 EXPECT_FALSE(devices[0].IsSameDevice(first_device));
390
391 access_handler_.reset();
392 }
393