Create windows for new app window bounds API

chrome/browser/ui/cocoa/apps/native_app_window_cocoa.mm

 // Copyright 2013 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 "chrome/browser/ui/cocoa/apps/native_app_window_cocoa.h"
 
 #include "apps/app_shim/extension_app_shim_handler_mac.h"
 #include "base/command_line.h"
 #include "base/mac/mac_util.h"
 #include "base/strings/sys_string_conversions.h"
@@ skipping 69 matching lines @@
   [window setCollectionBehavior:behavior];
 }
 
 // Returns the level for windows that are configured to be always on top.
 // This is not a constant because NSFloatingWindowLevel is a macro defined
 // as a function call.
 NSInteger AlwaysOnTopWindowLevel() {
   return NSFloatingWindowLevel;
 }
 
+NSRect GfxToCocoaBounds(const gfx::Rect& bounds,
+                            bool ensure_position_initialized) {

[benwells, 2014/03/05 02:33:30]

Nit: indenting.

[tapted, 2014/03/05 03:14:03]

nit: indenting. But also this is always called with
|ensure_position_initialized| = true - drop the argument?

+  typedef apps::AppWindow::BoundsSpecification BoundsSpecification;
+
+  // Flip coordinates based on the primary screen.
+  NSRect main_screen_rect = [[[NSScreen screens] objectAtIndex:0] frame];
+  NSRect cocoa_bounds = NSMakeRect(
+      bounds.x(),
+      NSHeight(main_screen_rect) - bounds.y() - bounds.height(),

[tapted, 2014/03/05 03:14:03]

nit (a bit nicer):
`NSHeight(main_screen_rect) - bounds.y() - bounds.height()` ->
`NSHeight(main_screen_rect) - bounds.bottom()`

or, even better,

NSRect cocoa_bounds = NSRectFromCGRect(bounds.ToCGRect());
cocoa_bounds.origin.y = NSHeight(main_screen_rect) - NSMaxY(cocoa_bounds);

+      bounds.width(),
+      bounds.height());
+
+  // If coordinates are < 0, center window on primary screen.

[tapted, 2014/03/05 03:14:03]

This comment doesn't really match (-ve coordinates come up whenever the primary
screen is not the bottom left one).

But it feels better to do this first. That is, take `bounds` by value instead of
reference, and flip once. I.e. do

if (bounds.x() == BoundsSpecification::kUnspecifiedPosition)
  bounds.set_x(floor((NSWidth(main_screen_rect) - bounds.width()) / 2));
/* same for y */
NSRect cocoa_bounds = NSRectFromCGRect(bounds.ToCGRect());
/* etc */

+  if (ensure_position_initialized &&
+      bounds.x() == BoundsSpecification::kUnspecifiedPosition) {
+    cocoa_bounds.origin.x =
+        floor((NSWidth(main_screen_rect) - NSWidth(cocoa_bounds)) / 2);
+  }
+  if (ensure_position_initialized &&
+      bounds.y() == BoundsSpecification::kUnspecifiedPosition) {
+    cocoa_bounds.origin.y =
+        floor((NSHeight(main_screen_rect) - NSHeight(cocoa_bounds)) / 2);
+  }
+
+  return cocoa_bounds;
+}
+
 }  // namespace
 
 @implementation NativeAppWindowController
 
 @synthesize appWindow = appWindow_;
 
 - (void)windowWillClose:(NSNotification*)notification {
   if (appWindow_)
     appWindow_->WindowWillClose();
 }
@@ skipping 177 matching lines @@
 
 NativeAppWindowCocoa::NativeAppWindowCocoa(
     AppWindow* app_window,
     const AppWindow::CreateParams& params)
     : app_window_(app_window),
       has_frame_(params.frame == AppWindow::FRAME_CHROME),
       is_hidden_(false),
       is_hidden_with_app_(false),
       is_maximized_(false),
       is_fullscreen_(false),
+      is_resizable_(params.resizable),
+      shows_resize_controls_(true),
+      shows_fullscreen_controls_(true),
       attention_request_id_(0),
       use_system_drag_(true) {
   Observe(web_contents());
 
-  // Flip coordinates based on the primary screen.
-  NSRect main_screen_rect = [[[NSScreen screens] objectAtIndex:0] frame];
-  NSRect cocoa_bounds = NSMakeRect(params.bounds.x(),
-      NSHeight(main_screen_rect) - params.bounds.y() - params.bounds.height(),
-      params.bounds.width(), params.bounds.height());
-
-  // If coordinates are < 0, center window on primary screen.
-  if (params.bounds.x() == INT_MIN) {
-    cocoa_bounds.origin.x =
-        floor((NSWidth(main_screen_rect) - NSWidth(cocoa_bounds)) / 2);
-  }
-  if (params.bounds.y() == INT_MIN) {
-    cocoa_bounds.origin.y =
-        floor((NSHeight(main_screen_rect) - NSHeight(cocoa_bounds)) / 2);
-  }
-
-  // Initialize |restored_bounds_| after |cocoa_bounds| have been sanitized.
-  restored_bounds_ = cocoa_bounds;
-
   base::scoped_nsobject<NSWindow> window;
   Class window_class;
   if (has_frame_) {
     bool should_use_native_frame =
         CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kAppsUseNativeFrame);
     window_class = should_use_native_frame ?
         [ShellNSWindow class] : [ShellCustomFrameNSWindow class];
   } else {
     window_class = [ShellFramelessNSWindow class];
   }
 
-  size_constraints_.set_minimum_size(params.minimum_size);
-  size_constraints_.set_maximum_size(params.maximum_size);
-  shows_resize_controls_ =
-      params.resizable && !size_constraints_.HasFixedSize();
-  shows_fullscreen_controls_ =
-      params.resizable && !size_constraints_.HasMaximumSize();
+  // Estimate the initial bounds of the window. Once the frame insets are known,
+  // the window bounds and constraints can be set precisely.
+  NSRect cocoa_bounds = GfxToCocoaBounds(
+      params.GetInitialWindowBounds(gfx::Insets()), true);
   window.reset([[window_class alloc]
       initWithContentRect:cocoa_bounds
                 styleMask:GetWindowStyleMask()
                   backing:NSBackingStoreBuffered
                     defer:NO]);
   [window setTitle:base::SysUTF8ToNSString(extension()->name())];
 
   if (base::mac::IsOSSnowLeopard() &&
       [window respondsToSelector:@selector(setBottomCornerRounded:)])
     [window setBottomCornerRounded:NO];
 
   if (params.always_on_top)
     [window setLevel:AlwaysOnTopWindowLevel()];
   InitCollectionBehavior(window);
 
-  // Set the window to participate in Lion Fullscreen mode. Setting this flag
-  // has no effect on Snow Leopard or earlier. UI controls for fullscreen are
-  // only shown for apps that have unbounded size.
-  if (shows_fullscreen_controls_)
-    SetFullScreenCollectionBehavior(window, true);
-
   window_controller_.reset(
       [[NativeAppWindowController alloc] initWithWindow:window.release()]);
 
   NSView* view = web_contents()->GetView()->GetNativeView();
   [view setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
 
   // By default, the whole frameless window is not draggable.
   if (!has_frame_) {
     gfx::Rect window_bounds(
         0, 0, NSWidth(cocoa_bounds), NSHeight(cocoa_bounds));
     system_drag_exclude_areas_.push_back(window_bounds);
   }
 
   InstallView();
 
   [[window_controller_ window] setDelegate:window_controller_];
   [window_controller_ setAppWindow:this];
 
-  // Update the size constraints of the NSWindow.
-  SetMinimumSize(params.minimum_size);
-  SetMaximumSize(params.maximum_size);
+  // We can now compute the precise window bounds and constraints.
+  gfx::Insets insets = GetFrameInsets();
+  SetBounds(params.GetInitialWindowBounds(insets));
+  SetContentSizeConstraints(params.GetContentMinimumSize(insets),
+                            params.GetContentMaximumSize(insets));
+
+  // Initialize |restored_bounds_|.
+  restored_bounds_ = [this->window() frame];
 
   extension_keybinding_registry_.reset(new ExtensionKeybindingRegistryCocoa(
       Profile::FromBrowserContext(app_window_->browser_context()),
       window,
       extensions::ExtensionKeybindingRegistry::PLATFORM_APPS_ONLY,
       app_window));
 }
 
 NSUInteger NativeAppWindowCocoa::GetWindowStyleMask() const {
   NSUInteger style_mask = NSTitledWindowMask | NSClosableWindowMask |
@@ skipping 226 matching lines @@
   if (bounds.width() < min_size.width)
     checked_bounds.set_width(min_size.width);
   if (bounds.height() < min_size.height)
     checked_bounds.set_height(min_size.height);
   NSSize max_size = [window() maxSize];
   if (checked_bounds.width() > max_size.width)
     checked_bounds.set_width(max_size.width);
   if (checked_bounds.height() > max_size.height)
     checked_bounds.set_height(max_size.height);
 
-  NSRect cocoa_bounds = NSMakeRect(checked_bounds.x(), 0,
-                                   checked_bounds.width(),
-                                   checked_bounds.height());
-  // Flip coordinates based on the primary screen.
-  NSScreen* screen = [[NSScreen screens] objectAtIndex:0];
-  cocoa_bounds.origin.y = NSHeight([screen frame]) - checked_bounds.bottom();
-
+  NSRect cocoa_bounds = GfxToCocoaBounds(checked_bounds, true);
   [window() setFrame:cocoa_bounds display:YES];
   // setFrame: without animate: does not trigger a windowDidEndLiveResize: so
   // call it here.
   WindowDidFinishResize();
 }
 
 void NativeAppWindowCocoa::UpdateWindowIcon() {
   // TODO(junmin): implement.
 }
 
@@ skipping 397 matching lines @@
   NSWindow* window = [window_controller_ window];
   CHECK(!window || [window isKindOfClass:[ShellNSWindow class]]);
   return static_cast<ShellNSWindow*>(window);
 }
 
 void NativeAppWindowCocoa::UpdateRestoredBounds() {
   if (IsRestored(*this))
     restored_bounds_ = [window() frame];
 }
 
-void NativeAppWindowCocoa::UpdateShelfMenu() {
-  // TODO(tmdiep): To be implemented for Mac.
-  NOTIMPLEMENTED();
-}
-
-gfx::Size NativeAppWindowCocoa::GetMinimumSize() const {
-  return size_constraints_.GetMinimumSize();
-}
-
-void NativeAppWindowCocoa::SetMinimumSize(const gfx::Size& size) {
-  size_constraints_.set_minimum_size(size);
+void NativeAppWindowCocoa::SetContentSizeConstraints(
+    const gfx::Size& minimum_size, const gfx::Size& maximum_size) {
+  // Update the size constraints.
+  size_constraints_.set_minimum_size(minimum_size);
+  size_constraints_.set_maximum_size(maximum_size);
 
   gfx::Size min_size = size_constraints_.GetMinimumSize();
   [window() setContentMinSize:NSMakeSize(min_size.width(), min_size.height())];
-}
-
-gfx::Size NativeAppWindowCocoa::GetMaximumSize() const {
-  return size_constraints_.GetMaximumSize();
-}
-
-void NativeAppWindowCocoa::SetMaximumSize(const gfx::Size& size) {
-  size_constraints_.set_maximum_size(size);
 
   gfx::Size max_size = size_constraints_.GetMaximumSize();
   const int kUnboundedSize = apps::SizeConstraints::kUnboundedSize;
   CGFloat max_width = max_size.width() == kUnboundedSize ?
       CGFLOAT_MAX : max_size.width();
   CGFloat max_height = max_size.height() == kUnboundedSize ?
       CGFLOAT_MAX : max_size.height();
   [window() setContentMaxSize:NSMakeSize(max_width, max_height)];
+
+  // Update the window controls.
+  shows_resize_controls_ =
+      is_resizable_ && !size_constraints_.HasFixedSize();
+  shows_fullscreen_controls_ =
+      is_resizable_ && !size_constraints_.HasMaximumSize();
+
+  if (!is_fullscreen_) {
+    [window() setStyleMask:GetWindowStyleMask()];
+
+    // Set the window to participate in Lion Fullscreen mode. Setting this flag
+    // has no effect on Snow Leopard or earlier. UI controls for fullscreen are
+    // only shown for apps that have unbounded size.
+    SetFullScreenCollectionBehavior(window(), shows_fullscreen_controls_);
+  }
 }
+
+void NativeAppWindowCocoa::UpdateShelfMenu() {
+  // TODO(tmdiep): To be implemented for Mac.
+  NOTIMPLEMENTED();
+}
+
+gfx::Size NativeAppWindowCocoa::GetContentMinimumSize() const {
+  return size_constraints_.GetMinimumSize();
+}
+
+void NativeAppWindowCocoa::SetContentMinimumSize(const gfx::Size& size) {
+  SetContentSizeConstraints(size, size_constraints_.GetMaximumSize());

[tmdiep, 2014/03/04 03:13:14]

Fixed bug - when the constraints were changed after window creation, the resize
and fullscreen controls were not updated accordingly. So
SetContentSizeConstraints() now makes everything consistent.

+}
+
+gfx::Size NativeAppWindowCocoa::GetContentMaximumSize() const {
+  return size_constraints_.GetMaximumSize();
+}
+
+void NativeAppWindowCocoa::SetContentMaximumSize(const gfx::Size& size) {
+  SetContentSizeConstraints(size_constraints_.GetMinimumSize(), size);
+}