[Mac] Refactor bookmark pulsing into BookmarkBubbleObserverCocoa.

chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller_unittest.mm

 // Copyright (c) 2012 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.
 
 #import <Cocoa/Cocoa.h>
 
 #include "base/basictypes.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/managed_bookmark_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
+#include "chrome/browser/ui/bookmarks/bookmark_bubble_observer.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller.h"
 #include "chrome/browser/ui/cocoa/browser_window_controller.h"
 #include "chrome/browser/ui/cocoa/cocoa_profile_test.h"
 #import "chrome/browser/ui/cocoa/info_bubble_window.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/managed/managed_bookmark_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #import "testing/gtest_mac.h"
 #include "testing/platform_test.h"
 
 using base::ASCIIToUTF16;
+using bookmarks::BookmarkBubbleObserver;
 using bookmarks::BookmarkModel;
 using bookmarks::BookmarkNode;
 using content::WebContents;
 
-// Watch for bookmark pulse notifications so we can confirm they were sent.
-@interface BookmarkPulseObserver : NSObject {
-  int notifications_;
-}
-@property (assign, nonatomic) int notifications;
-@end
-
-
-@implementation BookmarkPulseObserver
-
-@synthesize notifications = notifications_;
-
-- (id)init {
-  if ((self = [super init])) {
-    [[NSNotificationCenter defaultCenter]
-      addObserver:self
-         selector:@selector(pulseBookmarkNotification:)
-             name:bookmark_button::kPulseBookmarkButtonNotification
-           object:nil];
-  }
-  return self;
-}
-
-- (void)pulseBookmarkNotification:(NSNotificationCenter *)notification {
-  notifications_++;
-}
-
-- (void)dealloc {
-  [[NSNotificationCenter defaultCenter] removeObserver:self];
-  [super dealloc];
-}
-
-@end
-
-
 namespace {
 
 // URL of the test bookmark.
 const char kTestBookmarkURL[] = "http://www.google.com";
 
+class TestBookmarkBubbleObserver : public BookmarkBubbleObserver {
+ public:
+  TestBookmarkBubbleObserver() {}
+  ~TestBookmarkBubbleObserver() override{};
+
+  // bookmarks::BookmarkBubbleObserver.
+  void OnBookmarkBubbleShown(const BookmarkNode* node) override {
+    ++shown_count_;
+  }
+  void OnBookmarkBubbleHidden() override { ++hidden_count_; }
+
+  int shown_count() { return shown_count_; }
+  int hidden_count() { return hidden_count_; }
+
+ private:
+  int shown_count_ = 0;
+  int hidden_count_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(TestBookmarkBubbleObserver);
+};
+
 class BookmarkBubbleControllerTest : public CocoaProfileTest {
  public:
   static int edits_;
   BookmarkBubbleController* controller_;
+  TestBookmarkBubbleObserver test_observer_;
 
   BookmarkBubbleControllerTest() : controller_(nil) {
     edits_ = 0;
   }
 
   void TearDown() override {
     [controller_ close];
     CocoaProfileTest::TearDown();
   }
 
   // Returns a controller but ownership not transferred.
   // Only one of these will be valid at a time.
   BookmarkBubbleController* ControllerForNode(const BookmarkNode* node) {
     if (controller_ && !IsWindowClosing()) {
       [controller_ close];
       controller_ = nil;
     }
     BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
     bookmarks::ManagedBookmarkService* managed =
         ManagedBookmarkServiceFactory::GetForProfile(profile());
     controller_ = [[BookmarkBubbleController alloc]
         initWithParentWindow:browser()->window()->GetNativeWindow()
+              bubbleObserver:&test_observer_
                      managed:managed
                        model:model
                         node:node
            alreadyBookmarked:YES];
     EXPECT_TRUE([controller_ window]);
     // The window must be gone or we'll fail a unit test with windows left open.
     [static_cast<InfoBubbleWindow*>([controller_ window])
         setAllowedAnimations:info_bubble::kAnimateNone];
     [controller_ showWindow:nil];
     return controller_;
@@ skipping 125 matching lines @@
     if ([[item title] length] == 0 &&
         static_cast<const BookmarkNode*>([[item representedObject]
                                           pointerValue]) == node2) {
       blankFolderFound = YES;
       break;
     }
   }
   EXPECT_TRUE(blankFolderFound);
 }
 
-
 // Click on edit; bubble gets closed.
 TEST_F(BookmarkBubbleControllerTest, TestEdit) {
   const BookmarkNode* node = CreateTestBookmark();
   BookmarkBubbleController* controller = ControllerForNode(node);
   EXPECT_TRUE(controller);
 
   EXPECT_EQ(edits_, 0);
   EXPECT_FALSE(IsWindowClosing());
   [controller edit:controller];
   EXPECT_EQ(edits_, 1);
   EXPECT_TRUE(IsWindowClosing());
 }
 
 // CallClose; bubble gets closed.
-// Also confirm pulse notifications get sent.
+// Also confirm bubble notifications get sent.
 TEST_F(BookmarkBubbleControllerTest, TestClose) {
   const BookmarkNode* node = CreateTestBookmark();
   EXPECT_EQ(edits_, 0);
 
-  base::scoped_nsobject<BookmarkPulseObserver> observer(
-      [[BookmarkPulseObserver alloc] init]);
-  EXPECT_EQ([observer notifications], 0);
   BookmarkBubbleController* controller = ControllerForNode(node);
+  EXPECT_TRUE(controller.bookmarkBubbleObserver);
+  EXPECT_EQ(1, test_observer_.shown_count());
+  EXPECT_EQ(0, test_observer_.hidden_count());
   EXPECT_TRUE(controller);
   EXPECT_FALSE(IsWindowClosing());
-  EXPECT_EQ([observer notifications], 1);
   [controller ok:controller];
   EXPECT_EQ(edits_, 0);
   EXPECT_TRUE(IsWindowClosing());
-  EXPECT_EQ([observer notifications], 2);
+  EXPECT_FALSE(controller.bookmarkBubbleObserver);
+  EXPECT_EQ(1, test_observer_.hidden_count());
 }
 
 // User changes title and parent folder in the UI
 TEST_F(BookmarkBubbleControllerTest, TestUserEdit) {
   BookmarkModel* model = GetBookmarkModel();
   EXPECT_TRUE(model);
   const BookmarkNode* bookmarkBarNode = model->bookmark_bar_node();
   EXPECT_TRUE(bookmarkBarNode);
   const BookmarkNode* node = model->AddURL(bookmarkBarNode,
                                            0,
@@ skipping 108 matching lines @@
 // Create a controller that simulates the bookmark just now being created by
 // the user clicking the star, then sending the "cancel" command to represent
 // them pressing escape. The bookmark should not be there.
 TEST_F(BookmarkBubbleControllerTest, EscapeRemovesNewBookmark) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   bookmarks::ManagedBookmarkService* managed =
       ManagedBookmarkServiceFactory::GetForProfile(profile());
   const BookmarkNode* node = CreateTestBookmark();
   BookmarkBubbleController* controller = [[BookmarkBubbleController alloc]
       initWithParentWindow:browser()->window()->GetNativeWindow()
+            bubbleObserver:&test_observer_
                    managed:managed
                      model:model
                       node:node
          alreadyBookmarked:NO];  // The last param is the key difference.
   EXPECT_TRUE([controller window]);
   // Calls release on controller.
   [controller cancel:nil];
   EXPECT_FALSE(model->IsBookmarked(GURL(kTestBookmarkURL)));
 }
 
@@ skipping 69 matching lines @@
 // Normally this would be sent up the responder tree correctly, but since
 // tests run in the background, key window and main window are never set on
 // NSApplication. Adding it to NSApplication directly removes the need for
 // worrying about what the current window with focus is.
 - (void)editBookmarkNode:(id)sender {
   EXPECT_TRUE([sender respondsToSelector:@selector(node)]);
   BookmarkBubbleControllerTest::edits_++;
 }
 
 @end