[Mac] Refactor bookmark pulsing into BookmarkBubbleObserverCocoa.

chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller.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 "chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller.h"
 
 #include "base/mac/bundle_locations.h"
 #include "base/strings/sys_string_conversions.h"
+#include "chrome/browser/ui/bookmarks/bookmark_bubble_observer.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_button.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_sync_promo_controller.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
 #import "chrome/browser/ui/cocoa/info_bubble_view.h"
 #include "chrome/browser/ui/sync/sync_promo_ui.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
@@ skipping 28 matching lines @@
   // Singleton object to act as a representedObject for the "choose another
   // folder" item in the pop up.
   static ChooseAnotherFolder* object = nil;
   if (!object) {
     object = [[ChooseAnotherFolder alloc] init];
   }
   return object;
 }
 
 - (id)initWithParentWindow:(NSWindow*)parentWindow
+                  observer:(bookmarks::BookmarkBubbleObserver*)observer
                    managed:(bookmarks::ManagedBookmarkService*)managed
                      model:(BookmarkModel*)model
                       node:(const BookmarkNode*)node
          alreadyBookmarked:(BOOL)alreadyBookmarked {
   DCHECK(managed);
   DCHECK(node);
   if ((self = [super initWithWindowNibPath:@"BookmarkBubble"
                               parentWindow:parentWindow
                                 anchoredAt:NSZeroPoint])) {
+    bookmarkBubbleObserver_ = observer;
     managedBookmarkService_ = managed;
     model_ = model;
     node_ = node;
     alreadyBookmarked_ = alreadyBookmarked;
   }
   return self;
 }
 
 - (void)awakeFromNib {
   [super awakeFromNib];
@@ skipping 18 matching lines @@
     // Adjust the height of the bubble so that the sync promo fits in it,
     // except for its bottom border. The xib file hides the left and right
     // borders of the sync promo.
     NSRect bubbleFrame = [[self window] frame];
     bubbleFrame.size.height +=
         syncPromoHeight - [syncPromoController_ borderWidth];
     [[self window] setFrame:bubbleFrame display:YES];
   }
 }
 
-// If this is a new bookmark somewhere visible (e.g. on the bookmark
-// bar), pulse it.  Else, call ourself recursively with our parent
-// until we find something visible to pulse.
-- (void)startPulsingBookmarkButton:(const BookmarkNode*)node  {
-  while (node) {
-    if ((node->parent() == model_->bookmark_bar_node()) ||
-        (node->parent() ==
-         managedBookmarkService_->managed_node()) ||
-        (node->parent() == managedBookmarkService_->supervised_node()) ||
-        (node == model_->other_node())) {
-      pulsingBookmarkNode_ = node;
-      bookmarkObserver_->StartObservingNode(pulsingBookmarkNode_);
-      NSValue *value = [NSValue valueWithPointer:node];
-      NSDictionary *dict = [NSDictionary
-                             dictionaryWithObjectsAndKeys:value,
-                             bookmark_button::kBookmarkKey,
-                             [NSNumber numberWithBool:YES],
-                             bookmark_button::kBookmarkPulseFlagKey,
-                             nil];
-      [[NSNotificationCenter defaultCenter]
-        postNotificationName:bookmark_button::kPulseBookmarkButtonNotification
-                      object:self
-                    userInfo:dict];
-      return;
-    }
-    node = node->parent();
-  }
-}
+- (void)notifyBubbleClosed {
+  if (!bookmarkBubbleObserver_)
+    return;
 
-- (void)stopPulsingBookmarkButton {
-  if (!pulsingBookmarkNode_)
-    return;
-  NSValue *value = [NSValue valueWithPointer:pulsingBookmarkNode_];
-  if (bookmarkObserver_)
-      bookmarkObserver_->StopObservingNode(pulsingBookmarkNode_);
-  pulsingBookmarkNode_ = NULL;
-  NSDictionary *dict = [NSDictionary
-                         dictionaryWithObjectsAndKeys:value,
-                         bookmark_button::kBookmarkKey,
-                         [NSNumber numberWithBool:NO],
-                         bookmark_button::kBookmarkPulseFlagKey,
-                         nil];
-  [[NSNotificationCenter defaultCenter]
-        postNotificationName:bookmark_button::kPulseBookmarkButtonNotification
-                      object:self
-                    userInfo:dict];
+  bookmarkBubbleObserver_->OnBookmarkBubbleHidden();
+  bookmarkBubbleObserver_ = nullptr;
 }
 
 // Close the bookmark bubble without changing anything.  Unlike a
 // typical dialog's OK/Cancel, where Cancel is "do nothing", all
 // buttons on the bubble have the capacity to change the bookmark
 // model.  This is an IBOutlet-looking entry point to remove the
 // dialog without touching the model.
 - (void)dismissWithoutEditing:(id)sender {
   [self close];
 }
 
 - (void)windowWillClose:(NSNotification*)notification {
   // We caught a close so we don't need to watch for the parent closing.
   bookmarkObserver_.reset();
-  [self stopPulsingBookmarkButton];
+  [self notifyBubbleClosed];
   [super windowWillClose:notification];
 }
 
 // Override -[BaseBubbleController showWindow:] to tweak bubble location and
 // set up UI elements.
 - (void)showWindow:(id)sender {
   NSWindow* window = [self window];  // Force load the NIB.
   NSWindow* parentWindow = self.parentWindow;
   BrowserWindowController* bwc =
       [BrowserWindowController browserWindowControllerForWindow:parentWindow];
-  [bwc lockBarVisibilityForOwner:self withAnimation:NO delay:NO];
 
   InfoBubbleView* bubble = self.bubble;
   [bubble setArrowLocation:info_bubble::kTopRight];
 
   // Insure decent positioning even in the absence of a browser controller,
   // which will occur for some unit tests.
   NSPoint arrowTip = bwc ? [bwc bookmarkBubblePoint] :
       NSMakePoint([window frame].size.width, [window frame].size.height);
   arrowTip = [parentWindow convertBaseToScreen:arrowTip];
   NSPoint bubbleArrowTip = [bubble arrowTip];
   bubbleArrowTip = [bubble convertPoint:bubbleArrowTip toView:nil];
   arrowTip.y -= bubbleArrowTip.y;
   arrowTip.x -= bubbleArrowTip.x;
   [window setFrameOrigin:arrowTip];
 
   // Default is IDS_BOOKMARK_BUBBLE_PAGE_BOOKMARK; "Bookmark".
   // If adding for the 1st time the string becomes "Bookmark Added!"
   if (!alreadyBookmarked_) {
     NSString* title =
         l10n_util::GetNSString(IDS_BOOKMARK_BUBBLE_PAGE_BOOKMARKED);
     [bigTitle_ setStringValue:title];
   }
 
   [self fillInFolderList];
 
   // Ping me when things change out from under us.  Unlike a normal
   // dialog, the bookmark bubble's cancel: means "don't add this as a
   // bookmark", not "cancel editing".  We must take extra care to not
   // touch the bookmark in this selector.
-  bookmarkObserver_.reset(
-      new BookmarkModelObserverForCocoa(model_, ^(BOOL nodeWasDeleted) {
-          // If a watched node was deleted, the pointer to the pulsing button
-          // is likely stale.
-          if (nodeWasDeleted)
-            pulsingBookmarkNode_ = NULL;
-          [self dismissWithoutEditing:nil];
-      }));
+  bookmarkObserver_.reset(new BookmarkModelObserverForCocoa(model_, ^(BOOL) {

[tapted, 2015/08/25 01:13:21]

is the BOOL argument to the closure still needed?

[jackhou1, 2015/08/25 04:32:29]

Nope, removed.

+    [self dismissWithoutEditing:nil];
+  }));
   bookmarkObserver_->StartObservingNode(node_);
 
-  // Pulse something interesting on the bookmark bar.
-  [self startPulsingBookmarkButton:node_];
-
   [parentWindow addChildWindow:window ordered:NSWindowAbove];
   [window makeKeyAndOrderFront:self];
   [self registerKeyStateEventTap];
+
+  bookmarkBubbleObserver_->OnBookmarkBubbleShown(node_);
 }
 
 - (void)close {
   [[BrowserWindowController browserWindowControllerForWindow:self.parentWindow]
       releaseBarVisibilityForOwner:self withAnimation:YES delay:NO];
 
   [super close];
 }
 
 // Shows the bookmark editor sheet for more advanced editing.
 - (void)showEditor {
   [self ok:self];
   // Send the action up through the responder chain.
   [NSApp sendAction:@selector(editBookmarkNode:) to:nil from:self];
 }
 
 - (IBAction)edit:(id)sender {
   content::RecordAction(UserMetricsAction("BookmarkBubble_Edit"));
   [self showEditor];
 }
 
 - (IBAction)ok:(id)sender {
-  [self stopPulsingBookmarkButton];  // before parent changes
   [self updateBookmarkNode];
   [self close];
 }
 
 // By implementing this, ESC causes the window to go away. If clicking the
 // star was what prompted this bubble to appear (i.e., not already bookmarked),
 // remove the bookmark.
 - (IBAction)cancel:(id)sender {
   if (!alreadyBookmarked_) {
     // |-remove:| calls |-close| so don't do it.
     [self remove:sender];
   } else {
-    [self stopPulsingBookmarkButton];
     [self dismissWithoutEditing:nil];
   }
 }
 
 - (IBAction)remove:(id)sender {
-  [self stopPulsingBookmarkButton];
   bookmarks::RemoveAllBookmarks(model_, node_->url());
   content::RecordAction(UserMetricsAction("BookmarkBubble_Unstar"));
   node_ = NULL;  // no longer valid
   [self ok:sender];
 }
 
 // The controller is  the target of the pop up button box action so it can
 // handle when "choose another folder" was picked.
 - (IBAction)folderChanged:(id)sender {
   DCHECK([sender isEqual:folderPopUpButton_]);
@@ skipping 78 matching lines @@
 
 @end  // BookmarkBubbleController
 
 
 @implementation BookmarkBubbleController (ExposedForUnitTesting)
 
 - (NSView*)syncPromoPlaceholder {
   return syncPromoPlaceholder_;
 }
 
+- (bookmarks::BookmarkBubbleObserver*)bookmarkBubbleObserver {
+  return bookmarkBubbleObserver_;
+}
+
 + (NSString*)chooseAnotherFolderString {
   return l10n_util::GetNSStringWithFixup(
       IDS_BOOKMARK_BUBBLE_CHOOSER_ANOTHER_FOLDER);
 }
 
 // For the given folder node, walk the tree and add folder names to
 // the given pop up button.
 - (void)addFolderNodes:(const BookmarkNode*)parent
          toPopUpButton:(NSPopUpButton*)button
            indentation:(int)indentation {
@@ skipping 33 matching lines @@
   NSInteger idx = [menu indexOfItemWithRepresentedObject:parentValue];
   DCHECK(idx != -1);
   [folderPopUpButton_ selectItemAtIndex:idx];
 }
 
 - (NSPopUpButton*)folderPopUpButton {
   return folderPopUpButton_;
 }
 
 @end  // implementation BookmarkBubbleController(ExposedForUnitTesting)