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   virtual ~MockView() {}
  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   virtual void SetDelegate(Delegate* delegate) override {
  33     delegate_ = delegate;
  34   }
  35
  36   virtual void Show(
  37       const std::vector<PermissionBubbleRequest*>& requests,
  38       const std::vector<bool>& accept_state,
  39       bool customization_state_) override {
  40     shown_ = true;
  41     permission_requests_ = requests;
  42     permission_states_ = accept_state;
  43   }
  44
  45   virtual void Hide() override {
  46     shown_ = false;
  47   }
  48
  49   virtual bool CanAcceptRequestUpdate() override {
  50     return can_accept_updates_;
  51   }
  52
  53   virtual bool IsVisible() override {
  54     return shown_;
  55   }
  56
  57   bool shown_;
  58   bool can_accept_updates_;
  59   Delegate* delegate_;
  60   std::vector<PermissionBubbleRequest*> permission_requests_;
  61   std::vector<bool> permission_states_;
  62 };
  63
  64 }  // namespace
  65
  66 class PermissionBubbleManagerTest : public ChromeRenderViewHostTestHarness {
  67  public:
  68   PermissionBubbleManagerTest()
  69       : ChromeRenderViewHostTestHarness(),
  70         request1_("test1"),
  71         request2_("test2"),
  72         iframe_request_same_domain_("iframe",
  73                                     GURL("http://www.google.com/some/url")),
  74         iframe_request_other_domain_("iframe",
  75                                      GURL("http://www.youtube.com")) {}
  76   virtual ~PermissionBubbleManagerTest() {}
  77
  78   virtual void SetUp() override {
  79     ChromeRenderViewHostTestHarness::SetUp();
  80     SetContents(CreateTestWebContents());
  81     NavigateAndCommit(GURL("http://www.google.com"));
  82
  83     manager_.reset(new PermissionBubbleManager(web_contents()));
  84   }
  85
  86   virtual void TearDown() override {
  87     manager_.reset();
  88     ChromeRenderViewHostTestHarness::TearDown();
  89   }
  90
  91   void ToggleAccept(int index, bool value) {
  92     manager_->ToggleAccept(index, value);
  93   }
  94
  95   void Accept() {
  96     manager_->Accept();
  97   }
  98
  99   void Closing() {
 100     manager_->Closing();
 101   }
 102
 103   void WaitForFrameLoad() {
 104     // PermissionBubbleManager ignores all parameters. Yay?
 105     manager_->DocumentLoadedInFrame(NULL);
 106     base::MessageLoop::current()->RunUntilIdle();
 107   }
 108
 109   void WaitForCoalescing() {
 110     manager_->DocumentOnLoadCompletedInMainFrame();
 111     base::MessageLoop::current()->RunUntilIdle();
 112   }
 113
 114   virtual void NavigationEntryCommitted(
 115       const content::LoadCommittedDetails& details) {
 116     manager_->NavigationEntryCommitted(details);
 117   }
 118
 119  protected:
 120   MockPermissionBubbleRequest request1_;
 121   MockPermissionBubbleRequest request2_;
 122   MockPermissionBubbleRequest iframe_request_same_domain_;
 123   MockPermissionBubbleRequest iframe_request_other_domain_;
 124   MockView view_;
 125   scoped_ptr<PermissionBubbleManager> manager_;
 126 };
 127
 128 TEST_F(PermissionBubbleManagerTest, TestFlag) {
 129   EXPECT_FALSE(PermissionBubbleManager::Enabled());
 130   CommandLine::ForCurrentProcess()->AppendSwitch(
 131       switches::kEnablePermissionsBubbles);
 132   EXPECT_TRUE(PermissionBubbleManager::Enabled());
 133 }
 134
 135 TEST_F(PermissionBubbleManagerTest, SingleRequest) {
 136   manager_->AddRequest(&request1_);
 137   manager_->SetView(&view_);
 138   WaitForCoalescing();
 139
 140   EXPECT_TRUE(view_.delegate_ == manager_.get());
 141   EXPECT_TRUE(view_.shown_);
 142   ASSERT_EQ(static_cast<size_t>(1), view_.permission_requests_.size());
 143   EXPECT_EQ(&request1_, view_.permission_requests_[0]);
 144
 145   ToggleAccept(0, true);
 146   Accept();
 147   EXPECT_TRUE(request1_.granted());
 148 }
 149
 150 TEST_F(PermissionBubbleManagerTest, SingleRequestViewFirst) {
 151   manager_->SetView(&view_);
 152   manager_->AddRequest(&request1_);
 153   WaitForCoalescing();
 154
 155   EXPECT_TRUE(view_.delegate_ == manager_.get());
 156   EXPECT_TRUE(view_.shown_);
 157   ASSERT_EQ(static_cast<size_t>(1), view_.permission_requests_.size());
 158   EXPECT_EQ(&request1_, view_.permission_requests_[0]);
 159
 160   ToggleAccept(0, true);
 161   Accept();
 162   EXPECT_TRUE(request1_.granted());
 163 }
 164
 165 TEST_F(PermissionBubbleManagerTest, TwoRequests) {
 166   manager_->AddRequest(&request1_);
 167   manager_->AddRequest(&request2_);
 168   manager_->SetView(&view_);
 169   WaitForCoalescing();
 170
 171   EXPECT_TRUE(view_.delegate_ == manager_.get());
 172   EXPECT_TRUE(view_.shown_);
 173   ASSERT_EQ(static_cast<size_t>(2), view_.permission_requests_.size());
 174   EXPECT_EQ(&request1_, view_.permission_requests_[0]);
 175   EXPECT_EQ(&request2_, view_.permission_requests_[1]);
 176
 177   ToggleAccept(0, true);
 178   ToggleAccept(1, false);
 179   Accept();
 180   EXPECT_TRUE(request1_.granted());
 181   EXPECT_FALSE(request2_.granted());
 182 }
 183
 184 TEST_F(PermissionBubbleManagerTest, TwoRequestsTabSwitch) {
 185   manager_->AddRequest(&request1_);
 186   manager_->AddRequest(&request2_);
 187   manager_->SetView(&view_);
 188   WaitForCoalescing();
 189
 190   EXPECT_TRUE(view_.delegate_ == manager_.get());
 191   EXPECT_TRUE(view_.shown_);
 192   ASSERT_EQ(static_cast<size_t>(2), view_.permission_requests_.size());
 193   EXPECT_EQ(&request1_, view_.permission_requests_[0]);
 194   EXPECT_EQ(&request2_, view_.permission_requests_[1]);
 195
 196   ToggleAccept(0, true);
 197   ToggleAccept(1, false);
 198
 199   manager_->SetView(NULL);
 200   EXPECT_FALSE(view_.shown_);
 201   EXPECT_TRUE(view_.delegate_ == NULL);
 202   view_.Clear();
 203
 204   manager_->SetView(&view_);
 205   WaitForCoalescing();
 206   EXPECT_TRUE(view_.shown_);
 207   ASSERT_EQ(static_cast<size_t>(2), view_.permission_requests_.size());
 208   EXPECT_EQ(&request1_, view_.permission_requests_[0]);
 209   EXPECT_EQ(&request2_, view_.permission_requests_[1]);
 210   EXPECT_TRUE(view_.permission_states_[0]);
 211   EXPECT_FALSE(view_.permission_states_[1]);
 212
 213   Accept();
 214   EXPECT_TRUE(request1_.granted());
 215   EXPECT_FALSE(request2_.granted());
 216 }
 217
 218 TEST_F(PermissionBubbleManagerTest, NoRequests) {
 219   manager_->SetView(&view_);
 220   WaitForCoalescing();
 221   EXPECT_FALSE(view_.shown_);
 222 }
 223
 224 TEST_F(PermissionBubbleManagerTest, NoView) {
 225   manager_->AddRequest(&request1_);
 226   WaitForCoalescing();
 227   EXPECT_FALSE(view_.shown_);
 228 }
 229
 230 TEST_F(PermissionBubbleManagerTest, TwoRequestsCoalesce) {
 231   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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_->SetView(NULL);
 361   manager_->AddRequest(&request1_);
 362   WaitForCoalescing();
 363
 364   manager_->CancelRequest(&request1_);
 365   EXPECT_TRUE(request1_.finished());
 366   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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   manager_->SetView(&view_);
 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 }