1 // Copyright 2013 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 "ash/root_window_controller.h" 6 #include "ash/shelf/shelf_widget.h" 7 #include "ash/shell.h" 8 #include "ash/shell_window_ids.h" 9 #include "ash/test/ash_test_base.h" 10 #include "ash/test/test_session_state_delegate.h" 11 #include "ash/test/test_shell_delegate.h" 12 #include "ash/wm/maximize_mode/maximize_mode_controller.h" 13 #include "ash/wm/maximize_mode/maximize_mode_window_manager.h" 14 #include "ash/wm/window_state.h" 15 #include "ash/wm/wm_event.h" 16 #include "base/command_line.h" 17 #include "base/compiler_specific.h" 18 #include "base/logging.h" 19 #include "base/strings/string_util.h" 20 #include "base/time/time.h" 21 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h" 22 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager_chromeos.h" 23 #include "chrome/browser/ui/ash/multi_user/user_switch_animator_chromeos.h" 24 #include "chrome/test/base/testing_profile.h" 25 #include "components/user_manager/user_info.h" 26 #include "ui/aura/client/aura_constants.h" 27 #include "ui/aura/window_event_dispatcher.h" 28 #include "ui/base/ui_base_types.h" 29 #include "ui/wm/core/window_util.h" 30 #include "ui/wm/public/activation_client.h" 31 32 namespace ash { 33 namespace test { 34 35 // A test class for preparing the chrome::MultiUserWindowManager. It creates 36 // various windows and instantiates the chrome::MultiUserWindowManager. 37 class MultiUserWindowManagerChromeOSTest : public AshTestBase { 38 public: 39 MultiUserWindowManagerChromeOSTest() 40 : multi_user_window_manager_(NULL), 41 session_state_delegate_(NULL) {} 42 43 virtual void SetUp() OVERRIDE; 44 virtual void TearDown() OVERRIDE; 45 46 protected: 47 // Set up the test environment for this many windows. 48 void SetUpForThisManyWindows(int windows); 49 50 // Switch the user and wait until the animation is finished. 51 void SwitchUserAndWaitForAnimation(const std::string& user_id) { 52 multi_user_window_manager_->ActiveUserChanged(user_id); 53 base::TimeTicks now = base::TimeTicks::Now(); 54 while (multi_user_window_manager_->IsAnimationRunningForTest()) { 55 // This should never take longer then a second. 56 ASSERT_GE(1000, (base::TimeTicks::Now() - now).InMilliseconds()); 57 base::MessageLoop::current()->RunUntilIdle(); 58 } 59 } 60 61 // Return the window with the given index. 62 aura::Window* window(size_t index) { 63 DCHECK(index < window_.size()); 64 return window_[index]; 65 } 66 67 // Delete the window at the given index, and set the referefence to NULL. 68 void delete_window_at(size_t index) { 69 delete window_[index]; 70 window_[index] = NULL; 71 } 72 73 // The accessor to the MultiWindowManager. 74 chrome::MultiUserWindowManagerChromeOS* multi_user_window_manager() { 75 return multi_user_window_manager_; 76 } 77 78 // Returns a list of all open windows in the following form: 79 // "<H(idden)/S(hown)/D(eleted)>[<Owner>[,<shownForUser>]], .." 80 // Like: "S[B], .." would mean that window#0 is shown and belongs to user B. 81 // or "S[B,A], .." would mean that window#0 is shown, belongs to B but is 82 // shown by A, and "D,..." would mean that window#0 is deleted. 83 std::string GetStatus(); 84 85 // Returns a test-friendly string format of GetOwnersOfVisibleWindows(). 86 std::string GetOwnersOfVisibleWindowsAsString(); 87 88 TestSessionStateDelegate* session_state_delegate() { 89 return session_state_delegate_; 90 } 91 92 // Make a window system modal. 93 void MakeWindowSystemModal(aura::Window* window) { 94 aura::Window* system_modal_container = 95 window->GetRootWindow()->GetChildById( 96 ash::kShellWindowId_SystemModalContainer); 97 system_modal_container->AddChild(window); 98 } 99 100 void ShowWindowForUserNoUserTransition(aura::Window* window, 101 const std::string& user_id) { 102 multi_user_window_manager_->ShowWindowForUserIntern(window, user_id); 103 } 104 105 // The test session state observer does not automatically call the window 106 // manager. This function gets the current user from it and also sets it to 107 // the multi user window manager. 108 std::string GetAndValidateCurrentUserFromSessionStateObserver() { 109 const std::string& user = 110 session_state_delegate()->GetActiveUserInfo()->GetUserID(); 111 if (user != multi_user_window_manager_->GetCurrentUserForTest()) 112 multi_user_window_manager()->ActiveUserChanged(user); 113 return user; 114 } 115 116 // Initiate a user transition. 117 void StartUserTransitionAnimation(const std::string& user_id) { 118 multi_user_window_manager_->ActiveUserChanged(user_id); 119 } 120 121 // Call next animation step. 122 void AdvanceUserTransitionAnimation() { 123 multi_user_window_manager_->animation_->AdvanceUserTransitionAnimation(); 124 } 125 126 // Return the user id of the wallpaper which is currently set. 127 const std::string& GetWallaperUserIdForTest() { 128 return multi_user_window_manager_->animation_->wallpaper_user_id_for_test(); 129 } 130 131 // Returns true if the given window covers the screen. 132 bool CoversScreen(aura::Window* window) { 133 return chrome::UserSwichAnimatorChromeOS::CoversScreen( 134 window); 135 } 136 137 // Create a maximize mode window manager. 138 ash::MaximizeModeWindowManager* CreateMaximizeModeWindowManager() { 139 EXPECT_FALSE(maximize_mode_window_manager()); 140 Shell::GetInstance()->maximize_mode_controller()-> 141 EnableMaximizeModeWindowManager(true); 142 return maximize_mode_window_manager(); 143 } 144 145 ash::MaximizeModeWindowManager* maximize_mode_window_manager() { 146 return Shell::GetInstance()->maximize_mode_controller()-> 147 maximize_mode_window_manager_.get(); 148 } 149 150 private: 151 // These get created for each session. 152 std::vector<aura::Window*> window_; 153 154 // The instance of the MultiUserWindowManager. 155 chrome::MultiUserWindowManagerChromeOS* multi_user_window_manager_; 156 157 // The session state delegate. 158 ash::test::TestSessionStateDelegate* session_state_delegate_; 159 160 // The maximized window manager (if enabled). 161 scoped_ptr<MaximizeModeWindowManager> maximize_mode_window_manager_; 162 163 DISALLOW_COPY_AND_ASSIGN(MultiUserWindowManagerChromeOSTest); 164 }; 165 166 void MultiUserWindowManagerChromeOSTest::SetUp() { 167 AshTestBase::SetUp(); 168 session_state_delegate_ = 169 static_cast<TestSessionStateDelegate*> ( 170 ash::Shell::GetInstance()->session_state_delegate()); 171 session_state_delegate_->AddUser("a"); 172 session_state_delegate_->AddUser("b"); 173 session_state_delegate_->AddUser("c"); 174 } 175 176 void MultiUserWindowManagerChromeOSTest::SetUpForThisManyWindows(int windows) { 177 DCHECK(!window_.size()); 178 for (int i = 0; i < windows; i++) { 179 window_.push_back(CreateTestWindowInShellWithId(i)); 180 window_[i]->Show(); 181 } 182 multi_user_window_manager_ = new chrome::MultiUserWindowManagerChromeOS("A"); 183 multi_user_window_manager_->SetAnimationSpeedForTest( 184 chrome::MultiUserWindowManagerChromeOS::ANIMATION_SPEED_DISABLED); 185 chrome::MultiUserWindowManager::SetInstanceForTest(multi_user_window_manager_, 186 chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_SEPARATED); 187 EXPECT_TRUE(multi_user_window_manager_); 188 } 189 190 void MultiUserWindowManagerChromeOSTest::TearDown() { 191 // Since the AuraTestBase is needed to create our assets, we have to 192 // also delete them before we tear it down. 193 while (!window_.empty()) { 194 delete *(window_.begin()); 195 window_.erase(window_.begin()); 196 } 197 198 chrome::MultiUserWindowManager::DeleteInstance(); 199 AshTestBase::TearDown(); 200 } 201 202 std::string MultiUserWindowManagerChromeOSTest::GetStatus() { 203 std::string s; 204 for (size_t i = 0; i < window_.size(); i++) { 205 if (i) 206 s += ", "; 207 if (!window(i)) { 208 s += "D"; 209 continue; 210 } 211 s += window(i)->IsVisible() ? "S[" : "H["; 212 const std::string& owner = 213 multi_user_window_manager_->GetWindowOwner(window(i)); 214 s += owner; 215 const std::string& presenter = 216 multi_user_window_manager_->GetUserPresentingWindow(window(i)); 217 if (!owner.empty() && owner != presenter) { 218 s += ","; 219 s += presenter; 220 } 221 s += "]"; 222 } 223 return s; 224 } 225 226 std::string 227 MultiUserWindowManagerChromeOSTest::GetOwnersOfVisibleWindowsAsString() { 228 std::set<std::string> owners; 229 multi_user_window_manager_->GetOwnersOfVisibleWindows(&owners); 230 231 std::vector<std::string> owner_list; 232 owner_list.insert(owner_list.begin(), owners.begin(), owners.end()); 233 return JoinString(owner_list, ' '); 234 } 235 236 // Testing basic assumptions like default state and existence of manager. 237 TEST_F(MultiUserWindowManagerChromeOSTest, BasicTests) { 238 SetUpForThisManyWindows(3); 239 // Check the basic assumptions: All windows are visible and there is no owner. 240 EXPECT_EQ("S[], S[], S[]", GetStatus()); 241 EXPECT_TRUE(multi_user_window_manager()); 242 EXPECT_EQ(multi_user_window_manager(), 243 chrome::MultiUserWindowManager::GetInstance()); 244 EXPECT_FALSE(multi_user_window_manager()->AreWindowsSharedAmongUsers()); 245 246 // The owner of an unowned window should be empty and it should be shown on 247 // all windows. 248 EXPECT_EQ("", multi_user_window_manager()->GetWindowOwner(window(0))); 249 EXPECT_EQ("", 250 multi_user_window_manager()->GetUserPresentingWindow(window(0))); 251 EXPECT_TRUE( 252 multi_user_window_manager()->IsWindowOnDesktopOfUser(window(0), "A")); 253 EXPECT_TRUE( 254 multi_user_window_manager()->IsWindowOnDesktopOfUser(window(0), "B")); 255 256 // Set the owner of one window should remember it as such. It should only be 257 // drawn on the owners desktop - not on any other. 258 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 259 EXPECT_EQ("A", multi_user_window_manager()->GetWindowOwner(window(0))); 260 EXPECT_EQ("A", 261 multi_user_window_manager()->GetUserPresentingWindow(window(0))); 262 EXPECT_TRUE( 263 multi_user_window_manager()->IsWindowOnDesktopOfUser(window(0), "A")); 264 EXPECT_FALSE( 265 multi_user_window_manager()->IsWindowOnDesktopOfUser(window(0), "B")); 266 267 // Overriding it with another state should show it on the other user's 268 // desktop. 269 ShowWindowForUserNoUserTransition(window(0), "B"); 270 EXPECT_EQ("A", multi_user_window_manager()->GetWindowOwner(window(0))); 271 EXPECT_EQ("B", 272 multi_user_window_manager()->GetUserPresentingWindow(window(0))); 273 EXPECT_FALSE( 274 multi_user_window_manager()->IsWindowOnDesktopOfUser(window(0), "A")); 275 EXPECT_TRUE( 276 multi_user_window_manager()->IsWindowOnDesktopOfUser(window(0), "B")); 277 } 278 279 // Testing simple owner changes. 280 TEST_F(MultiUserWindowManagerChromeOSTest, OwnerTests) { 281 SetUpForThisManyWindows(5); 282 // Set some windows to the active owner. 283 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 284 EXPECT_EQ("S[A], S[], S[], S[], S[]", GetStatus()); 285 multi_user_window_manager()->SetWindowOwner(window(2), "A"); 286 EXPECT_EQ("S[A], S[], S[A], S[], S[]", GetStatus()); 287 288 // Set some windows to an inactive owner. Note that the windows should hide. 289 multi_user_window_manager()->SetWindowOwner(window(1), "B"); 290 EXPECT_EQ("S[A], H[B], S[A], S[], S[]", GetStatus()); 291 multi_user_window_manager()->SetWindowOwner(window(3), "B"); 292 EXPECT_EQ("S[A], H[B], S[A], H[B], S[]", GetStatus()); 293 294 // Assume that the user has now changed to C - which should show / hide 295 // accordingly. 296 multi_user_window_manager()->ActiveUserChanged("C"); 297 EXPECT_EQ("H[A], H[B], H[A], H[B], S[]", GetStatus()); 298 299 // If someone tries to show an inactive window it should only work if it can 300 // be shown / hidden. 301 multi_user_window_manager()->ActiveUserChanged("A"); 302 EXPECT_EQ("S[A], H[B], S[A], H[B], S[]", GetStatus()); 303 window(3)->Show(); 304 EXPECT_EQ("S[A], H[B], S[A], H[B], S[]", GetStatus()); 305 window(2)->Hide(); 306 EXPECT_EQ("S[A], H[B], H[A], H[B], S[]", GetStatus()); 307 window(2)->Show(); 308 EXPECT_EQ("S[A], H[B], S[A], H[B], S[]", GetStatus()); 309 } 310 311 TEST_F(MultiUserWindowManagerChromeOSTest, CloseWindowTests) { 312 SetUpForThisManyWindows(1); 313 multi_user_window_manager()->SetWindowOwner(window(0), "B"); 314 EXPECT_EQ("H[B]", GetStatus()); 315 ShowWindowForUserNoUserTransition(window(0), "A"); 316 EXPECT_EQ("S[B,A]", GetStatus()); 317 EXPECT_TRUE(multi_user_window_manager()->AreWindowsSharedAmongUsers()); 318 EXPECT_EQ("B", GetOwnersOfVisibleWindowsAsString()); 319 320 aura::Window* to_be_deleted = window(0); 321 322 EXPECT_EQ(std::string("A"), 323 multi_user_window_manager()->GetUserPresentingWindow( 324 to_be_deleted)); 325 EXPECT_EQ(std::string("B"), 326 multi_user_window_manager()->GetWindowOwner( 327 to_be_deleted)); 328 329 // Close the window. 330 delete_window_at(0); 331 332 EXPECT_EQ("D", GetStatus()); 333 EXPECT_EQ("", GetOwnersOfVisibleWindowsAsString()); 334 // There should be no owner anymore for that window and the shared windows 335 // should be gone as well. 336 EXPECT_EQ(std::string(), 337 multi_user_window_manager()->GetUserPresentingWindow( 338 to_be_deleted)); 339 EXPECT_EQ(std::string(), 340 multi_user_window_manager()->GetWindowOwner( 341 to_be_deleted)); 342 } 343 344 TEST_F(MultiUserWindowManagerChromeOSTest, SharedWindowTests) { 345 SetUpForThisManyWindows(5); 346 // Set some owners and make sure we got what we asked for. 347 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 348 multi_user_window_manager()->SetWindowOwner(window(1), "A"); 349 multi_user_window_manager()->SetWindowOwner(window(2), "B"); 350 multi_user_window_manager()->SetWindowOwner(window(3), "B"); 351 multi_user_window_manager()->SetWindowOwner(window(4), "C"); 352 EXPECT_EQ("S[A], S[A], H[B], H[B], H[C]", GetStatus()); 353 EXPECT_FALSE(multi_user_window_manager()->AreWindowsSharedAmongUsers()); 354 EXPECT_EQ("A", GetOwnersOfVisibleWindowsAsString()); 355 356 // For all following tests we override window 2 to be shown by user B. 357 ShowWindowForUserNoUserTransition(window(1), "B"); 358 359 // Change window 3 between two users and see that it changes 360 // accordingly (or not). 361 ShowWindowForUserNoUserTransition(window(2), "A"); 362 EXPECT_EQ("S[A], H[A,B], S[B,A], H[B], H[C]", GetStatus()); 363 EXPECT_TRUE(multi_user_window_manager()->AreWindowsSharedAmongUsers()); 364 EXPECT_EQ("A B", GetOwnersOfVisibleWindowsAsString()); 365 ShowWindowForUserNoUserTransition(window(2), "C"); 366 EXPECT_EQ("S[A], H[A,B], H[B,C], H[B], H[C]", GetStatus()); 367 EXPECT_TRUE(multi_user_window_manager()->AreWindowsSharedAmongUsers()); 368 EXPECT_EQ("A", GetOwnersOfVisibleWindowsAsString()); 369 370 // Switch the users and see that the results are correct. 371 multi_user_window_manager()->ActiveUserChanged("B"); 372 EXPECT_EQ("H[A], S[A,B], H[B,C], S[B], H[C]", GetStatus()); 373 EXPECT_EQ("A B", GetOwnersOfVisibleWindowsAsString()); 374 multi_user_window_manager()->ActiveUserChanged("C"); 375 EXPECT_EQ("H[A], H[A,B], S[B,C], H[B], S[C]", GetStatus()); 376 EXPECT_EQ("B C", GetOwnersOfVisibleWindowsAsString()); 377 378 // Showing on the desktop of the already owning user should have no impact. 379 ShowWindowForUserNoUserTransition(window(4), "C"); 380 EXPECT_EQ("H[A], H[A,B], S[B,C], H[B], S[C]", GetStatus()); 381 EXPECT_EQ("B C", GetOwnersOfVisibleWindowsAsString()); 382 383 // Changing however a shown window back to the original owner should hide it. 384 ShowWindowForUserNoUserTransition(window(2), "B"); 385 EXPECT_EQ("H[A], H[A,B], H[B], H[B], S[C]", GetStatus()); 386 EXPECT_TRUE(multi_user_window_manager()->AreWindowsSharedAmongUsers()); 387 EXPECT_EQ("C", GetOwnersOfVisibleWindowsAsString()); 388 389 // And the change should be "permanent" - switching somewhere else and coming 390 // back. 391 multi_user_window_manager()->ActiveUserChanged("B"); 392 EXPECT_EQ("H[A], S[A,B], S[B], S[B], H[C]", GetStatus()); 393 EXPECT_EQ("A B", GetOwnersOfVisibleWindowsAsString()); 394 multi_user_window_manager()->ActiveUserChanged("C"); 395 EXPECT_EQ("H[A], H[A,B], H[B], H[B], S[C]", GetStatus()); 396 EXPECT_EQ("C", GetOwnersOfVisibleWindowsAsString()); 397 398 // After switching window 2 back to its original desktop, all desktops should 399 // be "clean" again. 400 ShowWindowForUserNoUserTransition(window(1), "A"); 401 EXPECT_FALSE(multi_user_window_manager()->AreWindowsSharedAmongUsers()); 402 } 403 404 // Make sure that adding a window to another desktop does not cause harm. 405 TEST_F(MultiUserWindowManagerChromeOSTest, DoubleSharedWindowTests) { 406 SetUpForThisManyWindows(1); 407 multi_user_window_manager()->SetWindowOwner(window(0), "B"); 408 409 // Add two references to the same window. 410 ShowWindowForUserNoUserTransition(window(0), "A"); 411 ShowWindowForUserNoUserTransition(window(0), "A"); 412 EXPECT_TRUE(multi_user_window_manager()->AreWindowsSharedAmongUsers()); 413 414 // Close the window. 415 delete_window_at(0); 416 417 EXPECT_EQ("D", GetStatus()); 418 // There should be no shares anymore open. 419 EXPECT_FALSE(multi_user_window_manager()->AreWindowsSharedAmongUsers()); 420 } 421 422 // Tests that the user's desktop visibility changes get respected. These tests 423 // are required to make sure that our usage of the same feature for showing and 424 // hiding does not interfere with the "normal operation". 425 TEST_F(MultiUserWindowManagerChromeOSTest, PreserveWindowVisibilityTests) { 426 SetUpForThisManyWindows(5); 427 // Set some owners and make sure we got what we asked for. 428 // Note that we try to cover all combinations in one go. 429 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 430 multi_user_window_manager()->SetWindowOwner(window(1), "A"); 431 multi_user_window_manager()->SetWindowOwner(window(2), "B"); 432 multi_user_window_manager()->SetWindowOwner(window(3), "B"); 433 ShowWindowForUserNoUserTransition(window(2), "A"); 434 ShowWindowForUserNoUserTransition(window(3), "A"); 435 EXPECT_EQ("S[A], S[A], S[B,A], S[B,A], S[]", GetStatus()); 436 437 // Hiding a window should be respected - no matter if it is owned by that user 438 // owned by someone else but shown on that desktop - or not owned. 439 window(0)->Hide(); 440 window(2)->Hide(); 441 window(4)->Hide(); 442 EXPECT_EQ("H[A], S[A], H[B,A], S[B,A], H[]", GetStatus()); 443 444 // Flipping to another user and back should preserve all show / hide states. 445 multi_user_window_manager()->ActiveUserChanged("B"); 446 EXPECT_EQ("H[A], H[A], H[B,A], H[B,A], H[]", GetStatus()); 447 448 multi_user_window_manager()->ActiveUserChanged("A"); 449 EXPECT_EQ("H[A], S[A], H[B,A], S[B,A], H[]", GetStatus()); 450 451 // After making them visible and switching fore and back everything should be 452 // visible. 453 window(0)->Show(); 454 window(2)->Show(); 455 window(4)->Show(); 456 EXPECT_EQ("S[A], S[A], S[B,A], S[B,A], S[]", GetStatus()); 457 458 multi_user_window_manager()->ActiveUserChanged("B"); 459 EXPECT_EQ("H[A], H[A], H[B,A], H[B,A], S[]", GetStatus()); 460 461 multi_user_window_manager()->ActiveUserChanged("A"); 462 EXPECT_EQ("S[A], S[A], S[B,A], S[B,A], S[]", GetStatus()); 463 464 // Now test that making windows visible through "normal operation" while the 465 // user's desktop is hidden leads to the correct result. 466 multi_user_window_manager()->ActiveUserChanged("B"); 467 EXPECT_EQ("H[A], H[A], H[B,A], H[B,A], S[]", GetStatus()); 468 window(0)->Show(); 469 window(2)->Show(); 470 window(4)->Show(); 471 EXPECT_EQ("H[A], H[A], H[B,A], H[B,A], S[]", GetStatus()); 472 multi_user_window_manager()->ActiveUserChanged("A"); 473 EXPECT_EQ("S[A], S[A], S[B,A], S[B,A], S[]", GetStatus()); 474 } 475 476 // Check that minimizing a window which is owned by another user will move it 477 // back and gets restored upon switching back to the original user. 478 TEST_F(MultiUserWindowManagerChromeOSTest, MinimizeChangesOwnershipBack) { 479 SetUpForThisManyWindows(4); 480 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 481 multi_user_window_manager()->SetWindowOwner(window(1), "B"); 482 multi_user_window_manager()->SetWindowOwner(window(2), "B"); 483 ShowWindowForUserNoUserTransition(window(1), "A"); 484 EXPECT_EQ("S[A], S[B,A], H[B], S[]", GetStatus()); 485 EXPECT_TRUE(multi_user_window_manager()->IsWindowOnDesktopOfUser(window(1), 486 "A")); 487 wm::GetWindowState(window(1))->Minimize(); 488 // At this time the window is still on the desktop of that user, but the user 489 // does not have a way to get to it. 490 EXPECT_EQ("S[A], H[B,A], H[B], S[]", GetStatus()); 491 EXPECT_TRUE(multi_user_window_manager()->IsWindowOnDesktopOfUser(window(1), 492 "A")); 493 EXPECT_TRUE(wm::GetWindowState(window(1))->IsMinimized()); 494 // Change to user B and make sure that minimizing does not change anything. 495 multi_user_window_manager()->ActiveUserChanged("B"); 496 EXPECT_EQ("H[A], S[B], S[B], S[]", GetStatus()); 497 EXPECT_FALSE(wm::GetWindowState(window(1))->IsMinimized()); 498 } 499 500 // Check that we cannot transfer the ownership of a minimized window. 501 TEST_F(MultiUserWindowManagerChromeOSTest, MinimizeSuppressesViewTransfer) { 502 SetUpForThisManyWindows(1); 503 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 504 wm::GetWindowState(window(0))->Minimize(); 505 EXPECT_EQ("H[A]", GetStatus()); 506 507 // Try to transfer the window to user B - which should get ignored. 508 ShowWindowForUserNoUserTransition(window(0), "B"); 509 EXPECT_EQ("H[A]", GetStatus()); 510 } 511 512 // Testing that the activation state changes to the active window. 513 TEST_F(MultiUserWindowManagerChromeOSTest, ActiveWindowTests) { 514 SetUpForThisManyWindows(4); 515 516 aura::client::ActivationClient* activation_client = 517 aura::client::GetActivationClient(window(0)->GetRootWindow()); 518 519 // Set some windows to the active owner. 520 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 521 multi_user_window_manager()->SetWindowOwner(window(1), "A"); 522 multi_user_window_manager()->SetWindowOwner(window(2), "B"); 523 multi_user_window_manager()->SetWindowOwner(window(3), "B"); 524 EXPECT_EQ("S[A], S[A], H[B], H[B]", GetStatus()); 525 526 // Set the active window for user A to be #1 527 activation_client->ActivateWindow(window(1)); 528 529 // Change to user B and make sure that one of its windows is active. 530 multi_user_window_manager()->ActiveUserChanged("B"); 531 EXPECT_EQ("H[A], H[A], S[B], S[B]", GetStatus()); 532 EXPECT_TRUE(window(3) == activation_client->GetActiveWindow() || 533 window(2) == activation_client->GetActiveWindow()); 534 // Set the active window for user B now to be #2 535 activation_client->ActivateWindow(window(2)); 536 537 multi_user_window_manager()->ActiveUserChanged("A"); 538 EXPECT_EQ(window(1), activation_client->GetActiveWindow()); 539 540 multi_user_window_manager()->ActiveUserChanged("B"); 541 EXPECT_EQ(window(2), activation_client->GetActiveWindow()); 542 543 multi_user_window_manager()->ActiveUserChanged("C"); 544 EXPECT_EQ(NULL, activation_client->GetActiveWindow()); 545 546 // Now test that a minimized window stays minimized upon switch and back. 547 multi_user_window_manager()->ActiveUserChanged("A"); 548 wm::GetWindowState(window(0))->Minimize(); 549 550 multi_user_window_manager()->ActiveUserChanged("B"); 551 multi_user_window_manager()->ActiveUserChanged("A"); 552 EXPECT_TRUE(wm::GetWindowState(window(0))->IsMinimized()); 553 EXPECT_EQ(window(1), activation_client->GetActiveWindow()); 554 } 555 556 // Test that Transient windows are handled properly. 557 TEST_F(MultiUserWindowManagerChromeOSTest, TransientWindows) { 558 SetUpForThisManyWindows(10); 559 560 // We create a hierarchy like this: 561 // 0 (A) 4 (B) 7 (-) - The top level owned/not owned windows 562 // | | | 563 // 1 5 - 6 8 - Transient child of the owned windows. 564 // | | 565 // 2 9 - A transtient child of a transient child. 566 // | 567 // 3 - .. 568 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 569 multi_user_window_manager()->SetWindowOwner(window(4), "B"); 570 ::wm::AddTransientChild(window(0), window(1)); 571 // We first attach 2->3 and then 1->2 to see that the ownership gets 572 // properly propagated through the sub tree upon assigning. 573 ::wm::AddTransientChild(window(2), window(3)); 574 ::wm::AddTransientChild(window(1), window(2)); 575 ::wm::AddTransientChild(window(4), window(5)); 576 ::wm::AddTransientChild(window(4), window(6)); 577 ::wm::AddTransientChild(window(7), window(8)); 578 ::wm::AddTransientChild(window(7), window(9)); 579 580 // By now the hierarchy should have updated itself to show all windows of A 581 // and hide all windows of B. Unowned windows should remain in what ever state 582 // they are in. 583 EXPECT_EQ("S[A], S[], S[], S[], H[B], H[], H[], S[], S[], S[]", GetStatus()); 584 585 // Trying to show a hidden transient window shouldn't change anything for now. 586 window(5)->Show(); 587 window(6)->Show(); 588 EXPECT_EQ("S[A], S[], S[], S[], H[B], H[], H[], S[], S[], S[]", GetStatus()); 589 590 // Hiding on the other hand a shown window should work and hide also its 591 // children. Note that hide will have an immediate impact on itself and all 592 // transient children. It furthermore should remember this state when the 593 // transient children are removed from its owner later on. 594 window(2)->Hide(); 595 window(9)->Hide(); 596 EXPECT_EQ("S[A], S[], H[], H[], H[B], H[], H[], S[], S[], H[]", GetStatus()); 597 598 // Switching users and switch back should return to the previous state. 599 multi_user_window_manager()->ActiveUserChanged("B"); 600 EXPECT_EQ("H[A], H[], H[], H[], S[B], S[], S[], S[], S[], H[]", GetStatus()); 601 multi_user_window_manager()->ActiveUserChanged("A"); 602 EXPECT_EQ("S[A], S[], H[], H[], H[B], H[], H[], S[], S[], H[]", GetStatus()); 603 604 // Removing a window from its transient parent should return to the previously 605 // set visibility state. 606 // Note: Window2 was explicitly hidden above and that state should remain. 607 // Note furthermore that Window3 should also be hidden since it was hidden 608 // implicitly by hiding Window2. 609 // set hidden above). 610 // 0 (A) 4 (B) 7 (-) 2(-) 3 (-) 6(-) 611 // | | | 612 // 1 5 8 613 // | 614 // 9 615 ::wm::RemoveTransientChild(window(2), window(3)); 616 ::wm::RemoveTransientChild(window(4), window(6)); 617 EXPECT_EQ("S[A], S[], H[], H[], H[B], H[], S[], S[], S[], H[]", GetStatus()); 618 // Before we leave we need to reverse all transient window ownerships. 619 ::wm::RemoveTransientChild(window(0), window(1)); 620 ::wm::RemoveTransientChild(window(1), window(2)); 621 ::wm::RemoveTransientChild(window(4), window(5)); 622 ::wm::RemoveTransientChild(window(7), window(8)); 623 ::wm::RemoveTransientChild(window(7), window(9)); 624 } 625 626 // Test that the initial visibility state gets remembered. 627 TEST_F(MultiUserWindowManagerChromeOSTest, PreserveInitialVisibility) { 628 SetUpForThisManyWindows(4); 629 630 // Set our initial show state before we assign an owner. 631 window(0)->Show(); 632 window(1)->Hide(); 633 window(2)->Show(); 634 window(3)->Hide(); 635 EXPECT_EQ("S[], H[], S[], H[]", GetStatus()); 636 637 // First test: The show state gets preserved upon user switch. 638 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 639 multi_user_window_manager()->SetWindowOwner(window(1), "A"); 640 multi_user_window_manager()->SetWindowOwner(window(2), "B"); 641 multi_user_window_manager()->SetWindowOwner(window(3), "B"); 642 EXPECT_EQ("S[A], H[A], H[B], H[B]", GetStatus()); 643 multi_user_window_manager()->ActiveUserChanged("B"); 644 EXPECT_EQ("H[A], H[A], S[B], H[B]", GetStatus()); 645 multi_user_window_manager()->ActiveUserChanged("A"); 646 EXPECT_EQ("S[A], H[A], H[B], H[B]", GetStatus()); 647 648 // Second test: Transferring the window to another desktop preserves the 649 // show state. 650 ShowWindowForUserNoUserTransition(window(0), "B"); 651 ShowWindowForUserNoUserTransition(window(1), "B"); 652 ShowWindowForUserNoUserTransition(window(2), "A"); 653 ShowWindowForUserNoUserTransition(window(3), "A"); 654 EXPECT_EQ("H[A,B], H[A,B], S[B,A], H[B,A]", GetStatus()); 655 multi_user_window_manager()->ActiveUserChanged("B"); 656 EXPECT_EQ("S[A,B], H[A,B], H[B,A], H[B,A]", GetStatus()); 657 multi_user_window_manager()->ActiveUserChanged("A"); 658 EXPECT_EQ("H[A,B], H[A,B], S[B,A], H[B,A]", GetStatus()); 659 } 660 661 // Test that in case of an activated maximize mode, windows from other users get 662 // maximized after a user switch. 663 TEST_F(MultiUserWindowManagerChromeOSTest, MaximizeModeInteraction) { 664 SetUpForThisManyWindows(2); 665 666 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 667 multi_user_window_manager()->SetWindowOwner(window(1), "B"); 668 669 EXPECT_FALSE(wm::GetWindowState(window(0))->IsMaximized()); 670 EXPECT_FALSE(wm::GetWindowState(window(1))->IsMaximized()); 671 672 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 673 ASSERT_TRUE(manager); 674 675 EXPECT_TRUE(wm::GetWindowState(window(0))->IsMaximized()); 676 EXPECT_FALSE(wm::GetWindowState(window(1))->IsMaximized()); 677 678 // After we start switching to B, the windows of user B should maximize. 679 StartUserTransitionAnimation("B"); 680 681 EXPECT_TRUE(wm::GetWindowState(window(0))->IsMaximized()); 682 EXPECT_TRUE(wm::GetWindowState(window(1))->IsMaximized()); 683 } 684 685 // Test that a system modal dialog will switch to the desktop of the owning 686 // user. 687 TEST_F(MultiUserWindowManagerChromeOSTest, SwitchUsersUponModalityChange) { 688 SetUpForThisManyWindows(1); 689 session_state_delegate()->SwitchActiveUser("a"); 690 691 // Making the window system modal should not change anything. 692 MakeWindowSystemModal(window(0)); 693 EXPECT_EQ("a", session_state_delegate()->GetActiveUserInfo()->GetUserID()); 694 695 // Making the window owned by user B should switch users. 696 multi_user_window_manager()->SetWindowOwner(window(0), "b"); 697 EXPECT_EQ("b", session_state_delegate()->GetActiveUserInfo()->GetUserID()); 698 } 699 700 // Test that a system modal dialog will not switch desktop if active user has 701 // shows window. 702 TEST_F(MultiUserWindowManagerChromeOSTest, DontSwitchUsersUponModalityChange) { 703 SetUpForThisManyWindows(1); 704 session_state_delegate()->SwitchActiveUser("a"); 705 706 // Making the window system modal should not change anything. 707 MakeWindowSystemModal(window(0)); 708 EXPECT_EQ("a", session_state_delegate()->GetActiveUserInfo()->GetUserID()); 709 710 // Making the window owned by user a should not switch users. 711 multi_user_window_manager()->SetWindowOwner(window(0), "a"); 712 EXPECT_EQ("a", session_state_delegate()->GetActiveUserInfo()->GetUserID()); 713 } 714 715 // Test that a system modal dialog will not switch if shown on correct desktop 716 // but owned by another user. 717 TEST_F(MultiUserWindowManagerChromeOSTest, 718 DontSwitchUsersUponModalityChangeWhenShownButNotOwned) { 719 SetUpForThisManyWindows(1); 720 session_state_delegate()->SwitchActiveUser("a"); 721 722 window(0)->Hide(); 723 multi_user_window_manager()->SetWindowOwner(window(0), "b"); 724 ShowWindowForUserNoUserTransition(window(0), "a"); 725 MakeWindowSystemModal(window(0)); 726 // Showing the window should trigger no user switch. 727 window(0)->Show(); 728 EXPECT_EQ("a", session_state_delegate()->GetActiveUserInfo()->GetUserID()); 729 } 730 731 // Test that a system modal dialog will switch if shown on incorrect desktop but 732 // even if owned by current user. 733 TEST_F(MultiUserWindowManagerChromeOSTest, 734 SwitchUsersUponModalityChangeWhenShownButNotOwned) { 735 SetUpForThisManyWindows(1); 736 session_state_delegate()->SwitchActiveUser("a"); 737 738 window(0)->Hide(); 739 multi_user_window_manager()->SetWindowOwner(window(0), "a"); 740 ShowWindowForUserNoUserTransition(window(0), "b"); 741 MakeWindowSystemModal(window(0)); 742 // Showing the window should trigger a user switch. 743 window(0)->Show(); 744 EXPECT_EQ("b", session_state_delegate()->GetActiveUserInfo()->GetUserID()); 745 } 746 747 // Test that using the full user switch animations are working as expected. 748 TEST_F(MultiUserWindowManagerChromeOSTest, FullUserSwitchAnimationTests) { 749 SetUpForThisManyWindows(3); 750 // Turn the use of delays and animation on. 751 multi_user_window_manager()->SetAnimationSpeedForTest( 752 chrome::MultiUserWindowManagerChromeOS::ANIMATION_SPEED_FAST); 753 // Set some owners and make sure we got what we asked for. 754 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 755 multi_user_window_manager()->SetWindowOwner(window(1), "B"); 756 multi_user_window_manager()->SetWindowOwner(window(2), "C"); 757 EXPECT_EQ("S[A], H[B], H[C]", GetStatus()); 758 EXPECT_EQ("A", GetOwnersOfVisibleWindowsAsString()); 759 760 // Switch the user fore and back and see that the results are correct. 761 SwitchUserAndWaitForAnimation("B"); 762 763 EXPECT_EQ("H[A], S[B], H[C]", GetStatus()); 764 EXPECT_EQ("B", GetOwnersOfVisibleWindowsAsString()); 765 766 SwitchUserAndWaitForAnimation("A"); 767 768 EXPECT_EQ("S[A], H[B], H[C]", GetStatus()); 769 770 // Switch the user quickly to another user and before the animation is done 771 // switch back and see that this works. 772 multi_user_window_manager()->ActiveUserChanged("B"); 773 // With the start of the animation B should become visible. 774 EXPECT_EQ("H[A], S[B], H[C]", GetStatus()); 775 // Check that after switching to C, C is fully visible. 776 SwitchUserAndWaitForAnimation("C"); 777 EXPECT_EQ("H[A], H[B], S[C]", GetStatus()); 778 } 779 780 // Make sure that we do not crash upon shutdown when an animation is pending and 781 // a shutdown happens. 782 TEST_F(MultiUserWindowManagerChromeOSTest, SystemShutdownWithActiveAnimation) { 783 SetUpForThisManyWindows(2); 784 // Turn the use of delays and animation on. 785 multi_user_window_manager()->SetAnimationSpeedForTest( 786 chrome::MultiUserWindowManagerChromeOS::ANIMATION_SPEED_FAST); 787 // Set some owners and make sure we got what we asked for. 788 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 789 multi_user_window_manager()->SetWindowOwner(window(1), "B"); 790 StartUserTransitionAnimation("B"); 791 // We don't do anything more here - the animations are pending and with the 792 // shutdown of the framework the animations should get cancelled. If not a 793 // crash would happen. 794 } 795 796 // Test that using the full user switch, the animations are transitioning as 797 // we expect them to in all animation steps. 798 TEST_F(MultiUserWindowManagerChromeOSTest, AnimationSteps) { 799 SetUpForThisManyWindows(3); 800 // Turn the use of delays and animation on. 801 multi_user_window_manager()->SetAnimationSpeedForTest( 802 chrome::MultiUserWindowManagerChromeOS::ANIMATION_SPEED_FAST); 803 // Set some owners and make sure we got what we asked for. 804 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 805 multi_user_window_manager()->SetWindowOwner(window(1), "B"); 806 multi_user_window_manager()->SetWindowOwner(window(2), "C"); 807 EXPECT_FALSE(CoversScreen(window(0))); 808 EXPECT_FALSE(CoversScreen(window(1))); 809 EXPECT_EQ("S[A], H[B], H[C]", GetStatus()); 810 EXPECT_EQ("A", GetOwnersOfVisibleWindowsAsString()); 811 EXPECT_NE(ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN, 812 ash::Shell::GetInstance()->GetShelfAutoHideBehavior( 813 window(0)->GetRootWindow())); 814 EXPECT_EQ(1.0f, window(0)->layer()->GetTargetOpacity()); 815 ash::ShelfWidget* shelf = ash::RootWindowController::ForWindow( 816 window(0))->shelf(); 817 EXPECT_FALSE(shelf->IsShelfHiddenBehindBlackBar()); 818 819 // Start the animation and see that the old window is becoming invisible, the 820 // new one visible, the background starts transitionining and the shelf hides. 821 StartUserTransitionAnimation("B"); 822 EXPECT_EQ("->B", GetWallaperUserIdForTest()); 823 EXPECT_EQ("H[A], S[B], H[C]", GetStatus()); 824 EXPECT_EQ(0.0f, window(0)->layer()->GetTargetOpacity()); 825 EXPECT_EQ(1.0f, window(1)->layer()->GetTargetOpacity()); 826 EXPECT_EQ(ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN, 827 ash::Shell::GetInstance()->GetShelfAutoHideBehavior( 828 window(0)->GetRootWindow())); 829 EXPECT_FALSE(shelf->IsShelfHiddenBehindBlackBar()); 830 831 // Staring the next step should show the shelf again, but there are many 832 // subsystems missing (preferences system, ChromeLauncherController, ...) 833 // which should set the shelf to its users state. Since that isn't there we 834 // can only make sure that it stays where it is. 835 AdvanceUserTransitionAnimation(); 836 EXPECT_EQ("->B", GetWallaperUserIdForTest()); 837 EXPECT_EQ("H[A], S[B], H[C]", GetStatus()); 838 EXPECT_EQ(ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN, 839 ash::Shell::GetInstance()->GetShelfAutoHideBehavior( 840 window(0)->GetRootWindow())); 841 EXPECT_FALSE(shelf->IsShelfHiddenBehindBlackBar()); 842 843 // After the finalize the animation of the wallpaper should be finished. 844 AdvanceUserTransitionAnimation(); 845 EXPECT_FALSE(shelf->IsShelfHiddenBehindBlackBar()); 846 EXPECT_EQ("B", GetWallaperUserIdForTest()); 847 } 848 849 // Test that the screen coverage is properly determined. 850 TEST_F(MultiUserWindowManagerChromeOSTest, AnimationStepsScreenCoverage) { 851 SetUpForThisManyWindows(3); 852 // Maximizing, fully covering the screen by bounds or fullscreen mode should 853 // make CoversScreen return true. 854 wm::GetWindowState(window(0))->Maximize(); 855 window(1)->SetBounds(gfx::Rect(0, 0, 3000, 3000)); 856 857 EXPECT_TRUE(CoversScreen(window(0))); 858 EXPECT_TRUE(CoversScreen(window(1))); 859 EXPECT_FALSE(CoversScreen(window(2))); 860 861 ash::wm::WMEvent event(ash::wm::WM_EVENT_FULLSCREEN); 862 wm::GetWindowState(window(2))->OnWMEvent(&event); 863 EXPECT_TRUE(CoversScreen(window(2))); 864 } 865 866 // Test that switching from a desktop which has a maximized window to a desktop 867 // which has no maximized window will produce the proper animation. 868 TEST_F(MultiUserWindowManagerChromeOSTest, AnimationStepsMaximizeToNormal) { 869 SetUpForThisManyWindows(3); 870 // Turn the use of delays and animation on. 871 multi_user_window_manager()->SetAnimationSpeedForTest( 872 chrome::MultiUserWindowManagerChromeOS::ANIMATION_SPEED_FAST); 873 // Set some owners and make sure we got what we asked for. 874 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 875 wm::GetWindowState(window(0))->Maximize(); 876 multi_user_window_manager()->SetWindowOwner(window(1), "B"); 877 multi_user_window_manager()->SetWindowOwner(window(2), "C"); 878 EXPECT_TRUE(CoversScreen(window(0))); 879 EXPECT_FALSE(CoversScreen(window(1))); 880 EXPECT_EQ("S[A], H[B], H[C]", GetStatus()); 881 EXPECT_EQ("A", GetOwnersOfVisibleWindowsAsString()); 882 EXPECT_EQ(1.0f, window(0)->layer()->GetTargetOpacity()); 883 884 // Start the animation and see that the new background is immediately set. 885 StartUserTransitionAnimation("B"); 886 EXPECT_EQ("H[A], S[B], H[C]", GetStatus()); 887 EXPECT_EQ("B", GetWallaperUserIdForTest()); 888 EXPECT_EQ(0.0f, window(0)->layer()->GetTargetOpacity()); 889 EXPECT_EQ(1.0f, window(1)->layer()->GetTargetOpacity()); 890 891 // The next step will not change anything. 892 AdvanceUserTransitionAnimation(); 893 EXPECT_EQ("B", GetWallaperUserIdForTest()); 894 EXPECT_EQ(0.0f, window(0)->layer()->GetTargetOpacity()); 895 EXPECT_EQ(1.0f, window(1)->layer()->GetTargetOpacity()); 896 897 // The final step will also not have any visible impact. 898 AdvanceUserTransitionAnimation(); 899 EXPECT_EQ("H[A], S[B], H[C]", GetStatus()); 900 EXPECT_EQ("B", GetWallaperUserIdForTest()); 901 EXPECT_EQ(0.0f, window(0)->layer()->GetTargetOpacity()); 902 EXPECT_EQ(1.0f, window(1)->layer()->GetTargetOpacity()); 903 } 904 905 // Test that switching from a desktop which has a normal window to a desktop 906 // which has a maximized window will produce the proper animation. 907 TEST_F(MultiUserWindowManagerChromeOSTest, AnimationStepsNormalToMaximized) { 908 SetUpForThisManyWindows(3); 909 // Turn the use of delays and animation on. 910 multi_user_window_manager()->SetAnimationSpeedForTest( 911 chrome::MultiUserWindowManagerChromeOS::ANIMATION_SPEED_FAST); 912 // Set some owners and make sure we got what we asked for. 913 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 914 multi_user_window_manager()->SetWindowOwner(window(1), "B"); 915 wm::GetWindowState(window(1))->Maximize(); 916 multi_user_window_manager()->SetWindowOwner(window(2), "C"); 917 EXPECT_FALSE(CoversScreen(window(0))); 918 EXPECT_TRUE(CoversScreen(window(1))); 919 EXPECT_EQ("S[A], H[B], H[C]", GetStatus()); 920 EXPECT_EQ("A", GetOwnersOfVisibleWindowsAsString()); 921 EXPECT_EQ(1.0f, window(0)->layer()->GetTargetOpacity()); 922 923 // Start the animation and see that the old window is becoming invisible, the 924 // new one visible and the background remains as is. 925 StartUserTransitionAnimation("B"); 926 EXPECT_EQ("H[A], S[B], H[C]", GetStatus()); 927 EXPECT_EQ("", GetWallaperUserIdForTest()); 928 EXPECT_EQ(0.0f, window(0)->layer()->GetTargetOpacity()); 929 EXPECT_EQ(1.0f, window(1)->layer()->GetTargetOpacity()); 930 931 // The next step will not change anything. 932 AdvanceUserTransitionAnimation(); 933 EXPECT_EQ("", GetWallaperUserIdForTest()); 934 EXPECT_EQ(0.0f, window(0)->layer()->GetTargetOpacity()); 935 EXPECT_EQ(1.0f, window(1)->layer()->GetTargetOpacity()); 936 937 // The final step however will switch the background. 938 AdvanceUserTransitionAnimation(); 939 EXPECT_EQ("H[A], S[B], H[C]", GetStatus()); 940 EXPECT_EQ("B", GetWallaperUserIdForTest()); 941 EXPECT_EQ(0.0f, window(0)->layer()->GetTargetOpacity()); 942 EXPECT_EQ(1.0f, window(1)->layer()->GetTargetOpacity()); 943 } 944 945 // Test that switching from a desktop which has a maximized window to a desktop 946 // which has a maximized window will produce the proper animation. 947 TEST_F(MultiUserWindowManagerChromeOSTest, AnimationStepsMaximizedToMaximized) { 948 SetUpForThisManyWindows(3); 949 // Turn the use of delays and animation on. 950 multi_user_window_manager()->SetAnimationSpeedForTest( 951 chrome::MultiUserWindowManagerChromeOS::ANIMATION_SPEED_FAST); 952 // Set some owners and make sure we got what we asked for. 953 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 954 wm::GetWindowState(window(0))->Maximize(); 955 multi_user_window_manager()->SetWindowOwner(window(1), "B"); 956 wm::GetWindowState(window(1))->Maximize(); 957 multi_user_window_manager()->SetWindowOwner(window(2), "C"); 958 EXPECT_TRUE(CoversScreen(window(0))); 959 EXPECT_TRUE(CoversScreen(window(1))); 960 EXPECT_EQ("S[A], H[B], H[C]", GetStatus()); 961 EXPECT_EQ("A", GetOwnersOfVisibleWindowsAsString()); 962 EXPECT_EQ(1.0f, window(0)->layer()->GetTargetOpacity()); 963 964 // Start the animation and see that the old window is staying visible, the 965 // new one slowly visible and the background changes immediately. 966 StartUserTransitionAnimation("B"); 967 EXPECT_EQ("S[A], S[B], H[C]", GetStatus()); 968 EXPECT_EQ("B", GetWallaperUserIdForTest()); 969 EXPECT_EQ(1.0f, window(0)->layer()->GetTargetOpacity()); 970 EXPECT_EQ(1.0f, window(1)->layer()->GetTargetOpacity()); 971 972 // The next step will not change anything. 973 AdvanceUserTransitionAnimation(); 974 EXPECT_EQ("B", GetWallaperUserIdForTest()); 975 EXPECT_EQ(1.0f, window(0)->layer()->GetTargetOpacity()); 976 EXPECT_EQ(1.0f, window(1)->layer()->GetTargetOpacity()); 977 978 // The final step however will hide the old window. 979 AdvanceUserTransitionAnimation(); 980 EXPECT_EQ("H[A], S[B], H[C]", GetStatus()); 981 EXPECT_EQ("B", GetWallaperUserIdForTest()); 982 EXPECT_EQ(0.0f, window(0)->layer()->GetTargetOpacity()); 983 EXPECT_EQ(1.0f, window(1)->layer()->GetTargetOpacity()); 984 985 // Switching back will preserve the z-order by instantly showing the new 986 // window, hiding the layer above it and switching instantly the wallpaper. 987 StartUserTransitionAnimation("A"); 988 EXPECT_EQ("S[A], H[B], H[C]", GetStatus()); 989 EXPECT_EQ("A", GetWallaperUserIdForTest()); 990 EXPECT_EQ(1.0f, window(0)->layer()->GetTargetOpacity()); 991 EXPECT_EQ(0.0f, window(1)->layer()->GetTargetOpacity()); 992 993 // The next step will not change anything. 994 AdvanceUserTransitionAnimation(); 995 EXPECT_EQ("A", GetWallaperUserIdForTest()); 996 EXPECT_EQ(1.0f, window(0)->layer()->GetTargetOpacity()); 997 EXPECT_EQ(0.0f, window(1)->layer()->GetTargetOpacity()); 998 999 // The final step is also not changing anything to the status. 1000 AdvanceUserTransitionAnimation(); 1001 EXPECT_EQ("S[A], H[B], H[C]", GetStatus()); 1002 EXPECT_EQ("A", GetWallaperUserIdForTest()); 1003 EXPECT_EQ(1.0f, window(0)->layer()->GetTargetOpacity()); 1004 EXPECT_EQ(0.0f, window(1)->layer()->GetTargetOpacity()); 1005 } 1006 1007 // Test that showing a window for another user also switches the desktop. 1008 TEST_F(MultiUserWindowManagerChromeOSTest, ShowForUserSwitchesDesktop) { 1009 SetUpForThisManyWindows(3); 1010 multi_user_window_manager()->ActiveUserChanged("a"); 1011 session_state_delegate()->SwitchActiveUser("a"); 1012 1013 // Set some owners and make sure we got what we asked for. 1014 multi_user_window_manager()->SetWindowOwner(window(0), "a"); 1015 multi_user_window_manager()->SetWindowOwner(window(1), "b"); 1016 multi_user_window_manager()->SetWindowOwner(window(2), "c"); 1017 EXPECT_EQ("S[a], H[b], H[c]", GetStatus()); 1018 1019 // SetWindowOwner should not have changed the active user. 1020 EXPECT_EQ("a", GetAndValidateCurrentUserFromSessionStateObserver()); 1021 1022 // Check that teleporting the window of the currently active user will 1023 // teleport to the new desktop. 1024 multi_user_window_manager()->ShowWindowForUser(window(0), "b"); 1025 EXPECT_EQ("b", GetAndValidateCurrentUserFromSessionStateObserver()); 1026 EXPECT_EQ("S[a,b], S[b], H[c]", GetStatus()); 1027 1028 // Check that teleporting a window from a currently inactive user will not 1029 // trigger a switch. 1030 multi_user_window_manager()->ShowWindowForUser(window(2), "a"); 1031 EXPECT_EQ("b", GetAndValidateCurrentUserFromSessionStateObserver()); 1032 EXPECT_EQ("S[a,b], S[b], H[c,a]", GetStatus()); 1033 multi_user_window_manager()->ShowWindowForUser(window(2), "b"); 1034 EXPECT_EQ("b", GetAndValidateCurrentUserFromSessionStateObserver()); 1035 EXPECT_EQ("S[a,b], S[b], S[c,b]", GetStatus()); 1036 1037 // Check that teleporting back will also change the desktop. 1038 multi_user_window_manager()->ShowWindowForUser(window(2), "c"); 1039 EXPECT_EQ("c", GetAndValidateCurrentUserFromSessionStateObserver()); 1040 EXPECT_EQ("H[a,b], H[b], S[c]", GetStatus()); 1041 } 1042 1043 class TestWindowObserver : public aura::WindowObserver { 1044 public: 1045 TestWindowObserver(): resize_calls_(0) {} 1046 virtual ~TestWindowObserver() {}; 1047 1048 virtual void OnWindowBoundsChanged(aura::Window* window, 1049 const gfx::Rect& old_bounds, 1050 const gfx::Rect& new_bounds) OVERRIDE { 1051 resize_calls_++; 1052 } 1053 1054 int resize_calls() { return resize_calls_; } 1055 1056 private: 1057 int resize_calls_; 1058 1059 DISALLOW_COPY_AND_ASSIGN(TestWindowObserver); 1060 }; 1061 1062 // Test that switching between users with the shelf in the same place, the shelf 1063 // will get covered with a black bar instead being hidden and re-shown. 1064 TEST_F(MultiUserWindowManagerChromeOSTest, TestBlackBarCover) { 1065 SetUpForThisManyWindows(2); 1066 multi_user_window_manager()->SetWindowOwner(window(0), "A"); 1067 multi_user_window_manager()->SetWindowOwner(window(1), "B"); 1068 aura::Window* root_window = ash::Shell::GetInstance()->GetPrimaryRootWindow(); 1069 1070 // Turn the use of delays and animation on. 1071 multi_user_window_manager()->SetAnimationSpeedForTest( 1072 chrome::MultiUserWindowManagerChromeOS::ANIMATION_SPEED_FAST); 1073 EXPECT_NE(ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN, 1074 ash::Shell::GetInstance()->GetShelfAutoHideBehavior(root_window)); 1075 ash::ShelfWidget* shelf = ash::RootWindowController::ForWindow( 1076 root_window)->shelf(); 1077 EXPECT_FALSE(shelf->IsShelfHiddenBehindBlackBar()); 1078 1079 // First test that with no maximized window we show/hide the shelf. 1080 StartUserTransitionAnimation("B"); 1081 EXPECT_FALSE(shelf->IsShelfHiddenBehindBlackBar()); 1082 EXPECT_EQ(ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN, 1083 ash::Shell::GetInstance()->GetShelfAutoHideBehavior(root_window)); 1084 1085 // Staring the next step should show the shelf again. 1086 AdvanceUserTransitionAnimation(); 1087 EXPECT_FALSE(shelf->IsShelfHiddenBehindBlackBar()); 1088 1089 AdvanceUserTransitionAnimation(); 1090 EXPECT_FALSE(shelf->IsShelfHiddenBehindBlackBar()); 1091 ash::Shell::GetInstance()->SetShelfAutoHideBehavior( 1092 ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER, root_window); 1093 1094 // Now we maximize the windows which will cause the black overlay to show up. 1095 wm::GetWindowState(window(0))->Maximize(); 1096 wm::GetWindowState(window(1))->Maximize(); 1097 // We set a window observer on both windows to see that no resize is performed 1098 // on our test windows. 1099 TestWindowObserver window_observer; 1100 window(0)->AddObserver(&window_observer); 1101 window(1)->AddObserver(&window_observer); 1102 1103 // Start the animation and see that the shelf gets hidden by the black bar, 1104 // and the AutoHide behavior remains as it was. 1105 StartUserTransitionAnimation("A"); 1106 EXPECT_TRUE(shelf->IsShelfHiddenBehindBlackBar()); 1107 EXPECT_NE(ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN, 1108 ash::Shell::GetInstance()->GetShelfAutoHideBehavior(root_window)); 1109 1110 // Staring the next step should show the shelf again. 1111 AdvanceUserTransitionAnimation(); 1112 EXPECT_FALSE(shelf->IsShelfHiddenBehindBlackBar()); 1113 EXPECT_NE(ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN, 1114 ash::Shell::GetInstance()->GetShelfAutoHideBehavior(root_window)); 1115 1116 AdvanceUserTransitionAnimation(); 1117 EXPECT_FALSE(shelf->IsShelfHiddenBehindBlackBar()); 1118 window(0)->RemoveObserver(&window_observer); 1119 window(1)->RemoveObserver(&window_observer); 1120 // No resize should have been done to the window. 1121 EXPECT_EQ(0, window_observer.resize_calls()); 1122 } 1123 1124 } // namespace test 1125 } // namespace ash 1126
