src/ui/views/focus/focus_manager_unittest.cc

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