MacViews: Suppress visibility changes during an asynchronous close.

ui/views/widget/widget_unittest.cc

 // Copyright (c) 2012 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.
 
 #include <algorithm>
 #include <memory>
 #include <set>
 
 #include "base/bind.h"
 #include "base/environment.h"
@@ skipping 1308 matching lines @@
 }
 #endif
 
 // Desktop native widget Aura tests are for non Chrome OS platforms.
 #if !defined(OS_CHROMEOS)
 // This class validates whether paints are received for a visible Widget.
 // To achieve this it overrides the Show and Close methods on the Widget class
 // and sets state whether subsequent paints are expected.
 class DesktopAuraTestValidPaintWidget : public views::Widget {
  public:
-  DesktopAuraTestValidPaintWidget()
-    : received_paint_(false),
-      expect_paint_(true),
-      received_paint_while_hidden_(false) {}
-
+  DesktopAuraTestValidPaintWidget() {}
   ~DesktopAuraTestValidPaintWidget() override {}
 
   void InitForTest(Widget::InitParams create_params);
 
   bool ReadReceivedPaintAndReset() {
     bool result = received_paint_;
     received_paint_ = false;
     return result;
   }
 
   bool received_paint_while_hidden() const {
     return received_paint_while_hidden_;
   }
 
+  int visibility_change_count() const { return visibility_change_count_; }
+
+  bool visible_at_last_change() const { return visible_at_last_change_; }
+
   void WaitUntilPaint() {
     if (received_paint_)
       return;
     base::RunLoop runloop;
     quit_closure_ = runloop.QuitClosure();
     runloop.Run();
     quit_closure_ = base::Closure();
   }
 
   // views::Widget:
@@ skipping 15 matching lines @@
   void OnNativeWidgetPaint(const ui::PaintContext& context) override {
     received_paint_ = true;
     EXPECT_TRUE(expect_paint_);
     if (!expect_paint_)
       received_paint_while_hidden_ = true;
     views::Widget::OnNativeWidgetPaint(context);
     if (!quit_closure_.is_null())
       quit_closure_.Run();
   }
 
+  void OnNativeWidgetVisibilityChanged(bool visible) override {
+    ++visibility_change_count_;
+    visible_at_last_change_ = visible;
+    views::Widget::OnNativeWidgetVisibilityChanged(visible);
+  }
+
  private:
-  bool received_paint_;
-  bool expect_paint_;
-  bool received_paint_while_hidden_;
+  int visibility_change_count_ = 0;
+  bool visible_at_last_change_ = false;
+
+  bool received_paint_ = false;
+  bool expect_paint_ = true;
+  bool received_paint_while_hidden_ = false;
+
   base::Closure quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopAuraTestValidPaintWidget);
 };
 
 void DesktopAuraTestValidPaintWidget::InitForTest(InitParams init_params) {
   init_params.bounds = gfx::Rect(0, 0, 200, 200);
   init_params.ownership = InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   init_params.native_widget =
       CreatePlatformDesktopNativeWidgetImpl(init_params, this, nullptr);
@@ skipping 31 matching lines @@
   widget.WaitUntilPaint();
   EXPECT_TRUE(widget.ReadReceivedPaintAndReset());
   widget.SchedulePaintInRect(widget.GetRestoredBounds());
   widget.Hide();
   RunPendingMessages();
   EXPECT_FALSE(widget.ReadReceivedPaintAndReset());
   EXPECT_FALSE(widget.received_paint_while_hidden());
   widget.Close();
 }
 
+// Tests that visibility changes after scheduling an asynchronous Close() are
+// sane and consistent across platforms.
+TEST_F(WidgetTest, DesktopNativeWidgetVisibilityAfterCloseTest) {
+  // TODO(sad): Desktop widgets do not work well in mus https://crbug.com/616551
+  if (IsMus())
+    return;
+
+  DesktopAuraTestValidPaintWidget widget;
+  widget.InitForTest(CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS));
+  widget.WaitUntilPaint();
+  EXPECT_TRUE(widget.ReadReceivedPaintAndReset());
+  EXPECT_EQ(1, widget.visibility_change_count());
+  EXPECT_TRUE(widget.visible_at_last_change());
+
+  // Hide before close should behave normally. Hide and show are synchronous.
+  widget.Hide();
+  EXPECT_EQ(2, widget.visibility_change_count());
+  EXPECT_FALSE(widget.visible_at_last_change());
+  widget.Show();
+  EXPECT_EQ(3, widget.visibility_change_count());
+  EXPECT_TRUE(widget.visible_at_last_change());
+
+  RunPendingMessages();
+  EXPECT_EQ(3, widget.visibility_change_count());  // No change.
+
+  EXPECT_FALSE(widget.ReadReceivedPaintAndReset());
+  widget.WaitUntilPaint();
+  EXPECT_TRUE(widget.ReadReceivedPaintAndReset());
+
+  // After a Close, there should be no changes.
+  widget.Close();
+  EXPECT_EQ(3, widget.visibility_change_count());  // No change.
+  widget.Hide();
+  EXPECT_EQ(3, widget.visibility_change_count());  // No change.
+  widget.Show();
+  EXPECT_EQ(3, widget.visibility_change_count());  // No change.
+  RunPendingMessages();
+  EXPECT_EQ(3, widget.visibility_change_count());  // No change.
+}
+
 // Test to ensure that the aura Window's visiblity state is set to visible if
 // the underlying widget is hidden and then shown.
 TEST_F(WidgetTest, TestWindowVisibilityAfterHide) {
   // Create a widget.
   Widget widget;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW);
   init_params.show_state = ui::SHOW_STATE_NORMAL;
   gfx::Rect initial_bounds(0, 0, 300, 400);
   init_params.bounds = initial_bounds;
@@ skipping 2355 matching lines @@
                              CreateParams(Widget::InitParams::TYPE_WINDOW),
                              Widget::InitParams::TRANSLUCENT_WINDOW);
   EXPECT_EQ(IsNativeWindowTransparent(widget.GetNativeWindow()),
             widget.ShouldWindowContentsBeTransparent());
 }
 
 #endif  // !defined(OS_CHROMEOS)
 
 }  // namespace test
 }  // namespace views