Handles iframe permissions requests separately, in a subsequent bubble.

chrome/browser/ui/website_settings/permission_bubble_manager_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/website_settings/mock_permission_bubble_request.h"
 #include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
 #include "chrome/browser/ui/website_settings/permission_bubble_request.h"
@@ skipping 46 matching lines @@
   std::vector<bool> permission_states_;
 };
 
 }  // namespace
 
 class PermissionBubbleManagerTest : public ChromeRenderViewHostTestHarness {
  public:
   PermissionBubbleManagerTest()
       : ChromeRenderViewHostTestHarness(),
         request1_("test1"),
-        request2_("test2") {}
+        request2_("test2"),
+        iframe_request_same_domain_("iframe",
+                                    GURL("http://www.google.com/some/url")),
+        iframe_request_other_domain_("iframe",
+                                     GURL("http://www.youtube.com")) {}
   virtual ~PermissionBubbleManagerTest() {}
 
   virtual void SetUp() OVERRIDE {
     ChromeRenderViewHostTestHarness::SetUp();
     SetContents(CreateTestWebContents());
+    NavigateAndCommit(GURL("http://www.google.com"));
 
     manager_.reset(new PermissionBubbleManager(web_contents()));
   }
 
   virtual void TearDown() OVERRIDE {
     manager_.reset();
     ChromeRenderViewHostTestHarness::TearDown();
   }
 
   void ToggleAccept(int index, bool value) {
     manager_->ToggleAccept(index, value);
   }
 
   void Accept() {
     manager_->Accept();
   }
 
   void Closing() {
     manager_->Closing();
   }
 
+  void WaitForFrameLoad() {
+    manager_->DocumentLoadedInFrame(0, NULL);
+    base::MessageLoop::current()->RunUntilIdle();
+  }
+
   void WaitForCoalescing() {
     manager_->DocumentOnLoadCompletedInMainFrame();
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   virtual void NavigationEntryCommitted(
       const content::LoadCommittedDetails& details) {
     manager_->NavigationEntryCommitted(details);
   }
 
  protected:
   MockPermissionBubbleRequest request1_;
   MockPermissionBubbleRequest request2_;
+  MockPermissionBubbleRequest iframe_request_same_domain_;
+  MockPermissionBubbleRequest iframe_request_other_domain_;
   MockView view_;
   scoped_ptr<PermissionBubbleManager> manager_;
 };
 
 TEST_F(PermissionBubbleManagerTest, TestFlag) {
   EXPECT_FALSE(PermissionBubbleManager::Enabled());
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnablePermissionsBubbles);
   EXPECT_TRUE(PermissionBubbleManager::Enabled());
 }
@@ skipping 197 matching lines @@
   EXPECT_TRUE(dupe_request.finished());
   EXPECT_FALSE(request1_.finished());
 
   MockPermissionBubbleRequest dupe_request2("test1");
   manager_->AddRequest(&dupe_request2);
   EXPECT_TRUE(dupe_request2.finished());
   EXPECT_FALSE(request2_.finished());
 }
 
 TEST_F(PermissionBubbleManagerTest, ForgetRequestsOnPageNavigation) {
-  NavigateAndCommit(GURL("http://www.google.com/"));
   manager_->SetView(&view_);
   manager_->AddRequest(&request1_);
   WaitForCoalescing();
   manager_->AddRequest(&request2_);
 
   EXPECT_TRUE(view_.shown_);
   ASSERT_EQ(1u, view_.permission_requests_.size());
 
   NavigateAndCommit(GURL("http://www2.google.com/"));
   WaitForCoalescing();
@@ skipping 49 matching lines @@
 
   EXPECT_TRUE(view_.shown_);
   EXPECT_EQ(1u, view_.permission_requests_.size());
   manager_->CancelRequest(&request2_);
 
   EXPECT_TRUE(view_.shown_);
   EXPECT_FALSE(request1_.finished());
   EXPECT_TRUE(request2_.finished());
 }
 
+TEST_F(PermissionBubbleManagerTest, MainFrameNoRequestIFrameRequest) {
+  manager_->SetView(&view_);
+  manager_->AddRequest(&iframe_request_same_domain_);
+  WaitForCoalescing();
+  WaitForFrameLoad();
+
+  EXPECT_TRUE(view_.shown_);
+  Closing();
+  EXPECT_TRUE(iframe_request_same_domain_.finished());
+}
+
+TEST_F(PermissionBubbleManagerTest, MainFrameAndIFrameRequestSameDomain) {
+  manager_->SetView(&view_);
+  manager_->AddRequest(&request1_);
+  manager_->AddRequest(&iframe_request_same_domain_);
+  WaitForFrameLoad();
+  WaitForCoalescing();
+
+  EXPECT_TRUE(view_.shown_);
+  Closing();
+  EXPECT_TRUE(request1_.finished());
+  EXPECT_TRUE(iframe_request_same_domain_.finished());
+  EXPECT_FALSE(view_.shown_);
+}
+
+TEST_F(PermissionBubbleManagerTest, MainFrameAndIFrameRequestOtherDomain) {
+  manager_->SetView(&view_);
+  manager_->AddRequest(&request1_);
+  manager_->AddRequest(&iframe_request_other_domain_);
+  WaitForFrameLoad();
+  WaitForCoalescing();
+
+  EXPECT_TRUE(view_.shown_);
+  Closing();
+  EXPECT_TRUE(request1_.finished());
+  EXPECT_FALSE(iframe_request_other_domain_.finished());
+  EXPECT_TRUE(view_.shown_);
+  Closing();
+  EXPECT_TRUE(iframe_request_other_domain_.finished());
+}
+
+TEST_F(PermissionBubbleManagerTest, IFrameRequestWhenMainRequestVisible) {
+  manager_->SetView(&view_);
+  manager_->AddRequest(&request1_);
+  WaitForCoalescing();
+  EXPECT_TRUE(view_.shown_);
+
+  manager_->AddRequest(&iframe_request_same_domain_);

[Greg Billock, 2014/05/27 20:04:55]

Sorry, one other thing I thought of: we want same-domain iframe requests to
coalesce with the main frame request, right? I don't remember talking about that
specifically, but it seems like it'd be good (the obverse would look weird, but
presumably be pretty uncommon).

Want to modify this test so WaitForCoalescing and WaitForFrameLoad() co-occur
and then we expect view_permission_requests_.size() == 2?

[leng, 2014/05/27 23:03:55]

I made the same assumption - that same-domain iframe requests will coalesce with
the main frame request.  The code currently works like that, though
DocumentOnLoadCompletedInMainFrame() and DocumentLoadedInFrame() will both
schedule a call to show the bubble - they don't wait for each other.

For the tests, I added a view_.permission_requeusts_.size() == 2 check to an
earlier test, where WaitForCoalescing() and WaitForFrameLoad() are contiguous.

[Greg Billock, 2014/05/27 23:07:55]

ok, cool

On 2014/05/27 23:03:55, leng wrote:

+  WaitForFrameLoad();
+  EXPECT_EQ(1u, view_.permission_requests_.size());
+  Closing();
+  EXPECT_TRUE(request1_.finished());
+  EXPECT_FALSE(iframe_request_same_domain_.finished());
+  EXPECT_TRUE(view_.shown_);
+  EXPECT_EQ(1u, view_.permission_requests_.size());
+  Closing();
+  EXPECT_TRUE(iframe_request_same_domain_.finished());
+}
+
+TEST_F(PermissionBubbleManagerTest,
+       IFrameRequestOtherDomainWhenMainRequestVisible) {
+  manager_->SetView(&view_);
+  manager_->AddRequest(&request1_);
+  WaitForCoalescing();
+  EXPECT_TRUE(view_.shown_);
+
+  manager_->AddRequest(&iframe_request_other_domain_);
+  WaitForFrameLoad();
+  Closing();
+  EXPECT_TRUE(request1_.finished());
+  EXPECT_FALSE(iframe_request_other_domain_.finished());
+  EXPECT_TRUE(view_.shown_);
+  Closing();
+  EXPECT_TRUE(iframe_request_other_domain_.finished());
+}
+
+TEST_F(PermissionBubbleManagerTest, IFrameUserGestureRequest) {
+  iframe_request_other_domain_.SetHasUserGesture();
+  manager_->SetView(&view_);
+  manager_->AddRequest(&request1_);
+  manager_->AddRequest(&iframe_request_other_domain_);
+  WaitForFrameLoad();
+  WaitForCoalescing();
+  manager_->AddRequest(&request2_);
+
+  EXPECT_TRUE(view_.shown_);
+  Closing();
+  EXPECT_TRUE(request1_.finished());
+  EXPECT_FALSE(iframe_request_other_domain_.finished());
+  EXPECT_FALSE(request2_.finished());
+  EXPECT_TRUE(view_.shown_);
+  Closing();
+  EXPECT_TRUE(iframe_request_other_domain_.finished());
+  EXPECT_FALSE(request2_.finished());
+}
+
+TEST_F(PermissionBubbleManagerTest, AllUserGestureRequests) {
+  iframe_request_other_domain_.SetHasUserGesture();
+  request2_.SetHasUserGesture();
+  manager_->SetView(&view_);
+  manager_->AddRequest(&request1_);
+  manager_->AddRequest(&iframe_request_other_domain_);
+  WaitForCoalescing();
+  WaitForFrameLoad();
+  manager_->AddRequest(&request2_);
+
+  EXPECT_TRUE(view_.shown_);
+  Closing();
+  EXPECT_TRUE(request1_.finished());
+  EXPECT_FALSE(request2_.finished());
+  EXPECT_FALSE(iframe_request_other_domain_.finished());
+  EXPECT_TRUE(view_.shown_);
+  Closing();
+  EXPECT_TRUE(request2_.finished());
+  EXPECT_FALSE(iframe_request_other_domain_.finished());
+  Closing();
+  EXPECT_TRUE(iframe_request_other_domain_.finished());
+  EXPECT_FALSE(view_.shown_);
+}