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/views/focus/focus_manager.h" 6 7 #include <utility> 8 #include <vector> 9 10 #include "base/command_line.h" 11 #include "base/strings/utf_string_conversions.h" 12 #include "ui/aura/client/focus_client.h" 13 #include "ui/aura/window.h" 14 #include "ui/base/accelerators/accelerator.h" 15 #include "ui/base/ime/dummy_text_input_client.h" 16 #include "ui/base/ime/text_input_focus_manager.h" 17 #include "ui/base/ui_base_switches.h" 18 #include "ui/events/keycodes/keyboard_codes.h" 19 #include "ui/views/accessible_pane_view.h" 20 #include "ui/views/controls/button/label_button.h" 21 #include "ui/views/focus/focus_manager_factory.h" 22 #include "ui/views/focus/widget_focus_manager.h" 23 #include "ui/views/test/focus_manager_test.h" 24 #include "ui/views/widget/widget.h" 25 26 namespace views { 27 28 enum FocusTestEventType { 29 ON_FOCUS = 0, 30 ON_BLUR 31 }; 32 33 struct FocusTestEvent { 34 FocusTestEvent(FocusTestEventType type, int view_id) 35 : type(type), 36 view_id(view_id) { 37 } 38 39 FocusTestEventType type; 40 int view_id; 41 }; 42 43 class SimpleTestView : public View { 44 public: 45 SimpleTestView(std::vector<FocusTestEvent>* event_list, int view_id) 46 : event_list_(event_list) { 47 SetFocusable(true); 48 set_id(view_id); 49 } 50 51 virtual void OnFocus() OVERRIDE { 52 event_list_->push_back(FocusTestEvent(ON_FOCUS, id())); 53 } 54 55 virtual void OnBlur() OVERRIDE { 56 event_list_->push_back(FocusTestEvent(ON_BLUR, id())); 57 } 58 59 private: 60 std::vector<FocusTestEvent>* event_list_; 61 62 DISALLOW_COPY_AND_ASSIGN(SimpleTestView); 63 }; 64 65 // Tests that the appropriate Focus related methods are called when a View 66 // gets/loses focus. 67 TEST_F(FocusManagerTest, ViewFocusCallbacks) { 68 std::vector<FocusTestEvent> event_list; 69 const int kView1ID = 1; 70 const int kView2ID = 2; 71 72 SimpleTestView* view1 = new SimpleTestView(&event_list, kView1ID); 73 SimpleTestView* view2 = new SimpleTestView(&event_list, kView2ID); 74 GetContentsView()->AddChildView(view1); 75 GetContentsView()->AddChildView(view2); 76 77 view1->RequestFocus(); 78 ASSERT_EQ(1, static_cast<int>(event_list.size())); 79 EXPECT_EQ(ON_FOCUS, event_list[0].type); 80 EXPECT_EQ(kView1ID, event_list[0].view_id); 81 82 event_list.clear(); 83 view2->RequestFocus(); 84 ASSERT_EQ(2, static_cast<int>(event_list.size())); 85 EXPECT_EQ(ON_BLUR, event_list[0].type); 86 EXPECT_EQ(kView1ID, event_list[0].view_id); 87 EXPECT_EQ(ON_FOCUS, event_list[1].type); 88 EXPECT_EQ(kView2ID, event_list[1].view_id); 89 90 event_list.clear(); 91 GetFocusManager()->ClearFocus(); 92 ASSERT_EQ(1, static_cast<int>(event_list.size())); 93 EXPECT_EQ(ON_BLUR, event_list[0].type); 94 EXPECT_EQ(kView2ID, event_list[0].view_id); 95 } 96 97 TEST_F(FocusManagerTest, FocusChangeListener) { 98 View* view1 = new View(); 99 view1->SetFocusable(true); 100 View* view2 = new View(); 101 view2->SetFocusable(true); 102 GetContentsView()->AddChildView(view1); 103 GetContentsView()->AddChildView(view2); 104 105 TestFocusChangeListener listener; 106 AddFocusChangeListener(&listener); 107 108 // Required for VS2010: http://connect.microsoft.com/VisualStudio/feedback/details/520043/error-converting-from-null-to-a-pointer-type-in-std-pair 109 views::View* null_view = NULL; 110 111 view1->RequestFocus(); 112 ASSERT_EQ(1, static_cast<int>(listener.focus_changes().size())); 113 EXPECT_TRUE(listener.focus_changes()[0] == ViewPair(null_view, view1)); 114 listener.ClearFocusChanges(); 115 116 view2->RequestFocus(); 117 ASSERT_EQ(1, static_cast<int>(listener.focus_changes().size())); 118 EXPECT_TRUE(listener.focus_changes()[0] == ViewPair(view1, view2)); 119 listener.ClearFocusChanges(); 120 121 GetFocusManager()->ClearFocus(); 122 ASSERT_EQ(1, static_cast<int>(listener.focus_changes().size())); 123 EXPECT_TRUE(listener.focus_changes()[0] == ViewPair(view2, null_view)); 124 } 125 126 TEST_F(FocusManagerTest, WidgetFocusChangeListener) { 127 TestWidgetFocusChangeListener widget_listener; 128 AddWidgetFocusChangeListener(&widget_listener); 129 130 Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_WINDOW); 131 params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; 132 params.bounds = gfx::Rect(10, 10, 100, 100); 133 params.parent = GetWidget()->GetNativeView(); 134 135 scoped_ptr<Widget> widget1(new Widget); 136 widget1->Init(params); 137 widget1->Show(); 138 139 scoped_ptr<Widget> widget2(new Widget); 140 widget2->Init(params); 141 widget2->Show(); 142 143 widget_listener.ClearFocusChanges(); 144 gfx::NativeView native_view1 = widget1->GetNativeView(); 145 aura::client::GetFocusClient(native_view1)->FocusWindow(native_view1); 146 ASSERT_EQ(2, static_cast<int>(widget_listener.focus_changes().size())); 147 EXPECT_EQ(native_view1, widget_listener.focus_changes()[0].second); 148 EXPECT_EQ(native_view1, widget_listener.focus_changes()[1].second); 149 150 widget_listener.ClearFocusChanges(); 151 gfx::NativeView native_view2 = widget2->GetNativeView(); 152 aura::client::GetFocusClient(native_view2)->FocusWindow(native_view2); 153 ASSERT_EQ(2, static_cast<int>(widget_listener.focus_changes().size())); 154 EXPECT_EQ(NativeViewPair(native_view1, native_view2), 155 widget_listener.focus_changes()[0]); 156 EXPECT_EQ(NativeViewPair(native_view1, native_view2), 157 widget_listener.focus_changes()[1]); 158 } 159 160 // Counts accelerator calls. 161 class TestAcceleratorTarget : public ui::AcceleratorTarget { 162 public: 163 explicit TestAcceleratorTarget(bool process_accelerator) 164 : accelerator_count_(0), 165 process_accelerator_(process_accelerator), 166 can_handle_accelerators_(true) {} 167 168 virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE { 169 ++accelerator_count_; 170 return process_accelerator_; 171 } 172 173 virtual bool CanHandleAccelerators() const OVERRIDE { 174 return can_handle_accelerators_; 175 } 176 177 int accelerator_count() const { return accelerator_count_; } 178 179 void set_can_handle_accelerators(bool can_handle_accelerators) { 180 can_handle_accelerators_ = can_handle_accelerators; 181 } 182 183 private: 184 int accelerator_count_; // number of times that the accelerator is activated 185 bool process_accelerator_; // return value of AcceleratorPressed 186 bool can_handle_accelerators_; // return value of CanHandleAccelerators 187 188 DISALLOW_COPY_AND_ASSIGN(TestAcceleratorTarget); 189 }; 190 191 TEST_F(FocusManagerTest, CallsNormalAcceleratorTarget) { 192 FocusManager* focus_manager = GetFocusManager(); 193 ui::Accelerator return_accelerator(ui::VKEY_RETURN, ui::EF_NONE); 194 ui::Accelerator escape_accelerator(ui::VKEY_ESCAPE, ui::EF_NONE); 195 196 TestAcceleratorTarget return_target(true); 197 TestAcceleratorTarget escape_target(true); 198 EXPECT_EQ(return_target.accelerator_count(), 0); 199 EXPECT_EQ(escape_target.accelerator_count(), 0); 200 EXPECT_EQ(NULL, 201 focus_manager->GetCurrentTargetForAccelerator(return_accelerator)); 202 EXPECT_EQ(NULL, 203 focus_manager->GetCurrentTargetForAccelerator(escape_accelerator)); 204 205 // Register targets. 206 focus_manager->RegisterAccelerator(return_accelerator, 207 ui::AcceleratorManager::kNormalPriority, 208 &return_target); 209 focus_manager->RegisterAccelerator(escape_accelerator, 210 ui::AcceleratorManager::kNormalPriority, 211 &escape_target); 212 213 // Checks if the correct target is registered. 214 EXPECT_EQ(&return_target, 215 focus_manager->GetCurrentTargetForAccelerator(return_accelerator)); 216 EXPECT_EQ(&escape_target, 217 focus_manager->GetCurrentTargetForAccelerator(escape_accelerator)); 218 219 // Hitting the return key. 220 EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator)); 221 EXPECT_EQ(return_target.accelerator_count(), 1); 222 EXPECT_EQ(escape_target.accelerator_count(), 0); 223 224 // Hitting the escape key. 225 EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator)); 226 EXPECT_EQ(return_target.accelerator_count(), 1); 227 EXPECT_EQ(escape_target.accelerator_count(), 1); 228 229 // Register another target for the return key. 230 TestAcceleratorTarget return_target2(true); 231 EXPECT_EQ(return_target2.accelerator_count(), 0); 232 focus_manager->RegisterAccelerator(return_accelerator, 233 ui::AcceleratorManager::kNormalPriority, 234 &return_target2); 235 EXPECT_EQ(&return_target2, 236 focus_manager->GetCurrentTargetForAccelerator(return_accelerator)); 237 238 // Hitting the return key; return_target2 has the priority. 239 EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator)); 240 EXPECT_EQ(return_target.accelerator_count(), 1); 241 EXPECT_EQ(return_target2.accelerator_count(), 1); 242 243 // Register a target that does not process the accelerator event. 244 TestAcceleratorTarget return_target3(false); 245 EXPECT_EQ(return_target3.accelerator_count(), 0); 246 focus_manager->RegisterAccelerator(return_accelerator, 247 ui::AcceleratorManager::kNormalPriority, 248 &return_target3); 249 EXPECT_EQ(&return_target3, 250 focus_manager->GetCurrentTargetForAccelerator(return_accelerator)); 251 252 // Hitting the return key. 253 // Since the event handler of return_target3 returns false, return_target2 254 // should be called too. 255 EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator)); 256 EXPECT_EQ(return_target.accelerator_count(), 1); 257 EXPECT_EQ(return_target2.accelerator_count(), 2); 258 EXPECT_EQ(return_target3.accelerator_count(), 1); 259 260 // Unregister return_target2. 261 focus_manager->UnregisterAccelerator(return_accelerator, &return_target2); 262 EXPECT_EQ(&return_target3, 263 focus_manager->GetCurrentTargetForAccelerator(return_accelerator)); 264 265 // Hitting the return key. return_target3 and return_target should be called. 266 EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator)); 267 EXPECT_EQ(return_target.accelerator_count(), 2); 268 EXPECT_EQ(return_target2.accelerator_count(), 2); 269 EXPECT_EQ(return_target3.accelerator_count(), 2); 270 271 // Unregister targets. 272 focus_manager->UnregisterAccelerator(return_accelerator, &return_target); 273 focus_manager->UnregisterAccelerator(return_accelerator, &return_target3); 274 focus_manager->UnregisterAccelerator(escape_accelerator, &escape_target); 275 276 // Now there is no target registered. 277 EXPECT_EQ(NULL, 278 focus_manager->GetCurrentTargetForAccelerator(return_accelerator)); 279 EXPECT_EQ(NULL, 280 focus_manager->GetCurrentTargetForAccelerator(escape_accelerator)); 281 282 // Hitting the return key and the escape key. Nothing should happen. 283 EXPECT_FALSE(focus_manager->ProcessAccelerator(return_accelerator)); 284 EXPECT_EQ(return_target.accelerator_count(), 2); 285 EXPECT_EQ(return_target2.accelerator_count(), 2); 286 EXPECT_EQ(return_target3.accelerator_count(), 2); 287 EXPECT_FALSE(focus_manager->ProcessAccelerator(escape_accelerator)); 288 EXPECT_EQ(escape_target.accelerator_count(), 1); 289 } 290 291 TEST_F(FocusManagerTest, HighPriorityHandlers) { 292 FocusManager* focus_manager = GetFocusManager(); 293 ui::Accelerator escape_accelerator(ui::VKEY_ESCAPE, ui::EF_NONE); 294 295 TestAcceleratorTarget escape_target_high(true); 296 TestAcceleratorTarget escape_target_normal(true); 297 EXPECT_EQ(escape_target_high.accelerator_count(), 0); 298 EXPECT_EQ(escape_target_normal.accelerator_count(), 0); 299 EXPECT_EQ(NULL, 300 focus_manager->GetCurrentTargetForAccelerator(escape_accelerator)); 301 EXPECT_FALSE(focus_manager->HasPriorityHandler(escape_accelerator)); 302 303 // Register high priority target. 304 focus_manager->RegisterAccelerator(escape_accelerator, 305 ui::AcceleratorManager::kHighPriority, 306 &escape_target_high); 307 EXPECT_EQ(&escape_target_high, 308 focus_manager->GetCurrentTargetForAccelerator(escape_accelerator)); 309 EXPECT_TRUE(focus_manager->HasPriorityHandler(escape_accelerator)); 310 311 // Hit the escape key. 312 EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator)); 313 EXPECT_EQ(escape_target_high.accelerator_count(), 1); 314 EXPECT_EQ(escape_target_normal.accelerator_count(), 0); 315 316 // Add a normal priority target and make sure it doesn't see the key. 317 focus_manager->RegisterAccelerator(escape_accelerator, 318 ui::AcceleratorManager::kNormalPriority, 319 &escape_target_normal); 320 321 // Checks if the correct target is registered (same as before, the high 322 // priority one). 323 EXPECT_EQ(&escape_target_high, 324 focus_manager->GetCurrentTargetForAccelerator(escape_accelerator)); 325 EXPECT_TRUE(focus_manager->HasPriorityHandler(escape_accelerator)); 326 327 // Hit the escape key. 328 EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator)); 329 EXPECT_EQ(escape_target_high.accelerator_count(), 2); 330 EXPECT_EQ(escape_target_normal.accelerator_count(), 0); 331 332 // Unregister the high priority accelerator. 333 focus_manager->UnregisterAccelerator(escape_accelerator, &escape_target_high); 334 EXPECT_EQ(&escape_target_normal, 335 focus_manager->GetCurrentTargetForAccelerator(escape_accelerator)); 336 EXPECT_FALSE(focus_manager->HasPriorityHandler(escape_accelerator)); 337 338 // Hit the escape key. 339 EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator)); 340 EXPECT_EQ(escape_target_high.accelerator_count(), 2); 341 EXPECT_EQ(escape_target_normal.accelerator_count(), 1); 342 343 // Add the high priority target back and make sure it starts seeing the key. 344 focus_manager->RegisterAccelerator(escape_accelerator, 345 ui::AcceleratorManager::kHighPriority, 346 &escape_target_high); 347 EXPECT_EQ(&escape_target_high, 348 focus_manager->GetCurrentTargetForAccelerator(escape_accelerator)); 349 EXPECT_TRUE(focus_manager->HasPriorityHandler(escape_accelerator)); 350 351 // Hit the escape key. 352 EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator)); 353 EXPECT_EQ(escape_target_high.accelerator_count(), 3); 354 EXPECT_EQ(escape_target_normal.accelerator_count(), 1); 355 356 // Unregister the normal priority accelerator. 357 focus_manager->UnregisterAccelerator( 358 escape_accelerator, &escape_target_normal); 359 EXPECT_EQ(&escape_target_high, 360 focus_manager->GetCurrentTargetForAccelerator(escape_accelerator)); 361 EXPECT_TRUE(focus_manager->HasPriorityHandler(escape_accelerator)); 362 363 // Hit the escape key. 364 EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator)); 365 EXPECT_EQ(escape_target_high.accelerator_count(), 4); 366 EXPECT_EQ(escape_target_normal.accelerator_count(), 1); 367 368 // Unregister the high priority accelerator. 369 focus_manager->UnregisterAccelerator(escape_accelerator, &escape_target_high); 370 EXPECT_EQ(NULL, 371 focus_manager->GetCurrentTargetForAccelerator(escape_accelerator)); 372 EXPECT_FALSE(focus_manager->HasPriorityHandler(escape_accelerator)); 373 374 // Hit the escape key (no change, no targets registered). 375 EXPECT_FALSE(focus_manager->ProcessAccelerator(escape_accelerator)); 376 EXPECT_EQ(escape_target_high.accelerator_count(), 4); 377 EXPECT_EQ(escape_target_normal.accelerator_count(), 1); 378 } 379 380 TEST_F(FocusManagerTest, CallsEnabledAcceleratorTargetsOnly) { 381 FocusManager* focus_manager = GetFocusManager(); 382 ui::Accelerator return_accelerator(ui::VKEY_RETURN, ui::EF_NONE); 383 384 TestAcceleratorTarget return_target1(true); 385 TestAcceleratorTarget return_target2(true); 386 387 focus_manager->RegisterAccelerator(return_accelerator, 388 ui::AcceleratorManager::kNormalPriority, 389 &return_target1); 390 focus_manager->RegisterAccelerator(return_accelerator, 391 ui::AcceleratorManager::kNormalPriority, 392 &return_target2); 393 EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator)); 394 EXPECT_EQ(0, return_target1.accelerator_count()); 395 EXPECT_EQ(1, return_target2.accelerator_count()); 396 397 // If CanHandleAccelerators() return false, FocusManager shouldn't call 398 // AcceleratorPressed(). 399 return_target2.set_can_handle_accelerators(false); 400 EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator)); 401 EXPECT_EQ(1, return_target1.accelerator_count()); 402 EXPECT_EQ(1, return_target2.accelerator_count()); 403 404 // If no accelerator targets are enabled, ProcessAccelerator() should fail. 405 return_target1.set_can_handle_accelerators(false); 406 EXPECT_FALSE(focus_manager->ProcessAccelerator(return_accelerator)); 407 EXPECT_EQ(1, return_target1.accelerator_count()); 408 EXPECT_EQ(1, return_target2.accelerator_count()); 409 410 // Enabling the target again causes the accelerators to be processed again. 411 return_target1.set_can_handle_accelerators(true); 412 return_target2.set_can_handle_accelerators(true); 413 EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator)); 414 EXPECT_EQ(1, return_target1.accelerator_count()); 415 EXPECT_EQ(2, return_target2.accelerator_count()); 416 } 417 418 // Unregisters itself when its accelerator is invoked. 419 class SelfUnregisteringAcceleratorTarget : public ui::AcceleratorTarget { 420 public: 421 SelfUnregisteringAcceleratorTarget(ui::Accelerator accelerator, 422 FocusManager* focus_manager) 423 : accelerator_(accelerator), 424 focus_manager_(focus_manager), 425 accelerator_count_(0) { 426 } 427 428 virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE { 429 ++accelerator_count_; 430 focus_manager_->UnregisterAccelerator(accelerator, this); 431 return true; 432 } 433 434 virtual bool CanHandleAccelerators() const OVERRIDE { 435 return true; 436 } 437 438 int accelerator_count() const { return accelerator_count_; } 439 440 private: 441 ui::Accelerator accelerator_; 442 FocusManager* focus_manager_; 443 int accelerator_count_; 444 445 DISALLOW_COPY_AND_ASSIGN(SelfUnregisteringAcceleratorTarget); 446 }; 447 448 TEST_F(FocusManagerTest, CallsSelfDeletingAcceleratorTarget) { 449 FocusManager* focus_manager = GetFocusManager(); 450 ui::Accelerator return_accelerator(ui::VKEY_RETURN, ui::EF_NONE); 451 SelfUnregisteringAcceleratorTarget target(return_accelerator, focus_manager); 452 EXPECT_EQ(target.accelerator_count(), 0); 453 EXPECT_EQ(NULL, 454 focus_manager->GetCurrentTargetForAccelerator(return_accelerator)); 455 456 // Register the target. 457 focus_manager->RegisterAccelerator(return_accelerator, 458 ui::AcceleratorManager::kNormalPriority, 459 &target); 460 EXPECT_EQ(&target, 461 focus_manager->GetCurrentTargetForAccelerator(return_accelerator)); 462 463 // Hitting the return key. The target will be unregistered. 464 EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator)); 465 EXPECT_EQ(target.accelerator_count(), 1); 466 EXPECT_EQ(NULL, 467 focus_manager->GetCurrentTargetForAccelerator(return_accelerator)); 468 469 // Hitting the return key again; nothing should happen. 470 EXPECT_FALSE(focus_manager->ProcessAccelerator(return_accelerator)); 471 EXPECT_EQ(target.accelerator_count(), 1); 472 } 473 474 class FocusManagerDtorTest : public FocusManagerTest { 475 protected: 476 typedef std::vector<std::string> DtorTrackVector; 477 478 class FocusManagerDtorTracked : public FocusManager { 479 public: 480 FocusManagerDtorTracked(Widget* widget, DtorTrackVector* dtor_tracker) 481 : FocusManager(widget, NULL /* delegate */), 482 dtor_tracker_(dtor_tracker) { 483 } 484 485 virtual ~FocusManagerDtorTracked() { 486 dtor_tracker_->push_back("FocusManagerDtorTracked"); 487 } 488 489 DtorTrackVector* dtor_tracker_; 490 491 private: 492 DISALLOW_COPY_AND_ASSIGN(FocusManagerDtorTracked); 493 }; 494 495 class TestFocusManagerFactory : public FocusManagerFactory { 496 public: 497 explicit TestFocusManagerFactory(DtorTrackVector* dtor_tracker) 498 : dtor_tracker_(dtor_tracker) { 499 } 500 501 virtual FocusManager* CreateFocusManager(Widget* widget, 502 bool desktop_widget) OVERRIDE { 503 return new FocusManagerDtorTracked(widget, dtor_tracker_); 504 } 505 506 private: 507 DtorTrackVector* dtor_tracker_; 508 DISALLOW_COPY_AND_ASSIGN(TestFocusManagerFactory); 509 }; 510 511 class LabelButtonDtorTracked : public LabelButton { 512 public: 513 LabelButtonDtorTracked(const base::string16& text, 514 DtorTrackVector* dtor_tracker) 515 : LabelButton(NULL, text), 516 dtor_tracker_(dtor_tracker) { 517 SetStyle(STYLE_BUTTON); 518 }; 519 virtual ~LabelButtonDtorTracked() { 520 dtor_tracker_->push_back("LabelButtonDtorTracked"); 521 } 522 523 DtorTrackVector* dtor_tracker_; 524 }; 525 526 class WindowDtorTracked : public Widget { 527 public: 528 explicit WindowDtorTracked(DtorTrackVector* dtor_tracker) 529 : dtor_tracker_(dtor_tracker) { 530 } 531 532 virtual ~WindowDtorTracked() { 533 dtor_tracker_->push_back("WindowDtorTracked"); 534 } 535 536 DtorTrackVector* dtor_tracker_; 537 }; 538 539 virtual void SetUp() { 540 ViewsTestBase::SetUp(); 541 FocusManagerFactory::Install(new TestFocusManagerFactory(&dtor_tracker_)); 542 // Create WindowDtorTracked that uses FocusManagerDtorTracked. 543 Widget* widget = new WindowDtorTracked(&dtor_tracker_); 544 Widget::InitParams params; 545 params.delegate = this; 546 params.bounds = gfx::Rect(0, 0, 100, 100); 547 widget->Init(params); 548 549 tracked_focus_manager_ = 550 static_cast<FocusManagerDtorTracked*>(GetFocusManager()); 551 widget->Show(); 552 } 553 554 virtual void TearDown() { 555 FocusManagerFactory::Install(NULL); 556 ViewsTestBase::TearDown(); 557 } 558 559 FocusManager* tracked_focus_manager_; 560 DtorTrackVector dtor_tracker_; 561 }; 562 563 namespace { 564 565 class FocusInAboutToRequestFocusFromTabTraversalView : public View { 566 public: 567 FocusInAboutToRequestFocusFromTabTraversalView() : view_to_focus_(NULL) {} 568 569 void set_view_to_focus(View* view) { view_to_focus_ = view; } 570 571 virtual void AboutToRequestFocusFromTabTraversal(bool reverse) OVERRIDE { 572 view_to_focus_->RequestFocus(); 573 } 574 575 private: 576 views::View* view_to_focus_; 577 578 DISALLOW_COPY_AND_ASSIGN(FocusInAboutToRequestFocusFromTabTraversalView); 579 }; 580 } // namespace 581 582 // Verifies a focus change done during a call to 583 // AboutToRequestFocusFromTabTraversal() is honored. 584 TEST_F(FocusManagerTest, FocusInAboutToRequestFocusFromTabTraversal) { 585 // Create 3 views focuses the 3 and advances to the second. The 2nd views 586 // implementation of AboutToRequestFocusFromTabTraversal() focuses the first. 587 views::View* v1 = new View; 588 v1->SetFocusable(true); 589 GetContentsView()->AddChildView(v1); 590 591 FocusInAboutToRequestFocusFromTabTraversalView* v2 = 592 new FocusInAboutToRequestFocusFromTabTraversalView; 593 v2->SetFocusable(true); 594 v2->set_view_to_focus(v1); 595 GetContentsView()->AddChildView(v2); 596 597 views::View* v3 = new View; 598 v3->SetFocusable(true); 599 GetContentsView()->AddChildView(v3); 600 601 v3->RequestFocus(); 602 GetWidget()->GetFocusManager()->AdvanceFocus(true); 603 EXPECT_TRUE(v1->HasFocus()); 604 } 605 606 TEST_F(FocusManagerTest, RotatePaneFocus) { 607 views::AccessiblePaneView* pane1 = new AccessiblePaneView(); 608 GetContentsView()->AddChildView(pane1); 609 610 views::View* v1 = new View; 611 v1->SetFocusable(true); 612 pane1->AddChildView(v1); 613 614 views::View* v2 = new View; 615 v2->SetFocusable(true); 616 pane1->AddChildView(v2); 617 618 views::AccessiblePaneView* pane2 = new AccessiblePaneView(); 619 GetContentsView()->AddChildView(pane2); 620 621 views::View* v3 = new View; 622 v3->SetFocusable(true); 623 pane2->AddChildView(v3); 624 625 views::View* v4 = new View; 626 v4->SetFocusable(true); 627 pane2->AddChildView(v4); 628 629 std::vector<views::View*> panes; 630 panes.push_back(pane1); 631 panes.push_back(pane2); 632 SetAccessiblePanes(panes); 633 634 FocusManager* focus_manager = GetWidget()->GetFocusManager(); 635 636 // Advance forwards. Focus should stay trapped within each pane. 637 EXPECT_TRUE(focus_manager->RotatePaneFocus( 638 FocusManager::kForward, FocusManager::kWrap)); 639 EXPECT_EQ(v1, focus_manager->GetFocusedView()); 640 focus_manager->AdvanceFocus(false); 641 EXPECT_EQ(v2, focus_manager->GetFocusedView()); 642 focus_manager->AdvanceFocus(false); 643 EXPECT_EQ(v1, focus_manager->GetFocusedView()); 644 645 EXPECT_TRUE(focus_manager->RotatePaneFocus( 646 FocusManager::kForward, FocusManager::kWrap)); 647 EXPECT_EQ(v3, focus_manager->GetFocusedView()); 648 focus_manager->AdvanceFocus(false); 649 EXPECT_EQ(v4, focus_manager->GetFocusedView()); 650 focus_manager->AdvanceFocus(false); 651 EXPECT_EQ(v3, focus_manager->GetFocusedView()); 652 653 EXPECT_TRUE(focus_manager->RotatePaneFocus( 654 FocusManager::kForward, FocusManager::kWrap)); 655 EXPECT_EQ(v1, focus_manager->GetFocusedView()); 656 657 // Advance backwards. 658 EXPECT_TRUE(focus_manager->RotatePaneFocus( 659 FocusManager::kBackward, FocusManager::kWrap)); 660 EXPECT_EQ(v3, focus_manager->GetFocusedView()); 661 662 EXPECT_TRUE(focus_manager->RotatePaneFocus( 663 FocusManager::kBackward, FocusManager::kWrap)); 664 EXPECT_EQ(v1, focus_manager->GetFocusedView()); 665 666 // Advance without wrap. When it gets to the end of the list of 667 // panes, RotatePaneFocus should return false but the current 668 // focused view shouldn't change. 669 EXPECT_TRUE(focus_manager->RotatePaneFocus( 670 FocusManager::kForward, FocusManager::kNoWrap)); 671 EXPECT_EQ(v3, focus_manager->GetFocusedView()); 672 673 EXPECT_FALSE(focus_manager->RotatePaneFocus( 674 FocusManager::kForward, FocusManager::kNoWrap)); 675 EXPECT_EQ(v3, focus_manager->GetFocusedView()); 676 } 677 678 // Verifies the stored focus view tracks the focused view. 679 TEST_F(FocusManagerTest, ImplicitlyStoresFocus) { 680 views::View* v1 = new View; 681 v1->SetFocusable(true); 682 GetContentsView()->AddChildView(v1); 683 684 views::View* v2 = new View; 685 v2->SetFocusable(true); 686 GetContentsView()->AddChildView(v2); 687 688 // Verify a focus request on |v1| implicitly updates the stored focus view. 689 v1->RequestFocus(); 690 EXPECT_TRUE(v1->HasFocus()); 691 EXPECT_EQ(v1, GetWidget()->GetFocusManager()->GetStoredFocusView()); 692 693 // Verify a focus request on |v2| implicitly updates the stored focus view. 694 v2->RequestFocus(); 695 EXPECT_TRUE(v2->HasFocus()); 696 EXPECT_EQ(v2, GetWidget()->GetFocusManager()->GetStoredFocusView()); 697 } 698 699 namespace { 700 701 class FocusManagerArrowKeyTraversalTest : public FocusManagerTest { 702 public: 703 FocusManagerArrowKeyTraversalTest() 704 : previous_arrow_key_traversal_enabled_(false) { 705 } 706 virtual ~FocusManagerArrowKeyTraversalTest() {} 707 708 // FocusManagerTest overrides: 709 virtual void SetUp() OVERRIDE { 710 FocusManagerTest::SetUp(); 711 712 previous_arrow_key_traversal_enabled_ = 713 FocusManager::arrow_key_traversal_enabled(); 714 } 715 virtual void TearDown() OVERRIDE { 716 FocusManager::set_arrow_key_traversal_enabled( 717 previous_arrow_key_traversal_enabled_); 718 FocusManagerTest::TearDown(); 719 } 720 721 private: 722 bool previous_arrow_key_traversal_enabled_; 723 724 DISALLOW_COPY_AND_ASSIGN(FocusManagerArrowKeyTraversalTest); 725 }; 726 727 } // namespace 728 729 TEST_F(FocusManagerArrowKeyTraversalTest, ArrowKeyTraversal) { 730 FocusManager* focus_manager = GetFocusManager(); 731 const ui::KeyEvent left_key(ui::ET_KEY_PRESSED, ui::VKEY_LEFT, ui::EF_NONE); 732 const ui::KeyEvent right_key(ui::ET_KEY_PRESSED, ui::VKEY_RIGHT, ui::EF_NONE); 733 const ui::KeyEvent up_key(ui::ET_KEY_PRESSED, ui::VKEY_UP, ui::EF_NONE); 734 const ui::KeyEvent down_key(ui::ET_KEY_PRESSED, ui::VKEY_DOWN, ui::EF_NONE); 735 736 std::vector<views::View*> v; 737 for (size_t i = 0; i < 2; ++i) { 738 views::View* view = new View; 739 view->SetFocusable(true); 740 GetContentsView()->AddChildView(view); 741 v.push_back(view); 742 } 743 744 // Arrow key traversal is off and arrow key does not change focus. 745 FocusManager::set_arrow_key_traversal_enabled(false); 746 v[0]->RequestFocus(); 747 focus_manager->OnKeyEvent(right_key); 748 EXPECT_EQ(v[0], focus_manager->GetFocusedView()); 749 focus_manager->OnKeyEvent(left_key); 750 EXPECT_EQ(v[0], focus_manager->GetFocusedView()); 751 focus_manager->OnKeyEvent(down_key); 752 EXPECT_EQ(v[0], focus_manager->GetFocusedView()); 753 focus_manager->OnKeyEvent(up_key); 754 EXPECT_EQ(v[0], focus_manager->GetFocusedView()); 755 756 // Turn on arrow key traversal. 757 FocusManager::set_arrow_key_traversal_enabled(true); 758 v[0]->RequestFocus(); 759 focus_manager->OnKeyEvent(right_key); 760 EXPECT_EQ(v[1], focus_manager->GetFocusedView()); 761 focus_manager->OnKeyEvent(left_key); 762 EXPECT_EQ(v[0], focus_manager->GetFocusedView()); 763 focus_manager->OnKeyEvent(down_key); 764 EXPECT_EQ(v[1], focus_manager->GetFocusedView()); 765 focus_manager->OnKeyEvent(up_key); 766 EXPECT_EQ(v[0], focus_manager->GetFocusedView()); 767 } 768 769 TEST_F(FocusManagerTest, StoreFocusedView) { 770 View view; 771 GetFocusManager()->SetFocusedView(&view); 772 GetFocusManager()->StoreFocusedView(false); 773 EXPECT_EQ(NULL, GetFocusManager()->GetFocusedView()); 774 EXPECT_TRUE(GetFocusManager()->RestoreFocusedView()); 775 EXPECT_EQ(&view, GetFocusManager()->GetStoredFocusView()); 776 777 // Repeat with |true|. 778 GetFocusManager()->SetFocusedView(&view); 779 GetFocusManager()->StoreFocusedView(true); 780 EXPECT_EQ(NULL, GetFocusManager()->GetFocusedView()); 781 EXPECT_TRUE(GetFocusManager()->RestoreFocusedView()); 782 EXPECT_EQ(&view, GetFocusManager()->GetStoredFocusView()); 783 } 784 785 class TextInputTestView : public View { 786 public: 787 TextInputTestView() {} 788 789 virtual ui::TextInputClient* GetTextInputClient() OVERRIDE { 790 return &text_input_client_; 791 } 792 793 private: 794 ui::DummyTextInputClient text_input_client_; 795 796 DISALLOW_COPY_AND_ASSIGN(TextInputTestView); 797 }; 798 799 TEST_F(FocusManagerTest, TextInputClient) { 800 base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess(); 801 cmd_line->AppendSwitch(switches::kEnableTextInputFocusManager); 802 803 View* view = new TextInputTestView; 804 ui::TextInputClient* text_input_client = view->GetTextInputClient(); 805 view->SetFocusable(true); 806 GetContentsView()->AddChildView(view); 807 ui::TextInputFocusManager* text_input_focus_manager = 808 ui::TextInputFocusManager::GetInstance(); 809 810 GetFocusManager()->SetFocusedView(view); 811 EXPECT_EQ(view, GetFocusManager()->GetFocusedView()); 812 EXPECT_EQ(text_input_client, 813 text_input_focus_manager->GetFocusedTextInputClient()); 814 GetFocusManager()->StoreFocusedView(false); 815 EXPECT_TRUE(GetFocusManager()->RestoreFocusedView()); 816 EXPECT_EQ(text_input_client, 817 text_input_focus_manager->GetFocusedTextInputClient()); 818 819 // Repeat with |true|. 820 GetFocusManager()->SetFocusedView(view); 821 EXPECT_EQ(view, GetFocusManager()->GetFocusedView()); 822 EXPECT_EQ(text_input_client, 823 text_input_focus_manager->GetFocusedTextInputClient()); 824 GetFocusManager()->StoreFocusedView(true); 825 EXPECT_TRUE(GetFocusManager()->RestoreFocusedView()); 826 EXPECT_EQ(text_input_client, 827 text_input_focus_manager->GetFocusedTextInputClient()); 828 829 // Focus the view twice in a row. 830 GetFocusManager()->SetFocusedView(view); 831 EXPECT_EQ(text_input_client, 832 text_input_focus_manager->GetFocusedTextInputClient()); 833 ui::TextInputFocusManager::GetInstance()->FocusTextInputClient(NULL); 834 GetFocusManager()->SetFocusedView(view); 835 EXPECT_EQ(text_input_client, 836 text_input_focus_manager->GetFocusedTextInputClient()); 837 } 838 839 namespace { 840 841 // Trivial WidgetDelegate implementation that allows setting return value of 842 // ShouldAdvanceFocusToTopLevelWidget(). 843 class AdvanceFocusWidgetDelegate : public WidgetDelegate { 844 public: 845 explicit AdvanceFocusWidgetDelegate(Widget* widget) 846 : widget_(widget), 847 should_advance_focus_to_parent_(false) {} 848 virtual ~AdvanceFocusWidgetDelegate() {} 849 850 void set_should_advance_focus_to_parent(bool value) { 851 should_advance_focus_to_parent_ = value; 852 } 853 854 // WidgetDelegate overrides: 855 virtual bool ShouldAdvanceFocusToTopLevelWidget() const OVERRIDE { 856 return should_advance_focus_to_parent_; 857 } 858 virtual Widget* GetWidget() OVERRIDE { return widget_; } 859 virtual const Widget* GetWidget() const OVERRIDE { return widget_; } 860 861 private: 862 Widget* widget_; 863 bool should_advance_focus_to_parent_; 864 865 DISALLOW_COPY_AND_ASSIGN(AdvanceFocusWidgetDelegate); 866 }; 867 868 } // namespace 869 870 // Verifies focus wrapping happens in the same widget. 871 TEST_F(FocusManagerTest, AdvanceFocusStaysInWidget) { 872 // Add |widget_view| as a child of the Widget. 873 View* widget_view = new View; 874 widget_view->SetFocusable(true); 875 widget_view->SetBounds(20, 0, 20, 20); 876 GetContentsView()->AddChildView(widget_view); 877 878 // Create a widget with two views, focus the second. 879 scoped_ptr<AdvanceFocusWidgetDelegate> delegate; 880 Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_WINDOW); 881 params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; 882 params.child = true; 883 params.bounds = gfx::Rect(10, 10, 100, 100); 884 params.parent = GetWidget()->GetNativeView(); 885 Widget child_widget; 886 delegate.reset(new AdvanceFocusWidgetDelegate(&child_widget)); 887 params.delegate = delegate.get(); 888 child_widget.Init(params); 889 View* view1 = new View; 890 view1->SetFocusable(true); 891 view1->SetBounds(0, 0, 20, 20); 892 View* view2 = new View; 893 view2->SetFocusable(true); 894 view2->SetBounds(20, 0, 20, 20); 895 child_widget.client_view()->AddChildView(view1); 896 child_widget.client_view()->AddChildView(view2); 897 child_widget.Show(); 898 view2->RequestFocus(); 899 EXPECT_EQ(view2, GetFocusManager()->GetFocusedView()); 900 901 // Advance focus backwards, which should focus the first. 902 GetFocusManager()->AdvanceFocus(false); 903 EXPECT_EQ(view1, GetFocusManager()->GetFocusedView()); 904 905 // Focus forward to |view2|. 906 GetFocusManager()->AdvanceFocus(true); 907 EXPECT_EQ(view2, GetFocusManager()->GetFocusedView()); 908 909 // And forward again, wrapping back to |view1|. 910 GetFocusManager()->AdvanceFocus(true); 911 EXPECT_EQ(view1, GetFocusManager()->GetFocusedView()); 912 913 // Allow focus to go to the parent, and focus backwards which should now move 914 // up |widget_view| (in the parent). 915 delegate->set_should_advance_focus_to_parent(true); 916 GetFocusManager()->AdvanceFocus(true); 917 EXPECT_EQ(widget_view, GetFocusManager()->GetFocusedView()); 918 } 919 920 } // namespace views 921