Make sure bubbles in Views default to close before their RenderFrameHosts.

components/bubble/bubble_manager_unittest.cc

 // Copyright 2015 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 "components/bubble/bubble_manager.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "components/bubble/bubble_controller.h"
@@ skipping 64 matching lines @@
   MockBubbleManagerObserver() {}
   ~MockBubbleManagerObserver() override {}
 
   MOCK_METHOD1(OnBubbleNeverShown, void(BubbleReference));
   MOCK_METHOD2(OnBubbleClosed, void(BubbleReference, BubbleCloseReason));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBubbleManagerObserver);
 };
 
+class BubbleManagerSubclass : public BubbleManager {
+ public:
+  using BubbleManager::CloseBubblesOwnedBy;
+};
+
 class BubbleManagerTest : public testing::Test {
  public:
   BubbleManagerTest();
   ~BubbleManagerTest() override {}
 
   void SetUp() override;
   void TearDown() override;
 
  protected:
-  scoped_ptr<BubbleManager> manager_;
+  scoped_ptr<BubbleManagerSubclass> manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BubbleManagerTest);
 };
 
 BubbleManagerTest::BubbleManagerTest() {}
 
 void BubbleManagerTest::SetUp() {
   testing::Test::SetUp();
-  manager_.reset(new BubbleManager);
+  manager_.reset(new BubbleManagerSubclass);
 }
 
 void BubbleManagerTest::TearDown() {
   manager_.reset();
   testing::Test::TearDown();
 }
 
 TEST_F(BubbleManagerTest, ManagerShowsBubbleUi) {
   scoped_ptr<MockBubbleDelegate> delegate = MockBubbleDelegate::Default();
 
@@ skipping 132 matching lines @@
   EXPECT_TRUE(ref2);
   EXPECT_TRUE(ref3);
 
   ref2->CloseBubble(BUBBLE_CLOSE_FOCUS_LOST);
 
   EXPECT_TRUE(ref1);
   EXPECT_FALSE(ref2);
   EXPECT_TRUE(ref3);
 }
 
+TEST_F(BubbleManagerTest, CloseOwnedByShouldLeaveUnowned) {
+  scoped_ptr<MockBubbleDelegate> delegate1 = MockBubbleDelegate::Default();
+  scoped_ptr<MockBubbleDelegate> delegate2 = MockBubbleDelegate::Default();
+  scoped_ptr<MockBubbleDelegate> delegate3 = MockBubbleDelegate::Default();
+  MockBubbleDelegate& delegate1_ref = *delegate1;
+  MockBubbleDelegate& delegate2_ref = *delegate2;
+  MockBubbleDelegate& delegate3_ref = *delegate3;
+  BubbleReference ref1 = manager_->ShowBubble(std::move(delegate1));
+  BubbleReference ref2 = manager_->ShowBubble(std::move(delegate2));
+  BubbleReference ref3 = manager_->ShowBubble(std::move(delegate3));
+
+  // These pointers are only compared for equality, not dereferenced.
+  const content::RenderFrameHost* const frame1 =
+      reinterpret_cast<const content::RenderFrameHost*>(&ref1);
+  const content::RenderFrameHost* const frame2 =
+      reinterpret_cast<const content::RenderFrameHost*>(&ref2);
+
+  EXPECT_CALL(delegate1_ref, OwningFrame())
+      .WillRepeatedly(testing::Return(frame1));
+  EXPECT_CALL(delegate2_ref, OwningFrame())
+      .WillRepeatedly(testing::Return(frame2));
+  EXPECT_CALL(delegate3_ref, OwningFrame())
+      .WillRepeatedly(testing::Return(nullptr));
+  EXPECT_CALL(delegate1_ref, ShouldClose(BUBBLE_CLOSE_FRAME_DESTROYED))
+      .WillOnce(testing::Return(true));
+
+  manager_->CloseBubblesOwnedBy(frame1);
+  EXPECT_FALSE(ref1);
+  EXPECT_TRUE(ref2);
+  EXPECT_TRUE(ref3);
+}
+
 TEST_F(BubbleManagerTest, UpdateAllShouldWorkWithoutBubbles) {
   // Manager shouldn't crash if bubbles have never been added.
   manager_->UpdateAllBubbleAnchors();
 
   // Add a bubble and close it.
   BubbleReference ref = manager_->ShowBubble(MockBubbleDelegate::Default());
   ASSERT_TRUE(manager_->CloseBubble(ref, BUBBLE_CLOSE_FORCED));
 
   // Bubble should NOT get an update event because it's already closed.
   manager_->UpdateAllBubbleAnchors();
@@ skipping 133 matching lines @@
   EXPECT_TRUE(other_bubble_ref);
   EXPECT_TRUE(closing_bubble_ref);
 
   closing_bubble_ref->CloseBubble(BUBBLE_CLOSE_ACCEPTED);
 
   EXPECT_TRUE(other_bubble_ref);
   EXPECT_TRUE(closing_bubble_ref);
 }
 
 }  // namespace