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
16namespace {
17
18class 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
66class 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
128TEST_F(PermissionBubbleManagerTest, TestFlag) {
129  EXPECT_FALSE(PermissionBubbleManager::Enabled());
130  CommandLine::ForCurrentProcess()->AppendSwitch(
131      switches::kEnablePermissionsBubbles);
132  EXPECT_TRUE(PermissionBubbleManager::Enabled());
133}
134
135TEST_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
150TEST_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
165TEST_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
184TEST_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
218TEST_F(PermissionBubbleManagerTest, NoRequests) {
219  manager_->SetView(&view_);
220  WaitForCoalescing();
221  EXPECT_FALSE(view_.shown_);
222}
223
224TEST_F(PermissionBubbleManagerTest, NoView) {
225  manager_->AddRequest(&request1_);
226  WaitForCoalescing();
227  EXPECT_FALSE(view_.shown_);
228}
229
230TEST_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
241TEST_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
251TEST_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
270TEST_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
283TEST_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
302TEST_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
314TEST_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
323TEST_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
340TEST_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
359TEST_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
374TEST_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
385TEST_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
398TEST_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
413TEST_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
424TEST_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
439TEST_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
455TEST_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
473TEST_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
490TEST_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
510TEST_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}
533