Add support for constrained windows on os x, based on Avi's GTMWindowSheetController.

chrome/browser/cocoa/browser_window_controller.mm

 // Copyright (c) 2009 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.
 
 #include <Carbon/Carbon.h>
 
 #include "base/mac_util.h"
 #include "base/scoped_nsdisable_screen_updates.h"
 #import "base/scoped_nsobject.h"
 #include "base/sys_string_conversions.h"
@@ skipping 44 matching lines @@
 // Note: These functions are private, use -[NSObject respondsToSelector:]
 // before calling them.
 
 - (void)setAutorecalculatesContentBorderThickness:(BOOL)b
                                           forEdge:(NSRectEdge)e;
 - (void)setContentBorderThickness:(CGFloat)b forEdge:(NSRectEdge)e;
 
 - (void)setBottomCornerRounded:(BOOL)rounded;
 
 - (NSRect)_growBoxRect;
+
 @end
 
 
 @interface BrowserWindowController(Private)
 
 // Leopard's gradient heuristic gets confused by our tabs and makes the title
 // gradient jump when creating a tab that is less than a tab width from the
 // right side of the screen. This function disables Leopard's gradient
 // heuristic.
 - (void)fixWindowGradient;
@@ skipping 156 matching lines @@
 }
 
 - (void)destroyBrowser {
   [NSApp removeWindowsItem:[self window]];
 
   // We need the window to go away now.
   [self autorelease];
 }
 
 // Called when the window meets the criteria to be closed (ie,
-// |-windowShoudlClose:| returns YES). We must be careful to preserve the
+// |-windowShouldClose:| returns YES). We must be careful to preserve the
 // semantics of BrowserWindow::Close() and not call the Browser's dtor directly
 // from this method.
 - (void)windowWillClose:(NSNotification*)notification {
   DCHECK(!browser_->tabstrip_model()->count());
 
   // We can't actually use |-autorelease| here because there's an embedded
   // run loop in the |-performClose:| which contains its own autorelease pool.
   // Instead we use call it after a zero-length delay, which gets us back
   // to the main event loop.
   [self performSelector:@selector(autorelease)
              withObject:nil
              afterDelay:0];
 }
 
+// Checks if there are any tabs with sheets open, and if so, raises one of
+// the tabs with a sheet and returns NO.
+- (BOOL)shouldCloseWithOpenPerTabSheets {
+  // This is O(n_open_sheets * n_tabs), i.e. O(n**2). Since people probably
+  // won't have 100 tabs open, and not every tab will have a sheet, this is ok.
+  for (NSView* view in
+      [[tabStripController_ sheetController] viewsWithAttachedSheets]) {
+    [tabStripController_ gtm_systemRequestsVisibilityForView:view];
+    return NO;
+  }
+
+  return YES;
+}
+
+- (void)attachConstrainedWindow:(ConstrainedWindowMac*)window {
+  [tabStripController_ attachConstrainedWindow:window];
+}
+
+- (void)removeConstrainedWindow:(ConstrainedWindowMac*)window {
+  [tabStripController_ removeConstrainedWindow:window];
+}
+
 // Called when the user wants to close a window or from the shutdown process.
 // The Browser object is in control of whether or not we're allowed to close. It
 // may defer closing due to several states, such as onUnload handlers needing to
 // be fired. If closing is deferred, the Browser will handle the processing
 // required to get us to the closing state and (by watching for all the tabs
 // going away) will again call to close the window when it's finally ready.
 - (BOOL)windowShouldClose:(id)sender {
+  // Do not close a window with open sheets, as required by
+  // GTMWindowSheetController.
+  if (![self shouldCloseWithOpenPerTabSheets])
+    return NO;
+
   // Disable updates while closing all tabs to avoid flickering.
   base::ScopedNSDisableScreenUpdates disabler;
   // Give beforeunload handlers the chance to cancel the close before we hide
   // the window below.
   if (!browser_->ShouldCloseWindow())
     return NO;
 
   // saveWindowPositionIfNeeded: only works if we are the last active
   // window, but orderOut: ends up activating another window, so we
   // have to save the window position before we call orderOut:.
@@ skipping 140 matching lines @@
       return;
     }
     const std::wstring encoding = current_tab->encoding();
 
     bool toggled = encoding_controller.IsItemChecked(profile, encoding, tag);
     NSInteger oldState = [item state];
     NSInteger newState = toggled ? NSOnState : NSOffState;
     if (oldState != newState)
       [item setState:newState];
   }
+}
 
+- (BOOL)supportsFullscreen {
+  // TODO(avi, thakis): GTMWindowSheetController has no api to move
+  // tabsheets between windows. Until then, we have to prevent having to
+  // move a tabsheet between windows, e.g. no fullscreen toggling
+  NSArray* a = [[tabStripController_ sheetController] viewsWithAttachedSheets];
+  return [a count] == 0;
 }
 
 // Called to validate menu and toolbar items when this window is key. All the
 // items we care about have been set with the |commandDispatch:| action and
 // a target of FirstResponder in IB. If it's not one of those, let it
 // continue up the responder chain to be handled elsewhere. We pull out the
 // tag as the cross-platform constant to differentiate and dispatch the
 // various commands.
 // NOTE: we might have to handle state for app-wide menu items,
 // although we could cheat and directly ask the app controller if our
@@ skipping 11 matching lines @@
         case IDC_CLOSE_TAB:
           // Disable "close tab" if we're not the key window or if there's only
           // one tab.
           enable &= [self numberOfTabs] > 1 && [[self window] isKeyWindow];
           break;
         case IDC_RESTORE_TAB:
           // We have to ask the Browser manually if we can restore. The
           // command updater doesn't know.
           enable &= browser_->CanRestoreTab();
           break;
+        case IDC_FULLSCREEN:
+          enable &= [self supportsFullscreen];
+          break;
       }
 
       // If the item is toggleable, find its toggle state and
       // try to update it.  This is a little awkward, but the alternative is
       // to check after a commandDispatch, which seems worse.
       [self updateToggleStateWithTag:tag forItem:item];
     }
   }
   return enable;
 }
@@ skipping 35 matching lines @@
 - (float)verticalOffsetForStatusBubble {
   float offset = 0.0;
 
   // Don't create a download shelf if there isn't one.
   if (downloadShelfController_.get() && [[self downloadShelf] isVisible])
     offset += [[self downloadShelf] height];
 
   return offset;
 }
 
+- (GTMWindowSheetController*)sheetController {
+  return [tabStripController_ sheetController];
+}
+
 - (LocationBar*)locationBar {
   return [toolbarController_ locationBar];
 }
 
 - (StatusBubble*)statusBubble {
   return statusBubble_.get();
 }
 
 - (void)updateToolbarWithContents:(TabContents*)tab
                shouldRestoreState:(BOOL)shouldRestore {
@@ skipping 257 matching lines @@
   // Force a relayout.
   [self layoutSubviews];
 }
 
 - (NSWindow*)fullscreenWindow {
   return [[[FullscreenWindow alloc] initForScreen:[[self window] screen]]
            autorelease];
 }
 
 - (void)setFullscreen:(BOOL)fullscreen {
+  if (![self supportsFullscreen])
+      return;
+
   fullscreen_ = fullscreen;
   if (fullscreen) {
     // Move content to a new fullscreen window
     NSView* content = [[self window] contentView];
     fullscreen_window_.reset([[self fullscreenWindow] retain]);
     [content removeFromSuperview];
     [fullscreen_window_ setContentView:content];
     [self setWindow:fullscreen_window_.get()];
     // Minimize our UI.  This call triggers a relayout, so it needs to come
     // after we move the contentview to the new window.
@@ skipping 57 matching lines @@
 - (void)selectTabWithContents:(TabContents*)newContents
              previousContents:(TabContents*)oldContents
                       atIndex:(NSInteger)index
                   userGesture:(bool)wasUserGesture {
   DCHECK(oldContents != newContents);
 
   // Update various elements that are interested in knowing the current
   // TabContents.
 #if 0
 // TODO(pinkerton):Update as more things become window-specific
-  contents_container_->SetTabContents(new_contents);
+  contents_container_->SetTabContents(newContents);
 #endif
 
   // Update all the UI bits.
   windowShim_->UpdateTitleBar();
 #if 0
 // TODO(pinkerton):Update as more things become window-specific
-  toolbar_->SetProfile(new_contents->profile());
-  UpdateToolbar(new_contents, true);
-  UpdateUIForContents(new_contents);
+  toolbar_->SetProfile(newContents->profile());
+  UpdateToolbar(newContents, true);
+  UpdateUIForContents(newContents);
 #endif
 }
 
 - (void)tabChangedWithContents:(TabContents*)contents
                        atIndex:(NSInteger)index
                    loadingOnly:(BOOL)loading {
-  // Update titles if this is the currently selected tab.
-  if (index == browser_->tabstrip_model()->selected_index())
+  if (index == browser_->tabstrip_model()->selected_index()) {
+    // Update titles if this is the currently selected tab.
     windowShim_->UpdateTitleBar();
+  }
 }
 
 - (void)userChangedTheme {
   [self setTheme];
   [self applyTheme];
 
   [tabStripController_ userChangedTheme];
 }
 
 - (GTMTheme *)gtm_themeForWindow:(NSWindow*)window {
@@ skipping 298 matching lines @@
   NSColor* toolbarButtonBorderColor = toolbarButtonIconColor;
   [theme setValue:toolbarButtonBorderColor
      forAttribute:@"borderColor"
             style:GTMThemeStyleToolBar
             state:YES];
 
   return theme;
 }
 @end