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