MacViews: Fix child window z-order and SetBounds

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"
 
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #import "base/mac/sdk_forward_declarations.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 103 matching lines @@
   if (focus_manager_)
     focus_manager_->RemoveFocusChangeListener(this);
 
   if (focus_manager)
     focus_manager->AddFocusChangeListener(this);
 
   focus_manager_ = focus_manager;
 }
 
 void BridgedNativeWidget::SetBounds(const gfx::Rect& new_bounds) {
-  [window_ setFrame:gfx::ScreenRectToNSRect(new_bounds)
+  gfx::Rect actual_new_bounds(new_bounds);
+  if (parent_)
+    actual_new_bounds.Offset(parent_->GetRestoredBounds().OffsetFromOrigin());
+
+  [window_ setFrame:gfx::ScreenRectToNSRect(actual_new_bounds)
             display:YES
             animate:NO];
 }
 
 void BridgedNativeWidget::SetRootView(views::View* view) {
   if (view == [bridged_view_ hostedView])
     return;
 
   // If this is ever false, the compositor will need to be properly torn down
   // and replaced, pointing at the new view.
@@ skipping 18 matching lines @@
   // Ensure that:
   //  - A window with an invisible parent is not made visible.
   //  - A parent changing visibility updates child window visibility.
   //    * But only when changed via this function - ignore changes via the
   //      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_);
-    NotifyVisibilityChangeDown();
     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 (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];
 
     [window_ orderWindow:NSWindowAbove
               relativeTo:parent_window_number];
   }
   DCHECK(window_visible_);
-  NotifyVisibilityChangeDown();
 }
 
 void BridgedNativeWidget::AcquireCapture() {
   DCHECK(!HasCapture());
   if (!window_visible_)
     return;  // Capture on hidden windows is disallowed.
 
   mouse_capture_.reset(new CocoaMouseCapture(this));
 }
 
@@ skipping 98 matching lines @@
 void BridgedNativeWidget::OnVisibilityChangedTo(bool new_visibility) {
   if (window_visible_ == new_visibility)
     return;
 
   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_)
+  if (window_visible_) {
     wants_to_be_visible_ = true;
 
-  // Capture on hidden windows is not permitted.
-  if (!window_visible_)
-    mouse_capture_.reset();
+    if (parent_)
+      [parent_->ns_window() 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_];
+  }
 
   // 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_];
 }
 
@@ skipping 153 matching lines @@
   child->parent_ = nullptr;
 }
 
 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_) {
+      if (child->window_visible_)
         [child->ns_window() orderOut:nil];
-        child->NotifyVisibilityChangeDown();
-        CHECK_EQ(child_count, child_windows_.size());
-      }
+
+      DCHECK(!child->window_visible_);
+      CHECK_EQ(child_count, child_windows_.size());
     }
+    // The orderOut calls above should result in a call to OnVisibilityChanged()
+    // in each child. There, children will remove themselves from the NSWindow
+    // childWindow list as well as propagate NotifyVisibilityChangeDown() calls
+    // to any children of their own.
+    DCHECK_EQ(0u, [[window_ childWindows] count]);
     return;
   }
 
+  NSUInteger visible_children = 0;  // For a DCHECK below.
   NSInteger parent_window_number = [window_ windowNumber];
   for (BridgedNativeWidget* child: child_windows_) {
     // Note: order the child windows on top, regardless of whether or not they
     // are currently visible. They probably aren't, since the parent was hidden
     // prior to this, but they could have been made visible in other ways.
     if (child->wants_to_be_visible_) {
+      ++visible_children;
+      // Here -[NSWindow orderWindow:relativeTo:] is used to put the window on
+      // screen. However, that by itself is insufficient to guarantee a correct
+      // z-order relationship. If this function is being called from a z-order
+      // change in the parent, orderWindow turns out to be unreliable (i.e. the
+      // ordering doesn't always take effect). What this actually relies on is
+      // the resulting call to OnVisibilityChanged() in the child, which will
+      // then insert itself into -[NSWindow childWindows] to let Cocoa do its
+      // internal layering magic.
       [child->ns_window() orderWindow:NSWindowAbove
                            relativeTo:parent_window_number];
-      child->NotifyVisibilityChangeDown();
-      CHECK_EQ(child_count, child_windows_.size());
+      DCHECK(child->window_visible_);
     }
+    CHECK_EQ(child_count, child_windows_.size());
   }
+  DCHECK_EQ(visible_children, [[window_ childWindows] count]);
 }
 
 gfx::Size BridgedNativeWidget::GetClientAreaSize() const {
   NSRect content_rect = [window_ contentRectForFrameRect:[window_ frame]];
   return gfx::Size(NSWidth(content_rect), NSHeight(content_rect));
 }
 
 void BridgedNativeWidget::CreateCompositor() {
   DCHECK(!compositor_);
   DCHECK(!compositor_widget_);
@@ skipping 69 matching lines @@
   DCHECK(compositor_superview_);
   gfx::Size size_in_dip = GetClientAreaSize();
   layer()->SetBounds(gfx::Rect(size_in_dip));
 
   float scale_factor = GetDeviceScaleFactorFromView(compositor_superview_);
   compositor_->SetScaleAndSize(scale_factor,
                                ConvertSizeToPixel(scale_factor, size_in_dip));
 }
 
 }  // namespace views