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