[Mac] A more robust way to ensure panels avoid key status on window close

chrome/browser/ui/cocoa/panels/panel_window_controller_cocoa.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.
 
 #include "chrome/browser/ui/cocoa/panels/panel_window_controller_cocoa.h"
 
 #import <Cocoa/Cocoa.h>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
@@ skipping 28 matching lines @@
 
 using content::WebContents;
 
 const int kMinimumWindowSize = 1;
 const double kBoundsAnimationSpeedPixelsPerSecond = 1000;
 const double kBoundsAnimationMaxDurationSeconds = 0.18;
 
 // Edge thickness to trigger user resizing via system, in screen pixels.
 const double kWidthOfMouseResizeArea = 15.0;
 
+// Notification observer to prevent panels becoming key when windows are closed.
+@interface WindowCloseWatcher : NSObject
+- (void)windowWillClose:(NSNotification*)notification;
+@end
+
+namespace {
+
+// Leaky singleton. Initialized when the first panel is created.
+WindowCloseWatcher* g_window_close_watcher = nil;
+
+}
+
 @interface PanelWindowControllerCocoa (PanelsCanBecomeKey)
 // Internal helper method for extracting the total number of panel windows
 // from the panel manager. Used to decide if panel can become the key window.
 - (int)numPanels;
 @end
 
 @implementation PanelWindowCocoaImpl
 // The panels cannot be reduced to 3-px windows on the edge of the screen
 // active area (above Dock). Default constraining logic makes at least a height
 // of the titlebar visible, so the user could still grab it. We do 'restore'
@@ skipping 22 matching lines @@
 
   BrowserCrApplication* app = base::mac::ObjCCast<BrowserCrApplication>(
       [BrowserCrApplication sharedApplication]);
 
   // A Panel window can become the key window only in limited scenarios.
   // This prevents the system from always preferring a Panel window due
   // to its higher priority NSWindowLevel when selecting a window to make key.
   return ([app isHandlingSendEvent]  && [[app currentEvent] window] == self) ||
       [controller activationRequestedByPanel] ||
       [app isCyclingWindows] ||
+      [self isKeyWindow] ||

[tapted, 2015/03/31 11:34:10]

This case is encountered when there are multiple panels, a panel is active (i.e.
self) and another panel is closed. `app previousKeyWindow` hasn't yet been
updated for the check below, because the panel being *closed* hasn't become key
(which would make `self` previous). It wasn't an issue before because the
_removeWindow hook happened later, or (in tests) not at all. Now that the
trigger is more deterministic, a few cross-platform
{Docked,Stacked}PanelBrowserTests tickled this.

       [app previousKeyWindow] == self ||
       [[app windows] count] == static_cast<NSUInteger>([controller numPanels]);
 }
 
 - (void)performMiniaturize:(id)sender {
   [[self windowController] minimizeButtonClicked:0];
 }
 
 - (void)mouseMoved:(NSEvent*)event {
   // Cocoa does not support letting the application determine the edges that
@@ skipping 60 matching lines @@
 @implementation PanelWindowControllerCocoa
 
 - (id)initWithPanel:(PanelCocoa*)window {
   NSString* nibpath =
       [base::mac::FrameworkBundle() pathForResource:@"Panel" ofType:@"nib"];
   if ((self = [super initWithWindowNibPath:nibpath owner:self])) {
     windowShim_.reset(window);
     animateOnBoundsChange_ = YES;
     canBecomeKeyWindow_ = YES;
     activationRequestedByPanel_ = NO;
+
+    if (!g_window_close_watcher)

[Mark Mentovai, 2015/03/31 13:13:31]

Doesn’t need to be global. You can just write

  static WindowCloseWatcher* watcher = [[WindowCloseWatcher alloc] init];

right here.

[tapted, 2015/03/31 23:55:29]

Ooh - I didn't think of that. It results in

`error: unused variable 'watcher'`

But, a `(void)watcher;` on the line following suppresses the warning. That's not
exactly nice, but I think it's nicer than the global. (Done.)

+      g_window_close_watcher = [[WindowCloseWatcher alloc] init];
   }
   return self;
 }
 
 - (Panel*)panel {
   return windowShim_->panel();
 }
 
 - (void)awakeFromNib {
   NSWindow* window = [self window];
@@ skipping 739 matching lines @@
 - (NSRect)contentRectForFrameRect:(NSRect)frameRect {
   NSRect contentRect = [[[self window] contentView] convertRect:frameRect
                                                        fromView:nil];
   contentRect.size.height -= panel::kTitlebarHeight;
   if (contentRect.size.height < 0)
     contentRect.size.height = 0;
   return contentRect;
 }
 
 @end
+
+@implementation WindowCloseWatcher
+
+- (id)init {
+  if ((self = [super init])) {
+    [[NSNotificationCenter defaultCenter]
+        addObserver:self
+           selector:@selector(windowWillClose:)
+               name:NSWindowWillCloseNotification
+             object:nil];
+  }
+  return self;
+}
+
+- (void)windowWillClose:(NSNotification*)notification {
+  // If it looks like a panel may (refuse to) become key after this window is
+  // closed, then explicitly set the topmost browser window on the active space
+  // to be key (if there is one). Otherwise AppKit will stop looking for windows
+  // to make key once it encounters the panel.
+  id closingWindow = [notification object];
+  BOOL orderNext = NO;
+  for (NSWindow* window : [NSApp orderedWindows]) {
+    if ([window isEqual:closingWindow] || ![window isOnActiveSpace])
+      continue;
+
+    if ([window isKindOfClass:[PanelWindowCocoaImpl class]] &&
+        ![window canBecomeKeyWindow]) {
+      orderNext = YES;
+      continue;
+    }
+
+    if (orderNext) {
+      if (![window canBecomeKeyWindow])
+        continue;
+
+      [window makeKeyWindow];
+    }
+    return;
+  }
+}
+
+@end