Do not cache NSScreens.

chrome/browser/ui/cocoa/bookmarks/bookmark_bar_folder_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/bookmarks/bookmark_bar_folder_controller.h"
 
 #include "base/mac/bundle_locations.h"
 #include "base/strings/sys_string_conversions.h"
 #import "chrome/browser/bookmarks/bookmark_model_factory.h"
 #import "chrome/browser/bookmarks/chrome_bookmark_client.h"
@@ skipping 111 matching lines @@
 }
 
 }  // namespace
 
 
 // Required to set the right tracking bounds for our fake menus.
 @interface NSView(Private)
 - (void)_updateTrackingAreas;
 @end
 
-@interface BookmarkBarFolderController(Private)
+@interface BookmarkBarFolderController ()
 - (void)configureWindow;
 - (void)addOrUpdateScrollTracking;
 - (void)removeScrollTracking;
 - (void)endScroll;
 - (void)addScrollTimerWithDelta:(CGFloat)delta;
 
+// Return the screen to which the menu should be restricted. The screen list is
+// very volatile and can change with very short notice so it isn't worth
+// caching. http://crbug.com/463458
+- (NSScreen*)menuScreen;
+
 // Helper function to configureWindow which performs a basic layout of
 // the window subviews, in particular the menu buttons and the window width.
 - (void)layOutWindowWithHeight:(CGFloat)height;
 
 // Determine the best button width (which will be the widest button or the
 // maximum allowable button width, whichever is less) and resize all buttons.
 // Return the new width so that the window can be adjusted.
 - (CGFloat)adjustButtonWidths;
 
 // Returns the total menu height needed to display |buttonCount| buttons.
@@ skipping 105 matching lines @@
                                              ofType:@"nib"];
   if ((self = [super initWithWindowNibPath:nibPath owner:self])) {
     parentButton_.reset([button retain]);
     selectedIndex_ = -1;
 
     profile_ = profile;
 
     // We want the button to remain bordered as part of the menu path.
     [button forceButtonBorderToStayOnAlways:YES];
 
-    // Pick the parent button's screen to be the screen upon which all display
-    // happens. This loop over all screens is not equivalent to
-    // |[[button window] screen]|. BookmarkButtons are commonly positioned near
-    // the edge of their windows (both in the bookmark bar and in other bookmark
-    // menus), and |[[button window] screen]| would return the screen that the
-    // majority of their window was on even if the parent button were clearly
-    // contained within a different screen.
-    NSRect parentButtonGlobalFrame =
-        [button convertRect:[button bounds] toView:nil];
-    parentButtonGlobalFrame.origin =
-        [[button window] convertBaseToScreen:parentButtonGlobalFrame.origin];
-    for (NSScreen* screen in [NSScreen screens]) {
-      if (NSIntersectsRect([screen frame], parentButtonGlobalFrame)) {
-        screen_ = screen;
-        break;
-      }
-    }
-    if (!screen_) {
-      // The parent button is offscreen. The ideal thing to do would be to
-      // calculate the "closest" screen, the screen which has an edge parallel
-      // to, and the least distance from, one of the edges of the button.
-      // However, popping a subfolder from an offscreen button is an unrealistic
-      // edge case and so this ideal remains unrealized. Cheat instead; this
-      // code is wrong but a lot simpler.
-      screen_ = [[button window] screen];
-    }
-
     parentController_.reset([parentController retain]);
     if (!parentController_)
       [self setSubFolderGrowthToRight:YES];
     else
       [self setSubFolderGrowthToRight:[parentController
                                         subFolderGrowthToRight]];
     barController_ = barController;  // WEAK
     buttons_.reset([[NSMutableArray alloc] init]);
     folderTarget_.reset(
         [[BookmarkFolderTarget alloc] initWithController:self profile:profile]);
@@ skipping 160 matching lines @@
 // since it looks much more menu-like than with none.  If we would
 // grow off the screen, switch growth to the other direction.  Growth
 // direction sticks for folder windows which are descendents of us.
 // If we have tried both directions and neither fits, degrade to a
 // default.
 - (CGFloat)childFolderWindowLeftForWidth:(int)windowWidth {
   // We may legitimately need to try two times (growth to right and
   // left but not in that order).  Limit us to three tries in case
   // the folder window can't fit on either side of the screen; we
   // don't want to loop forever.
+  NSRect screenVisibleFrame = [[self menuScreen] visibleFrame];
   CGFloat x;
   int tries = 0;
   while (tries < 2) {
     // Try to grow right.
     if ([self subFolderGrowthToRight]) {
       tries++;
       x = NSMaxX([[parentButton_ window] frame]) -
           bookmarks::kBookmarkMenuOverlap;
       // If off the screen, switch direction.
-      if ((x + windowWidth +
-           bookmarks::kBookmarkHorizontalScreenPadding) >
-          NSMaxX([screen_ visibleFrame])) {
+      if ((x + windowWidth + bookmarks::kBookmarkHorizontalScreenPadding) >
+          NSMaxX(screenVisibleFrame)) {
         [self setSubFolderGrowthToRight:NO];
       } else {
         return x;
       }
     }
     // Try to grow left.
     if (![self subFolderGrowthToRight]) {
       tries++;
       x = NSMinX([[parentButton_ window] frame]) +
           bookmarks::kBookmarkMenuOverlap -
           windowWidth;
       // If off the screen, switch direction.
-      if (x < NSMinX([screen_ visibleFrame])) {
+      if (x < NSMinX(screenVisibleFrame)) {
         [self setSubFolderGrowthToRight:YES];
       } else {
         return x;
       }
     }
   }
   // Unhappy; do the best we can.
-  return NSMaxX([screen_ visibleFrame]) - windowWidth;
+  return NSMaxX(screenVisibleFrame) - windowWidth;
 }
 
 
 // Compute and return the top left point of our window (screen
 // coordinates).  The top left is positioned in a manner similar to
 // cascading menus.  Windows may grow to either the right or left of
 // their parent (if a sub-folder) so we need to know |windowWidth|.
 - (NSPoint)windowTopLeftForWidth:(int)windowWidth height:(int)windowHeight {
   CGFloat kMinSqueezedMenuHeight = bookmarks::kBookmarkFolderButtonHeight * 2.0;
   NSPoint newWindowTopLeft;
   if (![parentController_ isKindOfClass:[self class]]) {
     // If we're not popping up from one of ourselves, we must be
     // popping up from the bookmark bar itself.  In this case, start
     // BELOW the parent button.  Our left is the button left; our top
     // is bottom of button's parent view.
     NSPoint buttonBottomLeftInScreen =
         [[parentButton_ window]
             convertBaseToScreen:[parentButton_
                                     convertPoint:NSZeroPoint toView:nil]];
     NSPoint bookmarkBarBottomLeftInScreen =
         [[parentButton_ window]
             convertBaseToScreen:[[parentButton_ superview]
                                     convertPoint:NSZeroPoint toView:nil]];
     newWindowTopLeft = NSMakePoint(
         buttonBottomLeftInScreen.x + bookmarks::kBookmarkBarButtonOffset,
         bookmarkBarBottomLeftInScreen.y + bookmarks::kBookmarkBarMenuOffset);
     // Make sure the window is on-screen; if not, push left or right. It is
     // intentional that top level folders "push left" or "push right" slightly
     // different than subfolders.
-    NSRect screenFrame = [screen_ visibleFrame];
+    NSRect screenVisibleFrame = [[self menuScreen] visibleFrame];
     // Test if window goes off-screen on the right side.
-    CGFloat spillOff = (newWindowTopLeft.x + windowWidth) - NSMaxX(screenFrame);
+    CGFloat spillOff =
+        newWindowTopLeft.x + windowWidth - NSMaxX(screenVisibleFrame);
     if (spillOff > 0.0) {
       newWindowTopLeft.x = std::max(newWindowTopLeft.x - spillOff,
-                                    NSMinX(screenFrame));
-    } else if (newWindowTopLeft.x < NSMinX(screenFrame)) {
+                                    NSMinX(screenVisibleFrame));
+    } else if (newWindowTopLeft.x < NSMinX(screenVisibleFrame)) {
       // For left side.
-      newWindowTopLeft.x = NSMinX(screenFrame);
+      newWindowTopLeft.x = NSMinX(screenVisibleFrame);
     }
     // The menu looks bad when it is squeezed up against the bottom of the
     // screen and ends up being only a few pixels tall. If it meets the
     // threshold for this case, instead show the menu above the button.
     CGFloat availableVerticalSpace = newWindowTopLeft.y -
-        (NSMinY(screenFrame) + bookmarks::kScrollWindowVerticalMargin);
+        (NSMinY(screenVisibleFrame) + bookmarks::kScrollWindowVerticalMargin);
     if ((availableVerticalSpace < kMinSqueezedMenuHeight) &&
         (windowHeight > availableVerticalSpace)) {
       newWindowTopLeft.y = std::min(
           newWindowTopLeft.y + windowHeight + NSHeight([parentButton_ frame]),
-          NSMaxY(screenFrame));
+          NSMaxY(screenVisibleFrame));
     }
   } else {
     // Parent is a folder: expose as much as we can vertically; grow right/left.
     newWindowTopLeft.x = [self childFolderWindowLeftForWidth:windowWidth];
     NSPoint topOfWindow = NSMakePoint(0,
                                       NSMaxY([parentButton_ frame]) -
                                           bookmarks::kBookmarkVerticalPadding);
     topOfWindow = [[parentButton_ window]
                    convertBaseToScreen:[[parentButton_ superview]
                                         convertPoint:topOfWindow toView:nil]];
@@ skipping 45 matching lines @@
   metrics.couldScrollUp = ![scrollUpArrowView_ isHidden];
   metrics.couldScrollDown = ![scrollDownArrowView_ isHidden];
 
   metrics.deltaWindowHeight = 0.0;
   metrics.deltaWindowY = 0.0;
   metrics.deltaVisibleHeight = 0.0;
   metrics.deltaVisibleY = 0.0;
   metrics.deltaScrollerHeight = 0.0;
   metrics.deltaScrollerY = 0.0;
 
-  metrics.minimumY = NSMinY([screen_ visibleFrame]) +
+  metrics.minimumY = NSMinY([[self menuScreen] visibleFrame]) +
                      bookmarks::kScrollWindowVerticalMargin;
-  metrics.screenBottomY = NSMinY([screen_ frame]);
+  metrics.screenBottomY = NSMinY([[self menuScreen] frame]);
   metrics.oldWindowY = NSMinY(metrics.windowFrame);
   metrics.folderY =
       metrics.scrollerFrame.origin.y + metrics.visibleFrame.origin.y +
       metrics.oldWindowY - metrics.scrollPoint.y;
   metrics.folderTop = metrics.folderY + NSHeight([folderView_ frame]);
 }
 
 - (void)adjustMetrics:(LayoutMetrics*)layoutMetrics {
   LayoutMetrics& metrics(*layoutMetrics);
   CGFloat effectiveFolderY = metrics.folderY;
   if (!metrics.couldScrollUp && !metrics.couldScrollDown)
     effectiveFolderY -= metrics.windowSize.height;
   metrics.canScrollUp = effectiveFolderY < metrics.minimumY;
   CGFloat maximumY =
-      NSMaxY([screen_ visibleFrame]) - bookmarks::kScrollWindowVerticalMargin;
+      NSMaxY([[self menuScreen] visibleFrame]) -
+          bookmarks::kScrollWindowVerticalMargin;
   metrics.canScrollDown = metrics.folderTop > maximumY;
 
   // Accommodate changes in the bottom of the menu.
   [self adjustMetricsForMenuBottomChanges:layoutMetrics];
 
   // Accommodate changes in the top of the menu.
   [self adjustMetricsForMenuTopChanges:layoutMetrics];
 
   metrics.scrollerFrame.origin.y += metrics.deltaScrollerY;
   metrics.scrollerFrame.size.height += metrics.deltaScrollerHeight;
@@ skipping 54 matching lines @@
 - (void)adjustMetricsForMenuTopChanges:(LayoutMetrics*)layoutMetrics {
   LayoutMetrics& metrics(*layoutMetrics);
   if (metrics.canScrollDown == metrics.couldScrollDown) {
     if (!metrics.canScrollDown) {
       // Not scroll-down-able but the menu top has changed.
       metrics.deltaWindowHeight += metrics.scrollDelta;
     }
   } else {
     if (metrics.canScrollDown) {
       // Couldn't -> Can
-      const CGFloat maximumY = NSMaxY([screen_ visibleFrame]);
+      const CGFloat maximumY = NSMaxY([[self menuScreen] visibleFrame]);
       metrics.deltaWindowHeight += (maximumY - NSMaxY(metrics.windowFrame));
       metrics.deltaVisibleHeight -= bookmarks::kScrollWindowVerticalMargin;
       metrics.deltaScrollerHeight -= verticalScrollArrowHeight_;
     } else {
       // Could -> Can't
       metrics.deltaWindowHeight -= bookmarks::kScrollWindowVerticalMargin;
       metrics.deltaVisibleHeight += bookmarks::kScrollWindowVerticalMargin;
       metrics.deltaScrollerHeight += verticalScrollArrowHeight_;
     }
   }
@@ skipping 111 matching lines @@
   // Lay out the window by adjusting all button widths to be consistent, then
   // base the window width on this ideal button width.
   CGFloat buttonWidth = [self adjustButtonWidths];
   CGFloat windowWidth = buttonWidth + padding_;
   NSPoint newWindowTopLeft = [self windowTopLeftForWidth:windowWidth
                                                   height:height];
 
   // Make sure as much of a submenu is exposed (which otherwise would be a
   // problem if the parent button is close to the bottom of the screen).
   if ([parentController_ isKindOfClass:[self class]]) {
-    CGFloat minimumY = NSMinY([screen_ visibleFrame]) +
+    CGFloat minimumY = NSMinY([[self menuScreen] visibleFrame]) +
                        bookmarks::kScrollWindowVerticalMargin +
                        height;
     newWindowTopLeft.y = MAX(newWindowTopLeft.y, minimumY);
   }
 
   NSWindow* window = [self window];
   NSRect windowFrame = NSMakeRect(newWindowTopLeft.x,
                                   newWindowTopLeft.y - height,
                                   windowWidth, height);
   [window setFrame:windowFrame display:NO];
@@ skipping 124 matching lines @@
       index++;
     }
   }
 }
 
 - (CGFloat)determineFinalScrollDelta:(CGFloat)delta {
   if ((delta > 0.0 && ![scrollUpArrowView_ isHidden]) ||
       (delta < 0.0 && ![scrollDownArrowView_ isHidden])) {
     NSWindow* window = [self window];
     NSRect windowFrame = [window frame];
+    NSRect screenVisibleFrame = [[self menuScreen] visibleFrame];
     NSPoint scrollPosition = [scrollView_ documentVisibleRect].origin;
     CGFloat scrollY = scrollPosition.y;
     NSRect scrollerFrame = [scrollView_ frame];
     CGFloat scrollerY = NSMinY(scrollerFrame);
     NSRect visibleFrame = [visibleView_ frame];
     CGFloat visibleY = NSMinY(visibleFrame);
     CGFloat windowY = NSMinY(windowFrame);
     CGFloat offset = scrollerY + visibleY + windowY;
 
     if (delta > 0.0) {
       // Scrolling up.
-      CGFloat minimumY = NSMinY([screen_ visibleFrame]) +
+      CGFloat minimumY = NSMinY(screenVisibleFrame) +
                          bookmarks::kScrollWindowVerticalMargin;
       CGFloat maxUpDelta = scrollY - offset + minimumY;
       delta = MIN(delta, maxUpDelta);
     } else {
       // Scrolling down.
-      NSRect screenFrame =  [screen_ visibleFrame];
-      CGFloat topOfScreen = NSMaxY(screenFrame);
+      CGFloat topOfScreen = NSMaxY(screenVisibleFrame);
       NSRect folderFrame = [folderView_ frame];
       CGFloat folderHeight = NSHeight(folderFrame);
       CGFloat folderTop = folderHeight - scrollY + offset;
       CGFloat maxDownDelta =
           topOfScreen - folderTop - bookmarks::kScrollWindowVerticalMargin;
       delta = MAX(delta, maxDownDelta);
     }
   } else {
     delta = 0.0;
   }
@@ skipping 17 matching lines @@
   verticalScrollDelta_ = delta;
   scrollTimer_ = [NSTimer timerWithTimeInterval:kBookmarkBarFolderScrollInterval
                                          target:self
                                        selector:@selector(performScroll:)
                                        userInfo:nil
                                         repeats:YES];
 
   [[NSRunLoop mainRunLoop] addTimer:scrollTimer_ forMode:NSRunLoopCommonModes];
 }
 
+- (NSScreen*)menuScreen {
+  // Return the parent button's screen for use as the screen upon which all
+  // display happens. This loop over all screens is not equivalent to
+  // |[[button window] screen]|. BookmarkButtons are commonly positioned near
+  // the edge of their windows (both in the bookmark bar and in other bookmark
+  // menus), and |[[button window] screen]| would return the screen that the
+  // majority of their window was on even if the parent button were clearly
+  // contained within a different screen.
+  NSButton* button = parentButton_.get();
+  NSRect parentButtonGlobalFrame =
+      [button convertRect:[button bounds] toView:nil];
+  parentButtonGlobalFrame.origin =
+      [[button window] convertBaseToScreen:parentButtonGlobalFrame.origin];
+  for (NSScreen* screen in [NSScreen screens]) {
+    if (NSIntersectsRect([screen frame], parentButtonGlobalFrame))
+      return screen;
+  }
+
+  // The parent button is offscreen. The ideal thing to do would be to calculate
+  // the "closest" screen, the screen which has an edge parallel to, and the
+  // least distance from, one of the edges of the button. However, popping a
+  // subfolder from an offscreen button is an unrealistic edge case and so this
+  // ideal remains unrealized. Cheat instead; this code is wrong but a lot
+  // simpler.
+  return [[button window] screen];
+}
 
 // Called as a result of our tracking area.  Warning: on the main
 // screen (of a single-screened machine), the minimum mouse y value is
 // 1, not 0.  Also, we do not get events when the mouse is above the
 // menubar (to be fixed by setting the proper window level; see
 // initializer).
 // Note [theEvent window] may not be our window, as we also get these messages
 // forwarded from BookmarkButton's mouse tracking loop.
 - (void)mouseMovedOrDragged:(NSEvent*)theEvent {
   NSPoint eventScreenLocation =
@@ skipping 960 matching lines @@
 
 - (void)setIgnoreAnimations:(BOOL)ignore {
   ignoreAnimations_ = ignore;
 }
 
 - (BookmarkButton*)buttonThatMouseIsIn {
   return buttonThatMouseIsIn_;
 }
 
 @end  // BookmarkBarFolderController