[Mac] Refactor Cocoa fullscreen code

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/presentation_mode_controller.h"
+#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"
-
-NSString* const kWillEnterFullscreenNotification =
-    @"WillEnterFullscreenNotification";
-NSString* const kWillLeaveFullscreenNotification =
-    @"WillLeaveFullscreenNotification";
+#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 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 duration the toolbar is revealed for tab strip changes.
 const NSTimeInterval kDropdownForTabStripChangesDuration = 0.75;
 
 // 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)
-// in presentation mode. (We can't use |-[NSMenu menuBarHeight]| since it
+// 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) {
-  PresentationModeController* self =
-      static_cast<PresentationModeController*>(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 isMainWindow] && ![self isFullscreenTransitionInProgress]) {
     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
-// [PresentationModeController changeToolbarFraction] once per
+// [FullscreenToolbarController changeToolbarFraction] once per
 // animation step.
 @interface DropdownAnimation : NSAnimation {
  @private
-  PresentationModeController* controller_;
+  FullscreenToolbarController* 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:(NSAnimationCurve)animationCurve
-            controller:(PresentationModeController*)controller;
+            controller:(FullscreenToolbarController*)controller;
 
 @end
 
 @implementation DropdownAnimation
 
 @synthesize startFraction = startFraction_;
 @synthesize endFraction = endFraction_;
 
 - (id)initWithFraction:(CGFloat)toFraction
           fullDuration:(CGFloat)fullDuration
         animationCurve:(NSAnimationCurve)animationCurve
-            controller:(PresentationModeController*)controller {
+            controller:(FullscreenToolbarController*)controller {
   // Calculate the effective duration, based on the current shown fraction.
   DCHECK(controller);
   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 =
       startFraction_ + (progress * (endFraction_ - startFraction_));
   [controller_ changeToolbarFraction:fraction];
 }
 
 @end
 
-
-@interface PresentationModeController (PrivateMethods)
+@interface FullscreenToolbarController (PrivateMethods)
 
 // Updates the visibility of the menu bar and the dock.
 - (void)updateMenuBarAndDockVisibility;
 
 // 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;
+- (void)changeOverlayToFraction:(CGFloat)fraction withAnimation:(BOOL)animate;
 
 // Schedule the floating bar to be shown/hidden because of mouse position.
 - (void)scheduleShowForMouse;
 - (void)scheduleHideForMouse;
 
 // Set up the tracking area used to activate the sliding bar or keep it active
 // using with the rectangle in |trackingAreaBounds_|, or remove the tracking
 // area if one was previously set up.
 - (void)setupTrackingArea;
 - (void)removeTrackingAreaIfNecessary;
@@ skipping 32 matching lines @@
 // 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 PresentationModeController
+@implementation FullscreenToolbarController
 
-@synthesize inPresentationMode = inPresentationMode_;
 @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;
   }
 
-  // Let the world know what we're up to.
-  [[NSNotificationCenter defaultCenter]
-    postNotificationName:kWillEnterFullscreenNotification
-                  object:nil];
-
   // 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(!inPresentationMode_);
+  DCHECK(!inFullscreenMode_);
   DCHECK(!trackingArea_);
   [super dealloc];
 }
 
-- (void)enterPresentationModeForContentView:(NSView*)contentView
-                               showDropdown:(BOOL)showDropdown {
-  DCHECK(!inPresentationMode_);
-  enteringPresentationMode_ = YES;
-  inPresentationMode_ = YES;
+- (void)setupFullscreenToolbarForContentView:(NSView*)contentView
+                                showDropdown:(BOOL)showDropdown {
+  DCHECK(!inFullscreenMode_);
+  settingUp_ = YES;
+  inFullscreenMode_ = YES;
   contentView_ = contentView;
   [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];
 
   [nc addObserver:self
          selector:@selector(windowDidResignMain:)
              name:NSWindowDidResignMainNotification
            object:window];
 
-  enteringPresentationMode_ = NO;
+  settingUp_ = NO;
 }
 
-- (void)exitPresentationMode {
-  [[NSNotificationCenter defaultCenter]
-    postNotificationName:kWillLeaveFullscreenNotification
-                  object:nil];
-  DCHECK(inPresentationMode_);
-  inPresentationMode_ = NO;
+- (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 showActiveWindowUI];
 }
 
 - (void)windowDidResignMain:(NSNotification*)notification {
   [self hideActiveWindowUI];
 }
 
 // On OSX 10.8+, the menu bar shows on the secondary screen in fullscreen.
 - (CGFloat)floatingBarVerticalOffset {
   return kFloatingBarVerticalOffset;
 }
 
 - (void)overlayFrameChanged:(NSRect)frame {
-  if (!inPresentationMode_)
+  if (!inFullscreenMode_)
     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])
+  if (settingUp_ && [self mouseInsideTrackingRect])
     [browserController_ lockBarVisibilityForOwner:self
                                     withAnimation:NO
                                             delay:NO];
   [self setupTrackingArea];
 }
 
 - (void)ensureOverlayShownWithAnimation:(BOOL)animate delay:(BOOL)delay {
-  if (!inPresentationMode_)
+  if (!inFullscreenMode_)
     return;
 
   if (base::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_)
+  if (!inFullscreenMode_)
     return;
 
   if (self.slidingStyle == fullscreen_mac::OMNIBOX_TABS_PRESENT)
     return;
 
   if (animate) {
     if (delay) {
       [self startHideTimer];
     } else {
       [self cancelAllTimers];
@@ skipping 65 matching lines @@
 }
 
 - (BOOL)isFullscreenTransitionInProgress {
   return [browserController_ isFullscreenTransitionInProgress];
 }
 
 - (BOOL)isMainWindow {
   return [browserController_ window].isMainWindow;
 }
 
-// Used to activate the floating bar in presentation mode.
+// Used to activate the floating bar if the toolbar is hidden.
 - (void)mouseEntered:(NSEvent*)event {
-  DCHECK(inPresentationMode_);
+  DCHECK(inFullscreenMode_);
 
   // Having gotten a mouse entered, we no longer need to do exit checks.
   [self cancelMouseExitCheck];
 
-  NSTrackingArea* trackingArea = [event trackingArea];
-  if (trackingArea == trackingArea_) {
+  if ([event trackingArea] == trackingArea_.get()) {
     // The tracking area shouldn't be active during animation.
     DCHECK(!currentAnimation_);
 
     // Don't show anything if the style is set to OMNIBOX_TABS_NONE.
     if (self.slidingStyle != fullscreen_mac::OMNIBOX_TABS_NONE)
       [self scheduleShowForMouse];
   }
 }
 
-// Used to deactivate the floating bar in presentation mode.
+// Used to deactivate the floating bar if the toolbar is hidden.
 - (void)mouseExited:(NSEvent*)event {
-  DCHECK(inPresentationMode_);
+  DCHECK(inFullscreenMode_);
 
-  NSTrackingArea* trackingArea = [event trackingArea];
-  if (trackingArea == trackingArea_) {
+  if ([event trackingArea] == trackingArea_.get()) {
     // 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]) {
       [self setupMouseExitCheck];
       return;
     }
@@ skipping 52 matching lines @@
   // 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)
+@implementation FullscreenToolbarController (PrivateMethods)
 
 - (void)updateMenuBarAndDockVisibility {
   if (![self isMainWindow] || ![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];
@@ skipping 17 matching lines @@
   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 {
+- (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;
   }
 
   // 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]);
+  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];
 }
@@ skipping 15 matching lines @@
     // If the tracking rectangle is already |trackingAreaBounds_|, quit early.
     NSRect oldRect = [trackingArea_ rect];
     if (NSEqualRects(trackingAreaBounds_, oldRect))
       return;
 
     // Otherwise, remove it.
     [self removeTrackingAreaIfNecessary];
   }
 
   // Create and add a new tracking area for |frame|.
-  trackingArea_.reset(
-      [[NSTrackingArea alloc] initWithRect:trackingAreaBounds_
-                                   options:NSTrackingMouseEnteredAndExited |
-                                           NSTrackingActiveInKeyWindow
-                                     owner:self
-                                  userInfo:nil]);
+  trackingArea_.reset([[CrTrackingArea alloc]
+      initWithRect:trackingAreaBounds_
+           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)mouseInsideTrackingRect {
   NSWindow* window = [browserController_ window];
   NSPoint mouseLoc = [window mouseLocationOutsideOfEventStream];
   NSPoint mousePos = [contentView_ convertPoint:mouseLoc fromView:nil];
   return NSMouseInRect(mousePos, trackingAreaBounds_, [contentView_ isFlipped]);
 }
 
 - (void)setupMouseExitCheck {
   [self performSelector:@selector(checkForMouseExit)
              withObject:nil
              afterDelay:kMouseExitCheckDelay];
 }
 
 - (void)cancelMouseExitCheck {
   [NSObject cancelPreviousPerformRequestsWithTarget:self
-      selector:@selector(checkForMouseExit) object:nil];
+                                           selector:@selector(checkForMouseExit)
+                                             object:nil];
 }
 
 - (void)checkForMouseExit {
   if ([self mouseInsideTrackingRect])
     [self setupMouseExitCheck];
   else
     [self scheduleHideForMouse];
 }
 
 - (void)startShowTimer {
@@ skipping 64 matching lines @@
 }
 
 - (void)cleanup {
   [self cancelMouseExitCheck];
   [self cancelAnimationAndTimers];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 
   [self removeTrackingAreaIfNecessary];
   contentView_ = nil;
 
-  // This isn't tracked when not in presentation mode.
+  // This isn't tracked when not in fullscreen 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 setSystemFullscreenModeTo:base::mac::kFullScreenModeNormal];
 
   // No more calls back up to the BWC.
@@ skipping 10 matching lines @@
   [self updateMenuBarAndDockVisibility];
 
   // TODO(rohitrao): Remove the Exit Fullscreen button.  http://crbug.com/35956
 }
 
 - (BOOL)shouldShowMenubarInImmersiveFullscreen {
   return [self doesScreenHaveMenuBar] && toolbarFraction_ > 0.99;
 }
 
 @end