Fullscreen support for Lion.

chrome/browser/ui/cocoa/presentation_mode_controller.mm

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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_controller.h"
+#import "chrome/browser/ui/cocoa/presentation_mode_controller.h"
 
 #include <algorithm>
 
 #import "base/mac/mac_util.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
 #import "third_party/GTM/AppKit/GTMNSAnimation+Duration.h"
 
 NSString* const kWillEnterFullscreenNotification =
     @"WillEnterFullscreenNotification";
 NSString* const kWillLeaveFullscreenNotification =
     @"WillLeaveFullscreenNotification";
 
 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 CGFloat kDropdownActivationZoneHeight = 4;
 const NSTimeInterval kDropdownAnimationDuration = 0.12;
 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 fullscreen mode. (We can't use |-[NSMenu menuBarHeight]| since it returns
-// 0 when the menu bar is hidden.)
+// in presentation mode. (We can't use |-[NSMenu menuBarHeight]| since it
+// returns 0 when the menu bar is hidden.)
 const CGFloat kFloatingBarVerticalOffset = 22;
 
 }  // end namespace
 
 
-// Helper class to manage animations for the fullscreen dropdown bar.  Calls
-// [FullscreenController changeFloatingBarShownFraction] once per animation
-// step.
+// Helper class to manage animations for the dropdown bar.  Calls
+// [PresentationModeController changeFloatingBarShownFraction] once per
+// animation step.
 @interface DropdownAnimation : NSAnimation {
  @private
-  FullscreenController* controller_;
+  PresentationModeController* controller_;
   CGFloat startFraction_;
   CGFloat endFraction_;
 }
 
 @property(readonly, nonatomic) CGFloat startFraction;
 @property(readonly, nonatomic) CGFloat endFraction;
 
 // 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:(NSInteger)animationCurve
-            controller:(FullscreenController*)controller;
+            controller:(PresentationModeController*)controller;
 
 @end
 
 @implementation DropdownAnimation
 
 @synthesize startFraction = startFraction_;
 @synthesize endFraction = endFraction_;
 
 - (id)initWithFraction:(CGFloat)toFraction
           fullDuration:(CGFloat)fullDuration
         animationCurve:(NSInteger)animationCurve
-            controller:(FullscreenController*)controller {
+            controller:(PresentationModeController*)controller {
   // Calculate the effective duration, based on the current shown fraction.
   DCHECK(controller);
   CGFloat fromFraction = [controller floatingBarShownFraction];
   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];
 }
 
 @end
 
 
-@interface FullscreenController (PrivateMethods)
+@interface PresentationModeController (PrivateMethods)
 
-// Returns YES if the fullscreen window is on the primary screen.
+// Returns YES if the window is on the primary screen.
 - (BOOL)isWindowOnPrimaryScreen;
 
 // Returns YES if it is ok to show and hide the menu bar in response to the
 // overlay opening and closing.  Will return NO if the window is not main or not
 // on the primary monitor.
 - (BOOL)shouldToggleMenuBar;
 
 // Returns |kFullScreenModeHideAll| when the overlay is hidden and
 // |kFullScreenModeHideDock| when the overlay is shown.
-- (base::mac::FullScreenMode)desiredFullscreenMode;
+- (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;
 
 // Schedule the floating bar to be shown/hidden because of mouse position.
 - (void)scheduleShowForMouse;
 - (void)scheduleHideForMouse;
@@ skipping 27 matching lines @@
 - (void)cancelAllTimers;
 
 // Methods called when the show/hide timers fire. Do not call directly.
 - (void)showTimerFire:(NSTimer*)timer;
 - (void)hideTimerFire:(NSTimer*)timer;
 
 // 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 and displaying the "Exit
-// Fullscreen" button.  These functions are called when the window gains or
-// loses main status as well as in |-cleanup|.
+// 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;
 
 @end
 
 
-@implementation FullscreenController
+@implementation PresentationModeController
 
-@synthesize isFullscreen = isFullscreen_;
+@synthesize inPresentationMode = inPresentationMode_;
 
 - (id)initWithBrowserController:(BrowserWindowController*)controller {
   if ((self = [super init])) {
     browserController_ = controller;
-    currentFullscreenMode_ = base::mac::kFullScreenModeNormal;
+    systemFullscreenMode_ = base::mac::kFullScreenModeNormal;
   }
 
   // Let the world know what we're up to.
   [[NSNotificationCenter defaultCenter]
     postNotificationName:kWillEnterFullscreenNotification
                   object:nil];
 
   return self;
 }
 
 - (void)dealloc {
-  DCHECK(!isFullscreen_);
+  DCHECK(!inPresentationMode_);
   DCHECK(!trackingArea_);
   [super dealloc];
 }
 
-- (void)enterFullscreenForContentView:(NSView*)contentView
-                         showDropdown:(BOOL)showDropdown {
-  DCHECK(!isFullscreen_);
-  isFullscreen_ = YES;
+- (void)enterPresentationModeForContentView:(NSView*)contentView
+                               showDropdown:(BOOL)showDropdown {
+  DCHECK(!inPresentationMode_);
+  enteringPresentationMode_ = YES;
+  inPresentationMode_ = YES;
   contentView_ = contentView;
   [self changeFloatingBarShownFraction:(showDropdown ? 1 : 0)];
 
   // Register for notifications.  Self is removed as an observer in |-cleanup|.
   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
   NSWindow* window = [browserController_ window];
-  [nc addObserver:self
-         selector:@selector(windowDidChangeScreen:)
-             name:NSWindowDidChangeScreenNotification
-           object:window];
 
-  [nc addObserver:self
-         selector:@selector(windowDidMove:)
-             name:NSWindowDidMoveNotification
-           object: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::IsOSSnowLeopardOrEarlier()) {
+    [nc addObserver:self
+           selector:@selector(windowDidChangeScreen:)
+               name:NSWindowDidChangeScreenNotification
+             object:window];
+
+    [nc addObserver:self
+           selector:@selector(windowDidMove:)
+               name:NSWindowDidMoveNotification
+             object:window];
+  }
 
   [nc addObserver:self
          selector:@selector(windowDidBecomeMain:)
              name:NSWindowDidBecomeMainNotification
            object:window];
 
   [nc addObserver:self
          selector:@selector(windowDidResignMain:)
              name:NSWindowDidResignMainNotification
            object:window];
+
+  enteringPresentationMode_ = NO;
 }
 
-- (void)exitFullscreen {
+- (void)exitPresentationMode {
   [[NSNotificationCenter defaultCenter]
     postNotificationName:kWillLeaveFullscreenNotification
                   object:nil];
-  DCHECK(isFullscreen_);
+  DCHECK(inPresentationMode_);
+  inPresentationMode_ = NO;
   [self cleanup];
-  isFullscreen_ = NO;
 }
 
 - (void)windowDidChangeScreen:(NSNotification*)notification {
   [browserController_ resizeFullscreenWindow];
 }
 
 - (void)windowDidMove:(NSNotification*)notification {
   [browserController_ resizeFullscreenWindow];
 }
 
 - (void)windowDidBecomeMain:(NSNotification*)notification {
   [self showActiveWindowUI];
 }
 
 - (void)windowDidResignMain:(NSNotification*)notification {
   [self hideActiveWindowUI];
 }
 
 - (CGFloat)floatingBarVerticalOffset {
   return [self isWindowOnPrimaryScreen] ? kFloatingBarVerticalOffset : 0;
 }
 
 - (void)overlayFrameChanged:(NSRect)frame {
-  if (!isFullscreen_)
+  if (!inPresentationMode_)
     return;
 
   // Make sure |trackingAreaBounds_| always reflects either the tracking area or
   // the desired tracking area.
   trackingAreaBounds_ = frame;
   // The tracking area should always be at least the height of activation zone.
   NSRect contentBounds = [contentView_ bounds];
   trackingAreaBounds_.origin.y =
       std::min(trackingAreaBounds_.origin.y,
                NSMaxY(contentBounds) - kDropdownActivationZoneHeight);
   trackingAreaBounds_.size.height =
       NSMaxY(contentBounds) - trackingAreaBounds_.origin.y + 1;
 
   // If an animation is currently running, do not set up a tracking area now.
   // Instead, leave it to be created it in |-animationDidEnd:|.
   if (currentAnimation_)
     return;
 
+  // If this is part of the initial setup, lock bar visibility if the mouse is
+  // within the tracking area bounds.
+  if (enteringPresentationMode_ && [self mouseInsideTrackingRect])
+    [browserController_ lockBarVisibilityForOwner:self
+                                    withAnimation:NO
+                                            delay:NO];
   [self setupTrackingArea];
 }
 
 - (void)ensureOverlayShownWithAnimation:(BOOL)animate delay:(BOOL)delay {
-  if (!isFullscreen_)
+  if (!inPresentationMode_)
     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 (!isFullscreen_)
+  if (!inPresentationMode_)
     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)changeFloatingBarShownFraction:(CGFloat)fraction {
   [browserController_ setFloatingBarShownFraction:fraction];
 
-  base::mac::FullScreenMode desiredMode = [self desiredFullscreenMode];
-  if (desiredMode != currentFullscreenMode_ && [self shouldToggleMenuBar]) {
-    if (currentFullscreenMode_ == base::mac::kFullScreenModeNormal)
+  base::mac::FullScreenMode desiredMode = [self desiredSystemFullscreenMode];
+  if (desiredMode != systemFullscreenMode_ && [self shouldToggleMenuBar]) {
+    if (systemFullscreenMode_ == base::mac::kFullScreenModeNormal)
       base::mac::RequestFullScreen(desiredMode);
     else
-      base::mac::SwitchFullScreenModes(currentFullscreenMode_, desiredMode);
-    currentFullscreenMode_ = desiredMode;
+      base::mac::SwitchFullScreenModes(systemFullscreenMode_, desiredMode);
+    systemFullscreenMode_ = desiredMode;
   }
 }
 
-// Used to activate the floating bar in fullscreen mode.
+// Used to activate the floating bar in presentation mode.
 - (void)mouseEntered:(NSEvent*)event {
-  DCHECK(isFullscreen_);
+  DCHECK(inPresentationMode_);
 
   // Having gotten a mouse entered, we no longer need to do exit checks.
   [self cancelMouseExitCheck];
 
   NSTrackingArea* trackingArea = [event trackingArea];
   if (trackingArea == trackingArea_) {
     // The tracking area shouldn't be active during animation.
     DCHECK(!currentAnimation_);
     [self scheduleShowForMouse];
   }
 }
 
-// Used to deactivate the floating bar in fullscreen mode.
+// Used to deactivate the floating bar in presentation mode.
 - (void)mouseExited:(NSEvent*)event {
-  DCHECK(isFullscreen_);
+  DCHECK(inPresentationMode_);
 
   NSTrackingArea* trackingArea = [event trackingArea];
   if (trackingArea == trackingArea_) {
     // The tracking area shouldn't be active during animation.
     DCHECK(!currentAnimation_);
 
     // We can get a false mouse exit when the menu slides down, so if the mouse
     // is still actually over the tracking area, we ignore the mouse exit, but
     // we set up to check the mouse position again after a delay.
     if ([self mouseInsideTrackingRect]) {
@@ skipping 29 matching lines @@
 
   // 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];
 }
 
 @end
 
 
-@implementation FullscreenController (PrivateMethods)
+@implementation PresentationModeController (PrivateMethods)
 
 - (BOOL)isWindowOnPrimaryScreen {
   NSScreen* screen = [[browserController_ window] screen];
   NSScreen* primaryScreen = [[NSScreen screens] objectAtIndex:0];
   return (screen == primaryScreen);
 }
 
 - (BOOL)shouldToggleMenuBar {
-  return [self isWindowOnPrimaryScreen] &&
+  return base::mac::IsOSSnowLeopardOrEarlier() &&
+         [self isWindowOnPrimaryScreen] &&
          [[browserController_ window] isMainWindow];
 }
 
-- (base::mac::FullScreenMode)desiredFullscreenMode {
+- (base::mac::FullScreenMode)desiredSystemFullscreenMode {
   if ([browserController_ floatingBarShownFraction] >= 1.0)
     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];
@@ skipping 167 matching lines @@
 }
 
 - (void)cleanup {
   [self cancelMouseExitCheck];
   [self cancelAnimationAndTimers];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 
   [self removeTrackingAreaIfNecessary];
   contentView_ = nil;
 
-  // This isn't tracked when not in fullscreen mode.
+  // This isn't tracked when not in presentation mode.
   [browserController_ releaseBarVisibilityForOwner:self
                                      withAnimation:NO
                                              delay:NO];
 
   // Call the main status resignation code to perform the associated cleanup,
   // since we will no longer be receiving actual status resignation
   // notifications.
   [self hideActiveWindowUI];
 
   // No more calls back up to the BWC.
   browserController_ = nil;
 }
 
 - (void)showActiveWindowUI {
-  DCHECK_EQ(currentFullscreenMode_, base::mac::kFullScreenModeNormal);
-  if (currentFullscreenMode_ != base::mac::kFullScreenModeNormal)
+  DCHECK_EQ(systemFullscreenMode_, base::mac::kFullScreenModeNormal);
+  if (systemFullscreenMode_ != base::mac::kFullScreenModeNormal)
     return;
 
   if ([self shouldToggleMenuBar]) {
-    base::mac::FullScreenMode desiredMode = [self desiredFullscreenMode];
+    base::mac::FullScreenMode desiredMode = [self desiredSystemFullscreenMode];
     base::mac::RequestFullScreen(desiredMode);
-    currentFullscreenMode_ = desiredMode;
+    systemFullscreenMode_ = desiredMode;
   }
 
   // TODO(rohitrao): Insert the Exit Fullscreen button.  http://crbug.com/35956
 }
 
 - (void)hideActiveWindowUI {
-  if (currentFullscreenMode_ != base::mac::kFullScreenModeNormal) {
-    base::mac::ReleaseFullScreen(currentFullscreenMode_);
-    currentFullscreenMode_ = base::mac::kFullScreenModeNormal;
+  if (systemFullscreenMode_ != base::mac::kFullScreenModeNormal) {
+    base::mac::ReleaseFullScreen(systemFullscreenMode_);
+    systemFullscreenMode_ = base::mac::kFullScreenModeNormal;
   }
 
   // TODO(rohitrao): Remove the Exit Fullscreen button.  http://crbug.com/35956
 }
 
 @end