mac: Use NSWidth() and friends in a few more places.

chrome/browser/ui/cocoa/browser_window_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/browser_window_controller.h"
 
 #include <cmath>
 #include <numeric>
 
 #include "base/command_line.h"
@@ skipping 677 matching lines @@
   // "switchers" happy.
   if ([[NSApp currentEvent] modifierFlags] & NSShiftKeyMask) {
     return frame;
   }
 
   // To prevent strange results on portrait displays, the basic minimum zoomed
   // width is the larger of: 60% of available width, 60% of available height
   // (bounded by available width).
   const CGFloat kProportion = 0.6;
   CGFloat zoomedWidth =
-      std::max(kProportion * frame.size.width,
-               std::min(kProportion * frame.size.height, frame.size.width));
+      std::max(kProportion * NSWidth(frame),
+               std::min(kProportion * NSHeight(frame), NSWidth(frame)));
 
   WebContents* contents = browser_->GetSelectedWebContents();
   if (contents) {
     // If the intrinsic width is bigger, then make it the zoomed width.
     const int kScrollbarWidth = 16;  // TODO(viettrungluu): ugh.
     CGFloat intrinsicWidth = static_cast<CGFloat>(
         contents->GetPreferredSize().width() + kScrollbarWidth);
     zoomedWidth = std::max(zoomedWidth,
-                           std::min(intrinsicWidth, frame.size.width));
+                           std::min(intrinsicWidth, NSWidth(frame)));
   }
 
   // Never shrink from the current size on zoom (see above).
   NSRect currentFrame = [[self window] frame];
-  zoomedWidth = std::max(zoomedWidth, currentFrame.size.width);
+  zoomedWidth = std::max(zoomedWidth, NSWidth(currentFrame));
 
   // |frame| determines our maximum extents. We need to set the origin of the
   // frame -- and only move it left if necessary.
-  if (currentFrame.origin.x + zoomedWidth > frame.origin.x + frame.size.width)
-    frame.origin.x = frame.origin.x + frame.size.width - zoomedWidth;
+  if (currentFrame.origin.x + zoomedWidth > NSMaxX(frame))
+    frame.origin.x = NSMaxX(frame) - zoomedWidth;
   else
     frame.origin.x = currentFrame.origin.x;
 
   // Set the width. Don't touch y or height.
   frame.size.width = zoomedWidth;
 
   return frame;
 }
 
 - (void)activate {
   [BrowserWindowUtils activateWindowForController:self];
 }
 
 // Determine whether we should let a window zoom/unzoom to the given |newFrame|.
 // We avoid letting unzoom move windows between screens, because it's really
 // strange and unintuitive.
 - (BOOL)windowShouldZoom:(NSWindow*)window toFrame:(NSRect)newFrame {
   // Figure out which screen |newFrame| is on.
   NSScreen* newScreen = nil;
   CGFloat newScreenOverlapArea = 0.0;
   for (NSScreen* screen in [NSScreen screens]) {
     NSRect overlap = NSIntersectionRect(newFrame, [screen frame]);
-    CGFloat overlapArea = overlap.size.width * overlap.size.height;
+    CGFloat overlapArea = NSWidth(overlap) * NSHeight(overlap);
     if (overlapArea > newScreenOverlapArea) {
       newScreen = screen;
       newScreenOverlapArea = overlapArea;
     }
   }
   // If we're somehow not on any screen, allow the zoom.
   if (!newScreen)
     return YES;
 
   // If the new screen is the current screen, we can return a definitive YES.
   // Note: This check is not strictly necessary, but just short-circuits in the
   // "no-brainer" case. To test the complicated logic below, comment this out!
   NSScreen* curScreen = [window screen];
   if (newScreen == curScreen)
     return YES;
 
   // Worry a little: What happens when a window is on two (or more) screens?
   // E.g., what happens in a 50-50 scenario? Cocoa may reasonably elect to zoom
   // to the other screen rather than staying on the officially current one. So
   // we compare overlaps with the current window frame, and see if Cocoa's
   // choice was reasonable (allowing a small rounding error). This should
   // hopefully avoid us ever erroneously denying a zoom when a window is on
   // multiple screens.
   NSRect curFrame = [window frame];
   NSRect newScrIntersectCurFr = NSIntersectionRect([newScreen frame], curFrame);
   NSRect curScrIntersectCurFr = NSIntersectionRect([curScreen frame], curFrame);
-  if (newScrIntersectCurFr.size.width*newScrIntersectCurFr.size.height >=
-      (curScrIntersectCurFr.size.width*curScrIntersectCurFr.size.height - 1.0))
+  if (NSWidth(newScrIntersectCurFr) * NSHeight(newScrIntersectCurFr) >=
+      (NSWidth(curScrIntersectCurFr) * NSHeight(curScrIntersectCurFr) - 1.0)) {
     return YES;
+  }
 
   // If it wasn't reasonable, return NO.
   return NO;
 }
 
 // Adjusts the window height by the given amount.
 - (BOOL)adjustWindowHeightBy:(CGFloat)deltaH {
   // By not adjusting the window height when initializing, we can ensure that
   // the window opens with the same size that was saved on close.
   if (initializing_ || [self isFullscreen] || deltaH == 0)
     return NO;
 
   NSWindow* window = [self window];
   NSRect windowFrame = [window frame];
   NSRect workarea = [[window screen] visibleFrame];
 
   // If the window is not already fully in the workarea, do not adjust its frame
   // at all.
   if (!NSContainsRect(workarea, windowFrame))
     return NO;
 
   // Record the position of the top/bottom of the window, so we can easily check
   // whether we grew the window upwards/downwards.
   CGFloat oldWindowMaxY = NSMaxY(windowFrame);
   CGFloat oldWindowMinY = NSMinY(windowFrame);
 
   // We are "zoomed" if we occupy the full vertical space.
   bool isZoomed = (windowFrame.origin.y == workarea.origin.y &&
-                   windowFrame.size.height == workarea.size.height);
+                   NSHeight(windowFrame) == NSHeight(workarea));
 
   // If we're shrinking the window....
   if (deltaH < 0) {
     bool didChange = false;
 
     // Don't reset if not currently zoomed since shrinking can take several
     // steps!
     if (isZoomed)
       isShrinkingFromZoomed_ = YES;
 
@@ skipping 42 matching lines @@
     // Resize the window as requested, keeping the top left corner fixed.
     windowFrame.origin.y -= deltaH;
     windowFrame.size.height += deltaH;
 
     // If the bottom left corner is now outside the visible frame, move the
     // window up to make it fit, but make sure not to move the top left corner
     // out of the visible frame.
     if (windowFrame.origin.y < workarea.origin.y) {
       windowFrame.origin.y = workarea.origin.y;
       windowFrame.size.height =
-          std::min(windowFrame.size.height, workarea.size.height);
+          std::min(NSHeight(windowFrame), NSHeight(workarea));
     }
 
     // Record (if applicable) how much we grew the window in either direction.
     // (N.B.: These only record growth, not shrinkage.)
     if (NSMaxY(windowFrame) > oldWindowMaxY)
       windowTopGrowth_ += NSMaxY(windowFrame) - oldWindowMaxY;
     if (NSMinY(windowFrame) < oldWindowMinY)
       windowBottomGrowth_ += oldWindowMinY - NSMinY(windowFrame);
   }
 
@@ skipping 37 matching lines @@
   //
   // We do not adjust the window height for bookmark bar changes on the NTP.
   BOOL shouldAdjustBookmarkHeight =
       [bookmarkBarController_ isAnimatingBetweenState:bookmarks::kHiddenState
                                              andState:bookmarks::kShowingState];
 
   BOOL resizeRectDirty = NO;
   if ((shouldAdjustBookmarkHeight && view == [bookmarkBarController_ view]) ||
       view == [downloadShelfController_ view]) {
     [[self window] disableScreenUpdatesUntilFlush];
-    CGFloat deltaH = height - frame.size.height;
+    CGFloat deltaH = height - NSHeight(frame);
     if ([self adjustWindowHeightBy:deltaH] &&
         view == [downloadShelfController_ view]) {
       // If the window height didn't change, the download shelf will change the
       // size of the contents. If the contents size doesn't change, send it
       // an explicit grow box invalidation (else, the resize message does that.)
       resizeRectDirty = YES;
     }
   }
 
   frame.size.height = height;
@@ skipping 247 matching lines @@
 - (NSRect)selectedTabGrowBoxRect {
   NSWindow* window = [self window];
   if (![window respondsToSelector:@selector(_growBoxRect)])
     return NSZeroRect;
 
   // Before we return a rect, we need to convert it from window coordinates
   // to tab content area coordinates and flip the coordinate system.
   NSRect growBoxRect =
       [[self tabContentArea] convertRect:[window _growBoxRect] fromView:nil];
   growBoxRect.origin.y =
-      [[self tabContentArea] frame].size.height - growBoxRect.size.height -
-      growBoxRect.origin.y;
+      NSHeight([[self tabContentArea] frame]) - NSMaxY(growBoxRect);
   return growBoxRect;
 }
 
 // Accept tabs from a BrowserWindowController with the same Profile.
 - (BOOL)canReceiveFrom:(TabWindowController*)source {
   if (![source isKindOfClass:[BrowserWindowController class]]) {
     return NO;
   }
 
   BrowserWindowController* realSource =
@@ skipping 108 matching lines @@
   // Fetch the tab contents for the tab being dragged.
   int index = [tabStripController_ modelIndexForTabView:tabView];
   TabContentsWrapper* contents = browser_->GetTabContentsWrapperAt(index);
 
   // 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 = [tabView window];
   NSRect windowRect = [sourceWindow frame];
   NSScreen* screen = [sourceWindow screen];
-  windowRect.origin.y =
-      [screen frame].size.height - windowRect.size.height -
-          windowRect.origin.y;
+  windowRect.origin.y = NSHeight([screen frame]) - NSMaxY(windowRect);
   gfx::Rect browserRect(windowRect.origin.x, windowRect.origin.y,
-                        windowRect.size.width, windowRect.size.height);
+                        NSWidth(windowRect), NSHeight(windowRect));
 
   NSRect sourceTabRect = [tabView frame];
   NSView* tabStrip = [self tabStripView];
 
   // Pushes tabView's frame back inside the tabstrip.
   NSSize tabOverflow =
       [self overflowFrom:[tabStrip convertRectToBase:sourceTabRect]
                       to:[tabStrip frame]];
   NSRect tabRect = NSOffsetRect(sourceTabRect,
                                 -tabOverflow.width, -tabOverflow.height);
@@ skipping 587 matching lines @@
     return NSZeroRect;
 
   NSRect frame = [view convertRect:[view bounds] toView:nil];
   NSPoint originInScreenCoords =
       [[view window] convertBaseToScreen:frame.origin];
   frame.origin = originInScreenCoords;
 
   // Account for the bookmark bar height if it is currently in the detached
   // state on the new tab page.
   if ([bookmarkBarController_ isInState:(bookmarks::kDetachedState)])
-    frame.size.height += [[bookmarkBarController_ view] bounds].size.height;
+    frame.size.height += NSHeight([[bookmarkBarController_ view] bounds]);
 
   return frame;
 }
 
 - (void)sheetDidEnd:(NSWindow*)sheet
          returnCode:(NSInteger)code
             context:(void*)context {
   [sheet orderOut:self];
 }
 
@@ skipping 281 matching lines @@
 
 - (BOOL)supportsBookmarkBar {
   return [self supportsWindowFeature:Browser::FEATURE_BOOKMARKBAR];
 }
 
 - (BOOL)isTabbedWindow {
   return browser_->is_type_tabbed();
 }
 
 @end  // @implementation BrowserWindowController(WindowType)