mac, fullscreen: Several bug fixes after major refactor.

chrome/browser/ui/cocoa/presentation_mode_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/presentation_mode_controller.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/mac/sdk_forward_declarations.h"
@@ skipping 17 matching lines @@
 const NSTimeInterval kMouseExitCheckDelay = 0.1;
 // This show delay attempts to match the delay for the main menu.
 const NSTimeInterval kDropdownShowDelay = 0.3;
 const NSTimeInterval kDropdownHideDelay = 0.2;
 
 // The amount by which the floating bar is offset downwards (to avoid the menu)
 // in presentation mode. (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) {
+  PresentationModeController* self =
+      static_cast<PresentationModeController*>(context);
+  CGFloat revealFraction = 0;
+  GetEventParameter(event,
+                    FOUR_CHAR_CODE('rvlf'),
+                    typeCGFloat,
+                    NULL,
+                    sizeof(CGFloat),
+                    NULL,
+                    &revealFraction);
+  [self setMenuBarRevealProgress:revealFraction];
+  return CallNextEventHandler(handler, event);
+}
+
 }  // end namespace
 
+@interface PresentationModeController ()
+// Sets a new current floating bar shown fraction.  NOTE: This function has side
+// effects, such as modifying the system fullscreen mode (menu bar shown state).
+- (void)changeToolbarPercentage:(CGFloat)fraction;
+@end
 
 // Helper class to manage animations for the dropdown bar.  Calls
-// [PresentationModeController changeFloatingBarShownFraction] once per
+// [PresentationModeController changeToolbarPercentage] once per
 // animation step.
 @interface DropdownAnimation : NSAnimation {
  @private
   PresentationModeController* controller_;
   CGFloat startFraction_;
   CGFloat endFraction_;
 }
 
 @property(readonly, nonatomic) CGFloat startFraction;
 @property(readonly, nonatomic) CGFloat endFraction;
@@ skipping 12 matching lines @@
 
 @synthesize startFraction = startFraction_;
 @synthesize endFraction = endFraction_;
 
 - (id)initWithFraction:(CGFloat)toFraction
           fullDuration:(CGFloat)fullDuration
         animationCurve:(NSAnimationCurve)animationCurve
             controller:(PresentationModeController*)controller {
   // Calculate the effective duration, based on the current shown fraction.
   DCHECK(controller);
-  CGFloat fromFraction = [controller floatingBarShownFraction];
+  CGFloat fromFraction = controller.toolbarPercentage;
   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 =
       startFraction_ + (progress * (endFraction_ - startFraction_));
-  [controller_ changeFloatingBarShownFraction:fraction];
+  [controller_ changeToolbarPercentage:fraction];
 }
 
 @end
 
 
 @interface PresentationModeController (PrivateMethods)
 
 // Updates the visibility of the menu bar and the dock.
 - (void)updateMenuBarAndDockVisibility;
 
@@ skipping 52 matching lines @@
 
 // Stops any running animations, removes tracking areas, 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;
 
+// In Immersive Fullscreen, the menubar is visible iff. toolbarPercentage_ >=
+// 1.0.
+- (BOOL)shouldShowMenubarInImmersiveFullscreen;
+
 @end
 
 
 @implementation PresentationModeController
 
 @synthesize inPresentationMode = inPresentationMode_;
+@synthesize slidingStyle = slidingStyle_;
+@synthesize toolbarPercentage = toolbarPercentage_;
 
-- (id)initWithBrowserController:(BrowserWindowController*)controller {
+- (id)initWithBrowserController:(BrowserWindowController*)controller
+                          style:(fullscreen_mac::SlidingStyle)style {
   if ((self = [super init])) {
     browserController_ = controller;
     systemFullscreenMode_ = base::mac::kFullScreenModeNormal;
+    slidingStyle_ = style;
   }
 
   // Let the world know what we're up to.
   [[NSNotificationCenter defaultCenter]
     postNotificationName:kWillEnterFullscreenNotification
                   object:nil];
 
+  // Install the Carbon event handler for the undocumented menu bar show/hide
+  // event.
+  EventTypeSpec eventSpec = {kEventClassMenu, 2004};

[Robert Sesek, 2014/09/02 19:59:48]

nit: I think style is for spaces inside {}

[erikchen, 2014/09/02 20:43:21]

This is the output of clang-format. According to the style guide, braced
initializer lists use function style spacing.
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Braced_Initial...

+  InstallApplicationEventHandler(NewEventHandlerUPP(&MenuBarRevealHandler),
+                                 1,
+                                 &eventSpec,
+                                 self,
+                                 &menuBarTrackingHandler_);
   return self;
 }
 
 - (void)dealloc {
+  RemoveEventHandler(menuBarTrackingHandler_);
   DCHECK(!inPresentationMode_);
   DCHECK(!trackingArea_);
   [super dealloc];
 }
 
 - (void)enterPresentationModeForContentView:(NSView*)contentView
                                showDropdown:(BOOL)showDropdown {
   DCHECK(!inPresentationMode_);
   enteringPresentationMode_ = YES;
   inPresentationMode_ = YES;
   contentView_ = contentView;
-  [self changeFloatingBarShownFraction:(showDropdown ? 1 : 0)];
+  [self changeToolbarPercentage:(showDropdown ? 1 : 0)];
+  [self updateMenuBarAndDockVisibility];
 
   // Register for notifications.  Self is removed as an observer in |-cleanup|.
   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
   NSWindow* window = [browserController_ window];
 
   // Disable these notifications on Lion as they cause crashes.
   // TODO(rohitrao): Figure out what happens if a fullscreen window changes
   // monitors on Lion.
   if (base::mac::IsOSSnowLeopard()) {
     [nc addObserver:self
@@ skipping 85 matching lines @@
   [self setupTrackingArea];
 }
 
 - (void)ensureOverlayShownWithAnimation:(BOOL)animate delay:(BOOL)delay {
   if (!inPresentationMode_)
     return;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode))
     return;
 
+  if (self.slidingStyle == fullscreen_mac::OMNIBOX_TABS_PRESENT)
+    return;
+
   if (animate) {
     if (delay) {
       [self startShowTimer];
     } else {
       [self cancelAllTimers];
       [self changeOverlayToFraction:1 withAnimation:YES];
     }
   } else {
     DCHECK(!delay);
     [self cancelAllTimers];
     [self changeOverlayToFraction:1 withAnimation:NO];
   }
 }
 
 - (void)ensureOverlayHiddenWithAnimation:(BOOL)animate delay:(BOOL)delay {
   if (!inPresentationMode_)
     return;
 
+  if (self.slidingStyle == fullscreen_mac::OMNIBOX_TABS_PRESENT)
+    return;
+
   if (animate) {
     if (delay) {
       [self startHideTimer];
     } else {
       [self cancelAllTimers];
       [self changeOverlayToFraction:0 withAnimation:YES];
     }
   } else {
     DCHECK(!delay);
     [self cancelAllTimers];
     [self changeOverlayToFraction:0 withAnimation:NO];
   }
 }
 
 - (void)cancelAnimationAndTimers {
   [self cancelAllTimers];
   [currentAnimation_ stopAnimation];
   currentAnimation_.reset();
 }
 
-- (CGFloat)floatingBarShownFraction {
-  return [browserController_ floatingBarShownFraction];
-}
-
 - (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)changeFloatingBarShownFraction:(CGFloat)fraction {
-  [browserController_ setFloatingBarShownFraction:fraction];
+- (void)changeToolbarPercentage:(CGFloat)fraction {
+  toolbarPercentage_ = fraction;
+  [browserController_ layoutSubviews];
 
-  [self updateMenuBarAndDockVisibility];
+  // 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
+// menubarPercentage_ 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((menubarPercentage_) * [self floatingBarVerticalOffset]);

[Robert Sesek, 2014/09/02 19:59:48]

Why parens around the first multiplicand?

[erikchen, 2014/09/02 20:43:21]

removed.

+
+  return [self shouldShowMenubarInImmersiveFullscreen]
+             ? -[self floatingBarVerticalOffset]
+             : 0;
 }
 
 // Used to activate the floating bar in presentation mode.
 - (void)mouseEntered:(NSEvent*)event {
   DCHECK(inPresentationMode_);
 
   // Having gotten a mouse entered, we no longer need to do exit checks.
   [self cancelMouseExitCheck];
 
   NSTrackingArea* trackingArea = [event trackingArea];
@@ skipping 46 matching lines @@
   // |any updates that may have come while the animation was running. Install a
   // new tracking area with these bounds.
   [self setupTrackingArea];
 
   // TODO(viettrungluu): Better would be to check during the animation; doing it
   // here means that the timing is slightly off.
   if (![self mouseInsideTrackingRect])
     [self scheduleHideForMouse];
 }
 
+- (void)setMenuBarRevealProgress:(CGFloat)progress {
+  menubarPercentage_ = progress;
+
+  // 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 PresentationModeController (PrivateMethods)
 
 - (void)updateMenuBarAndDockVisibility {
   if (![[browserController_ window] isMainWindow] ||
       ![browserController_ isInImmersiveFullscreen]) {
     [self setSystemFullscreenModeTo:base::mac::kFullScreenModeNormal];
     return;
@@ skipping 17 matching lines @@
   return eachScreenShouldHaveMenuBar ?: [self isWindowOnPrimaryScreen];
 }
 
 - (BOOL)isWindowOnPrimaryScreen {
   NSScreen* screen = [[browserController_ window] screen];
   NSScreen* primaryScreen = [[NSScreen screens] objectAtIndex:0];
   return (screen == primaryScreen);
 }
 
 - (base::mac::FullScreenMode)desiredSystemFullscreenMode {
-  if ([browserController_ floatingBarShownFraction] >= 1.0)
+  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 changeFloatingBarShownFraction:fraction];
+    [self changeToolbarPercentage:fraction];
     return;
   }
 
   // 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];
 
-  // Now, if it happens to already be in the right state, there's nothing more
-  // to do.
-  if ([browserController_ floatingBarShownFraction] == fraction)
-    return;
-
   // 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];
 
@@ skipping 165 matching lines @@
 
   // TODO(rohitrao): Insert the Exit Fullscreen button.  http://crbug.com/35956
 }
 
 - (void)hideActiveWindowUI {
   [self updateMenuBarAndDockVisibility];
 
   // TODO(rohitrao): Remove the Exit Fullscreen button.  http://crbug.com/35956
 }
 
+- (BOOL)shouldShowMenubarInImmersiveFullscreen {
+  return toolbarPercentage_ >= 1.0;
+}
+
 @end