Mac: Retain the child NSWindow in WidgetOwnerNSWindowAdapter before invoking close

ui/views/widget/native_widget_mac_unittest.mm

 // Copyright 2014 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 "ui/views/widget/native_widget_mac.h"
 
 #import <Cocoa/Cocoa.h>
 
 #import "base/mac/foundation_util.h"
 #import "base/mac/scoped_nsobject.h"
+#import "base/mac/scoped_nsautorelease_pool.h"
 #import "base/mac/scoped_objc_class_swizzler.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_timeouts.h"
 #import "testing/gtest_mac.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #import "ui/base/cocoa/constrained_window/constrained_window_animation.h"
@@ skipping 27 matching lines @@
 @end
 
 @interface NSWindow (PrivateAPI)
 - (BOOL)_isTitleHidden;
 @end
 
 // Test NSWindow that provides hooks via method overrides to verify behavior.
 @interface NativeWidgetMacTestWindow : NativeWidgetMacNSWindow {
  @private
   int invalidateShadowCount_;
+  bool* deallocFlag_;
 }
 @property(readonly, nonatomic) int invalidateShadowCount;
+@property(assign, nonatomic) bool* deallocFlag;
 @end
 
 // Used to mock BridgedContentView so that calls to drawRect: can be
 // intercepted.
 @interface MockBridgedView : NSView {
  @private
   // Number of times -[NSView drawRect:] has been called.
   NSUInteger drawRectCount_;
 
   // The dirtyRect parameter passed to last invocation of drawRect:.
   NSRect lastDirtyRect_;
 }
 
 @property(assign, nonatomic) NSUInteger drawRectCount;
 @property(assign, nonatomic) NSRect lastDirtyRect;
 @end
 
 @interface FocusableTestNSView : NSView
 @end
 
+@interface TestNativeParentWindow : NSWindow
+@property(assign, nonatomic) bool* deallocFlag;
+@end
+
 namespace views {
 namespace test {
 
 // BridgedNativeWidget friend to access private members.
 class BridgedNativeWidgetTestApi {
  public:
   explicit BridgedNativeWidgetTestApi(NSWindow* window) {
     bridge_ = NativeWidgetMac::GetBridgeForNativeWindow(window);
   }
 
@@ skipping 41 matching lines @@
 // Tests for parts of NativeWidgetMac not covered by BridgedNativeWidget, which
 // need access to Cocoa APIs.
 class NativeWidgetMacTest : public WidgetTest {
  public:
   NativeWidgetMacTest() {}
 
   // The content size of NSWindows made by MakeNativeParent().
   NSRect ParentRect() const { return NSMakeRect(100, 100, 300, 200); }
 
   // Make a native NSWindow with the given |style_mask| to use as a parent.
-  NSWindow* MakeNativeParentWithStyle(int style_mask) {
-    native_parent_.reset([[NSWindow alloc]
+  TestNativeParentWindow* MakeNativeParentWithStyle(int style_mask) {
+    native_parent_.reset([[TestNativeParentWindow alloc]
         initWithContentRect:ParentRect()
                   styleMask:style_mask
                     backing:NSBackingStoreBuffered
                       defer:NO]);
     [native_parent_ setReleasedWhenClosed:NO];  // Owned by scoped_nsobject.
     [native_parent_ makeKeyAndOrderFront:nil];
     return native_parent_;
   }
 
   // Make a borderless, native NSWindow to use as a parent.
-  NSWindow* MakeNativeParent() {
+  TestNativeParentWindow* MakeNativeParent() {
     return MakeNativeParentWithStyle(NSBorderlessWindowMask);
   }
 
   // Create a Widget backed by the NativeWidgetMacTestWindow NSWindow subclass.
   Widget* CreateWidgetWithTestWindow(Widget::InitParams params,
                                      NativeWidgetMacTestWindow** window) {
     Widget* widget = new Widget;
     params.native_widget = new TestWindowNativeWidgetMac(widget);
     widget->Init(params);
     widget->Show();
     *window = base::mac::ObjCCastStrict<NativeWidgetMacTestWindow>(
         widget->GetNativeWindow());
     EXPECT_TRUE(*window);
     return widget;
   }
 
+ protected:
+  base::scoped_nsobject<TestNativeParentWindow> native_parent_;
+
  private:
-  base::scoped_nsobject<NSWindow> native_parent_;
-
   DISALLOW_COPY_AND_ASSIGN(NativeWidgetMacTest);
 };
 
 class WidgetChangeObserver : public TestWidgetObserver {
  public:
   WidgetChangeObserver(Widget* widget) : TestWidgetObserver(widget) {}
 
   void WaitForVisibleCounts(int gained, int lost) {
     if (gained_visible_count_ >= gained && lost_visible_count_ >= lost)
       return;
@@ skipping 456 matching lines @@
   EXPECT_EQ(native_parent, bridged_native_widget->parent()->GetNSWindow());
 
   // Closing the parent should close and destroy the child.
   EXPECT_FALSE(child_observer.widget_closed());
   [native_parent close];
   EXPECT_TRUE(child_observer.widget_closed());
 
   EXPECT_EQ(0u, [[native_parent childWindows] count]);
 }
 
+// Tests closing the last remaining NSWindow reference via -windowWillClose:.
+// This is a regression test for http://crbug.com/616701.
+TEST_F(NativeWidgetMacTest, NonWidgetParentLastReference) {
+  bool child_dealloced = false;
+  bool native_parent_dealloced = false;
+  {
+    base::mac::ScopedNSAutoreleasePool pool;
+    TestNativeParentWindow* native_parent = MakeNativeParent();
+    [native_parent setDeallocFlag:&native_parent_dealloced];
+
+    NativeWidgetMacTestWindow* window;
+    Widget::InitParams init_params =
+        CreateParams(Widget::InitParams::TYPE_POPUP);
+    init_params.parent = [native_parent_ contentView];
+    init_params.bounds = gfx::Rect(0, 0, 100, 200);
+    CreateWidgetWithTestWindow(init_params, &window);
+    [window setDeallocFlag:&child_dealloced];
+  }
+  {
+    // On 10.11, closing a weak reference on the parent window works, but older
+    // versions of AppKit get upset if things are released inside -[NSWindow
+    // close]. This test tries to establish a situation where the last reference
+    // to the child window is released inside WidgetOwnerNSWindowAdapter::
+    // OnWindowWillClose().
+    base::mac::ScopedNSAutoreleasePool pool;
+    [native_parent_.autorelease() close];
+    EXPECT_TRUE(child_dealloced);
+  }
+  EXPECT_TRUE(native_parent_dealloced);
+}
+
 // Use Native APIs to query the tooltip text that would be shown once the
 // tooltip delay had elapsed.
 base::string16 TooltipTextForWidget(Widget* widget) {
   // For Mac, the actual location doesn't matter, since there is only one native
   // view and it fills the window. This just assumes the window is at least big
   // big enough for a constant coordinate to be within it.
   NSPoint point = NSMakePoint(30, 30);
   NSView* view = [widget->GetNativeView() hitTest:point];
   NSString* text =
       [view view:view stringForToolTip:0 point:point userData:nullptr];
@@ skipping 901 matching lines @@
 
 @implementation TestStopAnimationWaiter
 - (void)setWindowStateForEnd {
   views::test::ScopedSwizzleWaiter::GetMethodAndMarkCalled()(self, _cmd);
 }
 @end
 
 @implementation NativeWidgetMacTestWindow
 
 @synthesize invalidateShadowCount = invalidateShadowCount_;
+@synthesize deallocFlag = deallocFlag_;
+
+- (void)dealloc {
+  if (deallocFlag_) {
+    DCHECK(!*deallocFlag_);
+    *deallocFlag_ = true;
+  }
+  [super dealloc];
+}
 
 - (void)invalidateShadow {
   ++invalidateShadowCount_;
   [super invalidateShadow];
 }
 
 @end
 
 @implementation MockBridgedView
 
 @synthesize drawRectCount = drawRectCount_;
 @synthesize lastDirtyRect = lastDirtyRect_;
 
 - (void)drawRect:(NSRect)dirtyRect {
   ++drawRectCount_;
   lastDirtyRect_ = dirtyRect;
 }
 
 @end
 
 @implementation FocusableTestNSView
 - (BOOL)acceptsFirstResponder {
   return YES;
 }
 @end
+
+@implementation TestNativeParentWindow {
+  bool* deallocFlag_;
+}
+
+@synthesize deallocFlag = deallocFlag_;
+
+- (void)dealloc {
+  if (deallocFlag_) {
+    DCHECK(!*deallocFlag_);
+    *deallocFlag_ = true;
+  }
+  [super dealloc];
+}
+
+@end