[Mac] Refactor the fullscreen menubar

chrome/browser/ui/cocoa/fullscreen_toolbar_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/fullscreen_toolbar_controller.h"
 
 #include <algorithm>
 
 #import "base/auto_reset.h"
 #include "base/command_line.h"
 #import "base/mac/mac_util.h"
 #include "base/mac/sdk_forward_declarations.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
+#import "chrome/browser/ui/cocoa/fullscreen/fullscreen_menubar_tracker.h"
 #include "chrome/common/chrome_switches.h"
 #import "third_party/google_toolbox_for_mac/src/AppKit/GTMNSAnimation+Duration.h"
+#include "ui/base/cocoa/appkit_utils.h"
 #import "ui/base/cocoa/nsview_additions.h"
 #import "ui/base/cocoa/tracking_area.h"
 
 namespace {
 
 // The duration of the toolbar show/hide animation.
 const NSTimeInterval kDropdownAnimationDuration = 0.20;
 
 // If the fullscreen toolbar is hidden, it is difficult for the user to see
 // changes in the tabstrip. As a result, if a tab is inserted or the current
 // tab switched to a new one, the toolbar must animate in and out to display
 // the tabstrip changes to the user. The animation drops down the toolbar and
 // then wait for 0.75 seconds before it hides the toolbar.
 const NSTimeInterval kTabStripChangesDelay = 0.75;
 
 // Additional height threshold added at the toolbar's bottom. This is to mimic
 // threshold the mouse position needs to be at before the menubar automatically
 // hides.
 const CGFloat kTrackingAreaAdditionalThreshold = 20;
 
-// The event kind value for a undocumented menubar show/hide Carbon event.
-const CGFloat kMenuBarRevealEventKind = 2004;
-
-// The amount by which the floating bar is offset downwards (to avoid the menu)
-// when the toolbar is hidden. (We can't use |-[NSMenu menuBarHeight]| since it
-// returns 0 when the menu bar is hidden.)
-const CGFloat kFloatingBarVerticalOffset = 22;
-
 // Visibility fractions for the menubar and toolbar.
 const CGFloat kHideFraction = 0.0;
 const CGFloat kShowFraction = 1.0;
 
-// Helper function for comparing CGFloat values.
-BOOL IsCGFloatEqual(CGFloat a, CGFloat b) {
-  return fabs(a - b) <= std::numeric_limits<CGFloat>::epsilon();
-}
-
-OSStatus MenuBarRevealHandler(EventHandlerCallRef handler,
-                              EventRef event,
-                              void* context) {
-  FullscreenToolbarController* self =
-      static_cast<FullscreenToolbarController*>(context);
-
-  // If Chrome has multiple fullscreen windows in their own space, the Handler
-  // becomes flaky and might start receiving kMenuBarRevealEventKind events
-  // from another space. Since the menubar in the another space is in either a
-  // shown or hidden state, it will give us a reveal fraction of 0.0 or 1.0.
-  // As such, we should ignore the kMenuBarRevealEventKind event if it gives
-  // us a fraction of 0.0 or 1.0, and rely on kEventMenuBarShown and
-  // kEventMenuBarHidden to set these values.
-  if (![self isFullscreenTransitionInProgress] && [self isInFullscreen]) {
-    if (GetEventKind(event) == kMenuBarRevealEventKind) {
-      CGFloat revealFraction = 0;
-      GetEventParameter(event, FOUR_CHAR_CODE('rvlf'), typeCGFloat, NULL,
-                        sizeof(CGFloat), NULL, &revealFraction);
-      if (revealFraction > kHideFraction && revealFraction < kShowFraction)
-        [self setMenuBarRevealProgress:revealFraction];
-    } else if (GetEventKind(event) == kEventMenuBarShown) {
-      [self setMenuBarRevealProgress:kShowFraction];
-    } else {
-      [self setMenuBarRevealProgress:kHideFraction];
-    }
-  }
-
-  return CallNextEventHandler(handler, event);
-}
+// The amount by which the toolbar is offset downwards (to avoid the menu)
+// when the toolbar style is OMNIBOX_TABS_HIDDEN. (We can't use
+// |-[NSMenu menuBarHeight]| since it returns 0 when the menu bar is hidden.)
+const CGFloat kToolbarVerticalOffset = 22;
 
 }  // end namespace
 
 // Helper class to manage animations for the dropdown bar.  Calls
 // [FullscreenToolbarController changeToolbarFraction] once per
 // animation step.
 @interface DropdownAnimation : NSAnimation {
  @private
   FullscreenToolbarController* controller_;
   CGFloat startFraction_;
@@ skipping 93 matching lines @@
 @implementation FullscreenToolbarController
 
 @synthesize slidingStyle = slidingStyle_;
 
 - (id)initWithBrowserController:(BrowserWindowController*)controller
                           style:(FullscreenSlidingStyle)style {
   if ((self = [super init])) {
     browserController_ = controller;
     systemFullscreenMode_ = base::mac::kFullScreenModeNormal;
     slidingStyle_ = style;
-    menubarState_ = FullscreenMenubarState::HIDDEN;
   }
 
-  // Install the Carbon event handler for the menubar show, hide and
-  // undocumented reveal event.
-  EventTypeSpec eventSpecs[3];
-
-  eventSpecs[0].eventClass = kEventClassMenu;
-  eventSpecs[0].eventKind = kMenuBarRevealEventKind;
-
-  eventSpecs[1].eventClass = kEventClassMenu;
-  eventSpecs[1].eventKind = kEventMenuBarShown;
-
-  eventSpecs[2].eventClass = kEventClassMenu;
-  eventSpecs[2].eventKind = kEventMenuBarHidden;
-
-  InstallApplicationEventHandler(NewEventHandlerUPP(&MenuBarRevealHandler), 3,
-                                 eventSpecs, self, &menuBarTrackingHandler_);
-
   return self;
 }
 
 - (void)dealloc {
-  RemoveEventHandler(menuBarTrackingHandler_);
   DCHECK(!inFullscreenMode_);
   [super dealloc];
 }
 
 - (void)setupFullscreenToolbarForContentView:(NSView*)contentView {
   DCHECK(!inFullscreenMode_);
   contentView_ = contentView;
   inFullscreenMode_ = YES;
 
+  menubarTracker_.reset([[FullscreenMenubarTracker alloc]
+      initWithFullscreenToolbarController:self]);
+
   [self updateMenuBarAndDockVisibility];
 
   // Register for notifications.  Self is removed as an observer in |-cleanup|.
   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
   NSWindow* window = [browserController_ window];
 
   [nc addObserver:self
          selector:@selector(windowDidBecomeMain:)
              name:NSWindowDidBecomeMainNotification
            object:window];
 
   [nc addObserver:self
          selector:@selector(windowDidResignMain:)
              name:NSWindowDidResignMainNotification
            object:window];
-
-  // Register for Active Space change notifications.
-  [[[NSWorkspace sharedWorkspace] notificationCenter]
-      addObserver:self
-         selector:@selector(activeSpaceDidChange:)
-             name:NSWorkspaceActiveSpaceDidChangeNotification
-           object:nil];
 }
 
 - (void)exitFullscreenMode {
   DCHECK(inFullscreenMode_);
   inFullscreenMode_ = NO;
 
   [self cleanup];
 }
 
 - (void)windowDidChangeScreen:(NSNotification*)notification {
   [browserController_ resizeFullscreenWindow];
 }
 
 - (void)windowDidMove:(NSNotification*)notification {
   [browserController_ resizeFullscreenWindow];
 }
 
 - (void)windowDidBecomeMain:(NSNotification*)notification {
   [self updateMenuBarAndDockVisibility];
 }
 
 - (void)windowDidResignMain:(NSNotification*)notification {
   [self updateMenuBarAndDockVisibility];
 }
 
-- (void)activeSpaceDidChange:(NSNotification*)notification {
-  menubarFraction_ = kHideFraction;
-  menubarState_ = FullscreenMenubarState::HIDDEN;
-  [browserController_ layoutSubviews];
-}
-
-- (CGFloat)floatingBarVerticalOffset {
-  return kFloatingBarVerticalOffset;
-}
-
 - (void)lockBarVisibilityWithAnimation:(BOOL)animate {
   base::AutoReset<BOOL> autoReset(&isLockingBarVisibility_, YES);
   [self ensureOverlayShownWithAnimation:animate];
 }
 
 - (void)releaseBarVisibilityWithAnimation:(BOOL)animate {
   base::AutoReset<BOOL> autoReset(&isReleasingBarVisibility_, YES);
   [self ensureOverlayHiddenWithAnimation:animate];
 }
 
@@ skipping 15 matching lines @@
   if (!inFullscreenMode_)
     return;
 
   if (self.slidingStyle != FullscreenSlidingStyle::OMNIBOX_TABS_HIDDEN)
     return;
 
   if ([browserController_ isBarVisibilityLockedForOwner:nil])
     return;
 
   if ([self mouseInsideTrackingArea] ||
-      menubarState_ == FullscreenMenubarState::SHOWN) {
+      [menubarTracker_ state] == FullscreenMenubarState::SHOWN) {
     return;
   }
 
   [self cancelHideTimer];
   [self animateToolbarVisibility:NO];
 }
 
 - (void)cancelAnimationAndTimer {
   [self cancelHideTimer];
   [currentAnimation_ stopAnimation];
   currentAnimation_.reset();
 }
 
 - (void)revealToolbarForTabStripChanges {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableFullscreenToolbarReveal)) {
     return;
   }
 
   // Reveal the toolbar for tabstrip changes if the toolbar is hidden.
-  if (IsCGFloatEqual([self toolbarFraction], kHideFraction)) {
+  if (ui::IsCGFloatEqual([self toolbarFraction], kHideFraction)) {
     isRevealingToolbarForTabStripChanges_ = YES;
     [self ensureOverlayShownWithAnimation:YES];
   }
 }
 
 - (void)setSystemFullscreenModeTo:(base::mac::FullScreenMode)mode {
   if (mode == systemFullscreenMode_)
     return;
   if (systemFullscreenMode_ == base::mac::kFullScreenModeNormal)
     base::mac::RequestFullScreen(mode);
   else if (mode == base::mac::kFullScreenModeNormal)
     base::mac::ReleaseFullScreen(systemFullscreenMode_);
   else
     base::mac::SwitchFullScreenModes(systemFullscreenMode_, mode);
   systemFullscreenMode_ = mode;
 }
 
 - (void)mouseEntered:(NSEvent*)event {
   // Empty implementation. Required for CrTrackingArea.
 }
 
 - (void)mouseExited:(NSEvent*)event {
   DCHECK(inFullscreenMode_);
   DCHECK_EQ([event trackingArea], trackingArea_.get());
 
   if ([browserController_ isBarVisibilityLockedForOwner:nil])
     return;
 
   // If the menubar is gone, animate the toolbar out.
-  if (menubarState_ == FullscreenMenubarState::HIDDEN) {
+  if ([menubarTracker_ state] == FullscreenMenubarState::HIDDEN) {
     base::AutoReset<BOOL> autoReset(&shouldAnimateToolbarOut_, YES);
     [self ensureOverlayHiddenWithAnimation:YES];
   }
 
   [self removeTrackingAreaIfNecessary];
 }
 
 - (void)updateToolbar {
   [browserController_ layoutSubviews];
+  [self updateTrackingArea];
 
   // In AppKit fullscreen, moving the mouse to the top of the screen toggles
   // menu visibility. Replicate the same effect for immersive fullscreen.
   if ([browserController_ isInImmersiveFullscreen])
     [self updateMenuBarAndDockVisibility];
 }
 
+- (BrowserWindowController*)browserWindowController {
+  return browserController_;
+}
+
 // This method works, but is fragile.
 //
 // It gets used during view layout, which sometimes needs to be done at the
 // beginning of an animation. As such, this method needs to reflect the
 // menubarOffset expected at the end of the animation. This information is not
 // readily available. (The layout logic needs a refactor).
 //
 // For AppKit Fullscreen, the menubar always starts hidden, and
 // menubarFraction_ always starts at 0, so the logic happens to work. For
 // Immersive Fullscreen, this class controls the visibility of the menu bar, so
 // the logic is correct and not fragile.
 - (CGFloat)menubarOffset {
-  if ([browserController_ isInAppKitFullscreen])
-    return -std::floor(menubarFraction_ * [self floatingBarVerticalOffset]);
+  if ([browserController_ isInAppKitFullscreen]) {
+    return -std::floor([menubarTracker_ menubarFraction] *
+                       kToolbarVerticalOffset);
+  }
 
-  return [self shouldShowMenubarInImmersiveFullscreen]
-             ? -[self floatingBarVerticalOffset]
-             : 0;
+  return [self shouldShowMenubarInImmersiveFullscreen] ? -kToolbarVerticalOffset
+                                                       : 0;
 }
 
 - (CGFloat)toolbarFraction {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode))
     return kHideFraction;
 
   switch (slidingStyle_) {
     case FullscreenSlidingStyle::OMNIBOX_TABS_PRESENT:
       return kShowFraction;
     case FullscreenSlidingStyle::OMNIBOX_TABS_NONE:
       return kHideFraction;
     case FullscreenSlidingStyle::OMNIBOX_TABS_HIDDEN:
-      if (menubarState_ == FullscreenMenubarState::SHOWN)
+      FullscreenMenubarState menubarState = [menubarTracker_ state];
+      if (menubarState == FullscreenMenubarState::SHOWN)
         return kShowFraction;
 
       if ([self mouseInsideTrackingArea])
         return kShowFraction;
 
       if (currentAnimation_.get())
         return [currentAnimation_ toolbarFraction];
 
       if (isLockingBarVisibility_)
         return kHideFraction;
       else if (isReleasingBarVisibility_)
         return kShowFraction;
       else if ([browserController_ isBarVisibilityLockedForOwner:nil])
         return kShowFraction;
 
       if (hideTimer_.get() || shouldAnimateToolbarOut_)
         return kShowFraction;
 
-      return menubarFraction_;
+      return [menubarTracker_ menubarFraction];
   }
 }
 
 - (BOOL)isFullscreenTransitionInProgress {
   return [browserController_ isFullscreenTransitionInProgress];
 }
 
 - (BOOL)isInFullscreen {
   return inFullscreenMode_;
 }
@@ skipping 29 matching lines @@
 
   // Reset the |currentAnimation_| pointer now that the animation is over.
   currentAnimation_.reset();
 }
 
 - (void)animationDidEnd:(NSAnimation*)animation {
   [self animationDidStop:animation];
   [self updateTrackingArea];
 }
 
-- (void)setMenuBarRevealProgress:(CGFloat)progress {
-  // If the menubarFraction increases, check if we are in the right screen
-  // so that the toolbar is not revealed on the wrong screen.
-  if (![self isMouseOnScreen] && progress > menubarFraction_)
-    return;
-
-  // Ignore the menubarFraction changes if the Space is inactive.
-  if (![[browserController_ window] isOnActiveSpace])
-    return;
-
-  if (IsCGFloatEqual(progress, kShowFraction))
-    menubarState_ = FullscreenMenubarState::SHOWN;
-  else if (IsCGFloatEqual(progress, kHideFraction))
-    menubarState_ = FullscreenMenubarState::HIDDEN;
-  else if (progress < menubarFraction_)
-    menubarState_ = FullscreenMenubarState::HIDING;
-  else if (progress > menubarFraction_)
-    menubarState_ = FullscreenMenubarState::SHOWING;
-
-  menubarFraction_ = progress;
-
-  if (slidingStyle_ == FullscreenSlidingStyle::OMNIBOX_TABS_HIDDEN) {
-    if (menubarState_ == FullscreenMenubarState::HIDDEN ||
-        menubarState_ == FullscreenMenubarState::SHOWN) {
-      [self updateTrackingArea];
-    }
-  }
-
-  // If an animation is not running, then -layoutSubviews will not be called
-  // for each tick of the menu bar reveal. Do that manually.
-  // TODO(erikchen): The animation is janky. layoutSubviews need a refactor so
-  // that it calls setFrameOffset: instead of setFrame: if the frame's size has
-  // not changed.
-  if (!currentAnimation_.get())
-    [browserController_ layoutSubviews];
-}
-
 @end
 
 @implementation FullscreenToolbarController (PrivateMethods)
 
 - (void)updateMenuBarAndDockVisibility {
   if (![self isMouseOnScreen] ||
       ![browserController_ isInImmersiveFullscreen]) {
     [self setSystemFullscreenModeTo:base::mac::kFullScreenModeNormal];
     return;
   }
 
   // The screen does not have a menu bar, so there's no need to hide it.
   if (![self doesScreenHaveMenuBar]) {
     [self setSystemFullscreenModeTo:base::mac::kFullScreenModeHideDock];
     return;
   }
 
   [self setSystemFullscreenModeTo:[self desiredSystemFullscreenMode]];
 }
 
 - (void)updateTrackingArea {
   // Remove the tracking area if the toolbar isn't fully shown.
-  if (!IsCGFloatEqual([self toolbarFraction], kShowFraction)) {
+  if (!ui::IsCGFloatEqual([self toolbarFraction], kShowFraction)) {
     [self removeTrackingAreaIfNecessary];
     return;
   }
 
   if (trackingArea_) {
     // If the tracking rectangle is already |trackingAreaBounds_|, quit early.
     NSRect oldRect = [trackingArea_ rect];
     if (NSEqualRects(trackingAreaFrame_, oldRect))
       return;
 
@@ skipping 88 matching lines @@
   DCHECK_EQ(hideTimer_, timer);  // This better be our hide timer.
   [hideTimer_ invalidate];       // Make sure it doesn't repeat.
   hideTimer_.reset();            // And get rid of it.
   base::AutoReset<BOOL> autoReset(&shouldAnimateToolbarOut_, YES);
   [self animateToolbarVisibility:NO];
 }
 
 - (void)cleanup {
   [self cancelAnimationAndTimer];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
-  [[[NSWorkspace sharedWorkspace] notificationCenter] removeObserver:self];
 
   [self removeTrackingAreaIfNecessary];
 
   // Call the main status resignation code to perform the associated cleanup,
   // since we will no longer be receiving actual status resignation
   // notifications.
   [self setSystemFullscreenModeTo:base::mac::kFullScreenModeNormal];
 
+  menubarTracker_.reset();
+
   // No more calls back up to the BWC.
   browserController_ = nil;
 }
 
 - (BOOL)shouldShowMenubarInImmersiveFullscreen {
   return [self doesScreenHaveMenuBar] && [self toolbarFraction] > 0.99;
 }
 
 @end