| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include <stdint.h> | |
| 6 | |
| 7 #include <string> | |
| 8 | |
| 9 #include "base/macros.h" | |
| 10 #include "base/message_loop/message_loop.h" | |
| 11 #include "components/mus/common/types.h" | |
| 12 #include "components/mus/common/util.h" | |
| 13 #include "components/mus/public/interfaces/window_tree.mojom.h" | |
| 14 #include "components/mus/surfaces/surfaces_state.h" | |
| 15 #include "components/mus/ws/display_manager.h" | |
| 16 #include "components/mus/ws/ids.h" | |
| 17 #include "components/mus/ws/platform_display.h" | |
| 18 #include "components/mus/ws/platform_display_factory.h" | |
| 19 #include "components/mus/ws/server_window.h" | |
| 20 #include "components/mus/ws/test_utils.h" | |
| 21 #include "components/mus/ws/window_manager_display_root.h" | |
| 22 #include "components/mus/ws/window_manager_state.h" | |
| 23 #include "components/mus/ws/window_server.h" | |
| 24 #include "components/mus/ws/window_server_delegate.h" | |
| 25 #include "components/mus/ws/window_tree.h" | |
| 26 #include "components/mus/ws/window_tree_binding.h" | |
| 27 #include "testing/gtest/include/gtest/gtest.h" | |
| 28 #include "ui/events/event.h" | |
| 29 #include "ui/gfx/geometry/rect.h" | |
| 30 | |
| 31 namespace mus { | |
| 32 namespace ws { | |
| 33 namespace test { | |
| 34 namespace { | |
| 35 | |
| 36 const UserId kTestId1 = "2"; | |
| 37 const UserId kTestId2 = "21"; | |
| 38 | |
| 39 ClientWindowId ClientWindowIdForFirstRoot(WindowTree* tree) { | |
| 40 if (tree->roots().empty()) | |
| 41 return ClientWindowId(); | |
| 42 return ClientWindowIdForWindow(tree, *tree->roots().begin()); | |
| 43 } | |
| 44 | |
| 45 WindowManagerState* GetWindowManagerStateForUser(Display* display, | |
| 46 const UserId& user_id) { | |
| 47 WindowManagerDisplayRoot* display_root = | |
| 48 display->GetWindowManagerDisplayRootForUser(user_id); | |
| 49 return display_root ? display_root->window_manager_state() : nullptr; | |
| 50 } | |
| 51 | |
| 52 } // namespace | |
| 53 | |
| 54 // ----------------------------------------------------------------------------- | |
| 55 | |
| 56 class DisplayTest : public testing::Test { | |
| 57 public: | |
| 58 DisplayTest() : cursor_id_(0), platform_display_factory_(&cursor_id_) {} | |
| 59 ~DisplayTest() override {} | |
| 60 | |
| 61 protected: | |
| 62 // testing::Test: | |
| 63 void SetUp() override { | |
| 64 PlatformDisplay::set_factory_for_testing(&platform_display_factory_); | |
| 65 window_server_.reset(new WindowServer(&window_server_delegate_, | |
| 66 scoped_refptr<SurfacesState>())); | |
| 67 window_server_delegate_.set_window_server(window_server_.get()); | |
| 68 window_server_->user_id_tracker()->AddUserId(kTestId1); | |
| 69 window_server_->user_id_tracker()->AddUserId(kTestId2); | |
| 70 } | |
| 71 | |
| 72 protected: | |
| 73 int32_t cursor_id_; | |
| 74 TestPlatformDisplayFactory platform_display_factory_; | |
| 75 TestWindowServerDelegate window_server_delegate_; | |
| 76 std::unique_ptr<WindowServer> window_server_; | |
| 77 base::MessageLoop message_loop_; | |
| 78 | |
| 79 private: | |
| 80 DISALLOW_COPY_AND_ASSIGN(DisplayTest); | |
| 81 }; | |
| 82 | |
| 83 TEST_F(DisplayTest, CallsCreateDefaultDisplays) { | |
| 84 const int kNumHostsToCreate = 2; | |
| 85 window_server_delegate_.set_num_displays_to_create(kNumHostsToCreate); | |
| 86 | |
| 87 DisplayManager* display_manager = window_server_->display_manager(); | |
| 88 WindowManagerWindowTreeFactorySetTestApi( | |
| 89 window_server_->window_manager_window_tree_factory_set()) | |
| 90 .Add(kTestId1); | |
| 91 // The first register should trigger creation of the default | |
| 92 // Displays. There should be kNumHostsToCreate Displays. | |
| 93 EXPECT_EQ(static_cast<size_t>(kNumHostsToCreate), | |
| 94 display_manager->displays().size()); | |
| 95 | |
| 96 // Each host should have a WindowManagerState for kTestId1. | |
| 97 for (Display* display : display_manager->displays()) { | |
| 98 EXPECT_EQ(1u, display->num_window_manger_states()); | |
| 99 EXPECT_TRUE(GetWindowManagerStateForUser(display, kTestId1)); | |
| 100 EXPECT_FALSE(GetWindowManagerStateForUser(display, kTestId2)); | |
| 101 } | |
| 102 | |
| 103 // Add another registry, should trigger creation of another wm. | |
| 104 WindowManagerWindowTreeFactorySetTestApi( | |
| 105 window_server_->window_manager_window_tree_factory_set()) | |
| 106 .Add(kTestId2); | |
| 107 for (Display* display : display_manager->displays()) { | |
| 108 ASSERT_EQ(2u, display->num_window_manger_states()); | |
| 109 WindowManagerDisplayRoot* root1 = | |
| 110 display->GetWindowManagerDisplayRootForUser(kTestId1); | |
| 111 ASSERT_TRUE(root1); | |
| 112 WindowManagerDisplayRoot* root2 = | |
| 113 display->GetWindowManagerDisplayRootForUser(kTestId2); | |
| 114 ASSERT_TRUE(root2); | |
| 115 // Verify the two states have different roots. | |
| 116 EXPECT_NE(root1, root2); | |
| 117 EXPECT_NE(root1->root(), root2->root()); | |
| 118 } | |
| 119 } | |
| 120 | |
| 121 TEST_F(DisplayTest, Destruction) { | |
| 122 window_server_delegate_.set_num_displays_to_create(1); | |
| 123 | |
| 124 WindowManagerWindowTreeFactorySetTestApi( | |
| 125 window_server_->window_manager_window_tree_factory_set()) | |
| 126 .Add(kTestId1); | |
| 127 | |
| 128 // Add another registry, should trigger creation of another wm. | |
| 129 DisplayManager* display_manager = window_server_->display_manager(); | |
| 130 WindowManagerWindowTreeFactorySetTestApi( | |
| 131 window_server_->window_manager_window_tree_factory_set()) | |
| 132 .Add(kTestId2); | |
| 133 ASSERT_EQ(1u, display_manager->displays().size()); | |
| 134 Display* display = *display_manager->displays().begin(); | |
| 135 ASSERT_EQ(2u, display->num_window_manger_states()); | |
| 136 // There should be two trees, one for each windowmanager. | |
| 137 EXPECT_EQ(2u, window_server_->num_trees()); | |
| 138 | |
| 139 { | |
| 140 WindowManagerState* state = GetWindowManagerStateForUser(display, kTestId1); | |
| 141 // Destroy the tree associated with |state|. Should result in deleting | |
| 142 // |state|. | |
| 143 window_server_->DestroyTree(state->window_tree()); | |
| 144 ASSERT_EQ(1u, display->num_window_manger_states()); | |
| 145 EXPECT_FALSE(GetWindowManagerStateForUser(display, kTestId1)); | |
| 146 EXPECT_EQ(1u, display_manager->displays().size()); | |
| 147 EXPECT_EQ(1u, window_server_->num_trees()); | |
| 148 } | |
| 149 | |
| 150 EXPECT_FALSE(window_server_delegate_.got_on_no_more_displays()); | |
| 151 window_server_->display_manager()->DestroyDisplay(display); | |
| 152 // There is still one tree left. | |
| 153 EXPECT_EQ(1u, window_server_->num_trees()); | |
| 154 EXPECT_TRUE(window_server_delegate_.got_on_no_more_displays()); | |
| 155 } | |
| 156 | |
| 157 TEST_F(DisplayTest, EventStateResetOnUserSwitch) { | |
| 158 window_server_delegate_.set_num_displays_to_create(1); | |
| 159 | |
| 160 WindowManagerWindowTreeFactorySetTestApi( | |
| 161 window_server_->window_manager_window_tree_factory_set()) | |
| 162 .Add(kTestId1); | |
| 163 WindowManagerWindowTreeFactorySetTestApi( | |
| 164 window_server_->window_manager_window_tree_factory_set()) | |
| 165 .Add(kTestId2); | |
| 166 | |
| 167 window_server_->user_id_tracker()->SetActiveUserId(kTestId1); | |
| 168 | |
| 169 DisplayManager* display_manager = window_server_->display_manager(); | |
| 170 ASSERT_EQ(1u, display_manager->displays().size()); | |
| 171 Display* display = *display_manager->displays().begin(); | |
| 172 WindowManagerState* active_wms = | |
| 173 display->GetActiveWindowManagerDisplayRoot()->window_manager_state(); | |
| 174 ASSERT_TRUE(active_wms); | |
| 175 EXPECT_EQ(kTestId1, active_wms->user_id()); | |
| 176 | |
| 177 static_cast<PlatformDisplayDelegate*>(display)->OnEvent(ui::PointerEvent( | |
| 178 ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(20, 25), | |
| 179 gfx::Point(20, 25), base::TimeTicks(), | |
| 180 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON))); | |
| 181 | |
| 182 EXPECT_TRUE(EventDispatcherTestApi(active_wms->event_dispatcher()) | |
| 183 .AreAnyPointersDown()); | |
| 184 EXPECT_EQ(gfx::Point(20, 25), | |
| 185 active_wms->event_dispatcher()->mouse_pointer_last_location()); | |
| 186 | |
| 187 // Switch the user. Should trigger resetting state in old event dispatcher | |
| 188 // and update state in new event dispatcher. | |
| 189 window_server_->user_id_tracker()->SetActiveUserId(kTestId2); | |
| 190 EXPECT_NE( | |
| 191 active_wms, | |
| 192 display->GetActiveWindowManagerDisplayRoot()->window_manager_state()); | |
| 193 EXPECT_FALSE(EventDispatcherTestApi(active_wms->event_dispatcher()) | |
| 194 .AreAnyPointersDown()); | |
| 195 active_wms = | |
| 196 display->GetActiveWindowManagerDisplayRoot()->window_manager_state(); | |
| 197 EXPECT_EQ(kTestId2, active_wms->user_id()); | |
| 198 EXPECT_EQ(gfx::Point(20, 25), | |
| 199 active_wms->event_dispatcher()->mouse_pointer_last_location()); | |
| 200 EXPECT_FALSE(EventDispatcherTestApi(active_wms->event_dispatcher()) | |
| 201 .AreAnyPointersDown()); | |
| 202 } | |
| 203 | |
| 204 // Verifies capture fails when wm is inactive and succeeds when wm is active. | |
| 205 TEST_F(DisplayTest, SetCaptureFromWindowManager) { | |
| 206 window_server_delegate_.set_num_displays_to_create(1); | |
| 207 WindowManagerWindowTreeFactorySetTestApi( | |
| 208 window_server_->window_manager_window_tree_factory_set()) | |
| 209 .Add(kTestId1); | |
| 210 WindowManagerWindowTreeFactorySetTestApi( | |
| 211 window_server_->window_manager_window_tree_factory_set()) | |
| 212 .Add(kTestId2); | |
| 213 window_server_->user_id_tracker()->SetActiveUserId(kTestId1); | |
| 214 DisplayManager* display_manager = window_server_->display_manager(); | |
| 215 ASSERT_EQ(1u, display_manager->displays().size()); | |
| 216 Display* display = *display_manager->displays().begin(); | |
| 217 WindowManagerState* wms_for_id2 = | |
| 218 GetWindowManagerStateForUser(display, kTestId2); | |
| 219 ASSERT_TRUE(wms_for_id2); | |
| 220 EXPECT_FALSE(wms_for_id2->IsActive()); | |
| 221 | |
| 222 // Create a child of the root that we can set capture on. | |
| 223 WindowTree* tree = wms_for_id2->window_tree(); | |
| 224 ClientWindowId child_window_id; | |
| 225 ASSERT_TRUE(NewWindowInTree(tree, &child_window_id)); | |
| 226 | |
| 227 WindowTreeTestApi(tree).EnableCapture(); | |
| 228 | |
| 229 // SetCapture() should fail for user id2 as it is inactive. | |
| 230 EXPECT_FALSE(tree->SetCapture(child_window_id)); | |
| 231 | |
| 232 // Make the second user active and verify capture works. | |
| 233 window_server_->user_id_tracker()->SetActiveUserId(kTestId2); | |
| 234 EXPECT_TRUE(wms_for_id2->IsActive()); | |
| 235 EXPECT_TRUE(tree->SetCapture(child_window_id)); | |
| 236 } | |
| 237 | |
| 238 TEST_F(DisplayTest, FocusFailsForInactiveUser) { | |
| 239 window_server_delegate_.set_num_displays_to_create(1); | |
| 240 WindowManagerWindowTreeFactorySetTestApi( | |
| 241 window_server_->window_manager_window_tree_factory_set()) | |
| 242 .Add(kTestId1); | |
| 243 TestWindowTreeClient* window_tree_client1 = | |
| 244 window_server_delegate_.last_client(); | |
| 245 ASSERT_TRUE(window_tree_client1); | |
| 246 WindowManagerWindowTreeFactorySetTestApi( | |
| 247 window_server_->window_manager_window_tree_factory_set()) | |
| 248 .Add(kTestId2); | |
| 249 window_server_->user_id_tracker()->SetActiveUserId(kTestId1); | |
| 250 DisplayManager* display_manager = window_server_->display_manager(); | |
| 251 ASSERT_EQ(1u, display_manager->displays().size()); | |
| 252 Display* display = *display_manager->displays().begin(); | |
| 253 WindowManagerState* wms_for_id2 = | |
| 254 GetWindowManagerStateForUser(display, kTestId2); | |
| 255 wms_for_id2->window_tree()->AddActivationParent( | |
| 256 ClientWindowIdForFirstRoot(wms_for_id2->window_tree())); | |
| 257 ASSERT_TRUE(wms_for_id2); | |
| 258 EXPECT_FALSE(wms_for_id2->IsActive()); | |
| 259 ClientWindowId child2_id; | |
| 260 NewWindowInTree(wms_for_id2->window_tree(), &child2_id); | |
| 261 | |
| 262 // Focus should fail for windows in inactive window managers. | |
| 263 EXPECT_FALSE(wms_for_id2->window_tree()->SetFocus(child2_id)); | |
| 264 | |
| 265 // Focus should succeed for the active window manager. | |
| 266 WindowManagerState* wms_for_id1 = | |
| 267 GetWindowManagerStateForUser(display, kTestId1); | |
| 268 ASSERT_TRUE(wms_for_id1); | |
| 269 wms_for_id1->window_tree()->AddActivationParent( | |
| 270 ClientWindowIdForFirstRoot(wms_for_id1->window_tree())); | |
| 271 ClientWindowId child1_id; | |
| 272 NewWindowInTree(wms_for_id1->window_tree(), &child1_id); | |
| 273 EXPECT_TRUE(wms_for_id1->IsActive()); | |
| 274 EXPECT_TRUE(wms_for_id1->window_tree()->SetFocus(child1_id)); | |
| 275 } | |
| 276 | |
| 277 // Verifies a single tree is used for multiple displays. | |
| 278 TEST_F(DisplayTest, MultipleDisplays) { | |
| 279 window_server_delegate_.set_num_displays_to_create(2); | |
| 280 WindowManagerWindowTreeFactorySetTestApi( | |
| 281 window_server_->window_manager_window_tree_factory_set()) | |
| 282 .Add(kTestId1); | |
| 283 window_server_->user_id_tracker()->SetActiveUserId(kTestId1); | |
| 284 ASSERT_EQ(1u, window_server_delegate_.bindings()->size()); | |
| 285 TestWindowTreeBinding* window_tree_binding = | |
| 286 (*window_server_delegate_.bindings())[0]; | |
| 287 WindowTree* tree = window_tree_binding->tree(); | |
| 288 ASSERT_EQ(2u, tree->roots().size()); | |
| 289 std::set<const ServerWindow*> roots = tree->roots(); | |
| 290 auto it = roots.begin(); | |
| 291 ServerWindow* root1 = tree->GetWindow((*it)->id()); | |
| 292 ++it; | |
| 293 ServerWindow* root2 = tree->GetWindow((*it)->id()); | |
| 294 ASSERT_NE(root1, root2); | |
| 295 Display* display1 = tree->GetDisplay(root1); | |
| 296 WindowManagerState* display1_wms = | |
| 297 display1->GetWindowManagerDisplayRootForUser(kTestId1) | |
| 298 ->window_manager_state(); | |
| 299 Display* display2 = tree->GetDisplay(root2); | |
| 300 WindowManagerState* display2_wms = | |
| 301 display2->GetWindowManagerDisplayRootForUser(kTestId1) | |
| 302 ->window_manager_state(); | |
| 303 EXPECT_EQ(display1_wms->window_tree(), display2_wms->window_tree()); | |
| 304 } | |
| 305 | |
| 306 } // namespace test | |
| 307 } // namespace ws | |
| 308 } // namespace mus | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2119963002:
Move mus to //services/ui (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master