MacViews: Suppress visibility changes during an asynchronous close.

ui/views/cocoa/bridged_native_widget.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/cocoa/bridged_native_widget.h"
 
 #import <objc/runtime.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/logging.h"
+#import "base/mac/bind_objc_block.h"
 #import "base/mac/foundation_util.h"
 #include "base/mac/mac_util.h"
 #import "base/mac/sdk_forward_declarations.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "ui/accelerated_widget_mac/window_resize_helper_mac.h"
 #import "ui/base/cocoa/constrained_window/constrained_window_animation.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/input_method_factory.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/geometry/dip_util.h"
 #import "ui/gfx/mac/coordinate_conversion.h"
 #import "ui/gfx/mac/nswindow_frame_controls.h"
 #import "ui/views/cocoa/bridged_content_view.h"
 #import "ui/views/cocoa/drag_drop_client_mac.h"
 #import "ui/views/cocoa/cocoa_mouse_capture.h"
 #import "ui/views/cocoa/cocoa_window_move_loop.h"
 #include "ui/views/cocoa/tooltip_manager_mac.h"
+#import "ui/views/cocoa/views_nswindow_close_animator.h"
 #import "ui/views/cocoa/views_nswindow_delegate.h"
 #import "ui/views/cocoa/widget_owner_nswindow_adapter.h"
 #include "ui/views/view.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/native_widget_mac.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_aura_utils.h"
 #include "ui/views/widget/widget_delegate.h"
 
 extern "C" {
@@ skipping 302 matching lines @@
 BridgedNativeWidget::~BridgedNativeWidget() {
   bool close_window = false;
   if ([window_ delegate]) {
     // If the delegate is still set on a modal dialog, it means it was not
     // closed via [NSApplication endSheet:]. This is probably OK if the widget
     // was never shown. But Cocoa ignores close() calls on open sheets. Calling
     // endSheet: here would work, but it messes up assumptions elsewhere. E.g.
     // DialogClientView assumes its delegate is alive when closing, which isn't
     // true after endSheet: synchronously calls OnNativeWidgetDestroyed().
     // So ban it. Modal dialogs should be closed via Widget::Close().
-    DCHECK(!native_widget_mac_->IsWindowModalSheet());
+    DCHECK(!IsWindowModalSheet());
 
     // If the delegate is still set, it means OnWindowWillClose() has not been
     // called and the window is still open. Usually, -[NSWindow close] would
     // synchronously call OnWindowWillClose() which removes the delegate and
     // notifies NativeWidgetMac, which then calls this with a nil delegate.
     // For other teardown flows (e.g. Widget::WIDGET_OWNS_NATIVE_WIDGET or
     // Widget::CloseNow()) the delegate must first be cleared to avoid AppKit
     // calling back into the bridge. This means OnWindowWillClose() needs to be
     // invoked manually, which is done below.
     // Note that if the window has children it can't be closed until the
@@ skipping 123 matching lines @@
   // no check for maximum size (consistent with aura::Window::SetBounds()).
   gfx::Size clamped_content_size =
       GetClientSizeForWindowSize(window_, new_bounds.size());
   clamped_content_size.SetToMax(widget->GetMinimumSize());
 
   // A contentRect with zero width or height is a banned practice in ChromeMac,
   // due to unpredictable OSX treatment.
   DCHECK(!clamped_content_size.IsEmpty())
       << "Zero-sized windows not supported on Mac";
 
-  if (!window_visible_ && native_widget_mac_->IsWindowModalSheet()) {
+  if (!window_visible_ && IsWindowModalSheet()) {
     // Window-Modal dialogs (i.e. sheets) are positioned by Cocoa when shown for
     // the first time. They also have no frame, so just update the content size.
     [window_ setContentSize:NSMakeSize(clamped_content_size.width(),
                                        clamped_content_size.height())];
     return;
   }
   gfx::Rect actual_new_bounds(
       new_bounds.origin(),
       GetWindowSizeForClientSize(window_, clamped_content_size));
 
@@ skipping 44 matching lines @@
     DCHECK(!window_visible_);
     return;
   }
 
   DCHECK(wants_to_be_visible_);
   // If the parent (or an ancestor) is hidden, return and wait for it to become
   // visible.
   if (parent() && !parent()->IsVisibleParent())
     return;
 
-  if (native_widget_mac_->IsWindowModalSheet()) {
+  if (IsWindowModalSheet()) {
     ShowAsModalSheet();
     return;
   }
 
   if (new_state == SHOW_AND_ACTIVATE_WINDOW) {
     [window_ makeKeyAndOrderFront:nil];
     [NSApp activateIgnoringOtherApps:YES];
   } else {
     // ui::SHOW_STATE_INACTIVE is typically used to avoid stealing focus from a
     // parent window. So, if there's a parent, order above that. Otherwise, this
@@ skipping 16 matching lines @@
     // duration of the animation, but would keep it smooth. The window also
     // hasn't yet received a frame from the compositor at this stage, so it is
     // fully transparent until the GPU sends a frame swap IPC. For the blocking
     // option, the animation needs to wait until AcceleratedWidgetSwapCompleted
     // has been called at least once, otherwise it will animate nothing.
     [show_animation setAnimationBlockingMode:NSAnimationNonblocking];
     [show_animation startAnimation];
   }
 }
 
+void BridgedNativeWidget::CloseAsynchronously() {
+  // In a past life, the window would be synchronously hidden for the non-modal
+  // case. AppKit UI could do funny things before an asynchronous close finished
+  // (see http://crbug.com/156101). But that shouldn't be needed with toolkit-
+  // views. But a synchronous hide would have released capture, so do it now.
+  ReleaseCapture();
+
+  if (IsWindowModalSheet()) {
+    // Sheets can't be closed normally. This starts the sheet closing. Once the
+    // sheet has finished animating, it will call sheetDidEnd: on the parent
+    // window's delegate. Note it still needs to be asynchronous, since code
+    // calling Widget::Close() doesn't expect things to be deleted upon return.
+    [NSApp performSelector:@selector(endSheet:)
+                withObject:window_
+                afterDelay:0];
+    return;
+  }
+
+  // For other modal types, animate the close.
+  if (native_widget_mac_->GetWidget()->IsModal()) {
+    CloseNativeWindowWithAnimation(window_);
+    return;
+  }
+
+  // Clear the view early to suppress repaints.
+  SetRootView(nullptr);
+
+  // Widget::Close() ensures [Non]ClientView::CanClose() returns true, so there
+  // is no need to call the NSWindow or its delegate's -windowShouldClose:
+  // implementation in the manner of -[NSWindow performClose:].
+
+  // Many tests assume that base::RunLoop().RunUntilIdle() is always sufficient
+  // to execute a close. However, in rare cases, -performSelector:..afterDelay:0
+  // does not do this. So post a regular task.
+  NSWindow* window = window_;  // Ensure the block retains the window.
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, base::BindBlock(^{
+                                                  [window close];
+                                                }));
+}
+
 void BridgedNativeWidget::AcquireCapture() {
   DCHECK(!HasCapture());
   if (!window_visible_)
     return;  // Capture on hidden windows is disallowed.
 
   mouse_capture_.reset(new CocoaMouseCapture(this));
 
   // Initiating global event capture with addGlobalMonitorForEventsMatchingMask:
   // will reset the mouse cursor to an arrow. Asking the window for an update
   // here will restore what we want. However, it can sometimes cause the cursor
@@ skipping 193 matching lines @@
   } else {
     ReleaseCapture();  // Capture on hidden windows is not permitted.
 
     // When becoming invisible, remove the entry in any parent's childWindow
     // list. Cocoa's childWindow management breaks down when child windows are
     // hidden.
     if (parent_)
       [parent_->GetNSWindow() removeChildWindow:window_];
   }
 
+  NotifyVisibilityChangeDown();
+
+  // Toolkit-views suppresses redraws while not visible. To prevent Cocoa asking
+  // for an "empty" draw, disable auto-display while hidden. For example, this
+  // prevents Cocoa drawing just *after* a minimize, resulting in a blank window
+  // represented in the deminiaturize animation.
+  [window_ setAutodisplay:window_visible_];
+
+  // |bridged_view_| is null when an asynchronous close is pending. Don't
+  // propagate the change further. Note it's not possible to block window
+  // visibility changes coming from native messages, so the bookkeeping above
+  // should still be done.
+  if (!bridged_view_)
+    return;
+
   // TODO(tapted): Investigate whether we want this for Mac. This is what Aura
   // does, and it is what tests expect. However, because layer drawing is
   // asynchronous (and things like deminiaturize in AppKit are not), it can
   // result in a CALayer appearing on screen before it has been redrawn in the
   // GPU process. This is a general problem. In content, a helper class,
   // RenderWidgetResizeHelper, blocks the UI thread in -[NSView setFrameSize:]
   // and RenderWidgetHostView::Show() until a frame is ready.
   if (layer()) {
     layer()->SetVisible(window_visible_);
     layer()->SchedulePaint(gfx::Rect(GetClientAreaSize()));
   }
 
-  NotifyVisibilityChangeDown();
-
   native_widget_mac_->GetWidget()->OnNativeWidgetVisibilityChanged(
       window_visible_);
-
-  // Toolkit-views suppresses redraws while not visible. To prevent Cocoa asking
-  // for an "empty" draw, disable auto-display while hidden. For example, this
-  // prevents Cocoa drawing just *after* a minimize, resulting in a blank window
-  // represented in the deminiaturize animation.
-  [window_ setAutodisplay:window_visible_];
 }
 
 void BridgedNativeWidget::OnBackingPropertiesChanged() {
   if (layer())
     UpdateLayerProperties();
 }
 
 void BridgedNativeWidget::OnWindowKeyStatusChangedTo(bool is_key) {
   Widget* widget = native_widget_mac()->GetWidget();
   widget->OnNativeWidgetActivationChanged(is_key);
@@ skipping 111 matching lines @@
   // Transparent window support.
   layer()->GetCompositor()->SetHostHasTransparentBackground(translucent);
   layer()->SetFillsBoundsOpaquely(!translucent);
 
   // Use the regular window background for window modal sheets. The layer() will
   // still paint over most of it, but the native -[NSApp beginSheet:] animation
   // blocks the UI thread, so there's no way to invalidate the shadow to match
   // the composited layer. This assumes the native window shape is a good match
   // for the composited NonClientFrameView, which should be the case since the
   // native shape is what's most appropriate for displaying sheets on Mac.
-  if (translucent && !native_widget_mac_->IsWindowModalSheet()) {
+  if (translucent && !IsWindowModalSheet()) {
     [window_ setOpaque:NO];
     // For Mac OS versions earlier than Yosemite, the Window server isn't able
     // to generate a window shadow from the composited CALayer. To get around
     // this, let the window background remain opaque and clip the window
     // boundary in drawRect method of BridgedContentView. See crbug.com/543671.
     if (base::mac::IsOSYosemiteOrLater())
       [window_ setBackgroundColor:[NSColor clearColor]];
   }
 
   UpdateLayerProperties();
@@ skipping 337 matching lines @@
     if (!resize_helper->WaitForSingleTaskToRun(timeout_time - now))
       return;  // Timeout.
 
     // Since the UI thread is blocked, the size shouldn't change.
     DCHECK(size_in_dip == GetClientAreaSize());
     if (compositor_widget_->HasFrameOfSize(size_in_dip))
       return;  // Frame arrived.
   }
 }
 
+bool BridgedNativeWidget::IsWindowModalSheet() const {
+  return native_widget_mac_->GetWidget()->widget_delegate()->GetModalType() ==
+         ui::MODAL_TYPE_WINDOW;
+}
+
 void BridgedNativeWidget::ShowAsModalSheet() {
   // -[NSApp beginSheet:] will block the UI thread while the animation runs.
   // So that it doesn't animate a fully transparent window, first wait for a
   // frame. The first step is to pretend that the window is already visible.
   window_visible_ = true;
   layer()->SetVisible(true);
   native_widget_mac_->GetWidget()->OnNativeWidgetVisibilityChanged(true);
   MaybeWaitForFrame(GetClientAreaSize());
 
   NSWindow* parent_window = parent_->GetNSWindow();
@@ skipping 21 matching lines @@
   [bridged_view_ setMouseDownCanMoveWindow:draggable];
   // AppKit will not update its cache of mouseDownCanMoveWindow unless something
   // changes. Previously we tried adding an NSView and removing it, but for some
   // reason it required reposting the mouse-down event, and didn't always work.
   // Calling the below seems to be an effective solution.
   [window_ setMovableByWindowBackground:NO];
   [window_ setMovableByWindowBackground:YES];
 }
 
 }  // namespace views