focus_controller_unittest.cc revision 0de6073388f4e2780db8536178b129cd8f6ab386 
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
29namespace wm {
30
31class 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
85class 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.
96class 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.
146class 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.
183class 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
219class 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
237class 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
259class 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.
279class 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
296class 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.
331class 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.
385class 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.
497class 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.
880class 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.
901class 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
943class 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.
971class 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.
1090class 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.
1109class 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.
1118class 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.
1136class 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.
1147class 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.
1173class 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.
1225ALL_FOCUS_TESTS(BasicFocus);
1226
1227// - Activates a window, verifies that activation changed.
1228TARGET_FOCUS_TESTS(BasicActivation);
1229
1230// - Focuses a window, verifies that focus events were dispatched.
1231ALL_FOCUS_TESTS(FocusEvents);
1232
1233// - Focuses or activates a window multiple times, verifies that events are only
1234//   dispatched when focus/activation actually changes.
1235DIRECT_FOCUS_CHANGE_TESTS(DuplicateFocusEvents);
1236DIRECT_FOCUS_CHANGE_TESTS(DuplicateActivationEvents);
1237
1238// - Activates a window, verifies that activation events were dispatched.
1239TARGET_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.
1243FOCUS_CONTROLLER_TEST(FocusControllerApiTest, ReactivationEvents);
1244
1245// - Input events/API calls shift focus between focusable windows within the
1246//   active window.
1247DIRECT_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.
1251DIRECT_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.
1255DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusToParentOfFocusedWindow);
1256
1257// - Verifies that FocusRules determine what can be focused.
1258ALL_FOCUS_TESTS(FocusRulesOverride);
1259
1260// - Verifies that FocusRules determine what can be activated.
1261TARGET_FOCUS_TESTS(ActivationRulesOverride);
1262
1263// - Verifies that attempts to change focus or activation from a focus or
1264//   activation change observer are ignored.
1265DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusOnActivation);
1266DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusOnActivationDueToHide);
1267DIRECT_FOCUS_CHANGE_TESTS(NoShiftActiveOnActivation);
1268
1269// Clicking on a window which has capture should not result in a focus change.
1270DIRECT_FOCUS_CHANGE_TESTS(NoFocusChangeOnClickOnCaptureWindow);
1271
1272FOCUS_CONTROLLER_TEST(FocusControllerApiTest,
1273                      ChangeFocusWhenNothingFocusedAndCaptured);
1274
1275// See description above DontPassDeletedWindow() for details.
1276FOCUS_CONTROLLER_TEST(FocusControllerApiTest, DontPassDeletedWindow);
1277
1278// - Verifies that the focused text input client is cleard when the window focus
1279//   changes.
1280ALL_FOCUS_TESTS(FocusedTextInputClient);
1281
1282// If a mouse event was handled, it should not activate a window.
1283FOCUS_CONTROLLER_TEST(FocusControllerMouseEventTest, IgnoreHandledEvent);
1284
1285}  // namespace wm
1286