| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 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 "ui/aura_shell/activation_controller.h" | |
| 6 | |
| 7 #include "ui/aura/client/aura_constants.h" | |
| 8 #include "ui/aura/focus_manager.h" | |
| 9 #include "ui/aura/root_window.h" | |
| 10 #include "ui/aura/test/event_generator.h" | |
| 11 #include "ui/aura/test/test_windows.h" | |
| 12 #include "ui/aura/test/test_window_delegate.h" | |
| 13 #include "ui/aura_shell/test/aura_shell_test_base.h" | |
| 14 #include "ui/aura_shell/test/test_activation_delegate.h" | |
| 15 #include "ui/aura_shell/window_util.h" | |
| 16 | |
| 17 #if defined(OS_WIN) | |
| 18 // Windows headers define macros for these function names which screw with us. | |
| 19 #if defined(CreateWindow) | |
| 20 #undef CreateWindow | |
| 21 #endif | |
| 22 #endif | |
| 23 | |
| 24 namespace aura_shell { | |
| 25 namespace test { | |
| 26 | |
| 27 typedef test::AuraShellTestBase ActivationControllerTest; | |
| 28 | |
| 29 // Utilities for a set of tests that test | |
| 30 // ActivationController::GetTopmostWindowToActivate(). | |
| 31 class GetTopmostWindowToActivateTest : public ActivationControllerTest { | |
| 32 public: | |
| 33 GetTopmostWindowToActivateTest() : ad_1_(false), ad_3_(false) {} | |
| 34 virtual ~GetTopmostWindowToActivateTest() {} | |
| 35 | |
| 36 // Overridden from ActivationControllerTest: | |
| 37 virtual void SetUp() OVERRIDE { | |
| 38 ActivationControllerTest::SetUp(); | |
| 39 CreateWindows(); | |
| 40 } | |
| 41 virtual void TearDown() OVERRIDE { | |
| 42 DestroyWindows(); | |
| 43 ActivationControllerTest::TearDown(); | |
| 44 } | |
| 45 | |
| 46 protected: | |
| 47 aura::Window* w1() { return w1_.get(); } | |
| 48 aura::Window* w2() { return w2_.get(); } | |
| 49 aura::Window* w3() { return w3_.get(); } | |
| 50 aura::Window* w4() { return w4_.get(); } | |
| 51 | |
| 52 void DestroyWindow2() { | |
| 53 w2_.reset(); | |
| 54 } | |
| 55 | |
| 56 private: | |
| 57 void CreateWindows() { | |
| 58 // Create four windows, the first and third are not activatable, the second | |
| 59 // and fourth are. | |
| 60 w1_.reset(CreateWindow(1, &ad_1_)); | |
| 61 w2_.reset(CreateWindow(2, &ad_2_)); | |
| 62 w3_.reset(CreateWindow(3, &ad_3_)); | |
| 63 w4_.reset(CreateWindow(4, &ad_4_)); | |
| 64 } | |
| 65 | |
| 66 aura::Window* CreateWindow(int id, TestActivationDelegate* delegate) { | |
| 67 aura::Window* window = aura::test::CreateTestWindowWithDelegate( | |
| 68 &delegate_, id, gfx::Rect(), NULL); | |
| 69 delegate->SetWindow(window); | |
| 70 return window; | |
| 71 } | |
| 72 | |
| 73 void DestroyWindows() { | |
| 74 w1_.reset(); | |
| 75 w2_.reset(); | |
| 76 w3_.reset(); | |
| 77 w4_.reset(); | |
| 78 } | |
| 79 | |
| 80 aura::test::TestWindowDelegate delegate_; | |
| 81 TestActivationDelegate ad_1_; | |
| 82 TestActivationDelegate ad_2_; | |
| 83 TestActivationDelegate ad_3_; | |
| 84 TestActivationDelegate ad_4_; | |
| 85 scoped_ptr<aura::Window> w1_; // Non-activatable. | |
| 86 scoped_ptr<aura::Window> w2_; // Activatable. | |
| 87 scoped_ptr<aura::Window> w3_; // Non-activatable. | |
| 88 scoped_ptr<aura::Window> w4_; // Activatable. | |
| 89 | |
| 90 DISALLOW_COPY_AND_ASSIGN(GetTopmostWindowToActivateTest); | |
| 91 }; | |
| 92 | |
| 93 // Hiding the active window should activate the next valid activatable window. | |
| 94 TEST_F(GetTopmostWindowToActivateTest, HideActivatesNext) { | |
| 95 ActivateWindow(w2()); | |
| 96 EXPECT_TRUE(IsActiveWindow(w2())); | |
| 97 | |
| 98 w2()->Hide(); | |
| 99 EXPECT_TRUE(IsActiveWindow(w4())); | |
| 100 } | |
| 101 | |
| 102 // Destroying the active window should activate the next valid activatable | |
| 103 // window. | |
| 104 TEST_F(GetTopmostWindowToActivateTest, DestroyActivatesNext) { | |
| 105 ActivateWindow(w2()); | |
| 106 EXPECT_TRUE(IsActiveWindow(w2())); | |
| 107 | |
| 108 DestroyWindow2(); | |
| 109 EXPECT_EQ(NULL, w2()); | |
| 110 EXPECT_TRUE(IsActiveWindow(w4())); | |
| 111 } | |
| 112 | |
| 113 // Deactivating the active window should activate the next valid activatable | |
| 114 // window. | |
| 115 TEST_F(GetTopmostWindowToActivateTest, DeactivateActivatesNext) { | |
| 116 ActivateWindow(w2()); | |
| 117 EXPECT_TRUE(IsActiveWindow(w2())); | |
| 118 | |
| 119 DeactivateWindow(w2()); | |
| 120 EXPECT_TRUE(IsActiveWindow(w4())); | |
| 121 } | |
| 122 | |
| 123 // Test if the clicking on a menu picks the transient parent as activatable | |
| 124 // window. | |
| 125 TEST_F(ActivationControllerTest, ClickOnMenu) { | |
| 126 aura::test::TestWindowDelegate wd; | |
| 127 TestActivationDelegate ad1; | |
| 128 TestActivationDelegate ad2(false); | |
| 129 | |
| 130 scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate( | |
| 131 &wd, 1, gfx::Rect(100, 100), NULL)); | |
| 132 ad1.SetWindow(w1.get()); | |
| 133 EXPECT_TRUE(IsActiveWindow(NULL)); | |
| 134 | |
| 135 // Clicking on an activatable window activtes the window. | |
| 136 aura::test::EventGenerator generator(w1.get()); | |
| 137 generator.ClickLeftButton(); | |
| 138 EXPECT_TRUE(IsActiveWindow(w1.get())); | |
| 139 | |
| 140 // Creates a menu that covers the transient parent. | |
| 141 scoped_ptr<aura::Window> menu(aura::test::CreateTestWindowWithDelegateAndType( | |
| 142 &wd, aura::WINDOW_TYPE_MENU, 2, gfx::Rect(100, 100), NULL)); | |
| 143 ad2.SetWindow(menu.get()); | |
| 144 w1->AddTransientChild(menu.get()); | |
| 145 | |
| 146 // Clicking on a menu whose transient parent is active window shouldn't | |
| 147 // change the active window. | |
| 148 generator.ClickLeftButton(); | |
| 149 EXPECT_TRUE(IsActiveWindow(w1.get())); | |
| 150 } | |
| 151 | |
| 152 // Various assertions for activating/deactivating. | |
| 153 TEST_F(ActivationControllerTest, Deactivate) { | |
| 154 aura::test::TestWindowDelegate d1; | |
| 155 aura::test::TestWindowDelegate d2; | |
| 156 scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate( | |
| 157 &d1, 1, gfx::Rect(), NULL)); | |
| 158 scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate( | |
| 159 &d2, 2, gfx::Rect(), NULL)); | |
| 160 aura::Window* parent = w1->parent(); | |
| 161 parent->Show(); | |
| 162 ASSERT_TRUE(parent); | |
| 163 ASSERT_EQ(2u, parent->children().size()); | |
| 164 // Activate w2 and make sure it's active and frontmost. | |
| 165 ActivateWindow(w2.get()); | |
| 166 EXPECT_TRUE(IsActiveWindow(w2.get())); | |
| 167 EXPECT_FALSE(IsActiveWindow(w1.get())); | |
| 168 EXPECT_EQ(w2.get(), parent->children()[1]); | |
| 169 | |
| 170 // Activate w1 and make sure it's active and frontmost. | |
| 171 ActivateWindow(w1.get()); | |
| 172 EXPECT_TRUE(IsActiveWindow(w1.get())); | |
| 173 EXPECT_FALSE(IsActiveWindow(w2.get())); | |
| 174 EXPECT_EQ(w1.get(), parent->children()[1]); | |
| 175 | |
| 176 // Deactivate w1 and make sure w2 becomes active and frontmost. | |
| 177 DeactivateWindow(w1.get()); | |
| 178 EXPECT_FALSE(IsActiveWindow(w1.get())); | |
| 179 EXPECT_TRUE(IsActiveWindow(w2.get())); | |
| 180 EXPECT_EQ(w2.get(), parent->children()[1]); | |
| 181 } | |
| 182 | |
| 183 // Verifies that when WindowDelegate::OnLostActive is invoked the window is not | |
| 184 // active. | |
| 185 TEST_F(ActivationControllerTest, NotActiveInLostActive) { | |
| 186 TestActivationDelegate ad1; | |
| 187 aura::test::TestWindowDelegate wd; | |
| 188 scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate( | |
| 189 &wd, 1, gfx::Rect(10, 10, 50, 50), NULL)); | |
| 190 ad1.SetWindow(w1.get()); | |
| 191 scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate( | |
| 192 NULL, 1, gfx::Rect(10, 10, 50, 50), NULL)); | |
| 193 | |
| 194 // Activate w1. | |
| 195 ActivateWindow(w1.get()); | |
| 196 EXPECT_TRUE(IsActiveWindow(w1.get())); | |
| 197 | |
| 198 // Should not have gotten a OnLostActive yet. | |
| 199 EXPECT_EQ(0, ad1.lost_active_count()); | |
| 200 | |
| 201 // ActivateWindow(NULL) should not change the active window. | |
| 202 ActivateWindow(NULL); | |
| 203 EXPECT_TRUE(IsActiveWindow(w1.get())); | |
| 204 | |
| 205 // Now activate another window. | |
| 206 ActivateWindow(w2.get()); | |
| 207 | |
| 208 // Should have gotten OnLostActive and w1 should not have been active at that | |
| 209 // time. | |
| 210 EXPECT_EQ(1, ad1.lost_active_count()); | |
| 211 EXPECT_FALSE(ad1.window_was_active()); | |
| 212 } | |
| 213 | |
| 214 // Verifies that focusing another window or its children causes it to become | |
| 215 // active. | |
| 216 TEST_F(ActivationControllerTest, FocusTriggersActivation) { | |
| 217 aura::test::TestWindowDelegate wd; | |
| 218 scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate( | |
| 219 &wd, -1, gfx::Rect(50, 50), NULL)); | |
| 220 scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate( | |
| 221 &wd, -2, gfx::Rect(50, 50), NULL)); | |
| 222 scoped_ptr<aura::Window> w21(aura::test::CreateTestWindowWithDelegate( | |
| 223 &wd, -21, gfx::Rect(50, 50), w2.get())); | |
| 224 | |
| 225 ActivateWindow(w1.get()); | |
| 226 EXPECT_TRUE(IsActiveWindow(w1.get())); | |
| 227 EXPECT_TRUE(w1->HasFocus()); | |
| 228 | |
| 229 w2->Focus(); | |
| 230 EXPECT_TRUE(IsActiveWindow(w2.get())); | |
| 231 EXPECT_TRUE(w2->HasFocus()); | |
| 232 | |
| 233 ActivateWindow(w1.get()); | |
| 234 EXPECT_TRUE(IsActiveWindow(w1.get())); | |
| 235 EXPECT_TRUE(w1->HasFocus()); | |
| 236 | |
| 237 w21->Focus(); | |
| 238 EXPECT_TRUE(IsActiveWindow(w2.get())); | |
| 239 EXPECT_TRUE(w21->HasFocus()); | |
| 240 } | |
| 241 | |
| 242 // Verifies that we prevent all attempts to focus a child of a non-activatable | |
| 243 // window from claiming focus to that window. | |
| 244 TEST_F(ActivationControllerTest, PreventFocusToNonActivatableWindow) { | |
| 245 aura::test::TestWindowDelegate wd; | |
| 246 scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate( | |
| 247 &wd, -1, gfx::Rect(50, 50), NULL)); | |
| 248 // The RootWindow itself is a non-activatable parent. | |
| 249 scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate( | |
| 250 &wd, -2, gfx::Rect(50, 50), aura::RootWindow::GetInstance())); | |
| 251 scoped_ptr<aura::Window> w21(aura::test::CreateTestWindowWithDelegate( | |
| 252 &wd, -21, gfx::Rect(50, 50), w2.get())); | |
| 253 | |
| 254 ActivateWindow(w1.get()); | |
| 255 EXPECT_TRUE(IsActiveWindow(w1.get())); | |
| 256 EXPECT_TRUE(w1->HasFocus()); | |
| 257 | |
| 258 // Try activating |w2|. It's not a child of an activatable container, so it | |
| 259 // should neither be activated nor get focus. | |
| 260 ActivateWindow(w2.get()); | |
| 261 EXPECT_FALSE(IsActiveWindow(w2.get())); | |
| 262 EXPECT_FALSE(w2->HasFocus()); | |
| 263 EXPECT_TRUE(IsActiveWindow(w1.get())); | |
| 264 EXPECT_TRUE(w1->HasFocus()); | |
| 265 | |
| 266 // Try focusing |w2|. Same rules apply. | |
| 267 w2->Focus(); | |
| 268 EXPECT_FALSE(IsActiveWindow(w2.get())); | |
| 269 EXPECT_FALSE(w2->HasFocus()); | |
| 270 EXPECT_TRUE(IsActiveWindow(w1.get())); | |
| 271 EXPECT_TRUE(w1->HasFocus()); | |
| 272 | |
| 273 // Try focusing |w21|. Same rules apply. | |
| 274 EXPECT_FALSE(IsActiveWindow(w2.get())); | |
| 275 EXPECT_FALSE(w21->HasFocus()); | |
| 276 EXPECT_TRUE(IsActiveWindow(w1.get())); | |
| 277 EXPECT_TRUE(w1->HasFocus()); | |
| 278 } | |
| 279 | |
| 280 } // namespace test | |
| 281 } // namespace aura_shell | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 8926004:
Revert 114095 - Move the concept of Activation to the Shell. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/