MacViews: Attach child windows when parent is on the screen.

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>
 
 #include "base/location.h"
 #import "base/mac/foundation_util.h"
@@ skipping 366 matching lines @@
   int paint_count() { return paint_count_; }
 
  private:
   int paint_count_ = 0;
   int target_paint_count_ = 0;
   base::RunLoop* run_loop_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(PaintCountView);
 };
 
+// Test for correct child window restore when parent window is minimized
+// and restored using -makeKeyAndOrderFront:.
+// Parent-child window relationships in AppKit are not supported when window
+// visibility changes.
+// Disabled because it relies on cocoa occlusion APIs
+// and state changes that are unavoidably flaky.
+TEST_F(NativeWidgetMacTest, DISABLED_OrderFrontAfterMiniaturize) {
+  Widget* widget = CreateTopLevelPlatformWidget();
+  NSWindow* ns_window = widget->GetNativeWindow();
+
+  Widget* child_widget = CreateChildPlatformWidget(widget->GetNativeView());
+  NSWindow* child_ns_window = child_widget->GetNativeWindow();
+
+  // Set parent bounds that overlap child.
+  widget->SetBounds(gfx::Rect(100, 100, 300, 300));
+  child_widget->SetBounds(gfx::Rect(110, 110, 100, 100));
+
+  widget->Show();
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_FALSE(widget->IsMinimized());
+
+  // Minimize parent.
+  [ns_window performMiniaturize:nil];
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(widget->IsMinimized());
+  EXPECT_FALSE(widget->IsVisible());
+  EXPECT_FALSE(child_widget->IsVisible());
+
+  // Restore parent window as AppController does.
+  [ns_window makeKeyAndOrderFront:nil];
+
+  // Wait and check that child is really visible.
+  // TODO(kirr): remove the fixed delay.
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
+      base::TimeDelta::FromSeconds(2));
+  base::MessageLoop::current()->Run();
+
+  EXPECT_FALSE(widget->IsMinimized());
+  EXPECT_TRUE(widget->IsVisible());
+  EXPECT_TRUE(child_widget->IsVisible());
+  // Check that child window is visible.
+  EXPECT_TRUE([child_ns_window occlusionState] & NSWindowOcclusionStateVisible);
+  EXPECT_TRUE(IsWindowStackedAbove(child_widget, widget));
+  widget->Close();
+}
+
 // Test minimized states triggered externally, implied visibility and restored
 // bounds whilst minimized.
 TEST_F(NativeWidgetMacTest, MiniaturizeExternally) {
   Widget* widget = new Widget;
   Widget::InitParams init_params(Widget::InitParams::TYPE_WINDOW);
   widget->Init(init_params);
 
   PaintCountView* view = new PaintCountView();
   widget->GetContentsView()->AddChildView(view);
   NSWindow* ns_window = widget->GetNativeWindow();
@@ skipping 568 matching lines @@
   // -[NSWindow orderOut:] call that is triggered from -[ViewsNSWindowDelegate
   // sheetDidEnd:]. |sheet_widget| will be destroyed next, so it's still safe to
   // use in the block. However, since the orderOut just happened, it's not very
   // interesting.
   observer = [[NSNotificationCenter defaultCenter]
       addObserverForName:NSWindowDidEndSheetNotification
                   object:native_parent
                    queue:nil
               usingBlock:^(NSNotification* note) {
                 EXPECT_TRUE([sheet_window delegate]);
-                EXPECT_FALSE(sheet_widget->IsVisible());
-                EXPECT_FALSE(sheet_widget->GetLayer()->IsDrawn());
                 *did_observe_ptr = true;
               }];
 
   // Pump in order to trigger -[NSWindow endSheet:..], which will block while
   // the animation runs, then delete |sheet_widget|.
   TestWidgetObserver widget_observer(sheet_widget);
   EXPECT_TRUE([sheet_window delegate]);
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE([sheet_window delegate]);
 
@@ skipping 665 matching lines @@
 
 - (void)dealloc {
   if (deallocFlag_) {
     DCHECK(!*deallocFlag_);
     *deallocFlag_ = true;
   }
   [super dealloc];
 }
 
 @end