[Mac] Replace the custom bookmark menus with native NSMenus.

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

 // Copyright (c) 2011 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_bar_controller.h"
 
 #include "base/mac/mac_util.h"
 #include "base/metrics/histogram.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_editor.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #import "chrome/browser/themes/theme_service.h"
 #import "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #import "chrome/browser/ui/cocoa/background_gradient_view.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_bridge.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_folder_controller.h"
-#import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_folder_window.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_toolbar_view.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_view.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_button.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_button_cell.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_editor_controller.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_folder_target.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_menu.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_menu_cocoa_controller.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_name_folder_controller.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
@@ skipping 327 matching lines @@
 
   // When resized we may need to add new buttons, or remove them (if
   // no longer visible), or add/remove the "off the side" menu.
   [[self view] setPostsFrameChangedNotifications:YES];
   [[NSNotificationCenter defaultCenter]
     addObserver:self
        selector:@selector(frameDidChange)
            name:NSViewFrameDidChangeNotification
          object:[self view]];
 
-  // Watch for things going to or from fullscreen.
-  [[NSNotificationCenter defaultCenter]
-    addObserver:self
-       selector:@selector(willEnterOrLeaveFullscreen:)
-           name:kWillEnterFullscreenNotification
-         object:nil];
-  [[NSNotificationCenter defaultCenter]
-    addObserver:self
-       selector:@selector(willEnterOrLeaveFullscreen:)
-           name:kWillLeaveFullscreenNotification
-         object:nil];
-
   // Don't pass ourself along (as 'self') until our init is completely
   // done.  Thus, this call is (almost) last.
   bridge_.reset(new BookmarkBarBridge(self, bookmarkModel_));
 }
 
 // Called by our main view (a BookmarkBarView) when it gets moved to a
 // window.  We perform operations which need to know the relevant
 // window (e.g. watch for a window close) so they can't be performed
 // earlier (such as in awakeFromNib).
 - (void)viewDidMoveToWindow {
@@ skipping 10 matching lines @@
   [defaultCenter addObserver:self
                     selector:@selector(parentWindowWillClose:)
                         name:NSWindowWillCloseNotification
                       object:[[self view] window]];
   [defaultCenter addObserver:self
                     selector:@selector(parentWindowDidResignMain:)
                         name:NSWindowDidResignMainNotification
                       object:[[self view] window]];
 }
 
-// When going fullscreen we can run into trouble.  Our view is removed
-// from the non-fullscreen window before the non-fullscreen window
-// loses key, so our parentDidResignKey: callback never gets called.
-// In addition, a bookmark folder controller needs to be autoreleased
-// (in case it's in the event chain when closed), but the release
-// implicitly needs to happen while it's connected to the original
-// (non-fullscreen) window to "unlock bar visibility".  Such a
-// contract isn't honored when going fullscreen with the menu option
-// (not with the keyboard shortcut).  We fake it as best we can here.
-// We have a similar problem leaving fullscreen.
-- (void)willEnterOrLeaveFullscreen:(NSNotification*)notification {
-  if (folderController_) {
-    [self childFolderWillClose:folderController_];
-    [self closeFolderAndStopTrackingMenus];
-  }
-}
-
 // NSNotificationCenter callback.
 - (void)parentWindowWillClose:(NSNotification*)notification {
   [self closeFolderAndStopTrackingMenus];
 }
 
 // NSNotificationCenter callback.
 - (void)parentWindowDidResignMain:(NSNotification*)notification {
   [self closeFolderAndStopTrackingMenus];
 }
 
@@ skipping 100 matching lines @@
   if (node == nil ||
       node == bookmarkModel_->bookmark_bar_node() ||
       node == bookmarkModel_->other_node() ||
       node == bookmarkModel_->synced_node())
     return NO;
   return YES;
 }
 
 #pragma mark Actions
 
-// Helper methods called on the main thread by runMenuFlashThread.
-
-- (void)setButtonFlashStateOn:(id)sender {
-  [sender highlight:YES];
-}
-
-- (void)setButtonFlashStateOff:(id)sender {
-  [sender highlight:NO];
-}
-
--(void)cleanupAfterMenuFlashThread:(id)sender {
-  [self closeFolderAndStopTrackingMenus];
-
-  // Items retained by doMenuFlashOnSeparateThread below.
-  [sender release];
-  [self release];
-}
-
-// End runMenuFlashThread helper methods.
-
-// This call is invoked only by doMenuFlashOnSeparateThread below.
-// It makes the selected BookmarkButton (which is masquerading as a menu item)
-// flash a few times to give confirmation feedback, then it closes the menu.
-// It spends all its time sleeping or scheduling UI work on the main thread.
-- (void)runMenuFlashThread:(id)sender {
-
-  // Check this is not running on the main thread, as it sleeps.
-  DCHECK(![NSThread isMainThread]);
-
-  // Duration of flash phases and number of flashes designed to evoke a
-  // slightly retro "more mac-like than the Mac" feel.
-  // Current Cocoa UI has a barely perceptible flash,probably because Apple
-  // doesn't fire the action til after the animation and so there's a hurry.
-  // As this code is fully asynchronous, it can take its time.
-  const float kBBOnFlashTime = 0.08;
-  const float kBBOffFlashTime = 0.08;
-  const int kBookmarkButtonMenuFlashes = 3;
-
-  for (int count = 0 ; count < kBookmarkButtonMenuFlashes ; count++) {
-    [self performSelectorOnMainThread:@selector(setButtonFlashStateOn:)
-                           withObject:sender
-                        waitUntilDone:NO];
-    [NSThread sleepForTimeInterval:kBBOnFlashTime];
-    [self performSelectorOnMainThread:@selector(setButtonFlashStateOff:)
-                           withObject:sender
-                        waitUntilDone:NO];
-    [NSThread sleepForTimeInterval:kBBOffFlashTime];
-  }
-  [self performSelectorOnMainThread:@selector(cleanupAfterMenuFlashThread:)
-                         withObject:sender
-                      waitUntilDone:NO];
-}
-
-// Non-blocking call which starts the process to make the selected menu item
-// flash a few times to give confirmation feedback, after which it closes the
-// menu. The item is of course actually a BookmarkButton masquerading as a menu
-// item).
-- (void)doMenuFlashOnSeparateThread:(id)sender {
-
-  // Ensure that self and sender don't go away before the animation completes.
-  // These retains are balanced in cleanupAfterMenuFlashThread above.
-  [self retain];
-  [sender retain];
-  [NSThread detachNewThreadSelector:@selector(runMenuFlashThread:)
-                           toTarget:self
-                         withObject:sender];
-}
-
 - (IBAction)openBookmark:(id)sender {
   BOOL isMenuItem = [[sender cell] isFolderButtonCell];
   BOOL animate = isMenuItem && [self animationEnabled];
-  if (animate)
-    [self doMenuFlashOnSeparateThread:sender];
   DCHECK([sender respondsToSelector:@selector(bookmarkNode)]);
   const BookmarkNode* node = [sender bookmarkNode];
   WindowOpenDisposition disposition =
       event_utils::WindowOpenDispositionFromNSEvent([NSApp currentEvent]);
   RecordAppLaunch(browser_->profile(), node->url());
   [self openURL:node->url() disposition:disposition];
 
   if (!animate)
     [self closeFolderAndStopTrackingMenus];
 }
@@ skipping 221 matching lines @@
                        bookmarks::kBookmarkHorizontalPadding));
   } else {
     frame.origin.x = (NSMaxX([otherBookmarksButton_ frame]) - frame.size.width);
   }
   [offTheSideButton_ setFrame:frame];
 }
 
 // Configure the off-the-side button (e.g. specify the node range,
 // check if we should enable or disable it, etc).
 - (void)configureOffTheSideButtonContentsAndVisibility {
-  // If deleting a button while off-the-side is open, buttons may be
-  // promoted from off-the-side to the bar.  Accomodate.
-  if (folderController_ &&
-      ([folderController_ parentButton] == offTheSideButton_)) {
-    [folderController_ reconfigureMenu];
-  }
-
   [[offTheSideButton_ cell] setStartingChildIndex:displayedButtonCount_];
   [[offTheSideButton_ cell]
    setBookmarkNode:bookmarkModel_->bookmark_bar_node()];
   int bookmarkChildren = bookmarkModel_->bookmark_bar_node()->child_count();
   if (bookmarkChildren > displayedButtonCount_) {
     [offTheSideButton_ setHidden:NO];
   } else {
     // If we just deleted the last item in an off-the-side menu so the
     // button will be going away, make sure the menu goes away.
     if (folderController_ &&
@@ skipping 933 matching lines @@
       // All other clicks on the bookmarks bar are counted as 'outside'
       // because they should close any open bookmark folder menu.
       if (eventWindow == myWindow) {
         NSView* hitView =
             [[eventWindow contentView] hitTest:[event locationInWindow]];
         if (hitView == [folderController_ parentButton])
           return NO;
         if (![hitView isDescendantOf:[self view]] || hitView == buttonView_)
           return YES;
       }
-      // If a click in a bookmark bar folder window and that isn't
-      // one of my bookmark bar folders, YES is click outside.
-      if (![eventWindow isKindOfClass:[BookmarkBarFolderWindow
-                                       class]]) {
-        return YES;
-      }
       break;
     case NSKeyDown: {
       // Event hooks often see the same keydown event twice due to the way key
       // events get dispatched and redispatched, so ignore if this keydown
       // event has the EXACT same timestamp as the previous keydown.
       static NSTimeInterval lastKeyDownEventTime;
       NSTimeInterval thisTime = [event timestamp];
       if (lastKeyDownEventTime != thisTime) {
         lastKeyDownEventTime = thisTime;
         if ([event modifierFlags] & NSCommandKeyMask)
           return YES;
-        else if (folderController_)
-          return [folderController_ handleInputText:[event characters]];
       }
       return NO;
     }
     case NSKeyUp:
       return NO;
     case NSLeftMouseDragged:
       // We can get here with the following sequence:
       // - open a bookmark folder
       // - right-click (and unclick) on it to open context menu
       // - move mouse to window titlebar then click-drag it by the titlebar
@@ skipping 336 matching lines @@
     if (cellnode == node) {
       [[button cell] setBookmarkCellText:[button title]
                                    image:[self faviconForNode:node]];
       // Adding an image means we might need more room for the
       // bookmark.  Test for it by growing the button (if needed)
       // and shifting everything else over.
       [self checkForBookmarkButtonGrowth:button];
       return;
     }
   }
-
-  if (folderController_)
-    [folderController_ faviconLoadedForNode:node];
 }
 
 // TODO(jrg): for now this is brute force.
 - (void)nodeChildrenReordered:(BookmarkModel*)model
                          node:(const BookmarkNode*)node {
   [self loaded:model];
 }
 
 #pragma mark BookmarkBarState Protocol
 
@@ skipping 88 matching lines @@
   // a subfolder menu.
   if (!showFolderMenus_)
     return;
 
   // From here down: same logic as BookmarkBarFolderController.
   // TODO(jrg): find a way to share these 4 non-comment lines?
   // http://crbug.com/35966
   // If already opened, then we exited but re-entered the button, so do nothing.
   if ([folderController_ parentButton] == sender)
     return;
-  // Else open a new one if it makes sense to do so.
-  if ([sender bookmarkNode]->is_folder()) {
-    // Update |hoverButton_| so that it corresponds to the open folder.
-    hoverButton_.reset([sender retain]);
-    [folderTarget_ openBookmarkFolderFromButton:sender];
-  } else {
-    // We're over a non-folder bookmark so close any old folders.
-    [folderController_ close];
-    folderController_ = nil;
-  }
 }
 
 // BookmarkButtonDelegate protocol implementation.
 - (void)mouseExitedButton:(id)sender event:(NSEvent*)event {
   // Don't care; do nothing.
   // This is different behavior that the folder menus.
 }
 
 - (NSWindow*)browserWindow {
   return [[self view] window];
@@ skipping 21 matching lines @@
   [self resetAllButtonPositionsWithAnimation:YES];
 }
 
 
 #pragma mark BookmarkButtonControllerProtocol
 
 // Close all bookmark folders.  "Folder" here is the fake menu for
 // bookmark folders, not a button context menu.
 - (void)closeAllBookmarkFolders {
   [self watchForExitEvent:NO];
-  [folderController_ close];
+  [folderController_ closeMenu];
   folderController_ = nil;
 }
 
 - (void)closeBookmarkFolder:(id)sender {
   // We're the top level, so close one means close them all.
   [self closeAllBookmarkFolders];
 }
 
 - (BookmarkModel*)bookmarkModel {
   return bookmarkModel_;
@@ skipping 34 matching lines @@
                                                          target]];
       // Unlike BookmarkBarFolderController, we do not delay the close
       // of the previous one.  Given the lack of diagonal movement,
       // there is no need, and it feels awkward to do so.  See
       // comments about kDragHoverCloseDelay in
       // bookmark_bar_folder_controller.mm for more details.
       [[hoverButton_ target] closeBookmarkFolder:hoverButton_];
       hoverButton_.reset();
     }
     hoverButton_.reset([button retain]);
-    DCHECK([[hoverButton_ target]
-            respondsToSelector:@selector(openBookmarkFolderFromButton:)]);
-    [[hoverButton_ target]
-     performSelector:@selector(openBookmarkFolderFromButton:)
-     withObject:hoverButton_
-     afterDelay:bookmarks::kDragHoverOpenDelay
-     inModes:[NSArray arrayWithObject:NSRunLoopCommonModes]];
   }
   if (!button) {
     if (hoverButton_) {
-      [NSObject cancelPreviousPerformRequestsWithTarget:[hoverButton_ target]];
       [[hoverButton_ target] closeBookmarkFolder:hoverButton_];
       hoverButton_.reset();
     }
   }
 
   // Thrown away but kept to be consistent with the draggingEntered: interface.
   return NSDragOperationMove;
 }
 
 - (void)draggingExited:(id<NSDraggingInfo>)info {
@@ skipping 84 matching lines @@
     } else {
       x = 0.5 * bookmarks::kBookmarkHorizontalPadding;
     }
   } else {
     NOTREACHED();
   }
 
   return x;
 }
 
-- (void)childFolderWillShow:(id<BookmarkButtonControllerProtocol>)child {
-  // If the bookmarkbar is not in detached mode, lock bar visibility, forcing
-  // the overlay to stay open when in fullscreen mode.
-  if (![self isInState:bookmarks::kDetachedState] &&
-      ![self isAnimatingToState:bookmarks::kDetachedState]) {
-    BrowserWindowController* browserController =
-        [BrowserWindowController browserWindowControllerForView:[self view]];
-    [browserController lockBarVisibilityForOwner:child
-                                   withAnimation:NO
-                                           delay:NO];
-  }
-}
-
-- (void)childFolderWillClose:(id<BookmarkButtonControllerProtocol>)child {
-  // Release bar visibility, allowing the overlay to close if in fullscreen
-  // mode.
-  BrowserWindowController* browserController =
-      [BrowserWindowController browserWindowControllerForView:[self view]];
-  [browserController releaseBarVisibilityForOwner:child
-                                    withAnimation:NO
-                                            delay:NO];
-}
-
 // Add a new folder controller as triggered by the given folder button.
 - (void)addNewFolderControllerWithParentButton:(BookmarkButton*)parentButton {
 
   // If doing a close/open, make sure the fullscreen chrome doesn't
   // have a chance to begin animating away in the middle of things.
   BrowserWindowController* browserController =
       [BrowserWindowController browserWindowControllerForView:[self view]];
   // Confirm we're not re-locking with ourself as an owner before locking.
   DCHECK([browserController isBarVisibilityLockedForOwner:self] == NO);
   [browserController lockBarVisibilityForOwner:self
                                  withAnimation:NO
                                          delay:NO];
 
   if (folderController_)
     [self closeAllBookmarkFolders];
 
   // Folder controller, like many window controllers, owns itself.
   folderController_ =
       [[BookmarkBarFolderController alloc] initWithParentButton:parentButton
-                                               parentController:nil
+                                                  bookmarkModel:bookmarkModel_
                                                   barController:self];
-  [folderController_ showWindow:self];
+  [folderController_ autorelease];
+  [folderController_ openMenu];
 
   // Only BookmarkBarController has this; the
   // BookmarkBarFolderController does not.
   [self watchForExitEvent:YES];
 
   // No longer need to hold the lock; the folderController_ now owns it.
   [browserController releaseBarVisibilityForOwner:self
                                     withAnimation:NO
                                             delay:NO];
 }
@@ skipping 24 matching lines @@
     ++displayedButtonCount_;
     [buttons_ insertObject:newButton atIndex:buttonIndex];
     [buttonView_ addSubview:newButton];
     [self resetAllButtonPositionsWithAnimation:NO];
     // See if any buttons need to be pushed off to or brought in from the side.
     [self reconfigureBookmarkBar];
   } else  {
     // A button from somewhere else (not the bar) is being moved to the
     // off-the-side so insure it gets redrawn if its showing.
     [self reconfigureBookmarkBar];
-    [folderController_ reconfigureMenu];
   }
 }
 
 // TODO(mrossetti): Duplicate code with BookmarkBarFolderController.
 // http://crbug.com/35966
 - (BOOL)addURLs:(NSArray*)urls withTitles:(NSArray*)titles at:(NSPoint)point {
   DCHECK([urls count] == [titles count]);
   BOOL nodesWereAdded = NO;
   // Figure out where these new bookmarks nodes are to be added.
   BookmarkButton* button = [self buttonForDroppingOnAtPoint:point];
@@ skipping 47 matching lines @@
       [movedButton setHidden:NO];
       [self resetAllButtonPositionsWithAnimation:NO];
     } else if (fromIndex < buttonCount) {
       // A button is being removed from the bar and added to off-the-side.
       // By now the node has already been inserted into the model so the
       // button to be added is represented by |toIndex|. Things get
       // complicated because the off-the-side is showing and must be redrawn
       // while possibly re-laying out the bookmark bar.
       [self removeButton:fromIndex animate:NO];
       [self reconfigureBookmarkBar];
-      [folderController_ reconfigureMenu];
     } else if (toIndex < buttonCount) {
       // A button is being added to the bar and removed from off-the-side.
       // By now the node has already been inserted into the model so the
       // button to be added is represented by |toIndex|.
       const BookmarkNode* node = bookmarkModel_->bookmark_bar_node();
       const BookmarkNode* movedNode = node->GetChild(toIndex);
       DCHECK(movedNode);
       [self addButtonForNode:movedNode atIndex:toIndex];
       [self reconfigureBookmarkBar];
-    } else {
-      // A button is being moved within the off-the-side.
-      fromIndex -= buttonCount;
-      toIndex -= buttonCount;
-      [folderController_ moveButtonFromIndex:fromIndex toIndex:toIndex];
     }
   }
 }
 
 - (void)removeButton:(NSInteger)buttonIndex animate:(BOOL)animate {
   if (buttonIndex < (NSInteger)[buttons_ count]) {
     // The button being removed is showing in the bar.
     BookmarkButton* oldButton = [buttons_ objectAtIndex:buttonIndex];
     if (oldButton == [folderController_ parentButton]) {
       // If we are deleting a button whose folder is currently open, close it!
       [self closeAllBookmarkFolders];
     }
     if (animate && !ignoreAnimations_ && [self isVisible] &&
         [[self browserWindow] isMainWindow]) {
       NSPoint poofPoint = [oldButton screenLocationForRemoveAnimation];
       NSShowAnimationEffect(NSAnimationEffectDisappearingItemDefault, poofPoint,
                             NSZeroSize, nil, nil, nil);
     }
     [oldButton setDelegate:nil];
     [oldButton removeFromSuperview];
     [buttons_ removeObjectAtIndex:buttonIndex];
     --displayedButtonCount_;
     [self resetAllButtonPositionsWithAnimation:YES];
     [self reconfigureBookmarkBar];
-  } else if (folderController_ &&
-             [folderController_ parentButton] == offTheSideButton_) {
-    // The button being removed is in the OTS (off-the-side) and the OTS
-    // menu is showing so we need to remove the button.
-    NSInteger index = buttonIndex - displayedButtonCount_;
-    [folderController_ removeButton:index animate:YES];
   }
 }
 
 - (id<BookmarkButtonControllerProtocol>)controllerForNode:
     (const BookmarkNode*)node {
   // See if it's in the bar, then if it is in the hierarchy of visible
   // folder menus.
   if (bookmarkModel_->bookmark_bar_node() == node)
     return self;
-  return [folderController_ controllerForNode:node];
+  return nil;
 }
 
 #pragma mark BookmarkButtonControllerProtocol
 
 // NOT an override of a standard Cocoa call made to NSViewControllers.
 - (void)hookForEvent:(NSEvent*)theEvent {
   if ([self isEventAnExitEvent:theEvent])
     [self closeFolderAndStopTrackingMenus];
 }
 
 #pragma mark TestingAPI Only
 
 - (NSMenu*)buttonContextMenu {
   return buttonContextMenu_;
 }
 
 // Intentionally ignores ownership issues; used for testing and we try
 // to minimize touching the object passed in (likely a mock).
 - (void)setButtonContextMenu:(id)menu {
   buttonContextMenu_ = menu;
 }
 
 - (void)setIgnoreAnimations:(BOOL)ignore {
   ignoreAnimations_ = ignore;
 }
 
 @end