Home | History | Annotate | Download | only in focus 
      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/focus_manager_test.h"
     23 #include "ui/views/focus/widget_focus_manager.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(
    732       ui::ET_KEY_PRESSED, ui::VKEY_LEFT, ui::EF_NONE, false);
    733   const ui::KeyEvent right_key(
    734       ui::ET_KEY_PRESSED, ui::VKEY_RIGHT, ui::EF_NONE, false);
    735   const ui::KeyEvent up_key(
    736       ui::ET_KEY_PRESSED, ui::VKEY_UP, ui::EF_NONE, false);
    737   const ui::KeyEvent down_key(
    738       ui::ET_KEY_PRESSED, ui::VKEY_DOWN, ui::EF_NONE, false);
    739 
    740   std::vector<views::View*> v;
    741   for (size_t i = 0; i < 2; ++i) {
    742     views::View* view = new View;
    743     view->SetFocusable(true);
    744     GetContentsView()->AddChildView(view);
    745     v.push_back(view);
    746   }
    747 
    748   // Arrow key traversal is off and arrow key does not change focus.
    749   FocusManager::set_arrow_key_traversal_enabled(false);
    750   v[0]->RequestFocus();
    751   focus_manager->OnKeyEvent(right_key);
    752   EXPECT_EQ(v[0], focus_manager->GetFocusedView());
    753   focus_manager->OnKeyEvent(left_key);
    754   EXPECT_EQ(v[0], focus_manager->GetFocusedView());
    755   focus_manager->OnKeyEvent(down_key);
    756   EXPECT_EQ(v[0], focus_manager->GetFocusedView());
    757   focus_manager->OnKeyEvent(up_key);
    758   EXPECT_EQ(v[0], focus_manager->GetFocusedView());
    759 
    760   // Turn on arrow key traversal.
    761   FocusManager::set_arrow_key_traversal_enabled(true);
    762   v[0]->RequestFocus();
    763   focus_manager->OnKeyEvent(right_key);
    764   EXPECT_EQ(v[1], focus_manager->GetFocusedView());
    765   focus_manager->OnKeyEvent(left_key);
    766   EXPECT_EQ(v[0], focus_manager->GetFocusedView());
    767   focus_manager->OnKeyEvent(down_key);
    768   EXPECT_EQ(v[1], focus_manager->GetFocusedView());
    769   focus_manager->OnKeyEvent(up_key);
    770   EXPECT_EQ(v[0], focus_manager->GetFocusedView());
    771 }
    772 
    773 TEST_F(FocusManagerTest, StoreFocusedView) {
    774   View view;
    775   GetFocusManager()->SetFocusedView(&view);
    776   GetFocusManager()->StoreFocusedView(false);
    777   EXPECT_EQ(NULL, GetFocusManager()->GetFocusedView());
    778   EXPECT_TRUE(GetFocusManager()->RestoreFocusedView());
    779   EXPECT_EQ(&view, GetFocusManager()->GetStoredFocusView());
    780 
    781   // Repeat with |true|.
    782   GetFocusManager()->SetFocusedView(&view);
    783   GetFocusManager()->StoreFocusedView(true);
    784   EXPECT_EQ(NULL, GetFocusManager()->GetFocusedView());
    785   EXPECT_TRUE(GetFocusManager()->RestoreFocusedView());
    786   EXPECT_EQ(&view, GetFocusManager()->GetStoredFocusView());
    787 }
    788 
    789 class TextInputTestView : public View {
    790  public:
    791   TextInputTestView() {}
    792 
    793   virtual ui::TextInputClient* GetTextInputClient() OVERRIDE {
    794     return &text_input_client_;
    795   }
    796 
    797  private:
    798   ui::DummyTextInputClient text_input_client_;
    799 
    800   DISALLOW_COPY_AND_ASSIGN(TextInputTestView);
    801 };
    802 
    803 TEST_F(FocusManagerTest, TextInputClient) {
    804   base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
    805   cmd_line->AppendSwitch(switches::kEnableTextInputFocusManager);
    806 
    807   View* view = new TextInputTestView;
    808   ui::TextInputClient* text_input_client = view->GetTextInputClient();
    809   view->SetFocusable(true);
    810   GetContentsView()->AddChildView(view);
    811   ui::TextInputFocusManager* text_input_focus_manager =
    812       ui::TextInputFocusManager::GetInstance();
    813 
    814   GetFocusManager()->SetFocusedView(view);
    815   EXPECT_EQ(view, GetFocusManager()->GetFocusedView());
    816   EXPECT_EQ(text_input_client,
    817             text_input_focus_manager->GetFocusedTextInputClient());
    818   GetFocusManager()->StoreFocusedView(false);
    819   EXPECT_TRUE(GetFocusManager()->RestoreFocusedView());
    820   EXPECT_EQ(text_input_client,
    821             text_input_focus_manager->GetFocusedTextInputClient());
    822 
    823   // Repeat with |true|.
    824   GetFocusManager()->SetFocusedView(view);
    825   EXPECT_EQ(view, GetFocusManager()->GetFocusedView());
    826   EXPECT_EQ(text_input_client,
    827             text_input_focus_manager->GetFocusedTextInputClient());
    828   GetFocusManager()->StoreFocusedView(true);
    829   EXPECT_TRUE(GetFocusManager()->RestoreFocusedView());
    830   EXPECT_EQ(text_input_client,
    831             text_input_focus_manager->GetFocusedTextInputClient());
    832 
    833   // Focus the view twice in a row.
    834   GetFocusManager()->SetFocusedView(view);
    835   EXPECT_EQ(text_input_client,
    836             text_input_focus_manager->GetFocusedTextInputClient());
    837   ui::TextInputFocusManager::GetInstance()->FocusTextInputClient(NULL);
    838   GetFocusManager()->SetFocusedView(view);
    839   EXPECT_EQ(text_input_client,
    840             text_input_focus_manager->GetFocusedTextInputClient());
    841 }
    842 
    843 namespace {
    844 
    845 // Trivial WidgetDelegate implementation that allows setting return value of
    846 // ShouldAdvanceFocusToTopLevelWidget().
    847 class AdvanceFocusWidgetDelegate : public WidgetDelegate {
    848  public:
    849   explicit AdvanceFocusWidgetDelegate(Widget* widget)
    850       : widget_(widget),
    851         should_advance_focus_to_parent_(false) {}
    852   virtual ~AdvanceFocusWidgetDelegate() {}
    853 
    854   void set_should_advance_focus_to_parent(bool value) {
    855     should_advance_focus_to_parent_ = value;
    856   }
    857 
    858   // WidgetDelegate overrides:
    859   virtual bool ShouldAdvanceFocusToTopLevelWidget() const OVERRIDE {
    860     return should_advance_focus_to_parent_;
    861   }
    862   virtual Widget* GetWidget() OVERRIDE { return widget_; }
    863   virtual const Widget* GetWidget() const OVERRIDE { return widget_; }
    864 
    865  private:
    866   Widget* widget_;
    867   bool should_advance_focus_to_parent_;
    868 
    869   DISALLOW_COPY_AND_ASSIGN(AdvanceFocusWidgetDelegate);
    870 };
    871 
    872 }  // namespace
    873 
    874 // Verifies focus wrapping happens in the same widget.
    875 TEST_F(FocusManagerTest, AdvanceFocusStaysInWidget) {
    876   // Add |widget_view| as a child of the Widget.
    877   View* widget_view = new View;
    878   widget_view->SetFocusable(true);
    879   widget_view->SetBounds(20, 0, 20, 20);
    880   GetContentsView()->AddChildView(widget_view);
    881 
    882   // Create a widget with two views, focus the second.
    883   scoped_ptr<AdvanceFocusWidgetDelegate> delegate;
    884   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_WINDOW);
    885   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
    886   params.child = true;
    887   params.bounds = gfx::Rect(10, 10, 100, 100);
    888   params.parent = GetWidget()->GetNativeView();
    889   Widget child_widget;
    890   delegate.reset(new AdvanceFocusWidgetDelegate(&child_widget));
    891   params.delegate = delegate.get();
    892   child_widget.Init(params);
    893   View* view1 = new View;
    894   view1->SetFocusable(true);
    895   view1->SetBounds(0, 0, 20, 20);
    896   View* view2 = new View;
    897   view2->SetFocusable(true);
    898   view2->SetBounds(20, 0, 20, 20);
    899   child_widget.client_view()->AddChildView(view1);
    900   child_widget.client_view()->AddChildView(view2);
    901   child_widget.Show();
    902   view2->RequestFocus();
    903   EXPECT_EQ(view2, GetFocusManager()->GetFocusedView());
    904 
    905   // Advance focus backwards, which should focus the first.
    906   GetFocusManager()->AdvanceFocus(false);
    907   EXPECT_EQ(view1, GetFocusManager()->GetFocusedView());
    908 
    909   // Focus forward to |view2|.
    910   GetFocusManager()->AdvanceFocus(true);
    911   EXPECT_EQ(view2, GetFocusManager()->GetFocusedView());
    912 
    913   // And forward again, wrapping back to |view1|.
    914   GetFocusManager()->AdvanceFocus(true);
    915   EXPECT_EQ(view1, GetFocusManager()->GetFocusedView());
    916 
    917   // Allow focus to go to the parent, and focus backwards which should now move
    918   // up |widget_view| (in the parent).
    919   delegate->set_should_advance_focus_to_parent(true);
    920   GetFocusManager()->AdvanceFocus(true);
    921   EXPECT_EQ(widget_view, GetFocusManager()->GetFocusedView());
    922 }
    923 
    924 }  // namespace views
    925