wallpaper_window_state_manager_unittest.cc 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188
  1. // Copyright 2018 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. #include "ash/wallpaper/wallpaper_window_state_manager.h"
  5. #include <memory>
  6. #include "ash/test/ash_test_base.h"
  7. #include "ash/wm/window_state.h"
  8. #include "base/memory/ptr_util.h"
  9. #include "ui/aura/window.h"
  10. namespace ash {
  11. namespace {
  12. constexpr char kTestAccount[] = "user@test.com";
  13. std::string GetUserIdHash(const std::string& user_id) {
  14. return user_id + "-hash";
  15. }
  16. class WallpaperWindowStateManagerTest : public AshTestBase {
  17. public:
  18. WallpaperWindowStateManagerTest()
  19. : window_state_manager_(std::make_unique<WallpaperWindowStateManager>()) {
  20. }
  21. WallpaperWindowStateManagerTest(const WallpaperWindowStateManagerTest&) =
  22. delete;
  23. WallpaperWindowStateManagerTest& operator=(
  24. const WallpaperWindowStateManagerTest&) = delete;
  25. ~WallpaperWindowStateManagerTest() override = default;
  26. protected:
  27. std::unique_ptr<WallpaperWindowStateManager> window_state_manager_;
  28. };
  29. TEST_F(WallpaperWindowStateManagerTest, HideAndRestoreWindows) {
  30. SimulateUserLogin(kTestAccount);
  31. std::unique_ptr<aura::Window> wallpaper_picker_window(
  32. CreateTestWindowInShellWithId(0));
  33. std::unique_ptr<aura::Window> window1(CreateTestWindowInShellWithId(1));
  34. std::unique_ptr<aura::Window> window2(CreateTestWindowInShellWithId(2));
  35. std::unique_ptr<aura::Window> window3(CreateTestWindowInShellWithId(3));
  36. std::unique_ptr<aura::Window> window4(CreateTestWindowInShellWithId(4));
  37. WindowState* wallpaper_picker_window_state =
  38. WindowState::Get(wallpaper_picker_window.get());
  39. WindowState* window1_state = WindowState::Get(window1.get());
  40. WindowState* window2_state = WindowState::Get(window2.get());
  41. WindowState* window3_state = WindowState::Get(window3.get());
  42. WindowState* window4_state = WindowState::Get(window4.get());
  43. // Window 1 starts maximized and window 3 starts minimized.
  44. window1_state->Maximize();
  45. window3_state->Minimize();
  46. EXPECT_FALSE(wallpaper_picker_window_state->IsMinimized());
  47. EXPECT_FALSE(window1_state->IsMinimized());
  48. EXPECT_FALSE(window2_state->IsMinimized());
  49. EXPECT_TRUE(window3_state->IsMinimized());
  50. EXPECT_FALSE(window4_state->IsMinimized());
  51. // Activates the wallpaper picker window and call the minimize function.
  52. wallpaper_picker_window_state->Activate();
  53. EXPECT_TRUE(wallpaper_picker_window_state->IsActive());
  54. window_state_manager_->MinimizeInactiveWindows(GetUserIdHash(kTestAccount));
  55. // All windows except the wallpaper picker should be minimized.
  56. EXPECT_FALSE(wallpaper_picker_window_state->IsMinimized());
  57. EXPECT_TRUE(window1_state->IsMinimized());
  58. EXPECT_TRUE(window2_state->IsMinimized());
  59. EXPECT_TRUE(window3_state->IsMinimized());
  60. EXPECT_TRUE(window4_state->IsMinimized());
  61. // Activates window 4 and then minimizes it.
  62. window4_state->Activate();
  63. window4_state->Minimize();
  64. // Destroy wallpaper picker window and call the restore function.
  65. wallpaper_picker_window.reset();
  66. window_state_manager_->RestoreMinimizedWindows(GetUserIdHash(kTestAccount));
  67. // Window 1 should be restored to maximized.
  68. EXPECT_TRUE(window1_state->IsMaximized());
  69. // Window 2 should be restored and is no longer minimized.
  70. EXPECT_FALSE(window2_state->IsMinimized());
  71. // Window 3 should remain minimized because it was minimized before wallpaper
  72. // picker was open.
  73. EXPECT_TRUE(window3_state->IsMinimized());
  74. // Window 4 should remain minimized since user interacted with it (i.e.
  75. // explicitly minimized it) while wallpaper picker was open.
  76. EXPECT_TRUE(window4_state->IsMinimized());
  77. }
  78. // Test for multiple calls to |MinimizeInactiveWindows| before calling
  79. // |RestoreMinimizedWindows|:
  80. // 1. If none of the windows changed their states, the following calls are
  81. // no-op.
  82. // 2. If some windows are unminimized by user, the following call will minimize
  83. // the unminimized windows again.
  84. TEST_F(WallpaperWindowStateManagerTest, HideAndManualUnminimizeWindows) {
  85. SimulateUserLogin(kTestAccount);
  86. std::unique_ptr<aura::Window> wallpaper_picker_window(
  87. CreateTestWindowInShellWithId(0));
  88. std::unique_ptr<aura::Window> window1(CreateTestWindowInShellWithId(1));
  89. WindowState* wallpaper_picker_window_state =
  90. WindowState::Get(wallpaper_picker_window.get());
  91. WindowState* window1_state = WindowState::Get(window1.get());
  92. // Activates the wallpaper picker window and call the minimize function.
  93. wallpaper_picker_window_state->Activate();
  94. EXPECT_TRUE(wallpaper_picker_window_state->IsActive());
  95. window_state_manager_->MinimizeInactiveWindows(GetUserIdHash(kTestAccount));
  96. // All windows except the wallpaper picker should be minimized.
  97. EXPECT_FALSE(wallpaper_picker_window_state->IsMinimized());
  98. EXPECT_TRUE(window1_state->IsMinimized());
  99. // Calling minimize function again should be an no-op if window state didn't
  100. // change.
  101. window_state_manager_->MinimizeInactiveWindows(GetUserIdHash(kTestAccount));
  102. EXPECT_FALSE(wallpaper_picker_window_state->IsMinimized());
  103. EXPECT_TRUE(window1_state->IsMinimized());
  104. // Manually unminimize window 1.
  105. window1_state->Unminimize();
  106. EXPECT_FALSE(window1_state->IsMinimized());
  107. // Call the minimize function and verify window 1 should be minimized again.
  108. wallpaper_picker_window_state->Activate();
  109. window_state_manager_->MinimizeInactiveWindows(GetUserIdHash(kTestAccount));
  110. EXPECT_FALSE(wallpaper_picker_window_state->IsMinimized());
  111. EXPECT_TRUE(window1_state->IsMinimized());
  112. // Destroy wallpaper picker window and call the restore function.
  113. wallpaper_picker_window.reset();
  114. window_state_manager_->RestoreMinimizedWindows(GetUserIdHash(kTestAccount));
  115. // Windows 1 should no longer be minimized.
  116. EXPECT_FALSE(window1_state->IsMinimized());
  117. }
  118. // Test that invisible windows (e.g. those belonging to an inactive user) should
  119. // not be affected by |MinimizeInactiveWindows| or |RestoreMinimizedWindows|.
  120. TEST_F(WallpaperWindowStateManagerTest, IgnoreInvisibleWindows) {
  121. SimulateUserLogin(kTestAccount);
  122. std::unique_ptr<aura::Window> wallpaper_picker_window(
  123. CreateTestWindowInShellWithId(0));
  124. std::unique_ptr<aura::Window> window1(CreateTestWindowInShellWithId(1));
  125. std::unique_ptr<aura::Window> window2(CreateTestWindowInShellWithId(2));
  126. WindowState* wallpaper_picker_window_state =
  127. WindowState::Get(wallpaper_picker_window.get());
  128. WindowState* window1_state = WindowState::Get(window1.get());
  129. WindowState* window2_state = WindowState::Get(window2.get());
  130. window2->Hide();
  131. EXPECT_FALSE(window2->IsVisible());
  132. // Activates the wallpaper picker window and call the minimize function.
  133. wallpaper_picker_window_state->Activate();
  134. EXPECT_TRUE(wallpaper_picker_window_state->IsActive());
  135. window_state_manager_->MinimizeInactiveWindows(GetUserIdHash(kTestAccount));
  136. // The wallpaper picker window should not be minimized, and window 1 should be
  137. // minimized.
  138. EXPECT_FALSE(wallpaper_picker_window_state->IsMinimized());
  139. EXPECT_TRUE(window1_state->IsMinimized());
  140. // Window 2 should stay unminimized and invisible.
  141. EXPECT_FALSE(window2_state->IsMinimized());
  142. EXPECT_FALSE(window2->IsVisible());
  143. // Destroy wallpaper picker window and call the restore function.
  144. wallpaper_picker_window.reset();
  145. window_state_manager_->RestoreMinimizedWindows(GetUserIdHash(kTestAccount));
  146. // Windows 1 should no longer be minimized.
  147. EXPECT_FALSE(window1_state->IsMinimized());
  148. // Window 2 should stay unminimized and invisible.
  149. EXPECT_FALSE(window2_state->IsMinimized());
  150. EXPECT_FALSE(window2->IsVisible());
  151. }
  152. } // namespace
  153. } // namespace ash