| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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/wm/core/focus_controller.h" | |
| 6 | |
| 7 #include <map> | |
| 8 | |
| 9 #include "ui/aura/client/aura_constants.h" | |
| 10 #include "ui/aura/client/default_capture_client.h" | |
| 11 #include "ui/aura/client/focus_change_observer.h" | |
| 12 #include "ui/aura/test/aura_test_base.h" | |
| 13 #include "ui/aura/test/test_window_delegate.h" | |
| 14 #include "ui/aura/test/test_windows.h" | |
| 15 #include "ui/aura/window.h" | |
| 16 #include "ui/aura/window_event_dispatcher.h" | |
| 17 #include "ui/aura/window_tracker.h" | |
| 18 #include "ui/base/ime/dummy_text_input_client.h" | |
| 19 #include "ui/base/ime/text_input_focus_manager.h" | |
| 20 #include "ui/events/event.h" | |
| 21 #include "ui/events/event_constants.h" | |
| 22 #include "ui/events/event_handler.h" | |
| 23 #include "ui/events/test/event_generator.h" | |
| 24 #include "ui/wm/core/base_focus_rules.h" | |
| 25 #include "ui/wm/core/wm_state.h" | |
| 26 #include "ui/wm/public/activation_change_observer.h" | |
| 27 #include "ui/wm/public/activation_client.h" | |
| 28 | |
| 29 namespace wm { | |
| 30 | |
| 31 class FocusNotificationObserver : public aura::client::ActivationChangeObserver, | |
| 32 public aura::client::FocusChangeObserver { | |
| 33 public: | |
| 34 FocusNotificationObserver() | |
| 35 : activation_changed_count_(0), | |
| 36 focus_changed_count_(0), | |
| 37 reactivation_count_(0), | |
| 38 reactivation_requested_window_(NULL), | |
| 39 reactivation_actual_window_(NULL) {} | |
| 40 virtual ~FocusNotificationObserver() {} | |
| 41 | |
| 42 void ExpectCounts(int activation_changed_count, int focus_changed_count) { | |
| 43 EXPECT_EQ(activation_changed_count, activation_changed_count_); | |
| 44 EXPECT_EQ(focus_changed_count, focus_changed_count_); | |
| 45 } | |
| 46 int reactivation_count() const { | |
| 47 return reactivation_count_; | |
| 48 } | |
| 49 aura::Window* reactivation_requested_window() const { | |
| 50 return reactivation_requested_window_; | |
| 51 } | |
| 52 aura::Window* reactivation_actual_window() const { | |
| 53 return reactivation_actual_window_; | |
| 54 } | |
| 55 | |
| 56 private: | |
| 57 // Overridden from aura::client::ActivationChangeObserver: | |
| 58 virtual void OnWindowActivated(aura::Window* gained_active, | |
| 59 aura::Window* lost_active) override { | |
| 60 ++activation_changed_count_; | |
| 61 } | |
| 62 virtual void OnAttemptToReactivateWindow( | |
| 63 aura::Window* request_active, | |
| 64 aura::Window* actual_active) override { | |
| 65 ++reactivation_count_; | |
| 66 reactivation_requested_window_ = request_active; | |
| 67 reactivation_actual_window_ = actual_active; | |
| 68 } | |
| 69 | |
| 70 // Overridden from aura::client::FocusChangeObserver: | |
| 71 virtual void OnWindowFocused(aura::Window* gained_focus, | |
| 72 aura::Window* lost_focus) override { | |
| 73 ++focus_changed_count_; | |
| 74 } | |
| 75 | |
| 76 int activation_changed_count_; | |
| 77 int focus_changed_count_; | |
| 78 int reactivation_count_; | |
| 79 aura::Window* reactivation_requested_window_; | |
| 80 aura::Window* reactivation_actual_window_; | |
| 81 | |
| 82 DISALLOW_COPY_AND_ASSIGN(FocusNotificationObserver); | |
| 83 }; | |
| 84 | |
| 85 class WindowDeleter { | |
| 86 public: | |
| 87 virtual aura::Window* GetDeletedWindow() = 0; | |
| 88 | |
| 89 protected: | |
| 90 virtual ~WindowDeleter() {} | |
| 91 }; | |
| 92 | |
| 93 // ActivationChangeObserver and FocusChangeObserver that keeps track of whether | |
| 94 // it was notified about activation changes or focus changes with a deleted | |
| 95 // window. | |
| 96 class RecordingActivationAndFocusChangeObserver | |
| 97 : public aura::client::ActivationChangeObserver, | |
| 98 public aura::client::FocusChangeObserver { | |
| 99 public: | |
| 100 RecordingActivationAndFocusChangeObserver(aura::Window* root, | |
| 101 WindowDeleter* deleter) | |
| 102 : root_(root), | |
| 103 deleter_(deleter), | |
| 104 was_notified_with_deleted_window_(false) { | |
| 105 aura::client::GetActivationClient(root_)->AddObserver(this); | |
| 106 aura::client::GetFocusClient(root_)->AddObserver(this); | |
| 107 } | |
| 108 virtual ~RecordingActivationAndFocusChangeObserver() { | |
| 109 aura::client::GetActivationClient(root_)->RemoveObserver(this); | |
| 110 aura::client::GetFocusClient(root_)->RemoveObserver(this); | |
| 111 } | |
| 112 | |
| 113 bool was_notified_with_deleted_window() const { | |
| 114 return was_notified_with_deleted_window_; | |
| 115 } | |
| 116 | |
| 117 // Overridden from aura::client::ActivationChangeObserver: | |
| 118 virtual void OnWindowActivated(aura::Window* gained_active, | |
| 119 aura::Window* lost_active) override { | |
| 120 if (lost_active && lost_active == deleter_->GetDeletedWindow()) | |
| 121 was_notified_with_deleted_window_ = true; | |
| 122 } | |
| 123 | |
| 124 // Overridden from aura::client::FocusChangeObserver: | |
| 125 virtual void OnWindowFocused(aura::Window* gained_focus, | |
| 126 aura::Window* lost_focus) override { | |
| 127 if (lost_focus && lost_focus == deleter_->GetDeletedWindow()) | |
| 128 was_notified_with_deleted_window_ = true; | |
| 129 } | |
| 130 | |
| 131 private: | |
| 132 aura::Window* root_; | |
| 133 | |
| 134 // Not owned. | |
| 135 WindowDeleter* deleter_; | |
| 136 | |
| 137 // Whether the observer was notified about the loss of activation or the | |
| 138 // loss of focus with a window already deleted by |deleter_| as the | |
| 139 // |lost_active| or |lost_focus| parameter. | |
| 140 bool was_notified_with_deleted_window_; | |
| 141 | |
| 142 DISALLOW_COPY_AND_ASSIGN(RecordingActivationAndFocusChangeObserver); | |
| 143 }; | |
| 144 | |
| 145 // ActivationChangeObserver that deletes the window losing activation. | |
| 146 class DeleteOnLoseActivationChangeObserver : | |
| 147 public aura::client::ActivationChangeObserver, | |
| 148 public WindowDeleter { | |
| 149 public: | |
| 150 explicit DeleteOnLoseActivationChangeObserver(aura::Window* window) | |
| 151 : root_(window->GetRootWindow()), | |
| 152 window_(window), | |
| 153 did_delete_(false) { | |
| 154 aura::client::GetActivationClient(root_)->AddObserver(this); | |
| 155 } | |
| 156 virtual ~DeleteOnLoseActivationChangeObserver() { | |
| 157 aura::client::GetActivationClient(root_)->RemoveObserver(this); | |
| 158 } | |
| 159 | |
| 160 // Overridden from aura::client::ActivationChangeObserver: | |
| 161 virtual void OnWindowActivated(aura::Window* gained_active, | |
| 162 aura::Window* lost_active) override { | |
| 163 if (window_ && lost_active == window_) { | |
| 164 delete lost_active; | |
| 165 did_delete_ = true; | |
| 166 } | |
| 167 } | |
| 168 | |
| 169 // Overridden from WindowDeleter: | |
| 170 virtual aura::Window* GetDeletedWindow() override { | |
| 171 return did_delete_ ? window_ : NULL; | |
| 172 } | |
| 173 | |
| 174 private: | |
| 175 aura::Window* root_; | |
| 176 aura::Window* window_; | |
| 177 bool did_delete_; | |
| 178 | |
| 179 DISALLOW_COPY_AND_ASSIGN(DeleteOnLoseActivationChangeObserver); | |
| 180 }; | |
| 181 | |
| 182 // FocusChangeObserver that deletes the window losing focus. | |
| 183 class DeleteOnLoseFocusChangeObserver | |
| 184 : public aura::client::FocusChangeObserver, | |
| 185 public WindowDeleter { | |
| 186 public: | |
| 187 explicit DeleteOnLoseFocusChangeObserver(aura::Window* window) | |
| 188 : root_(window->GetRootWindow()), | |
| 189 window_(window), | |
| 190 did_delete_(false) { | |
| 191 aura::client::GetFocusClient(root_)->AddObserver(this); | |
| 192 } | |
| 193 virtual ~DeleteOnLoseFocusChangeObserver() { | |
| 194 aura::client::GetFocusClient(root_)->RemoveObserver(this); | |
| 195 } | |
| 196 | |
| 197 // Overridden from aura::client::FocusChangeObserver: | |
| 198 virtual void OnWindowFocused(aura::Window* gained_focus, | |
| 199 aura::Window* lost_focus) override { | |
| 200 if (window_ && lost_focus == window_) { | |
| 201 delete lost_focus; | |
| 202 did_delete_ = true; | |
| 203 } | |
| 204 } | |
| 205 | |
| 206 // Overridden from WindowDeleter: | |
| 207 virtual aura::Window* GetDeletedWindow() override { | |
| 208 return did_delete_ ? window_ : NULL; | |
| 209 } | |
| 210 | |
| 211 private: | |
| 212 aura::Window* root_; | |
| 213 aura::Window* window_; | |
| 214 bool did_delete_; | |
| 215 | |
| 216 DISALLOW_COPY_AND_ASSIGN(DeleteOnLoseFocusChangeObserver); | |
| 217 }; | |
| 218 | |
| 219 class ScopedFocusNotificationObserver : public FocusNotificationObserver { | |
| 220 public: | |
| 221 ScopedFocusNotificationObserver(aura::Window* root_window) | |
| 222 : root_window_(root_window) { | |
| 223 aura::client::GetActivationClient(root_window_)->AddObserver(this); | |
| 224 aura::client::GetFocusClient(root_window_)->AddObserver(this); | |
| 225 } | |
| 226 virtual ~ScopedFocusNotificationObserver() { | |
| 227 aura::client::GetActivationClient(root_window_)->RemoveObserver(this); | |
| 228 aura::client::GetFocusClient(root_window_)->RemoveObserver(this); | |
| 229 } | |
| 230 | |
| 231 private: | |
| 232 aura::Window* root_window_; | |
| 233 | |
| 234 DISALLOW_COPY_AND_ASSIGN(ScopedFocusNotificationObserver); | |
| 235 }; | |
| 236 | |
| 237 class ScopedTargetFocusNotificationObserver : public FocusNotificationObserver { | |
| 238 public: | |
| 239 ScopedTargetFocusNotificationObserver(aura::Window* root_window, int id) | |
| 240 : target_(root_window->GetChildById(id)) { | |
| 241 aura::client::SetActivationChangeObserver(target_, this); | |
| 242 aura::client::SetFocusChangeObserver(target_, this); | |
| 243 tracker_.Add(target_); | |
| 244 } | |
| 245 virtual ~ScopedTargetFocusNotificationObserver() { | |
| 246 if (tracker_.Contains(target_)) { | |
| 247 aura::client::SetActivationChangeObserver(target_, NULL); | |
| 248 aura::client::SetFocusChangeObserver(target_, NULL); | |
| 249 } | |
| 250 } | |
| 251 | |
| 252 private: | |
| 253 aura::Window* target_; | |
| 254 aura::WindowTracker tracker_; | |
| 255 | |
| 256 DISALLOW_COPY_AND_ASSIGN(ScopedTargetFocusNotificationObserver); | |
| 257 }; | |
| 258 | |
| 259 class ScopedFocusedTextInputClientChanger | |
| 260 : public ScopedFocusNotificationObserver { | |
| 261 public: | |
| 262 ScopedFocusedTextInputClientChanger(aura::Window* root_window, | |
| 263 ui::TextInputClient* text_input_client) | |
| 264 : ScopedFocusNotificationObserver(root_window), | |
| 265 text_input_client_(text_input_client) {} | |
| 266 | |
| 267 private: | |
| 268 // Overridden from aura::client::FocusChangeObserver: | |
| 269 virtual void OnWindowFocused(aura::Window* gained_focus, | |
| 270 aura::Window* lost_focus) override { | |
| 271 ui::TextInputFocusManager::GetInstance()->FocusTextInputClient( | |
| 272 text_input_client_); | |
| 273 } | |
| 274 | |
| 275 ui::TextInputClient* text_input_client_; | |
| 276 }; | |
| 277 | |
| 278 // Used to fake the handling of events in the pre-target phase. | |
| 279 class SimpleEventHandler : public ui::EventHandler { | |
| 280 public: | |
| 281 SimpleEventHandler() {} | |
| 282 virtual ~SimpleEventHandler() {} | |
| 283 | |
| 284 // Overridden from ui::EventHandler: | |
| 285 virtual void OnMouseEvent(ui::MouseEvent* event) override { | |
| 286 event->SetHandled(); | |
| 287 } | |
| 288 virtual void OnGestureEvent(ui::GestureEvent* event) override { | |
| 289 event->SetHandled(); | |
| 290 } | |
| 291 | |
| 292 private: | |
| 293 DISALLOW_COPY_AND_ASSIGN(SimpleEventHandler); | |
| 294 }; | |
| 295 | |
| 296 class FocusShiftingActivationObserver | |
| 297 : public aura::client::ActivationChangeObserver { | |
| 298 public: | |
| 299 explicit FocusShiftingActivationObserver(aura::Window* activated_window) | |
| 300 : activated_window_(activated_window), | |
| 301 shift_focus_to_(NULL) {} | |
| 302 virtual ~FocusShiftingActivationObserver() {} | |
| 303 | |
| 304 void set_shift_focus_to(aura::Window* shift_focus_to) { | |
| 305 shift_focus_to_ = shift_focus_to; | |
| 306 } | |
| 307 | |
| 308 private: | |
| 309 // Overridden from aura::client::ActivationChangeObserver: | |
| 310 virtual void OnWindowActivated(aura::Window* gained_active, | |
| 311 aura::Window* lost_active) override { | |
| 312 // Shift focus to a child. This should prevent the default focusing from | |
| 313 // occurring in FocusController::FocusWindow(). | |
| 314 if (gained_active == activated_window_) { | |
| 315 aura::client::FocusClient* client = | |
| 316 aura::client::GetFocusClient(gained_active); | |
| 317 client->FocusWindow(shift_focus_to_); | |
| 318 } | |
| 319 } | |
| 320 | |
| 321 aura::Window* activated_window_; | |
| 322 aura::Window* shift_focus_to_; | |
| 323 | |
| 324 DISALLOW_COPY_AND_ASSIGN(FocusShiftingActivationObserver); | |
| 325 }; | |
| 326 | |
| 327 // BaseFocusRules subclass that allows basic overrides of focus/activation to | |
| 328 // be tested. This is intended more as a test that the override system works at | |
| 329 // all, rather than as an exhaustive set of use cases, those should be covered | |
| 330 // in tests for those FocusRules implementations. | |
| 331 class TestFocusRules : public BaseFocusRules { | |
| 332 public: | |
| 333 TestFocusRules() : focus_restriction_(NULL) {} | |
| 334 | |
| 335 // Restricts focus and activation to this window and its child hierarchy. | |
| 336 void set_focus_restriction(aura::Window* focus_restriction) { | |
| 337 focus_restriction_ = focus_restriction; | |
| 338 } | |
| 339 | |
| 340 // Overridden from BaseFocusRules: | |
| 341 virtual bool SupportsChildActivation(aura::Window* window) const override { | |
| 342 // In FocusControllerTests, only the RootWindow has activatable children. | |
| 343 return window->GetRootWindow() == window; | |
| 344 } | |
| 345 virtual bool CanActivateWindow(aura::Window* window) const override { | |
| 346 // Restricting focus to a non-activatable child window means the activatable | |
| 347 // parent outside the focus restriction is activatable. | |
| 348 bool can_activate = | |
| 349 CanFocusOrActivate(window) || window->Contains(focus_restriction_); | |
| 350 return can_activate ? BaseFocusRules::CanActivateWindow(window) : false; | |
| 351 } | |
| 352 virtual bool CanFocusWindow(aura::Window* window) const override { | |
| 353 return CanFocusOrActivate(window) ? | |
| 354 BaseFocusRules::CanFocusWindow(window) : false; | |
| 355 } | |
| 356 virtual aura::Window* GetActivatableWindow( | |
| 357 aura::Window* window) const override { | |
| 358 return BaseFocusRules::GetActivatableWindow( | |
| 359 CanFocusOrActivate(window) ? window : focus_restriction_); | |
| 360 } | |
| 361 virtual aura::Window* GetFocusableWindow( | |
| 362 aura::Window* window) const override { | |
| 363 return BaseFocusRules::GetFocusableWindow( | |
| 364 CanFocusOrActivate(window) ? window : focus_restriction_); | |
| 365 } | |
| 366 virtual aura::Window* GetNextActivatableWindow( | |
| 367 aura::Window* ignore) const override { | |
| 368 aura::Window* next_activatable = | |
| 369 BaseFocusRules::GetNextActivatableWindow(ignore); | |
| 370 return CanFocusOrActivate(next_activatable) ? | |
| 371 next_activatable : GetActivatableWindow(focus_restriction_); | |
| 372 } | |
| 373 | |
| 374 private: | |
| 375 bool CanFocusOrActivate(aura::Window* window) const { | |
| 376 return !focus_restriction_ || focus_restriction_->Contains(window); | |
| 377 } | |
| 378 | |
| 379 aura::Window* focus_restriction_; | |
| 380 | |
| 381 DISALLOW_COPY_AND_ASSIGN(TestFocusRules); | |
| 382 }; | |
| 383 | |
| 384 // Common infrastructure shared by all FocusController test types. | |
| 385 class FocusControllerTestBase : public aura::test::AuraTestBase { | |
| 386 protected: | |
| 387 FocusControllerTestBase() {} | |
| 388 | |
| 389 // Overridden from aura::test::AuraTestBase: | |
| 390 virtual void SetUp() override { | |
| 391 wm_state_.reset(new wm::WMState); | |
| 392 // FocusController registers itself as an Env observer so it can catch all | |
| 393 // window initializations, including the root_window()'s, so we create it | |
| 394 // before allowing the base setup. | |
| 395 test_focus_rules_ = new TestFocusRules; | |
| 396 focus_controller_.reset(new FocusController(test_focus_rules_)); | |
| 397 aura::test::AuraTestBase::SetUp(); | |
| 398 root_window()->AddPreTargetHandler(focus_controller_.get()); | |
| 399 aura::client::SetFocusClient(root_window(), focus_controller_.get()); | |
| 400 aura::client::SetActivationClient(root_window(), focus_controller_.get()); | |
| 401 | |
| 402 // Hierarchy used by all tests: | |
| 403 // root_window | |
| 404 // +-- w1 | |
| 405 // | +-- w11 | |
| 406 // | +-- w12 | |
| 407 // +-- w2 | |
| 408 // | +-- w21 | |
| 409 // | +-- w211 | |
| 410 // +-- w3 | |
| 411 aura::Window* w1 = aura::test::CreateTestWindowWithDelegate( | |
| 412 aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 1, | |
| 413 gfx::Rect(0, 0, 50, 50), root_window()); | |
| 414 aura::test::CreateTestWindowWithDelegate( | |
| 415 aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 11, | |
| 416 gfx::Rect(5, 5, 10, 10), w1); | |
| 417 aura::test::CreateTestWindowWithDelegate( | |
| 418 aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 12, | |
| 419 gfx::Rect(15, 15, 10, 10), w1); | |
| 420 aura::Window* w2 = aura::test::CreateTestWindowWithDelegate( | |
| 421 aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 2, | |
| 422 gfx::Rect(75, 75, 50, 50), root_window()); | |
| 423 aura::Window* w21 = aura::test::CreateTestWindowWithDelegate( | |
| 424 aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 21, | |
| 425 gfx::Rect(5, 5, 10, 10), w2); | |
| 426 aura::test::CreateTestWindowWithDelegate( | |
| 427 aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 211, | |
| 428 gfx::Rect(1, 1, 5, 5), w21); | |
| 429 aura::test::CreateTestWindowWithDelegate( | |
| 430 aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 3, | |
| 431 gfx::Rect(125, 125, 50, 50), root_window()); | |
| 432 } | |
| 433 virtual void TearDown() override { | |
| 434 root_window()->RemovePreTargetHandler(focus_controller_.get()); | |
| 435 aura::test::AuraTestBase::TearDown(); | |
| 436 test_focus_rules_ = NULL; // Owned by FocusController. | |
| 437 focus_controller_.reset(); | |
| 438 wm_state_.reset(); | |
| 439 } | |
| 440 | |
| 441 void FocusWindow(aura::Window* window) { | |
| 442 aura::client::GetFocusClient(root_window())->FocusWindow(window); | |
| 443 } | |
| 444 aura::Window* GetFocusedWindow() { | |
| 445 return aura::client::GetFocusClient(root_window())->GetFocusedWindow(); | |
| 446 } | |
| 447 int GetFocusedWindowId() { | |
| 448 aura::Window* focused_window = GetFocusedWindow(); | |
| 449 return focused_window ? focused_window->id() : -1; | |
| 450 } | |
| 451 void ActivateWindow(aura::Window* window) { | |
| 452 aura::client::GetActivationClient(root_window())->ActivateWindow(window); | |
| 453 } | |
| 454 void DeactivateWindow(aura::Window* window) { | |
| 455 aura::client::GetActivationClient(root_window())->DeactivateWindow(window); | |
| 456 } | |
| 457 aura::Window* GetActiveWindow() { | |
| 458 return aura::client::GetActivationClient(root_window())->GetActiveWindow(); | |
| 459 } | |
| 460 int GetActiveWindowId() { | |
| 461 aura::Window* active_window = GetActiveWindow(); | |
| 462 return active_window ? active_window->id() : -1; | |
| 463 } | |
| 464 | |
| 465 TestFocusRules* test_focus_rules() { return test_focus_rules_; } | |
| 466 | |
| 467 // Test functions. | |
| 468 virtual void BasicFocus() = 0; | |
| 469 virtual void BasicActivation() = 0; | |
| 470 virtual void FocusEvents() = 0; | |
| 471 virtual void DuplicateFocusEvents() {} | |
| 472 virtual void ActivationEvents() = 0; | |
| 473 virtual void ReactivationEvents() {} | |
| 474 virtual void DuplicateActivationEvents() {} | |
| 475 virtual void ShiftFocusWithinActiveWindow() {} | |
| 476 virtual void ShiftFocusToChildOfInactiveWindow() {} | |
| 477 virtual void ShiftFocusToParentOfFocusedWindow() {} | |
| 478 virtual void FocusRulesOverride() = 0; | |
| 479 virtual void ActivationRulesOverride() = 0; | |
| 480 virtual void ShiftFocusOnActivation() {} | |
| 481 virtual void ShiftFocusOnActivationDueToHide() {} | |
| 482 virtual void NoShiftActiveOnActivation() {} | |
| 483 virtual void NoFocusChangeOnClickOnCaptureWindow() {} | |
| 484 virtual void ChangeFocusWhenNothingFocusedAndCaptured() {} | |
| 485 virtual void DontPassDeletedWindow() {} | |
| 486 virtual void FocusedTextInputClient() {} | |
| 487 | |
| 488 private: | |
| 489 scoped_ptr<FocusController> focus_controller_; | |
| 490 TestFocusRules* test_focus_rules_; | |
| 491 scoped_ptr<wm::WMState> wm_state_; | |
| 492 | |
| 493 DISALLOW_COPY_AND_ASSIGN(FocusControllerTestBase); | |
| 494 }; | |
| 495 | |
| 496 // Test base for tests where focus is directly set to a target window. | |
| 497 class FocusControllerDirectTestBase : public FocusControllerTestBase { | |
| 498 protected: | |
| 499 FocusControllerDirectTestBase() {} | |
| 500 | |
| 501 // Different test types shift focus in different ways. | |
| 502 virtual void FocusWindowDirect(aura::Window* window) = 0; | |
| 503 virtual void ActivateWindowDirect(aura::Window* window) = 0; | |
| 504 virtual void DeactivateWindowDirect(aura::Window* window) = 0; | |
| 505 | |
| 506 // Input events do not change focus if the window can not be focused. | |
| 507 virtual bool IsInputEvent() = 0; | |
| 508 | |
| 509 void FocusWindowById(int id) { | |
| 510 aura::Window* window = root_window()->GetChildById(id); | |
| 511 DCHECK(window); | |
| 512 FocusWindowDirect(window); | |
| 513 } | |
| 514 void ActivateWindowById(int id) { | |
| 515 aura::Window* window = root_window()->GetChildById(id); | |
| 516 DCHECK(window); | |
| 517 ActivateWindowDirect(window); | |
| 518 } | |
| 519 | |
| 520 // Overridden from FocusControllerTestBase: | |
| 521 virtual void BasicFocus() override { | |
| 522 EXPECT_EQ(NULL, GetFocusedWindow()); | |
| 523 FocusWindowById(1); | |
| 524 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 525 FocusWindowById(2); | |
| 526 EXPECT_EQ(2, GetFocusedWindowId()); | |
| 527 } | |
| 528 virtual void BasicActivation() override { | |
| 529 EXPECT_EQ(NULL, GetActiveWindow()); | |
| 530 ActivateWindowById(1); | |
| 531 EXPECT_EQ(1, GetActiveWindowId()); | |
| 532 ActivateWindowById(2); | |
| 533 EXPECT_EQ(2, GetActiveWindowId()); | |
| 534 // Verify that attempting to deactivate NULL does not crash and does not | |
| 535 // change activation. | |
| 536 DeactivateWindow(NULL); | |
| 537 EXPECT_EQ(2, GetActiveWindowId()); | |
| 538 DeactivateWindow(GetActiveWindow()); | |
| 539 EXPECT_EQ(1, GetActiveWindowId()); | |
| 540 } | |
| 541 virtual void FocusEvents() override { | |
| 542 ScopedFocusNotificationObserver root_observer(root_window()); | |
| 543 ScopedTargetFocusNotificationObserver observer1(root_window(), 1); | |
| 544 ScopedTargetFocusNotificationObserver observer2(root_window(), 2); | |
| 545 | |
| 546 root_observer.ExpectCounts(0, 0); | |
| 547 observer1.ExpectCounts(0, 0); | |
| 548 observer2.ExpectCounts(0, 0); | |
| 549 | |
| 550 FocusWindowById(1); | |
| 551 root_observer.ExpectCounts(1, 1); | |
| 552 observer1.ExpectCounts(1, 1); | |
| 553 observer2.ExpectCounts(0, 0); | |
| 554 | |
| 555 FocusWindowById(2); | |
| 556 root_observer.ExpectCounts(2, 2); | |
| 557 observer1.ExpectCounts(2, 2); | |
| 558 observer2.ExpectCounts(1, 1); | |
| 559 } | |
| 560 virtual void DuplicateFocusEvents() override { | |
| 561 // Focusing an existing focused window should not resend focus events. | |
| 562 ScopedFocusNotificationObserver root_observer(root_window()); | |
| 563 ScopedTargetFocusNotificationObserver observer1(root_window(), 1); | |
| 564 | |
| 565 root_observer.ExpectCounts(0, 0); | |
| 566 observer1.ExpectCounts(0, 0); | |
| 567 | |
| 568 FocusWindowById(1); | |
| 569 root_observer.ExpectCounts(1, 1); | |
| 570 observer1.ExpectCounts(1, 1); | |
| 571 | |
| 572 FocusWindowById(1); | |
| 573 root_observer.ExpectCounts(1, 1); | |
| 574 observer1.ExpectCounts(1, 1); | |
| 575 } | |
| 576 virtual void ActivationEvents() override { | |
| 577 ActivateWindowById(1); | |
| 578 | |
| 579 ScopedFocusNotificationObserver root_observer(root_window()); | |
| 580 ScopedTargetFocusNotificationObserver observer1(root_window(), 1); | |
| 581 ScopedTargetFocusNotificationObserver observer2(root_window(), 2); | |
| 582 | |
| 583 root_observer.ExpectCounts(0, 0); | |
| 584 observer1.ExpectCounts(0, 0); | |
| 585 observer2.ExpectCounts(0, 0); | |
| 586 | |
| 587 ActivateWindowById(2); | |
| 588 root_observer.ExpectCounts(1, 1); | |
| 589 observer1.ExpectCounts(1, 1); | |
| 590 observer2.ExpectCounts(1, 1); | |
| 591 } | |
| 592 virtual void ReactivationEvents() override { | |
| 593 ActivateWindowById(1); | |
| 594 ScopedFocusNotificationObserver root_observer(root_window()); | |
| 595 EXPECT_EQ(0, root_observer.reactivation_count()); | |
| 596 root_window()->GetChildById(2)->Hide(); | |
| 597 // When we attempt to activate "2", which cannot be activated because it | |
| 598 // is not visible, "1" will be reactivated. | |
| 599 ActivateWindowById(2); | |
| 600 EXPECT_EQ(1, root_observer.reactivation_count()); | |
| 601 EXPECT_EQ(root_window()->GetChildById(2), | |
| 602 root_observer.reactivation_requested_window()); | |
| 603 EXPECT_EQ(root_window()->GetChildById(1), | |
| 604 root_observer.reactivation_actual_window()); | |
| 605 } | |
| 606 virtual void DuplicateActivationEvents() override { | |
| 607 // Activating an existing active window should not resend activation events. | |
| 608 ActivateWindowById(1); | |
| 609 | |
| 610 ScopedFocusNotificationObserver root_observer(root_window()); | |
| 611 ScopedTargetFocusNotificationObserver observer1(root_window(), 1); | |
| 612 ScopedTargetFocusNotificationObserver observer2(root_window(), 2); | |
| 613 | |
| 614 root_observer.ExpectCounts(0, 0); | |
| 615 observer1.ExpectCounts(0, 0); | |
| 616 observer2.ExpectCounts(0, 0); | |
| 617 | |
| 618 ActivateWindowById(2); | |
| 619 root_observer.ExpectCounts(1, 1); | |
| 620 observer1.ExpectCounts(1, 1); | |
| 621 observer2.ExpectCounts(1, 1); | |
| 622 | |
| 623 ActivateWindowById(2); | |
| 624 root_observer.ExpectCounts(1, 1); | |
| 625 observer1.ExpectCounts(1, 1); | |
| 626 observer2.ExpectCounts(1, 1); | |
| 627 } | |
| 628 virtual void ShiftFocusWithinActiveWindow() override { | |
| 629 ActivateWindowById(1); | |
| 630 EXPECT_EQ(1, GetActiveWindowId()); | |
| 631 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 632 FocusWindowById(11); | |
| 633 EXPECT_EQ(11, GetFocusedWindowId()); | |
| 634 FocusWindowById(12); | |
| 635 EXPECT_EQ(12, GetFocusedWindowId()); | |
| 636 } | |
| 637 virtual void ShiftFocusToChildOfInactiveWindow() override { | |
| 638 ActivateWindowById(2); | |
| 639 EXPECT_EQ(2, GetActiveWindowId()); | |
| 640 EXPECT_EQ(2, GetFocusedWindowId()); | |
| 641 FocusWindowById(11); | |
| 642 EXPECT_EQ(1, GetActiveWindowId()); | |
| 643 EXPECT_EQ(11, GetFocusedWindowId()); | |
| 644 } | |
| 645 virtual void ShiftFocusToParentOfFocusedWindow() override { | |
| 646 ActivateWindowById(1); | |
| 647 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 648 FocusWindowById(11); | |
| 649 EXPECT_EQ(11, GetFocusedWindowId()); | |
| 650 FocusWindowById(1); | |
| 651 // Focus should _not_ shift to the parent of the already-focused window. | |
| 652 EXPECT_EQ(11, GetFocusedWindowId()); | |
| 653 } | |
| 654 virtual void FocusRulesOverride() override { | |
| 655 EXPECT_EQ(NULL, GetFocusedWindow()); | |
| 656 FocusWindowById(11); | |
| 657 EXPECT_EQ(11, GetFocusedWindowId()); | |
| 658 | |
| 659 test_focus_rules()->set_focus_restriction(root_window()->GetChildById(211)); | |
| 660 FocusWindowById(12); | |
| 661 // Input events leave focus unchanged; direct API calls will change focus | |
| 662 // to the restricted window. | |
| 663 int focused_window = IsInputEvent() ? 11 : 211; | |
| 664 EXPECT_EQ(focused_window, GetFocusedWindowId()); | |
| 665 | |
| 666 test_focus_rules()->set_focus_restriction(NULL); | |
| 667 FocusWindowById(12); | |
| 668 EXPECT_EQ(12, GetFocusedWindowId()); | |
| 669 } | |
| 670 virtual void ActivationRulesOverride() override { | |
| 671 ActivateWindowById(1); | |
| 672 EXPECT_EQ(1, GetActiveWindowId()); | |
| 673 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 674 | |
| 675 aura::Window* w3 = root_window()->GetChildById(3); | |
| 676 test_focus_rules()->set_focus_restriction(w3); | |
| 677 | |
| 678 ActivateWindowById(2); | |
| 679 // Input events leave activation unchanged; direct API calls will activate | |
| 680 // the restricted window. | |
| 681 int active_window = IsInputEvent() ? 1 : 3; | |
| 682 EXPECT_EQ(active_window, GetActiveWindowId()); | |
| 683 EXPECT_EQ(active_window, GetFocusedWindowId()); | |
| 684 | |
| 685 test_focus_rules()->set_focus_restriction(NULL); | |
| 686 ActivateWindowById(2); | |
| 687 EXPECT_EQ(2, GetActiveWindowId()); | |
| 688 EXPECT_EQ(2, GetFocusedWindowId()); | |
| 689 } | |
| 690 virtual void ShiftFocusOnActivation() override { | |
| 691 // When a window is activated, by default that window is also focused. | |
| 692 // An ActivationChangeObserver may shift focus to another window within the | |
| 693 // same activatable window. | |
| 694 ActivateWindowById(2); | |
| 695 EXPECT_EQ(2, GetFocusedWindowId()); | |
| 696 ActivateWindowById(1); | |
| 697 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 698 | |
| 699 ActivateWindowById(2); | |
| 700 | |
| 701 aura::Window* target = root_window()->GetChildById(1); | |
| 702 aura::client::ActivationClient* client = | |
| 703 aura::client::GetActivationClient(root_window()); | |
| 704 | |
| 705 scoped_ptr<FocusShiftingActivationObserver> observer( | |
| 706 new FocusShiftingActivationObserver(target)); | |
| 707 observer->set_shift_focus_to(target->GetChildById(11)); | |
| 708 client->AddObserver(observer.get()); | |
| 709 | |
| 710 ActivateWindowById(1); | |
| 711 | |
| 712 // w1's ActivationChangeObserver shifted focus to this child, pre-empting | |
| 713 // FocusController's default setting. | |
| 714 EXPECT_EQ(11, GetFocusedWindowId()); | |
| 715 | |
| 716 ActivateWindowById(2); | |
| 717 EXPECT_EQ(2, GetFocusedWindowId()); | |
| 718 | |
| 719 // Simulate a focus reset by the ActivationChangeObserver. This should | |
| 720 // trigger the default setting in FocusController. | |
| 721 observer->set_shift_focus_to(NULL); | |
| 722 ActivateWindowById(1); | |
| 723 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 724 | |
| 725 client->RemoveObserver(observer.get()); | |
| 726 | |
| 727 ActivateWindowById(2); | |
| 728 EXPECT_EQ(2, GetFocusedWindowId()); | |
| 729 ActivateWindowById(1); | |
| 730 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 731 } | |
| 732 virtual void ShiftFocusOnActivationDueToHide() override { | |
| 733 // Similar to ShiftFocusOnActivation except the activation change is | |
| 734 // triggered by hiding the active window. | |
| 735 ActivateWindowById(1); | |
| 736 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 737 | |
| 738 // Removes window 3 as candidate for next activatable window. | |
| 739 root_window()->GetChildById(3)->Hide(); | |
| 740 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 741 | |
| 742 aura::Window* target = root_window()->GetChildById(2); | |
| 743 aura::client::ActivationClient* client = | |
| 744 aura::client::GetActivationClient(root_window()); | |
| 745 | |
| 746 scoped_ptr<FocusShiftingActivationObserver> observer( | |
| 747 new FocusShiftingActivationObserver(target)); | |
| 748 observer->set_shift_focus_to(target->GetChildById(21)); | |
| 749 client->AddObserver(observer.get()); | |
| 750 | |
| 751 // Hide the active window. | |
| 752 root_window()->GetChildById(1)->Hide(); | |
| 753 | |
| 754 EXPECT_EQ(21, GetFocusedWindowId()); | |
| 755 | |
| 756 client->RemoveObserver(observer.get()); | |
| 757 } | |
| 758 virtual void NoShiftActiveOnActivation() override { | |
| 759 // When a window is activated, we need to prevent any change to activation | |
| 760 // from being made in response to an activation change notification. | |
| 761 } | |
| 762 | |
| 763 virtual void NoFocusChangeOnClickOnCaptureWindow() override { | |
| 764 scoped_ptr<aura::client::DefaultCaptureClient> capture_client( | |
| 765 new aura::client::DefaultCaptureClient(root_window())); | |
| 766 // Clicking on a window which has capture should not cause a focus change | |
| 767 // to the window. This test verifies whether that is indeed the case. | |
| 768 ActivateWindowById(1); | |
| 769 | |
| 770 EXPECT_EQ(1, GetActiveWindowId()); | |
| 771 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 772 | |
| 773 aura::Window* w2 = root_window()->GetChildById(2); | |
| 774 aura::client::GetCaptureClient(root_window())->SetCapture(w2); | |
| 775 ui::test::EventGenerator generator(root_window(), w2); | |
| 776 generator.ClickLeftButton(); | |
| 777 | |
| 778 EXPECT_EQ(1, GetActiveWindowId()); | |
| 779 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 780 aura::client::GetCaptureClient(root_window())->ReleaseCapture(w2); | |
| 781 } | |
| 782 | |
| 783 // Verifies focus change is honored while capture held. | |
| 784 virtual void ChangeFocusWhenNothingFocusedAndCaptured() override { | |
| 785 scoped_ptr<aura::client::DefaultCaptureClient> capture_client( | |
| 786 new aura::client::DefaultCaptureClient(root_window())); | |
| 787 aura::Window* w1 = root_window()->GetChildById(1); | |
| 788 aura::client::GetCaptureClient(root_window())->SetCapture(w1); | |
| 789 | |
| 790 EXPECT_EQ(-1, GetActiveWindowId()); | |
| 791 EXPECT_EQ(-1, GetFocusedWindowId()); | |
| 792 | |
| 793 FocusWindowById(1); | |
| 794 | |
| 795 EXPECT_EQ(1, GetActiveWindowId()); | |
| 796 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 797 | |
| 798 aura::client::GetCaptureClient(root_window())->ReleaseCapture(w1); | |
| 799 } | |
| 800 | |
| 801 // Verifies if a window that loses activation or focus is deleted during | |
| 802 // observer notification we don't pass the deleted window to other observers. | |
| 803 virtual void DontPassDeletedWindow() override { | |
| 804 FocusWindowById(1); | |
| 805 | |
| 806 EXPECT_EQ(1, GetActiveWindowId()); | |
| 807 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 808 | |
| 809 { | |
| 810 aura::Window* to_delete = root_window()->GetChildById(1); | |
| 811 DeleteOnLoseActivationChangeObserver observer1(to_delete); | |
| 812 RecordingActivationAndFocusChangeObserver observer2(root_window(), | |
| 813 &observer1); | |
| 814 | |
| 815 FocusWindowById(2); | |
| 816 | |
| 817 EXPECT_EQ(2, GetActiveWindowId()); | |
| 818 EXPECT_EQ(2, GetFocusedWindowId()); | |
| 819 | |
| 820 EXPECT_EQ(to_delete, observer1.GetDeletedWindow()); | |
| 821 EXPECT_FALSE(observer2.was_notified_with_deleted_window()); | |
| 822 } | |
| 823 | |
| 824 { | |
| 825 aura::Window* to_delete = root_window()->GetChildById(2); | |
| 826 DeleteOnLoseFocusChangeObserver observer1(to_delete); | |
| 827 RecordingActivationAndFocusChangeObserver observer2(root_window(), | |
| 828 &observer1); | |
| 829 | |
| 830 FocusWindowById(3); | |
| 831 | |
| 832 EXPECT_EQ(3, GetActiveWindowId()); | |
| 833 EXPECT_EQ(3, GetFocusedWindowId()); | |
| 834 | |
| 835 EXPECT_EQ(to_delete, observer1.GetDeletedWindow()); | |
| 836 EXPECT_FALSE(observer2.was_notified_with_deleted_window()); | |
| 837 } | |
| 838 } | |
| 839 | |
| 840 // Verifies if the focused text input client is cleared when a window gains | |
| 841 // or loses the focus. | |
| 842 virtual void FocusedTextInputClient() override { | |
| 843 ui::TextInputFocusManager* text_input_focus_manager = | |
| 844 ui::TextInputFocusManager::GetInstance(); | |
| 845 ui::DummyTextInputClient text_input_client; | |
| 846 ui::TextInputClient* null_text_input_client = NULL; | |
| 847 | |
| 848 EXPECT_EQ(null_text_input_client, | |
| 849 text_input_focus_manager->GetFocusedTextInputClient()); | |
| 850 | |
| 851 text_input_focus_manager->FocusTextInputClient(&text_input_client); | |
| 852 EXPECT_EQ(&text_input_client, | |
| 853 text_input_focus_manager->GetFocusedTextInputClient()); | |
| 854 FocusWindowById(1); | |
| 855 // The focused text input client gets cleared when a window gets focused | |
| 856 // unless any of observers sets the focused text input client. | |
| 857 EXPECT_EQ(null_text_input_client, | |
| 858 text_input_focus_manager->GetFocusedTextInputClient()); | |
| 859 | |
| 860 ScopedFocusedTextInputClientChanger text_input_focus_changer( | |
| 861 root_window(), &text_input_client); | |
| 862 EXPECT_EQ(null_text_input_client, | |
| 863 text_input_focus_manager->GetFocusedTextInputClient()); | |
| 864 FocusWindowById(2); | |
| 865 // |text_input_focus_changer| sets the focused text input client. | |
| 866 EXPECT_EQ(&text_input_client, | |
| 867 text_input_focus_manager->GetFocusedTextInputClient()); | |
| 868 | |
| 869 FocusWindow(NULL); | |
| 870 // The focused text input client gets cleared when a window loses the focus. | |
| 871 EXPECT_EQ(null_text_input_client, | |
| 872 text_input_focus_manager->GetFocusedTextInputClient()); | |
| 873 } | |
| 874 | |
| 875 private: | |
| 876 DISALLOW_COPY_AND_ASSIGN(FocusControllerDirectTestBase); | |
| 877 }; | |
| 878 | |
| 879 // Focus and Activation changes via aura::client::ActivationClient API. | |
| 880 class FocusControllerApiTest : public FocusControllerDirectTestBase { | |
| 881 public: | |
| 882 FocusControllerApiTest() {} | |
| 883 | |
| 884 private: | |
| 885 // Overridden from FocusControllerTestBase: | |
| 886 virtual void FocusWindowDirect(aura::Window* window) override { | |
| 887 FocusWindow(window); | |
| 888 } | |
| 889 virtual void ActivateWindowDirect(aura::Window* window) override { | |
| 890 ActivateWindow(window); | |
| 891 } | |
| 892 virtual void DeactivateWindowDirect(aura::Window* window) override { | |
| 893 DeactivateWindow(window); | |
| 894 } | |
| 895 virtual bool IsInputEvent() override { return false; } | |
| 896 | |
| 897 DISALLOW_COPY_AND_ASSIGN(FocusControllerApiTest); | |
| 898 }; | |
| 899 | |
| 900 // Focus and Activation changes via input events. | |
| 901 class FocusControllerMouseEventTest : public FocusControllerDirectTestBase { | |
| 902 public: | |
| 903 FocusControllerMouseEventTest() {} | |
| 904 | |
| 905 // Tests that a handled mouse or gesture event does not trigger a window | |
| 906 // activation. | |
| 907 void IgnoreHandledEvent() { | |
| 908 EXPECT_EQ(NULL, GetActiveWindow()); | |
| 909 aura::Window* w1 = root_window()->GetChildById(1); | |
| 910 SimpleEventHandler handler; | |
| 911 root_window()->PrependPreTargetHandler(&handler); | |
| 912 ui::test::EventGenerator generator(root_window(), w1); | |
| 913 generator.ClickLeftButton(); | |
| 914 EXPECT_EQ(NULL, GetActiveWindow()); | |
| 915 generator.GestureTapAt(w1->bounds().CenterPoint()); | |
| 916 EXPECT_EQ(NULL, GetActiveWindow()); | |
| 917 root_window()->RemovePreTargetHandler(&handler); | |
| 918 generator.ClickLeftButton(); | |
| 919 EXPECT_EQ(1, GetActiveWindowId()); | |
| 920 } | |
| 921 | |
| 922 private: | |
| 923 // Overridden from FocusControllerTestBase: | |
| 924 virtual void FocusWindowDirect(aura::Window* window) override { | |
| 925 ui::test::EventGenerator generator(root_window(), window); | |
| 926 generator.ClickLeftButton(); | |
| 927 } | |
| 928 virtual void ActivateWindowDirect(aura::Window* window) override { | |
| 929 ui::test::EventGenerator generator(root_window(), window); | |
| 930 generator.ClickLeftButton(); | |
| 931 } | |
| 932 virtual void DeactivateWindowDirect(aura::Window* window) override { | |
| 933 aura::Window* next_activatable = | |
| 934 test_focus_rules()->GetNextActivatableWindow(window); | |
| 935 ui::test::EventGenerator generator(root_window(), next_activatable); | |
| 936 generator.ClickLeftButton(); | |
| 937 } | |
| 938 virtual bool IsInputEvent() override { return true; } | |
| 939 | |
| 940 DISALLOW_COPY_AND_ASSIGN(FocusControllerMouseEventTest); | |
| 941 }; | |
| 942 | |
| 943 class FocusControllerGestureEventTest : public FocusControllerDirectTestBase { | |
| 944 public: | |
| 945 FocusControllerGestureEventTest() {} | |
| 946 | |
| 947 private: | |
| 948 // Overridden from FocusControllerTestBase: | |
| 949 virtual void FocusWindowDirect(aura::Window* window) override { | |
| 950 ui::test::EventGenerator generator(root_window(), window); | |
| 951 generator.GestureTapAt(window->bounds().CenterPoint()); | |
| 952 } | |
| 953 virtual void ActivateWindowDirect(aura::Window* window) override { | |
| 954 ui::test::EventGenerator generator(root_window(), window); | |
| 955 generator.GestureTapAt(window->bounds().CenterPoint()); | |
| 956 } | |
| 957 virtual void DeactivateWindowDirect(aura::Window* window) override { | |
| 958 aura::Window* next_activatable = | |
| 959 test_focus_rules()->GetNextActivatableWindow(window); | |
| 960 ui::test::EventGenerator generator(root_window(), next_activatable); | |
| 961 generator.GestureTapAt(window->bounds().CenterPoint()); | |
| 962 } | |
| 963 virtual bool IsInputEvent() override { return true; } | |
| 964 | |
| 965 DISALLOW_COPY_AND_ASSIGN(FocusControllerGestureEventTest); | |
| 966 }; | |
| 967 | |
| 968 // Test base for tests where focus is implicitly set to a window as the result | |
| 969 // of a disposition change to the focused window or the hierarchy that contains | |
| 970 // it. | |
| 971 class FocusControllerImplicitTestBase : public FocusControllerTestBase { | |
| 972 protected: | |
| 973 explicit FocusControllerImplicitTestBase(bool parent) : parent_(parent) {} | |
| 974 | |
| 975 aura::Window* GetDispositionWindow(aura::Window* window) { | |
| 976 return parent_ ? window->parent() : window; | |
| 977 } | |
| 978 | |
| 979 // Change the disposition of |window| in such a way as it will lose focus. | |
| 980 virtual void ChangeWindowDisposition(aura::Window* window) = 0; | |
| 981 | |
| 982 // Allow each disposition change test to add additional post-disposition | |
| 983 // change expectations. | |
| 984 virtual void PostDispostionChangeExpectations() {} | |
| 985 | |
| 986 // Overridden from FocusControllerTestBase: | |
| 987 virtual void BasicFocus() override { | |
| 988 EXPECT_EQ(NULL, GetFocusedWindow()); | |
| 989 | |
| 990 aura::Window* w211 = root_window()->GetChildById(211); | |
| 991 FocusWindow(w211); | |
| 992 EXPECT_EQ(211, GetFocusedWindowId()); | |
| 993 | |
| 994 ChangeWindowDisposition(w211); | |
| 995 // BasicFocusRules passes focus to the parent. | |
| 996 EXPECT_EQ(parent_ ? 2 : 21, GetFocusedWindowId()); | |
| 997 } | |
| 998 virtual void BasicActivation() override { | |
| 999 DCHECK(!parent_) << "Activation tests don't support parent changes."; | |
| 1000 | |
| 1001 EXPECT_EQ(NULL, GetActiveWindow()); | |
| 1002 | |
| 1003 aura::Window* w2 = root_window()->GetChildById(2); | |
| 1004 ActivateWindow(w2); | |
| 1005 EXPECT_EQ(2, GetActiveWindowId()); | |
| 1006 | |
| 1007 ChangeWindowDisposition(w2); | |
| 1008 EXPECT_EQ(3, GetActiveWindowId()); | |
| 1009 PostDispostionChangeExpectations(); | |
| 1010 } | |
| 1011 virtual void FocusEvents() override { | |
| 1012 aura::Window* w211 = root_window()->GetChildById(211); | |
| 1013 FocusWindow(w211); | |
| 1014 | |
| 1015 ScopedFocusNotificationObserver root_observer(root_window()); | |
| 1016 ScopedTargetFocusNotificationObserver observer211(root_window(), 211); | |
| 1017 root_observer.ExpectCounts(0, 0); | |
| 1018 observer211.ExpectCounts(0, 0); | |
| 1019 | |
| 1020 ChangeWindowDisposition(w211); | |
| 1021 root_observer.ExpectCounts(0, 1); | |
| 1022 observer211.ExpectCounts(0, 1); | |
| 1023 } | |
| 1024 virtual void ActivationEvents() override { | |
| 1025 DCHECK(!parent_) << "Activation tests don't support parent changes."; | |
| 1026 | |
| 1027 aura::Window* w2 = root_window()->GetChildById(2); | |
| 1028 ActivateWindow(w2); | |
| 1029 | |
| 1030 ScopedFocusNotificationObserver root_observer(root_window()); | |
| 1031 ScopedTargetFocusNotificationObserver observer2(root_window(), 2); | |
| 1032 ScopedTargetFocusNotificationObserver observer3(root_window(), 3); | |
| 1033 root_observer.ExpectCounts(0, 0); | |
| 1034 observer2.ExpectCounts(0, 0); | |
| 1035 observer3.ExpectCounts(0, 0); | |
| 1036 | |
| 1037 ChangeWindowDisposition(w2); | |
| 1038 root_observer.ExpectCounts(1, 1); | |
| 1039 observer2.ExpectCounts(1, 1); | |
| 1040 observer3.ExpectCounts(1, 1); | |
| 1041 } | |
| 1042 virtual void FocusRulesOverride() override { | |
| 1043 EXPECT_EQ(NULL, GetFocusedWindow()); | |
| 1044 aura::Window* w211 = root_window()->GetChildById(211); | |
| 1045 FocusWindow(w211); | |
| 1046 EXPECT_EQ(211, GetFocusedWindowId()); | |
| 1047 | |
| 1048 test_focus_rules()->set_focus_restriction(root_window()->GetChildById(11)); | |
| 1049 ChangeWindowDisposition(w211); | |
| 1050 // Normally, focus would shift to the parent (w21) but the override shifts | |
| 1051 // it to 11. | |
| 1052 EXPECT_EQ(11, GetFocusedWindowId()); | |
| 1053 | |
| 1054 test_focus_rules()->set_focus_restriction(NULL); | |
| 1055 } | |
| 1056 virtual void ActivationRulesOverride() override { | |
| 1057 DCHECK(!parent_) << "Activation tests don't support parent changes."; | |
| 1058 | |
| 1059 aura::Window* w1 = root_window()->GetChildById(1); | |
| 1060 ActivateWindow(w1); | |
| 1061 | |
| 1062 EXPECT_EQ(1, GetActiveWindowId()); | |
| 1063 EXPECT_EQ(1, GetFocusedWindowId()); | |
| 1064 | |
| 1065 aura::Window* w3 = root_window()->GetChildById(3); | |
| 1066 test_focus_rules()->set_focus_restriction(w3); | |
| 1067 | |
| 1068 // Normally, activation/focus would move to w2, but since we have a focus | |
| 1069 // restriction, it should move to w3 instead. | |
| 1070 ChangeWindowDisposition(w1); | |
| 1071 EXPECT_EQ(3, GetActiveWindowId()); | |
| 1072 EXPECT_EQ(3, GetFocusedWindowId()); | |
| 1073 | |
| 1074 test_focus_rules()->set_focus_restriction(NULL); | |
| 1075 ActivateWindow(root_window()->GetChildById(2)); | |
| 1076 EXPECT_EQ(2, GetActiveWindowId()); | |
| 1077 EXPECT_EQ(2, GetFocusedWindowId()); | |
| 1078 } | |
| 1079 | |
| 1080 private: | |
| 1081 // When true, the disposition change occurs to the parent of the window | |
| 1082 // instead of to the window. This verifies that changes occurring in the | |
| 1083 // hierarchy that contains the window affect the window's focus. | |
| 1084 bool parent_; | |
| 1085 | |
| 1086 DISALLOW_COPY_AND_ASSIGN(FocusControllerImplicitTestBase); | |
| 1087 }; | |
| 1088 | |
| 1089 // Focus and Activation changes in response to window visibility changes. | |
| 1090 class FocusControllerHideTest : public FocusControllerImplicitTestBase { | |
| 1091 public: | |
| 1092 FocusControllerHideTest() : FocusControllerImplicitTestBase(false) {} | |
| 1093 | |
| 1094 protected: | |
| 1095 FocusControllerHideTest(bool parent) | |
| 1096 : FocusControllerImplicitTestBase(parent) {} | |
| 1097 | |
| 1098 // Overridden from FocusControllerImplicitTestBase: | |
| 1099 virtual void ChangeWindowDisposition(aura::Window* window) override { | |
| 1100 GetDispositionWindow(window)->Hide(); | |
| 1101 } | |
| 1102 | |
| 1103 private: | |
| 1104 DISALLOW_COPY_AND_ASSIGN(FocusControllerHideTest); | |
| 1105 }; | |
| 1106 | |
| 1107 // Focus and Activation changes in response to window parent visibility | |
| 1108 // changes. | |
| 1109 class FocusControllerParentHideTest : public FocusControllerHideTest { | |
| 1110 public: | |
| 1111 FocusControllerParentHideTest() : FocusControllerHideTest(true) {} | |
| 1112 | |
| 1113 private: | |
| 1114 DISALLOW_COPY_AND_ASSIGN(FocusControllerParentHideTest); | |
| 1115 }; | |
| 1116 | |
| 1117 // Focus and Activation changes in response to window destruction. | |
| 1118 class FocusControllerDestructionTest : public FocusControllerImplicitTestBase { | |
| 1119 public: | |
| 1120 FocusControllerDestructionTest() : FocusControllerImplicitTestBase(false) {} | |
| 1121 | |
| 1122 protected: | |
| 1123 FocusControllerDestructionTest(bool parent) | |
| 1124 : FocusControllerImplicitTestBase(parent) {} | |
| 1125 | |
| 1126 // Overridden from FocusControllerImplicitTestBase: | |
| 1127 virtual void ChangeWindowDisposition(aura::Window* window) override { | |
| 1128 delete GetDispositionWindow(window); | |
| 1129 } | |
| 1130 | |
| 1131 private: | |
| 1132 DISALLOW_COPY_AND_ASSIGN(FocusControllerDestructionTest); | |
| 1133 }; | |
| 1134 | |
| 1135 // Focus and Activation changes in response to window parent destruction. | |
| 1136 class FocusControllerParentDestructionTest | |
| 1137 : public FocusControllerDestructionTest { | |
| 1138 public: | |
| 1139 FocusControllerParentDestructionTest() | |
| 1140 : FocusControllerDestructionTest(true) {} | |
| 1141 | |
| 1142 private: | |
| 1143 DISALLOW_COPY_AND_ASSIGN(FocusControllerParentDestructionTest); | |
| 1144 }; | |
| 1145 | |
| 1146 // Focus and Activation changes in response to window removal. | |
| 1147 class FocusControllerRemovalTest : public FocusControllerImplicitTestBase { | |
| 1148 public: | |
| 1149 FocusControllerRemovalTest() : FocusControllerImplicitTestBase(false) {} | |
| 1150 | |
| 1151 protected: | |
| 1152 FocusControllerRemovalTest(bool parent) | |
| 1153 : FocusControllerImplicitTestBase(parent) {} | |
| 1154 | |
| 1155 // Overridden from FocusControllerImplicitTestBase: | |
| 1156 virtual void ChangeWindowDisposition(aura::Window* window) override { | |
| 1157 aura::Window* disposition_window = GetDispositionWindow(window); | |
| 1158 disposition_window->parent()->RemoveChild(disposition_window); | |
| 1159 window_owner_.reset(disposition_window); | |
| 1160 } | |
| 1161 virtual void TearDown() override { | |
| 1162 window_owner_.reset(); | |
| 1163 FocusControllerImplicitTestBase::TearDown(); | |
| 1164 } | |
| 1165 | |
| 1166 private: | |
| 1167 scoped_ptr<aura::Window> window_owner_; | |
| 1168 | |
| 1169 DISALLOW_COPY_AND_ASSIGN(FocusControllerRemovalTest); | |
| 1170 }; | |
| 1171 | |
| 1172 // Focus and Activation changes in response to window parent removal. | |
| 1173 class FocusControllerParentRemovalTest : public FocusControllerRemovalTest { | |
| 1174 public: | |
| 1175 FocusControllerParentRemovalTest() : FocusControllerRemovalTest(true) {} | |
| 1176 | |
| 1177 private: | |
| 1178 DISALLOW_COPY_AND_ASSIGN(FocusControllerParentRemovalTest); | |
| 1179 }; | |
| 1180 | |
| 1181 | |
| 1182 #define FOCUS_CONTROLLER_TEST(TESTCLASS, TESTNAME) \ | |
| 1183 TEST_F(TESTCLASS, TESTNAME) { TESTNAME(); } | |
| 1184 | |
| 1185 // Runs direct focus change tests (input events and API calls). | |
| 1186 #define DIRECT_FOCUS_CHANGE_TESTS(TESTNAME) \ | |
| 1187 FOCUS_CONTROLLER_TEST(FocusControllerApiTest, TESTNAME) \ | |
| 1188 FOCUS_CONTROLLER_TEST(FocusControllerMouseEventTest, TESTNAME) \ | |
| 1189 FOCUS_CONTROLLER_TEST(FocusControllerGestureEventTest, TESTNAME) | |
| 1190 | |
| 1191 // Runs implicit focus change tests for disposition changes to target. | |
| 1192 #define IMPLICIT_FOCUS_CHANGE_TARGET_TESTS(TESTNAME) \ | |
| 1193 FOCUS_CONTROLLER_TEST(FocusControllerHideTest, TESTNAME) \ | |
| 1194 FOCUS_CONTROLLER_TEST(FocusControllerDestructionTest, TESTNAME) \ | |
| 1195 FOCUS_CONTROLLER_TEST(FocusControllerRemovalTest, TESTNAME) | |
| 1196 | |
| 1197 // Runs implicit focus change tests for disposition changes to target's parent | |
| 1198 // hierarchy. | |
| 1199 #define IMPLICIT_FOCUS_CHANGE_PARENT_TESTS(TESTNAME) \ | |
| 1200 /* TODO(beng): parent destruction tests are not supported at | |
| 1201 present due to workspace manager issues. \ | |
| 1202 FOCUS_CONTROLLER_TEST(FocusControllerParentDestructionTest, TESTNAME) */ \ | |
| 1203 FOCUS_CONTROLLER_TEST(FocusControllerParentHideTest, TESTNAME) \ | |
| 1204 FOCUS_CONTROLLER_TEST(FocusControllerParentRemovalTest, TESTNAME) | |
| 1205 | |
| 1206 // Runs all implicit focus change tests (changes to the target and target's | |
| 1207 // parent hierarchy) | |
| 1208 #define IMPLICIT_FOCUS_CHANGE_TESTS(TESTNAME) \ | |
| 1209 IMPLICIT_FOCUS_CHANGE_TARGET_TESTS(TESTNAME) \ | |
| 1210 IMPLICIT_FOCUS_CHANGE_PARENT_TESTS(TESTNAME) | |
| 1211 | |
| 1212 // Runs all possible focus change tests. | |
| 1213 #define ALL_FOCUS_TESTS(TESTNAME) \ | |
| 1214 DIRECT_FOCUS_CHANGE_TESTS(TESTNAME) \ | |
| 1215 IMPLICIT_FOCUS_CHANGE_TESTS(TESTNAME) | |
| 1216 | |
| 1217 // Runs focus change tests that apply only to the target. For example, | |
| 1218 // implicit activation changes caused by window disposition changes do not | |
| 1219 // occur when changes to the containing hierarchy happen. | |
| 1220 #define TARGET_FOCUS_TESTS(TESTNAME) \ | |
| 1221 DIRECT_FOCUS_CHANGE_TESTS(TESTNAME) \ | |
| 1222 IMPLICIT_FOCUS_CHANGE_TARGET_TESTS(TESTNAME) | |
| 1223 | |
| 1224 // - Focuses a window, verifies that focus changed. | |
| 1225 ALL_FOCUS_TESTS(BasicFocus); | |
| 1226 | |
| 1227 // - Activates a window, verifies that activation changed. | |
| 1228 TARGET_FOCUS_TESTS(BasicActivation); | |
| 1229 | |
| 1230 // - Focuses a window, verifies that focus events were dispatched. | |
| 1231 ALL_FOCUS_TESTS(FocusEvents); | |
| 1232 | |
| 1233 // - Focuses or activates a window multiple times, verifies that events are only | |
| 1234 // dispatched when focus/activation actually changes. | |
| 1235 DIRECT_FOCUS_CHANGE_TESTS(DuplicateFocusEvents); | |
| 1236 DIRECT_FOCUS_CHANGE_TESTS(DuplicateActivationEvents); | |
| 1237 | |
| 1238 // - Activates a window, verifies that activation events were dispatched. | |
| 1239 TARGET_FOCUS_TESTS(ActivationEvents); | |
| 1240 | |
| 1241 // - Attempts to active a hidden window, verifies that current window is | |
| 1242 // attempted to be reactivated and the appropriate event dispatched. | |
| 1243 FOCUS_CONTROLLER_TEST(FocusControllerApiTest, ReactivationEvents); | |
| 1244 | |
| 1245 // - Input events/API calls shift focus between focusable windows within the | |
| 1246 // active window. | |
| 1247 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusWithinActiveWindow); | |
| 1248 | |
| 1249 // - Input events/API calls to a child window of an inactive window shifts | |
| 1250 // activation to the activatable parent and focuses the child. | |
| 1251 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusToChildOfInactiveWindow); | |
| 1252 | |
| 1253 // - Input events/API calls to focus the parent of the focused window do not | |
| 1254 // shift focus away from the child. | |
| 1255 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusToParentOfFocusedWindow); | |
| 1256 | |
| 1257 // - Verifies that FocusRules determine what can be focused. | |
| 1258 ALL_FOCUS_TESTS(FocusRulesOverride); | |
| 1259 | |
| 1260 // - Verifies that FocusRules determine what can be activated. | |
| 1261 TARGET_FOCUS_TESTS(ActivationRulesOverride); | |
| 1262 | |
| 1263 // - Verifies that attempts to change focus or activation from a focus or | |
| 1264 // activation change observer are ignored. | |
| 1265 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusOnActivation); | |
| 1266 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusOnActivationDueToHide); | |
| 1267 DIRECT_FOCUS_CHANGE_TESTS(NoShiftActiveOnActivation); | |
| 1268 | |
| 1269 // Clicking on a window which has capture should not result in a focus change. | |
| 1270 DIRECT_FOCUS_CHANGE_TESTS(NoFocusChangeOnClickOnCaptureWindow); | |
| 1271 | |
| 1272 FOCUS_CONTROLLER_TEST(FocusControllerApiTest, | |
| 1273 ChangeFocusWhenNothingFocusedAndCaptured); | |
| 1274 | |
| 1275 // See description above DontPassDeletedWindow() for details. | |
| 1276 FOCUS_CONTROLLER_TEST(FocusControllerApiTest, DontPassDeletedWindow); | |
| 1277 | |
| 1278 // - Verifies that the focused text input client is cleard when the window focus | |
| 1279 // changes. | |
| 1280 ALL_FOCUS_TESTS(FocusedTextInputClient); | |
| 1281 | |
| 1282 // If a mouse event was handled, it should not activate a window. | |
| 1283 FOCUS_CONTROLLER_TEST(FocusControllerMouseEventTest, IgnoreHandledEvent); | |
| 1284 | |
| 1285 } // namespace wm | |
| OLD | NEW |
|---|
Chromium Code Reviews
