1 // Copyright 2014 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.
10 #include "base/command_line.h"
11 #include "base/run_loop.h"
12 #include "base/test/metrics/histogram_tester.h"
13 #include "base/test/scoped_feature_list.h"
14 #include "base/threading/sequenced_task_runner_handle.h"
15 #include "build/build_config.h"
16 #include "components/permissions/features.h"
17 #include "components/permissions/permission_request.h"
18 #include "components/permissions/permission_request_manager.h"
19 #include "components/permissions/permission_ui_selector.h"
20 #include "components/permissions/permission_uma_util.h"
21 #include "components/permissions/request_type.h"
22 #include "components/permissions/test/mock_permission_prompt_factory.h"
23 #include "components/permissions/test/mock_permission_request.h"
24 #include "components/permissions/test/test_permissions_client.h"
25 #include "content/public/test/test_renderer_host.h"
26 #include "testing/gtest/include/gtest/gtest.h"
27 #include "third_party/abseil-cpp/absl/types/optional.h"
29 namespace permissions {
32 using QuietUiReason = PermissionUiSelector::QuietUiReason;
35 class PermissionRequestManagerTest
36 : public content::RenderViewHostTestHarness,
37 public ::testing::WithParamInterface<bool> {
39 PermissionRequestManagerTest()
40 : request1_(RequestType::kGeolocation,
41 PermissionRequestGestureType::GESTURE),
42 request2_(RequestType::kMultipleDownloads,
43 PermissionRequestGestureType::NO_GESTURE),
44 request_mic_(RequestType::kMicStream,
45 PermissionRequestGestureType::NO_GESTURE),
46 request_camera_(RequestType::kCameraStream,
47 PermissionRequestGestureType::NO_GESTURE),
48 #if !defined(OS_ANDROID)
49 request_ptz_(RequestType::kCameraPanTiltZoom,
50 PermissionRequestGestureType::NO_GESTURE),
52 iframe_request_same_domain_(GURL("https://www.google.com/some/url"),
53 RequestType::kMidiSysex),
54 iframe_request_other_domain_(GURL("https://www.youtube.com"),
55 RequestType::kGeolocation),
56 iframe_request_camera_other_domain_(GURL("https://www.youtube.com"),
57 RequestType::kStorageAccess),
58 iframe_request_mic_other_domain_(GURL("https://www.youtube.com"),
59 RequestType::kMicStream) {
60 feature_list_.InitWithFeatureState(permissions::features::kPermissionChip,
64 void SetUp() override {
65 content::RenderViewHostTestHarness::SetUp();
66 SetContents(CreateTestWebContents());
67 NavigateAndCommit(GURL(permissions::MockPermissionRequest::kDefaultOrigin));
69 PermissionRequestManager::CreateForWebContents(web_contents());
70 manager_ = PermissionRequestManager::FromWebContents(web_contents());
71 prompt_factory_ = std::make_unique<MockPermissionPromptFactory>(manager_);
74 void TearDown() override {
75 prompt_factory_ = nullptr;
76 content::RenderViewHostTestHarness::TearDown();
81 base::RunLoop().RunUntilIdle();
86 base::RunLoop().RunUntilIdle();
91 base::RunLoop().RunUntilIdle();
94 void WaitForFrameLoad() {
95 // PermissionRequestManager ignores all parameters. Yay?
96 manager_->DOMContentLoaded(nullptr);
97 base::RunLoop().RunUntilIdle();
100 void WaitForBubbleToBeShown() {
101 manager_->DocumentOnLoadCompletedInMainFrame(main_rfh());
102 base::RunLoop().RunUntilIdle();
105 void MockTabSwitchAway() {
106 manager_->OnVisibilityChanged(content::Visibility::HIDDEN);
109 void MockTabSwitchBack() {
110 manager_->OnVisibilityChanged(content::Visibility::VISIBLE);
113 virtual void NavigationEntryCommitted(
114 const content::LoadCommittedDetails& details) {
115 manager_->NavigationEntryCommitted(details);
118 std::unique_ptr<MockPermissionRequest> CreateAndAddRequest(
121 int expected_request_count) {
122 std::unique_ptr<MockPermissionRequest> request =
123 std::make_unique<MockPermissionRequest>(
124 type, PermissionRequestGestureType::GESTURE);
125 manager_->AddRequest(web_contents()->GetMainFrame(), request.get());
126 WaitForBubbleToBeShown();
127 if (should_be_seen) {
128 EXPECT_TRUE(prompt_factory_->RequestTypeSeen(type));
130 EXPECT_FALSE(prompt_factory_->RequestTypeSeen(type));
132 EXPECT_EQ(prompt_factory_->TotalRequestCount(), expected_request_count);
137 void WaitAndAcceptPromptForRequest(MockPermissionRequest* request) {
138 WaitForBubbleToBeShown();
140 EXPECT_FALSE(request->finished());
141 EXPECT_TRUE(prompt_factory_->is_visible());
142 ASSERT_EQ(prompt_factory_->request_count(), 1);
145 EXPECT_TRUE(request->granted());
149 MockPermissionRequest request1_;
150 MockPermissionRequest request2_;
151 MockPermissionRequest request_mic_;
152 MockPermissionRequest request_camera_;
153 #if !defined(OS_ANDROID)
154 MockPermissionRequest request_ptz_;
156 MockPermissionRequest iframe_request_same_domain_;
157 MockPermissionRequest iframe_request_other_domain_;
158 MockPermissionRequest iframe_request_camera_other_domain_;
159 MockPermissionRequest iframe_request_mic_other_domain_;
160 PermissionRequestManager* manager_;
161 std::unique_ptr<MockPermissionPromptFactory> prompt_factory_;
162 TestPermissionsClient client_;
163 base::test::ScopedFeatureList feature_list_;
166 ////////////////////////////////////////////////////////////////////////////////
168 ////////////////////////////////////////////////////////////////////////////////
170 TEST_P(PermissionRequestManagerTest, NoRequests) {
171 WaitForBubbleToBeShown();
172 EXPECT_FALSE(prompt_factory_->is_visible());
175 TEST_P(PermissionRequestManagerTest, SingleRequest) {
176 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
177 WaitForBubbleToBeShown();
179 EXPECT_TRUE(prompt_factory_->is_visible());
180 ASSERT_EQ(prompt_factory_->request_count(), 1);
183 EXPECT_TRUE(request1_.granted());
186 TEST_P(PermissionRequestManagerTest, SequentialRequests) {
187 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
188 WaitForBubbleToBeShown();
189 EXPECT_TRUE(prompt_factory_->is_visible());
192 EXPECT_TRUE(request1_.granted());
193 EXPECT_FALSE(prompt_factory_->is_visible());
195 manager_->AddRequest(web_contents()->GetMainFrame(), &request2_);
196 WaitForBubbleToBeShown();
197 EXPECT_TRUE(prompt_factory_->is_visible());
199 EXPECT_FALSE(prompt_factory_->is_visible());
200 EXPECT_TRUE(request2_.granted());
203 TEST_P(PermissionRequestManagerTest, ForgetRequestsOnPageNavigation) {
204 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
205 manager_->AddRequest(web_contents()->GetMainFrame(), &request2_);
206 manager_->AddRequest(web_contents()->GetMainFrame(),
207 &iframe_request_other_domain_);
208 WaitForBubbleToBeShown();
210 EXPECT_TRUE(prompt_factory_->is_visible());
211 ASSERT_EQ(prompt_factory_->request_count(), 1);
213 NavigateAndCommit(GURL("http://www2.google.com/"));
214 WaitForBubbleToBeShown();
216 EXPECT_FALSE(prompt_factory_->is_visible());
217 EXPECT_TRUE(request1_.finished());
218 EXPECT_TRUE(request2_.finished());
219 EXPECT_TRUE(iframe_request_other_domain_.finished());
222 TEST_P(PermissionRequestManagerTest, RequestsDontNeedUserGesture) {
224 WaitForBubbleToBeShown();
225 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
226 manager_->AddRequest(web_contents()->GetMainFrame(),
227 &iframe_request_other_domain_);
228 manager_->AddRequest(web_contents()->GetMainFrame(), &request2_);
229 base::RunLoop().RunUntilIdle();
231 EXPECT_TRUE(prompt_factory_->is_visible());
234 TEST_P(PermissionRequestManagerTest, RequestsNotSupported) {
235 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
236 WaitForBubbleToBeShown();
238 EXPECT_TRUE(request1_.granted());
240 manager_->set_web_contents_supports_permission_requests(false);
242 manager_->AddRequest(web_contents()->GetMainFrame(), &request2_);
243 EXPECT_TRUE(request2_.cancelled());
246 ////////////////////////////////////////////////////////////////////////////////
248 ////////////////////////////////////////////////////////////////////////////////
250 // Most requests should never be grouped.
251 TEST_P(PermissionRequestManagerTest, TwoRequestsUngrouped) {
252 // Grouping for chip feature is tested in ThreeRequestsStackOrderChip.
256 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
257 manager_->AddRequest(web_contents()->GetMainFrame(), &request2_);
259 WaitForBubbleToBeShown();
260 EXPECT_TRUE(prompt_factory_->is_visible());
261 ASSERT_EQ(prompt_factory_->request_count(), 1);
263 EXPECT_TRUE(request1_.granted());
265 WaitForBubbleToBeShown();
266 EXPECT_TRUE(prompt_factory_->is_visible());
267 ASSERT_EQ(prompt_factory_->request_count(), 1);
269 EXPECT_TRUE(request2_.granted());
271 ASSERT_EQ(prompt_factory_->show_count(), 2);
274 TEST_P(PermissionRequestManagerTest, ThreeRequestsStackOrderChip) {
278 // Test new permissions order, requests shouldn't be grouped.
279 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
280 manager_->AddRequest(web_contents()->GetMainFrame(), &request2_);
281 manager_->AddRequest(web_contents()->GetMainFrame(), &request_mic_);
282 WaitForBubbleToBeShown();
284 EXPECT_TRUE(prompt_factory_->is_visible());
285 EXPECT_EQ(prompt_factory_->request_count(), 1);
287 EXPECT_TRUE(request_mic_.granted());
288 EXPECT_FALSE(request2_.granted());
289 EXPECT_FALSE(request1_.granted());
290 WaitForBubbleToBeShown();
292 EXPECT_TRUE(prompt_factory_->is_visible());
293 EXPECT_EQ(prompt_factory_->request_count(), 1);
295 EXPECT_TRUE(request2_.granted());
296 EXPECT_FALSE(request1_.granted());
297 WaitForBubbleToBeShown();
299 EXPECT_TRUE(prompt_factory_->is_visible());
300 EXPECT_EQ(prompt_factory_->request_count(), 1);
302 EXPECT_TRUE(request1_.granted());
305 // Test new permissions order by adding requests one at a time.
306 TEST_P(PermissionRequestManagerTest, ThreeRequestsOneByOneStackOrderChip) {
310 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
311 WaitForBubbleToBeShown();
313 manager_->AddRequest(web_contents()->GetMainFrame(), &request2_);
314 WaitForBubbleToBeShown();
316 manager_->AddRequest(web_contents()->GetMainFrame(), &request_mic_);
317 WaitForBubbleToBeShown();
319 EXPECT_TRUE(prompt_factory_->is_visible());
320 EXPECT_EQ(prompt_factory_->request_count(), 1);
322 EXPECT_TRUE(request_mic_.granted());
323 EXPECT_FALSE(request2_.granted());
324 EXPECT_FALSE(request1_.granted());
325 WaitForBubbleToBeShown();
327 EXPECT_TRUE(prompt_factory_->is_visible());
328 EXPECT_EQ(prompt_factory_->request_count(), 1);
330 EXPECT_TRUE(request2_.granted());
331 EXPECT_FALSE(request1_.granted());
332 WaitForBubbleToBeShown();
334 EXPECT_TRUE(prompt_factory_->is_visible());
335 EXPECT_EQ(prompt_factory_->request_count(), 1);
337 EXPECT_TRUE(request1_.granted());
340 // Only mic/camera requests from the same origin should be grouped.
341 TEST_P(PermissionRequestManagerTest, MicCameraGrouped) {
342 manager_->AddRequest(web_contents()->GetMainFrame(), &request_mic_);
343 manager_->AddRequest(web_contents()->GetMainFrame(), &request_camera_);
344 WaitForBubbleToBeShown();
346 EXPECT_TRUE(prompt_factory_->is_visible());
347 ASSERT_EQ(prompt_factory_->request_count(), 2);
350 EXPECT_TRUE(request_mic_.granted());
351 EXPECT_TRUE(request_camera_.granted());
354 // If mic/camera requests come from different origins, they should not be
356 TEST_P(PermissionRequestManagerTest, MicCameraDifferentOrigins) {
357 manager_->AddRequest(web_contents()->GetMainFrame(),
358 &iframe_request_mic_other_domain_);
359 manager_->AddRequest(web_contents()->GetMainFrame(), &request_camera_);
360 WaitForBubbleToBeShown();
362 EXPECT_TRUE(prompt_factory_->is_visible());
363 ASSERT_EQ(prompt_factory_->request_count(), 1);
366 #if !defined(OS_ANDROID)
367 // Only camera/ptz requests from the same origin should be grouped.
368 TEST_P(PermissionRequestManagerTest, CameraPtzGrouped) {
369 manager_->AddRequest(web_contents()->GetMainFrame(), &request_camera_);
370 manager_->AddRequest(web_contents()->GetMainFrame(), &request_ptz_);
371 WaitForBubbleToBeShown();
373 EXPECT_TRUE(prompt_factory_->is_visible());
374 ASSERT_EQ(prompt_factory_->request_count(), 2);
377 EXPECT_TRUE(request_camera_.granted());
378 EXPECT_TRUE(request_ptz_.granted());
381 TEST_P(PermissionRequestManagerTest, CameraPtzDifferentOrigins) {
382 // If camera/ptz requests come from different origins, they should not be
384 manager_->AddRequest(web_contents()->GetMainFrame(),
385 &iframe_request_camera_other_domain_);
386 manager_->AddRequest(web_contents()->GetMainFrame(), &request_ptz_);
387 WaitForBubbleToBeShown();
389 EXPECT_TRUE(prompt_factory_->is_visible());
390 ASSERT_EQ(prompt_factory_->request_count(), 1);
393 // Only mic/camera/ptz requests from the same origin should be grouped.
394 TEST_P(PermissionRequestManagerTest, MicCameraPtzGrouped) {
395 manager_->AddRequest(web_contents()->GetMainFrame(), &request_mic_);
396 manager_->AddRequest(web_contents()->GetMainFrame(), &request_camera_);
397 manager_->AddRequest(web_contents()->GetMainFrame(), &request_ptz_);
398 WaitForBubbleToBeShown();
400 EXPECT_TRUE(prompt_factory_->is_visible());
401 ASSERT_EQ(prompt_factory_->request_count(), 3);
404 EXPECT_TRUE(request_mic_.granted());
405 EXPECT_TRUE(request_camera_.granted());
406 EXPECT_TRUE(request_ptz_.granted());
409 // If mic/camera/ptz requests come from different origins, they should not be
411 TEST_P(PermissionRequestManagerTest, MicCameraPtzDifferentOrigins) {
412 manager_->AddRequest(web_contents()->GetMainFrame(),
413 &iframe_request_mic_other_domain_);
414 manager_->AddRequest(web_contents()->GetMainFrame(), &request_camera_);
415 manager_->AddRequest(web_contents()->GetMainFrame(), &request_ptz_);
416 WaitForBubbleToBeShown();
418 // Requests should be split into two groups and each one will contain less
419 // than 3 requests (1 request + 2 request for current logic and 2 requests + 1
420 // request for chip).
421 EXPECT_TRUE(prompt_factory_->is_visible());
422 ASSERT_LT(prompt_factory_->request_count(), 3);
425 EXPECT_TRUE(prompt_factory_->is_visible());
426 ASSERT_LT(prompt_factory_->request_count(), 3);
428 #endif // !defined(OS_ANDROID)
430 // Tests mix of grouped media requests and non-groupable request.
431 TEST_P(PermissionRequestManagerTest, MixOfMediaAndNotMediaRequests) {
432 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
433 manager_->AddRequest(web_contents()->GetMainFrame(), &request_camera_);
434 manager_->AddRequest(web_contents()->GetMainFrame(), &request_mic_);
435 WaitForBubbleToBeShown();
437 // Requests should be split into two groups and each one will contain less
438 // than 3 requests (1 request + 2 request for current logic and 2 requests + 1
439 // request for chip).
440 EXPECT_TRUE(prompt_factory_->is_visible());
441 ASSERT_LT(prompt_factory_->request_count(), 3);
443 WaitForBubbleToBeShown();
445 EXPECT_TRUE(prompt_factory_->is_visible());
446 ASSERT_LT(prompt_factory_->request_count(), 3);
450 ////////////////////////////////////////////////////////////////////////////////
452 ////////////////////////////////////////////////////////////////////////////////
454 TEST_P(PermissionRequestManagerTest, TwoRequestsTabSwitch) {
455 manager_->AddRequest(web_contents()->GetMainFrame(), &request_mic_);
456 manager_->AddRequest(web_contents()->GetMainFrame(), &request_camera_);
457 WaitForBubbleToBeShown();
459 EXPECT_TRUE(prompt_factory_->is_visible());
460 ASSERT_EQ(prompt_factory_->request_count(), 2);
463 #if defined(OS_ANDROID)
464 EXPECT_TRUE(prompt_factory_->is_visible());
466 EXPECT_FALSE(prompt_factory_->is_visible());
470 WaitForBubbleToBeShown();
471 EXPECT_TRUE(prompt_factory_->is_visible());
472 ASSERT_EQ(prompt_factory_->request_count(), 2);
475 EXPECT_TRUE(request_mic_.granted());
476 EXPECT_TRUE(request_camera_.granted());
479 TEST_P(PermissionRequestManagerTest, PermissionRequestWhileTabSwitchedAway) {
481 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
482 WaitForBubbleToBeShown();
483 EXPECT_FALSE(prompt_factory_->is_visible());
486 WaitForBubbleToBeShown();
487 EXPECT_TRUE(prompt_factory_->is_visible());
490 ////////////////////////////////////////////////////////////////////////////////
491 // Duplicated requests
492 ////////////////////////////////////////////////////////////////////////////////
494 TEST_P(PermissionRequestManagerTest, SameRequestRejected) {
495 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
496 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
497 EXPECT_FALSE(request1_.finished());
499 WaitForBubbleToBeShown();
500 EXPECT_TRUE(prompt_factory_->is_visible());
501 ASSERT_EQ(prompt_factory_->request_count(), 1);
503 base::RunLoop().RunUntilIdle();
504 EXPECT_TRUE(request1_.granted());
505 EXPECT_FALSE(prompt_factory_->is_visible());
508 TEST_P(PermissionRequestManagerTest, DuplicateRequest) {
509 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
510 WaitForBubbleToBeShown();
511 manager_->AddRequest(web_contents()->GetMainFrame(), &request2_);
513 auto dupe_request = request1_.CreateDuplicateRequest();
514 manager_->AddRequest(web_contents()->GetMainFrame(), dupe_request.get());
515 EXPECT_FALSE(dupe_request->finished());
516 EXPECT_FALSE(request1_.finished());
518 auto dupe_request2 = request2_.CreateDuplicateRequest();
519 manager_->AddRequest(web_contents()->GetMainFrame(), dupe_request2.get());
520 EXPECT_FALSE(dupe_request2->finished());
521 EXPECT_FALSE(request2_.finished());
523 WaitForBubbleToBeShown();
526 EXPECT_TRUE(dupe_request2->finished());
527 EXPECT_TRUE(request2_.finished());
529 EXPECT_TRUE(dupe_request->finished());
530 EXPECT_TRUE(request1_.finished());
533 WaitForBubbleToBeShown();
536 EXPECT_TRUE(dupe_request->finished());
537 EXPECT_TRUE(request1_.finished());
539 EXPECT_TRUE(dupe_request2->finished());
540 EXPECT_TRUE(request2_.finished());
544 ////////////////////////////////////////////////////////////////////////////////
545 // Requests from iframes
546 ////////////////////////////////////////////////////////////////////////////////
548 TEST_P(PermissionRequestManagerTest, MainFrameNoRequestIFrameRequest) {
549 manager_->AddRequest(web_contents()->GetMainFrame(),
550 &iframe_request_same_domain_);
551 WaitForBubbleToBeShown();
554 EXPECT_TRUE(prompt_factory_->is_visible());
556 EXPECT_TRUE(iframe_request_same_domain_.finished());
559 TEST_P(PermissionRequestManagerTest, MainFrameAndIFrameRequestSameDomain) {
560 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
561 manager_->AddRequest(web_contents()->GetMainFrame(),
562 &iframe_request_same_domain_);
564 WaitForBubbleToBeShown();
566 EXPECT_TRUE(prompt_factory_->is_visible());
567 ASSERT_EQ(1, prompt_factory_->request_count());
570 EXPECT_TRUE(iframe_request_same_domain_.finished());
571 EXPECT_FALSE(request1_.finished());
573 EXPECT_TRUE(request1_.finished());
574 EXPECT_FALSE(iframe_request_same_domain_.finished());
577 WaitForBubbleToBeShown();
578 EXPECT_TRUE(prompt_factory_->is_visible());
579 ASSERT_EQ(1, prompt_factory_->request_count());
582 EXPECT_FALSE(prompt_factory_->is_visible());
584 EXPECT_TRUE(request1_.finished());
586 EXPECT_TRUE(iframe_request_same_domain_.finished());
589 TEST_P(PermissionRequestManagerTest, MainFrameAndIFrameRequestOtherDomain) {
590 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
591 manager_->AddRequest(web_contents()->GetMainFrame(),
592 &iframe_request_other_domain_);
594 WaitForBubbleToBeShown();
596 EXPECT_TRUE(prompt_factory_->is_visible());
599 EXPECT_TRUE(iframe_request_other_domain_.finished());
600 EXPECT_FALSE(request1_.finished());
602 EXPECT_TRUE(request1_.finished());
603 EXPECT_FALSE(iframe_request_other_domain_.finished());
606 EXPECT_TRUE(prompt_factory_->is_visible());
608 EXPECT_TRUE(iframe_request_other_domain_.finished());
610 EXPECT_TRUE(request1_.finished());
612 EXPECT_TRUE(iframe_request_other_domain_.finished());
615 TEST_P(PermissionRequestManagerTest, IFrameRequestWhenMainRequestVisible) {
616 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
617 WaitForBubbleToBeShown();
618 EXPECT_TRUE(prompt_factory_->is_visible());
620 manager_->AddRequest(web_contents()->GetMainFrame(),
621 &iframe_request_same_domain_);
623 ASSERT_EQ(prompt_factory_->request_count(), 1);
626 EXPECT_TRUE(iframe_request_same_domain_.finished());
627 EXPECT_FALSE(request1_.finished());
629 EXPECT_TRUE(request1_.finished());
630 EXPECT_FALSE(iframe_request_same_domain_.finished());
633 EXPECT_TRUE(prompt_factory_->is_visible());
634 ASSERT_EQ(prompt_factory_->request_count(), 1);
636 EXPECT_TRUE(iframe_request_same_domain_.finished());
638 EXPECT_TRUE(request1_.finished());
640 EXPECT_TRUE(iframe_request_same_domain_.finished());
643 TEST_P(PermissionRequestManagerTest,
644 IFrameRequestOtherDomainWhenMainRequestVisible) {
645 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
646 WaitForBubbleToBeShown();
647 EXPECT_TRUE(prompt_factory_->is_visible());
649 manager_->AddRequest(web_contents()->GetMainFrame(),
650 &iframe_request_other_domain_);
654 EXPECT_TRUE(iframe_request_other_domain_.finished());
655 EXPECT_FALSE(request1_.finished());
657 EXPECT_TRUE(request1_.finished());
658 EXPECT_FALSE(iframe_request_other_domain_.finished());
661 EXPECT_TRUE(prompt_factory_->is_visible());
664 EXPECT_TRUE(request1_.finished());
666 EXPECT_TRUE(iframe_request_other_domain_.finished());
669 ////////////////////////////////////////////////////////////////////////////////
671 ////////////////////////////////////////////////////////////////////////////////
673 // This code path (calling Accept on a non-merged bubble, with no accepted
674 // permission) would never be used in actual Chrome, but its still tested for
676 TEST_P(PermissionRequestManagerTest, UMAForSimpleDeniedBubbleAlternatePath) {
677 base::HistogramTester histograms;
679 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
680 WaitForBubbleToBeShown();
681 // No need to test UMA for showing prompts again, they were tested in
682 // UMAForSimpleAcceptedBubble.
685 histograms.ExpectUniqueSample(PermissionUmaUtil::kPermissionsPromptDenied,
686 static_cast<base::HistogramBase::Sample>(
687 RequestTypeForUma::PERMISSION_GEOLOCATION),
691 TEST_P(PermissionRequestManagerTest, UMAForTabSwitching) {
692 base::HistogramTester histograms;
694 manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
695 WaitForBubbleToBeShown();
696 histograms.ExpectUniqueSample(PermissionUmaUtil::kPermissionsPromptShown,
697 static_cast<base::HistogramBase::Sample>(
698 RequestTypeForUma::PERMISSION_GEOLOCATION),
703 histograms.ExpectUniqueSample(PermissionUmaUtil::kPermissionsPromptShown,
704 static_cast<base::HistogramBase::Sample>(
705 RequestTypeForUma::PERMISSION_GEOLOCATION),
709 ////////////////////////////////////////////////////////////////////////////////
711 ////////////////////////////////////////////////////////////////////////////////
713 // Simulate a PermissionUiSelector that simply returns a predefined |ui_to_use|
715 class MockNotificationPermissionUiSelector : public PermissionUiSelector {
717 explicit MockNotificationPermissionUiSelector(
718 absl::optional<QuietUiReason> quiet_ui_reason,
719 absl::optional<PermissionUmaUtil::PredictionGrantLikelihood>
720 prediction_likelihood,
722 : quiet_ui_reason_(quiet_ui_reason),
723 prediction_likelihood_(prediction_likelihood),
726 void SelectUiToUse(PermissionRequest* request,
727 DecisionMadeCallback callback) override {
728 Decision decision(quiet_ui_reason_, Decision::ShowNoWarning());
730 base::SequencedTaskRunnerHandle::Get()->PostTask(
731 FROM_HERE, base::BindOnce(std::move(callback), decision));
733 std::move(callback).Run(decision);
737 bool IsPermissionRequestSupported(RequestType request_type) override {
738 return request_type == RequestType::kNotifications ||
739 request_type == RequestType::kGeolocation;
742 absl::optional<PermissionUmaUtil::PredictionGrantLikelihood>
743 PredictedGrantLikelihoodForUKM() override {
744 return prediction_likelihood_;
747 static void CreateForManager(
748 PermissionRequestManager* manager,
749 absl::optional<QuietUiReason> quiet_ui_reason,
751 absl::optional<PermissionUmaUtil::PredictionGrantLikelihood>
752 prediction_likelihood = absl::nullopt) {
753 manager->add_permission_ui_selector_for_testing(
754 std::make_unique<MockNotificationPermissionUiSelector>(
755 quiet_ui_reason, prediction_likelihood, async));
759 absl::optional<QuietUiReason> quiet_ui_reason_;
760 absl::optional<PermissionUmaUtil::PredictionGrantLikelihood>
761 prediction_likelihood_;
765 // Same as the MockNotificationPermissionUiSelector but handling only the
766 // Camera stream request type
767 class MockCameraStreamPermissionUiSelector
768 : public MockNotificationPermissionUiSelector {
770 explicit MockCameraStreamPermissionUiSelector(
771 absl::optional<QuietUiReason> quiet_ui_reason,
772 absl::optional<PermissionUmaUtil::PredictionGrantLikelihood>
773 prediction_likelihood,
775 : MockNotificationPermissionUiSelector(quiet_ui_reason,
776 prediction_likelihood,
779 bool IsPermissionRequestSupported(RequestType request_type) override {
780 return request_type == RequestType::kCameraStream;
783 static void CreateForManager(
784 PermissionRequestManager* manager,
785 absl::optional<QuietUiReason> quiet_ui_reason,
787 absl::optional<PermissionUmaUtil::PredictionGrantLikelihood>
788 prediction_likelihood = absl::nullopt) {
789 manager->add_permission_ui_selector_for_testing(
790 std::make_unique<MockCameraStreamPermissionUiSelector>(
791 quiet_ui_reason, prediction_likelihood, async));
795 TEST_P(PermissionRequestManagerTest,
796 UiSelectorNotUsedForPermissionsOtherThanNotification) {
797 manager_->clear_permission_ui_selector_for_testing();
798 MockNotificationPermissionUiSelector::CreateForManager(
799 manager_, PermissionUiSelector::QuietUiReason::kEnabledInPrefs,
802 manager_->AddRequest(web_contents()->GetMainFrame(), &request_camera_);
803 WaitForBubbleToBeShown();
805 ASSERT_TRUE(prompt_factory_->is_visible());
806 ASSERT_TRUE(prompt_factory_->RequestTypeSeen(request_camera_.request_type()));
807 EXPECT_FALSE(manager_->ShouldCurrentRequestUseQuietUI());
810 EXPECT_TRUE(request_camera_.granted());
813 TEST_P(PermissionRequestManagerTest, UiSelectorUsedForNotifications) {
815 absl::optional<PermissionUiSelector::QuietUiReason> quiet_ui_reason;
818 {QuietUiReason::kEnabledInPrefs, true},
819 {PermissionUiSelector::Decision::UseNormalUi(), true},
820 {QuietUiReason::kEnabledInPrefs, false},
821 {PermissionUiSelector::Decision::UseNormalUi(), false},
824 for (const auto& test : kTests) {
825 manager_->clear_permission_ui_selector_for_testing();
826 MockNotificationPermissionUiSelector::CreateForManager(
827 manager_, test.quiet_ui_reason, test.async);
829 MockPermissionRequest request(RequestType::kNotifications,
830 PermissionRequestGestureType::GESTURE);
832 manager_->AddRequest(web_contents()->GetMainFrame(), &request);
833 WaitForBubbleToBeShown();
835 EXPECT_TRUE(prompt_factory_->is_visible());
836 EXPECT_TRUE(prompt_factory_->RequestTypeSeen(request.request_type()));
837 EXPECT_EQ(!!test.quiet_ui_reason,
838 manager_->ShouldCurrentRequestUseQuietUI());
841 EXPECT_TRUE(request.granted());
845 TEST_P(PermissionRequestManagerTest,
846 UiSelectionHappensSeparatelyForEachRequest) {
847 manager_->clear_permission_ui_selector_for_testing();
848 MockNotificationPermissionUiSelector::CreateForManager(
849 manager_, QuietUiReason::kEnabledInPrefs, true);
850 MockPermissionRequest request1(RequestType::kNotifications,
851 PermissionRequestGestureType::GESTURE);
852 manager_->AddRequest(web_contents()->GetMainFrame(), &request1);
853 WaitForBubbleToBeShown();
854 EXPECT_TRUE(manager_->ShouldCurrentRequestUseQuietUI());
857 MockPermissionRequest request2(RequestType::kNotifications,
858 PermissionRequestGestureType::GESTURE);
859 manager_->clear_permission_ui_selector_for_testing();
860 MockNotificationPermissionUiSelector::CreateForManager(
861 manager_, PermissionUiSelector::Decision::UseNormalUi(), true);
862 manager_->AddRequest(web_contents()->GetMainFrame(), &request2);
863 WaitForBubbleToBeShown();
864 EXPECT_FALSE(manager_->ShouldCurrentRequestUseQuietUI());
868 TEST_P(PermissionRequestManagerTest, MultipleUiSelectors) {
871 std::vector<absl::optional<QuietUiReason>> quiet_ui_reasons;
872 std::vector<bool> simulate_delayed_decision;
873 absl::optional<QuietUiReason> expected_reason;
875 // Simple sync selectors, first one should take priority.
876 {{QuietUiReason::kTriggeredByCrowdDeny, QuietUiReason::kEnabledInPrefs},
878 QuietUiReason::kTriggeredByCrowdDeny},
879 // First selector is async but should still take priority even if it
881 {{QuietUiReason::kTriggeredByCrowdDeny, QuietUiReason::kEnabledInPrefs},
883 QuietUiReason::kTriggeredByCrowdDeny},
884 // The first selector that has a quiet ui decision should be used.
885 {{absl::nullopt, absl::nullopt,
886 QuietUiReason::kTriggeredDueToAbusiveContent,
887 QuietUiReason::kEnabledInPrefs},
888 {false, true, true, false},
889 QuietUiReason::kTriggeredDueToAbusiveContent},
890 // If all selectors return a normal ui, it should use a normal ui.
891 {{absl::nullopt, absl::nullopt}, {false, true}, absl::nullopt},
893 // Use a bunch of selectors both async and sync.
894 {{absl::nullopt, absl::nullopt, absl::nullopt, absl::nullopt,
895 absl::nullopt, QuietUiReason::kTriggeredDueToAbusiveRequests,
896 absl::nullopt, QuietUiReason::kEnabledInPrefs},
897 {false, true, false, true, true, true, false, false},
898 QuietUiReason::kTriggeredDueToAbusiveRequests},
899 // Use a bunch of selectors all sync.
900 {{absl::nullopt, absl::nullopt, absl::nullopt, absl::nullopt,
901 absl::nullopt, QuietUiReason::kTriggeredDueToAbusiveRequests,
902 absl::nullopt, QuietUiReason::kEnabledInPrefs},
903 {false, false, false, false, false, false, false, false},
904 QuietUiReason::kTriggeredDueToAbusiveRequests},
905 // Use a bunch of selectors all async.
906 {{absl::nullopt, absl::nullopt, absl::nullopt, absl::nullopt,
907 absl::nullopt, QuietUiReason::kTriggeredDueToAbusiveRequests,
908 absl::nullopt, QuietUiReason::kEnabledInPrefs},
909 {true, true, true, true, true, true, true, true},
910 QuietUiReason::kTriggeredDueToAbusiveRequests},
913 for (const auto& test : kTests) {
914 manager_->clear_permission_ui_selector_for_testing();
915 for (size_t i = 0; i < test.quiet_ui_reasons.size(); ++i) {
916 MockNotificationPermissionUiSelector::CreateForManager(
917 manager_, test.quiet_ui_reasons[i],
918 test.simulate_delayed_decision[i]);
921 MockPermissionRequest request(RequestType::kNotifications,
922 PermissionRequestGestureType::GESTURE);
924 manager_->AddRequest(web_contents()->GetMainFrame(), &request);
925 WaitForBubbleToBeShown();
927 EXPECT_TRUE(prompt_factory_->is_visible());
928 EXPECT_TRUE(prompt_factory_->RequestTypeSeen(request.request_type()));
929 if (test.expected_reason.has_value()) {
930 EXPECT_EQ(test.expected_reason, manager_->ReasonForUsingQuietUi());
932 EXPECT_FALSE(manager_->ShouldCurrentRequestUseQuietUI());
936 EXPECT_TRUE(request.granted());
940 TEST_P(PermissionRequestManagerTest, SelectorsPredictionLikelihood) {
941 using PredictionLikelihood = PermissionUmaUtil::PredictionGrantLikelihood;
942 const auto VeryLikely = PredictionLikelihood::
943 PermissionPrediction_Likelihood_DiscretizedLikelihood_VERY_LIKELY;
944 const auto Neutral = PredictionLikelihood::
945 PermissionPrediction_Likelihood_DiscretizedLikelihood_NEUTRAL;
948 std::vector<bool> enable_quiet_uis;
949 std::vector<absl::optional<PredictionLikelihood>> prediction_likelihoods;
950 absl::optional<PredictionLikelihood> expected_prediction_likelihood;
952 // Sanity check: prediction likelihood is populated correctly.
953 {{true}, {VeryLikely}, VeryLikely},
954 {{false}, {Neutral}, Neutral},
956 // Prediction likelihood is populated only if the selector was considered.
957 {{true, true}, {absl::nullopt, VeryLikely}, absl::nullopt},
958 {{false, true}, {absl::nullopt, VeryLikely}, VeryLikely},
959 {{false, false}, {absl::nullopt, VeryLikely}, VeryLikely},
961 // First considered selector is preserved.
962 {{true, true}, {Neutral, VeryLikely}, Neutral},
963 {{false, true}, {Neutral, VeryLikely}, Neutral},
964 {{false, false}, {Neutral, VeryLikely}, Neutral},
967 for (const auto& test : kTests) {
968 manager_->clear_permission_ui_selector_for_testing();
969 for (size_t i = 0; i < test.enable_quiet_uis.size(); ++i) {
970 MockNotificationPermissionUiSelector::CreateForManager(
972 test.enable_quiet_uis[i]
973 ? absl::optional<QuietUiReason>(QuietUiReason::kEnabledInPrefs)
975 false /* async */, test.prediction_likelihoods[i]);
978 MockPermissionRequest request(RequestType::kNotifications,
979 PermissionRequestGestureType::GESTURE);
981 manager_->AddRequest(web_contents()->GetMainFrame(), &request);
982 WaitForBubbleToBeShown();
984 EXPECT_TRUE(prompt_factory_->is_visible());
985 EXPECT_TRUE(prompt_factory_->RequestTypeSeen(request.request_type()));
986 EXPECT_EQ(test.expected_prediction_likelihood,
987 manager_->prediction_grant_likelihood_for_testing());
990 EXPECT_TRUE(request.granted());
994 TEST_P(PermissionRequestManagerTest, SelectorRequestTypes) {
996 RequestType request_type;
997 bool should_request_use_quiet_ui;
999 {RequestType::kNotifications, true},
1000 {RequestType::kGeolocation, true},
1001 {RequestType::kCameraStream, false},
1003 manager_->clear_permission_ui_selector_for_testing();
1004 MockNotificationPermissionUiSelector::CreateForManager(
1005 manager_, QuietUiReason::kEnabledInPrefs, true);
1006 for (const auto& test : kTests) {
1007 MockPermissionRequest request(test.request_type,
1008 PermissionRequestGestureType::GESTURE);
1009 manager_->AddRequest(web_contents()->GetMainFrame(), &request);
1010 WaitForBubbleToBeShown();
1011 EXPECT_EQ(test.should_request_use_quiet_ui,
1012 manager_->ShouldCurrentRequestUseQuietUI());
1015 // Adding a mock PermissionUiSelector that handles Camera stream.
1016 MockCameraStreamPermissionUiSelector::CreateForManager(
1017 manager_, QuietUiReason::kEnabledInPrefs, true);
1018 // Now the RequestType::kCameraStream should show a quiet UI as well
1019 MockPermissionRequest request2(RequestType::kCameraStream,
1020 PermissionRequestGestureType::GESTURE);
1021 manager_->AddRequest(web_contents()->GetMainFrame(), &request2);
1022 WaitForBubbleToBeShown();
1023 EXPECT_TRUE(manager_->ShouldCurrentRequestUseQuietUI());
1027 ////////////////////////////////////////////////////////////////////////////////
1028 // Quiet UI chip. Low priority for Notifications & Geolocation.
1029 ////////////////////////////////////////////////////////////////////////////////
1031 TEST_P(PermissionRequestManagerTest, NotificationsSingleBubbleAndChipRequest) {
1032 MockPermissionRequest request(RequestType::kNotifications,
1033 PermissionRequestGestureType::GESTURE);
1035 manager_->AddRequest(web_contents()->GetMainFrame(), &request);
1036 WaitForBubbleToBeShown();
1038 EXPECT_TRUE(prompt_factory_->is_visible());
1039 ASSERT_EQ(prompt_factory_->request_count(), 1);
1042 EXPECT_TRUE(request.granted());
1043 EXPECT_EQ(prompt_factory_->show_count(), 1);
1046 // Quiet UI feature is disabled. Chip is disabled. No low priority requests, the
1047 // first request is always shown.
1049 // Permissions requested in order:
1050 // 1. Notification (non abusive)
1054 // Prompt display order:
1055 // 1. Notification request shown
1056 // 2. Geolocation request shown
1057 // 3. Camera request shown
1058 TEST_P(PermissionRequestManagerTest,
1059 NotificationsGeolocationCameraBubbleRequest) {
1060 // permissions::features::kPermissionChip is enabled based on `GetParam()`.
1061 // That test is only for the default bubble.
1065 std::unique_ptr<MockPermissionRequest> request_notifications =
1066 CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/true,
1068 std::unique_ptr<MockPermissionRequest> request_geolocation =
1069 CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/false,
1071 std::unique_ptr<MockPermissionRequest> request_camera = CreateAndAddRequest(
1072 RequestType::kCameraStream, /*should_be_seen=*/false, 1);
1074 for (auto* kRequest : {request_notifications.get(), request_geolocation.get(),
1075 request_camera.get()}) {
1076 WaitAndAcceptPromptForRequest(kRequest);
1079 EXPECT_EQ(prompt_factory_->show_count(), 3);
1082 // Quiet UI feature is disabled, no low priority requests, the last request is
1085 // Permissions requested in order:
1086 // 1. Notification (non abusive)
1090 // Prompt display order:
1091 // 1. Notifications request shown but is preempted
1092 // 2. Geolocation request shown but is preempted
1093 // 3. Camera request shown
1094 // 4. Geolocation request shown again
1095 // 5. Notifications request shown again
1096 TEST_P(PermissionRequestManagerTest,
1097 NotificationsGeolocationCameraChipRequest) {
1098 // permissions::features::kPermissionChip is enabled based on `GetParam()`.
1099 // That test is only for the chip UI.
1103 std::unique_ptr<MockPermissionRequest> request_notifications =
1104 CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/true,
1106 std::unique_ptr<MockPermissionRequest> request_geolocation =
1107 CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/true,
1109 std::unique_ptr<MockPermissionRequest> request_camera = CreateAndAddRequest(
1110 RequestType::kCameraStream, /*should_be_seen=*/true, 3);
1112 for (auto* kRequest : {request_camera.get(), request_geolocation.get(),
1113 request_notifications.get()}) {
1114 WaitAndAcceptPromptForRequest(kRequest);
1117 EXPECT_EQ(prompt_factory_->show_count(), 5);
1120 // Quiet UI feature is disabled, no low priority requests, the last request is
1123 // Permissions requested in order:
1125 // 2. Notification (non abusive)
1128 // Prompt display order:
1129 // 1. Camera request shown but is preempted
1130 // 2. Notifications request shown but is preempted
1131 // 3. Geolocation request shown
1132 // 4. Notifications request shown again
1133 // 5. Camera request shown again
1134 TEST_P(PermissionRequestManagerTest,
1135 CameraNotificationsGeolocationChipRequest) {
1136 // permissions::features::kPermissionChip is enabled based on `GetParam()`.
1137 // That test is only for the chip.
1141 std::unique_ptr<MockPermissionRequest> request_camera = CreateAndAddRequest(
1142 RequestType::kCameraStream, /*should_be_seen=*/true, 1);
1143 std::unique_ptr<MockPermissionRequest> request_notifications =
1144 CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/true,
1146 std::unique_ptr<MockPermissionRequest> request_geolocation =
1147 CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/true,
1150 for (auto* kRequest : {request_geolocation.get(), request_notifications.get(),
1151 request_camera.get()}) {
1152 WaitAndAcceptPromptForRequest(kRequest);
1155 EXPECT_EQ(prompt_factory_->show_count(), 5);
1158 class PermissionRequestManagerTestQuietChip
1159 : public PermissionRequestManagerTest {
1161 PermissionRequestManagerTestQuietChip() {
1162 feature_list_.InitWithFeatureState(
1163 permissions::features::kPermissionQuietChip, true);
1167 base::test::ScopedFeatureList feature_list_;
1170 // Verifies that the quiet UI chip is not ignored if another request came in
1171 // less than 8.5 seconds after.
1172 // Permissions requested in order:
1173 // 1. Notification (abusive)
1174 // 2. After less than 8.5 seconds Geolocation
1176 // Prompt display order:
1177 // 1. Notifications request shown but is preempted because of quiet UI.
1178 // 2. Geolocation request shown
1179 // 3. Notifications request shown again
1180 TEST_P(PermissionRequestManagerTestQuietChip,
1181 AbusiveNotificationsGeolocationQuietUIChipRequest) {
1182 MockNotificationPermissionUiSelector::CreateForManager(
1184 PermissionUiSelector::QuietUiReason::kTriggeredDueToAbusiveRequests,
1187 std::unique_ptr<MockPermissionRequest> request_notifications =
1188 CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/true,
1191 // Less then 8.5 seconds.
1192 manager_->set_current_request_first_display_time_for_testing(
1193 base::Time::Now() - base::TimeDelta::FromMilliseconds(5000));
1195 std::unique_ptr<MockPermissionRequest> request_geolocation =
1196 CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/true,
1199 WaitAndAcceptPromptForRequest(request_geolocation.get());
1200 WaitAndAcceptPromptForRequest(request_notifications.get());
1202 EXPECT_EQ(prompt_factory_->show_count(), 3);
1205 // Verifies that the quiet UI chip is ignored if another request came in more
1206 // than 8.5 seconds after.
1208 // Permissions requested in order:
1209 // 1. Notification (abusive)
1210 // 2. After more than 8.5 seconds Geolocation
1212 // Prompt display order:
1213 // 1. Notifications request shown but is preempted because of quiet UI.
1214 // 2. Geolocation request shown
1215 TEST_P(PermissionRequestManagerTestQuietChip,
1216 AbusiveNotificationsShownLongEnough) {
1217 MockNotificationPermissionUiSelector::CreateForManager(
1219 PermissionUiSelector::QuietUiReason::kTriggeredDueToAbusiveRequests,
1222 std::unique_ptr<MockPermissionRequest> request_notifications =
1223 CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/true,
1226 // More then 8.5 seconds.
1227 manager_->set_current_request_first_display_time_for_testing(
1228 base::Time::Now() - base::TimeDelta::FromMilliseconds(9000));
1230 std::unique_ptr<MockPermissionRequest> request_geolocation =
1231 CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/true,
1234 // The second permission was requested after 8.5 second window, the quiet UI
1235 // Notifiations request for an abusive origin is automatically ignored.
1236 EXPECT_FALSE(request_notifications->granted());
1237 EXPECT_TRUE(request_notifications->finished());
1239 WaitAndAcceptPromptForRequest(request_geolocation.get());
1241 EXPECT_EQ(prompt_factory_->show_count(), 2);
1244 // Verifies that the quiet UI chip is not ignored if another request came in
1245 // more than 8.5 seconds after. Verify different requests priority. Camera
1246 // request is shown despite being requested last.
1248 // Permissions requested in order:
1249 // 1. Notification (abusive)
1250 // 2. After less than 8.5 seconds Geolocation
1253 // Prompt display order:
1254 // 1. Notifications request shown but is preempted because of quiet UI.
1255 // 2. Geolocation request shown but is preempted because of low priority.
1256 // 3. Camera request shown
1257 // 4. Geolocation request shown again
1258 // 5. Notifications quiet UI request shown again
1259 TEST_P(PermissionRequestManagerTestQuietChip,
1260 AbusiveNotificationsShownLongEnoughCamera) {
1261 MockNotificationPermissionUiSelector::CreateForManager(
1263 PermissionUiSelector::QuietUiReason::kTriggeredDueToAbusiveRequests,
1266 std::unique_ptr<MockPermissionRequest> request_notifications =
1267 CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/true,
1269 // Less then 8.5 seconds.
1270 manager_->set_current_request_first_display_time_for_testing(
1271 base::Time::Now() - base::TimeDelta::FromMilliseconds(5000));
1273 std::unique_ptr<MockPermissionRequest> request_geolocation =
1274 CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/true,
1276 std::unique_ptr<MockPermissionRequest> request_camera = CreateAndAddRequest(
1277 RequestType::kCameraStream, /*should_be_seen=*/true, 3);
1279 // The second permission was requested in 8.5 second window, the quiet UI
1280 // Notifiations request for an abusive origin is not automatically ignored.
1281 EXPECT_FALSE(request_notifications->granted());
1282 EXPECT_FALSE(request_notifications->finished());
1284 for (auto* kRequest : {request_camera.get(), request_geolocation.get(),
1285 request_notifications.get()}) {
1286 WaitAndAcceptPromptForRequest(kRequest);
1289 EXPECT_EQ(prompt_factory_->show_count(), 5);
1292 // Verifies that the quiet UI chip is not ignored if another request came in
1293 // more than 8.5 seconds after. Verify different requests priority. Camera
1294 // request is not preemted.
1296 // Permissions requested in order:
1298 // 2. Notification (abusive)
1299 // 3. After less than 8.5 seconds Geolocation
1301 // Prompt display order:
1302 // 1. Camera request shown
1303 // 2. Geolocation request shown
1304 // 3. Camera request shown
1305 TEST_P(PermissionRequestManagerTestQuietChip,
1306 CameraAbusiveNotificationsGeolocation) {
1307 MockNotificationPermissionUiSelector::CreateForManager(
1309 PermissionUiSelector::QuietUiReason::kTriggeredDueToAbusiveRequests,
1312 std::unique_ptr<MockPermissionRequest> request_camera = CreateAndAddRequest(
1313 RequestType::kCameraStream, /*should_be_seen=*/true, 1);
1315 // Quiet UI is not shown because Camera has higher priority.
1316 std::unique_ptr<MockPermissionRequest> request_notifications =
1317 CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/false,
1319 // Less then 8.5 seconds.
1320 manager_->set_current_request_first_display_time_for_testing(
1321 base::Time::Now() - base::TimeDelta::FromMilliseconds(5000));
1323 // Geolocation is not shown because Camera has higher priority.
1324 std::unique_ptr<MockPermissionRequest> request_geolocation =
1325 CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/false,
1328 // The second permission after quiet UI was requested in 8.5 second window,
1329 // the quiet UI Notifiations request for an abusive origin is not
1330 // automatically ignored.
1331 EXPECT_FALSE(request_notifications->granted());
1332 EXPECT_FALSE(request_notifications->finished());
1334 for (auto* kRequest : {request_camera.get(), request_geolocation.get(),
1335 request_notifications.get()}) {
1336 WaitAndAcceptPromptForRequest(kRequest);
1339 EXPECT_EQ(prompt_factory_->show_count(), 3);
1342 // Verifies that the quiet UI chip is not ignored if another request came in
1343 // more than 8.5 seconds after. Verify different requests priority. Camera
1344 // request is not preemted.
1346 // Permissions requested in order:
1348 // 2. Notification (abusive)
1349 // 3. After less than 8.5 seconds Geolocation
1352 // Prompt display order:
1353 // 1. Camera request shown
1354 // 2. MIDI request shown (or MIDI and then Camera, the order depends on
1356 // 3. Geolocation request shown
1357 // 4. Notifications request shown
1358 // If Chip is enabled MIDI will replace Camera, hence 5 prompts will be
1359 // shown. Otherwise 4.
1360 TEST_P(PermissionRequestManagerTestQuietChip,
1361 CameraAbusiveNotificationsGeolocationMIDI) {
1362 MockNotificationPermissionUiSelector::CreateForManager(
1364 PermissionUiSelector::QuietUiReason::kTriggeredDueToAbusiveRequests,
1367 std::unique_ptr<MockPermissionRequest> request_camera = CreateAndAddRequest(
1368 RequestType::kCameraStream, /*should_be_seen=*/true, 1);
1370 // Quiet UI is not shown because Camera has higher priority.
1371 std::unique_ptr<MockPermissionRequest> request_notifications =
1372 CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/false,
1374 // Less then 8.5 seconds.
1375 manager_->set_current_request_first_display_time_for_testing(
1376 base::Time::Now() - base::TimeDelta::FromMilliseconds(5000));
1378 // Geolocation is not shown because Camera has higher priority.
1379 std::unique_ptr<MockPermissionRequest> request_geolocation =
1380 CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/false,
1383 std::unique_ptr<MockPermissionRequest> request_midi;
1385 // If Chip is enabled, MIDI should be shown, otherwise MIDI should not be
1388 request_midi = CreateAndAddRequest(RequestType::kMidiSysex,
1389 /*should_be_seen=*/true, 2);
1391 request_midi = CreateAndAddRequest(RequestType::kMidiSysex,
1392 /*should_be_seen=*/false, 1);
1395 // The second permission after quiet UI was requested in 8.5 second window,
1396 // the quiet UI Notifiations request for an abusive origin is not
1397 // automatically ignored.
1398 EXPECT_FALSE(request_notifications->granted());
1399 EXPECT_FALSE(request_notifications->finished());
1401 WaitAndAcceptPromptForRequest(GetParam() ? request_midi.get()
1402 : request_camera.get());
1403 WaitAndAcceptPromptForRequest(GetParam() ? request_camera.get()
1404 : request_midi.get());
1405 WaitAndAcceptPromptForRequest(request_geolocation.get());
1406 WaitAndAcceptPromptForRequest(request_notifications.get());
1408 EXPECT_EQ(prompt_factory_->show_count(), GetParam() ? 5 : 4);
1411 // Verifies that non abusive chip behaves similar to others when Quiet UI Chip
1414 // Permissions requested in order:
1416 // 2. Notification (non abusive)
1417 // 3. After less than 8.5 seconds Geolocation
1420 // Prompt display order:
1421 // 1. Camera request shown
1422 // 2. MIDI request shown (or MIDI and then Camera, the order depends on
1424 // 3. Geolocation request shown
1425 // 4. Notifications request shown
1426 // If Chip is enabled MIDI will replace Camera, hence 5 prompts will be
1427 // shown. Otherwise 4.
1428 TEST_P(PermissionRequestManagerTestQuietChip,
1429 CameraNonAbusiveNotificationsGeolocationMIDI) {
1430 std::unique_ptr<MockPermissionRequest> request_camera = CreateAndAddRequest(
1431 RequestType::kCameraStream, /*should_be_seen=*/true, 1);
1433 // Quiet UI is not shown because Camera has higher priority.
1434 std::unique_ptr<MockPermissionRequest> request_notifications =
1435 CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/false,
1437 // Less then 8.5 seconds.
1438 manager_->set_current_request_first_display_time_for_testing(
1439 base::Time::Now() - base::TimeDelta::FromMilliseconds(5000));
1441 // Geolocation is not shown because Camera has higher priority.
1442 std::unique_ptr<MockPermissionRequest> request_geolocation =
1443 CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/false,
1446 std::unique_ptr<MockPermissionRequest> request_midi;
1448 // If Chip is enabled, MIDI should be shown, otherwise MIDI should not be
1451 request_midi = CreateAndAddRequest(RequestType::kMidiSysex,
1452 /*should_be_seen=*/true, 2);
1454 request_midi = CreateAndAddRequest(RequestType::kMidiSysex,
1455 /*should_be_seen=*/false, 1);
1458 // The second permission after quiet UI was requested in 8.5 second window,
1459 // the quiet UI Notifiations request for an abusive origin is not
1460 // automatically ignored.
1461 EXPECT_FALSE(request_notifications->granted());
1462 EXPECT_FALSE(request_notifications->finished());
1464 WaitAndAcceptPromptForRequest(GetParam() ? request_midi.get()
1465 : request_camera.get());
1466 WaitAndAcceptPromptForRequest(GetParam() ? request_camera.get()
1467 : request_midi.get());
1468 WaitAndAcceptPromptForRequest(request_geolocation.get());
1469 WaitAndAcceptPromptForRequest(request_notifications.get());
1471 EXPECT_EQ(prompt_factory_->show_count(), GetParam() ? 5 : 4);
1474 INSTANTIATE_TEST_SUITE_P(All,
1475 PermissionRequestManagerTest,
1476 ::testing::Values(false, true));
1477 INSTANTIATE_TEST_SUITE_P(All,
1478 PermissionRequestManagerTestQuietChip,
1479 ::testing::Values(false, true));
1481 } // namespace permissions