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

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

+// Copyright (c) 2010 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_folder_hover_state.h"
+#import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.h"
+
+@interface BookmarkBarFolderHoverState(Private)
+- (void)setHoverState:(HoverState)state;
+- (void)closeBookmarkFolderOnHoverButton:(BookmarkButton*)button;
+- (void)openBookmarkFolderOnHoverButton:(BookmarkButton*)button;
+@end
+
+@implementation BookmarkBarFolderHoverState
+
+- (id)init {
+  if ((self = [super init])) {
+    hoverState_ = kHoverStateClosed;
+  }
+  return self;
+}
+
+- (NSDragOperation)draggingEnteredButton:(BookmarkButton*)button {
+  if ([button isFolder]) {
+    if (hoverButton_ == button) {
+      // CASE A: hoverButton_ == button implies we've dragged over
+      // the same folder so no need to open or close anything new.
+    } else if (hoverButton_ &&
+               hoverButton_ != button) {
+      // CASE B: we have a hoverButton_ but it is different from the new button.
+      // This implies we've dragged over a new folder, so we'll close the old
+      // and open the new.
+      // Note that we only schedule the open or close if we have no other tasks
+      // currently pending.
+
+      if (hoverState_ == kHoverStateOpen) {
+        // Close the old.
+        [self scheduleCloseBookmarkFolderOnHoverButton];
+      } else if (hoverState_ == kHoverStateClosed) {
+        // Open the new.
+        [self scheduleOpenBookmarkFolderOnHoverButton:button];
+      }
+    } else if (!hoverButton_) {
+      // CASE C: we don't have a current hoverButton_ but we have dragged onto
+      // a new folder so we open the new one.
+      [self scheduleOpenBookmarkFolderOnHoverButton:button];
+    }
+  } else if (!button) {
+    if (hoverButton_) {
+      // CASE D: We have a hoverButton_ but we've moved onto an area that
+      // requires no hover.  We close the hoverButton_ in this case.  This
+      // means cancelling if the open is pending (i.e. |kHoverStateOpening|)
+      // or closing if we don't alrealy have once in progress.
+
+      // Intiate close only if we have not already done so.
+      if (hoverState_ == kHoverStateOpening) {
+        // Cancel the pending open.
+        [self cancelPendingOpenBookmarkFolderOnHoverButton];
+      } else if (hoverState_ != kHoverStateClosing) {
+        // Schedule the close.
+        [self scheduleCloseBookmarkFolderOnHoverButton];
+      }
+    } else {
+      // CASE E: We have neither a hoverButton_ nor a new button that requires
+      // a hover.  In this case we do nothing.
+    }
+  }
+
+  return NSDragOperationMove;
+}
+
+- (void)draggingExited {
+  if (hoverButton_) {
+    if (hoverState_ == kHoverStateOpening) {
+      [self cancelPendingOpenBookmarkFolderOnHoverButton];
+    } else if (hoverState_ == kHoverStateClosing) {
+      [self cancelPendingCloseBookmarkFolderOnHoverButton];
+    }
+  }
+}
+
+// Schedule close of hover button.  Transition to kHoverStateClosing state.
+- (void)scheduleCloseBookmarkFolderOnHoverButton {
+  DCHECK(hoverButton_);
+  [self setHoverState:kHoverStateClosing];
+  [self performSelector:@selector(closeBookmarkFolderOnHoverButton:)
+             withObject:hoverButton_
+             afterDelay:bookmarks::kDragHoverCloseDelay
+                inModes:[NSArray arrayWithObject:NSRunLoopCommonModes]];
+}
+
+// Cancel pending hover close.  Transition to kHoverStateOpen state.
+- (void)cancelPendingCloseBookmarkFolderOnHoverButton {
+  [self setHoverState:kHoverStateOpen];
+  [NSObject
+      cancelPreviousPerformRequestsWithTarget:self
+      selector:@selector(closeBookmarkFolderOnHoverButton:)
+      object:hoverButton_];
+}
+
+// Schedule open of hover button.  Transition to kHoverStateOpening state.
+- (void)scheduleOpenBookmarkFolderOnHoverButton:(BookmarkButton*)button {
+  DCHECK(button);
+  hoverButton_.reset([button retain]);
+  [self setHoverState:kHoverStateOpening];
+  [self performSelector:@selector(openBookmarkFolderOnHoverButton:)
+             withObject:hoverButton_
+             afterDelay:bookmarks::kDragHoverOpenDelay
+                inModes:[NSArray arrayWithObject:NSRunLoopCommonModes]];
+}
+
+// Cancel pending hover open.  Transition to kHoverStateClosed state.
+- (void)cancelPendingOpenBookmarkFolderOnHoverButton {
+  [self setHoverState:kHoverStateClosed];
+  [NSObject
+      cancelPreviousPerformRequestsWithTarget:self
+      selector:@selector(openBookmarkFolderOnHoverButton:)
+      object:hoverButton_];
+  hoverButton_.reset();
+}
+
+// Hover button accessor.  For testing only.
+- (BookmarkButton*)hoverButton {
+  return hoverButton_;
+}
+
+// Hover state accessor.  For testing only.
+- (HoverState)hoverState {
+  return hoverState_;
+}
+
+// This method encodes the rules of our |hoverButton_| state machine.  Only
+// specific state transitions are allowable (encoded in the DCHECK).
+// Note that there is no state for simultaneously opening and closing.  A
+// pending open must complete before scheduling a close, and vice versa.  And
+// it is not possible to make a transition directly from open to closed, and
+// vice versa.
+- (void)setHoverState:(HoverState)state {
+  DCHECK(
+    (hoverState_ == kHoverStateClosed && state == kHoverStateOpening) ||
+    (hoverState_ == kHoverStateOpening && state == kHoverStateClosed) ||
+    (hoverState_ == kHoverStateOpening && state == kHoverStateOpen) ||
+    (hoverState_ == kHoverStateOpen && state == kHoverStateClosing) ||
+    (hoverState_ == kHoverStateClosing && state == kHoverStateOpen) ||
+    (hoverState_ == kHoverStateClosing && state == kHoverStateClosed)
+  ) << "bad transition: old = " << hoverState_ << " new = " << state;
+
+  hoverState_ = state;
+}
+
+// Called after a delay to close a previously hover-opened folder.
+// Note: this method is not meant to be invoked directly, only through
+// a delayed call to |scheduleCloseBookmarkFolderOnHoverButton:|.
+- (void)closeBookmarkFolderOnHoverButton:(BookmarkButton*)button {
+  [NSObject
+      cancelPreviousPerformRequestsWithTarget:self
+      selector:@selector(closeBookmarkFolderOnHoverButton:)
+      object:hoverButton_];
+  [self setHoverState:kHoverStateClosed];
+  [[button target] closeBookmarkFolder:button];
+  hoverButton_.reset();
+}
+
+// Called after a delay to open a new hover folder.
+// Note: this method is not meant to be invoked directly, only through
+// a delayed call to |scheduleOpenBookmarkFolderOnHoverButton:|.
+- (void)openBookmarkFolderOnHoverButton:(BookmarkButton*)button {
+  [self setHoverState:kHoverStateOpen];
+  [[button target] performSelector:@selector(openBookmarkFolderFromButton:)
+      withObject:button];
+}
+
+@end