MacViews: Allow views::Widgets to be parented off NSWindows

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 "base/logging.h"
 #include "base/mac/mac_util.h"
 #import "base/mac/sdk_forward_declarations.h"
 #include "base/thread_task_runner_handle.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/input_method_factory.h"
 #include "ui/base/ui_base_switches_util.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/dip_util.h"
 #import "ui/gfx/mac/coordinate_conversion.h"
 #import "ui/gfx/mac/nswindow_frame_controls.h"
 #include "ui/gfx/screen.h"
 #import "ui/views/cocoa/cocoa_mouse_capture.h"
 #import "ui/views/cocoa/bridged_content_view.h"
 #import "ui/views/cocoa/views_nswindow_delegate.h"
+#import "ui/views/cocoa/widget_owner_nswindow_adapter.h"
 #include "ui/views/widget/native_widget_mac.h"
 #include "ui/views/ime/input_method_bridge.h"
 #include "ui/views/ime/null_input_method.h"
 #include "ui/views/view.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_aura_utils.h"
 #include "ui/views/widget/widget_delegate.h"
 
 // The NSView that hosts the composited CALayer drawing the UI. It fills the
@@ skipping 114 matching lines @@
            object:nil];
 
   // Validate the window's initial state, otherwise the bridge's initial
   // tracking state will be incorrect.
   DCHECK(![window_ isVisible]);
   DCHECK_EQ(0u, [window_ styleMask] & NSFullScreenWindowMask);
 
   if (params.parent) {
     // Disallow creating child windows of views not currently in an NSWindow.
     CHECK([params.parent window]);
-    BridgedNativeWidget* parent =
+    BridgedNativeWidget* bridged_native_widget_parent =
         NativeWidgetMac::GetBridgeForNativeWindow([params.parent window]);
-    // The parent could be an NSWindow without an associated Widget. That could
-    // work by observing NSWindowWillCloseNotification, but for now it's not
-    // supported, and there might not be a use-case for that.
-    CHECK(parent);
-    parent_ = parent;
-    parent->child_windows_.push_back(this);
+    // If the parent is another BridgedNativeWidget, just add to the collection
+    // of child windows it owns and manages. Otherwise, create an adapter to
+    // anchor the child widget and observe when the parent NSWindow is closed.
+    if (bridged_native_widget_parent) {
+      parent_ = bridged_native_widget_parent;
+      bridged_native_widget_parent->child_windows_.push_back(this);
+    } else {
+      parent_ = new WidgetOwnerNSWindowAdapter(this, params.parent);
+    }
   }
 
   // Set a meaningful initial bounds. Note that except for frameless widgets
   // with no WidgetDelegate, the bounds will be set again by Widget after
   // initializing the non-client view. In the former case, if bounds were not
   // set at all, the creator of the Widget is expected to call SetBounds()
   // before calling Widget::Show() to avoid a kWindowSizeDeterminedLater-sized
   // (i.e. 1x1) window appearing.
   if (!params.bounds.IsEmpty()) {
     SetBounds(params.bounds);
@@ skipping 50 matching lines @@
     // 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));
 
   if (parent_ && !PositionWindowInScreenCoordinates(widget, widget_type_))
-    actual_new_bounds.Offset(parent_->GetRestoredBounds().OffsetFromOrigin());
+    actual_new_bounds.Offset(parent_->GetChildWindowOffset());
 
   [window_ setFrame:gfx::ScreenRectToNSRect(actual_new_bounds)
             display:YES
             animate:NO];
 }
 
 void BridgedNativeWidget::SetRootView(views::View* view) {
   if (view == [bridged_view_ hostedView])
     return;
 
@@ skipping 24 matching lines @@
   //      NSWindow API, or changes propagating out from here.
   wants_to_be_visible_ = new_state != HIDE_WINDOW;
 
   if (new_state == HIDE_WINDOW) {
     [window_ orderOut:nil];
     DCHECK(!window_visible_);
     return;
   }
 
   DCHECK(wants_to_be_visible_);
-
-  // If there's a hidden ancestor, return and wait for it to become visible.
-  for (BridgedNativeWidget* ancestor = parent();
-       ancestor;
-       ancestor = ancestor->parent()) {
-    if (!ancestor->window_visible_)
-      return;
-  }
+  // 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_->GetWidget()->IsModal()) {
-    NSWindow* parent_window = parent_->ns_window();
+    NSWindow* parent_window = parent_->GetNSWindow();
     DCHECK(parent_window);
 
     [NSApp beginSheet:window_
         modalForWindow:parent_window
          modalDelegate:[window_ delegate]
         didEndSelector:@selector(sheetDidEnd:returnCode:contextInfo:)
            contextInfo:nullptr];
     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
     // will order above all windows at the same level.
     NSInteger parent_window_number = 0;
-    if (parent())
-      parent_window_number = [parent()->ns_window() windowNumber];
+    if (parent_)
+      parent_window_number = [parent_->GetNSWindow() windowNumber];
 
     [window_ orderWindow:NSWindowAbove
               relativeTo:parent_window_number];
   }
   DCHECK(window_visible_);
 }
 
 void BridgedNativeWidget::AcquireCapture() {
   DCHECK(!HasCapture());
   if (!window_visible_)
@@ skipping 32 matching lines @@
 void* BridgedNativeWidget::GetNativeWindowProperty(const char* name) const {
   NSString* key = [NSString stringWithUTF8String:name];
   return [[GetWindowProperties() objectForKey:key] pointerValue];
 }
 
 void BridgedNativeWidget::SetCursor(NSCursor* cursor) {
   [window_delegate_ setCursor:cursor];
 }
 
 void BridgedNativeWidget::OnWindowWillClose() {
-  if (parent_)
+  if (parent_) {
     parent_->RemoveChildWindow(this);
+    parent_ = nullptr;
+  }
   [window_ setDelegate:nil];
   [[NSNotificationCenter defaultCenter] removeObserver:window_delegate_];
   native_widget_mac_->OnWindowWillClose();
 }
 
 void BridgedNativeWidget::OnFullscreenTransitionStart(
     bool target_fullscreen_state) {
   // Note: This can fail for fullscreen changes started externally, but a user
   // shouldn't be able to do that if the window is invisible to begin with.
   DCHECK(window_visible_);
@@ skipping 81 matching lines @@
   window_visible_ = new_visibility;
 
   // If arriving via SetVisible(), |wants_to_be_visible_| should already be set.
   // If made visible externally (e.g. Cmd+H), just roll with it. Don't try (yet)
   // to distinguish being *hidden* externally from being hidden by a parent
   // window - we might not need that.
   if (window_visible_) {
     wants_to_be_visible_ = true;
 
     if (parent_)
-      [parent_->ns_window() addChildWindow:window_ ordered:NSWindowAbove];
+      [parent_->GetNSWindow() addChildWindow:window_ ordered:NSWindowAbove];
   } else {
     mouse_capture_.reset();  // 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_->ns_window() removeChildWindow:window_];
+      [parent_->GetNSWindow() removeChildWindow:window_];
   }
 
   // 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()) {
@@ skipping 171 matching lines @@
 
 void BridgedNativeWidget::AcceleratedWidgetSwapCompleted(
     const std::vector<ui::LatencyInfo>& latency_info) {
 }
 
 void BridgedNativeWidget::AcceleratedWidgetHitError() {
   compositor_->ScheduleFullRedraw();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// BridgedNativeWidget, private:
+// BridgedNativeWidget, BridgedNativeWidgetOwner:
 
-void BridgedNativeWidget::RemoveOrDestroyChildren() {
-  // TODO(tapted): Implement unowned child windows if required.
-  while (!child_windows_.empty()) {
-    // The NSWindow can only be destroyed after -[NSWindow close] is complete.
-    // Retain the window, otherwise the reference count can reach zero when the
-    // child calls back into RemoveChildWindow() via its OnWindowWillClose().
-    base::scoped_nsobject<NSWindow> child(
-        [child_windows_.back()->ns_window() retain]);
-    [child close];
-  }
+NSWindow* BridgedNativeWidget::GetNSWindow() {
+  return window_;
+}
+
+gfx::Vector2d BridgedNativeWidget::GetChildWindowOffset() const {
+  return gfx::ScreenRectFromNSRect([window_ frame]).OffsetFromOrigin();
+}
+
+bool BridgedNativeWidget::IsVisibleParent() const {
+  return parent_ ? window_visible_ && parent_->IsVisibleParent()
+                 : window_visible_;
 }
 
 void BridgedNativeWidget::RemoveChildWindow(BridgedNativeWidget* child) {
   auto location = std::find(
       child_windows_.begin(), child_windows_.end(), child);
   DCHECK(location != child_windows_.end());
   child_windows_.erase(location);
-  child->parent_ = nullptr;
 
   // Note the child is sometimes removed already by AppKit. This depends on OS
   // version, and possibly some unpredictable reference counting. Removing it
   // here should be safe regardless.
   [window_ removeChildWindow:child->window_];
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// BridgedNativeWidget, private:
+
+void BridgedNativeWidget::RemoveOrDestroyChildren() {
+  // TODO(tapted): Implement unowned child windows if required.
+  while (!child_windows_.empty()) {
+    // The NSWindow can only be destroyed after -[NSWindow close] is complete.
+    // Retain the window, otherwise the reference count can reach zero when the
+    // child calls back into RemoveChildWindow() via its OnWindowWillClose().
+    base::scoped_nsobject<NSWindow> child(
+        [child_windows_.back()->ns_window() retain]);
+    [child close];
+  }
+}
+
 void BridgedNativeWidget::NotifyVisibilityChangeDown() {
   // Child windows sometimes like to close themselves in response to visibility
   // changes. That's supported, but only with the asynchronous Widget::Close().
   // Perform a heuristic to detect child removal that would break these loops.
   const size_t child_count = child_windows_.size();
   if (!window_visible_) {
     for (BridgedNativeWidget* child : child_windows_) {
       if (child->window_visible_)
         [child->ns_window() orderOut:nil];
 
@@ skipping 128 matching lines @@
       window_, &kWindowPropertiesKey);
   if (!properties) {
     properties = [NSMutableDictionary dictionary];
     objc_setAssociatedObject(window_, &kWindowPropertiesKey,
                              properties, OBJC_ASSOCIATION_RETAIN);
   }
   return properties;
 }
 
 }  // namespace views