Implement Tab Detaching in Fullscreen Mode on Mac OSX

chrome/browser/ui/cocoa/browser_window_controller.mm

 // Copyright 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.h"
 
 #include <cmath>
 #include <numeric>
 #include <utility>
 
@@ skipping 345 matching lines @@
 
     // We don't want to try and show the bar before it gets placed in its parent
     // view, so this step shoudn't be inside the bookmark bar controller's
     // |-awakeFromNib|.
     windowShim_->BookmarkBarStateChanged(
         BookmarkBar::DONT_ANIMATE_STATE_CHANGE);
 
     // Allow bar visibility to be changed.
     [self enableBarVisibilityUpdates];
 
-    // Set the window to participate in Lion Fullscreen mode.  Setting this flag
-    // has no effect on Snow Leopard or earlier.  Panels can share a fullscreen
-    // space with a tabbed window, but they can not be primary fullscreen
-    // windows.
-    // This ensures the fullscreen button is appropriately positioned. It must
-    // be done before calling layoutSubviews because the new avatar button's
-    // position depends on the fullscreen button's position, as well as
-    // TabStripController's rightIndentForControls.
-    // The fullscreen button's position may depend on the old avatar button's
-    // width, but that does not require calling layoutSubviews first.
-    NSUInteger collectionBehavior = [window collectionBehavior];
-    collectionBehavior |=
-       browser_->type() == Browser::TYPE_TABBED ||
-           browser_->type() == Browser::TYPE_POPUP ?
-               NSWindowCollectionBehaviorFullScreenPrimary :
-               NSWindowCollectionBehaviorFullScreenAuxiliary;
-    [window setCollectionBehavior:collectionBehavior];
+    [self updateFullscreenCollectionBehavior];
 
     [self layoutSubviews];
 
     // For non-trusted, non-app popup windows, |desiredContentRect| contains the
     // desired height of the content, not of the whole window.  Now that all the
     // views are laid out, measure the current content area size and grow if
     // needed. The window has not been placed onscreen yet, so this extra resize
     // will not cause visible jank.
     if (chrome::SavedBoundsAreContentBounds(browser_.get())) {
       CGFloat deltaH = desiredContentRect.height() -
@@ skipping 805 matching lines @@
 
   // Disable screen updates so that this appears as a single visual change.
   gfx::ScopedCocoaDisableScreenUpdates disabler;
 
   // Set the window size. Need to do this before we detach the tab so it's
   // still in the window. We have to flip the coordinates as that's what
   // is expected by the Browser code.
   NSWindow* sourceWindow = [draggedTab window];
   NSRect windowRect = [sourceWindow frame];
   NSScreen* screen = [sourceWindow screen];
-  windowRect.origin.y = NSHeight([screen frame]) - NSMaxY(windowRect);
+  windowRect.origin.y =
+      NSHeight([screen frame]) - NSMaxY(windowRect) + [self menubarOffset];
   gfx::Rect browserRect(windowRect.origin.x, windowRect.origin.y,
                         NSWidth(windowRect), NSHeight(windowRect));
 
   std::vector<TabStripModelDelegate::NewStripContents> contentses;
   TabStripModel* model = browser_->tab_strip_model();
 
   for (TabView* tabView in tabViews) {
     // Fetch the tab contents for the tab being dragged.
     int index = [tabStripController_ modelIndexForTabView:tabView];
     bool isPinned = model->IsTabPinned(index);
@@ skipping 19 matching lines @@
   // Create a new window with the dragged tabs in its model.
   Browser* newBrowser = browser_->tab_strip_model()->delegate()->
       CreateNewStripWithContents(contentses, browserRect, false);
 
   // Get the new controller by asking the new window for its delegate.
   BrowserWindowController* controller =
       reinterpret_cast<BrowserWindowController*>(
           [newBrowser->window()->GetNativeWindow() delegate]);
   DCHECK(controller && [controller isKindOfClass:[TabWindowController class]]);
 
+  // Ensure that the window will appear on top of the source window in
+  // fullscreen mode.
+  if ([self isInAppKitFullscreen]) {
+    NSWindow* window = [controller window];
+    NSUInteger collectionBehavior = [window collectionBehavior];
+    collectionBehavior &= ~NSWindowCollectionBehaviorFullScreenPrimary;
+    collectionBehavior |= NSWindowCollectionBehaviorFullScreenAuxiliary;
+    [window setCollectionBehavior:collectionBehavior];
+    [window setLevel:NSFloatingWindowLevel];
+
+    controller->savedRegularWindowFrame_ = savedRegularWindowFrame_;
+  }
+
   // And make sure we use the correct frame in the new view.
   TabStripController* tabStripController = [controller tabStripController];
   NSView* tabStrip = [self tabStripView];
   NSEnumerator* tabEnumerator = [tabViews objectEnumerator];
   for (NSView* newView in [tabStripController tabViews]) {
     NSView* oldView = [tabEnumerator nextObject];
     if (oldView) {
       // Pushes tabView's frame back inside the tabstrip.
       NSRect sourceTabRect = [oldView frame];
       NSSize tabOverflow =
           [self overflowFrom:[tabStrip convertRect:sourceTabRect toView:nil]
                           to:[tabStrip frame]];
       NSRect tabRect =
           NSOffsetRect(sourceTabRect, -tabOverflow.width, -tabOverflow.height);
       // Force the added tab to the right size (remove stretching.)
       tabRect.size.height = [TabStripController defaultTabHeight];
 
       [tabStripController setFrame:tabRect ofTabView:newView];
     }
   }
 
   return controller;
 }
 
+- (void)detachedWindowEnterFullscreenIfNeeded:(TabWindowController*)source {
+  // Ensure that this is only called when the tab is detached into its own
+  // window (in which the overlay window will be present).
+  DCHECK([self overlayWindow]);
+
+  if (([[source window] styleMask] & NSFullScreenWindowMask)
+      == NSFullScreenWindowMask) {
+    [self updateFullscreenCollectionBehavior];
+
+    // Since the detached window in fullscreen will have the size of the
+    // screen, it will set |savedRegularWindowFrame_| to the screen size after
+    // it enters fullscreen. Make sure that we have the correct value for the
+    // |savedRegularWindowFrame_|.
+    NSRect regularWindowFrame = savedRegularWindowFrame_;
+    [[self window] toggleFullScreen:nil];
+    savedRegularWindowFrame_ = regularWindowFrame;
+  }
+}
+
 - (void)insertPlaceholderForTab:(TabView*)tab
                           frame:(NSRect)frame {
   [super insertPlaceholderForTab:tab frame:frame];
   [tabStripController_ insertPlaceholderForTab:tab frame:frame];
 }
 
 - (void)removePlaceholder {
   [super removePlaceholder];
   [tabStripController_ insertPlaceholderForTab:nil frame:NSZeroRect];
 }
 
 - (BOOL)isDragSessionActive {
   // The tab can be dragged within the existing tab strip or detached
   // into its own window (then the overlay window will be present).
   return [[self tabStripController] isDragSessionActive] ||
          [self overlayWindow] != nil;
 }
 
 - (BOOL)tabDraggingAllowed {
   return [tabStripController_ tabDraggingAllowed];
 }
 
 - (BOOL)tabTearingAllowed {
-  return ![self isInAnyFullscreenMode];
+  return ![self isInAnyFullscreenMode] ||
+         base::CommandLine::ForCurrentProcess()->HasSwitch(
+             switches::kEnableFullscreenTabDetaching);
 }
 
 - (BOOL)windowMovementAllowed {
-  return ![self isInAnyFullscreenMode];
+  return ![self isInAnyFullscreenMode] || [self overlayWindow];
 }
 
 - (BOOL)isTabFullyVisible:(TabView*)tab {
   return [tabStripController_ isTabFullyVisible:tab];
 }
 
 - (void)showNewTabButton:(BOOL)show {
   [tabStripController_ showNewTabButton:show];
 }
 
@@ skipping 591 matching lines @@
   return fullscreenWindow_.get() != nil || enteringImmersiveFullscreen_;
 }
 
 - (BOOL)isInAppKitFullscreen {
   return !exitingAppKitFullscreen_ &&
          (([[self window] styleMask] & NSFullScreenWindowMask) ==
               NSFullScreenWindowMask ||
           enteringAppKitFullscreen_);
 }
 
+- (CGFloat)menubarOffset {
+  return [presentationModeController_ menubarOffset];
+}
+
 - (void)enterExtensionFullscreen {
   if (chrome::mac::SupportsSystemFullscreen()) {
     [self enterBrowserFullscreenWithToolbar:NO];
   } else {
     [self enterImmersiveFullscreen];
     DCHECK(!exclusiveAccessController_->url().is_empty());
     [self updateFullscreenExitBubble];
   }
 }
 
@@ skipping 125 matching lines @@
 
 - (BOOL)isTabbedWindow {
   return browser_->is_type_tabbed();
 }
 
 - (NSRect)savedRegularWindowFrame {
   return savedRegularWindowFrame_;
 }
 
 @end  // @implementation BrowserWindowController(WindowType)