Promotes remaining global window manager state into WindowManagerState

components/mus/ws/display_unittest.cc

Index: components/mus/ws/display_unittest.cc
diff --git a/components/mus/ws/display_unittest.cc b/components/mus/ws/display_unittest.cc
index eef1da6d9a83889b424014ca82d17b3415b9ce60..a06a3b02f62c741acdfe0835f95d61b6183888c5 100644
--- a/components/mus/ws/display_unittest.cc
+++ b/components/mus/ws/display_unittest.cc
@@ -18,6 +18,7 @@
 #include "components/mus/ws/platform_display_factory.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/test_utils.h"
+#include "components/mus/ws/window_manager_display_root.h"
 #include "components/mus/ws/window_manager_state.h"
 #include "components/mus/ws/window_server.h"
 #include "components/mus/ws/window_server_delegate.h"
@@ -38,6 +39,13 @@ ClientWindowId ClientWindowIdForFirstRoot(WindowTree* tree) {
   return ClientWindowIdForWindow(tree, *tree->roots().begin());
 }
 
+WindowManagerState* GetWindowManagerStateForUser(Display* display,
+                                                 const UserId& user_id) {
+  WindowManagerDisplayRoot* display_root =
+      display->GetWindowManagerDisplayRootForUser(user_id);
+  return display_root ? display_root->window_manager_state() : nullptr;
+}
+
 }  // namespace
 
 // -----------------------------------------------------------------------------
@@ -85,8 +93,8 @@ TEST_F(DisplayTest, CallsCreateDefaultDisplays) {
   // Each host should have a WindowManagerState for kTestId1.
   for (Display* display : display_manager->displays()) {
     EXPECT_EQ(1u, display->num_window_manger_states());
-    EXPECT_TRUE(display->GetWindowManagerStateForUser(kTestId1));
-    EXPECT_FALSE(display->GetWindowManagerStateForUser(kTestId2));
+    EXPECT_TRUE(GetWindowManagerStateForUser(display, kTestId1));
+    EXPECT_FALSE(GetWindowManagerStateForUser(display, kTestId2));
   }
 
   // Add another registry, should trigger creation of another wm.
@@ -95,15 +103,15 @@ TEST_F(DisplayTest, CallsCreateDefaultDisplays) {
       .Add(kTestId2);
   for (Display* display : display_manager->displays()) {
     ASSERT_EQ(2u, display->num_window_manger_states());
-    WindowManagerState* state1 =
-        display->GetWindowManagerStateForUser(kTestId1);
-    ASSERT_TRUE(state1);
-    WindowManagerState* state2 =
-        display->GetWindowManagerStateForUser(kTestId2);
-    ASSERT_TRUE(state2);
+    WindowManagerDisplayRoot* root1 =
+        display->GetWindowManagerDisplayRootForUser(kTestId1);
+    ASSERT_TRUE(root1);
+    WindowManagerDisplayRoot* root2 =
+        display->GetWindowManagerDisplayRootForUser(kTestId2);
+    ASSERT_TRUE(root2);
     // Verify the two states have different roots.
-    EXPECT_NE(state1, state2);
-    EXPECT_NE(state1->root(), state2->root());
+    EXPECT_NE(root1, root2);
+    EXPECT_NE(root1->root(), root2->root());
   }
 }
 
@@ -128,20 +136,20 @@ TEST_F(DisplayTest, Destruction) {
   EXPECT_EQ(2u, window_server_->num_trees());
 
   {
-    WindowManagerState* state = display->GetWindowManagerStateForUser(kTestId1);
+    WindowManagerState* state = GetWindowManagerStateForUser(display, kTestId1);
     // Destroy the tree associated with |state|. Should result in deleting
     // |state|.
-    window_server_->DestroyTree(state->tree());
+    window_server_->DestroyTree(state->window_tree());
     ASSERT_EQ(1u, display->num_window_manger_states());
-    EXPECT_FALSE(display->GetWindowManagerStateForUser(kTestId1));
+    EXPECT_FALSE(GetWindowManagerStateForUser(display, kTestId1));
     EXPECT_EQ(1u, display_manager->displays().size());
     EXPECT_EQ(1u, window_server_->num_trees());
   }
 
   EXPECT_FALSE(window_server_delegate_.got_on_no_more_displays());
-  // Destroy the Display, which should shutdown the trees.
   window_server_->display_manager()->DestroyDisplay(display);
-  EXPECT_EQ(0u, window_server_->num_trees());
+  // There is still one tree left.
+  EXPECT_EQ(1u, window_server_->num_trees());
   EXPECT_TRUE(window_server_delegate_.got_on_no_more_displays());
 }
 
@@ -162,7 +170,8 @@ TEST_F(DisplayTest, EventStateResetOnUserSwitch) {
   DisplayManager* display_manager = window_server_->display_manager();
   ASSERT_EQ(1u, display_manager->displays().size());
   Display* display = *display_manager->displays().begin();
-  WindowManagerState* active_wms = display->GetActiveWindowManagerState();
+  WindowManagerState* active_wms =
+      display->GetActiveWindowManagerDisplayRoot()->window_manager_state();
   ASSERT_TRUE(active_wms);
   EXPECT_EQ(kTestId1, active_wms->user_id());
 
@@ -179,10 +188,13 @@ TEST_F(DisplayTest, EventStateResetOnUserSwitch) {
   // Switch the user. Should trigger resetting state in old event dispatcher
   // and update state in new event dispatcher.
   window_server_->user_id_tracker()->SetActiveUserId(kTestId2);
-  EXPECT_NE(active_wms, display->GetActiveWindowManagerState());
+  EXPECT_NE(
+      active_wms,
+      display->GetActiveWindowManagerDisplayRoot()->window_manager_state());
   EXPECT_FALSE(EventDispatcherTestApi(active_wms->event_dispatcher())
                    .AreAnyPointersDown());
-  active_wms = display->GetActiveWindowManagerState();
+  active_wms =
+      display->GetActiveWindowManagerDisplayRoot()->window_manager_state();
   EXPECT_EQ(kTestId2, active_wms->user_id());
   EXPECT_EQ(gfx::Point(20, 25),
             active_wms->event_dispatcher()->mouse_pointer_last_location());
@@ -206,12 +218,12 @@ TEST_F(DisplayTest, SetCaptureFromWindowManager) {
   ASSERT_EQ(1u, display_manager->displays().size());
   Display* display = *display_manager->displays().begin();
   WindowManagerState* wms_for_id2 =
-      display->GetWindowManagerStateForUser(kTestId2);
+      GetWindowManagerStateForUser(display, kTestId2);
   ASSERT_TRUE(wms_for_id2);
   EXPECT_FALSE(wms_for_id2->IsActive());
 
   // Create a child of the root that we can set capture on.
-  WindowTree* tree = wms_for_id2->tree();
+  WindowTree* tree = wms_for_id2->window_tree();
   ClientWindowId child_window_id;
   ASSERT_TRUE(NewWindowInTree(tree, &child_window_id));
 
@@ -244,27 +256,27 @@ TEST_F(DisplayTest, FocusFailsForInactiveUser) {
   ASSERT_EQ(1u, display_manager->displays().size());
   Display* display = *display_manager->displays().begin();
   WindowManagerState* wms_for_id2 =
-      display->GetWindowManagerStateForUser(kTestId2);
-  wms_for_id2->tree()->AddActivationParent(
-      ClientWindowIdForFirstRoot(wms_for_id2->tree()));
+      GetWindowManagerStateForUser(display, kTestId2);
+  wms_for_id2->window_tree()->AddActivationParent(
+      ClientWindowIdForFirstRoot(wms_for_id2->window_tree()));
   ASSERT_TRUE(wms_for_id2);
   EXPECT_FALSE(wms_for_id2->IsActive());
   ClientWindowId child2_id;
-  NewWindowInTree(wms_for_id2->tree(), &child2_id);
+  NewWindowInTree(wms_for_id2->window_tree(), &child2_id);
 
   // Focus should fail for windows in inactive window managers.
-  EXPECT_FALSE(wms_for_id2->tree()->SetFocus(child2_id));
+  EXPECT_FALSE(wms_for_id2->window_tree()->SetFocus(child2_id));
 
   // Focus should succeed for the active window manager.
   WindowManagerState* wms_for_id1 =
-      display->GetWindowManagerStateForUser(kTestId1);
+      GetWindowManagerStateForUser(display, kTestId1);
   ASSERT_TRUE(wms_for_id1);
-  wms_for_id1->tree()->AddActivationParent(
-      ClientWindowIdForFirstRoot(wms_for_id1->tree()));
+  wms_for_id1->window_tree()->AddActivationParent(
+      ClientWindowIdForFirstRoot(wms_for_id1->window_tree()));
   ClientWindowId child1_id;
-  NewWindowInTree(wms_for_id1->tree(), &child1_id);
+  NewWindowInTree(wms_for_id1->window_tree(), &child1_id);
   EXPECT_TRUE(wms_for_id1->IsActive());
-  EXPECT_TRUE(wms_for_id1->tree()->SetFocus(child1_id));
+  EXPECT_TRUE(wms_for_id1->window_tree()->SetFocus(child1_id));
 }
 
 // Verifies a single tree is used for multiple displays.
@@ -288,11 +300,13 @@ TEST_F(DisplayTest, MultipleDisplays) {
   ASSERT_NE(root1, root2);
   Display* display1 = tree->GetDisplay(root1);
   WindowManagerState* display1_wms =
-      display1->GetWindowManagerStateForUser(kTestId1);
+      display1->GetWindowManagerDisplayRootForUser(kTestId1)
+          ->window_manager_state();
   Display* display2 = tree->GetDisplay(root2);
   WindowManagerState* display2_wms =
-      display2->GetWindowManagerStateForUser(kTestId1);
-  EXPECT_EQ(display1_wms->tree(), display2_wms->tree());
+      display2->GetWindowManagerDisplayRootForUser(kTestId1)
+          ->window_manager_state();
+  EXPECT_EQ(display1_wms->window_tree(), display2_wms->window_tree());
 }
 
 }  // namespace test