Check WindowTreeClient for empty inflight queue upon teardown

components/mus/ws/window_manager_client_unittest.cc

 // 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.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "components/mus/common/util.h"
 #include "components/mus/public/cpp/lib/window_private.h"
 #include "components/mus/public/cpp/tests/window_server_test_base.h"
+#include "components/mus/public/cpp/tests/window_tree_client_private.h"
 #include "components/mus/public/cpp/window_observer.h"
 #include "components/mus/public/cpp/window_tree_client.h"
 #include "components/mus/public/cpp/window_tree_client_delegate.h"
 #include "components/mus/public/cpp/window_tree_client_observer.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace mus {
 namespace ws {
 
 namespace {
@@ skipping 725 matching lines @@
   {
     FocusChangeObserver observer(window11);
     observer.set_quit_on_change(false);
     window11->SetFocus();
     ASSERT_TRUE(window11->HasFocus());
     ASSERT_NE(nullptr, observer.last_gained_focus());
     ASSERT_NE(nullptr, observer.last_lost_focus());
     EXPECT_EQ(server_id(window11), server_id(observer.last_gained_focus()));
     EXPECT_EQ(server_id(GetFirstRoot(embedded)),
               server_id(observer.last_lost_focus()));
+    ASSERT_TRUE(WaitForWindowToHaveFocus(window11));

[sadrul, 2016/06/15 06:42:46]

Why? window11 already has focus (asserted above in line 755)

   }
 
   {
     // Add an observer on the Window that loses focus, and make sure the
     // observer sees the right values.
     FocusChangeObserver observer(window11);
     observer.set_quit_on_change(false);
     GetFirstRoot(embedded)->SetFocus();
     ASSERT_NE(nullptr, observer.last_gained_focus());
     ASSERT_NE(nullptr, observer.last_lost_focus());
     EXPECT_EQ(server_id(window11), server_id(observer.last_lost_focus()));
     EXPECT_EQ(server_id(GetFirstRoot(embedded)),
               server_id(observer.last_gained_focus()));
+    ASSERT_TRUE(WaitForWindowToHaveFocus(GetFirstRoot(embedded)));
   }
+
+  WindowTreeClientPrivate(embedded).WaitForInFlightQueue();
 }
 
 TEST_F(WindowServerTest, ClearFocus) {
   Window* window1 = window_manager()->NewWindow();
   window1->SetVisible(true);
   GetFirstWMRoot()->AddChild(window1);
 
   WindowTreeClient* embedded = Embed(window1).client;
   ASSERT_NE(nullptr, embedded);
   Window* window11 = embedded->NewWindow();
@@ skipping 19 matching lines @@
   {
     FocusChangeObserver observer(window1);
     embedded->ClearFocus();
     ASSERT_FALSE(embedded_root->HasFocus());
     EXPECT_FALSE(embedded->GetFocusedWindow());
 
     ASSERT_TRUE(WindowServerTestBase::DoRunLoopWithTimeout());
     EXPECT_FALSE(window1->HasFocus());
     EXPECT_FALSE(window_manager()->GetFocusedWindow());
   }
+
+  WindowTreeClientPrivate(embedded).WaitForInFlightQueue();

[sadrul, 2016/06/15 06:42:46]

I don't think we should require individual tests to have to do this.

[jonross, 2016/06/15 14:03:08]

Yeah I dislike having certain tests with this. I could look at having the actual
test class do this during teardown. The burden then would be ensuring that the
test class has the WindowTreeClient* to wait for.

 }
 
 TEST_F(WindowServerTest, FocusNonFocusableWindow) {
   Window* window = window_manager()->NewWindow();
   window->SetVisible(true);
   GetFirstWMRoot()->AddChild(window);
 
   WindowTreeClient* client = Embed(window).client;
   ASSERT_NE(nullptr, client);
   ASSERT_FALSE(client->GetRoots().empty());
@@ skipping 61 matching lines @@
       GetChildWindowByServerId(window_manager(), server_id(child21))));
   EXPECT_EQ(server_id(child21),
             server_id(window_manager()->GetFocusedWindow()));
   EXPECT_EQ(server_id(child21), server_id(embedded2->GetFocusedWindow()));
   EXPECT_TRUE(WaitForNoWindowToHaveFocus(embedded1));
   EXPECT_EQ(nullptr, embedded1->GetFocusedWindow());
   EXPECT_GT(ValidIndexOf(parent->children(), child2),
             ValidIndexOf(parent->children(), child1));
   EXPECT_GT(ValidIndexOf(parent->children(), child3),
             ValidIndexOf(parent->children(), child1));
+
+  WindowTreeClientPrivate(embedded1).WaitForInFlightQueue();
+  WindowTreeClientPrivate(embedded2).WaitForInFlightQueue();
 }
 
 TEST_F(WindowServerTest, ActivationNext) {
   Window* parent = GetFirstWMRoot();
   Window* child1 = NewVisibleWindow(parent, window_manager());
   Window* child2 = NewVisibleWindow(parent, window_manager());
   Window* child3 = NewVisibleWindow(parent, window_manager());
 
   WindowTreeClient* embedded1 = Embed(child1).client;
   ASSERT_NE(nullptr, embedded1);
@@ skipping 256 matching lines @@
   ASSERT_TRUE(window_in_wm);
 
   // Change the bounds in the wm, and make sure the child sees it.
   window_in_wm->SetBounds(gfx::Rect(1, 11, 12, 101));
   ASSERT_TRUE(WaitForBoundsToChange(window_in_second_client));
   EXPECT_EQ(gfx::Rect(1, 11, 12, 101), window_in_second_client->bounds());
 }
 
 }  // namespace ws
 }  // namespace mus