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