mac, fullscreen: Major refactor.

chrome/browser/ui/cocoa/browser_window_controller_private.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/browser_window_controller_private.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/mac/mac_util.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/fullscreen.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window_state.h"
 #import "chrome/browser/ui/cocoa/dev_tools_controller.h"
 #import "chrome/browser/ui/cocoa/fast_resize_view.h"
 #import "chrome/browser/ui/cocoa/find_bar/find_bar_cocoa_controller.h"
 #import "chrome/browser/ui/cocoa/floating_bar_backing_view.h"
 #import "chrome/browser/ui/cocoa/framed_browser_window.h"
-#import "chrome/browser/ui/cocoa/fullscreen_mode_controller.h"
 #import "chrome/browser/ui/cocoa/fullscreen_window.h"
 #import "chrome/browser/ui/cocoa/infobars/infobar_container_controller.h"
 #include "chrome/browser/ui/cocoa/last_active_browser_cocoa.h"
 #import "chrome/browser/ui/cocoa/nsview_additions.h"
 #import "chrome/browser/ui/cocoa/presentation_mode_controller.h"
 #import "chrome/browser/ui/cocoa/profiles/avatar_button_controller.h"
 #import "chrome/browser/ui/cocoa/profiles/avatar_icon_controller.h"
 #import "chrome/browser/ui/cocoa/status_bubble_mac.h"
 #import "chrome/browser/ui/cocoa/tab_contents/overlayable_contents_controller.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_strip_view.h"
@@ skipping 46 matching lines @@
            browser:browser_.get()
           delegate:self]);
 }
 
 - (void)saveWindowPositionIfNeeded {
   if (!chrome::ShouldSaveWindowPlacement(browser_.get()))
     return;
 
   // If we're in fullscreen mode, save the position of the regular window
   // instead.
-  NSWindow* window = [self isFullscreen] ? savedRegularWindow_ : [self window];
+  NSWindow* window =
+      [self isInAnyFullscreenMode] ? savedRegularWindow_ : [self window];
 
   // Window positions are stored relative to the origin of the primary monitor.
   NSRect monitorFrame = [[[NSScreen screens] objectAtIndex:0] frame];
   NSScreen* windowScreen = [window screen];
 
   // Start with the window's frame, which is in virtual coordinates.
   // Do some y twiddling to flip the coordinate system.
   gfx::Rect bounds(NSRectToCGRect([window frame]));
   bounds.set_y(monitorFrame.size.height - bounds.y() - bounds.height());
 
   // Browser::SaveWindowPlacement saves information for session restore.
   ui::WindowShowState show_state = ui::SHOW_STATE_NORMAL;
   if ([window isMiniaturized])
     show_state = ui::SHOW_STATE_MINIMIZED;
-  else if ([self isFullscreen])
+  else if ([self isInAnyFullscreenMode])
     show_state = ui::SHOW_STATE_FULLSCREEN;
   chrome::SaveWindowPlacement(browser_.get(), bounds, show_state);
 
   // |windowScreen| can be nil (for example, if the monitor arrangement was
   // changed while in fullscreen mode).  If we see a nil screen, return without
   // saving.
   // TODO(rohitrao): We should just not save anything for fullscreen windows.
   // http://crbug.com/36479.
   if (!windowScreen)
     return;
@@ skipping 62 matching lines @@
   // subviews of the content view, so we mainly work in the content view's
   // coordinate system. Note, however, that the content view's coordinate system
   // and the window's base coordinate system should coincide.
   NSWindow* window = [self window];
   NSView* contentView = [window contentView];
   NSRect contentBounds = [contentView bounds];
   CGFloat minX = NSMinX(contentBounds);
   CGFloat minY = NSMinY(contentBounds);
   CGFloat width = NSWidth(contentBounds);
 
-  BOOL useSimplifiedFullscreen = CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kEnableSimplifiedFullscreen);
-
   // Suppress title drawing if necessary.
   if ([window respondsToSelector:@selector(setShouldHideTitle:)])
     [(id)window setShouldHideTitle:![self hasTitleBar]];
 
   // Update z-order. The code below depends on this.
-  [self updateSubviewZOrder:[self inPresentationMode]];
+  [self updateSubviewZOrder:[self isInFullscreenWithOmniboxSliding]];
 
-  BOOL inPresentationMode = [self inPresentationMode];
   CGFloat floatingBarHeight = [self floatingBarHeight];
-  // In presentation mode, |yOffset| accounts for the sliding position of the
-  // floating bar and the extra offset needed to dodge the menu bar.
-  CGFloat yOffset = inPresentationMode && !useSimplifiedFullscreen ?
-      (std::floor((1 - floatingBarShownFraction_) * floatingBarHeight) -
-          [presentationModeController_ floatingBarVerticalOffset]) : 0;
+  CGFloat yOffset = 0;
+  if ([self isInFullscreenWithOmniboxSliding]) {
+    yOffset += [presentationModeController_ menubarOffset];
+    switch (presentationModeController_.get().slidingStyle) {
+      case fullscreen_mac::OMNIBOX_TABS_PRESENT:
+        break;
+      case fullscreen_mac::OMNIBOX_PRESENT: {
+        // At rest: omnibox showing. yOffset should be tabstrip height
+        // When cursor is at top: everything shows. yOffset should be -menubar
+        // height.
+        CGFloat tabStripHeight = 0;
+        if ([self hasTabStrip])
+          tabStripHeight = NSHeight([[self tabStripView] frame]);
+        yOffset +=
+            std::floor((1 - presentationModeController_.get().toolbarFraction) *
+                       tabStripHeight);
+        break;
+      }
+      case fullscreen_mac::OMNIBOX_TABS_HIDDEN:
+        // In presentation mode, |yOffset| accounts for the sliding position of
+        // the floating bar and the extra offset needed to dodge the menu bar.
+        yOffset +=
+            std::floor((1 - presentationModeController_.get().toolbarFraction) *
+                       floatingBarHeight);
+        break;
+    }
+  }
+
   CGFloat maxY = NSMaxY(contentBounds) + yOffset;
 
   if ([self hasTabStrip]) {
     // If we need to lay out the top tab strip, replace |maxY| with a higher
     // value, and then lay out the tab strip.
     NSRect windowFrame = [contentView convertRect:[window frame] fromView:nil];
     maxY = NSHeight(windowFrame) + yOffset;
-    if (useSimplifiedFullscreen && [self isFullscreen]) {
-      CGFloat tabStripHeight = NSHeight([[self tabStripView] frame]);
-      CGFloat revealAmount = (1 - floatingBarShownFraction_) * tabStripHeight;
-      // In simplified fullscreen, only the toolbar is visible by default, and
-      // the tabstrip and menu bar come down (each separately) when the user
-      // mouses near the top of the window. Push the maxY of the toolbar up by
-      // the amount of the tabstrip that is revealed, while removing the amount
-      // of space needed by the menu bar.
-      maxY += std::floor(
-          revealAmount - [fullscreenModeController_ menuBarHeight]);
-    }
     maxY = [self layoutTabStripAtMaxY:maxY
                                 width:width
-                           fullscreen:[self isFullscreen]];
+                           fullscreen:[self isInAnyFullscreenMode]];
   }
 
   // Sanity-check |maxY|.
   DCHECK_GE(maxY, minY);
   DCHECK_LE(maxY, NSMaxY(contentBounds) + yOffset);
 
   // Place the toolbar at the top of the reserved area.
   maxY = [self layoutToolbarAtMinX:minX maxY:maxY width:width];
 
   // If we're not displaying the bookmark bar below the info bar, then it goes
   // immediately below the toolbar.
   BOOL placeBookmarkBarBelowInfoBar = [self placeBookmarkBarBelowInfoBar];
   if (!placeBookmarkBarBelowInfoBar)
     maxY = [self layoutBookmarkBarAtMinX:minX maxY:maxY width:width];
 
   // The floating bar backing view doesn't actually add any height.
   NSRect floatingBarBackingRect =
       NSMakeRect(minX, maxY, width, floatingBarHeight);
   [self layoutFloatingBarBackingView:floatingBarBackingRect
-                    presentationMode:inPresentationMode];
+                    presentationMode:[self isInFullscreenWithOmniboxSliding]];
 
   // Place the find bar immediately below the toolbar/attached bookmark bar. In
   // presentation mode, it hangs off the top of the screen when the bar is
   // hidden.
   [findBarCocoaController_ positionFindBarViewAtMaxY:maxY maxWidth:width];
   [fullscreenExitBubbleController_ positionInWindowAtTop:maxY width:width];
 
-  // If in presentation mode, reset |maxY| to top of screen, so that the
-  // floating bar slides over the things which appear to be in the content area.
-  if (inPresentationMode ||
-      (useSimplifiedFullscreen && !fullscreenUrl_.is_empty())) {
-    maxY = NSMaxY(contentBounds);
+  if ([self isInFullscreenWithOmniboxSliding]) {
+    switch (presentationModeController_.get().slidingStyle) {
+      case fullscreen_mac::OMNIBOX_TABS_PRESENT:
+      case fullscreen_mac::OMNIBOX_PRESENT:
+        // Do nothing in Canonical Fullscreen and Simplified Fullscreen. All
+        // content slides.
+        break;
+      case fullscreen_mac::OMNIBOX_TABS_HIDDEN:
+        // If in presentation mode, reset |maxY| to top of screen, so that the
+        // floating bar slides over the things which appear to be in the content
+        // area.
+        maxY = NSMaxY(contentBounds);
+        break;
+    }
   }
 
   // Also place the info bar container immediate below the toolbar, except in
   // presentation mode in which case it's at the top of the visual content area.
   maxY = [self layoutInfoBarAtMinX:minX maxY:maxY width:width];
 
   // If the bookmark bar is detached, place it next in the visual content area.
   if (placeBookmarkBarBelowInfoBar)
     maxY = [self layoutBookmarkBarAtMinX:minX maxY:maxY width:width];
 
   // Place the download shelf, if any, at the bottom of the view.
   minY = [self layoutDownloadShelfAtMinX:minX minY:minY width:width];
 
   // Finally, the content area takes up all of the remaining space.
   NSRect contentAreaRect = NSMakeRect(minX, minY, width, maxY - minY);
   [self layoutTabContentArea:contentAreaRect];
 
   // Normally, we don't need to tell the toolbar whether or not to show the
   // divider, but things break down during animation.
   [toolbarController_ setDividerOpacity:[self toolbarDividerOpacity]];
 }
 
 - (CGFloat)floatingBarHeight {
-  if (![self inPresentationMode])
+  if (![self isInFullscreenWithOmniboxSliding])
     return 0;
 
-  CGFloat totalHeight = [presentationModeController_ floatingBarVerticalOffset];
+  CGFloat totalHeight = 0;
+  if (presentationModeController_)
+    totalHeight = [presentationModeController_ floatingBarVerticalOffset];
 
   if ([self hasTabStrip])
     totalHeight += NSHeight([[self tabStripView] frame]);
 
   if ([self hasToolbar]) {
     totalHeight += NSHeight([[toolbarController_ view] frame]);
   } else if ([self hasLocationBar]) {
     totalHeight += NSHeight([[toolbarController_ view] frame]) +
                    kLocBarTopInset + kLocBarBottomInset;
   }
@@ skipping 23 matching lines @@
   // Lay out the icognito/avatar badge because calculating the indentation on
   // the right depends on it.
   NSView* avatarButton = [avatarButtonController_ view];
   if ([self shouldShowAvatar]) {
     CGFloat badgeXOffset = -kAvatarRightOffset;
     CGFloat badgeYOffset = 0;
     CGFloat buttonHeight = NSHeight([avatarButton frame]);
 
     if ([self shouldUseNewAvatarButton]) {
       // The fullscreen icon is displayed to the right of the avatar button.
-      if (![self isFullscreen])
+      if (![self isInAnyFullscreenMode])
         badgeXOffset -= kFullscreenIconWidth;
       // Center the button vertically on the tabstrip.
       badgeYOffset = (tabStripHeight - buttonHeight) / 2;
     } else {
       // Actually place the badge *above* |maxY|, by +2 to miss the divider.
       badgeYOffset = 2 * [[avatarButton superview] cr_lineWidth];
     }
 
     [avatarButton setFrameSize:NSMakeSize(NSWidth([avatarButton frame]),
         std::min(buttonHeight, tabStripHeight))];
@@ skipping 15 matching lines @@
         static_cast<FramedBrowserWindow*>([self window]);
     rightIndent += -[window fullScreenButtonOriginAdjustment].x;
 
     if ([self shouldUseNewAvatarButton]) {
       // The new avatar is wider than the default indentation, so we need to
       // account for its width.
       rightIndent += NSWidth([avatarButton frame]) + kAvatarTabStripShrink;
 
       // When the fullscreen icon is not displayed, return its width to the
       // tabstrip.
-      if ([self isFullscreen])
+      if ([self isInAnyFullscreenMode])
         rightIndent -= kFullscreenIconWidth;
     }
   } else if ([self shouldShowAvatar]) {
     rightIndent += kAvatarTabStripShrink +
         NSWidth([avatarButton frame]) + kAvatarRightOffset;
   }
   [tabStripController_ setRightIndentForControls:rightIndent];
 
   // Go ahead and layout the tabs.
   [tabStripController_ layoutTabsWithoutAnimation];
@@ skipping 132 matching lines @@
   if (contentShifted) {
     if (WebContents* contents =
             browser_->tab_strip_model()->GetActiveWebContents()) {
       if (RenderWidgetHostView* rwhv = contents->GetRenderWidgetHostView())
         rwhv->WindowFrameChanged();
     }
   }
 }
 
 - (void)updateRoundedBottomCorners {
-  [[self tabContentArea] setRoundedBottomCorners:![self isFullscreen]];
+  [[self tabContentArea] setRoundedBottomCorners:![self isInAnyFullscreenMode]];
 }
 
 - (void)adjustToolbarAndBookmarkBarForCompression:(CGFloat)compression {
   CGFloat newHeight =
       [toolbarController_ desiredHeightForCompression:compression];
   NSRect toolbarFrame = [[toolbarController_ view] frame];
   CGFloat deltaH = newHeight - toolbarFrame.size.height;
 
   if (deltaH == 0)
     return;
@@ skipping 108 matching lines @@
 
   NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
   [center removeObserver:self
                     name:NSWindowWillCloseNotification
                   object:[notification object]];
   [self releaseBarVisibilityForOwner:[notification object]
                        withAnimation:YES
                                delay:YES];
 }
 
-- (void)setPresentationModeInternal:(BOOL)presentationMode
-                      forceDropdown:(BOOL)forceDropdown {
-  if (presentationMode == [self inPresentationMode])
-    return;
-
-  if (presentationMode) {
-    BOOL fullscreen_for_tab =
-        browser_->fullscreen_controller()->IsWindowFullscreenForTabOrPending();
-    BOOL kiosk_mode =
-        CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode);
-    BOOL showDropdown = !fullscreen_for_tab &&
-        !kiosk_mode &&
-        (forceDropdown || [self floatingBarHasFocus]);
-    presentationModeController_.reset(
-        [[PresentationModeController alloc] initWithBrowserController:self]);
-
-    if (permissionBubbleCocoa_ && permissionBubbleCocoa_->IsVisible()) {
-      DCHECK(permissionBubbleCocoa_->window());
-      // A visible permission bubble will force the dropdown to remain visible.
-      [self lockBarVisibilityForOwner:permissionBubbleCocoa_->window()
-                        withAnimation:NO
-                                delay:NO];
-      showDropdown = YES;
-      // Register to be notified when the permission bubble is closed, to
-      // allow fullscreen to hide the dropdown.
-      NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
-      [center addObserver:self
-                 selector:@selector(permissionBubbleWindowWillClose:)
-                     name:NSWindowWillCloseNotification
-                   object:permissionBubbleCocoa_->window()];
-    }
-    if (showDropdown) {
-      // Turn on layered mode for the window's root view for the entry
-      // animation.  Without this, the OS fullscreen animation for entering
-      // fullscreen mode does not correctly draw the tab strip.
-      // It will be turned off (set back to NO) when the animation finishes,
-      // in -windowDidEnterFullScreen:.
-      // Leaving wantsLayer on for the duration of presentation mode causes
-      // performance issues when the dropdown is animated in/out.  It also does
-      // not seem to be required for the exit animation.
-      windowViewWantsLayer_ = [[[self window] cr_windowView] wantsLayer];
-      [[[self window] cr_windowView] setWantsLayer:YES];
-    }
-    NSView* contentView = [[self window] contentView];
-    [presentationModeController_ enterPresentationModeForContentView:contentView
-                                 showDropdown:showDropdown];
-  } else {
-    [presentationModeController_ exitPresentationMode];
-    presentationModeController_.reset();
+- (void)configurePresentationModeController {
+  BOOL fullscreen_for_tab =
+      browser_->fullscreen_controller()->IsWindowFullscreenForTabOrPending();
+  BOOL kiosk_mode =
+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode);
+  BOOL showDropdown =
+      !fullscreen_for_tab && !kiosk_mode && ([self floatingBarHasFocus]);
+  if (permissionBubbleCocoa_ && permissionBubbleCocoa_->IsVisible()) {
+    DCHECK(permissionBubbleCocoa_->window());
+    // A visible permission bubble will force the dropdown to remain visible.
+    [self lockBarVisibilityForOwner:permissionBubbleCocoa_->window()
+                      withAnimation:NO
+                              delay:NO];
+    showDropdown = YES;
+    // Register to be notified when the permission bubble is closed, to
+    // allow fullscreen to hide the dropdown.
+    NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
+    [center addObserver:self
+               selector:@selector(permissionBubbleWindowWillClose:)
+                   name:NSWindowWillCloseNotification
+                 object:permissionBubbleCocoa_->window()];
+  }
+  if (showDropdown) {
+    // Turn on layered mode for the window's root view for the entry
+    // animation.  Without this, the OS fullscreen animation for entering
+    // fullscreen mode does not correctly draw the tab strip.
+    // It will be turned off (set back to NO) when the animation finishes,
+    // in -windowDidEnterFullScreen:.
+    // Leaving wantsLayer on for the duration of presentation mode causes
+    // performance issues when the dropdown is animated in/out.  It also does
+    // not seem to be required for the exit animation.
+    windowViewWantsLayer_ = [[[self window] cr_windowView] wantsLayer];
+    [[[self window] cr_windowView] setWantsLayer:YES];
   }
 
-  [self adjustUIForPresentationMode:presentationMode];
+  NSView* contentView = [[self window] contentView];
+  [presentationModeController_
+      enterPresentationModeForContentView:contentView
+                             showDropdown:showDropdown];
+}
+
+- (void)adjustUIForExitingFullscreenAndStopOmniboxSliding {
+  [presentationModeController_ exitPresentationMode];
+  presentationModeController_.reset();
+
+  // Force the bookmark bar z-order to update.
+  [[bookmarkBarController_ view] removeFromSuperview];
+  [self layoutSubviews];
+}
+
+- (void)adjustUIForSlidingFullscreenStyle:(fullscreen_mac::SlidingStyle)style {
+  if (!presentationModeController_) {
+    presentationModeController_.reset(
+        [[PresentationModeController alloc] initWithBrowserController:self
+                                                                style:style]);
+    [self configurePresentationModeController];
+  } else {
+    presentationModeController_.get().slidingStyle = style;
+  }
+
+  if (!floatingBarBackingView_.get() &&
+      ([self hasTabStrip] || [self hasToolbar] || [self hasLocationBar])) {
+    floatingBarBackingView_.reset(
+        [[FloatingBarBackingView alloc] initWithFrame:NSZeroRect]);
+    [floatingBarBackingView_
+        setAutoresizingMask:(NSViewWidthSizable | NSViewMinYMargin)];
+  }
+
+  // Force the bookmark bar z-order to update.
+  [[bookmarkBarController_ view] removeFromSuperview];
   [self layoutSubviews];
 }
 
 - (void)enterImmersiveFullscreen {
-  // |-isFullscreen:| will return YES from here onwards.
-  enteringFullscreen_ = YES;  // Set to NO by |-windowDidEnterFullScreen:|.
+  // Set to NO by |-windowDidEnterFullScreen:|.
+  enteringImmersiveFullscreen_ = YES;
 
   // Fade to black.
   const CGDisplayReservationInterval kFadeDurationSeconds = 0.6;
   Boolean didFadeOut = NO;
   CGDisplayFadeReservationToken token;
   if (CGAcquireDisplayFadeReservation(kFadeDurationSeconds, &token)
       == kCGErrorSuccess) {
     didFadeOut = YES;
     CGDisplayFade(token, kFadeDurationSeconds / 2, kCGDisplayBlendNormal,
         kCGDisplayBlendSolidColor, 0.0, 0.0, 0.0, /*synchronous=*/true);
   }
 
   // Create the fullscreen window.
   fullscreenWindow_.reset([[self createFullscreenWindow] retain]);
   savedRegularWindow_ = [[self window] retain];
   savedRegularWindowFrame_ = [savedRegularWindow_ frame];
 
   [self moveViewsForImmersiveFullscreen:YES
                           regularWindow:[self window]
                        fullscreenWindow:fullscreenWindow_.get()];
 
   // When simplified fullscreen is enabled, do not enter presentation mode.
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
+  fullscreen_mac::SlidingStyle style;
   if (command_line->HasSwitch(switches::kEnableSimplifiedFullscreen)) {
-    // TODO(rohitrao): Add code to manage the menubar here.
+    style = fullscreen_mac::OMNIBOX_PRESENT;
   } else {
-    [self adjustUIForPresentationMode:YES];
-    [self setPresentationModeInternal:YES forceDropdown:NO];
+    style = fullscreen_mac::OMNIBOX_TABS_HIDDEN;
   }
+  [self adjustUIForSlidingFullscreenStyle:style];
 
   // AppKit is helpful and prevents NSWindows from having the same height as
   // the screen while the menu bar is showing. This only applies to windows on
   // a secondary screen, in a separate space. Calling [NSWindow
   // setFrame:display:] with the screen's height will always reduce the
   // height by the height of the MenuBar. Calling the method with any other
   // height works fine. The relevant method in the 10.10 AppKit SDK is called:
   // _canAdjustSizeForScreensHaveSeparateSpacesIfFillingSecondaryScreen
   //
   // TODO(erikchen): Refactor the logic to allow the window to be shown after
@@ skipping 49 matching lines @@
   [self windowDidExitFullScreen:nil];
 
   // Fade back in.
   if (didFadeOut) {
     CGDisplayFade(token, kFadeDurationSeconds / 2, kCGDisplayBlendSolidColor,
         kCGDisplayBlendNormal, 0.0, 0.0, 0.0, /*synchronous=*/false);
     CGReleaseDisplayFadeReservation(token);
   }
 }
 
-// TODO(rohitrao): This function has shrunk into uselessness, and
-// |-setFullscreen:| has grown rather large.  Find a good way to break up
-// |-setFullscreen:| into smaller pieces.  http://crbug.com/36449
-- (void)adjustUIForPresentationMode:(BOOL)fullscreen {
-  // Create the floating bar backing view if necessary.
-  if (fullscreen && !floatingBarBackingView_.get() &&
-      ([self hasTabStrip] || [self hasToolbar] || [self hasLocationBar])) {
-    floatingBarBackingView_.reset(
-        [[FloatingBarBackingView alloc] initWithFrame:NSZeroRect]);
-    [floatingBarBackingView_ setAutoresizingMask:(NSViewWidthSizable |
-                                                  NSViewMinYMargin)];
-  }
-
-  // Force the bookmark bar z-order to update.
-  [[bookmarkBarController_ view] removeFromSuperview];
-  [self updateSubviewZOrder:fullscreen];
-}
-
 - (void)showFullscreenExitBubbleIfNecessary {
   // This method is called in response to
   // |-updateFullscreenExitBubbleURL:bubbleType:|. If we're in the middle of the
-  // transition into fullscreen (i.e., using the System Fullscreen API), do not
+  // transition into fullscreen (i.e., using the AppKit Fullscreen API), do not
   // show the bubble because it will cause visual jank
   // (http://crbug.com/130649). This will be called again as part of
   // |-windowDidEnterFullScreen:|, so arrange to do that work then instead.
-  if (enteringFullscreen_)
+  if (enteringAppKitFullscreen_)
     return;
 
   [self hideOverlayIfPossibleWithAnimation:NO delay:NO];
 
   if (fullscreenBubbleType_ == FEB_TYPE_NONE ||
       fullscreenBubbleType_ == FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION) {
     // Show no exit instruction bubble on Mac when in Browser Fullscreen.
     [self destroyFullscreenExitBubbleIfNecessary];
   } else {
     [fullscreenExitBubbleController_ closeImmediately];
@@ skipping 44 matching lines @@
 }
 
 - (void)windowWillEnterFullScreen:(NSNotification*)notification {
   if (notification)  // For System Fullscreen when non-nil.
     [self registerForContentViewResizeNotifications];
 
   NSWindow* window = [self window];
   savedRegularWindowFrame_ = [window frame];
   BOOL mode = enteringPresentationMode_ ||
        browser_->fullscreen_controller()->IsWindowFullscreenForTabOrPending();
-  enteringFullscreen_ = YES;
-  [self setPresentationModeInternal:mode forceDropdown:NO];
+  enteringAppKitFullscreen_ = YES;
+
+  fullscreen_mac::SlidingStyle style;
+  const CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kEnableSimplifiedFullscreen))
+    style = fullscreen_mac::OMNIBOX_PRESENT;
+  else if (mode)
+    style = fullscreen_mac::OMNIBOX_TABS_HIDDEN;
+  else
+    style = fullscreen_mac::OMNIBOX_TABS_PRESENT;
+
+  [self adjustUIForSlidingFullscreenStyle:style];
 }
 
 - (void)windowDidEnterFullScreen:(NSNotification*)notification {
   // In Yosemite, some combination of the titlebar and toolbar always show in
   // full-screen mode. We do not want either to show. Search for the window that
   // contains the views, and hide it. There is no need to ever unhide the view.
   // http://crbug.com/380235
   if (base::mac::IsOSYosemiteOrLater()) {
     for (NSWindow* window in [[NSApplication sharedApplication] windows]) {
       if ([window
               isKindOfClass:NSClassFromString(@"NSToolbarFullScreenWindow")]) {
         [window.contentView setHidden:YES];
       }
     }
   }
 
   if (notification)  // For System Fullscreen when non-nil.
     [self deregisterForContentViewResizeNotifications];
-  enteringFullscreen_ = NO;
+  enteringAppKitFullscreen_ = NO;
+  enteringImmersiveFullscreen_ = NO;
   enteringPresentationMode_ = NO;
 
-  const CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kEnableSimplifiedFullscreen) &&
-      fullscreenUrl_.is_empty()) {
-    fullscreenModeController_.reset([[FullscreenModeController alloc]
-        initWithBrowserWindowController:self]);
-  }
-
   [self showFullscreenExitBubbleIfNecessary];
   browser_->WindowFullscreenStateChanged();
   [[[self window] cr_windowView] setWantsLayer:windowViewWantsLayer_];
   [self updateRoundedBottomCorners];
 }
 
 - (void)windowWillExitFullScreen:(NSNotification*)notification {
   if (notification)  // For System Fullscreen when non-nil.
     [self registerForContentViewResizeNotifications];
-  fullscreenModeController_.reset();
   [self destroyFullscreenExitBubbleIfNecessary];
-  [self setPresentationModeInternal:NO forceDropdown:NO];
+  [self adjustUIForExitingFullscreenAndStopOmniboxSliding];
 }
 
 - (void)windowDidExitFullScreen:(NSNotification*)notification {
   if (notification)  // For System Fullscreen when non-nil.
     [self deregisterForContentViewResizeNotifications];
   browser_->WindowFullscreenStateChanged();
   [self updateRoundedBottomCorners];
 }
 
 - (void)windowDidFailToEnterFullScreen:(NSWindow*)window {
   [self deregisterForContentViewResizeNotifications];
-  enteringFullscreen_ = NO;
-  [self setPresentationModeInternal:NO forceDropdown:NO];
-
-  // Force a relayout to try and get the window back into a reasonable state.
-  [self layoutSubviews];
+  enteringAppKitFullscreen_ = NO;
+  [self adjustUIForExitingFullscreenAndStopOmniboxSliding];
 }
 
 - (void)windowDidFailToExitFullScreen:(NSWindow*)window {
   [self deregisterForContentViewResizeNotifications];
 
   // Force a relayout to try and get the window back into a reasonable state.
   [self layoutSubviews];
 }
 
 - (void)enableBarVisibilityUpdates {
@@ skipping 22 matching lines @@
   if (!barVisibilityUpdatesEnabled_ || [barVisibilityLocks_ count])
     return;
   [presentationModeController_ ensureOverlayHiddenWithAnimation:animation
                                                           delay:delay];
 }
 
 - (CGFloat)toolbarDividerOpacity {
   return [bookmarkBarController_ toolbarDividerOpacity];
 }
 
-- (void)updateSubviewZOrder:(BOOL)inPresentationMode {
+// TODO(erikchen): The implementation of this method is quite fragile. The
+// method cr_ensureSubview:... does not check that the subview is /directly/
+// above/below the given view. e.g. There are 3 subviews: A, B, C, in that
+// order.  The method cr_ensureSubview:A isPositioned:NSWindowBelow
+// relativeTo:C will have no effect, even though the desired result may have
+// been: B, A, C.  Consider changing it?
+- (void)updateSubviewZOrder:(BOOL)inAnyFullscreen {
   NSView* contentView = [[self window] contentView];
   NSView* toolbarView = [toolbarController_ view];
 
-  if (inPresentationMode) {
+  if (inAnyFullscreen) {
     // Toolbar is above tab contents so that it can slide down from top of
     // screen.
     [contentView cr_ensureSubview:toolbarView
                      isPositioned:NSWindowAbove
                        relativeTo:[self tabContentArea]];
   } else {
     // Toolbar is below tab contents so that the info bar arrow can appear above
     // it.
     [contentView cr_ensureSubview:toolbarView
                      isPositioned:NSWindowBelow
                        relativeTo:[self tabContentArea]];
   }
 
   // The bookmark bar is always below the toolbar.
   [contentView cr_ensureSubview:[bookmarkBarController_ view]
                    isPositioned:NSWindowBelow
                      relativeTo:toolbarView];
 
-  if (inPresentationMode) {
+  if (inAnyFullscreen) {
     // In presentation mode the info bar is below all other views.
     [contentView cr_ensureSubview:[infoBarContainerController_ view]
                      isPositioned:NSWindowBelow
                        relativeTo:[self tabContentArea]];
   } else {
     // Above the toolbar but still below tab contents. Similar to the bookmark
     // bar, this allows Instant results to be above the info bar.
     [contentView cr_ensureSubview:[infoBarContainerController_ view]
                      isPositioned:NSWindowAbove
                        relativeTo:toolbarView];
   }
 
   // The find bar is above everything.
   if (findBarCocoaController_) {
     NSView* relativeView = nil;
-    if (inPresentationMode)
+    if (inAnyFullscreen)
       relativeView = toolbarView;
     else
       relativeView = [self tabContentArea];
     [contentView cr_ensureSubview:[findBarCocoaController_ view]
                      isPositioned:NSWindowAbove
                        relativeTo:relativeView];
   }
 
   if (floatingBarBackingView_) {
     if ([floatingBarBackingView_ cr_isBelowView:[self tabContentArea]])
       [floatingBarBackingView_ removeFromSuperview];
     if ([self placeBookmarkBarBelowInfoBar]) {
       [contentView cr_ensureSubview:floatingBarBackingView_
                        isPositioned:NSWindowAbove
                          relativeTo:[bookmarkBarController_ view]];
     } else {
       [contentView cr_ensureSubview:floatingBarBackingView_
                        isPositioned:NSWindowBelow
                          relativeTo:[bookmarkBarController_ view]];
     }
+
+    // TODO(erikchen): This constraint is necessary. See comment at the
+    // beginning of the method.
+    [contentView cr_ensureSubview:floatingBarBackingView_
+                     isPositioned:NSWindowAbove
+                       relativeTo:[self tabContentArea]];
+  }
+
+  // TODO(erikchen): Remove and then add the tabStripView to the root NSView.
+  // This fixes a layer ordering problem that occurs between the contentView
+  // and the tabStripView. This is a hack required because NSThemeFrame is not
+  // layer backed, and because Chrome adds subviews directly to the
+  // NSThemeFrame.
+  // http://crbug.com/407921
+  if (enteringAppKitFullscreen_) {
+    // The tabstrip frequently lies outside the bounds of its superview.
+    // Repeatedly adding/removing the tabstrip from its superview during the
+    // AppKit Fullscreen transition causes graphical glitches on 10.10. The
+    // correct solution is to use the AppKit fullscreen transition APIs added
+    // in 10.7+.
+    // http://crbug.com/408791
+    if (!hasAdjustedTabStripWhileEnteringAppKitFullscreen_) {
+      // Disable implicit animations.
+      [CATransaction begin];
+      [CATransaction setDisableActions:YES];
+
+      // Get the current position of the tabStripView.
+      NSView* superview = [[self tabStripView] superview];
+      NSArray* subviews = [superview subviews];
+      NSInteger index = [subviews indexOfObject:[self tabStripView]];
+      NSView* siblingBelow = nil;
+      if (index > 0)
+        siblingBelow = [subviews objectAtIndex:index - 1];
+
+      // Remove the tabStripView.
+      [[self tabStripView] removeFromSuperview];
+
+      // Add it to the same position.
+      if (siblingBelow) {
+        [superview addSubview:[self tabStripView]
+                   positioned:NSWindowAbove
+                   relativeTo:siblingBelow];
+      } else {
+        [superview addSubview:[self tabStripView]
+                   positioned:NSWindowBelow
+                   relativeTo:nil];
+      }
+
+      [CATransaction commit];
+      hasAdjustedTabStripWhileEnteringAppKitFullscreen_ = YES;
+    }
+  } else {
+    hasAdjustedTabStripWhileEnteringAppKitFullscreen_ = NO;
   }
 }
 
 - (void)updateInfoBarTipVisibility {
   // If there's no toolbar then hide the infobar tip.
   [infoBarContainerController_
       setShouldSuppressTopInfoBarTip:![self hasToolbar]];
 }
 
 - (NSInteger)infoBarMaxTopArrowHeight {
   NSInteger topArrowHeight = 0;
   LocationBarViewMac* locationBarView = [self locationBarBridge];
   NSPoint iconBottom = locationBarView->GetPageInfoBubblePoint();
 
   CGFloat overlappingTipHeight =
       [infoBarContainerController_ overlappingTipHeight];
   NSPoint infoBarTop =
       NSMakePoint(0, NSHeight([infoBarContainerController_ view].frame) -
                   overlappingTipHeight);
   infoBarTop = [[infoBarContainerController_ view] convertPoint:infoBarTop
                                                          toView:nil];
 
   topArrowHeight = iconBottom.y - infoBarTop.y;
   return topArrowHeight;
 }
 
+- (void)enterAppKitFullscreen {
+  DCHECK(base::mac::IsOSLionOrLater());
+  if (FramedBrowserWindow* framedBrowserWindow =
+          base::mac::ObjCCast<FramedBrowserWindow>([self window])) {
+    [framedBrowserWindow toggleSystemFullScreen];
+  }
+}
+
+- (void)exitAppKitFullscreen {
+  DCHECK(base::mac::IsOSLionOrLater());
+  if (FramedBrowserWindow* framedBrowserWindow =
+          base::mac::ObjCCast<FramedBrowserWindow>([self window])) {
+    [framedBrowserWindow toggleSystemFullScreen];
+  }
+}
+
 @end  // @implementation BrowserWindowController(Private)