mus: Allow the WM to specify the windows that can have active children.

components/mus/ws/window_manager_client_apptest.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 "base/bind.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "components/mus/common/util.h"
 #include "components/mus/public/cpp/tests/window_server_test_base.h"
 #include "components/mus/public/cpp/window_observer.h"
 #include "components/mus/public/cpp/window_tree_connection.h"
 #include "components/mus/public/cpp/window_tree_delegate.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/application_test_base.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/mojo/geometry/geometry_util.h"
 
 namespace mus {
 
 namespace ws {
 
 namespace {
 
+int ValidIndexOf(const Window::Children& windows, Window* window) {
+  Window::Children::const_iterator it =
+      std::find(windows.begin(), windows.end(), window);
+  return (it != windows.end()) ? (it - windows.begin()) : -1;
+}
+
 class BoundsChangeObserver : public WindowObserver {
  public:
   explicit BoundsChangeObserver(Window* window) : window_(window) {
     window_->AddObserver(this);
   }
   ~BoundsChangeObserver() override { window_->RemoveObserver(this); }
 
  private:
   // Overridden from WindowObserver:
   void OnWindowBoundsChanged(Window* window,
@@ skipping 158 matching lines @@
 };
 
 // These tests model synchronization of two peer connections to the window
 // manager
 // service, that are given access to some root window.
 
 class WindowServerTest : public WindowServerTestBase {
  public:
   WindowServerTest() {}
 
+  Window* NewVisibleWindow(Window* parent, WindowTreeConnection* connection) {
+    Window* window = connection->NewWindow();
+    window->SetVisible(true);
+    parent->AddChild(window);
+    return window;
+  }
+
   // Embeds another version of the test app @ window. This runs a run loop until
   // a response is received, or a timeout. On success the new WindowServer is
   // returned.
   EmbedResult Embed(Window* window) {
     return Embed(window, mus::mojom::WindowTree::ACCESS_POLICY_DEFAULT);
   }
 
   EmbedResult Embed(Window* window, uint32_t access_policy_bitmask) {
     DCHECK(!embed_details_);
     embed_details_.reset(new EmbedDetails);
@@ skipping 402 matching lines @@
     EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   Window* window_;
   Window* last_gained_focus_;
   Window* last_lost_focus_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(FocusChangeObserver);
 };
 
+bool WaitForWindowToHaveFocus(Window* window) {
+  if (window->HasFocus())
+    return true;
+  FocusChangeObserver observer(window);
+  return WindowServerTestBase::DoRunLoopWithTimeout();
+}
+
 }  // namespace
 
 TEST_F(WindowServerTest, Focus) {
   Window* window1 = window_manager()->NewWindow();
   window1->SetVisible(true);
   window_manager()->GetRoot()->AddChild(window1);
 
   WindowTreeConnection* embedded = Embed(window1).connection;
   ASSERT_NE(nullptr, embedded);
   Window* window11 = embedded->NewWindow();
@@ skipping 14 matching lines @@
     FocusChangeObserver observer(window11);
     window11->SetFocus();
     ASSERT_TRUE(DoRunLoopWithTimeout());
     ASSERT_NE(nullptr, observer.last_gained_focus());
     ASSERT_NE(nullptr, observer.last_lost_focus());
     EXPECT_EQ(window11->id(), observer.last_gained_focus()->id());
     EXPECT_EQ(embedded->GetRoot()->id(), observer.last_lost_focus()->id());
   }
   {
     // Add an observer on the Window that loses focus, and make sure the
-    // observer
-    // sees the right values.
+    // observer sees the right values.
     FocusChangeObserver observer(window11);
     embedded->GetRoot()->SetFocus();
     ASSERT_TRUE(DoRunLoopWithTimeout());
     ASSERT_NE(nullptr, observer.last_gained_focus());
     ASSERT_NE(nullptr, observer.last_lost_focus());
     EXPECT_EQ(window11->id(), observer.last_lost_focus()->id());
     EXPECT_EQ(embedded->GetRoot()->id(), observer.last_gained_focus()->id());
   }
 }
 
+TEST_F(WindowServerTest, Activation) {
+  Window* parent =
+      NewVisibleWindow(window_manager()->GetRoot(), window_manager());
+  Window* child1 = NewVisibleWindow(parent, window_manager());
+  Window* child2 = NewVisibleWindow(parent, window_manager());
+  Window* child3 = NewVisibleWindow(parent, window_manager());
+
+  child1->AddTransientWindow(child3);
+
+  WindowTreeConnection* embedded1 = Embed(child1).connection;
+  ASSERT_NE(nullptr, embedded1);
+  WindowTreeConnection* embedded2 = Embed(child2).connection;
+  ASSERT_NE(nullptr, embedded2);
+
+  Window* child11 = NewVisibleWindow(embedded1->GetRoot(), embedded1);
+  Window* child21 = NewVisibleWindow(embedded2->GetRoot(), embedded2);
+
+  WaitForTreeSizeToMatch(parent, 6);
+
+  // Allow the child windows to be activated.
+  host()->AddActivationParent(parent->id());
+
+  // |child2| and |child3| are stacked about |child1|.
+  EXPECT_GT(ValidIndexOf(parent->children(), child2),
+            ValidIndexOf(parent->children(), child1));
+  EXPECT_GT(ValidIndexOf(parent->children(), child3),
+            ValidIndexOf(parent->children(), child1));
+
+  // Set focus on |child11|. This should activate |child1|, and raise it over
+  // |child2|. But |child3| should still be above |child1| because of
+  // transiency.
+  child11->SetFocus();
+  ASSERT_TRUE(WaitForWindowToHaveFocus(child11));
+  ASSERT_TRUE(
+      WaitForWindowToHaveFocus(window_manager()->GetWindowById(child11->id())));
+  EXPECT_EQ(child11->id(), window_manager()->GetFocusedWindow()->id());
+  EXPECT_EQ(child11->id(), embedded1->GetFocusedWindow()->id());
+  EXPECT_EQ(nullptr, embedded2->GetFocusedWindow());
+  EXPECT_GT(ValidIndexOf(parent->children(), child1),
+            ValidIndexOf(parent->children(), child2));
+  EXPECT_GT(ValidIndexOf(parent->children(), child3),
+            ValidIndexOf(parent->children(), child1));
+
+  // Set focus on |child21|. This should activate |child2|, and raise it over
+  // |child1|.
+  child21->SetFocus();
+  ASSERT_TRUE(WaitForWindowToHaveFocus(child21));
+  ASSERT_TRUE(
+      WaitForWindowToHaveFocus(window_manager()->GetWindowById(child21->id())));
+  EXPECT_EQ(child21->id(), window_manager()->GetFocusedWindow()->id());
+  EXPECT_EQ(child21->id(), embedded2->GetFocusedWindow()->id());
+  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));
+}
+
 namespace {
 
 class DestroyedChangedObserver : public WindowObserver {
  public:
   DestroyedChangedObserver(WindowServerTestBase* test,
                            Window* window,
                            bool* got_destroy)
       : test_(test), window_(window), got_destroy_(got_destroy) {
     window_->AddObserver(this);
   }
@@ skipping 220 matching lines @@
   WaitForBoundsToChange(embedded_connection->GetRoot());
   EXPECT_TRUE(gfx::Rect(21, 22, 23, 24) ==
               embedded_connection->GetRoot()->bounds());
   EXPECT_TRUE(gfx::Insets(1, 2, 3, 4) ==
               embedded_connection->GetRoot()->client_area());
 }
 
 }  // namespace ws
 
 }  // namespace mus