Home | History | Annotate | Download | only in core 
      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/wm/core/focus_controller.h"
      6 
      7 #include <map>
      8 
      9 #include "ui/aura/client/aura_constants.h"
     10 #include "ui/aura/client/default_capture_client.h"
     11 #include "ui/aura/client/focus_change_observer.h"
     12 #include "ui/aura/test/aura_test_base.h"
     13 #include "ui/aura/test/event_generator.h"
     14 #include "ui/aura/test/test_window_delegate.h"
     15 #include "ui/aura/test/test_windows.h"
     16 #include "ui/aura/window.h"
     17 #include "ui/aura/window_event_dispatcher.h"
     18 #include "ui/aura/window_tracker.h"
     19 #include "ui/base/ime/dummy_text_input_client.h"
     20 #include "ui/base/ime/text_input_focus_manager.h"
     21 #include "ui/events/event.h"
     22 #include "ui/events/event_constants.h"
     23 #include "ui/events/event_handler.h"
     24 #include "ui/wm/core/base_focus_rules.h"
     25 #include "ui/wm/core/wm_state.h"
     26 #include "ui/wm/public/activation_change_observer.h"
     27 #include "ui/wm/public/activation_client.h"
     28 
     29 namespace wm {
     30 
     31 class FocusNotificationObserver : public aura::client::ActivationChangeObserver,
     32                                   public aura::client::FocusChangeObserver {
     33  public:
     34   FocusNotificationObserver()
     35       : activation_changed_count_(0),
     36         focus_changed_count_(0),
     37         reactivation_count_(0),
     38         reactivation_requested_window_(NULL),
     39         reactivation_actual_window_(NULL) {}
     40   virtual ~FocusNotificationObserver() {}
     41 
     42   void ExpectCounts(int activation_changed_count, int focus_changed_count) {
     43     EXPECT_EQ(activation_changed_count, activation_changed_count_);
     44     EXPECT_EQ(focus_changed_count, focus_changed_count_);
     45   }
     46   int reactivation_count() const {
     47     return reactivation_count_;
     48   }
     49   aura::Window* reactivation_requested_window() const {
     50     return reactivation_requested_window_;
     51   }
     52   aura::Window* reactivation_actual_window() const {
     53     return reactivation_actual_window_;
     54   }
     55 
     56  private:
     57   // Overridden from aura::client::ActivationChangeObserver:
     58   virtual void OnWindowActivated(aura::Window* gained_active,
     59                                  aura::Window* lost_active) OVERRIDE {
     60     ++activation_changed_count_;
     61   }
     62   virtual void OnAttemptToReactivateWindow(
     63       aura::Window* request_active,
     64       aura::Window* actual_active) OVERRIDE {
     65     ++reactivation_count_;
     66     reactivation_requested_window_ = request_active;
     67     reactivation_actual_window_ = actual_active;
     68   }
     69 
     70   // Overridden from aura::client::FocusChangeObserver:
     71   virtual void OnWindowFocused(aura::Window* gained_focus,
     72                                aura::Window* lost_focus) OVERRIDE {
     73     ++focus_changed_count_;
     74   }
     75 
     76   int activation_changed_count_;
     77   int focus_changed_count_;
     78   int reactivation_count_;
     79   aura::Window* reactivation_requested_window_;
     80   aura::Window* reactivation_actual_window_;
     81 
     82   DISALLOW_COPY_AND_ASSIGN(FocusNotificationObserver);
     83 };
     84 
     85 class WindowDeleter {
     86  public:
     87   virtual aura::Window* GetDeletedWindow() = 0;
     88 
     89  protected:
     90   virtual ~WindowDeleter() {}
     91 };
     92 
     93 // ActivationChangeObserver and FocusChangeObserver that keeps track of whether
     94 // it was notified about activation changes or focus changes with a deleted
     95 // window.
     96 class RecordingActivationAndFocusChangeObserver
     97     : public aura::client::ActivationChangeObserver,
     98       public aura::client::FocusChangeObserver {
     99  public:
    100   RecordingActivationAndFocusChangeObserver(aura::Window* root,
    101                                             WindowDeleter* deleter)
    102       : root_(root),
    103         deleter_(deleter),
    104         was_notified_with_deleted_window_(false) {
    105     aura::client::GetActivationClient(root_)->AddObserver(this);
    106     aura::client::GetFocusClient(root_)->AddObserver(this);
    107   }
    108   virtual ~RecordingActivationAndFocusChangeObserver() {
    109     aura::client::GetActivationClient(root_)->RemoveObserver(this);
    110     aura::client::GetFocusClient(root_)->RemoveObserver(this);
    111   }
    112 
    113   bool was_notified_with_deleted_window() const {
    114     return was_notified_with_deleted_window_;
    115   }
    116 
    117   // Overridden from aura::client::ActivationChangeObserver:
    118   virtual void OnWindowActivated(aura::Window* gained_active,
    119                                  aura::Window* lost_active) OVERRIDE {
    120     if (lost_active && lost_active == deleter_->GetDeletedWindow())
    121       was_notified_with_deleted_window_ = true;
    122   }
    123 
    124   // Overridden from aura::client::FocusChangeObserver:
    125   virtual void OnWindowFocused(aura::Window* gained_focus,
    126                                aura::Window* lost_focus) OVERRIDE {
    127     if (lost_focus && lost_focus == deleter_->GetDeletedWindow())
    128       was_notified_with_deleted_window_ = true;
    129   }
    130 
    131  private:
    132   aura::Window* root_;
    133 
    134   // Not owned.
    135   WindowDeleter* deleter_;
    136 
    137   // Whether the observer was notified about the loss of activation or the
    138   // loss of focus with a window already deleted by |deleter_| as the
    139   // |lost_active| or |lost_focus| parameter.
    140   bool was_notified_with_deleted_window_;
    141 
    142   DISALLOW_COPY_AND_ASSIGN(RecordingActivationAndFocusChangeObserver);
    143 };
    144 
    145 // ActivationChangeObserver that deletes the window losing activation.
    146 class DeleteOnLoseActivationChangeObserver :
    147     public aura::client::ActivationChangeObserver,
    148     public WindowDeleter {
    149  public:
    150   explicit DeleteOnLoseActivationChangeObserver(aura::Window* window)
    151       : root_(window->GetRootWindow()),
    152         window_(window),
    153         did_delete_(false) {
    154     aura::client::GetActivationClient(root_)->AddObserver(this);
    155   }
    156   virtual ~DeleteOnLoseActivationChangeObserver() {
    157     aura::client::GetActivationClient(root_)->RemoveObserver(this);
    158   }
    159 
    160   // Overridden from aura::client::ActivationChangeObserver:
    161   virtual void OnWindowActivated(aura::Window* gained_active,
    162                                  aura::Window* lost_active) OVERRIDE {
    163     if (window_ && lost_active == window_) {
    164       delete lost_active;
    165       did_delete_ = true;
    166     }
    167   }
    168 
    169   // Overridden from WindowDeleter:
    170   virtual aura::Window* GetDeletedWindow() OVERRIDE {
    171     return did_delete_ ? window_ : NULL;
    172   }
    173 
    174  private:
    175   aura::Window* root_;
    176   aura::Window* window_;
    177   bool did_delete_;
    178 
    179   DISALLOW_COPY_AND_ASSIGN(DeleteOnLoseActivationChangeObserver);
    180 };
    181 
    182 // FocusChangeObserver that deletes the window losing focus.
    183 class DeleteOnLoseFocusChangeObserver
    184     : public aura::client::FocusChangeObserver,
    185       public WindowDeleter {
    186  public:
    187   explicit DeleteOnLoseFocusChangeObserver(aura::Window* window)
    188       : root_(window->GetRootWindow()),
    189         window_(window),
    190         did_delete_(false) {
    191     aura::client::GetFocusClient(root_)->AddObserver(this);
    192   }
    193   virtual ~DeleteOnLoseFocusChangeObserver() {
    194     aura::client::GetFocusClient(root_)->RemoveObserver(this);
    195   }
    196 
    197   // Overridden from aura::client::FocusChangeObserver:
    198   virtual void OnWindowFocused(aura::Window* gained_focus,
    199                                aura::Window* lost_focus) OVERRIDE {
    200     if (window_ && lost_focus == window_) {
    201       delete lost_focus;
    202       did_delete_ = true;
    203     }
    204   }
    205 
    206   // Overridden from WindowDeleter:
    207   virtual aura::Window* GetDeletedWindow() OVERRIDE {
    208     return did_delete_ ? window_ : NULL;
    209   }
    210 
    211  private:
    212   aura::Window* root_;
    213   aura::Window* window_;
    214   bool did_delete_;
    215 
    216   DISALLOW_COPY_AND_ASSIGN(DeleteOnLoseFocusChangeObserver);
    217 };
    218 
    219 class ScopedFocusNotificationObserver : public FocusNotificationObserver {
    220  public:
    221   ScopedFocusNotificationObserver(aura::Window* root_window)
    222       : root_window_(root_window) {
    223     aura::client::GetActivationClient(root_window_)->AddObserver(this);
    224     aura::client::GetFocusClient(root_window_)->AddObserver(this);
    225   }
    226   virtual ~ScopedFocusNotificationObserver() {
    227     aura::client::GetActivationClient(root_window_)->RemoveObserver(this);
    228     aura::client::GetFocusClient(root_window_)->RemoveObserver(this);
    229   }
    230 
    231  private:
    232   aura::Window* root_window_;
    233 
    234   DISALLOW_COPY_AND_ASSIGN(ScopedFocusNotificationObserver);
    235 };
    236 
    237 class ScopedTargetFocusNotificationObserver : public FocusNotificationObserver {
    238  public:
    239   ScopedTargetFocusNotificationObserver(aura::Window* root_window, int id)
    240       : target_(root_window->GetChildById(id)) {
    241     aura::client::SetActivationChangeObserver(target_, this);
    242     aura::client::SetFocusChangeObserver(target_, this);
    243     tracker_.Add(target_);
    244   }
    245   virtual ~ScopedTargetFocusNotificationObserver() {
    246     if (tracker_.Contains(target_)) {
    247       aura::client::SetActivationChangeObserver(target_, NULL);
    248       aura::client::SetFocusChangeObserver(target_, NULL);
    249     }
    250   }
    251 
    252  private:
    253   aura::Window* target_;
    254   aura::WindowTracker tracker_;
    255 
    256   DISALLOW_COPY_AND_ASSIGN(ScopedTargetFocusNotificationObserver);
    257 };
    258 
    259 class ScopedFocusedTextInputClientChanger
    260     : public ScopedFocusNotificationObserver {
    261  public:
    262   ScopedFocusedTextInputClientChanger(aura::Window* root_window,
    263                                       ui::TextInputClient* text_input_client)
    264       : ScopedFocusNotificationObserver(root_window),
    265         text_input_client_(text_input_client) {}
    266 
    267  private:
    268   // Overridden from aura::client::FocusChangeObserver:
    269   virtual void OnWindowFocused(aura::Window* gained_focus,
    270                                aura::Window* lost_focus) OVERRIDE {
    271     ui::TextInputFocusManager::GetInstance()->FocusTextInputClient(
    272         text_input_client_);
    273   }
    274 
    275   ui::TextInputClient* text_input_client_;
    276 };
    277 
    278 // Used to fake the handling of events in the pre-target phase.
    279 class SimpleEventHandler : public ui::EventHandler {
    280  public:
    281   SimpleEventHandler() {}
    282   virtual ~SimpleEventHandler() {}
    283 
    284   // Overridden from ui::EventHandler:
    285   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
    286     event->SetHandled();
    287   }
    288   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
    289     event->SetHandled();
    290   }
    291 
    292  private:
    293   DISALLOW_COPY_AND_ASSIGN(SimpleEventHandler);
    294 };
    295 
    296 class FocusShiftingActivationObserver
    297     : public aura::client::ActivationChangeObserver {
    298  public:
    299   explicit FocusShiftingActivationObserver(aura::Window* activated_window)
    300       : activated_window_(activated_window),
    301         shift_focus_to_(NULL) {}
    302   virtual ~FocusShiftingActivationObserver() {}
    303 
    304   void set_shift_focus_to(aura::Window* shift_focus_to) {
    305     shift_focus_to_ = shift_focus_to;
    306   }
    307 
    308  private:
    309   // Overridden from aura::client::ActivationChangeObserver:
    310   virtual void OnWindowActivated(aura::Window* gained_active,
    311                                  aura::Window* lost_active) OVERRIDE {
    312     // Shift focus to a child. This should prevent the default focusing from
    313     // occurring in FocusController::FocusWindow().
    314     if (gained_active == activated_window_) {
    315       aura::client::FocusClient* client =
    316           aura::client::GetFocusClient(gained_active);
    317       client->FocusWindow(shift_focus_to_);
    318     }
    319   }
    320 
    321   aura::Window* activated_window_;
    322   aura::Window* shift_focus_to_;
    323 
    324   DISALLOW_COPY_AND_ASSIGN(FocusShiftingActivationObserver);
    325 };
    326 
    327 // BaseFocusRules subclass that allows basic overrides of focus/activation to
    328 // be tested. This is intended more as a test that the override system works at
    329 // all, rather than as an exhaustive set of use cases, those should be covered
    330 // in tests for those FocusRules implementations.
    331 class TestFocusRules : public BaseFocusRules {
    332  public:
    333   TestFocusRules() : focus_restriction_(NULL) {}
    334 
    335   // Restricts focus and activation to this window and its child hierarchy.
    336   void set_focus_restriction(aura::Window* focus_restriction) {
    337     focus_restriction_ = focus_restriction;
    338   }
    339 
    340   // Overridden from BaseFocusRules:
    341   virtual bool SupportsChildActivation(aura::Window* window) const OVERRIDE {
    342     // In FocusControllerTests, only the RootWindow has activatable children.
    343     return window->GetRootWindow() == window;
    344   }
    345   virtual bool CanActivateWindow(aura::Window* window) const OVERRIDE {
    346     // Restricting focus to a non-activatable child window means the activatable
    347     // parent outside the focus restriction is activatable.
    348     bool can_activate =
    349         CanFocusOrActivate(window) || window->Contains(focus_restriction_);
    350     return can_activate ? BaseFocusRules::CanActivateWindow(window) : false;
    351   }
    352   virtual bool CanFocusWindow(aura::Window* window) const OVERRIDE {
    353     return CanFocusOrActivate(window) ?
    354         BaseFocusRules::CanFocusWindow(window) : false;
    355   }
    356   virtual aura::Window* GetActivatableWindow(
    357       aura::Window* window) const OVERRIDE {
    358     return BaseFocusRules::GetActivatableWindow(
    359         CanFocusOrActivate(window) ? window : focus_restriction_);
    360   }
    361   virtual aura::Window* GetFocusableWindow(
    362       aura::Window* window) const OVERRIDE {
    363     return BaseFocusRules::GetFocusableWindow(
    364         CanFocusOrActivate(window) ? window : focus_restriction_);
    365   }
    366   virtual aura::Window* GetNextActivatableWindow(
    367       aura::Window* ignore) const OVERRIDE {
    368     aura::Window* next_activatable =
    369         BaseFocusRules::GetNextActivatableWindow(ignore);
    370     return CanFocusOrActivate(next_activatable) ?
    371         next_activatable : GetActivatableWindow(focus_restriction_);
    372   }
    373 
    374  private:
    375   bool CanFocusOrActivate(aura::Window* window) const {
    376     return !focus_restriction_ || focus_restriction_->Contains(window);
    377   }
    378 
    379   aura::Window* focus_restriction_;
    380 
    381   DISALLOW_COPY_AND_ASSIGN(TestFocusRules);
    382 };
    383 
    384 // Common infrastructure shared by all FocusController test types.
    385 class FocusControllerTestBase : public aura::test::AuraTestBase {
    386  protected:
    387   FocusControllerTestBase() {}
    388 
    389   // Overridden from aura::test::AuraTestBase:
    390   virtual void SetUp() OVERRIDE {
    391     wm_state_.reset(new wm::WMState);
    392     // FocusController registers itself as an Env observer so it can catch all
    393     // window initializations, including the root_window()'s, so we create it
    394     // before allowing the base setup.
    395     test_focus_rules_ = new TestFocusRules;
    396     focus_controller_.reset(new FocusController(test_focus_rules_));
    397     aura::test::AuraTestBase::SetUp();
    398     root_window()->AddPreTargetHandler(focus_controller_.get());
    399     aura::client::SetFocusClient(root_window(), focus_controller_.get());
    400     aura::client::SetActivationClient(root_window(), focus_controller_.get());
    401 
    402     // Hierarchy used by all tests:
    403     // root_window
    404     //       +-- w1
    405     //       |    +-- w11
    406     //       |    +-- w12
    407     //       +-- w2
    408     //       |    +-- w21
    409     //       |         +-- w211
    410     //       +-- w3
    411     aura::Window* w1 = aura::test::CreateTestWindowWithDelegate(
    412         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 1,
    413         gfx::Rect(0, 0, 50, 50), root_window());
    414     aura::test::CreateTestWindowWithDelegate(
    415         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 11,
    416         gfx::Rect(5, 5, 10, 10), w1);
    417     aura::test::CreateTestWindowWithDelegate(
    418         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 12,
    419         gfx::Rect(15, 15, 10, 10), w1);
    420     aura::Window* w2 = aura::test::CreateTestWindowWithDelegate(
    421         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 2,
    422         gfx::Rect(75, 75, 50, 50), root_window());
    423     aura::Window* w21 = aura::test::CreateTestWindowWithDelegate(
    424         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 21,
    425         gfx::Rect(5, 5, 10, 10), w2);
    426     aura::test::CreateTestWindowWithDelegate(
    427         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 211,
    428         gfx::Rect(1, 1, 5, 5), w21);
    429     aura::test::CreateTestWindowWithDelegate(
    430         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 3,
    431         gfx::Rect(125, 125, 50, 50), root_window());
    432   }
    433   virtual void TearDown() OVERRIDE {
    434     root_window()->RemovePreTargetHandler(focus_controller_.get());
    435     aura::test::AuraTestBase::TearDown();
    436     test_focus_rules_ = NULL;  // Owned by FocusController.
    437     focus_controller_.reset();
    438     wm_state_.reset();
    439   }
    440 
    441   void FocusWindow(aura::Window* window) {
    442     aura::client::GetFocusClient(root_window())->FocusWindow(window);
    443   }
    444   aura::Window* GetFocusedWindow() {
    445     return aura::client::GetFocusClient(root_window())->GetFocusedWindow();
    446   }
    447   int GetFocusedWindowId() {
    448     aura::Window* focused_window = GetFocusedWindow();
    449     return focused_window ? focused_window->id() : -1;
    450   }
    451   void ActivateWindow(aura::Window* window) {
    452     aura::client::GetActivationClient(root_window())->ActivateWindow(window);
    453   }
    454   void DeactivateWindow(aura::Window* window) {
    455     aura::client::GetActivationClient(root_window())->DeactivateWindow(window);
    456   }
    457   aura::Window* GetActiveWindow() {
    458     return aura::client::GetActivationClient(root_window())->GetActiveWindow();
    459   }
    460   int GetActiveWindowId() {
    461     aura::Window* active_window = GetActiveWindow();
    462     return active_window ? active_window->id() : -1;
    463   }
    464 
    465   TestFocusRules* test_focus_rules() { return test_focus_rules_; }
    466 
    467   // Test functions.
    468   virtual void BasicFocus() = 0;
    469   virtual void BasicActivation() = 0;
    470   virtual void FocusEvents() = 0;
    471   virtual void DuplicateFocusEvents() {}
    472   virtual void ActivationEvents() = 0;
    473   virtual void ReactivationEvents() {}
    474   virtual void DuplicateActivationEvents() {}
    475   virtual void ShiftFocusWithinActiveWindow() {}
    476   virtual void ShiftFocusToChildOfInactiveWindow() {}
    477   virtual void ShiftFocusToParentOfFocusedWindow() {}
    478   virtual void FocusRulesOverride() = 0;
    479   virtual void ActivationRulesOverride() = 0;
    480   virtual void ShiftFocusOnActivation() {}
    481   virtual void ShiftFocusOnActivationDueToHide() {}
    482   virtual void NoShiftActiveOnActivation() {}
    483   virtual void NoFocusChangeOnClickOnCaptureWindow() {}
    484   virtual void ChangeFocusWhenNothingFocusedAndCaptured() {}
    485   virtual void DontPassDeletedWindow() {}
    486   virtual void FocusedTextInputClient() {}
    487 
    488  private:
    489   scoped_ptr<FocusController> focus_controller_;
    490   TestFocusRules* test_focus_rules_;
    491   scoped_ptr<wm::WMState> wm_state_;
    492 
    493   DISALLOW_COPY_AND_ASSIGN(FocusControllerTestBase);
    494 };
    495 
    496 // Test base for tests where focus is directly set to a target window.
    497 class FocusControllerDirectTestBase : public FocusControllerTestBase {
    498  protected:
    499   FocusControllerDirectTestBase() {}
    500 
    501   // Different test types shift focus in different ways.
    502   virtual void FocusWindowDirect(aura::Window* window) = 0;
    503   virtual void ActivateWindowDirect(aura::Window* window) = 0;
    504   virtual void DeactivateWindowDirect(aura::Window* window) = 0;
    505 
    506   // Input events do not change focus if the window can not be focused.
    507   virtual bool IsInputEvent() = 0;
    508 
    509   void FocusWindowById(int id) {
    510     aura::Window* window = root_window()->GetChildById(id);
    511     DCHECK(window);
    512     FocusWindowDirect(window);
    513   }
    514   void ActivateWindowById(int id) {
    515     aura::Window* window = root_window()->GetChildById(id);
    516     DCHECK(window);
    517     ActivateWindowDirect(window);
    518   }
    519 
    520   // Overridden from FocusControllerTestBase:
    521   virtual void BasicFocus() OVERRIDE {
    522     EXPECT_EQ(NULL, GetFocusedWindow());
    523     FocusWindowById(1);
    524     EXPECT_EQ(1, GetFocusedWindowId());
    525     FocusWindowById(2);
    526     EXPECT_EQ(2, GetFocusedWindowId());
    527   }
    528   virtual void BasicActivation() OVERRIDE {
    529     EXPECT_EQ(NULL, GetActiveWindow());
    530     ActivateWindowById(1);
    531     EXPECT_EQ(1, GetActiveWindowId());
    532     ActivateWindowById(2);
    533     EXPECT_EQ(2, GetActiveWindowId());
    534     // Verify that attempting to deactivate NULL does not crash and does not
    535     // change activation.
    536     DeactivateWindow(NULL);
    537     EXPECT_EQ(2, GetActiveWindowId());
    538     DeactivateWindow(GetActiveWindow());
    539     EXPECT_EQ(1, GetActiveWindowId());
    540   }
    541   virtual void FocusEvents() OVERRIDE {
    542     ScopedFocusNotificationObserver root_observer(root_window());
    543     ScopedTargetFocusNotificationObserver observer1(root_window(), 1);
    544     ScopedTargetFocusNotificationObserver observer2(root_window(), 2);
    545 
    546     root_observer.ExpectCounts(0, 0);
    547     observer1.ExpectCounts(0, 0);
    548     observer2.ExpectCounts(0, 0);
    549 
    550     FocusWindowById(1);
    551     root_observer.ExpectCounts(1, 1);
    552     observer1.ExpectCounts(1, 1);
    553     observer2.ExpectCounts(0, 0);
    554 
    555     FocusWindowById(2);
    556     root_observer.ExpectCounts(2, 2);
    557     observer1.ExpectCounts(2, 2);
    558     observer2.ExpectCounts(1, 1);
    559   }
    560   virtual void DuplicateFocusEvents() OVERRIDE {
    561     // Focusing an existing focused window should not resend focus events.
    562     ScopedFocusNotificationObserver root_observer(root_window());
    563     ScopedTargetFocusNotificationObserver observer1(root_window(), 1);
    564 
    565     root_observer.ExpectCounts(0, 0);
    566     observer1.ExpectCounts(0, 0);
    567 
    568     FocusWindowById(1);
    569     root_observer.ExpectCounts(1, 1);
    570     observer1.ExpectCounts(1, 1);
    571 
    572     FocusWindowById(1);
    573     root_observer.ExpectCounts(1, 1);
    574     observer1.ExpectCounts(1, 1);
    575   }
    576   virtual void ActivationEvents() OVERRIDE {
    577     ActivateWindowById(1);
    578 
    579     ScopedFocusNotificationObserver root_observer(root_window());
    580     ScopedTargetFocusNotificationObserver observer1(root_window(), 1);
    581     ScopedTargetFocusNotificationObserver observer2(root_window(), 2);
    582 
    583     root_observer.ExpectCounts(0, 0);
    584     observer1.ExpectCounts(0, 0);
    585     observer2.ExpectCounts(0, 0);
    586 
    587     ActivateWindowById(2);
    588     root_observer.ExpectCounts(1, 1);
    589     observer1.ExpectCounts(1, 1);
    590     observer2.ExpectCounts(1, 1);
    591   }
    592   virtual void ReactivationEvents() OVERRIDE {
    593     ActivateWindowById(1);
    594     ScopedFocusNotificationObserver root_observer(root_window());
    595     EXPECT_EQ(0, root_observer.reactivation_count());
    596     root_window()->GetChildById(2)->Hide();
    597     // When we attempt to activate "2", which cannot be activated because it
    598     // is not visible, "1" will be reactivated.
    599     ActivateWindowById(2);
    600     EXPECT_EQ(1, root_observer.reactivation_count());
    601     EXPECT_EQ(root_window()->GetChildById(2),
    602               root_observer.reactivation_requested_window());
    603     EXPECT_EQ(root_window()->GetChildById(1),
    604               root_observer.reactivation_actual_window());
    605   }
    606   virtual void DuplicateActivationEvents() OVERRIDE {
    607     // Activating an existing active window should not resend activation events.
    608     ActivateWindowById(1);
    609 
    610     ScopedFocusNotificationObserver root_observer(root_window());
    611     ScopedTargetFocusNotificationObserver observer1(root_window(), 1);
    612     ScopedTargetFocusNotificationObserver observer2(root_window(), 2);
    613 
    614     root_observer.ExpectCounts(0, 0);
    615     observer1.ExpectCounts(0, 0);
    616     observer2.ExpectCounts(0, 0);
    617 
    618     ActivateWindowById(2);
    619     root_observer.ExpectCounts(1, 1);
    620     observer1.ExpectCounts(1, 1);
    621     observer2.ExpectCounts(1, 1);
    622 
    623     ActivateWindowById(2);
    624     root_observer.ExpectCounts(1, 1);
    625     observer1.ExpectCounts(1, 1);
    626     observer2.ExpectCounts(1, 1);
    627   }
    628   virtual void ShiftFocusWithinActiveWindow() OVERRIDE {
    629     ActivateWindowById(1);
    630     EXPECT_EQ(1, GetActiveWindowId());
    631     EXPECT_EQ(1, GetFocusedWindowId());
    632     FocusWindowById(11);
    633     EXPECT_EQ(11, GetFocusedWindowId());
    634     FocusWindowById(12);
    635     EXPECT_EQ(12, GetFocusedWindowId());
    636   }
    637   virtual void ShiftFocusToChildOfInactiveWindow() OVERRIDE {
    638     ActivateWindowById(2);
    639     EXPECT_EQ(2, GetActiveWindowId());
    640     EXPECT_EQ(2, GetFocusedWindowId());
    641     FocusWindowById(11);
    642     EXPECT_EQ(1, GetActiveWindowId());
    643     EXPECT_EQ(11, GetFocusedWindowId());
    644   }
    645   virtual void ShiftFocusToParentOfFocusedWindow() OVERRIDE {
    646     ActivateWindowById(1);
    647     EXPECT_EQ(1, GetFocusedWindowId());
    648     FocusWindowById(11);
    649     EXPECT_EQ(11, GetFocusedWindowId());
    650     FocusWindowById(1);
    651     // Focus should _not_ shift to the parent of the already-focused window.
    652     EXPECT_EQ(11, GetFocusedWindowId());
    653   }
    654   virtual void FocusRulesOverride() OVERRIDE {
    655     EXPECT_EQ(NULL, GetFocusedWindow());
    656     FocusWindowById(11);
    657     EXPECT_EQ(11, GetFocusedWindowId());
    658 
    659     test_focus_rules()->set_focus_restriction(root_window()->GetChildById(211));
    660     FocusWindowById(12);
    661     // Input events leave focus unchanged; direct API calls will change focus
    662     // to the restricted window.
    663     int focused_window = IsInputEvent() ? 11 : 211;
    664     EXPECT_EQ(focused_window, GetFocusedWindowId());
    665 
    666     test_focus_rules()->set_focus_restriction(NULL);
    667     FocusWindowById(12);
    668     EXPECT_EQ(12, GetFocusedWindowId());
    669   }
    670   virtual void ActivationRulesOverride() OVERRIDE {
    671     ActivateWindowById(1);
    672     EXPECT_EQ(1, GetActiveWindowId());
    673     EXPECT_EQ(1, GetFocusedWindowId());
    674 
    675     aura::Window* w3 = root_window()->GetChildById(3);
    676     test_focus_rules()->set_focus_restriction(w3);
    677 
    678     ActivateWindowById(2);
    679     // Input events leave activation unchanged; direct API calls will activate
    680     // the restricted window.
    681     int active_window = IsInputEvent() ? 1 : 3;
    682     EXPECT_EQ(active_window, GetActiveWindowId());
    683     EXPECT_EQ(active_window, GetFocusedWindowId());
    684 
    685     test_focus_rules()->set_focus_restriction(NULL);
    686     ActivateWindowById(2);
    687     EXPECT_EQ(2, GetActiveWindowId());
    688     EXPECT_EQ(2, GetFocusedWindowId());
    689   }
    690   virtual void ShiftFocusOnActivation() OVERRIDE {
    691     // When a window is activated, by default that window is also focused.
    692     // An ActivationChangeObserver may shift focus to another window within the
    693     // same activatable window.
    694     ActivateWindowById(2);
    695     EXPECT_EQ(2, GetFocusedWindowId());
    696     ActivateWindowById(1);
    697     EXPECT_EQ(1, GetFocusedWindowId());
    698 
    699     ActivateWindowById(2);
    700 
    701     aura::Window* target = root_window()->GetChildById(1);
    702     aura::client::ActivationClient* client =
    703         aura::client::GetActivationClient(root_window());
    704 
    705     scoped_ptr<FocusShiftingActivationObserver> observer(
    706         new FocusShiftingActivationObserver(target));
    707     observer->set_shift_focus_to(target->GetChildById(11));
    708     client->AddObserver(observer.get());
    709 
    710     ActivateWindowById(1);
    711 
    712     // w1's ActivationChangeObserver shifted focus to this child, pre-empting
    713     // FocusController's default setting.
    714     EXPECT_EQ(11, GetFocusedWindowId());
    715 
    716     ActivateWindowById(2);
    717     EXPECT_EQ(2, GetFocusedWindowId());
    718 
    719     // Simulate a focus reset by the ActivationChangeObserver. This should
    720     // trigger the default setting in FocusController.
    721     observer->set_shift_focus_to(NULL);
    722     ActivateWindowById(1);
    723     EXPECT_EQ(1, GetFocusedWindowId());
    724 
    725     client->RemoveObserver(observer.get());
    726 
    727     ActivateWindowById(2);
    728     EXPECT_EQ(2, GetFocusedWindowId());
    729     ActivateWindowById(1);
    730     EXPECT_EQ(1, GetFocusedWindowId());
    731   }
    732   virtual void ShiftFocusOnActivationDueToHide() OVERRIDE {
    733     // Similar to ShiftFocusOnActivation except the activation change is
    734     // triggered by hiding the active window.
    735     ActivateWindowById(1);
    736     EXPECT_EQ(1, GetFocusedWindowId());
    737 
    738     // Removes window 3 as candidate for next activatable window.
    739     root_window()->GetChildById(3)->Hide();
    740     EXPECT_EQ(1, GetFocusedWindowId());
    741 
    742     aura::Window* target = root_window()->GetChildById(2);
    743     aura::client::ActivationClient* client =
    744         aura::client::GetActivationClient(root_window());
    745 
    746     scoped_ptr<FocusShiftingActivationObserver> observer(
    747         new FocusShiftingActivationObserver(target));
    748     observer->set_shift_focus_to(target->GetChildById(21));
    749     client->AddObserver(observer.get());
    750 
    751     // Hide the active window.
    752     root_window()->GetChildById(1)->Hide();
    753 
    754     EXPECT_EQ(21, GetFocusedWindowId());
    755 
    756     client->RemoveObserver(observer.get());
    757   }
    758   virtual void NoShiftActiveOnActivation() OVERRIDE {
    759     // When a window is activated, we need to prevent any change to activation
    760     // from being made in response to an activation change notification.
    761   }
    762 
    763   virtual void NoFocusChangeOnClickOnCaptureWindow() OVERRIDE {
    764     scoped_ptr<aura::client::DefaultCaptureClient> capture_client(
    765         new aura::client::DefaultCaptureClient(root_window()));
    766     // Clicking on a window which has capture should not cause a focus change
    767     // to the window. This test verifies whether that is indeed the case.
    768     ActivateWindowById(1);
    769 
    770     EXPECT_EQ(1, GetActiveWindowId());
    771     EXPECT_EQ(1, GetFocusedWindowId());
    772 
    773     aura::Window* w2 = root_window()->GetChildById(2);
    774     aura::client::GetCaptureClient(root_window())->SetCapture(w2);
    775     aura::test::EventGenerator generator(root_window(), w2);
    776     generator.ClickLeftButton();
    777 
    778     EXPECT_EQ(1, GetActiveWindowId());
    779     EXPECT_EQ(1, GetFocusedWindowId());
    780     aura::client::GetCaptureClient(root_window())->ReleaseCapture(w2);
    781   }
    782 
    783   // Verifies focus change is honored while capture held.
    784   virtual void ChangeFocusWhenNothingFocusedAndCaptured() OVERRIDE {
    785     scoped_ptr<aura::client::DefaultCaptureClient> capture_client(
    786         new aura::client::DefaultCaptureClient(root_window()));
    787     aura::Window* w1 = root_window()->GetChildById(1);
    788     aura::client::GetCaptureClient(root_window())->SetCapture(w1);
    789 
    790     EXPECT_EQ(-1, GetActiveWindowId());
    791     EXPECT_EQ(-1, GetFocusedWindowId());
    792 
    793     FocusWindowById(1);
    794 
    795     EXPECT_EQ(1, GetActiveWindowId());
    796     EXPECT_EQ(1, GetFocusedWindowId());
    797 
    798     aura::client::GetCaptureClient(root_window())->ReleaseCapture(w1);
    799   }
    800 
    801   // Verifies if a window that loses activation or focus is deleted during
    802   // observer notification we don't pass the deleted window to other observers.
    803   virtual void DontPassDeletedWindow() OVERRIDE {
    804     FocusWindowById(1);
    805 
    806     EXPECT_EQ(1, GetActiveWindowId());
    807     EXPECT_EQ(1, GetFocusedWindowId());
    808 
    809     {
    810       aura::Window* to_delete = root_window()->GetChildById(1);
    811       DeleteOnLoseActivationChangeObserver observer1(to_delete);
    812       RecordingActivationAndFocusChangeObserver observer2(root_window(),
    813                                                           &observer1);
    814 
    815       FocusWindowById(2);
    816 
    817       EXPECT_EQ(2, GetActiveWindowId());
    818       EXPECT_EQ(2, GetFocusedWindowId());
    819 
    820       EXPECT_EQ(to_delete, observer1.GetDeletedWindow());
    821       EXPECT_FALSE(observer2.was_notified_with_deleted_window());
    822     }
    823 
    824     {
    825       aura::Window* to_delete = root_window()->GetChildById(2);
    826       DeleteOnLoseFocusChangeObserver observer1(to_delete);
    827       RecordingActivationAndFocusChangeObserver observer2(root_window(),
    828                                                           &observer1);
    829 
    830       FocusWindowById(3);
    831 
    832       EXPECT_EQ(3, GetActiveWindowId());
    833       EXPECT_EQ(3, GetFocusedWindowId());
    834 
    835       EXPECT_EQ(to_delete, observer1.GetDeletedWindow());
    836       EXPECT_FALSE(observer2.was_notified_with_deleted_window());
    837     }
    838   }
    839 
    840   // Verifies if the focused text input client is cleared when a window gains
    841   // or loses the focus.
    842   virtual void FocusedTextInputClient() OVERRIDE {
    843     ui::TextInputFocusManager* text_input_focus_manager =
    844         ui::TextInputFocusManager::GetInstance();
    845     ui::DummyTextInputClient text_input_client;
    846     ui::TextInputClient* null_text_input_client = NULL;
    847 
    848     EXPECT_EQ(null_text_input_client,
    849               text_input_focus_manager->GetFocusedTextInputClient());
    850 
    851     text_input_focus_manager->FocusTextInputClient(&text_input_client);
    852     EXPECT_EQ(&text_input_client,
    853               text_input_focus_manager->GetFocusedTextInputClient());
    854     FocusWindowById(1);
    855     // The focused text input client gets cleared when a window gets focused
    856     // unless any of observers sets the focused text input client.
    857     EXPECT_EQ(null_text_input_client,
    858               text_input_focus_manager->GetFocusedTextInputClient());
    859 
    860     ScopedFocusedTextInputClientChanger text_input_focus_changer(
    861         root_window(), &text_input_client);
    862     EXPECT_EQ(null_text_input_client,
    863               text_input_focus_manager->GetFocusedTextInputClient());
    864     FocusWindowById(2);
    865     // |text_input_focus_changer| sets the focused text input client.
    866     EXPECT_EQ(&text_input_client,
    867               text_input_focus_manager->GetFocusedTextInputClient());
    868 
    869     FocusWindow(NULL);
    870     // The focused text input client gets cleared when a window loses the focus.
    871     EXPECT_EQ(null_text_input_client,
    872               text_input_focus_manager->GetFocusedTextInputClient());
    873   }
    874 
    875  private:
    876   DISALLOW_COPY_AND_ASSIGN(FocusControllerDirectTestBase);
    877 };
    878 
    879 // Focus and Activation changes via aura::client::ActivationClient API.
    880 class FocusControllerApiTest : public FocusControllerDirectTestBase {
    881  public:
    882   FocusControllerApiTest() {}
    883 
    884  private:
    885   // Overridden from FocusControllerTestBase:
    886   virtual void FocusWindowDirect(aura::Window* window) OVERRIDE {
    887     FocusWindow(window);
    888   }
    889   virtual void ActivateWindowDirect(aura::Window* window) OVERRIDE {
    890     ActivateWindow(window);
    891   }
    892   virtual void DeactivateWindowDirect(aura::Window* window) OVERRIDE {
    893     DeactivateWindow(window);
    894   }
    895   virtual bool IsInputEvent() OVERRIDE { return false; }
    896 
    897   DISALLOW_COPY_AND_ASSIGN(FocusControllerApiTest);
    898 };
    899 
    900 // Focus and Activation changes via input events.
    901 class FocusControllerMouseEventTest : public FocusControllerDirectTestBase {
    902  public:
    903   FocusControllerMouseEventTest() {}
    904 
    905   // Tests that a handled mouse or gesture event does not trigger a window
    906   // activation.
    907   void IgnoreHandledEvent() {
    908     EXPECT_EQ(NULL, GetActiveWindow());
    909     aura::Window* w1 = root_window()->GetChildById(1);
    910     SimpleEventHandler handler;
    911     root_window()->PrependPreTargetHandler(&handler);
    912     aura::test::EventGenerator generator(root_window(), w1);
    913     generator.ClickLeftButton();
    914     EXPECT_EQ(NULL, GetActiveWindow());
    915     generator.GestureTapAt(w1->bounds().CenterPoint());
    916     EXPECT_EQ(NULL, GetActiveWindow());
    917     root_window()->RemovePreTargetHandler(&handler);
    918     generator.ClickLeftButton();
    919     EXPECT_EQ(1, GetActiveWindowId());
    920   }
    921 
    922  private:
    923   // Overridden from FocusControllerTestBase:
    924   virtual void FocusWindowDirect(aura::Window* window) OVERRIDE {
    925     aura::test::EventGenerator generator(root_window(), window);
    926     generator.ClickLeftButton();
    927   }
    928   virtual void ActivateWindowDirect(aura::Window* window) OVERRIDE {
    929     aura::test::EventGenerator generator(root_window(), window);
    930     generator.ClickLeftButton();
    931   }
    932   virtual void DeactivateWindowDirect(aura::Window* window) OVERRIDE {
    933     aura::Window* next_activatable =
    934         test_focus_rules()->GetNextActivatableWindow(window);
    935     aura::test::EventGenerator generator(root_window(), next_activatable);
    936     generator.ClickLeftButton();
    937   }
    938   virtual bool IsInputEvent() OVERRIDE { return true; }
    939 
    940   DISALLOW_COPY_AND_ASSIGN(FocusControllerMouseEventTest);
    941 };
    942 
    943 class FocusControllerGestureEventTest : public FocusControllerDirectTestBase {
    944  public:
    945   FocusControllerGestureEventTest() {}
    946 
    947  private:
    948   // Overridden from FocusControllerTestBase:
    949   virtual void FocusWindowDirect(aura::Window* window) OVERRIDE {
    950     aura::test::EventGenerator generator(root_window(), window);
    951     generator.GestureTapAt(window->bounds().CenterPoint());
    952   }
    953   virtual void ActivateWindowDirect(aura::Window* window) OVERRIDE {
    954     aura::test::EventGenerator generator(root_window(), window);
    955     generator.GestureTapAt(window->bounds().CenterPoint());
    956   }
    957   virtual void DeactivateWindowDirect(aura::Window* window) OVERRIDE {
    958     aura::Window* next_activatable =
    959         test_focus_rules()->GetNextActivatableWindow(window);
    960     aura::test::EventGenerator generator(root_window(), next_activatable);
    961     generator.GestureTapAt(window->bounds().CenterPoint());
    962   }
    963   virtual bool IsInputEvent() OVERRIDE { return true; }
    964 
    965   DISALLOW_COPY_AND_ASSIGN(FocusControllerGestureEventTest);
    966 };
    967 
    968 // Test base for tests where focus is implicitly set to a window as the result
    969 // of a disposition change to the focused window or the hierarchy that contains
    970 // it.
    971 class FocusControllerImplicitTestBase : public FocusControllerTestBase {
    972  protected:
    973   explicit FocusControllerImplicitTestBase(bool parent) : parent_(parent) {}
    974 
    975   aura::Window* GetDispositionWindow(aura::Window* window) {
    976     return parent_ ? window->parent() : window;
    977   }
    978 
    979   // Change the disposition of |window| in such a way as it will lose focus.
    980   virtual void ChangeWindowDisposition(aura::Window* window) = 0;
    981 
    982   // Allow each disposition change test to add additional post-disposition
    983   // change expectations.
    984   virtual void PostDispostionChangeExpectations() {}
    985 
    986   // Overridden from FocusControllerTestBase:
    987   virtual void BasicFocus() OVERRIDE {
    988     EXPECT_EQ(NULL, GetFocusedWindow());
    989 
    990     aura::Window* w211 = root_window()->GetChildById(211);
    991     FocusWindow(w211);
    992     EXPECT_EQ(211, GetFocusedWindowId());
    993 
    994     ChangeWindowDisposition(w211);
    995     // BasicFocusRules passes focus to the parent.
    996     EXPECT_EQ(parent_ ? 2 : 21, GetFocusedWindowId());
    997   }
    998   virtual void BasicActivation() OVERRIDE {
    999     DCHECK(!parent_) << "Activation tests don't support parent changes.";
   1000 
   1001     EXPECT_EQ(NULL, GetActiveWindow());
   1002 
   1003     aura::Window* w2 = root_window()->GetChildById(2);
   1004     ActivateWindow(w2);
   1005     EXPECT_EQ(2, GetActiveWindowId());
   1006 
   1007     ChangeWindowDisposition(w2);
   1008     EXPECT_EQ(3, GetActiveWindowId());
   1009     PostDispostionChangeExpectations();
   1010   }
   1011   virtual void FocusEvents() OVERRIDE {
   1012     aura::Window* w211 = root_window()->GetChildById(211);
   1013     FocusWindow(w211);
   1014 
   1015     ScopedFocusNotificationObserver root_observer(root_window());
   1016     ScopedTargetFocusNotificationObserver observer211(root_window(), 211);
   1017     root_observer.ExpectCounts(0, 0);
   1018     observer211.ExpectCounts(0, 0);
   1019 
   1020     ChangeWindowDisposition(w211);
   1021     root_observer.ExpectCounts(0, 1);
   1022     observer211.ExpectCounts(0, 1);
   1023   }
   1024   virtual void ActivationEvents() OVERRIDE {
   1025     DCHECK(!parent_) << "Activation tests don't support parent changes.";
   1026 
   1027     aura::Window* w2 = root_window()->GetChildById(2);
   1028     ActivateWindow(w2);
   1029 
   1030     ScopedFocusNotificationObserver root_observer(root_window());
   1031     ScopedTargetFocusNotificationObserver observer2(root_window(), 2);
   1032     ScopedTargetFocusNotificationObserver observer3(root_window(), 3);
   1033     root_observer.ExpectCounts(0, 0);
   1034     observer2.ExpectCounts(0, 0);
   1035     observer3.ExpectCounts(0, 0);
   1036 
   1037     ChangeWindowDisposition(w2);
   1038     root_observer.ExpectCounts(1, 1);
   1039     observer2.ExpectCounts(1, 1);
   1040     observer3.ExpectCounts(1, 1);
   1041   }
   1042   virtual void FocusRulesOverride() OVERRIDE {
   1043     EXPECT_EQ(NULL, GetFocusedWindow());
   1044     aura::Window* w211 = root_window()->GetChildById(211);
   1045     FocusWindow(w211);
   1046     EXPECT_EQ(211, GetFocusedWindowId());
   1047 
   1048     test_focus_rules()->set_focus_restriction(root_window()->GetChildById(11));
   1049     ChangeWindowDisposition(w211);
   1050     // Normally, focus would shift to the parent (w21) but the override shifts
   1051     // it to 11.
   1052     EXPECT_EQ(11, GetFocusedWindowId());
   1053 
   1054     test_focus_rules()->set_focus_restriction(NULL);
   1055   }
   1056   virtual void ActivationRulesOverride() OVERRIDE {
   1057     DCHECK(!parent_) << "Activation tests don't support parent changes.";
   1058 
   1059     aura::Window* w1 = root_window()->GetChildById(1);
   1060     ActivateWindow(w1);
   1061 
   1062     EXPECT_EQ(1, GetActiveWindowId());
   1063     EXPECT_EQ(1, GetFocusedWindowId());
   1064 
   1065     aura::Window* w3 = root_window()->GetChildById(3);
   1066     test_focus_rules()->set_focus_restriction(w3);
   1067 
   1068     // Normally, activation/focus would move to w2, but since we have a focus
   1069     // restriction, it should move to w3 instead.
   1070     ChangeWindowDisposition(w1);
   1071     EXPECT_EQ(3, GetActiveWindowId());
   1072     EXPECT_EQ(3, GetFocusedWindowId());
   1073 
   1074     test_focus_rules()->set_focus_restriction(NULL);
   1075     ActivateWindow(root_window()->GetChildById(2));
   1076     EXPECT_EQ(2, GetActiveWindowId());
   1077     EXPECT_EQ(2, GetFocusedWindowId());
   1078   }
   1079 
   1080  private:
   1081   // When true, the disposition change occurs to the parent of the window
   1082   // instead of to the window. This verifies that changes occurring in the
   1083   // hierarchy that contains the window affect the window's focus.
   1084   bool parent_;
   1085 
   1086   DISALLOW_COPY_AND_ASSIGN(FocusControllerImplicitTestBase);
   1087 };
   1088 
   1089 // Focus and Activation changes in response to window visibility changes.
   1090 class FocusControllerHideTest : public FocusControllerImplicitTestBase {
   1091  public:
   1092   FocusControllerHideTest() : FocusControllerImplicitTestBase(false) {}
   1093 
   1094  protected:
   1095   FocusControllerHideTest(bool parent)
   1096       : FocusControllerImplicitTestBase(parent) {}
   1097 
   1098   // Overridden from FocusControllerImplicitTestBase:
   1099   virtual void ChangeWindowDisposition(aura::Window* window) OVERRIDE {
   1100     GetDispositionWindow(window)->Hide();
   1101   }
   1102 
   1103  private:
   1104   DISALLOW_COPY_AND_ASSIGN(FocusControllerHideTest);
   1105 };
   1106 
   1107 // Focus and Activation changes in response to window parent visibility
   1108 // changes.
   1109 class FocusControllerParentHideTest : public FocusControllerHideTest {
   1110  public:
   1111   FocusControllerParentHideTest() : FocusControllerHideTest(true) {}
   1112 
   1113  private:
   1114   DISALLOW_COPY_AND_ASSIGN(FocusControllerParentHideTest);
   1115 };
   1116 
   1117 // Focus and Activation changes in response to window destruction.
   1118 class FocusControllerDestructionTest : public FocusControllerImplicitTestBase {
   1119  public:
   1120   FocusControllerDestructionTest() : FocusControllerImplicitTestBase(false) {}
   1121 
   1122  protected:
   1123   FocusControllerDestructionTest(bool parent)
   1124       : FocusControllerImplicitTestBase(parent) {}
   1125 
   1126   // Overridden from FocusControllerImplicitTestBase:
   1127   virtual void ChangeWindowDisposition(aura::Window* window) OVERRIDE {
   1128     delete GetDispositionWindow(window);
   1129   }
   1130 
   1131  private:
   1132   DISALLOW_COPY_AND_ASSIGN(FocusControllerDestructionTest);
   1133 };
   1134 
   1135 // Focus and Activation changes in response to window parent destruction.
   1136 class FocusControllerParentDestructionTest
   1137     : public FocusControllerDestructionTest {
   1138  public:
   1139   FocusControllerParentDestructionTest()
   1140       : FocusControllerDestructionTest(true) {}
   1141 
   1142  private:
   1143   DISALLOW_COPY_AND_ASSIGN(FocusControllerParentDestructionTest);
   1144 };
   1145 
   1146 // Focus and Activation changes in response to window removal.
   1147 class FocusControllerRemovalTest : public FocusControllerImplicitTestBase {
   1148  public:
   1149   FocusControllerRemovalTest() : FocusControllerImplicitTestBase(false) {}
   1150 
   1151  protected:
   1152   FocusControllerRemovalTest(bool parent)
   1153       : FocusControllerImplicitTestBase(parent) {}
   1154 
   1155   // Overridden from FocusControllerImplicitTestBase:
   1156   virtual void ChangeWindowDisposition(aura::Window* window) OVERRIDE {
   1157     aura::Window* disposition_window = GetDispositionWindow(window);
   1158     disposition_window->parent()->RemoveChild(disposition_window);
   1159     window_owner_.reset(disposition_window);
   1160   }
   1161   virtual void TearDown() OVERRIDE {
   1162     window_owner_.reset();
   1163     FocusControllerImplicitTestBase::TearDown();
   1164   }
   1165 
   1166  private:
   1167   scoped_ptr<aura::Window> window_owner_;
   1168 
   1169   DISALLOW_COPY_AND_ASSIGN(FocusControllerRemovalTest);
   1170 };
   1171 
   1172 // Focus and Activation changes in response to window parent removal.
   1173 class FocusControllerParentRemovalTest : public FocusControllerRemovalTest {
   1174  public:
   1175   FocusControllerParentRemovalTest() : FocusControllerRemovalTest(true) {}
   1176 
   1177  private:
   1178   DISALLOW_COPY_AND_ASSIGN(FocusControllerParentRemovalTest);
   1179 };
   1180 
   1181 
   1182 #define FOCUS_CONTROLLER_TEST(TESTCLASS, TESTNAME) \
   1183     TEST_F(TESTCLASS, TESTNAME) { TESTNAME(); }
   1184 
   1185 // Runs direct focus change tests (input events and API calls).
   1186 #define DIRECT_FOCUS_CHANGE_TESTS(TESTNAME) \
   1187     FOCUS_CONTROLLER_TEST(FocusControllerApiTest, TESTNAME) \
   1188     FOCUS_CONTROLLER_TEST(FocusControllerMouseEventTest, TESTNAME) \
   1189     FOCUS_CONTROLLER_TEST(FocusControllerGestureEventTest, TESTNAME)
   1190 
   1191 // Runs implicit focus change tests for disposition changes to target.
   1192 #define IMPLICIT_FOCUS_CHANGE_TARGET_TESTS(TESTNAME) \
   1193     FOCUS_CONTROLLER_TEST(FocusControllerHideTest, TESTNAME) \
   1194     FOCUS_CONTROLLER_TEST(FocusControllerDestructionTest, TESTNAME) \
   1195     FOCUS_CONTROLLER_TEST(FocusControllerRemovalTest, TESTNAME)
   1196 
   1197 // Runs implicit focus change tests for disposition changes to target's parent
   1198 // hierarchy.
   1199 #define IMPLICIT_FOCUS_CHANGE_PARENT_TESTS(TESTNAME) \
   1200     /* TODO(beng): parent destruction tests are not supported at
   1201        present due to workspace manager issues. \
   1202     FOCUS_CONTROLLER_TEST(FocusControllerParentDestructionTest, TESTNAME) */ \
   1203     FOCUS_CONTROLLER_TEST(FocusControllerParentHideTest, TESTNAME) \
   1204     FOCUS_CONTROLLER_TEST(FocusControllerParentRemovalTest, TESTNAME)
   1205 
   1206 // Runs all implicit focus change tests (changes to the target and target's
   1207 // parent hierarchy)
   1208 #define IMPLICIT_FOCUS_CHANGE_TESTS(TESTNAME) \
   1209     IMPLICIT_FOCUS_CHANGE_TARGET_TESTS(TESTNAME) \
   1210     IMPLICIT_FOCUS_CHANGE_PARENT_TESTS(TESTNAME)
   1211 
   1212 // Runs all possible focus change tests.
   1213 #define ALL_FOCUS_TESTS(TESTNAME) \
   1214     DIRECT_FOCUS_CHANGE_TESTS(TESTNAME) \
   1215     IMPLICIT_FOCUS_CHANGE_TESTS(TESTNAME)
   1216 
   1217 // Runs focus change tests that apply only to the target. For example,
   1218 // implicit activation changes caused by window disposition changes do not
   1219 // occur when changes to the containing hierarchy happen.
   1220 #define TARGET_FOCUS_TESTS(TESTNAME) \
   1221     DIRECT_FOCUS_CHANGE_TESTS(TESTNAME) \
   1222     IMPLICIT_FOCUS_CHANGE_TARGET_TESTS(TESTNAME)
   1223 
   1224 // - Focuses a window, verifies that focus changed.
   1225 ALL_FOCUS_TESTS(BasicFocus);
   1226 
   1227 // - Activates a window, verifies that activation changed.
   1228 TARGET_FOCUS_TESTS(BasicActivation);
   1229 
   1230 // - Focuses a window, verifies that focus events were dispatched.
   1231 ALL_FOCUS_TESTS(FocusEvents);
   1232 
   1233 // - Focuses or activates a window multiple times, verifies that events are only
   1234 //   dispatched when focus/activation actually changes.
   1235 DIRECT_FOCUS_CHANGE_TESTS(DuplicateFocusEvents);
   1236 DIRECT_FOCUS_CHANGE_TESTS(DuplicateActivationEvents);
   1237 
   1238 // - Activates a window, verifies that activation events were dispatched.
   1239 TARGET_FOCUS_TESTS(ActivationEvents);
   1240 
   1241 // - Attempts to active a hidden window, verifies that current window is
   1242 //   attempted to be reactivated and the appropriate event dispatched.
   1243 FOCUS_CONTROLLER_TEST(FocusControllerApiTest, ReactivationEvents);
   1244 
   1245 // - Input events/API calls shift focus between focusable windows within the
   1246 //   active window.
   1247 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusWithinActiveWindow);
   1248 
   1249 // - Input events/API calls to a child window of an inactive window shifts
   1250 //   activation to the activatable parent and focuses the child.
   1251 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusToChildOfInactiveWindow);
   1252 
   1253 // - Input events/API calls to focus the parent of the focused window do not
   1254 //   shift focus away from the child.
   1255 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusToParentOfFocusedWindow);
   1256 
   1257 // - Verifies that FocusRules determine what can be focused.
   1258 ALL_FOCUS_TESTS(FocusRulesOverride);
   1259 
   1260 // - Verifies that FocusRules determine what can be activated.
   1261 TARGET_FOCUS_TESTS(ActivationRulesOverride);
   1262 
   1263 // - Verifies that attempts to change focus or activation from a focus or
   1264 //   activation change observer are ignored.
   1265 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusOnActivation);
   1266 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusOnActivationDueToHide);
   1267 DIRECT_FOCUS_CHANGE_TESTS(NoShiftActiveOnActivation);
   1268 
   1269 // Clicking on a window which has capture should not result in a focus change.
   1270 DIRECT_FOCUS_CHANGE_TESTS(NoFocusChangeOnClickOnCaptureWindow);
   1271 
   1272 FOCUS_CONTROLLER_TEST(FocusControllerApiTest,
   1273                       ChangeFocusWhenNothingFocusedAndCaptured);
   1274 
   1275 // See description above DontPassDeletedWindow() for details.
   1276 FOCUS_CONTROLLER_TEST(FocusControllerApiTest, DontPassDeletedWindow);
   1277 
   1278 // - Verifies that the focused text input client is cleard when the window focus
   1279 //   changes.
   1280 ALL_FOCUS_TESTS(FocusedTextInputClient);
   1281 
   1282 // If a mouse event was handled, it should not activate a window.
   1283 FOCUS_CONTROLLER_TEST(FocusControllerMouseEventTest, IgnoreHandledEvent);
   1284 
   1285 }  // namespace wm
   1286