Fix Restore after Minimize on X11.

ui/views/widget/widget_interactive_uitest.cc

 // Copyright (c) 2013 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 <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/macros.h"
@@ skipping 213 matching lines @@
 #endif
 
 // Calls ShowInactive() on a Widget, and spins a run loop. The goal is to give
 // the OS a chance to activate a widget. However, for this case, the test
 // doesn't expect that to happen, so there is nothing to wait for.
 void ShowInactiveSync(Widget* widget) {
   widget->ShowInactive();
   RunPendingMessagesForActiveStatusChange();
 }
 
+// Wait until |property| returns |expected_value|, but no longer than 1 second.
+class PropertyWaiter {
+ public:
+  PropertyWaiter(const base::Callback<bool(void)>& property,

[msw, 2017/05/18 18:37:44]

nit: rename |callback| here and in class and comment?

[alshabalin, 2017/05/23 06:48:18]

Done.

+                 bool expected_value)
+      : property_(property), expected_value_(expected_value) {}
+
+  bool Wait() {
+    if (property_.Run() == expected_value_) {
+      success_ = true;
+      return success_;
+    }
+    start_time_ = base::TimeTicks::Now();
+    timer_.Start(FROM_HERE, base::TimeDelta(), this, &PropertyWaiter::Check);
+    run_loop_.Run();
+    return success_;
+  }
+
+ private:
+  void Check() {
+    DCHECK(!success_);
+    success_ = property_.Run() == expected_value_;
+    if (success_ || base::TimeTicks::Now() - start_time_ > kTimeout) {
+      timer_.Stop();
+      run_loop_.Quit();
+    }
+  }
+
+  const base::TimeDelta kTimeout = base::TimeDelta::FromSeconds(1);
+  base::Callback<bool(void)> property_;
+  const bool expected_value_;
+  bool success_ = false;
+  base::TimeTicks start_time_;
+  base::RunLoop run_loop_;
+  base::RepeatingTimer timer_;
+};
+
 }  // namespace
 
 class WidgetTestInteractive : public WidgetTest {
  public:
   WidgetTestInteractive() {}
   ~WidgetTestInteractive() override {}
 
   void SetUp() override {
     // On mus these tests run as part of views::ViewsTestSuite which already
     // does this initialization.
@@ skipping 964 matching lines @@
   // Testing a widget which specifies a initially focused view.
   TestInitialFocusWidgetDelegate delegate(GetContext());
 
   Widget* widget = delegate.GetWidget();
   ShowSync(widget);
   widget->Show();
   EXPECT_TRUE(delegate.view()->HasFocus());
   EXPECT_EQ(delegate.view(), widget->GetFocusManager()->GetStoredFocusView());
 }
 
+TEST_F(WidgetTestInteractive, RestoreAfterMinimize) {
+  Widget* widget = CreateWidget();
+  ShowSync(widget);
+  ASSERT_FALSE(widget->IsMinimized());
+
+  PropertyWaiter minimize_waiter(

[msw, 2017/05/18 18:37:44]

Could a single base::RunLoop().RunUntilIdle(); handle these operations?
It would be nice to avoid adding this one-off PropertyWaiter if possible.

[alshabalin, 2017/05/23 06:48:18]

I tried that initially and it seemed to work, but decided against it because it
might flake: there's no guarantee when WM will honor minimization request.

+      base::Bind(&Widget::IsMinimized, base::Unretained(widget)), true);
+  widget->Minimize();
+  EXPECT_TRUE(minimize_waiter.Wait());
+
+  PropertyWaiter restore_waiter(
+      base::Bind(&Widget::IsMinimized, base::Unretained(widget)), false);
+  widget->Restore();
+  EXPECT_TRUE(restore_waiter.Wait());
+
+  widget->CloseNow();
+}
+
 namespace {
 
 // Helper class for CaptureLostTrackingWidget to store whether
 // OnMouseCaptureLost has been invoked for a widget.
 class CaptureLostState {
  public:
   CaptureLostState() : got_capture_lost_(false) {}
 
   bool GetAndClearGotCaptureLost() {
     bool value = got_capture_lost_;
@@ skipping 579 matching lines @@
 
   ui::KeyEvent key_event2(key_event);
   widget->OnKeyEvent(&key_event2);
   EXPECT_FALSE(key_event2.stopped_propagation());
 
   widget->CloseNow();
 }
 
 }  // namespace test
 }  // namespace views