[Mac] Fix for fullscreen toolbar

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>
 
 #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"
 #include "chrome/common/chrome_switches.h"
 #import "third_party/google_toolbox_for_mac/src/AppKit/GTMNSAnimation+Duration.h"
 #import "ui/base/cocoa/nsview_additions.h"
+#import "ui/base/cocoa/tracking_area.h"
 
 namespace {
 
-// The activation zone for the main menu is 4 pixels high; if we make it any
-// smaller, then the menu can be made to appear without the bar sliding down.
-const NSTimeInterval kDropdownAnimationDuration = 0.12;
+// The duration of the toolbar show/hide animation.
+const NSTimeInterval kDropdownAnimationDuration = 0.20;
 
-// The duration the toolbar is revealed for tab strip changes.
-const NSTimeInterval kDropdownForTabStripChangesDuration = 0.75;
+// 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;
 
 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]) {
+  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 > 0.0 && revealFraction < 1.0)
         [self setMenuBarRevealProgress:revealFraction];
     } else if (GetEventKind(event) == kEventMenuBarShown) {
       [self setMenuBarRevealProgress:1.0];
     } else {
       [self setMenuBarRevealProgress:0.0];
     }
   }
 
   return CallNextEventHandler(handler, event);
 }
 
 }  // 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_;
   CGFloat endFraction_;
+  CGFloat toolbarFraction_;
 }
 
-@property(readonly, nonatomic) CGFloat startFraction;
 @property(readonly, nonatomic) CGFloat endFraction;
+@property(readonly, nonatomic) CGFloat toolbarFraction;
 
 // Designated initializer.  Asks |controller| for the current shown fraction, so
 // if the bar is already partially shown or partially hidden, the animation
 // duration may be less than |fullDuration|.
 - (id)initWithFraction:(CGFloat)fromFraction
           fullDuration:(CGFloat)fullDuration
         animationCurve:(NSAnimationCurve)animationCurve
             controller:(FullscreenToolbarController*)controller;
 
 @end
 
 @implementation DropdownAnimation
 
-@synthesize startFraction = startFraction_;
 @synthesize endFraction = endFraction_;
+@synthesize toolbarFraction = toolbarFraction_;
 
 - (id)initWithFraction:(CGFloat)toFraction
           fullDuration:(CGFloat)fullDuration
         animationCurve:(NSAnimationCurve)animationCurve
             controller:(FullscreenToolbarController*)controller {
   // Calculate the effective duration, based on the current shown fraction.
   DCHECK(controller);
-  CGFloat fromFraction = controller.toolbarFraction;
+  CGFloat fromFraction = [controller toolbarFraction];
   CGFloat effectiveDuration = fabs(fullDuration * (fromFraction - toFraction));
 
   if ((self = [super gtm_initWithDuration:effectiveDuration
                                 eventMask:NSLeftMouseDownMask
                            animationCurve:animationCurve])) {
     startFraction_ = fromFraction;
     endFraction_ = toFraction;
     controller_ = controller;
   }
   return self;
 }
 
 // Called once per animation step.  Overridden to change the floating bar's
 // position based on the animation's progress.
 - (void)setCurrentProgress:(NSAnimationProgress)progress {
-  CGFloat fraction =
+  toolbarFraction_ =
       startFraction_ + (progress * (endFraction_ - startFraction_));
-  [controller_ changeToolbarFraction:fraction];
+  [controller_ updateToolbar];
 }
 
 @end
 
 @interface FullscreenToolbarController (PrivateMethods)
 
 // Updates the visibility of the menu bar and the dock.
 - (void)updateMenuBarAndDockVisibility;
 
+// Methods to set up or remove the tracking area.
+- (void)setupTrackingArea;
+- (void)removeTrackingAreaIfNecessary;
+
+// Returns YES if the mouse is inside the tracking area.
+- (BOOL)mouseInsideTrackingArea;
+
 // Whether the current screen is expected to have a menu bar, regardless of
 // current visibility of the menu bar.
 - (BOOL)doesScreenHaveMenuBar;
 
 // Returns YES if the window is on the primary screen.
 - (BOOL)isWindowOnPrimaryScreen;
 
 // Returns |kFullScreenModeHideAll| when the overlay is hidden and
 // |kFullScreenModeHideDock| when the overlay is shown.
 - (base::mac::FullScreenMode)desiredSystemFullscreenMode;
 
-// Change the overlay to the given fraction, with or without animation. Only
-// guaranteed to work properly with |fraction == 0| or |fraction == 1|. This
-// performs the show/hide (animation) immediately. It does not touch the timers.
-- (void)changeOverlayToFraction:(CGFloat)fraction withAnimation:(BOOL)animate;
+// Animate the overlay to the given visibility with animation. If |visible|
+// is true, animate the toolbar to a fraction of 1.0. Otherwise it's 0.0.
+- (void)animateToolbarVisibility:(BOOL)visible;
 
 // Cancels the timer for hiding the floating bar.
 - (void)cancelHideTimer;
 
 // Methods called when the hide timers fire. Do not call directly.
 - (void)hideTimerFire:(NSTimer*)timer;
 
 // Stops any running animations, etc.
 - (void)cleanup;
 
-// Shows and hides the UI associated with this window being active (having main
-// status).  This includes hiding the menu bar.  These functions are called when
-// the window gains or loses main status as well as in |-cleanup|.
-- (void)showActiveWindowUI;
-- (void)hideActiveWindowUI;
-
 // Whether the menu bar should be shown in immersive fullscreen for the screen
 // that contains the window.
 - (BOOL)shouldShowMenubarInImmersiveFullscreen;
 
 @end
 
 @implementation FullscreenToolbarController
 
 @synthesize slidingStyle = slidingStyle_;
-@synthesize toolbarFraction = toolbarFraction_;
 
 - (id)initWithBrowserController:(BrowserWindowController*)controller
                           style:(fullscreen_mac::SlidingStyle)style {
   if ((self = [super init])) {
     browserController_ = controller;
     systemFullscreenMode_ = base::mac::kFullScreenModeNormal;
     slidingStyle_ = style;
   }
 
   // Install the Carbon event handler for the menubar show, hide and
@@ skipping 14 matching lines @@
 
   return self;
 }
 
 - (void)dealloc {
   RemoveEventHandler(menuBarTrackingHandler_);
   DCHECK(!inFullscreenMode_);
   [super dealloc];
 }
 
-- (void)setupFullscreenToolbarWithDropdown:(BOOL)showDropdown {
+- (void)setupFullscreenToolbarForContentView:(NSView*)contentView {
   DCHECK(!inFullscreenMode_);
+  contentView_ = contentView;
   inFullscreenMode_ = YES;
-  [self changeToolbarFraction:(showDropdown ? 1 : 0)];
+
   [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];
@@ skipping 13 matching lines @@
 
 - (void)windowDidChangeScreen:(NSNotification*)notification {
   [browserController_ resizeFullscreenWindow];
 }
 
 - (void)windowDidMove:(NSNotification*)notification {
   [browserController_ resizeFullscreenWindow];
 }
 
 - (void)windowDidBecomeMain:(NSNotification*)notification {
-  [self showActiveWindowUI];
+  [self updateMenuBarAndDockVisibility];
 }
 
 - (void)windowDidResignMain:(NSNotification*)notification {
-  [self hideActiveWindowUI];
+  [self updateMenuBarAndDockVisibility];
 }
 
 - (CGFloat)floatingBarVerticalOffset {
   return kFloatingBarVerticalOffset;
 }
 
 - (void)ensureOverlayShownWithAnimation:(BOOL)animate {
   if (!inFullscreenMode_)
     return;
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode))
     return;
 
-  if (self.slidingStyle == fullscreen_mac::OMNIBOX_TABS_PRESENT)
+  if (self.slidingStyle != fullscreen_mac::OMNIBOX_TABS_HIDDEN)
     return;
 
   [self cancelHideTimer];
-  [self changeOverlayToFraction:1 withAnimation:animate];
+  [self animateToolbarVisibility:YES];
 }
 
 - (void)ensureOverlayHiddenWithAnimation:(BOOL)animate {
   if (!inFullscreenMode_)
     return;
 
-  if (self.slidingStyle == fullscreen_mac::OMNIBOX_TABS_PRESENT)
+  if (self.slidingStyle != fullscreen_mac::OMNIBOX_TABS_HIDDEN)
     return;
 
   [self cancelHideTimer];
-  [self changeOverlayToFraction:0 withAnimation:animate];
+  [self animateToolbarVisibility:NO];
 }
 
 - (void)cancelAnimationAndTimer {
   [self cancelHideTimer];
   [currentAnimation_ stopAnimation];
   currentAnimation_.reset();
 }
 
 - (void)revealToolbarForTabStripChanges {

[erikchen, 2016/08/24 23:52:58]

nit: Having a method named "foo" which changes the value of an ivar named "foo_"
is an antipattern. "foo" should be a getter, and "setFoo:" should be the setter.
Read more about this here:
https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/Coding...

Based on my understanding of the use of this ivar, I recommend:
keep the name of the method -revealToolbarForTabStripChanges.
Change the ivar to be called isRevealingToolbarForTabStripChanges_.

[spqchan, 2016/08/26 00:46:30]

Done.

   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableFullscreenToolbarReveal)) {
     return;
   }
 
-  revealToolbarForTabStripChanges_ = YES;
-  [self ensureOverlayShownWithAnimation:YES];
+  // Reveal the toolbar for tabstrip changes if the toolbar
+  // isn't shown.
+  if ([self toolbarFraction] == 0.0) {

[erikchen, 2016/08/24 23:52:58]

nit: You have a lot of double comparisons in your CL. They happen to work
because 0.0 and 1.0 have exact representations in IEEE754. That being said, an
implicit casts between double and floats will cause problems:
http://stackoverflow.com/questions/9834273/floating-point-comparison-of-const...

This works for now because CGFloat is a double on 64-bit platforms. However,
this is liable to break in the future when someone accidentally introduces a
cast. Can we find a way to avoid double comparisons altogether?

[spqchan, 2016/08/26 00:46:30]

Added IsCGFloatEqual(). Is this what you mean?

[erikchen, 2016/08/26 00:56:58]

Ideally, we would be able to avoid any type of float comparison (even using an
epsilon). e.g., if we know the toolbar is showing, instead of relying on
fraction == 1.0, have an enum kToolbarStatus { Hidden, Showing, Animating}.

That being said, what you've done is enough to alleviate my concerns.

+    revealToolbarForTabStripChanges_ = 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)changeToolbarFraction:(CGFloat)fraction {
-  toolbarFraction_ = fraction;
+- (void)mouseEntered:(NSEvent*)event {
+  // Empty implementation. Required for CrTrackingArea.
+}
+
+- (void)mouseExited:(NSEvent*)event {
+  DCHECK(inFullscreenMode_);
+
+  // If the menubar is gone, animate the toolbar out.
+  if ([event trackingArea] == trackingArea_.get()) {

[erikchen, 2016/08/24 23:52:58]

nit: Should this be DCHECK_EQ([event trackingArea], trackingArea_.get())

[spqchan, 2016/08/26 00:46:30]

Done.

+    if (menubarFraction_ == 0.0)
+      [self ensureOverlayHiddenWithAnimation:YES];
+
+    [self removeTrackingAreaIfNecessary];
+  }
+}
+
+- (void)updateToolbar {
   [browserController_ layoutSubviews];
 
   // 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];
 }
 
 // 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]);
 
   return [self shouldShowMenubarInImmersiveFullscreen]
              ? -[self floatingBarVerticalOffset]
              : 0;
 }
 
+- (CGFloat)toolbarFraction {

[erikchen, 2016/08/24 23:52:58]

Wow. This is amazing. Thank you.

[spqchan, 2016/08/26 00:46:30]

Ack

+  if ([browserController_ isBarVisibilityLockedForOwner:nil])
+    return 1.0;
+
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode))
+    return 0.0;
+
+  switch (slidingStyle_) {
+    case fullscreen_mac::OMNIBOX_TABS_PRESENT:
+      return 1.0;
+    case fullscreen_mac::OMNIBOX_TABS_NONE:
+      return 0.0;
+    case fullscreen_mac::OMNIBOX_TABS_HIDDEN:
+      if (currentAnimation_.get())
+        return [currentAnimation_ toolbarFraction];
+      return toolbarFractionFromMenuProgress_;
+  }
+}
+
 - (BOOL)isFullscreenTransitionInProgress {
   return [browserController_ isFullscreenTransitionInProgress];
 }
 
+- (BOOL)isInFullscreen {
+  return inFullscreenMode_;
+}
+
 - (BOOL)isMouseOnScreen {
   return NSMouseInRect([NSEvent mouseLocation],
                        [[browserController_ window] screen].frame, false);
 }
 
+- (void)setTrackingAreaFromOverlayFrame:(NSRect)frame {
+  NSRect contentBounds = [contentView_ bounds];
+  trackingAreaFrame_ = frame;
+  trackingAreaFrame_.origin.y -= kTrackingAreaAdditionalThreshold;
+  trackingAreaFrame_.size.height =
+      NSMaxY(contentBounds) - trackingAreaFrame_.origin.y;
+}
+
 - (void)animationDidStop:(NSAnimation*)animation {
   // Reset the |currentAnimation_| pointer now that the animation is over.
   currentAnimation_.reset();

[erikchen, 2016/08/24 23:52:58]

If -toolbarFraction is called after the animation has stopped, but while the
hideTimer_ is still running, shouldn't it also return 1.0?

[spqchan, 2016/08/26 00:46:30]

Good point.

 
   if (revealToolbarForTabStripChanges_) {
-    if (toolbarFraction_ > 0.0) {
+    if ([self toolbarFraction] > 0.0) {
       // Set the timer to hide the toolbar.
       [hideTimer_ invalidate];
-      hideTimer_.reset([[NSTimer
-          scheduledTimerWithTimeInterval:kDropdownForTabStripChangesDuration
-                                  target:self
-                                selector:@selector(hideTimerFire:)
-                                userInfo:nil
-                                 repeats:NO] retain]);
+      hideTimer_.reset(
+          [[NSTimer scheduledTimerWithTimeInterval:kTabStripChangesDelay
+                                            target:self
+                                          selector:@selector(hideTimerFire:)
+                                          userInfo:nil
+                                           repeats:NO] retain]);
     } else {
       revealToolbarForTabStripChanges_ = NO;
     }
   }
 }
 
 - (void)animationDidEnd:(NSAnimation*)animation {
   [self animationDidStop:animation];
+  [self setupTrackingArea];
 }
 
 - (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;
 
   menubarFraction_ = progress;
 
+  if (self.slidingStyle == fullscreen_mac::OMNIBOX_TABS_HIDDEN) {
+    if (menubarFraction_ == 1.0)

[erikchen, 2016/08/24 23:52:58]

This double comparison relies on the assumption that the CGFloat we get from
AppKit has the double literal 1.0, which is not guaranteed. 

You probably want to use std::numeric_limits<CGFloat>::epsilon

http://stackoverflow.com/questions/4548004/how-to-correctly-and-standardly-co...

[spqchan, 2016/08/26 00:46:30]

Ditto from above

+      [self setupTrackingArea];
+
+    // If the menubar is disappearing from the screen, check if the mouse
+    // is still interacting with the. If it is, then don't set

[erikchen, 2016/08/24 23:52:58]

incomplete sentence?

[spqchan, 2016/08/26 00:46:30]

Done.

+    // |toolbarFractionFromMenuProgress_| so that the the toolbar will remain
+    // on the screen.
+    BOOL isMenuBarDisappearing =
+        menubarFraction_ < toolbarFractionFromMenuProgress_;
+    if (!(isMenuBarDisappearing && [self mouseInsideTrackingArea]))
+      toolbarFractionFromMenuProgress_ = progress;

[erikchen, 2016/08/24 23:52:58]

Can we separate the logic for toolbarFractionFromMenuProgress_ from the
underlying state?

Can we instead have toolbarFractionFromMenuProgress_ be a calculated property
based on:

1) menuProgress_
2) isMenuBarDisappearing_

Both (1) and (2) would be recalculated each time setMenuBarRevealProgress: is
called.

[spqchan, 2016/08/26 00:46:30]

I already tried that. I find that having |toolbarFractionFromMenuProgress_| is
simpler and easier to understand, because there's a couple of edge cases we'll
have to cover.

[erikchen, 2016/08/26 00:56:58]

Acknowledged.

+  }
+
   // 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()) {
-    if (self.slidingStyle != fullscreen_mac::OMNIBOX_TABS_NONE)
-      toolbarFraction_ = progress;
+  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)setupTrackingArea {
+  if (trackingArea_) {
+    // If the tracking rectangle is already |trackingAreaBounds_|, quit early.
+    NSRect oldRect = [trackingArea_ rect];
+    if (NSEqualRects(trackingAreaFrame_, oldRect))
+      return;
+
+    // Otherwise, remove it.
+    [self removeTrackingAreaIfNecessary];
+  }
+
+  // Create and add a new tracking area for |frame|.
+  trackingArea_.reset([[CrTrackingArea alloc]
+      initWithRect:trackingAreaFrame_
+           options:NSTrackingMouseEnteredAndExited | NSTrackingActiveInKeyWindow
+             owner:self
+          userInfo:nil]);
+  DCHECK(contentView_);
+  [contentView_ addTrackingArea:trackingArea_];
+}
+
+- (void)removeTrackingAreaIfNecessary {
+  if (trackingArea_) {
+    DCHECK(contentView_);  // |contentView_| better be valid.
+    [contentView_ removeTrackingArea:trackingArea_];
+    trackingArea_.reset();
+  }
+}
+
+- (BOOL)mouseInsideTrackingArea {
+  NSWindow* window = [browserController_ window];
+  NSPoint mouseLoc = [window mouseLocationOutsideOfEventStream];
+  NSPoint mousePos = [contentView_ convertPoint:mouseLoc fromView:nil];
+  return NSMouseInRect(mousePos, trackingAreaFrame_, [contentView_ isFlipped]);
+}
+
 - (BOOL)doesScreenHaveMenuBar {
   if (![[NSScreen class]
           respondsToSelector:@selector(screensHaveSeparateSpaces)])
     return [self isWindowOnPrimaryScreen];
 
   BOOL eachScreenShouldHaveMenuBar = [NSScreen screensHaveSeparateSpaces];
   return eachScreenShouldHaveMenuBar ?: [self isWindowOnPrimaryScreen];
 }
 
 - (BOOL)isWindowOnPrimaryScreen {
   NSScreen* screen = [[browserController_ window] screen];
   NSScreen* primaryScreen = [[NSScreen screens] firstObject];
   return (screen == primaryScreen);
 }
 
 - (base::mac::FullScreenMode)desiredSystemFullscreenMode {
   if ([self shouldShowMenubarInImmersiveFullscreen])
     return base::mac::kFullScreenModeHideDock;
   return base::mac::kFullScreenModeHideAll;
 }
 
-- (void)changeOverlayToFraction:(CGFloat)fraction withAnimation:(BOOL)animate {
-  // The non-animated case is really simple, so do it and return.
-  if (!animate) {
-    [currentAnimation_ stopAnimation];
-    [self changeToolbarFraction:fraction];
-    return;
-  }
+- (void)animateToolbarVisibility:(BOOL)visible {
+  CGFloat fraction = visible ? 1.0 : 0.0;
 
-  // If we're already animating to the given fraction, then there's nothing more
-  // to do.
+  // If we're already animating to the given fraction, then there's nothing
+  // more to do.
   if (currentAnimation_ && [currentAnimation_ endFraction] == fraction)
     return;
 
   // In all other cases, we want to cancel any running animation (which may be
   // to show or to hide).
   [currentAnimation_ stopAnimation];
 
   // Create the animation and set it up.
   currentAnimation_.reset([[DropdownAnimation alloc]
       initWithFraction:fraction
           fullDuration:kDropdownAnimationDuration
         animationCurve:NSAnimationEaseOut
             controller:self]);
   DCHECK(currentAnimation_);
   [currentAnimation_ setAnimationBlockingMode:NSAnimationNonblocking];
   [currentAnimation_ setDelegate:self];
 
+  // If there is an existing tracking area, remove it. We do not track mouse
+  // movements during animations (see class comment in the header file).
+  [self removeTrackingAreaIfNecessary];
+
   [currentAnimation_ startAnimation];
 }
 
 - (void)cancelHideTimer {
   [hideTimer_ invalidate];
   hideTimer_.reset();
 }
 
 - (void)hideTimerFire:(NSTimer*)timer {
   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.
-  [self changeOverlayToFraction:0 withAnimation:YES];
+  [self animateToolbarVisibility:NO];
 }
 
 - (void)cleanup {
   [self cancelAnimationAndTimer];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 
-  // This isn't tracked when not in fullscreen mode.
-  [browserController_ releaseBarVisibilityForOwner:self withAnimation:NO];
+  [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];
 
   // No more calls back up to the BWC.
   browserController_ = nil;
 }
 
-- (void)showActiveWindowUI {
-  [self updateMenuBarAndDockVisibility];
-}
-
-- (void)hideActiveWindowUI {
-  [self updateMenuBarAndDockVisibility];
-}
-
 - (BOOL)shouldShowMenubarInImmersiveFullscreen {
-  return [self doesScreenHaveMenuBar] && toolbarFraction_ > 0.99;
+  return [self doesScreenHaveMenuBar] && [self toolbarFraction] > 0.99;
 }
 
 @end