Index: mojo/services/window_manager/focus_controller_unittest.cc |
diff --git a/mojo/services/window_manager/focus_controller_unittest.cc b/mojo/services/window_manager/focus_controller_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..ea60ac726a53619205574047a81474d9ac127e82 |
--- /dev/null |
+++ b/mojo/services/window_manager/focus_controller_unittest.cc |
@@ -0,0 +1,1197 @@ |
+// Copyright (c) 2012 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#include "mojo/services/window_manager/focus_controller.h" |
+ |
+#include "mojo/converters/geometry/geometry_type_converters.h" |
+#include "mojo/services/window_manager/basic_focus_rules.h" |
+#include "mojo/services/window_manager/capture_controller.h" |
+#include "mojo/services/window_manager/focus_controller_observer.h" |
+#include "mojo/services/window_manager/view_event_dispatcher.h" |
+#include "mojo/services/window_manager/view_targeter.h" |
+#include "mojo/services/window_manager/window_manager_test_util.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+#include "ui/events/event_utils.h" |
+#include "ui/gfx/geometry/rect.h" |
+ |
+using mojo::View; |
+ |
+namespace window_manager { |
+ |
+// Counts the number of events that occur. |
+class FocusNotificationObserver : public FocusControllerObserver { |
+ public: |
+ FocusNotificationObserver() |
+ : activation_changed_count_(0), |
+ focus_changed_count_(0), |
+ reactivation_count_(0), |
+ reactivation_requested_view_(NULL), |
+ reactivation_actual_view_(NULL) {} |
+ ~FocusNotificationObserver() override {} |
+ |
+ void ExpectCounts(int activation_changed_count, int focus_changed_count) { |
+ EXPECT_EQ(activation_changed_count, activation_changed_count_); |
+ EXPECT_EQ(focus_changed_count, focus_changed_count_); |
+ } |
+ int reactivation_count() const { return reactivation_count_; } |
+ View* reactivation_requested_view() const { |
+ return reactivation_requested_view_; |
+ } |
+ View* reactivation_actual_view() const { |
+ return reactivation_actual_view_; |
+ } |
+ |
+ protected: |
+ // Overridden from FocusControllerObserver: |
+ void OnActivated(View* gained_active) override { |
+ ++activation_changed_count_; |
+ } |
+ |
+ void OnFocused(View* gained_focus) override { ++focus_changed_count_; } |
+ |
+ void OnAttemptToReactivateView(View* request_active, |
+ View* actual_active) override { |
+ ++reactivation_count_; |
+ reactivation_requested_view_ = request_active; |
+ reactivation_actual_view_ = actual_active; |
+ } |
+ |
+ private: |
+ int activation_changed_count_; |
+ int focus_changed_count_; |
+ int reactivation_count_; |
+ View* reactivation_requested_view_; |
+ View* reactivation_actual_view_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(FocusNotificationObserver); |
+}; |
+ |
+class ViewDestroyer { |
+ public: |
+ virtual View* GetDestroyedView() = 0; |
+ |
+ protected: |
+ virtual ~ViewDestroyer() {} |
+}; |
+ |
+// FocusNotificationObserver that keeps track of whether it was notified about |
+// activation changes or focus changes with a destroyed view. |
+class RecordingFocusNotificationObserver : public FocusNotificationObserver { |
+ public: |
+ RecordingFocusNotificationObserver(FocusController* focus_controller, |
+ ViewDestroyer* destroyer) |
+ : focus_controller_(focus_controller), |
+ destroyer_(destroyer), |
+ active_(nullptr), |
+ focus_(nullptr), |
+ was_notified_with_destroyed_view_(false) { |
+ focus_controller_->AddObserver(this); |
+ } |
+ ~RecordingFocusNotificationObserver() override { |
+ focus_controller_->RemoveObserver(this); |
+ } |
+ |
+ bool was_notified_with_destroyed_view() const { |
+ return was_notified_with_destroyed_view_; |
+ } |
+ |
+ // Overridden from FocusNotificationObserver: |
+ void OnActivated(View* gained_active) override { |
+ if (active_ && active_ == destroyer_->GetDestroyedView()) |
+ was_notified_with_destroyed_view_ = true; |
+ active_ = gained_active; |
+ } |
+ |
+ void OnFocused(View* gained_focus) override { |
+ if (focus_ && focus_ == destroyer_->GetDestroyedView()) |
+ was_notified_with_destroyed_view_ = true; |
+ focus_ = gained_focus; |
+ } |
+ |
+ private: |
+ FocusController* focus_controller_; |
+ |
+ // Not owned. |
+ ViewDestroyer* destroyer_; |
+ View* active_; |
+ View* focus_; |
+ |
+ // Whether the observer was notified about the loss of activation or the |
+ // loss of focus with a view already destroyed by |destroyer_| as the |
+ // |lost_active| or |lost_focus| parameter. |
+ bool was_notified_with_destroyed_view_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(RecordingFocusNotificationObserver); |
+}; |
+ |
+class DestroyOnLoseActivationFocusNotificationObserver |
+ : public FocusNotificationObserver, |
+ public ViewDestroyer { |
+ public: |
+ DestroyOnLoseActivationFocusNotificationObserver( |
+ FocusController* focus_controller, |
+ View* view_to_destroy, |
+ View* initial_active) |
+ : focus_controller_(focus_controller), |
+ view_to_destroy_(view_to_destroy), |
+ active_(initial_active), |
+ did_destroy_(false) { |
+ focus_controller_->AddObserver(this); |
+ } |
+ ~DestroyOnLoseActivationFocusNotificationObserver() override { |
+ focus_controller_->RemoveObserver(this); |
+ } |
+ |
+ // Overridden from FocusNotificationObserver: |
+ void OnActivated(View* gained_active) override { |
+ if (view_to_destroy_ && active_ == view_to_destroy_) { |
+ view_to_destroy_->Destroy(); |
+ did_destroy_ = true; |
+ } |
+ active_ = gained_active; |
+ } |
+ |
+ // Overridden from ViewDestroyer: |
+ View* GetDestroyedView() override { |
+ return did_destroy_ ? view_to_destroy_ : nullptr; |
+ } |
+ |
+ private: |
+ FocusController* focus_controller_; |
+ View* view_to_destroy_; |
+ View* active_; |
+ bool did_destroy_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(DestroyOnLoseActivationFocusNotificationObserver); |
+}; |
+ |
+class ScopedFocusNotificationObserver : public FocusNotificationObserver { |
+ public: |
+ ScopedFocusNotificationObserver(FocusController* focus_controller) |
+ : focus_controller_(focus_controller) { |
+ focus_controller_->AddObserver(this); |
+ } |
+ ~ScopedFocusNotificationObserver() override { |
+ focus_controller_->RemoveObserver(this); |
+ } |
+ |
+ private: |
+ FocusController* focus_controller_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(ScopedFocusNotificationObserver); |
+}; |
+ |
+// Only responds to events if a message contains |target| as a parameter. |
+class ScopedFilteringFocusNotificationObserver |
+ : public FocusNotificationObserver { |
+ public: |
+ ScopedFilteringFocusNotificationObserver(FocusController* focus_controller, |
+ View* target, |
+ View* initial_active, |
+ View* initial_focus) |
+ : focus_controller_(focus_controller), |
+ target_(target), |
+ active_(initial_active), |
+ focus_(initial_focus) { |
+ focus_controller_->AddObserver(this); |
+ } |
+ ~ScopedFilteringFocusNotificationObserver() override { |
+ focus_controller_->RemoveObserver(this); |
+ } |
+ |
+ private: |
+ // Overridden from FocusControllerObserver: |
+ void OnActivated(View* gained_active) override { |
+ if (gained_active == target_ || active_ == target_) |
+ FocusNotificationObserver::OnActivated(gained_active); |
+ active_ = gained_active; |
+ } |
+ |
+ void OnFocused(View* gained_focus) override { |
+ if (gained_focus == target_ || focus_ == target_) |
+ FocusNotificationObserver::OnFocused(gained_focus); |
+ focus_ = gained_focus; |
+ } |
+ |
+ void OnAttemptToReactivateView(View* request_active, |
+ View* actual_active) override { |
+ if (request_active == target_ || actual_active == target_) { |
+ FocusNotificationObserver::OnAttemptToReactivateView(request_active, |
+ actual_active); |
+ } |
+ } |
+ |
+ FocusController* focus_controller_; |
+ View* target_; |
+ View* active_; |
+ View* focus_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(ScopedFilteringFocusNotificationObserver); |
+}; |
+ |
+// Used to fake the handling of events in the pre-target phase. |
+class SimpleEventHandler : public ui::EventHandler { |
+ public: |
+ SimpleEventHandler() {} |
+ ~SimpleEventHandler() override {} |
+ |
+ // Overridden from ui::EventHandler: |
+ void OnMouseEvent(ui::MouseEvent* event) override { |
+ event->SetHandled(); |
+ } |
+ void OnGestureEvent(ui::GestureEvent* event) override { |
+ event->SetHandled(); |
+ } |
+ |
+ private: |
+ DISALLOW_COPY_AND_ASSIGN(SimpleEventHandler); |
+}; |
+ |
+class FocusShiftingActivationObserver |
+ : public FocusControllerObserver { |
+ public: |
+ explicit FocusShiftingActivationObserver(FocusController* focus_controller, |
+ View* activated_view) |
+ : focus_controller_(focus_controller), |
+ activated_view_(activated_view), |
+ shift_focus_to_(NULL) {} |
+ ~FocusShiftingActivationObserver() override {} |
+ |
+ void set_shift_focus_to(View* shift_focus_to) { |
+ shift_focus_to_ = shift_focus_to; |
+ } |
+ |
+ private: |
+ // Overridden from FocusControllerObserver: |
+ void OnActivated(View* gained_active) override { |
+ // Shift focus to a child. This should prevent the default focusing from |
+ // occurring in FocusController::FocusView(). |
+ if (gained_active == activated_view_) |
+ focus_controller_->FocusView(shift_focus_to_); |
+ } |
+ |
+ void OnFocused(View* gained_focus) override {} |
+ |
+ FocusController* focus_controller_; |
+ View* activated_view_; |
+ View* shift_focus_to_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(FocusShiftingActivationObserver); |
+}; |
+ |
+// BasicFocusRules subclass that allows basic overrides of focus/activation to |
+// be tested. This is intended more as a test that the override system works at |
+// all, rather than as an exhaustive set of use cases, those should be covered |
+// in tests for those FocusRules implementations. |
+class TestFocusRules : public BasicFocusRules { |
+ public: |
+ TestFocusRules(View* root) |
+ : BasicFocusRules(root), focus_restriction_(NULL) {} |
+ |
+ // Restricts focus and activation to this view and its child hierarchy. |
+ void set_focus_restriction(View* focus_restriction) { |
+ focus_restriction_ = focus_restriction; |
+ } |
+ |
+ // Overridden from BasicFocusRules: |
+ bool SupportsChildActivation(View* view) const override { |
+ // In FocusControllerTests, only the Root has activatable children. |
+ return view->GetRoot() == view; |
+ } |
+ bool CanActivateView(View* view) const override { |
+ // Restricting focus to a non-activatable child view means the activatable |
+ // parent outside the focus restriction is activatable. |
+ bool can_activate = |
+ CanFocusOrActivate(view) || view->Contains(focus_restriction_); |
+ return can_activate ? BasicFocusRules::CanActivateView(view) : false; |
+ } |
+ bool CanFocusView(View* view) const override { |
+ return CanFocusOrActivate(view) ? BasicFocusRules::CanFocusView(view) |
+ : false; |
+ } |
+ View* GetActivatableView(View* view) const override { |
+ return BasicFocusRules::GetActivatableView( |
+ CanFocusOrActivate(view) ? view : focus_restriction_); |
+ } |
+ View* GetFocusableView(View* view) const override { |
+ return BasicFocusRules::GetFocusableView( |
+ CanFocusOrActivate(view) ? view : focus_restriction_); |
+ } |
+ View* GetNextActivatableView(View* ignore) const override { |
+ View* next_activatable = BasicFocusRules::GetNextActivatableView(ignore); |
+ return CanFocusOrActivate(next_activatable) |
+ ? next_activatable |
+ : GetActivatableView(focus_restriction_); |
+ } |
+ |
+ private: |
+ bool CanFocusOrActivate(View* view) const { |
+ return !focus_restriction_ || focus_restriction_->Contains(view); |
+ } |
+ |
+ View* focus_restriction_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(TestFocusRules); |
+}; |
+ |
+// Common infrastructure shared by all FocusController test types. |
+class FocusControllerTestBase : public testing::Test { |
+ protected: |
+ // Hierarchy used by all tests: |
+ // root_view |
+ // +-- w1 |
+ // | +-- w11 |
+ // | +-- w12 |
+ // +-- w2 |
+ // | +-- w21 |
+ // | +-- w211 |
+ // +-- w3 |
+ FocusControllerTestBase() |
+ : root_view_(TestView::Build(0, gfx::Rect(0, 0, 800, 600))), |
+ v1(TestView::Build(1, gfx::Rect(0, 0, 50, 50), root_view())), |
+ v11(TestView::Build(11, gfx::Rect(5, 5, 10, 10), v1)), |
+ v12(TestView::Build(12, gfx::Rect(15, 15, 10, 10), v1)), |
+ v2(TestView::Build(2, gfx::Rect(75, 75, 50, 50), root_view())), |
+ v21(TestView::Build(21, gfx::Rect(5, 5, 10, 10), v2)), |
+ v211(TestView::Build(211, gfx::Rect(1, 1, 5, 5), v21)), |
+ v3(TestView::Build(3, gfx::Rect(125, 125, 50, 50), root_view())) {} |
+ |
+ // Overridden from testing::Test: |
+ void SetUp() override { |
+ testing::Test::SetUp(); |
+ |
+ test_focus_rules_ = new TestFocusRules(root_view()); |
+ focus_controller_.reset( |
+ new FocusController(scoped_ptr<FocusRules>(test_focus_rules_))); |
+ SetFocusController(root_view(), focus_controller_.get()); |
+ |
+ capture_controller_.reset(new CaptureController); |
+ SetCaptureController(root_view(), capture_controller_.get()); |
+ |
+ ViewTarget* root_target = root_view_->target(); |
+ root_target->SetEventTargeter(scoped_ptr<ViewTargeter>(new ViewTargeter())); |
+ view_event_dispatcher_.reset(new ViewEventDispatcher()); |
+ view_event_dispatcher_->SetRootViewTarget(root_target); |
+ |
+ GetRootViewTarget()->AddPreTargetHandler(focus_controller_.get()); |
+ } |
+ |
+ void TearDown() override { |
+ GetRootViewTarget()->RemovePreTargetHandler(focus_controller_.get()); |
+ view_event_dispatcher_.reset(); |
+ |
+ root_view_->Destroy(); |
+ |
+ capture_controller_.reset(); |
+ test_focus_rules_ = nullptr; // Owned by FocusController. |
+ focus_controller_.reset(); |
+ |
+ testing::Test::TearDown(); |
+ } |
+ |
+ void FocusView(View* view) { focus_controller_->FocusView(view); } |
+ View* GetFocusedView() { return focus_controller_->GetFocusedView(); } |
+ int GetFocusedViewId() { |
+ View* focused_view = GetFocusedView(); |
+ return focused_view ? focused_view->id() : -1; |
+ } |
+ void ActivateView(View* view) { focus_controller_->ActivateView(view); } |
+ void DeactivateView(View* view) { focus_controller_->DeactivateView(view); } |
+ View* GetActiveView() { return focus_controller_->GetActiveView(); } |
+ int GetActiveViewId() { |
+ View* active_view = GetActiveView(); |
+ return active_view ? active_view->id() : -1; |
+ } |
+ |
+ View* GetViewById(int id) { return root_view_->GetChildById(id); } |
+ |
+ void ClickLeftButton(View* view) { |
+ // Get the center bounds of |target| in |root_view_| coordinate space. |
+ gfx::Point center = |
+ gfx::Rect(view->bounds().To<gfx::Rect>().size()).CenterPoint(); |
+ ViewTarget::ConvertPointToTarget(ViewTarget::TargetFromView(view), |
+ root_view_->target(), ¢er); |
+ |
+ ui::MouseEvent button_down(ui::ET_MOUSE_PRESSED, center, center, |
+ ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON, |
+ ui::EF_NONE); |
+ ui::EventDispatchDetails details = |
+ view_event_dispatcher_->OnEventFromSource(&button_down); |
+ CHECK(!details.dispatcher_destroyed); |
+ |
+ ui::MouseEvent button_up(ui::ET_MOUSE_RELEASED, center, center, |
+ ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON, |
+ ui::EF_NONE); |
+ details = view_event_dispatcher_->OnEventFromSource(&button_up); |
+ CHECK(!details.dispatcher_destroyed); |
+ } |
+ |
+ ViewTarget* GetRootViewTarget() { |
+ return ViewTarget::TargetFromView(root_view()); |
+ } |
+ |
+ View* root_view() { return root_view_; } |
+ TestFocusRules* test_focus_rules() { return test_focus_rules_; } |
+ FocusController* focus_controller() { return focus_controller_.get(); } |
+ CaptureController* capture_controller() { return capture_controller_.get(); } |
+ |
+ // Test functions. |
+ virtual void BasicFocus() = 0; |
+ virtual void BasicActivation() = 0; |
+ virtual void FocusEvents() = 0; |
+ virtual void DuplicateFocusEvents() {} |
+ virtual void ActivationEvents() = 0; |
+ virtual void ReactivationEvents() {} |
+ virtual void DuplicateActivationEvents() {} |
+ virtual void ShiftFocusWithinActiveView() {} |
+ virtual void ShiftFocusToChildOfInactiveView() {} |
+ virtual void ShiftFocusToParentOfFocusedView() {} |
+ virtual void FocusRulesOverride() = 0; |
+ virtual void ActivationRulesOverride() = 0; |
+ virtual void ShiftFocusOnActivation() {} |
+ virtual void ShiftFocusOnActivationDueToHide() {} |
+ virtual void NoShiftActiveOnActivation() {} |
+ virtual void ChangeFocusWhenNothingFocusedAndCaptured() {} |
+ virtual void DontPassDestroyedView() {} |
+ // TODO(erg): Also, void FocusedTextInputClient() once we build the IME. |
+ |
+ private: |
+ TestView* root_view_; |
+ scoped_ptr<FocusController> focus_controller_; |
+ TestFocusRules* test_focus_rules_; |
+ scoped_ptr<CaptureController> capture_controller_; |
+ // TODO(erg): The aura version of this class also keeps track of WMState. Do |
+ // we need something analogous here? |
+ |
+ scoped_ptr<ViewEventDispatcher> view_event_dispatcher_; |
+ |
+ TestView* v1; |
+ TestView* v11; |
+ TestView* v12; |
+ TestView* v2; |
+ TestView* v21; |
+ TestView* v211; |
+ TestView* v3; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(FocusControllerTestBase); |
+}; |
+ |
+// Test base for tests where focus is directly set to a target view. |
+class FocusControllerDirectTestBase : public FocusControllerTestBase { |
+ protected: |
+ FocusControllerDirectTestBase() {} |
+ |
+ // Different test types shift focus in different ways. |
+ virtual void FocusViewDirect(View* view) = 0; |
+ virtual void ActivateViewDirect(View* view) = 0; |
+ virtual void DeactivateViewDirect(View* view) = 0; |
+ |
+ // Input events do not change focus if the view can not be focused. |
+ virtual bool IsInputEvent() = 0; |
+ |
+ void FocusViewById(int id) { |
+ View* view = root_view()->GetChildById(id); |
+ DCHECK(view); |
+ FocusViewDirect(view); |
+ } |
+ void ActivateViewById(int id) { |
+ View* view = root_view()->GetChildById(id); |
+ DCHECK(view); |
+ ActivateViewDirect(view); |
+ } |
+ |
+ // Overridden from FocusControllerTestBase: |
+ void BasicFocus() override { |
+ EXPECT_EQ(nullptr, GetFocusedView()); |
+ FocusViewById(1); |
+ EXPECT_EQ(1, GetFocusedViewId()); |
+ FocusViewById(2); |
+ EXPECT_EQ(2, GetFocusedViewId()); |
+ } |
+ void BasicActivation() override { |
+ EXPECT_EQ(nullptr, GetActiveView()); |
+ ActivateViewById(1); |
+ EXPECT_EQ(1, GetActiveViewId()); |
+ ActivateViewById(2); |
+ EXPECT_EQ(2, GetActiveViewId()); |
+ // Verify that attempting to deactivate NULL does not crash and does not |
+ // change activation. |
+ DeactivateView(nullptr); |
+ EXPECT_EQ(2, GetActiveViewId()); |
+ DeactivateView(GetActiveView()); |
+ EXPECT_EQ(1, GetActiveViewId()); |
+ } |
+ void FocusEvents() override { |
+ ScopedFocusNotificationObserver root_observer(focus_controller()); |
+ ScopedFilteringFocusNotificationObserver observer1( |
+ focus_controller(), GetViewById(1), GetActiveView(), GetFocusedView()); |
+ ScopedFilteringFocusNotificationObserver observer2( |
+ focus_controller(), GetViewById(2), GetActiveView(), GetFocusedView()); |
+ |
+ { |
+ SCOPED_TRACE("initial state"); |
+ root_observer.ExpectCounts(0, 0); |
+ observer1.ExpectCounts(0, 0); |
+ observer2.ExpectCounts(0, 0); |
+ } |
+ |
+ FocusViewById(1); |
+ { |
+ SCOPED_TRACE("FocusViewById(1)"); |
+ root_observer.ExpectCounts(1, 1); |
+ observer1.ExpectCounts(1, 1); |
+ observer2.ExpectCounts(0, 0); |
+ } |
+ |
+ FocusViewById(2); |
+ { |
+ SCOPED_TRACE("FocusViewById(2)"); |
+ root_observer.ExpectCounts(2, 2); |
+ observer1.ExpectCounts(2, 2); |
+ observer2.ExpectCounts(1, 1); |
+ } |
+ } |
+ void DuplicateFocusEvents() override { |
+ // Focusing an existing focused view should not resend focus events. |
+ ScopedFocusNotificationObserver root_observer(focus_controller()); |
+ ScopedFilteringFocusNotificationObserver observer1( |
+ focus_controller(), GetViewById(1), GetActiveView(), GetFocusedView()); |
+ |
+ root_observer.ExpectCounts(0, 0); |
+ observer1.ExpectCounts(0, 0); |
+ |
+ FocusViewById(1); |
+ root_observer.ExpectCounts(1, 1); |
+ observer1.ExpectCounts(1, 1); |
+ |
+ FocusViewById(1); |
+ root_observer.ExpectCounts(1, 1); |
+ observer1.ExpectCounts(1, 1); |
+ } |
+ void ActivationEvents() override { |
+ ActivateViewById(1); |
+ |
+ ScopedFocusNotificationObserver root_observer(focus_controller()); |
+ ScopedFilteringFocusNotificationObserver observer1( |
+ focus_controller(), GetViewById(1), GetActiveView(), GetFocusedView()); |
+ ScopedFilteringFocusNotificationObserver observer2( |
+ focus_controller(), GetViewById(2), GetActiveView(), GetFocusedView()); |
+ |
+ root_observer.ExpectCounts(0, 0); |
+ observer1.ExpectCounts(0, 0); |
+ observer2.ExpectCounts(0, 0); |
+ |
+ ActivateViewById(2); |
+ root_observer.ExpectCounts(1, 1); |
+ observer1.ExpectCounts(1, 1); |
+ observer2.ExpectCounts(1, 1); |
+ } |
+ void ReactivationEvents() override { |
+ ActivateViewById(1); |
+ ScopedFocusNotificationObserver root_observer(focus_controller()); |
+ EXPECT_EQ(0, root_observer.reactivation_count()); |
+ GetViewById(2)->SetVisible(false); |
+ // When we attempt to activate "2", which cannot be activated because it |
+ // is not visible, "1" will be reactivated. |
+ ActivateViewById(2); |
+ EXPECT_EQ(1, root_observer.reactivation_count()); |
+ EXPECT_EQ(GetViewById(2), |
+ root_observer.reactivation_requested_view()); |
+ EXPECT_EQ(GetViewById(1), |
+ root_observer.reactivation_actual_view()); |
+ } |
+ void DuplicateActivationEvents() override { |
+ ActivateViewById(1); |
+ |
+ ScopedFocusNotificationObserver root_observer(focus_controller()); |
+ ScopedFilteringFocusNotificationObserver observer1( |
+ focus_controller(), GetViewById(1), GetActiveView(), GetFocusedView()); |
+ ScopedFilteringFocusNotificationObserver observer2( |
+ focus_controller(), GetViewById(2), GetActiveView(), GetFocusedView()); |
+ |
+ root_observer.ExpectCounts(0, 0); |
+ observer1.ExpectCounts(0, 0); |
+ observer2.ExpectCounts(0, 0); |
+ |
+ ActivateViewById(2); |
+ root_observer.ExpectCounts(1, 1); |
+ observer1.ExpectCounts(1, 1); |
+ observer2.ExpectCounts(1, 1); |
+ |
+ // Activating an existing active view should not resend activation events. |
+ ActivateViewById(2); |
+ root_observer.ExpectCounts(1, 1); |
+ observer1.ExpectCounts(1, 1); |
+ observer2.ExpectCounts(1, 1); |
+ } |
+ void ShiftFocusWithinActiveView() override { |
+ ActivateViewById(1); |
+ EXPECT_EQ(1, GetActiveViewId()); |
+ EXPECT_EQ(1, GetFocusedViewId()); |
+ FocusViewById(11); |
+ EXPECT_EQ(11, GetFocusedViewId()); |
+ FocusViewById(12); |
+ EXPECT_EQ(12, GetFocusedViewId()); |
+ } |
+ void ShiftFocusToChildOfInactiveView() override { |
+ ActivateViewById(2); |
+ EXPECT_EQ(2, GetActiveViewId()); |
+ EXPECT_EQ(2, GetFocusedViewId()); |
+ FocusViewById(11); |
+ EXPECT_EQ(1, GetActiveViewId()); |
+ EXPECT_EQ(11, GetFocusedViewId()); |
+ } |
+ void ShiftFocusToParentOfFocusedView() override { |
+ ActivateViewById(1); |
+ EXPECT_EQ(1, GetFocusedViewId()); |
+ FocusViewById(11); |
+ EXPECT_EQ(11, GetFocusedViewId()); |
+ FocusViewById(1); |
+ // Focus should _not_ shift to the parent of the already-focused view. |
+ EXPECT_EQ(11, GetFocusedViewId()); |
+ } |
+ void FocusRulesOverride() override { |
+ EXPECT_EQ(NULL, GetFocusedView()); |
+ FocusViewById(11); |
+ EXPECT_EQ(11, GetFocusedViewId()); |
+ |
+ test_focus_rules()->set_focus_restriction(GetViewById(211)); |
+ FocusViewById(12); |
+ // Input events leave focus unchanged; direct API calls will change focus |
+ // to the restricted view. |
+ int focused_view = IsInputEvent() ? 11 : 211; |
+ EXPECT_EQ(focused_view, GetFocusedViewId()); |
+ |
+ test_focus_rules()->set_focus_restriction(NULL); |
+ FocusViewById(12); |
+ EXPECT_EQ(12, GetFocusedViewId()); |
+ } |
+ void ActivationRulesOverride() override { |
+ ActivateViewById(1); |
+ EXPECT_EQ(1, GetActiveViewId()); |
+ EXPECT_EQ(1, GetFocusedViewId()); |
+ |
+ View* v3 = GetViewById(3); |
+ test_focus_rules()->set_focus_restriction(v3); |
+ |
+ ActivateViewById(2); |
+ // Input events leave activation unchanged; direct API calls will activate |
+ // the restricted view. |
+ int active_view = IsInputEvent() ? 1 : 3; |
+ EXPECT_EQ(active_view, GetActiveViewId()); |
+ EXPECT_EQ(active_view, GetFocusedViewId()); |
+ |
+ test_focus_rules()->set_focus_restriction(NULL); |
+ ActivateViewById(2); |
+ EXPECT_EQ(2, GetActiveViewId()); |
+ EXPECT_EQ(2, GetFocusedViewId()); |
+ } |
+ void ShiftFocusOnActivation() override { |
+ // When a view is activated, by default that view is also focused. |
+ // An ActivationChangeObserver may shift focus to another view within the |
+ // same activatable view. |
+ ActivateViewById(2); |
+ EXPECT_EQ(2, GetFocusedViewId()); |
+ ActivateViewById(1); |
+ EXPECT_EQ(1, GetFocusedViewId()); |
+ |
+ ActivateViewById(2); |
+ |
+ View* target = GetViewById(1); |
+ |
+ scoped_ptr<FocusShiftingActivationObserver> observer( |
+ new FocusShiftingActivationObserver(focus_controller(), target)); |
+ observer->set_shift_focus_to(target->GetChildById(11)); |
+ focus_controller()->AddObserver(observer.get()); |
+ |
+ ActivateViewById(1); |
+ |
+ // w1's ActivationChangeObserver shifted focus to this child, pre-empting |
+ // FocusController's default setting. |
+ EXPECT_EQ(11, GetFocusedViewId()); |
+ |
+ ActivateViewById(2); |
+ EXPECT_EQ(2, GetFocusedViewId()); |
+ |
+ // Simulate a focus reset by the ActivationChangeObserver. This should |
+ // trigger the default setting in FocusController. |
+ observer->set_shift_focus_to(nullptr); |
+ ActivateViewById(1); |
+ EXPECT_EQ(1, GetFocusedViewId()); |
+ |
+ focus_controller()->RemoveObserver(observer.get()); |
+ |
+ ActivateViewById(2); |
+ EXPECT_EQ(2, GetFocusedViewId()); |
+ ActivateViewById(1); |
+ EXPECT_EQ(1, GetFocusedViewId()); |
+ } |
+ void ShiftFocusOnActivationDueToHide() override { |
+ // Similar to ShiftFocusOnActivation except the activation change is |
+ // triggered by hiding the active view. |
+ ActivateViewById(1); |
+ EXPECT_EQ(1, GetFocusedViewId()); |
+ |
+ // Removes view 3 as candidate for next activatable view. |
+ root_view()->GetChildById(3)->SetVisible(false); |
+ EXPECT_EQ(1, GetFocusedViewId()); |
+ |
+ View* target = root_view()->GetChildById(2); |
+ |
+ scoped_ptr<FocusShiftingActivationObserver> observer( |
+ new FocusShiftingActivationObserver(focus_controller(), target)); |
+ observer->set_shift_focus_to(target->GetChildById(21)); |
+ focus_controller()->AddObserver(observer.get()); |
+ |
+ // Hide the active view. |
+ root_view()->GetChildById(1)->SetVisible(false); |
+ |
+ EXPECT_EQ(21, GetFocusedViewId()); |
+ |
+ focus_controller()->RemoveObserver(observer.get()); |
+ } |
+ void NoShiftActiveOnActivation() override { |
+ // When a view is activated, we need to prevent any change to activation |
+ // from being made in response to an activation change notification. |
+ } |
+ |
+ // Verifies focus change is honored while capture held. |
+ void ChangeFocusWhenNothingFocusedAndCaptured() override { |
+ View* v1 = root_view()->GetChildById(1); |
+ capture_controller()->SetCapture(v1); |
+ |
+ EXPECT_EQ(-1, GetActiveViewId()); |
+ EXPECT_EQ(-1, GetFocusedViewId()); |
+ |
+ FocusViewById(1); |
+ |
+ EXPECT_EQ(1, GetActiveViewId()); |
+ EXPECT_EQ(1, GetFocusedViewId()); |
+ |
+ capture_controller()->ReleaseCapture(v1); |
+ } |
+ |
+ // Verifies if a view that loses activation or focus is destroyed during |
+ // observer notification we don't pass the destroyed view to other observers. |
+ void DontPassDestroyedView() override { |
+ FocusViewById(1); |
+ |
+ EXPECT_EQ(1, GetActiveViewId()); |
+ EXPECT_EQ(1, GetFocusedViewId()); |
+ |
+ { |
+ View* to_destroy = root_view()->GetChildById(1); |
+ DestroyOnLoseActivationFocusNotificationObserver observer1( |
+ focus_controller(), to_destroy, GetActiveView()); |
+ RecordingFocusNotificationObserver observer2(focus_controller(), |
+ &observer1); |
+ |
+ FocusViewById(2); |
+ |
+ EXPECT_EQ(2, GetActiveViewId()); |
+ EXPECT_EQ(2, GetFocusedViewId()); |
+ |
+ EXPECT_EQ(to_destroy, observer1.GetDestroyedView()); |
+ EXPECT_FALSE(observer2.was_notified_with_destroyed_view()); |
+ } |
+ |
+ { |
+ View* to_destroy = root_view()->GetChildById(2); |
+ DestroyOnLoseActivationFocusNotificationObserver observer1( |
+ focus_controller(), to_destroy, GetActiveView()); |
+ RecordingFocusNotificationObserver observer2(focus_controller(), |
+ &observer1); |
+ |
+ FocusViewById(3); |
+ |
+ EXPECT_EQ(3, GetActiveViewId()); |
+ EXPECT_EQ(3, GetFocusedViewId()); |
+ |
+ EXPECT_EQ(to_destroy, observer1.GetDestroyedView()); |
+ EXPECT_FALSE(observer2.was_notified_with_destroyed_view()); |
+ } |
+ } |
+ |
+ private: |
+ DISALLOW_COPY_AND_ASSIGN(FocusControllerDirectTestBase); |
+}; |
+ |
+// Focus and Activation changes via the FocusController API. |
+class FocusControllerApiTest : public FocusControllerDirectTestBase { |
+ public: |
+ FocusControllerApiTest() {} |
+ |
+ private: |
+ // Overridden from FocusControllerTestBase: |
+ void FocusViewDirect(View* view) override { FocusView(view); } |
+ void ActivateViewDirect(View* view) override { ActivateView(view); } |
+ void DeactivateViewDirect(View* view) override { DeactivateView(view); } |
+ bool IsInputEvent() override { return false; } |
+ |
+ DISALLOW_COPY_AND_ASSIGN(FocusControllerApiTest); |
+}; |
+ |
+// Focus and Activation changes via input events. |
+class FocusControllerMouseEventTest : public FocusControllerDirectTestBase { |
+ public: |
+ FocusControllerMouseEventTest() {} |
+ |
+ // Tests that a handled mouse event does not trigger a view activation. |
+ void IgnoreHandledEvent() { |
+ EXPECT_EQ(NULL, GetActiveView()); |
+ View* v1 = root_view()->GetChildById(1); |
+ SimpleEventHandler handler; |
+ GetRootViewTarget()->PrependPreTargetHandler(&handler); |
+ ClickLeftButton(v1); |
+ EXPECT_EQ(NULL, GetActiveView()); |
+ // TODO(erg): Add gesture testing when we get gestures working. |
+ GetRootViewTarget()->RemovePreTargetHandler(&handler); |
+ ClickLeftButton(v1); |
+ EXPECT_EQ(1, GetActiveViewId()); |
+ } |
+ |
+ private: |
+ // Overridden from FocusControllerTestBase: |
+ void FocusViewDirect(View* view) override { ClickLeftButton(view); } |
+ void ActivateViewDirect(View* view) override { ClickLeftButton(view); } |
+ void DeactivateViewDirect(View* view) override { |
+ View* next_activatable = test_focus_rules()->GetNextActivatableView(view); |
+ ClickLeftButton(next_activatable); |
+ } |
+ bool IsInputEvent() override { return true; } |
+ |
+ DISALLOW_COPY_AND_ASSIGN(FocusControllerMouseEventTest); |
+}; |
+ |
+// TODO(erg): Add a FocusControllerGestureEventTest once we have working |
+// gesture forwarding and handling. |
+ |
+// Test base for tests where focus is implicitly set to a window as the result |
+// of a disposition change to the focused window or the hierarchy that contains |
+// it. |
+class FocusControllerImplicitTestBase : public FocusControllerTestBase { |
+ protected: |
+ explicit FocusControllerImplicitTestBase(bool parent) : parent_(parent) {} |
+ |
+ View* GetDispositionView(View* view) { |
+ return parent_ ? view->parent() : view; |
+ } |
+ |
+ // Change the disposition of |view| in such a way as it will lose focus. |
+ virtual void ChangeViewDisposition(View* view) = 0; |
+ |
+ // Allow each disposition change test to add additional post-disposition |
+ // change expectations. |
+ virtual void PostDispostionChangeExpectations() {} |
+ |
+ // Overridden from FocusControllerTestBase: |
+ void BasicFocus() override { |
+ EXPECT_EQ(NULL, GetFocusedView()); |
+ |
+ View* w211 = root_view()->GetChildById(211); |
+ FocusView(w211); |
+ EXPECT_EQ(211, GetFocusedViewId()); |
+ |
+ ChangeViewDisposition(w211); |
+ // BasicFocusRules passes focus to the parent. |
+ EXPECT_EQ(parent_ ? 2 : 21, GetFocusedViewId()); |
+ } |
+ |
+ void BasicActivation() override { |
+ DCHECK(!parent_) << "Activation tests don't support parent changes."; |
+ |
+ EXPECT_EQ(NULL, GetActiveView()); |
+ |
+ View* w2 = root_view()->GetChildById(2); |
+ ActivateView(w2); |
+ EXPECT_EQ(2, GetActiveViewId()); |
+ |
+ ChangeViewDisposition(w2); |
+ EXPECT_EQ(3, GetActiveViewId()); |
+ PostDispostionChangeExpectations(); |
+ } |
+ |
+ void FocusEvents() override { |
+ View* w211 = root_view()->GetChildById(211); |
+ FocusView(w211); |
+ |
+ ScopedFocusNotificationObserver root_observer(focus_controller()); |
+ ScopedFilteringFocusNotificationObserver observer211( |
+ focus_controller(), GetViewById(211), GetActiveView(), |
+ GetFocusedView()); |
+ |
+ { |
+ SCOPED_TRACE("first"); |
+ root_observer.ExpectCounts(0, 0); |
+ observer211.ExpectCounts(0, 0); |
+ } |
+ |
+ ChangeViewDisposition(w211); |
+ { |
+ SCOPED_TRACE("second"); |
+ { |
+ SCOPED_TRACE("root_observer"); |
+ root_observer.ExpectCounts(0, 1); |
+ } |
+ { |
+ SCOPED_TRACE("observer211"); |
+ observer211.ExpectCounts(0, 1); |
+ } |
+ } |
+ } |
+ |
+ void ActivationEvents() override { |
+ DCHECK(!parent_) << "Activation tests don't support parent changes."; |
+ |
+ View* w2 = root_view()->GetChildById(2); |
+ ActivateView(w2); |
+ |
+ ScopedFocusNotificationObserver root_observer(focus_controller()); |
+ ScopedFilteringFocusNotificationObserver observer2( |
+ focus_controller(), GetViewById(2), GetActiveView(), GetFocusedView()); |
+ ScopedFilteringFocusNotificationObserver observer3( |
+ focus_controller(), GetViewById(3), GetActiveView(), GetFocusedView()); |
+ root_observer.ExpectCounts(0, 0); |
+ observer2.ExpectCounts(0, 0); |
+ observer3.ExpectCounts(0, 0); |
+ |
+ ChangeViewDisposition(w2); |
+ root_observer.ExpectCounts(1, 1); |
+ observer2.ExpectCounts(1, 1); |
+ observer3.ExpectCounts(1, 1); |
+ } |
+ |
+ void FocusRulesOverride() override { |
+ EXPECT_EQ(NULL, GetFocusedView()); |
+ View* w211 = root_view()->GetChildById(211); |
+ FocusView(w211); |
+ EXPECT_EQ(211, GetFocusedViewId()); |
+ |
+ test_focus_rules()->set_focus_restriction(root_view()->GetChildById(11)); |
+ ChangeViewDisposition(w211); |
+ // Normally, focus would shift to the parent (w21) but the override shifts |
+ // it to 11. |
+ EXPECT_EQ(11, GetFocusedViewId()); |
+ |
+ test_focus_rules()->set_focus_restriction(NULL); |
+ } |
+ |
+ void ActivationRulesOverride() override { |
+ DCHECK(!parent_) << "Activation tests don't support parent changes."; |
+ |
+ View* w1 = root_view()->GetChildById(1); |
+ ActivateView(w1); |
+ |
+ EXPECT_EQ(1, GetActiveViewId()); |
+ EXPECT_EQ(1, GetFocusedViewId()); |
+ |
+ View* w3 = root_view()->GetChildById(3); |
+ test_focus_rules()->set_focus_restriction(w3); |
+ |
+ // Normally, activation/focus would move to w2, but since we have a focus |
+ // restriction, it should move to w3 instead. |
+ ChangeViewDisposition(w1); |
+ EXPECT_EQ(3, GetActiveViewId()); |
+ EXPECT_EQ(3, GetFocusedViewId()); |
+ |
+ test_focus_rules()->set_focus_restriction(NULL); |
+ ActivateView(root_view()->GetChildById(2)); |
+ EXPECT_EQ(2, GetActiveViewId()); |
+ EXPECT_EQ(2, GetFocusedViewId()); |
+ } |
+ |
+ private: |
+ // When true, the disposition change occurs to the parent of the window |
+ // instead of to the window. This verifies that changes occurring in the |
+ // hierarchy that contains the window affect the window's focus. |
+ bool parent_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(FocusControllerImplicitTestBase); |
+}; |
+ |
+// Focus and Activation changes in response to window visibility changes. |
+class FocusControllerHideTest : public FocusControllerImplicitTestBase { |
+ public: |
+ FocusControllerHideTest() : FocusControllerImplicitTestBase(false) {} |
+ |
+ protected: |
+ FocusControllerHideTest(bool parent) |
+ : FocusControllerImplicitTestBase(parent) {} |
+ |
+ // Overridden from FocusControllerImplicitTestBase: |
+ void ChangeViewDisposition(View* view) override { |
+ GetDispositionView(view)->SetVisible(false); |
+ } |
+ |
+ private: |
+ DISALLOW_COPY_AND_ASSIGN(FocusControllerHideTest); |
+}; |
+ |
+// Focus and Activation changes in response to window parent visibility |
+// changes. |
+class FocusControllerParentHideTest : public FocusControllerHideTest { |
+ public: |
+ FocusControllerParentHideTest() : FocusControllerHideTest(true) {} |
+ |
+ private: |
+ DISALLOW_COPY_AND_ASSIGN(FocusControllerParentHideTest); |
+}; |
+ |
+// Focus and Activation changes in response to window destruction. |
+class FocusControllerDestructionTest : public FocusControllerImplicitTestBase { |
+ public: |
+ FocusControllerDestructionTest() : FocusControllerImplicitTestBase(false) {} |
+ |
+ protected: |
+ FocusControllerDestructionTest(bool parent) |
+ : FocusControllerImplicitTestBase(parent) {} |
+ |
+ // Overridden from FocusControllerImplicitTestBase: |
+ void ChangeViewDisposition(View* view) override { |
+ GetDispositionView(view)->Destroy(); |
+ } |
+ |
+ private: |
+ DISALLOW_COPY_AND_ASSIGN(FocusControllerDestructionTest); |
+}; |
+ |
+// Focus and Activation changes in response to window removal. |
+class FocusControllerRemovalTest : public FocusControllerImplicitTestBase { |
+ public: |
+ FocusControllerRemovalTest() |
+ : FocusControllerImplicitTestBase(false), |
+ window_to_destroy_(nullptr) {} |
+ |
+ protected: |
+ FocusControllerRemovalTest(bool parent) |
+ : FocusControllerImplicitTestBase(parent), |
+ window_to_destroy_(nullptr) {} |
+ |
+ // Overridden from FocusControllerImplicitTestBase: |
+ void ChangeViewDisposition(View* view) override { |
+ View* disposition_view = GetDispositionView(view); |
+ disposition_view->parent()->RemoveChild(disposition_view); |
+ window_to_destroy_ = disposition_view; |
+ } |
+ void TearDown() override { |
+ if (window_to_destroy_) |
+ window_to_destroy_->Destroy(); |
+ |
+ FocusControllerImplicitTestBase::TearDown(); |
+ } |
+ |
+ private: |
+ View* window_to_destroy_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(FocusControllerRemovalTest); |
+}; |
+ |
+// Focus and Activation changes in response to window parent removal. |
+class FocusControllerParentRemovalTest : public FocusControllerRemovalTest { |
+ public: |
+ FocusControllerParentRemovalTest() : FocusControllerRemovalTest(true) {} |
+ |
+ private: |
+ DISALLOW_COPY_AND_ASSIGN(FocusControllerParentRemovalTest); |
+}; |
+ |
+#define FOCUS_CONTROLLER_TEST(TESTCLASS, TESTNAME) \ |
+ TEST_F(TESTCLASS, TESTNAME) { TESTNAME(); } |
+ |
+// Runs direct focus change tests (input events and API calls). |
+// |
+// TODO(erg): Enable gesture events in the future. |
+#define DIRECT_FOCUS_CHANGE_TESTS(TESTNAME) \ |
+ FOCUS_CONTROLLER_TEST(FocusControllerApiTest, TESTNAME) \ |
+ FOCUS_CONTROLLER_TEST(FocusControllerMouseEventTest, TESTNAME) |
+ |
+// Runs implicit focus change tests for disposition changes to target. |
+#define IMPLICIT_FOCUS_CHANGE_TARGET_TESTS(TESTNAME) \ |
+ FOCUS_CONTROLLER_TEST(FocusControllerHideTest, TESTNAME) \ |
+ FOCUS_CONTROLLER_TEST(FocusControllerDestructionTest, TESTNAME) \ |
+ FOCUS_CONTROLLER_TEST(FocusControllerRemovalTest, TESTNAME) |
+ |
+// Runs implicit focus change tests for disposition changes to target's parent |
+// hierarchy. |
+#define IMPLICIT_FOCUS_CHANGE_PARENT_TESTS(TESTNAME) \ |
+ FOCUS_CONTROLLER_TEST(FocusControllerParentHideTest, TESTNAME) \ |
+ FOCUS_CONTROLLER_TEST(FocusControllerParentRemovalTest, TESTNAME) |
+// TODO(erg): FocusControllerParentDestructionTest were commented out in the |
+// aura version of this file, and don't work when I tried porting things over. |
+ |
+// Runs all implicit focus change tests (changes to the target and target's |
+// parent hierarchy) |
+#define IMPLICIT_FOCUS_CHANGE_TESTS(TESTNAME) \ |
+ IMPLICIT_FOCUS_CHANGE_TARGET_TESTS(TESTNAME) \ |
+ IMPLICIT_FOCUS_CHANGE_PARENT_TESTS(TESTNAME) |
+ |
+// Runs all possible focus change tests. |
+#define ALL_FOCUS_TESTS(TESTNAME) \ |
+ DIRECT_FOCUS_CHANGE_TESTS(TESTNAME) \ |
+ IMPLICIT_FOCUS_CHANGE_TESTS(TESTNAME) |
+ |
+// Runs focus change tests that apply only to the target. For example, |
+// implicit activation changes caused by window disposition changes do not |
+// occur when changes to the containing hierarchy happen. |
+#define TARGET_FOCUS_TESTS(TESTNAME) \ |
+ DIRECT_FOCUS_CHANGE_TESTS(TESTNAME) \ |
+ IMPLICIT_FOCUS_CHANGE_TARGET_TESTS(TESTNAME) |
+ |
+// - Focuses a window, verifies that focus changed. |
+ALL_FOCUS_TESTS(BasicFocus); |
+ |
+// - Activates a window, verifies that activation changed. |
+TARGET_FOCUS_TESTS(BasicActivation); |
+ |
+// - Focuses a window, verifies that focus events were dispatched. |
+ALL_FOCUS_TESTS(FocusEvents); |
+ |
+// - Focuses or activates a window multiple times, verifies that events are only |
+// dispatched when focus/activation actually changes. |
+DIRECT_FOCUS_CHANGE_TESTS(DuplicateFocusEvents); |
+DIRECT_FOCUS_CHANGE_TESTS(DuplicateActivationEvents); |
+ |
+// - Activates a window, verifies that activation events were dispatched. |
+TARGET_FOCUS_TESTS(ActivationEvents); |
+ |
+// - Attempts to active a hidden view, verifies that current view is |
+// attempted to be reactivated and the appropriate event dispatched. |
+FOCUS_CONTROLLER_TEST(FocusControllerApiTest, ReactivationEvents); |
+ |
+// - Input events/API calls shift focus between focusable views within the |
+// active view. |
+DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusWithinActiveView); |
+ |
+// - Input events/API calls to a child view of an inactive view shifts |
+// activation to the activatable parent and focuses the child. |
+DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusToChildOfInactiveView); |
+ |
+// - Input events/API calls to focus the parent of the focused view do not |
+// shift focus away from the child. |
+DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusToParentOfFocusedView); |
+ |
+// - Verifies that FocusRules determine what can be focused. |
+ALL_FOCUS_TESTS(FocusRulesOverride); |
+ |
+// - Verifies that FocusRules determine what can be activated. |
+TARGET_FOCUS_TESTS(ActivationRulesOverride); |
+ |
+// - Verifies that attempts to change focus or activation from a focus or |
+// activation change observer are ignored. |
+DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusOnActivation); |
+DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusOnActivationDueToHide); |
+DIRECT_FOCUS_CHANGE_TESTS(NoShiftActiveOnActivation); |
+ |
+FOCUS_CONTROLLER_TEST(FocusControllerApiTest, |
+ ChangeFocusWhenNothingFocusedAndCaptured); |
+ |
+// See description above DontPassDestroyedView() for details. |
+FOCUS_CONTROLLER_TEST(FocusControllerApiTest, DontPassDestroyedView); |
+ |
+// TODO(erg): Add the TextInputClient tests here. |
+ |
+// If a mouse event was handled, it should not activate a view. |
+FOCUS_CONTROLLER_TEST(FocusControllerMouseEventTest, IgnoreHandledEvent); |
+ |
+} // namespace window_manager |