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 "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