[Mac] Fullscreen Toolbar Bar Visibility Edge Cases

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"
 #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 {
@@ skipping 119 matching lines @@
 }
 
 @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)updateTrackingArea;
 - (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.
@@ skipping 20 matching lines @@
 // that contains the window.
 - (BOOL)shouldShowMenubarInImmersiveFullscreen;
 
 @end
 
 @implementation FullscreenToolbarController
 
 @synthesize slidingStyle = slidingStyle_;
 
 - (id)initWithBrowserController:(BrowserWindowController*)controller
-                          style:(fullscreen_mac::SlidingStyle)style {
+                          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;
@@ skipping 56 matching lines @@
 }
 
 - (void)windowDidResignMain:(NSNotification*)notification {
   [self updateMenuBarAndDockVisibility];
 }
 
 - (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];
+}
+
 - (void)ensureOverlayShownWithAnimation:(BOOL)animate {
   if (!inFullscreenMode_)
     return;
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode))
     return;
 
-  if (self.slidingStyle != fullscreen_mac::OMNIBOX_TABS_HIDDEN)
+  if (self.slidingStyle != FullscreenSlidingStyle::OMNIBOX_TABS_HIDDEN)
     return;
 
   [self cancelHideTimer];
   [self animateToolbarVisibility:YES];
 }
 
 - (void)ensureOverlayHiddenWithAnimation:(BOOL)animate {
   if (!inFullscreenMode_)
     return;
 
-  if (self.slidingStyle != fullscreen_mac::OMNIBOX_TABS_HIDDEN)
+  if (self.slidingStyle != FullscreenSlidingStyle::OMNIBOX_TABS_HIDDEN)
     return;
 
+  if ([browserController_ isBarVisibilityLockedForOwner:nil])
+    return;
+
+  if ([self mouseInsideTrackingArea] ||
+      menubarState_ == FullscreenMenubarState::SHOWN) {
+    return;
+  }
+
   [self cancelHideTimer];
   [self animateToolbarVisibility:NO];
 }
 
 - (void)cancelAnimationAndTimer {
   [self cancelHideTimer];
   [currentAnimation_ stopAnimation];
   currentAnimation_.reset();
 }
 
@@ skipping 23 matching lines @@
 }
 
 - (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 (IsCGFloatEqual(menubarFraction_, kHideFraction))
+  if (menubarState_ == FullscreenMenubarState::HIDDEN) {
+    base::AutoReset<BOOL> autoReset(&shouldAnimateToolbarOut_, YES);
     [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])
@@ skipping 14 matching lines @@
 - (CGFloat)menubarOffset {
   if ([browserController_ isInAppKitFullscreen])
     return -std::floor(menubarFraction_ * [self floatingBarVerticalOffset]);
 
   return [self shouldShowMenubarInImmersiveFullscreen]
              ? -[self floatingBarVerticalOffset]
              : 0;
 }
 
 - (CGFloat)toolbarFraction {
-  if ([browserController_ isBarVisibilityLockedForOwner:nil])
-    return kShowFraction;
-
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode))
     return kHideFraction;
 
   switch (slidingStyle_) {
-    case fullscreen_mac::OMNIBOX_TABS_PRESENT:
+    case FullscreenSlidingStyle::OMNIBOX_TABS_PRESENT:
       return kShowFraction;
-    case fullscreen_mac::OMNIBOX_TABS_NONE:
+    case FullscreenSlidingStyle::OMNIBOX_TABS_NONE:
       return kHideFraction;
-    case fullscreen_mac::OMNIBOX_TABS_HIDDEN:
+    case FullscreenSlidingStyle::OMNIBOX_TABS_HIDDEN:
+      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 toolbarFractionFromMenuProgress_;
+      return menubarFraction_;
   }
 }
 
 - (BOOL)isFullscreenTransitionInProgress {
   return [browserController_ isFullscreenTransitionInProgress];
 }
 
 - (BOOL)isInFullscreen {
   return inFullscreenMode_;
 }
@@ skipping 26 matching lines @@
       isRevealingToolbarForTabStripChanges_ = NO;
     }
   }
 
   // Reset the |currentAnimation_| pointer now that the animation is over.
   currentAnimation_.reset();
 }
 
 - (void)animationDidEnd:(NSAnimation*)animation {
   [self animationDidStop:animation];
-  [self setupTrackingArea];
+  [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;
 
+  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 (self.slidingStyle == fullscreen_mac::OMNIBOX_TABS_HIDDEN) {
-    if (IsCGFloatEqual(menubarFraction_, kShowFraction))
-      [self setupTrackingArea];
-
-    // If the menubar is disappearing from the screen, check if the mouse
-    // is still interacting with the toolbar. If it is, don't set
-    // |toolbarFractionFromMenuProgress_| so that the the toolbar will remain
-    // on the screen.
-    BOOL isMenuBarDisappearing =
-        menubarFraction_ < toolbarFractionFromMenuProgress_;
-    if (!(isMenuBarDisappearing && [self mouseInsideTrackingArea]))
-      toolbarFractionFromMenuProgress_ = 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];
 }
@@ skipping 11 matching lines @@
 
   // 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 {
+- (void)updateTrackingArea {
+  // Remove the tracking area if the toolbar isn't fully shown.
+  if (!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;
 
     // 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 {
+  if (!trackingArea_)
+    return NO;
+
   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];
@@ skipping 45 matching lines @@
 
 - (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.
-  shouldAnimateToolbarOut_ = YES;
+  base::AutoReset<BOOL> autoReset(&shouldAnimateToolbarOut_, YES);
   [self animateToolbarVisibility:NO];
-  shouldAnimateToolbarOut_ = NO;
 }
 
 - (void)cleanup {
   [self cancelAnimationAndTimer];
   [[NSNotificationCenter defaultCenter] 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];
 
   // No more calls back up to the BWC.
   browserController_ = nil;
 }
 
 - (BOOL)shouldShowMenubarInImmersiveFullscreen {
   return [self doesScreenHaveMenuBar] && [self toolbarFraction] > 0.99;
 }
 
 @end