components/permissions/permission_request_manager_unittest.cc

   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.
   4
   5 #include <stddef.h>
   6 #include <memory>
   7 #include <string>
   8
   9 #include "base/bind.h"
  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"
  28
  29 namespace permissions {
  30
  31 namespace {
  32 using QuietUiReason = PermissionUiSelector::QuietUiReason;
  33 }
  34
  35 class PermissionRequestManagerTest
  36     : public content::RenderViewHostTestHarness,
  37       public ::testing::WithParamInterface<bool> {
  38  public:
  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),
  51 #endif
  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,
  61                                        GetParam());
  62   }
  63
  64   void SetUp() override {
  65     content::RenderViewHostTestHarness::SetUp();
  66     SetContents(CreateTestWebContents());
  67     NavigateAndCommit(GURL(permissions::MockPermissionRequest::kDefaultOrigin));
  68
  69     PermissionRequestManager::CreateForWebContents(web_contents());
  70     manager_ = PermissionRequestManager::FromWebContents(web_contents());
  71     prompt_factory_ = std::make_unique<MockPermissionPromptFactory>(manager_);
  72   }
  73
  74   void TearDown() override {
  75     prompt_factory_ = nullptr;
  76     content::RenderViewHostTestHarness::TearDown();
  77   }
  78
  79   void Accept() {
  80     manager_->Accept();
  81     base::RunLoop().RunUntilIdle();
  82   }
  83
  84   void Deny() {
  85     manager_->Deny();
  86     base::RunLoop().RunUntilIdle();
  87   }
  88
  89   void Closing() {
  90     manager_->Closing();
  91     base::RunLoop().RunUntilIdle();
  92   }
  93
  94   void WaitForFrameLoad() {
  95     // PermissionRequestManager ignores all parameters. Yay?
  96     manager_->DOMContentLoaded(nullptr);
  97     base::RunLoop().RunUntilIdle();
  98   }
  99
 100   void WaitForBubbleToBeShown() {
 101     manager_->DocumentOnLoadCompletedInMainFrame(main_rfh());
 102     base::RunLoop().RunUntilIdle();
 103   }
 104
 105   void MockTabSwitchAway() {
 106     manager_->OnVisibilityChanged(content::Visibility::HIDDEN);
 107   }
 108
 109   void MockTabSwitchBack() {
 110     manager_->OnVisibilityChanged(content::Visibility::VISIBLE);
 111   }
 112
 113   virtual void NavigationEntryCommitted(
 114       const content::LoadCommittedDetails& details) {
 115     manager_->NavigationEntryCommitted(details);
 116   }
 117
 118   std::unique_ptr<MockPermissionRequest> CreateAndAddRequest(
 119       RequestType type,
 120       bool should_be_seen,
 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));
 129     } else {
 130       EXPECT_FALSE(prompt_factory_->RequestTypeSeen(type));
 131     }
 132     EXPECT_EQ(prompt_factory_->TotalRequestCount(), expected_request_count);
 133
 134     return request;
 135   }
 136
 137   void WaitAndAcceptPromptForRequest(MockPermissionRequest* request) {
 138     WaitForBubbleToBeShown();
 139
 140     EXPECT_FALSE(request->finished());
 141     EXPECT_TRUE(prompt_factory_->is_visible());
 142     ASSERT_EQ(prompt_factory_->request_count(), 1);
 143
 144     Accept();
 145     EXPECT_TRUE(request->granted());
 146   }
 147
 148  protected:
 149   MockPermissionRequest request1_;
 150   MockPermissionRequest request2_;
 151   MockPermissionRequest request_mic_;
 152   MockPermissionRequest request_camera_;
 153 #if !defined(OS_ANDROID)
 154   MockPermissionRequest request_ptz_;
 155 #endif
 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_;
 164 };
 165
 166 ////////////////////////////////////////////////////////////////////////////////
 167 // General
 168 ////////////////////////////////////////////////////////////////////////////////
 169
 170 TEST_P(PermissionRequestManagerTest, NoRequests) {
 171   WaitForBubbleToBeShown();
 172   EXPECT_FALSE(prompt_factory_->is_visible());
 173 }
 174
 175 TEST_P(PermissionRequestManagerTest, SingleRequest) {
 176   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 177   WaitForBubbleToBeShown();
 178
 179   EXPECT_TRUE(prompt_factory_->is_visible());
 180   ASSERT_EQ(prompt_factory_->request_count(), 1);
 181
 182   Accept();
 183   EXPECT_TRUE(request1_.granted());
 184 }
 185
 186 TEST_P(PermissionRequestManagerTest, SequentialRequests) {
 187   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 188   WaitForBubbleToBeShown();
 189   EXPECT_TRUE(prompt_factory_->is_visible());
 190
 191   Accept();
 192   EXPECT_TRUE(request1_.granted());
 193   EXPECT_FALSE(prompt_factory_->is_visible());
 194
 195   manager_->AddRequest(web_contents()->GetMainFrame(), &request2_);
 196   WaitForBubbleToBeShown();
 197   EXPECT_TRUE(prompt_factory_->is_visible());
 198   Accept();
 199   EXPECT_FALSE(prompt_factory_->is_visible());
 200   EXPECT_TRUE(request2_.granted());
 201 }
 202
 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();
 209
 210   EXPECT_TRUE(prompt_factory_->is_visible());
 211   ASSERT_EQ(prompt_factory_->request_count(), 1);
 212
 213   NavigateAndCommit(GURL("http://www2.google.com/"));
 214   WaitForBubbleToBeShown();
 215
 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());
 220 }
 221
 222 TEST_P(PermissionRequestManagerTest, RequestsDontNeedUserGesture) {
 223   WaitForFrameLoad();
 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();
 230
 231   EXPECT_TRUE(prompt_factory_->is_visible());
 232 }
 233
 234 TEST_P(PermissionRequestManagerTest, RequestsNotSupported) {
 235   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 236   WaitForBubbleToBeShown();
 237   Accept();
 238   EXPECT_TRUE(request1_.granted());
 239
 240   manager_->set_web_contents_supports_permission_requests(false);
 241
 242   manager_->AddRequest(web_contents()->GetMainFrame(), &request2_);
 243   EXPECT_TRUE(request2_.cancelled());
 244 }
 245
 246 ////////////////////////////////////////////////////////////////////////////////
 247 // Requests grouping
 248 ////////////////////////////////////////////////////////////////////////////////
 249
 250 // Most requests should never be grouped.
 251 TEST_P(PermissionRequestManagerTest, TwoRequestsUngrouped) {
 252   // Grouping for chip feature is tested in ThreeRequestsStackOrderChip.
 253   if (GetParam())
 254     return;
 255
 256   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 257   manager_->AddRequest(web_contents()->GetMainFrame(), &request2_);
 258
 259   WaitForBubbleToBeShown();
 260   EXPECT_TRUE(prompt_factory_->is_visible());
 261   ASSERT_EQ(prompt_factory_->request_count(), 1);
 262   Accept();
 263   EXPECT_TRUE(request1_.granted());
 264
 265   WaitForBubbleToBeShown();
 266   EXPECT_TRUE(prompt_factory_->is_visible());
 267   ASSERT_EQ(prompt_factory_->request_count(), 1);
 268   Accept();
 269   EXPECT_TRUE(request2_.granted());
 270
 271   ASSERT_EQ(prompt_factory_->show_count(), 2);
 272 }
 273
 274 TEST_P(PermissionRequestManagerTest, ThreeRequestsStackOrderChip) {
 275   if (!GetParam())
 276     return;
 277
 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();
 283
 284   EXPECT_TRUE(prompt_factory_->is_visible());
 285   EXPECT_EQ(prompt_factory_->request_count(), 1);
 286   Accept();
 287   EXPECT_TRUE(request_mic_.granted());
 288   EXPECT_FALSE(request2_.granted());
 289   EXPECT_FALSE(request1_.granted());
 290   WaitForBubbleToBeShown();
 291
 292   EXPECT_TRUE(prompt_factory_->is_visible());
 293   EXPECT_EQ(prompt_factory_->request_count(), 1);
 294   Accept();
 295   EXPECT_TRUE(request2_.granted());
 296   EXPECT_FALSE(request1_.granted());
 297   WaitForBubbleToBeShown();
 298
 299   EXPECT_TRUE(prompt_factory_->is_visible());
 300   EXPECT_EQ(prompt_factory_->request_count(), 1);
 301   Accept();
 302   EXPECT_TRUE(request1_.granted());
 303 }
 304
 305 // Test new permissions order by adding requests one at a time.
 306 TEST_P(PermissionRequestManagerTest, ThreeRequestsOneByOneStackOrderChip) {
 307   if (!GetParam())
 308     return;
 309
 310   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 311   WaitForBubbleToBeShown();
 312
 313   manager_->AddRequest(web_contents()->GetMainFrame(), &request2_);
 314   WaitForBubbleToBeShown();
 315
 316   manager_->AddRequest(web_contents()->GetMainFrame(), &request_mic_);
 317   WaitForBubbleToBeShown();
 318
 319   EXPECT_TRUE(prompt_factory_->is_visible());
 320   EXPECT_EQ(prompt_factory_->request_count(), 1);
 321   Accept();
 322   EXPECT_TRUE(request_mic_.granted());
 323   EXPECT_FALSE(request2_.granted());
 324   EXPECT_FALSE(request1_.granted());
 325   WaitForBubbleToBeShown();
 326
 327   EXPECT_TRUE(prompt_factory_->is_visible());
 328   EXPECT_EQ(prompt_factory_->request_count(), 1);
 329   Accept();
 330   EXPECT_TRUE(request2_.granted());
 331   EXPECT_FALSE(request1_.granted());
 332   WaitForBubbleToBeShown();
 333
 334   EXPECT_TRUE(prompt_factory_->is_visible());
 335   EXPECT_EQ(prompt_factory_->request_count(), 1);
 336   Accept();
 337   EXPECT_TRUE(request1_.granted());
 338 }
 339
 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();
 345
 346   EXPECT_TRUE(prompt_factory_->is_visible());
 347   ASSERT_EQ(prompt_factory_->request_count(), 2);
 348
 349   Accept();
 350   EXPECT_TRUE(request_mic_.granted());
 351   EXPECT_TRUE(request_camera_.granted());
 352 }
 353
 354 // If mic/camera requests come from different origins, they should not be
 355 // grouped.
 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();
 361
 362   EXPECT_TRUE(prompt_factory_->is_visible());
 363   ASSERT_EQ(prompt_factory_->request_count(), 1);
 364 }
 365
 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();
 372
 373   EXPECT_TRUE(prompt_factory_->is_visible());
 374   ASSERT_EQ(prompt_factory_->request_count(), 2);
 375
 376   Accept();
 377   EXPECT_TRUE(request_camera_.granted());
 378   EXPECT_TRUE(request_ptz_.granted());
 379 }
 380
 381 TEST_P(PermissionRequestManagerTest, CameraPtzDifferentOrigins) {
 382   // If camera/ptz requests come from different origins, they should not be
 383   // grouped.
 384   manager_->AddRequest(web_contents()->GetMainFrame(),
 385                        &iframe_request_camera_other_domain_);
 386   manager_->AddRequest(web_contents()->GetMainFrame(), &request_ptz_);
 387   WaitForBubbleToBeShown();
 388
 389   EXPECT_TRUE(prompt_factory_->is_visible());
 390   ASSERT_EQ(prompt_factory_->request_count(), 1);
 391 }
 392
 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();
 399
 400   EXPECT_TRUE(prompt_factory_->is_visible());
 401   ASSERT_EQ(prompt_factory_->request_count(), 3);
 402
 403   Accept();
 404   EXPECT_TRUE(request_mic_.granted());
 405   EXPECT_TRUE(request_camera_.granted());
 406   EXPECT_TRUE(request_ptz_.granted());
 407 }
 408
 409 // If mic/camera/ptz requests come from different origins, they should not be
 410 // grouped.
 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();
 417
 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);
 423   Accept();
 424
 425   EXPECT_TRUE(prompt_factory_->is_visible());
 426   ASSERT_LT(prompt_factory_->request_count(), 3);
 427 }
 428 #endif  // !defined(OS_ANDROID)
 429
 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();
 436
 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);
 442   Accept();
 443   WaitForBubbleToBeShown();
 444
 445   EXPECT_TRUE(prompt_factory_->is_visible());
 446   ASSERT_LT(prompt_factory_->request_count(), 3);
 447   Accept();
 448 }
 449
 450 ////////////////////////////////////////////////////////////////////////////////
 451 // Tab switching
 452 ////////////////////////////////////////////////////////////////////////////////
 453
 454 TEST_P(PermissionRequestManagerTest, TwoRequestsTabSwitch) {
 455   manager_->AddRequest(web_contents()->GetMainFrame(), &request_mic_);
 456   manager_->AddRequest(web_contents()->GetMainFrame(), &request_camera_);
 457   WaitForBubbleToBeShown();
 458
 459   EXPECT_TRUE(prompt_factory_->is_visible());
 460   ASSERT_EQ(prompt_factory_->request_count(), 2);
 461
 462   MockTabSwitchAway();
 463 #if defined(OS_ANDROID)
 464   EXPECT_TRUE(prompt_factory_->is_visible());
 465 #else
 466   EXPECT_FALSE(prompt_factory_->is_visible());
 467 #endif
 468
 469   MockTabSwitchBack();
 470   WaitForBubbleToBeShown();
 471   EXPECT_TRUE(prompt_factory_->is_visible());
 472   ASSERT_EQ(prompt_factory_->request_count(), 2);
 473
 474   Accept();
 475   EXPECT_TRUE(request_mic_.granted());
 476   EXPECT_TRUE(request_camera_.granted());
 477 }
 478
 479 TEST_P(PermissionRequestManagerTest, PermissionRequestWhileTabSwitchedAway) {
 480   MockTabSwitchAway();
 481   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 482   WaitForBubbleToBeShown();
 483   EXPECT_FALSE(prompt_factory_->is_visible());
 484
 485   MockTabSwitchBack();
 486   WaitForBubbleToBeShown();
 487   EXPECT_TRUE(prompt_factory_->is_visible());
 488 }
 489
 490 ////////////////////////////////////////////////////////////////////////////////
 491 // Duplicated requests
 492 ////////////////////////////////////////////////////////////////////////////////
 493
 494 TEST_P(PermissionRequestManagerTest, SameRequestRejected) {
 495   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 496   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 497   EXPECT_FALSE(request1_.finished());
 498
 499   WaitForBubbleToBeShown();
 500   EXPECT_TRUE(prompt_factory_->is_visible());
 501   ASSERT_EQ(prompt_factory_->request_count(), 1);
 502   Accept();
 503   base::RunLoop().RunUntilIdle();
 504   EXPECT_TRUE(request1_.granted());
 505   EXPECT_FALSE(prompt_factory_->is_visible());
 506 }
 507
 508 TEST_P(PermissionRequestManagerTest, DuplicateRequest) {
 509   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 510   WaitForBubbleToBeShown();
 511   manager_->AddRequest(web_contents()->GetMainFrame(), &request2_);
 512
 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());
 517
 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());
 522
 523   WaitForBubbleToBeShown();
 524   Accept();
 525   if (GetParam()) {
 526     EXPECT_TRUE(dupe_request2->finished());
 527     EXPECT_TRUE(request2_.finished());
 528   } else {
 529     EXPECT_TRUE(dupe_request->finished());
 530     EXPECT_TRUE(request1_.finished());
 531   }
 532
 533   WaitForBubbleToBeShown();
 534   Accept();
 535   if (GetParam()) {
 536     EXPECT_TRUE(dupe_request->finished());
 537     EXPECT_TRUE(request1_.finished());
 538   } else {
 539     EXPECT_TRUE(dupe_request2->finished());
 540     EXPECT_TRUE(request2_.finished());
 541   }
 542 }
 543
 544 ////////////////////////////////////////////////////////////////////////////////
 545 // Requests from iframes
 546 ////////////////////////////////////////////////////////////////////////////////
 547
 548 TEST_P(PermissionRequestManagerTest, MainFrameNoRequestIFrameRequest) {
 549   manager_->AddRequest(web_contents()->GetMainFrame(),
 550                        &iframe_request_same_domain_);
 551   WaitForBubbleToBeShown();
 552   WaitForFrameLoad();
 553
 554   EXPECT_TRUE(prompt_factory_->is_visible());
 555   Closing();
 556   EXPECT_TRUE(iframe_request_same_domain_.finished());
 557 }
 558
 559 TEST_P(PermissionRequestManagerTest, MainFrameAndIFrameRequestSameDomain) {
 560   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 561   manager_->AddRequest(web_contents()->GetMainFrame(),
 562                        &iframe_request_same_domain_);
 563   WaitForFrameLoad();
 564   WaitForBubbleToBeShown();
 565
 566   EXPECT_TRUE(prompt_factory_->is_visible());
 567   ASSERT_EQ(1, prompt_factory_->request_count());
 568   Closing();
 569   if (GetParam()) {
 570     EXPECT_TRUE(iframe_request_same_domain_.finished());
 571     EXPECT_FALSE(request1_.finished());
 572   } else {
 573     EXPECT_TRUE(request1_.finished());
 574     EXPECT_FALSE(iframe_request_same_domain_.finished());
 575   }
 576
 577   WaitForBubbleToBeShown();
 578   EXPECT_TRUE(prompt_factory_->is_visible());
 579   ASSERT_EQ(1, prompt_factory_->request_count());
 580
 581   Closing();
 582   EXPECT_FALSE(prompt_factory_->is_visible());
 583   if (GetParam())
 584     EXPECT_TRUE(request1_.finished());
 585   else
 586     EXPECT_TRUE(iframe_request_same_domain_.finished());
 587 }
 588
 589 TEST_P(PermissionRequestManagerTest, MainFrameAndIFrameRequestOtherDomain) {
 590   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 591   manager_->AddRequest(web_contents()->GetMainFrame(),
 592                        &iframe_request_other_domain_);
 593   WaitForFrameLoad();
 594   WaitForBubbleToBeShown();
 595
 596   EXPECT_TRUE(prompt_factory_->is_visible());
 597   Closing();
 598   if (GetParam()) {
 599     EXPECT_TRUE(iframe_request_other_domain_.finished());
 600     EXPECT_FALSE(request1_.finished());
 601   } else {
 602     EXPECT_TRUE(request1_.finished());
 603     EXPECT_FALSE(iframe_request_other_domain_.finished());
 604   }
 605
 606   EXPECT_TRUE(prompt_factory_->is_visible());
 607   Closing();
 608   EXPECT_TRUE(iframe_request_other_domain_.finished());
 609   if (GetParam())
 610     EXPECT_TRUE(request1_.finished());
 611   else
 612     EXPECT_TRUE(iframe_request_other_domain_.finished());
 613 }
 614
 615 TEST_P(PermissionRequestManagerTest, IFrameRequestWhenMainRequestVisible) {
 616   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 617   WaitForBubbleToBeShown();
 618   EXPECT_TRUE(prompt_factory_->is_visible());
 619
 620   manager_->AddRequest(web_contents()->GetMainFrame(),
 621                        &iframe_request_same_domain_);
 622   WaitForFrameLoad();
 623   ASSERT_EQ(prompt_factory_->request_count(), 1);
 624   Closing();
 625   if (GetParam()) {
 626     EXPECT_TRUE(iframe_request_same_domain_.finished());
 627     EXPECT_FALSE(request1_.finished());
 628   } else {
 629     EXPECT_TRUE(request1_.finished());
 630     EXPECT_FALSE(iframe_request_same_domain_.finished());
 631   }
 632
 633   EXPECT_TRUE(prompt_factory_->is_visible());
 634   ASSERT_EQ(prompt_factory_->request_count(), 1);
 635   Closing();
 636   EXPECT_TRUE(iframe_request_same_domain_.finished());
 637   if (GetParam())
 638     EXPECT_TRUE(request1_.finished());
 639   else
 640     EXPECT_TRUE(iframe_request_same_domain_.finished());
 641 }
 642
 643 TEST_P(PermissionRequestManagerTest,
 644        IFrameRequestOtherDomainWhenMainRequestVisible) {
 645   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 646   WaitForBubbleToBeShown();
 647   EXPECT_TRUE(prompt_factory_->is_visible());
 648
 649   manager_->AddRequest(web_contents()->GetMainFrame(),
 650                        &iframe_request_other_domain_);
 651   WaitForFrameLoad();
 652   Closing();
 653   if (GetParam()) {
 654     EXPECT_TRUE(iframe_request_other_domain_.finished());
 655     EXPECT_FALSE(request1_.finished());
 656   } else {
 657     EXPECT_TRUE(request1_.finished());
 658     EXPECT_FALSE(iframe_request_other_domain_.finished());
 659   }
 660
 661   EXPECT_TRUE(prompt_factory_->is_visible());
 662   Closing();
 663   if (GetParam())
 664     EXPECT_TRUE(request1_.finished());
 665   else
 666     EXPECT_TRUE(iframe_request_other_domain_.finished());
 667 }
 668
 669 ////////////////////////////////////////////////////////////////////////////////
 670 // UMA logging
 671 ////////////////////////////////////////////////////////////////////////////////
 672
 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
 675 // completeness.
 676 TEST_P(PermissionRequestManagerTest, UMAForSimpleDeniedBubbleAlternatePath) {
 677   base::HistogramTester histograms;
 678
 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.
 683
 684   Deny();
 685   histograms.ExpectUniqueSample(PermissionUmaUtil::kPermissionsPromptDenied,
 686                                 static_cast<base::HistogramBase::Sample>(
 687                                     RequestTypeForUma::PERMISSION_GEOLOCATION),
 688                                 1);
 689 }
 690
 691 TEST_P(PermissionRequestManagerTest, UMAForTabSwitching) {
 692   base::HistogramTester histograms;
 693
 694   manager_->AddRequest(web_contents()->GetMainFrame(), &request1_);
 695   WaitForBubbleToBeShown();
 696   histograms.ExpectUniqueSample(PermissionUmaUtil::kPermissionsPromptShown,
 697                                 static_cast<base::HistogramBase::Sample>(
 698                                     RequestTypeForUma::PERMISSION_GEOLOCATION),
 699                                 1);
 700
 701   MockTabSwitchAway();
 702   MockTabSwitchBack();
 703   histograms.ExpectUniqueSample(PermissionUmaUtil::kPermissionsPromptShown,
 704                                 static_cast<base::HistogramBase::Sample>(
 705                                     RequestTypeForUma::PERMISSION_GEOLOCATION),
 706                                 1);
 707 }
 708
 709 ////////////////////////////////////////////////////////////////////////////////
 710 // UI selectors
 711 ////////////////////////////////////////////////////////////////////////////////
 712
 713 // Simulate a PermissionUiSelector that simply returns a predefined |ui_to_use|
 714 // every time.
 715 class MockNotificationPermissionUiSelector : public PermissionUiSelector {
 716  public:
 717   explicit MockNotificationPermissionUiSelector(
 718       absl::optional<QuietUiReason> quiet_ui_reason,
 719       absl::optional<PermissionUmaUtil::PredictionGrantLikelihood>
 720           prediction_likelihood,
 721       bool async)
 722       : quiet_ui_reason_(quiet_ui_reason),
 723         prediction_likelihood_(prediction_likelihood),
 724         async_(async) {}
 725
 726   void SelectUiToUse(PermissionRequest* request,
 727                      DecisionMadeCallback callback) override {
 728     Decision decision(quiet_ui_reason_, Decision::ShowNoWarning());
 729     if (async_) {
 730       base::SequencedTaskRunnerHandle::Get()->PostTask(
 731           FROM_HERE, base::BindOnce(std::move(callback), decision));
 732     } else {
 733       std::move(callback).Run(decision);
 734     }
 735   }
 736
 737   bool IsPermissionRequestSupported(RequestType request_type) override {
 738     return request_type == RequestType::kNotifications ||
 739            request_type == RequestType::kGeolocation;
 740   }
 741
 742   absl::optional<PermissionUmaUtil::PredictionGrantLikelihood>
 743   PredictedGrantLikelihoodForUKM() override {
 744     return prediction_likelihood_;
 745   }
 746
 747   static void CreateForManager(
 748       PermissionRequestManager* manager,
 749       absl::optional<QuietUiReason> quiet_ui_reason,
 750       bool async,
 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));
 756   }
 757
 758  private:
 759   absl::optional<QuietUiReason> quiet_ui_reason_;
 760   absl::optional<PermissionUmaUtil::PredictionGrantLikelihood>
 761       prediction_likelihood_;
 762   bool async_;
 763 };
 764
 765 // Same as the MockNotificationPermissionUiSelector but handling only the
 766 // Camera stream request type
 767 class MockCameraStreamPermissionUiSelector
 768     : public MockNotificationPermissionUiSelector {
 769  public:
 770   explicit MockCameraStreamPermissionUiSelector(
 771       absl::optional<QuietUiReason> quiet_ui_reason,
 772       absl::optional<PermissionUmaUtil::PredictionGrantLikelihood>
 773           prediction_likelihood,
 774       bool async)
 775       : MockNotificationPermissionUiSelector(quiet_ui_reason,
 776                                              prediction_likelihood,
 777                                              async) {}
 778
 779   bool IsPermissionRequestSupported(RequestType request_type) override {
 780     return request_type == RequestType::kCameraStream;
 781   }
 782
 783   static void CreateForManager(
 784       PermissionRequestManager* manager,
 785       absl::optional<QuietUiReason> quiet_ui_reason,
 786       bool async,
 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));
 792   }
 793 };
 794
 795 TEST_P(PermissionRequestManagerTest,
 796        UiSelectorNotUsedForPermissionsOtherThanNotification) {
 797   manager_->clear_permission_ui_selector_for_testing();
 798   MockNotificationPermissionUiSelector::CreateForManager(
 799       manager_, PermissionUiSelector::QuietUiReason::kEnabledInPrefs,
 800       false /* async */);
 801
 802   manager_->AddRequest(web_contents()->GetMainFrame(), &request_camera_);
 803   WaitForBubbleToBeShown();
 804
 805   ASSERT_TRUE(prompt_factory_->is_visible());
 806   ASSERT_TRUE(prompt_factory_->RequestTypeSeen(request_camera_.request_type()));
 807   EXPECT_FALSE(manager_->ShouldCurrentRequestUseQuietUI());
 808   Accept();
 809
 810   EXPECT_TRUE(request_camera_.granted());
 811 }
 812
 813 TEST_P(PermissionRequestManagerTest, UiSelectorUsedForNotifications) {
 814   const struct {
 815     absl::optional<PermissionUiSelector::QuietUiReason> quiet_ui_reason;
 816     bool async;
 817   } kTests[] = {
 818       {QuietUiReason::kEnabledInPrefs, true},
 819       {PermissionUiSelector::Decision::UseNormalUi(), true},
 820       {QuietUiReason::kEnabledInPrefs, false},
 821       {PermissionUiSelector::Decision::UseNormalUi(), false},
 822   };
 823
 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);
 828
 829     MockPermissionRequest request(RequestType::kNotifications,
 830                                   PermissionRequestGestureType::GESTURE);
 831
 832     manager_->AddRequest(web_contents()->GetMainFrame(), &request);
 833     WaitForBubbleToBeShown();
 834
 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());
 839     Accept();
 840
 841     EXPECT_TRUE(request.granted());
 842   }
 843 }
 844
 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());
 855   Accept();
 856
 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());
 865   Accept();
 866 }
 867
 868 TEST_P(PermissionRequestManagerTest, MultipleUiSelectors) {
 869
 870   const struct {
 871     std::vector<absl::optional<QuietUiReason>> quiet_ui_reasons;
 872     std::vector<bool> simulate_delayed_decision;
 873     absl::optional<QuietUiReason> expected_reason;
 874   } kTests[] = {
 875       // Simple sync selectors, first one should take priority.
 876       {{QuietUiReason::kTriggeredByCrowdDeny, QuietUiReason::kEnabledInPrefs},
 877        {false, false},
 878        QuietUiReason::kTriggeredByCrowdDeny},
 879       // First selector is async but should still take priority even if it
 880       // returns later.
 881       {{QuietUiReason::kTriggeredByCrowdDeny, QuietUiReason::kEnabledInPrefs},
 882        {true, false},
 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},
 892
 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},
 911   };
 912
 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]);
 919     }
 920
 921     MockPermissionRequest request(RequestType::kNotifications,
 922                                   PermissionRequestGestureType::GESTURE);
 923
 924     manager_->AddRequest(web_contents()->GetMainFrame(), &request);
 925     WaitForBubbleToBeShown();
 926
 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());
 931     } else {
 932       EXPECT_FALSE(manager_->ShouldCurrentRequestUseQuietUI());
 933     }
 934
 935     Accept();
 936     EXPECT_TRUE(request.granted());
 937   }
 938 }
 939
 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;
 946
 947   const struct {
 948     std::vector<bool> enable_quiet_uis;
 949     std::vector<absl::optional<PredictionLikelihood>> prediction_likelihoods;
 950     absl::optional<PredictionLikelihood> expected_prediction_likelihood;
 951   } kTests[] = {
 952       // Sanity check: prediction likelihood is populated correctly.
 953       {{true}, {VeryLikely}, VeryLikely},
 954       {{false}, {Neutral}, Neutral},
 955
 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},
 960
 961       // First considered selector is preserved.
 962       {{true, true}, {Neutral, VeryLikely}, Neutral},
 963       {{false, true}, {Neutral, VeryLikely}, Neutral},
 964       {{false, false}, {Neutral, VeryLikely}, Neutral},
 965   };
 966
 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(
 971           manager_,
 972           test.enable_quiet_uis[i]
 973               ? absl::optional<QuietUiReason>(QuietUiReason::kEnabledInPrefs)
 974               : absl::nullopt,
 975           false /* async */, test.prediction_likelihoods[i]);
 976     }
 977
 978     MockPermissionRequest request(RequestType::kNotifications,
 979                                   PermissionRequestGestureType::GESTURE);
 980
 981     manager_->AddRequest(web_contents()->GetMainFrame(), &request);
 982     WaitForBubbleToBeShown();
 983
 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());
 988
 989     Accept();
 990     EXPECT_TRUE(request.granted());
 991   }
 992 }
 993
 994 TEST_P(PermissionRequestManagerTest, SelectorRequestTypes) {
 995   const struct {
 996     RequestType request_type;
 997     bool should_request_use_quiet_ui;
 998   } kTests[] = {
 999       {RequestType::kNotifications, true},
1000       {RequestType::kGeolocation, true},
1001       {RequestType::kCameraStream, false},
1002   };
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());
1013     Accept();
1014   }
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());
1024   Accept();
1025 }
1026
1027 ////////////////////////////////////////////////////////////////////////////////
1028 // Quiet UI chip. Low priority for Notifications & Geolocation.
1029 ////////////////////////////////////////////////////////////////////////////////
1030
1031 TEST_P(PermissionRequestManagerTest, NotificationsSingleBubbleAndChipRequest) {
1032   MockPermissionRequest request(RequestType::kNotifications,
1033                                 PermissionRequestGestureType::GESTURE);
1034
1035   manager_->AddRequest(web_contents()->GetMainFrame(), &request);
1036   WaitForBubbleToBeShown();
1037
1038   EXPECT_TRUE(prompt_factory_->is_visible());
1039   ASSERT_EQ(prompt_factory_->request_count(), 1);
1040
1041   Accept();
1042   EXPECT_TRUE(request.granted());
1043   EXPECT_EQ(prompt_factory_->show_count(), 1);
1044 }
1045
1046 // Quiet UI feature is disabled. Chip is disabled. No low priority requests, the
1047 // first request is always shown.
1048 //
1049 // Permissions requested in order:
1050 // 1. Notification (non abusive)
1051 // 2. Geolocation
1052 // 3. Camera
1053 //
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.
1062   if (GetParam())
1063     return;
1064
1065   std::unique_ptr<MockPermissionRequest> request_notifications =
1066       CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/true,
1067                           1);
1068   std::unique_ptr<MockPermissionRequest> request_geolocation =
1069       CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/false,
1070                           1);
1071   std::unique_ptr<MockPermissionRequest> request_camera = CreateAndAddRequest(
1072       RequestType::kCameraStream, /*should_be_seen=*/false, 1);
1073
1074   for (auto* kRequest : {request_notifications.get(), request_geolocation.get(),
1075                          request_camera.get()}) {
1076     WaitAndAcceptPromptForRequest(kRequest);
1077   }
1078
1079   EXPECT_EQ(prompt_factory_->show_count(), 3);
1080 }
1081
1082 // Quiet UI feature is disabled, no low priority requests, the last request is
1083 // always shown.
1084 //
1085 // Permissions requested in order:
1086 // 1. Notification (non abusive)
1087 // 2. Geolocation
1088 // 3. Camera
1089 //
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.
1100   if (!GetParam())
1101     return;
1102
1103   std::unique_ptr<MockPermissionRequest> request_notifications =
1104       CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/true,
1105                           1);
1106   std::unique_ptr<MockPermissionRequest> request_geolocation =
1107       CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/true,
1108                           2);
1109   std::unique_ptr<MockPermissionRequest> request_camera = CreateAndAddRequest(
1110       RequestType::kCameraStream, /*should_be_seen=*/true, 3);
1111
1112   for (auto* kRequest : {request_camera.get(), request_geolocation.get(),
1113                          request_notifications.get()}) {
1114     WaitAndAcceptPromptForRequest(kRequest);
1115   }
1116
1117   EXPECT_EQ(prompt_factory_->show_count(), 5);
1118 }
1119
1120 // Quiet UI feature is disabled, no low priority requests, the last request is
1121 // always shown.
1122 //
1123 // Permissions requested in order:
1124 // 1. Camera
1125 // 2. Notification (non abusive)
1126 // 3. Geolocation
1127 //
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.
1138   if (!GetParam())
1139     return;
1140
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,
1145                           2);
1146   std::unique_ptr<MockPermissionRequest> request_geolocation =
1147       CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/true,
1148                           3);
1149
1150   for (auto* kRequest : {request_geolocation.get(), request_notifications.get(),
1151                          request_camera.get()}) {
1152     WaitAndAcceptPromptForRequest(kRequest);
1153   }
1154
1155   EXPECT_EQ(prompt_factory_->show_count(), 5);
1156 }
1157
1158 class PermissionRequestManagerTestQuietChip
1159     : public PermissionRequestManagerTest {
1160  public:
1161   PermissionRequestManagerTestQuietChip() {
1162     feature_list_.InitWithFeatureState(
1163         permissions::features::kPermissionQuietChip, true);
1164   }
1165
1166  private:
1167   base::test::ScopedFeatureList feature_list_;
1168 };
1169
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
1175 //
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(
1183       manager_,
1184       PermissionUiSelector::QuietUiReason::kTriggeredDueToAbusiveRequests,
1185       false /* async */);
1186
1187   std::unique_ptr<MockPermissionRequest> request_notifications =
1188       CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/true,
1189                           1);
1190
1191   // Less then 8.5 seconds.
1192   manager_->set_current_request_first_display_time_for_testing(
1193       base::Time::Now() - base::TimeDelta::FromMilliseconds(5000));
1194
1195   std::unique_ptr<MockPermissionRequest> request_geolocation =
1196       CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/true,
1197                           2);
1198
1199   WaitAndAcceptPromptForRequest(request_geolocation.get());
1200   WaitAndAcceptPromptForRequest(request_notifications.get());
1201
1202   EXPECT_EQ(prompt_factory_->show_count(), 3);
1203 }
1204
1205 // Verifies that the quiet UI chip is ignored if another request came in more
1206 // than 8.5 seconds after.
1207 //
1208 // Permissions requested in order:
1209 // 1. Notification (abusive)
1210 // 2. After more than 8.5 seconds Geolocation
1211 //
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(
1218       manager_,
1219       PermissionUiSelector::QuietUiReason::kTriggeredDueToAbusiveRequests,
1220       false /* async */);
1221
1222   std::unique_ptr<MockPermissionRequest> request_notifications =
1223       CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/true,
1224                           1);
1225
1226   // More then 8.5 seconds.
1227   manager_->set_current_request_first_display_time_for_testing(
1228       base::Time::Now() - base::TimeDelta::FromMilliseconds(9000));
1229
1230   std::unique_ptr<MockPermissionRequest> request_geolocation =
1231       CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/true,
1232                           2);
1233
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());
1238
1239   WaitAndAcceptPromptForRequest(request_geolocation.get());
1240
1241   EXPECT_EQ(prompt_factory_->show_count(), 2);
1242 }
1243
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.
1247 //
1248 // Permissions requested in order:
1249 // 1. Notification (abusive)
1250 // 2. After less than 8.5 seconds Geolocation
1251 // 3. Camera
1252 //
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(
1262       manager_,
1263       PermissionUiSelector::QuietUiReason::kTriggeredDueToAbusiveRequests,
1264       false /* async */);
1265
1266   std::unique_ptr<MockPermissionRequest> request_notifications =
1267       CreateAndAddRequest(RequestType::kNotifications, /*should_be_seen=*/true,
1268                           1);
1269   // Less then 8.5 seconds.
1270   manager_->set_current_request_first_display_time_for_testing(
1271       base::Time::Now() - base::TimeDelta::FromMilliseconds(5000));
1272
1273   std::unique_ptr<MockPermissionRequest> request_geolocation =
1274       CreateAndAddRequest(RequestType::kGeolocation, /*should_be_seen=*/true,
1275                           2);
1276   std::unique_ptr<MockPermissionRequest> request_camera = CreateAndAddRequest(
1277       RequestType::kCameraStream, /*should_be_seen=*/true, 3);
1278
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());
1283
1284   for (auto* kRequest : {request_camera.get(), request_geolocation.get(),
1285                          request_notifications.get()}) {
1286     WaitAndAcceptPromptForRequest(kRequest);
1287   }
1288
1289   EXPECT_EQ(prompt_factory_->show_count(), 5);
1290 }
1291
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.
1295 //
1296 // Permissions requested in order:
1297 // 1. Camera
1298 // 2. Notification (abusive)
1299 // 3. After less than 8.5 seconds Geolocation
1300 //
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(
1308       manager_,
1309       PermissionUiSelector::QuietUiReason::kTriggeredDueToAbusiveRequests,
1310       false /* async */);
1311
1312   std::unique_ptr<MockPermissionRequest> request_camera = CreateAndAddRequest(
1313       RequestType::kCameraStream, /*should_be_seen=*/true, 1);
1314
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,
1318                           1);
1319   // Less then 8.5 seconds.
1320   manager_->set_current_request_first_display_time_for_testing(
1321       base::Time::Now() - base::TimeDelta::FromMilliseconds(5000));
1322
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,
1326                           1);
1327
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());
1333
1334   for (auto* kRequest : {request_camera.get(), request_geolocation.get(),
1335                          request_notifications.get()}) {
1336     WaitAndAcceptPromptForRequest(kRequest);
1337   }
1338
1339   EXPECT_EQ(prompt_factory_->show_count(), 3);
1340 }
1341
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.
1345 //
1346 // Permissions requested in order:
1347 // 1. Camera
1348 // 2. Notification (abusive)
1349 // 3. After less than 8.5 seconds Geolocation
1350 // 4. MIDI
1351 //
1352 // Prompt display order:
1353 // 1. Camera request shown
1354 // 2. MIDI request shown (or MIDI and then Camera, the order depends on
1355 // `GetParam()`)
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(
1363       manager_,
1364       PermissionUiSelector::QuietUiReason::kTriggeredDueToAbusiveRequests,
1365       false /* async */);
1366
1367   std::unique_ptr<MockPermissionRequest> request_camera = CreateAndAddRequest(
1368       RequestType::kCameraStream, /*should_be_seen=*/true, 1);
1369
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,
1373                           1);
1374   // Less then 8.5 seconds.
1375   manager_->set_current_request_first_display_time_for_testing(
1376       base::Time::Now() - base::TimeDelta::FromMilliseconds(5000));
1377
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,
1381                           1);
1382
1383   std::unique_ptr<MockPermissionRequest> request_midi;
1384
1385   // If Chip is enabled, MIDI should be shown, otherwise MIDI should not be
1386   // shown.
1387   if (GetParam()) {
1388     request_midi = CreateAndAddRequest(RequestType::kMidiSysex,
1389                                        /*should_be_seen=*/true, 2);
1390   } else {
1391     request_midi = CreateAndAddRequest(RequestType::kMidiSysex,
1392                                        /*should_be_seen=*/false, 1);
1393   }
1394
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());
1400
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());
1407
1408   EXPECT_EQ(prompt_factory_->show_count(), GetParam() ? 5 : 4);
1409 }
1410
1411 // Verifies that non abusive chip behaves similar to others when Quiet UI Chip
1412 // is enabled.
1413 //
1414 // Permissions requested in order:
1415 // 1. Camera
1416 // 2. Notification (non abusive)
1417 // 3. After less than 8.5 seconds Geolocation
1418 // 4. MIDI
1419 //
1420 // Prompt display order:
1421 // 1. Camera request shown
1422 // 2. MIDI request shown (or MIDI and then Camera, the order depends on
1423 // `GetParam()`)
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);
1432
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,
1436                           1);
1437   // Less then 8.5 seconds.
1438   manager_->set_current_request_first_display_time_for_testing(
1439       base::Time::Now() - base::TimeDelta::FromMilliseconds(5000));
1440
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,
1444                           1);
1445
1446   std::unique_ptr<MockPermissionRequest> request_midi;
1447
1448   // If Chip is enabled, MIDI should be shown, otherwise MIDI should not be
1449   // shown.
1450   if (GetParam()) {
1451     request_midi = CreateAndAddRequest(RequestType::kMidiSysex,
1452                                        /*should_be_seen=*/true, 2);
1453   } else {
1454     request_midi = CreateAndAddRequest(RequestType::kMidiSysex,
1455                                        /*should_be_seen=*/false, 1);
1456   }
1457
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());
1463
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());
1470
1471   EXPECT_EQ(prompt_factory_->show_count(), GetParam() ? 5 : 4);
1472 }
1473
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));
1480
1481 }  // namespace permissions