Add ability for a BubbleReference to update the BubbleUI.

components/bubble/bubble_manager_unittest.cc

Index: components/bubble/bubble_manager_unittest.cc
diff --git a/components/bubble/bubble_manager_unittest.cc b/components/bubble/bubble_manager_unittest.cc
index 84ed380aa31a6b33c76c4ff12d2f0da3851801a7..d426f95b7011bbb2b3b167be0bc909fccfbe9e51 100644
--- a/components/bubble/bubble_manager_unittest.cc
+++ b/components/bubble/bubble_manager_unittest.cc
@@ -6,16 +6,17 @@
 
 #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());
@@ -39,11 +40,13 @@ class MockBubbleDelegate : public BubbleDelegate {
   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());
 };
@@ -51,8 +54,8 @@ class MockBubbleDelegate : public BubbleDelegate {
 // 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);
@@ -61,8 +64,8 @@ scoped_ptr<MockBubbleDelegate> MockBubbleDelegate::Default() {
 // 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);
@@ -114,9 +117,9 @@ void BubbleManagerTest::TearDown() {
   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());
@@ -125,7 +128,7 @@ TEST_F(BubbleManagerTest, ManagerShowsBubbleUI) {
   // 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));
@@ -133,9 +136,9 @@ TEST_F(BubbleManagerTest, ManagerShowsBubbleUI) {
   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());
@@ -144,7 +147,7 @@ TEST_F(BubbleManagerTest, ManagerUpdatesBubbleUI) {
   // 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));
@@ -287,8 +290,8 @@ TEST_F(BubbleManagerTest, AllowBubbleChainingOnClose) {
 
   // 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),
@@ -306,8 +309,8 @@ TEST_F(BubbleManagerTest, AllowBubbleChainingOnCloseAll) {
 
   // 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),
@@ -322,7 +325,7 @@ TEST_F(BubbleManagerTest, AllowBubbleChainingOnCloseAll) {
 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(),
@@ -330,8 +333,8 @@ TEST_F(BubbleManagerTest, BubblesDoNotChainOnDestroy) {
 
   // 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),
@@ -344,4 +347,32 @@ TEST_F(BubbleManagerTest, BubblesDoNotChainOnDestroy) {
   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