chrome/browser/ui/website_settings/permission_bubble_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 "base/command_line.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "chrome/browser/ui/website_settings/mock_permission_bubble_request.h"
   9 #include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
  10 #include "chrome/browser/ui/website_settings/permission_bubble_request.h"
  11 #include "chrome/browser/ui/website_settings/permission_bubble_view.h"
  12 #include "chrome/common/chrome_switches.h"
  13 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace {
  17
  18 class MockView : public PermissionBubbleView {
  19  public:
  20   MockView() : shown_(false), can_accept_updates_(true), delegate_(NULL) {}
  21   ~MockView() override {}
  22
  23   static scoped_ptr<PermissionBubbleView> Create(Browser* browser) {
  24     return make_scoped_ptr(new MockView());
  25   }
  26
  27   void Clear() {
  28     shown_ = false;
  29     can_accept_updates_ = true;
  30     delegate_ = NULL;
  31     permission_requests_.clear();
  32     permission_states_.clear();
  33   }
  34
  35   // PermissionBubbleView:
  36   void SetDelegate(Delegate* delegate) override { delegate_ = delegate; }
  37
  38   void Show(const std::vector<PermissionBubbleRequest*>& requests,
  39             const std::vector<bool>& accept_state) override {
  40     shown_ = true;
  41     permission_requests_ = requests;
  42     permission_states_ = accept_state;
  43   }
  44
  45   void Hide() override { shown_ = false; }
  46   bool CanAcceptRequestUpdate() override { return can_accept_updates_; }
  47   bool IsVisible() override { return shown_; }
  48   void UpdateAnchorPosition() override {}
  49   gfx::NativeWindow GetNativeWindow() override { return nullptr; }
  50
  51   bool shown_;
  52   bool can_accept_updates_;
  53   Delegate* delegate_;
  54   std::vector<PermissionBubbleRequest*> permission_requests_;
  55   std::vector<bool> permission_states_;
  56 };
  57
  58 }  // namespace
  59
  60 class PermissionBubbleManagerTest : public ChromeRenderViewHostTestHarness {
  61  public:
  62   PermissionBubbleManagerTest()
  63       : ChromeRenderViewHostTestHarness(),
  64         request1_("test1"),
  65         request2_("test2"),
  66         iframe_request_same_domain_("iframe",
  67                                     GURL("http://www.google.com/some/url")),
  68         iframe_request_other_domain_("iframe",
  69                                      GURL("http://www.youtube.com")) {}
  70   ~PermissionBubbleManagerTest() override {}
  71
  72   void SetUp() override {
  73     ChromeRenderViewHostTestHarness::SetUp();
  74     SetContents(CreateTestWebContents());
  75     NavigateAndCommit(GURL("http://www.google.com"));
  76
  77     manager_.reset(new PermissionBubbleManager(web_contents()));
  78     manager_->view_factory_ = base::Bind(MockView::Create);
  79   }
  80
  81   void TearDown() override {
  82     manager_.reset();
  83     ChromeRenderViewHostTestHarness::TearDown();
  84   }
  85
  86   void ToggleAccept(int index, bool value) {
  87     manager_->ToggleAccept(index, value);
  88   }
  89
  90   void Accept() {
  91     manager_->Accept();
  92   }
  93
  94   void Closing() {
  95     manager_->Closing();
  96   }
  97
  98   void WaitForFrameLoad() {
  99     // PermissionBubbleManager ignores all parameters. Yay?
 100     manager_->DocumentLoadedInFrame(NULL);
 101     base::MessageLoop::current()->RunUntilIdle();
 102   }
 103
 104   void WaitForCoalescing() {
 105     manager_->DocumentOnLoadCompletedInMainFrame();
 106     base::MessageLoop::current()->RunUntilIdle();
 107   }
 108
 109   virtual void NavigationEntryCommitted(
 110       const content::LoadCommittedDetails& details) {
 111     manager_->NavigationEntryCommitted(details);
 112   }
 113
 114  protected:
 115   MockPermissionBubbleRequest request1_;
 116   MockPermissionBubbleRequest request2_;
 117   MockPermissionBubbleRequest iframe_request_same_domain_;
 118   MockPermissionBubbleRequest iframe_request_other_domain_;
 119   scoped_ptr<PermissionBubbleManager> manager_;
 120
 121   MockView* view_() { return static_cast<MockView*>(manager_->view_.get()); }
 122
 123   void ShowBubble() {
 124     // nullptr browser is OK for test.
 125     manager_->DisplayPendingRequests(nullptr);
 126   }
 127 };
 128
 129 TEST_F(PermissionBubbleManagerTest, TestFlag) {
 130   EXPECT_TRUE(PermissionBubbleManager::Enabled());
 131   base::CommandLine::ForCurrentProcess()->AppendSwitch(
 132       switches::kDisablePermissionsBubbles);
 133   EXPECT_FALSE(PermissionBubbleManager::Enabled());
 134 }
 135
 136 TEST_F(PermissionBubbleManagerTest, SingleRequest) {
 137   manager_->AddRequest(&request1_);
 138   ShowBubble();
 139   WaitForCoalescing();
 140
 141   EXPECT_TRUE(view_()->delegate_ == manager_.get());
 142   EXPECT_TRUE(view_()->shown_);
 143   ASSERT_EQ(static_cast<size_t>(1), view_()->permission_requests_.size());
 144   EXPECT_EQ(&request1_, view_()->permission_requests_[0]);
 145
 146   ToggleAccept(0, true);
 147   Accept();
 148   EXPECT_TRUE(request1_.granted());
 149 }
 150
 151 TEST_F(PermissionBubbleManagerTest, SingleRequestViewFirst) {
 152   ShowBubble();
 153   manager_->AddRequest(&request1_);
 154   WaitForCoalescing();
 155
 156   EXPECT_TRUE(view_()->delegate_ == manager_.get());
 157   EXPECT_TRUE(view_()->shown_);
 158   ASSERT_EQ(static_cast<size_t>(1), view_()->permission_requests_.size());
 159   EXPECT_EQ(&request1_, view_()->permission_requests_[0]);
 160
 161   ToggleAccept(0, true);
 162   Accept();
 163   EXPECT_TRUE(request1_.granted());
 164 }
 165
 166 TEST_F(PermissionBubbleManagerTest, TwoRequests) {
 167   manager_->AddRequest(&request1_);
 168   manager_->AddRequest(&request2_);
 169   ShowBubble();
 170   WaitForCoalescing();
 171
 172   EXPECT_TRUE(view_()->delegate_ == manager_.get());
 173   EXPECT_TRUE(view_()->shown_);
 174   ASSERT_EQ(static_cast<size_t>(2), view_()->permission_requests_.size());
 175   EXPECT_EQ(&request1_, view_()->permission_requests_[0]);
 176   EXPECT_EQ(&request2_, view_()->permission_requests_[1]);
 177
 178   ToggleAccept(0, true);
 179   ToggleAccept(1, false);
 180   Accept();
 181   EXPECT_TRUE(request1_.granted());
 182   EXPECT_FALSE(request2_.granted());
 183 }
 184
 185 TEST_F(PermissionBubbleManagerTest, TwoRequestsTabSwitch) {
 186   manager_->AddRequest(&request1_);
 187   manager_->AddRequest(&request2_);
 188   ShowBubble();
 189   WaitForCoalescing();
 190
 191   EXPECT_TRUE(view_()->delegate_ == manager_.get());
 192   EXPECT_TRUE(view_()->shown_);
 193   ASSERT_EQ(static_cast<size_t>(2), view_()->permission_requests_.size());
 194   EXPECT_EQ(&request1_, view_()->permission_requests_[0]);
 195   EXPECT_EQ(&request2_, view_()->permission_requests_[1]);
 196
 197   ToggleAccept(0, true);
 198   ToggleAccept(1, false);
 199
 200   manager_->HideBubble();
 201   EXPECT_FALSE(view_());
 202
 203   ShowBubble();
 204   WaitForCoalescing();
 205   EXPECT_TRUE(view_()->shown_);
 206   ASSERT_EQ(static_cast<size_t>(2), view_()->permission_requests_.size());
 207   EXPECT_EQ(&request1_, view_()->permission_requests_[0]);
 208   EXPECT_EQ(&request2_, view_()->permission_requests_[1]);
 209   EXPECT_TRUE(view_()->permission_states_[0]);
 210   EXPECT_FALSE(view_()->permission_states_[1]);
 211
 212   Accept();
 213   EXPECT_TRUE(request1_.granted());
 214   EXPECT_FALSE(request2_.granted());
 215 }
 216
 217 TEST_F(PermissionBubbleManagerTest, NoRequests) {
 218   ShowBubble();
 219   WaitForCoalescing();
 220   EXPECT_FALSE(view_()->shown_);
 221 }
 222
 223 TEST_F(PermissionBubbleManagerTest, NoView) {
 224   manager_->AddRequest(&request1_);
 225   // Don't display the pending requests.
 226   WaitForCoalescing();
 227   EXPECT_FALSE(view_());
 228 }
 229
 230 TEST_F(PermissionBubbleManagerTest, TwoRequestsCoalesce) {
 231   ShowBubble();
 232   manager_->AddRequest(&request1_);
 233   manager_->AddRequest(&request2_);
 234   EXPECT_FALSE(view_()->shown_);
 235   WaitForCoalescing();
 236
 237   EXPECT_TRUE(view_()->shown_);
 238   EXPECT_EQ(2u, view_()->permission_requests_.size());
 239 }
 240
 241 TEST_F(PermissionBubbleManagerTest, TwoRequestsDoNotCoalesce) {
 242   ShowBubble();
 243   manager_->AddRequest(&request1_);
 244   WaitForCoalescing();
 245   manager_->AddRequest(&request2_);
 246
 247   EXPECT_TRUE(view_()->shown_);
 248   EXPECT_EQ(1u, view_()->permission_requests_.size());
 249 }
 250
 251 TEST_F(PermissionBubbleManagerTest, TwoRequestsShownInTwoBubbles) {
 252   ShowBubble();
 253   manager_->AddRequest(&request1_);
 254   WaitForCoalescing();
 255   manager_->AddRequest(&request2_);
 256
 257   EXPECT_TRUE(view_()->shown_);
 258   ASSERT_EQ(1u, view_()->permission_requests_.size());
 259   EXPECT_EQ(&request1_, view_()->permission_requests_[0]);
 260
 261   view_()->Hide();
 262   Accept();
 263   WaitForCoalescing();
 264
 265   EXPECT_TRUE(view_()->shown_);
 266   ASSERT_EQ(1u, view_()->permission_requests_.size());
 267   EXPECT_EQ(&request2_, view_()->permission_requests_[0]);
 268 }
 269
 270 TEST_F(PermissionBubbleManagerTest, TestAddDuplicateRequest) {
 271   ShowBubble();
 272   manager_->AddRequest(&request1_);
 273   manager_->AddRequest(&request2_);
 274   manager_->AddRequest(&request1_);
 275
 276   WaitForCoalescing();
 277   EXPECT_TRUE(view_()->shown_);
 278   ASSERT_EQ(2u, view_()->permission_requests_.size());
 279   EXPECT_EQ(&request1_, view_()->permission_requests_[0]);
 280   EXPECT_EQ(&request2_, view_()->permission_requests_[1]);
 281 }
 282
 283 TEST_F(PermissionBubbleManagerTest, SequentialRequests) {
 284   ShowBubble();
 285   manager_->AddRequest(&request1_);
 286   WaitForCoalescing();
 287   EXPECT_TRUE(view_()->shown_);
 288
 289   Accept();
 290   EXPECT_TRUE(request1_.granted());
 291
 292   EXPECT_FALSE(view_()->shown_);
 293
 294   manager_->AddRequest(&request2_);
 295   WaitForCoalescing();
 296   EXPECT_TRUE(view_()->shown_);
 297   Accept();
 298   EXPECT_FALSE(view_()->shown_);
 299   EXPECT_TRUE(request2_.granted());
 300 }
 301
 302 TEST_F(PermissionBubbleManagerTest, SameRequestRejected) {
 303   ShowBubble();
 304   manager_->AddRequest(&request1_);
 305   manager_->AddRequest(&request1_);
 306   EXPECT_FALSE(request1_.finished());
 307
 308   WaitForCoalescing();
 309   EXPECT_TRUE(view_()->shown_);
 310   ASSERT_EQ(1u, view_()->permission_requests_.size());
 311   EXPECT_EQ(&request1_, view_()->permission_requests_[0]);
 312 }
 313
 314 TEST_F(PermissionBubbleManagerTest, DuplicateRequestRejected) {
 315   ShowBubble();
 316   manager_->AddRequest(&request1_);
 317   MockPermissionBubbleRequest dupe_request("test1");
 318   manager_->AddRequest(&dupe_request);
 319   EXPECT_TRUE(dupe_request.finished());
 320   EXPECT_FALSE(request1_.finished());
 321 }
 322
 323 TEST_F(PermissionBubbleManagerTest, DuplicateQueuedRequest) {
 324   ShowBubble();
 325   manager_->AddRequest(&request1_);
 326   WaitForCoalescing();
 327   manager_->AddRequest(&request2_);
 328
 329   MockPermissionBubbleRequest dupe_request("test1");
 330   manager_->AddRequest(&dupe_request);
 331   EXPECT_TRUE(dupe_request.finished());
 332   EXPECT_FALSE(request1_.finished());
 333
 334   MockPermissionBubbleRequest dupe_request2("test1");
 335   manager_->AddRequest(&dupe_request2);
 336   EXPECT_TRUE(dupe_request2.finished());
 337   EXPECT_FALSE(request2_.finished());
 338 }
 339
 340 TEST_F(PermissionBubbleManagerTest, ForgetRequestsOnPageNavigation) {
 341   ShowBubble();
 342   manager_->AddRequest(&request1_);
 343   WaitForCoalescing();
 344   manager_->AddRequest(&request2_);
 345   manager_->AddRequest(&iframe_request_other_domain_);
 346
 347   EXPECT_TRUE(view_()->shown_);
 348   ASSERT_EQ(1u, view_()->permission_requests_.size());
 349
 350   NavigateAndCommit(GURL("http://www2.google.com/"));
 351   WaitForCoalescing();
 352
 353   EXPECT_FALSE(view_()->shown_);
 354   EXPECT_TRUE(request1_.finished());
 355   EXPECT_TRUE(request2_.finished());
 356   EXPECT_TRUE(iframe_request_other_domain_.finished());
 357 }
 358
 359 TEST_F(PermissionBubbleManagerTest, TestCancel) {
 360   manager_->HideBubble();
 361   manager_->AddRequest(&request1_);
 362   WaitForCoalescing();
 363
 364   manager_->CancelRequest(&request1_);
 365   EXPECT_TRUE(request1_.finished());
 366   ShowBubble();
 367   EXPECT_FALSE(view_()->shown_);
 368
 369   manager_->AddRequest(&request2_);
 370   WaitForCoalescing();
 371   EXPECT_TRUE(view_()->shown_);
 372 }
 373
 374 TEST_F(PermissionBubbleManagerTest, TestCancelWhileDialogShown) {
 375   ShowBubble();
 376   manager_->AddRequest(&request1_);
 377   WaitForCoalescing();
 378
 379   EXPECT_TRUE(view_()->shown_);
 380   EXPECT_FALSE(request1_.finished());
 381   manager_->CancelRequest(&request1_);
 382   EXPECT_TRUE(request1_.finished());
 383 }
 384
 385 TEST_F(PermissionBubbleManagerTest, TestCancelWhileDialogShownNoUpdate) {
 386   ShowBubble();
 387   view_()->can_accept_updates_ = false;
 388   manager_->AddRequest(&request1_);
 389   WaitForCoalescing();
 390
 391   EXPECT_TRUE(view_()->shown_);
 392   EXPECT_FALSE(request1_.finished());
 393   manager_->CancelRequest(&request1_);
 394   EXPECT_TRUE(request1_.finished());
 395   Closing();
 396 }
 397
 398 TEST_F(PermissionBubbleManagerTest, TestCancelPendingRequest) {
 399   ShowBubble();
 400   manager_->AddRequest(&request1_);
 401   WaitForCoalescing();
 402   manager_->AddRequest(&request2_);
 403
 404   EXPECT_TRUE(view_()->shown_);
 405   EXPECT_EQ(1u, view_()->permission_requests_.size());
 406   manager_->CancelRequest(&request2_);
 407
 408   EXPECT_TRUE(view_()->shown_);
 409   EXPECT_FALSE(request1_.finished());
 410   EXPECT_TRUE(request2_.finished());
 411 }
 412
 413 TEST_F(PermissionBubbleManagerTest, MainFrameNoRequestIFrameRequest) {
 414   ShowBubble();
 415   manager_->AddRequest(&iframe_request_same_domain_);
 416   WaitForCoalescing();
 417   WaitForFrameLoad();
 418
 419   EXPECT_TRUE(view_()->shown_);
 420   Closing();
 421   EXPECT_TRUE(iframe_request_same_domain_.finished());
 422 }
 423
 424 TEST_F(PermissionBubbleManagerTest, MainFrameAndIFrameRequestSameDomain) {
 425   ShowBubble();
 426   manager_->AddRequest(&request1_);
 427   manager_->AddRequest(&iframe_request_same_domain_);
 428   WaitForFrameLoad();
 429   WaitForCoalescing();
 430
 431   EXPECT_TRUE(view_()->shown_);
 432   EXPECT_EQ(2u, view_()->permission_requests_.size());
 433   Closing();
 434   EXPECT_TRUE(request1_.finished());
 435   EXPECT_TRUE(iframe_request_same_domain_.finished());
 436   EXPECT_FALSE(view_()->shown_);
 437 }
 438
 439 TEST_F(PermissionBubbleManagerTest, MainFrameAndIFrameRequestOtherDomain) {
 440   ShowBubble();
 441   manager_->AddRequest(&request1_);
 442   manager_->AddRequest(&iframe_request_other_domain_);
 443   WaitForFrameLoad();
 444   WaitForCoalescing();
 445
 446   EXPECT_TRUE(view_()->shown_);
 447   Closing();
 448   EXPECT_TRUE(request1_.finished());
 449   EXPECT_FALSE(iframe_request_other_domain_.finished());
 450   EXPECT_TRUE(view_()->shown_);
 451   Closing();
 452   EXPECT_TRUE(iframe_request_other_domain_.finished());
 453 }
 454
 455 TEST_F(PermissionBubbleManagerTest, IFrameRequestWhenMainRequestVisible) {
 456   ShowBubble();
 457   manager_->AddRequest(&request1_);
 458   WaitForCoalescing();
 459   EXPECT_TRUE(view_()->shown_);
 460
 461   manager_->AddRequest(&iframe_request_same_domain_);
 462   WaitForFrameLoad();
 463   EXPECT_EQ(1u, view_()->permission_requests_.size());
 464   Closing();
 465   EXPECT_TRUE(request1_.finished());
 466   EXPECT_FALSE(iframe_request_same_domain_.finished());
 467   EXPECT_TRUE(view_()->shown_);
 468   EXPECT_EQ(1u, view_()->permission_requests_.size());
 469   Closing();
 470   EXPECT_TRUE(iframe_request_same_domain_.finished());
 471 }
 472
 473 TEST_F(PermissionBubbleManagerTest,
 474        IFrameRequestOtherDomainWhenMainRequestVisible) {
 475   ShowBubble();
 476   manager_->AddRequest(&request1_);
 477   WaitForCoalescing();
 478   EXPECT_TRUE(view_()->shown_);
 479
 480   manager_->AddRequest(&iframe_request_other_domain_);
 481   WaitForFrameLoad();
 482   Closing();
 483   EXPECT_TRUE(request1_.finished());
 484   EXPECT_FALSE(iframe_request_other_domain_.finished());
 485   EXPECT_TRUE(view_()->shown_);
 486   Closing();
 487   EXPECT_TRUE(iframe_request_other_domain_.finished());
 488 }
 489
 490 TEST_F(PermissionBubbleManagerTest, IFrameUserGestureRequest) {
 491   iframe_request_other_domain_.SetHasUserGesture();
 492   ShowBubble();
 493   manager_->AddRequest(&request1_);
 494   manager_->AddRequest(&iframe_request_other_domain_);
 495   WaitForFrameLoad();
 496   WaitForCoalescing();
 497   manager_->AddRequest(&request2_);
 498
 499   EXPECT_TRUE(view_()->shown_);
 500   Closing();
 501   EXPECT_TRUE(request1_.finished());
 502   EXPECT_FALSE(iframe_request_other_domain_.finished());
 503   EXPECT_FALSE(request2_.finished());
 504   EXPECT_TRUE(view_()->shown_);
 505   Closing();
 506   EXPECT_TRUE(iframe_request_other_domain_.finished());
 507   EXPECT_FALSE(request2_.finished());
 508 }
 509
 510 TEST_F(PermissionBubbleManagerTest, AllUserGestureRequests) {
 511   iframe_request_other_domain_.SetHasUserGesture();
 512   request2_.SetHasUserGesture();
 513   ShowBubble();
 514   manager_->AddRequest(&request1_);
 515   manager_->AddRequest(&iframe_request_other_domain_);
 516   WaitForCoalescing();
 517   WaitForFrameLoad();
 518   manager_->AddRequest(&request2_);
 519
 520   EXPECT_TRUE(view_()->shown_);
 521   Closing();
 522   EXPECT_TRUE(request1_.finished());
 523   EXPECT_FALSE(request2_.finished());
 524   EXPECT_FALSE(iframe_request_other_domain_.finished());
 525   EXPECT_TRUE(view_()->shown_);
 526   Closing();
 527   EXPECT_TRUE(request2_.finished());
 528   EXPECT_FALSE(iframe_request_other_domain_.finished());
 529   Closing();
 530   EXPECT_TRUE(iframe_request_other_domain_.finished());
 531   EXPECT_FALSE(view_()->shown_);
 532 }
 533
 534 TEST_F(PermissionBubbleManagerTest, RequestsWithoutUserGesture) {
 535   manager_->RequireUserGesture(true);
 536   ShowBubble();
 537   WaitForFrameLoad();
 538   WaitForCoalescing();
 539   manager_->AddRequest(&request1_);
 540   manager_->AddRequest(&iframe_request_other_domain_);
 541   manager_->AddRequest(&request2_);
 542   base::MessageLoop::current()->RunUntilIdle();
 543
 544   EXPECT_FALSE(view_()->shown_);
 545 }
 546
 547 TEST_F(PermissionBubbleManagerTest, RequestsWithUserGesture) {
 548   manager_->RequireUserGesture(true);
 549   ShowBubble();
 550   WaitForFrameLoad();
 551   WaitForCoalescing();
 552   request1_.SetHasUserGesture();
 553   manager_->AddRequest(&request1_);
 554   manager_->AddRequest(&iframe_request_other_domain_);
 555   manager_->AddRequest(&request2_);
 556   base::MessageLoop::current()->RunUntilIdle();
 557
 558   EXPECT_TRUE(view_()->shown_);
 559 }
 560
 561 TEST_F(PermissionBubbleManagerTest, RequestsDontNeedUserGesture) {
 562   ShowBubble();
 563   WaitForFrameLoad();
 564   WaitForCoalescing();
 565   manager_->AddRequest(&request1_);
 566   manager_->AddRequest(&iframe_request_other_domain_);
 567   manager_->AddRequest(&request2_);
 568   base::MessageLoop::current()->RunUntilIdle();
 569
 570   EXPECT_TRUE(view_()->shown_);
 571 }