[Mac] Restore the old bookmark menus now that the experiment is over.

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/incognito_mode_prefs.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 169 matching lines @@
 
 - (void)addNode:(const BookmarkNode*)child toMenu:(NSMenu*)menu;
 - (void)addFolderNode:(const BookmarkNode*)node toMenu:(NSMenu*)menu;
 - (void)tagEmptyMenu:(NSMenu*)menu;
 - (void)clearMenuTagMap;
 - (int)preferredHeight;
 - (void)addNonBookmarkButtonsToView;
 - (void)addButtonsToView;
 - (void)centerNoItemsLabel;
 - (void)setNodeForBarMenu;
+- (void)watchForExitEvent:(BOOL)watch;
 - (void)resetAllButtonPositionsWithAnimation:(BOOL)animate;
 - (BOOL)animationEnabled;
 
 @end
 
 @implementation BookmarkBarController
 
 @synthesize visualState = visualState_;
 @synthesize lastVisualState = lastVisualState_;
 @synthesize delegate = delegate_;
@@ skipping 95 matching lines @@
 
   // For safety, make sure the buttons can no longer call us.
   for (BookmarkButton* button in buttons_.get()) {
     [button setDelegate:nil];
     [button setTarget:nil];
     [button setAction:nil];
   }
 
   bridge_.reset(NULL);
   [[NSNotificationCenter defaultCenter] removeObserver:self];
+  [self watchForExitEvent:NO];
   [super dealloc];
 }
 
 - (void)awakeFromNib {
   // We default to NOT open, which means height=0.
   DCHECK([[self view] isHidden]);  // Hidden so it's OK to change.
 
   // Set our initial height to zero, since that is what the superview
   // expects.  We will resize ourselves open later if needed.
   [[self view] setFrame:NSMakeRect(0, 0, initialWidth_, 0)];
@@ skipping 21 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 isFolder];
+  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];
 }
 
 // Common function to open a bookmark folder of any type.
 - (void)openBookmarkFolder:(id)sender {
   DCHECK([sender isKindOfClass:[BookmarkButton class]]);
   DCHECK([[sender cell] isKindOfClass:[BookmarkButtonCell class]]);
 
   showFolderMenus_ = !showFolderMenus_;
 
+  if (sender == offTheSideButton_)
+    [[sender cell] setStartingChildIndex:displayedButtonCount_];
+
   // Toggle presentation of bar folder menus.
   [folderTarget_ openBookmarkFolderFromButton:sender];
 }
 
 
 // Click on a bookmark folder button.
 - (IBAction)openBookmarkFolderFromButton:(id)sender {
   [self openBookmarkFolder:sender];
 }
 
@@ skipping 197 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()];
+   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_ &&
         ([folderController_ parentButton] == offTheSideButton_))
       [self closeAllBookmarkFolders];
     // (And hide the button, too.)
     [offTheSideButton_ setHidden:YES];
   }
 }
 
+// Main menubar observation code, so we can know to close our fake menus if the
+// user clicks on the actual menubar, as multiple unconnected menus sharing
+// the screen looks weird.
+// Needed because the hookForEvent method doesn't see the click on the menubar.
+
+// Gets called when the menubar is clicked.
+- (void)begunTracking:(NSNotification *)notification {
+  [self closeFolderAndStopTrackingMenus];
+}
+
+// Install the callback.
+- (void)startObservingMenubar {
+  NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
+  [nc addObserver:self
+         selector:@selector(begunTracking:)
+             name:NSMenuDidBeginTrackingNotification
+           object:[NSApp mainMenu]];
+}
+
+// Remove the callback.
+- (void)stopObservingMenubar {
+  NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
+  [nc removeObserver:self
+                name:NSMenuDidBeginTrackingNotification
+              object:[NSApp mainMenu]];
+}
+
+// End of menubar observation code.
+
+// Begin (or end) watching for a click outside this window.  Unlike
+// normal NSWindows, bookmark folder "fake menu" windows do not become
+// key or main.  Thus, traditional notification (e.g. WillResignKey)
+// won't work.  Our strategy is to watch (at the app level) for a
+// "click outside" these windows to detect when they logically lose
+// focus.
+- (void)watchForExitEvent:(BOOL)watch {
+  CrApplication* app = static_cast<CrApplication*>([NSApplication
+                                                    sharedApplication]);
+  DCHECK([app isKindOfClass:[CrApplication class]]);
+  if (watch) {
+    if (!watchingForExitEvent_) {
+      [app addEventHook:self];
+      [self startObservingMenubar];
+    }
+  } else {
+    if (watchingForExitEvent_) {
+      [app removeEventHook:self];
+      [self stopObservingMenubar];
+    }
+  }
+  watchingForExitEvent_ = watch;
+}
+
 // Keep the "no items" label centered in response to a frame size change.
 - (void)centerNoItemsLabel {
   // Note that this computation is done in the parent's coordinate system,
   // which is unflipped. Also, we want the label to be a fixed distance from
   // the bottom, so that it slides up properly (on animating to hidden).
   // The textfield sits in the itemcontainer, so to center it we maintain
   // equal vertical padding on the top and bottom.
   int yoffset = (NSHeight([[buttonView_ noItemTextfield] frame]) -
                  NSHeight([[buttonView_ noItemContainer] frame])) / 2;
   [[buttonView_ noItemContainer] setFrameOrigin:NSMakePoint(0, yoffset)];
@@ skipping 851 matching lines @@
   NSColor* color =
       themeProvider->GetNSColor(ThemeService::COLOR_BOOKMARK_TEXT,
                                 true);
   for (BookmarkButton* button in buttons_.get()) {
     BookmarkButtonCell* cell = [button cell];
     [cell setTextColor:color];
   }
   [[otherBookmarksButton_ cell] setTextColor:color];
 }
 
+// Return YES if the event indicates an exit from the bookmark bar
+// folder menus.  E.g. "click outside" of the area we are watching.
+// At this time we are watching the area that includes all popup
+// bookmark folder windows.
+- (BOOL)isEventAnExitEvent:(NSEvent*)event {
+  NSWindow* eventWindow = [event window];
+  NSWindow* myWindow = [[self view] window];
+  switch ([event type]) {
+    case NSLeftMouseDown:
+    case NSRightMouseDown:
+      // If the click is in my window but NOT in the bookmark bar, consider
+      // it a click 'outside'. Clicks directly on an active button (i.e. one
+      // that is a folder and for which its folder menu is showing) are 'in'.
+      // 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
+      // http://crbug.com/49333
+      return NO;
+    default:
+      break;
+  }
+  return NO;
+}
+
 #pragma mark Drag & Drop
 
 // Find something like std::is_between<T>?  I can't believe one doesn't exist.
 static BOOL ValueInRangeInclusive(CGFloat low, CGFloat value, CGFloat high) {
   return ((value >= low) && (value <= high));
 }
 
 // Return the proposed drop target for a hover open button from the
 // given array, or nil if none.  We use this for distinguishing
 // between a hover-open candidate or drop-indicator draw.
@@ skipping 318 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 20 matching lines @@
   [button setHidden:NO];
   [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 {
-  [folderController_ closeMenu];
+  [self watchForExitEvent:NO];
+  [folderController_ close];
   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
-                                                  bookmarkModel:bookmarkModel_
+                                               parentController:nil
                                                   barController:self];
-  [folderController_ autorelease];
+  [folderController_ showWindow:self];
 
-  // If this is for the off-the-side menu, set the display count.
-  if (parentButton == offTheSideButton_)
-    [folderController_ setOffTheSideNodeStartIndex:displayedButtonCount_];
-
-  [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];
 }
 
 - (void)openAll:(const BookmarkNode*)node
     disposition:(WindowOpenDisposition)disposition {
   [self closeFolderAndStopTrackingMenus];
@@ skipping 20 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 nil;
+  return [folderController_ controllerForNode:node];
+}
+
+#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