Add ability for a BubbleReference to update the BubbleUI.

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 "components/bubble/bubble_controller.h"
 #include "components/bubble/bubble_delegate.h"
+#include "components/bubble/bubble_reference.h"
 #include "components/bubble/bubble_ui.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
-class MockBubbleUI : public BubbleUI {
+class MockBubbleUi : public BubbleUi {
  public:
-  MockBubbleUI() {}
-  ~MockBubbleUI() override { Destroyed(); }
+  MockBubbleUi() {}
+  ~MockBubbleUi() override { Destroyed(); }
 
   MOCK_METHOD1(Show, void(BubbleReference));
   MOCK_METHOD0(Close, void());
   MOCK_METHOD0(UpdateAnchorPosition, void());
 
   // To verify destructor call.
   MOCK_METHOD0(Destroyed, void());
 };
 
 class MockBubbleDelegate : public BubbleDelegate {
  public:
   MockBubbleDelegate() {}
   ~MockBubbleDelegate() override { Destroyed(); }
 
   // Default bubble shows UI and closes when asked to close.
   static scoped_ptr<MockBubbleDelegate> Default();
 
   // Stubborn bubble shows UI and doesn't want to close.
   static scoped_ptr<MockBubbleDelegate> Stubborn();
 
   MOCK_METHOD1(ShouldClose, bool(BubbleCloseReason reason));
 
   // A scoped_ptr can't be returned in MOCK_METHOD.
-  MOCK_METHOD0(BuildBubbleUIMock, BubbleUI*());
-  scoped_ptr<BubbleUI> BuildBubbleUI() override {
-    return make_scoped_ptr(BuildBubbleUIMock());
+  MOCK_METHOD0(BuildBubbleUiMock, BubbleUi*());
+  scoped_ptr<BubbleUi> BuildBubbleUi() override {
+    return make_scoped_ptr(BuildBubbleUiMock());
   }
 
+  MOCK_METHOD1(UpdateBubbleUi, bool(BubbleUi*));
+
   // To verify destructor call.
   MOCK_METHOD0(Destroyed, void());
 };
 
 // static
 scoped_ptr<MockBubbleDelegate> MockBubbleDelegate::Default() {
   MockBubbleDelegate* delegate = new MockBubbleDelegate;
-  EXPECT_CALL(*delegate, BuildBubbleUIMock())
-      .WillOnce(testing::Return(new MockBubbleUI));
+  EXPECT_CALL(*delegate, BuildBubbleUiMock())
+      .WillOnce(testing::Return(new MockBubbleUi));
   EXPECT_CALL(*delegate, ShouldClose(testing::_))
       .WillOnce(testing::Return(true));
   return make_scoped_ptr(delegate);
 }
 
 // static
 scoped_ptr<MockBubbleDelegate> MockBubbleDelegate::Stubborn() {
   MockBubbleDelegate* delegate = new MockBubbleDelegate;
-  EXPECT_CALL(*delegate, BuildBubbleUIMock())
-      .WillOnce(testing::Return(new MockBubbleUI));
+  EXPECT_CALL(*delegate, BuildBubbleUiMock())
+      .WillOnce(testing::Return(new MockBubbleUi));
   EXPECT_CALL(*delegate, ShouldClose(testing::_))
       .WillRepeatedly(testing::Return(false));
   return make_scoped_ptr(delegate);
 }
 
 // Helper class used to test chaining another bubble.
 class DelegateChainHelper {
  public:
   DelegateChainHelper(BubbleManager* manager,
                       scoped_ptr<BubbleDelegate> next_delegate);
@@ skipping 31 matching lines @@
 void BubbleManagerTest::SetUp() {
   testing::Test::SetUp();
   manager_.reset(new BubbleManager);
 }
 
 void BubbleManagerTest::TearDown() {
   manager_.reset();
   testing::Test::TearDown();
 }
 
-TEST_F(BubbleManagerTest, ManagerShowsBubbleUI) {
+TEST_F(BubbleManagerTest, ManagerShowsBubbleUi) {
   // Manager will delete bubble_ui.
-  MockBubbleUI* bubble_ui = new MockBubbleUI;
+  MockBubbleUi* bubble_ui = new MockBubbleUi;
   EXPECT_CALL(*bubble_ui, Destroyed());
   EXPECT_CALL(*bubble_ui, Show(testing::_));
   EXPECT_CALL(*bubble_ui, Close());
   EXPECT_CALL(*bubble_ui, UpdateAnchorPosition()).Times(0);
 
   // Manager will delete delegate.
   MockBubbleDelegate* delegate = new MockBubbleDelegate;
   EXPECT_CALL(*delegate, Destroyed());
-  EXPECT_CALL(*delegate, BuildBubbleUIMock())
+  EXPECT_CALL(*delegate, BuildBubbleUiMock())
       .WillOnce(testing::Return(bubble_ui));
   EXPECT_CALL(*delegate, ShouldClose(testing::_))
       .WillOnce(testing::Return(true));
 
   manager_->ShowBubble(make_scoped_ptr(delegate));
 }
 
-TEST_F(BubbleManagerTest, ManagerUpdatesBubbleUI) {
+TEST_F(BubbleManagerTest, ManagerUpdatesBubbleUi) {
   // Manager will delete bubble_ui.
-  MockBubbleUI* bubble_ui = new MockBubbleUI;
+  MockBubbleUi* bubble_ui = new MockBubbleUi;
   EXPECT_CALL(*bubble_ui, Destroyed());
   EXPECT_CALL(*bubble_ui, Show(testing::_));
   EXPECT_CALL(*bubble_ui, Close());
   EXPECT_CALL(*bubble_ui, UpdateAnchorPosition());
 
   // Manager will delete delegate.
   MockBubbleDelegate* delegate = new MockBubbleDelegate;
   EXPECT_CALL(*delegate, Destroyed());
-  EXPECT_CALL(*delegate, BuildBubbleUIMock())
+  EXPECT_CALL(*delegate, BuildBubbleUiMock())
       .WillOnce(testing::Return(bubble_ui));
   EXPECT_CALL(*delegate, ShouldClose(testing::_))
       .WillOnce(testing::Return(true));
 
   manager_->ShowBubble(make_scoped_ptr(delegate));
   manager_->UpdateAllBubbleAnchors();
 }
 
 TEST_F(BubbleManagerTest, CloseOnReferenceInvalidatesReference) {
   BubbleReference ref = manager_->ShowBubble(MockBubbleDelegate::Default());
@@ skipping 122 matching lines @@
   // Bubble should NOT get a close event because it's already closed.
   manager_->CloseAllBubbles(BUBBLE_CLOSE_FOCUS_LOST);
 }
 
 TEST_F(BubbleManagerTest, AllowBubbleChainingOnClose) {
   scoped_ptr<BubbleDelegate> chained_delegate = MockBubbleDelegate::Default();
   DelegateChainHelper chain_helper(manager_.get(), chained_delegate.Pass());
 
   // Manager will delete delegate.
   MockBubbleDelegate* delegate = new MockBubbleDelegate;
-  EXPECT_CALL(*delegate, BuildBubbleUIMock())
-      .WillOnce(testing::Return(new MockBubbleUI));
+  EXPECT_CALL(*delegate, BuildBubbleUiMock())
+      .WillOnce(testing::Return(new MockBubbleUi));
   EXPECT_CALL(*delegate, ShouldClose(testing::_))
       .WillOnce(testing::DoAll(testing::InvokeWithoutArgs(
                                    &chain_helper, &DelegateChainHelper::Chain),
                                testing::Return(true)));
 
   BubbleReference ref = manager_->ShowBubble(make_scoped_ptr(delegate));
   ASSERT_TRUE(manager_->CloseBubble(ref, BUBBLE_CLOSE_FORCED));
 
   ASSERT_TRUE(chain_helper.BubbleWasTaken());
 }
 
 TEST_F(BubbleManagerTest, AllowBubbleChainingOnCloseAll) {
   scoped_ptr<BubbleDelegate> chained_delegate = MockBubbleDelegate::Default();
   DelegateChainHelper chain_helper(manager_.get(), chained_delegate.Pass());
 
   // Manager will delete delegate.
   MockBubbleDelegate* delegate = new MockBubbleDelegate;
-  EXPECT_CALL(*delegate, BuildBubbleUIMock())
-      .WillOnce(testing::Return(new MockBubbleUI));
+  EXPECT_CALL(*delegate, BuildBubbleUiMock())
+      .WillOnce(testing::Return(new MockBubbleUi));
   EXPECT_CALL(*delegate, ShouldClose(testing::_))
       .WillOnce(testing::DoAll(testing::InvokeWithoutArgs(
                                    &chain_helper, &DelegateChainHelper::Chain),
                                testing::Return(true)));
 
   manager_->ShowBubble(make_scoped_ptr(delegate));
   manager_->CloseAllBubbles(BUBBLE_CLOSE_FORCED);
 
   ASSERT_TRUE(chain_helper.BubbleWasTaken());
 }
 
 TEST_F(BubbleManagerTest, BubblesDoNotChainOnDestroy) {
   // Manager will delete delegate.
   MockBubbleDelegate* chained_delegate = new MockBubbleDelegate;
-  EXPECT_CALL(*chained_delegate, BuildBubbleUIMock()).Times(0);
+  EXPECT_CALL(*chained_delegate, BuildBubbleUiMock()).Times(0);
   EXPECT_CALL(*chained_delegate, ShouldClose(testing::_)).Times(0);
 
   DelegateChainHelper chain_helper(manager_.get(),
                                    make_scoped_ptr(chained_delegate));
 
   // Manager will delete delegate.
   MockBubbleDelegate* delegate = new MockBubbleDelegate;
-  EXPECT_CALL(*delegate, BuildBubbleUIMock())
-      .WillOnce(testing::Return(new MockBubbleUI));
+  EXPECT_CALL(*delegate, BuildBubbleUiMock())
+      .WillOnce(testing::Return(new MockBubbleUi));
   EXPECT_CALL(*delegate, ShouldClose(testing::_))
       .WillOnce(testing::DoAll(testing::InvokeWithoutArgs(
                                    &chain_helper, &DelegateChainHelper::Chain),
                                testing::Return(true)));
 
   manager_->ShowBubble(make_scoped_ptr(delegate));
   manager_.reset();
 
   // The manager will take the bubble, but not show it.
   ASSERT_TRUE(chain_helper.BubbleWasTaken());
 }
 
+TEST_F(BubbleManagerTest, BubbleUpdatesTrue) {
+  MockBubbleUi* bubble_ui = new MockBubbleUi;
+  MockBubbleDelegate* delegate = new MockBubbleDelegate;
+  EXPECT_CALL(*delegate, BuildBubbleUiMock())
+      .WillOnce(testing::Return(bubble_ui));
+  EXPECT_CALL(*delegate, ShouldClose(testing::_))
+      .WillOnce(testing::Return(true));
+  EXPECT_CALL(*delegate, UpdateBubbleUi(bubble_ui))
+      .WillOnce(testing::Return(true));
+
+  BubbleReference ref = manager_->ShowBubble(make_scoped_ptr(delegate));
+  ASSERT_TRUE(ref->UpdateBubbleUi());
+}
+
+TEST_F(BubbleManagerTest, BubbleUpdatesFalse) {
+  MockBubbleUi* bubble_ui = new MockBubbleUi;
+  MockBubbleDelegate* delegate = new MockBubbleDelegate;
+  EXPECT_CALL(*delegate, BuildBubbleUiMock())
+      .WillOnce(testing::Return(bubble_ui));
+  EXPECT_CALL(*delegate, ShouldClose(testing::_))
+      .WillOnce(testing::Return(true));
+  EXPECT_CALL(*delegate, UpdateBubbleUi(bubble_ui))
+      .WillOnce(testing::Return(false));
+
+  BubbleReference ref = manager_->ShowBubble(make_scoped_ptr(delegate));
+  ASSERT_FALSE(ref->UpdateBubbleUi());
+}
+
 }  // namespace