#include "ui/aura/client/default_capture_client.h"
#include "ui/aura/client/focus_change_observer.h"
#include "ui/aura/test/aura_test_base.h"
-#include "ui/aura/test/event_generator.h"
#include "ui/aura/test/test_window_delegate.h"
#include "ui/aura/test/test_windows.h"
#include "ui/aura/window.h"
#include "ui/aura/window_event_dispatcher.h"
#include "ui/aura/window_tracker.h"
+#include "ui/base/ime/dummy_text_input_client.h"
+#include "ui/base/ime/text_input_focus_manager.h"
+#include "ui/events/event.h"
+#include "ui/events/event_constants.h"
#include "ui/events/event_handler.h"
+#include "ui/events/test/event_generator.h"
#include "ui/wm/core/base_focus_rules.h"
#include "ui/wm/core/wm_state.h"
#include "ui/wm/public/activation_change_observer.h"
reactivation_count_(0),
reactivation_requested_window_(NULL),
reactivation_actual_window_(NULL) {}
- virtual ~FocusNotificationObserver() {}
+ ~FocusNotificationObserver() override {}
void ExpectCounts(int activation_changed_count, int focus_changed_count) {
EXPECT_EQ(activation_changed_count, activation_changed_count_);
private:
// Overridden from aura::client::ActivationChangeObserver:
- virtual void OnWindowActivated(aura::Window* gained_active,
- aura::Window* lost_active) OVERRIDE {
+ void OnWindowActivated(aura::Window* gained_active,
+ aura::Window* lost_active) override {
++activation_changed_count_;
}
- virtual void OnAttemptToReactivateWindow(
- aura::Window* request_active,
- aura::Window* actual_active) OVERRIDE {
+ void OnAttemptToReactivateWindow(aura::Window* request_active,
+ aura::Window* actual_active) override {
++reactivation_count_;
reactivation_requested_window_ = request_active;
reactivation_actual_window_ = actual_active;
}
// Overridden from aura::client::FocusChangeObserver:
- virtual void OnWindowFocused(aura::Window* gained_focus,
- aura::Window* lost_focus) OVERRIDE {
+ void OnWindowFocused(aura::Window* gained_focus,
+ aura::Window* lost_focus) override {
++focus_changed_count_;
}
aura::client::GetActivationClient(root_)->AddObserver(this);
aura::client::GetFocusClient(root_)->AddObserver(this);
}
- virtual ~RecordingActivationAndFocusChangeObserver() {
+ ~RecordingActivationAndFocusChangeObserver() override {
aura::client::GetActivationClient(root_)->RemoveObserver(this);
aura::client::GetFocusClient(root_)->RemoveObserver(this);
}
}
// Overridden from aura::client::ActivationChangeObserver:
- virtual void OnWindowActivated(aura::Window* gained_active,
- aura::Window* lost_active) OVERRIDE {
+ void OnWindowActivated(aura::Window* gained_active,
+ aura::Window* lost_active) override {
if (lost_active && lost_active == deleter_->GetDeletedWindow())
was_notified_with_deleted_window_ = true;
}
// Overridden from aura::client::FocusChangeObserver:
- virtual void OnWindowFocused(aura::Window* gained_focus,
- aura::Window* lost_focus) OVERRIDE {
+ void OnWindowFocused(aura::Window* gained_focus,
+ aura::Window* lost_focus) override {
if (lost_focus && lost_focus == deleter_->GetDeletedWindow())
was_notified_with_deleted_window_ = true;
}
did_delete_(false) {
aura::client::GetActivationClient(root_)->AddObserver(this);
}
- virtual ~DeleteOnLoseActivationChangeObserver() {
+ ~DeleteOnLoseActivationChangeObserver() override {
aura::client::GetActivationClient(root_)->RemoveObserver(this);
}
// Overridden from aura::client::ActivationChangeObserver:
- virtual void OnWindowActivated(aura::Window* gained_active,
- aura::Window* lost_active) OVERRIDE {
+ void OnWindowActivated(aura::Window* gained_active,
+ aura::Window* lost_active) override {
if (window_ && lost_active == window_) {
delete lost_active;
did_delete_ = true;
}
// Overridden from WindowDeleter:
- virtual aura::Window* GetDeletedWindow() OVERRIDE {
+ aura::Window* GetDeletedWindow() override {
return did_delete_ ? window_ : NULL;
}
did_delete_(false) {
aura::client::GetFocusClient(root_)->AddObserver(this);
}
- virtual ~DeleteOnLoseFocusChangeObserver() {
+ ~DeleteOnLoseFocusChangeObserver() override {
aura::client::GetFocusClient(root_)->RemoveObserver(this);
}
// Overridden from aura::client::FocusChangeObserver:
- virtual void OnWindowFocused(aura::Window* gained_focus,
- aura::Window* lost_focus) OVERRIDE {
+ void OnWindowFocused(aura::Window* gained_focus,
+ aura::Window* lost_focus) override {
if (window_ && lost_focus == window_) {
delete lost_focus;
did_delete_ = true;
}
// Overridden from WindowDeleter:
- virtual aura::Window* GetDeletedWindow() OVERRIDE {
+ aura::Window* GetDeletedWindow() override {
return did_delete_ ? window_ : NULL;
}
aura::client::GetActivationClient(root_window_)->AddObserver(this);
aura::client::GetFocusClient(root_window_)->AddObserver(this);
}
- virtual ~ScopedFocusNotificationObserver() {
+ ~ScopedFocusNotificationObserver() override {
aura::client::GetActivationClient(root_window_)->RemoveObserver(this);
aura::client::GetFocusClient(root_window_)->RemoveObserver(this);
}
aura::client::SetFocusChangeObserver(target_, this);
tracker_.Add(target_);
}
- virtual ~ScopedTargetFocusNotificationObserver() {
+ ~ScopedTargetFocusNotificationObserver() override {
if (tracker_.Contains(target_)) {
aura::client::SetActivationChangeObserver(target_, NULL);
aura::client::SetFocusChangeObserver(target_, NULL);
DISALLOW_COPY_AND_ASSIGN(ScopedTargetFocusNotificationObserver);
};
+class ScopedFocusedTextInputClientChanger
+ : public ScopedFocusNotificationObserver {
+ public:
+ ScopedFocusedTextInputClientChanger(aura::Window* root_window,
+ ui::TextInputClient* text_input_client)
+ : ScopedFocusNotificationObserver(root_window),
+ text_input_client_(text_input_client) {}
+
+ private:
+ // Overridden from aura::client::FocusChangeObserver:
+ void OnWindowFocused(aura::Window* gained_focus,
+ aura::Window* lost_focus) override {
+ ui::TextInputFocusManager::GetInstance()->FocusTextInputClient(
+ text_input_client_);
+ }
+
+ ui::TextInputClient* text_input_client_;
+};
+
+// 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 aura::client::ActivationChangeObserver {
public:
explicit FocusShiftingActivationObserver(aura::Window* activated_window)
: activated_window_(activated_window),
shift_focus_to_(NULL) {}
- virtual ~FocusShiftingActivationObserver() {}
+ ~FocusShiftingActivationObserver() override {}
void set_shift_focus_to(aura::Window* shift_focus_to) {
shift_focus_to_ = shift_focus_to;
private:
// Overridden from aura::client::ActivationChangeObserver:
- virtual void OnWindowActivated(aura::Window* gained_active,
- aura::Window* lost_active) OVERRIDE {
+ void OnWindowActivated(aura::Window* gained_active,
+ aura::Window* lost_active) override {
// Shift focus to a child. This should prevent the default focusing from
// occurring in FocusController::FocusWindow().
if (gained_active == activated_window_) {
}
// Overridden from BaseFocusRules:
- virtual bool SupportsChildActivation(aura::Window* window) const OVERRIDE {
+ bool SupportsChildActivation(aura::Window* window) const override {
// In FocusControllerTests, only the RootWindow has activatable children.
return window->GetRootWindow() == window;
}
- virtual bool CanActivateWindow(aura::Window* window) const OVERRIDE {
+ bool CanActivateWindow(aura::Window* window) const override {
// Restricting focus to a non-activatable child window means the activatable
// parent outside the focus restriction is activatable.
bool can_activate =
CanFocusOrActivate(window) || window->Contains(focus_restriction_);
return can_activate ? BaseFocusRules::CanActivateWindow(window) : false;
}
- virtual bool CanFocusWindow(aura::Window* window) const OVERRIDE {
+ bool CanFocusWindow(aura::Window* window) const override {
return CanFocusOrActivate(window) ?
BaseFocusRules::CanFocusWindow(window) : false;
}
- virtual aura::Window* GetActivatableWindow(
- aura::Window* window) const OVERRIDE {
+ aura::Window* GetActivatableWindow(aura::Window* window) const override {
return BaseFocusRules::GetActivatableWindow(
CanFocusOrActivate(window) ? window : focus_restriction_);
}
- virtual aura::Window* GetFocusableWindow(
- aura::Window* window) const OVERRIDE {
+ aura::Window* GetFocusableWindow(aura::Window* window) const override {
return BaseFocusRules::GetFocusableWindow(
CanFocusOrActivate(window) ? window : focus_restriction_);
}
- virtual aura::Window* GetNextActivatableWindow(
- aura::Window* ignore) const OVERRIDE {
+ aura::Window* GetNextActivatableWindow(aura::Window* ignore) const override {
aura::Window* next_activatable =
BaseFocusRules::GetNextActivatableWindow(ignore);
return CanFocusOrActivate(next_activatable) ?
FocusControllerTestBase() {}
// Overridden from aura::test::AuraTestBase:
- virtual void SetUp() OVERRIDE {
+ void SetUp() override {
wm_state_.reset(new wm::WMState);
// FocusController registers itself as an Env observer so it can catch all
// window initializations, including the root_window()'s, so we create it
aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 3,
gfx::Rect(125, 125, 50, 50), root_window());
}
- virtual void TearDown() OVERRIDE {
+ void TearDown() override {
root_window()->RemovePreTargetHandler(focus_controller_.get());
aura::test::AuraTestBase::TearDown();
test_focus_rules_ = NULL; // Owned by FocusController.
virtual void NoFocusChangeOnClickOnCaptureWindow() {}
virtual void ChangeFocusWhenNothingFocusedAndCaptured() {}
virtual void DontPassDeletedWindow() {}
+ virtual void FocusedTextInputClient() {}
private:
scoped_ptr<FocusController> focus_controller_;
}
// Overridden from FocusControllerTestBase:
- virtual void BasicFocus() OVERRIDE {
+ void BasicFocus() override {
EXPECT_EQ(NULL, GetFocusedWindow());
FocusWindowById(1);
EXPECT_EQ(1, GetFocusedWindowId());
FocusWindowById(2);
EXPECT_EQ(2, GetFocusedWindowId());
}
- virtual void BasicActivation() OVERRIDE {
+ void BasicActivation() override {
EXPECT_EQ(NULL, GetActiveWindow());
ActivateWindowById(1);
EXPECT_EQ(1, GetActiveWindowId());
DeactivateWindow(GetActiveWindow());
EXPECT_EQ(1, GetActiveWindowId());
}
- virtual void FocusEvents() OVERRIDE {
+ void FocusEvents() override {
ScopedFocusNotificationObserver root_observer(root_window());
ScopedTargetFocusNotificationObserver observer1(root_window(), 1);
ScopedTargetFocusNotificationObserver observer2(root_window(), 2);
observer1.ExpectCounts(2, 2);
observer2.ExpectCounts(1, 1);
}
- virtual void DuplicateFocusEvents() OVERRIDE {
+ void DuplicateFocusEvents() override {
// Focusing an existing focused window should not resend focus events.
ScopedFocusNotificationObserver root_observer(root_window());
ScopedTargetFocusNotificationObserver observer1(root_window(), 1);
root_observer.ExpectCounts(1, 1);
observer1.ExpectCounts(1, 1);
}
- virtual void ActivationEvents() OVERRIDE {
+ void ActivationEvents() override {
ActivateWindowById(1);
ScopedFocusNotificationObserver root_observer(root_window());
observer1.ExpectCounts(1, 1);
observer2.ExpectCounts(1, 1);
}
- virtual void ReactivationEvents() OVERRIDE {
+ void ReactivationEvents() override {
ActivateWindowById(1);
ScopedFocusNotificationObserver root_observer(root_window());
EXPECT_EQ(0, root_observer.reactivation_count());
EXPECT_EQ(root_window()->GetChildById(1),
root_observer.reactivation_actual_window());
}
- virtual void DuplicateActivationEvents() OVERRIDE {
+ void DuplicateActivationEvents() override {
// Activating an existing active window should not resend activation events.
ActivateWindowById(1);
observer1.ExpectCounts(1, 1);
observer2.ExpectCounts(1, 1);
}
- virtual void ShiftFocusWithinActiveWindow() OVERRIDE {
+ void ShiftFocusWithinActiveWindow() override {
ActivateWindowById(1);
EXPECT_EQ(1, GetActiveWindowId());
EXPECT_EQ(1, GetFocusedWindowId());
FocusWindowById(12);
EXPECT_EQ(12, GetFocusedWindowId());
}
- virtual void ShiftFocusToChildOfInactiveWindow() OVERRIDE {
+ void ShiftFocusToChildOfInactiveWindow() override {
ActivateWindowById(2);
EXPECT_EQ(2, GetActiveWindowId());
EXPECT_EQ(2, GetFocusedWindowId());
EXPECT_EQ(1, GetActiveWindowId());
EXPECT_EQ(11, GetFocusedWindowId());
}
- virtual void ShiftFocusToParentOfFocusedWindow() OVERRIDE {
+ void ShiftFocusToParentOfFocusedWindow() override {
ActivateWindowById(1);
EXPECT_EQ(1, GetFocusedWindowId());
FocusWindowById(11);
// Focus should _not_ shift to the parent of the already-focused window.
EXPECT_EQ(11, GetFocusedWindowId());
}
- virtual void FocusRulesOverride() OVERRIDE {
+ void FocusRulesOverride() override {
EXPECT_EQ(NULL, GetFocusedWindow());
FocusWindowById(11);
EXPECT_EQ(11, GetFocusedWindowId());
FocusWindowById(12);
EXPECT_EQ(12, GetFocusedWindowId());
}
- virtual void ActivationRulesOverride() OVERRIDE {
+ void ActivationRulesOverride() override {
ActivateWindowById(1);
EXPECT_EQ(1, GetActiveWindowId());
EXPECT_EQ(1, GetFocusedWindowId());
EXPECT_EQ(2, GetActiveWindowId());
EXPECT_EQ(2, GetFocusedWindowId());
}
- virtual void ShiftFocusOnActivation() OVERRIDE {
+ void ShiftFocusOnActivation() override {
// When a window is activated, by default that window is also focused.
// An ActivationChangeObserver may shift focus to another window within the
// same activatable window.
ActivateWindowById(1);
EXPECT_EQ(1, GetFocusedWindowId());
}
- virtual void ShiftFocusOnActivationDueToHide() OVERRIDE {
+ void ShiftFocusOnActivationDueToHide() override {
// Similar to ShiftFocusOnActivation except the activation change is
// triggered by hiding the active window.
ActivateWindowById(1);
client->RemoveObserver(observer.get());
}
- virtual void NoShiftActiveOnActivation() OVERRIDE {
+ void NoShiftActiveOnActivation() override {
// When a window is activated, we need to prevent any change to activation
// from being made in response to an activation change notification.
}
- virtual void NoFocusChangeOnClickOnCaptureWindow() OVERRIDE {
+ void NoFocusChangeOnClickOnCaptureWindow() override {
scoped_ptr<aura::client::DefaultCaptureClient> capture_client(
new aura::client::DefaultCaptureClient(root_window()));
// Clicking on a window which has capture should not cause a focus change
aura::Window* w2 = root_window()->GetChildById(2);
aura::client::GetCaptureClient(root_window())->SetCapture(w2);
- aura::test::EventGenerator generator(root_window(), w2);
+ ui::test::EventGenerator generator(root_window(), w2);
generator.ClickLeftButton();
EXPECT_EQ(1, GetActiveWindowId());
}
// Verifies focus change is honored while capture held.
- virtual void ChangeFocusWhenNothingFocusedAndCaptured() OVERRIDE {
+ void ChangeFocusWhenNothingFocusedAndCaptured() override {
scoped_ptr<aura::client::DefaultCaptureClient> capture_client(
new aura::client::DefaultCaptureClient(root_window()));
aura::Window* w1 = root_window()->GetChildById(1);
// Verifies if a window that loses activation or focus is deleted during
// observer notification we don't pass the deleted window to other observers.
- virtual void DontPassDeletedWindow() OVERRIDE {
+ void DontPassDeletedWindow() override {
FocusWindowById(1);
EXPECT_EQ(1, GetActiveWindowId());
}
}
+ // Verifies if the focused text input client is cleared when a window gains
+ // or loses the focus.
+ void FocusedTextInputClient() override {
+ ui::TextInputFocusManager* text_input_focus_manager =
+ ui::TextInputFocusManager::GetInstance();
+ ui::DummyTextInputClient text_input_client;
+ ui::TextInputClient* null_text_input_client = NULL;
+
+ EXPECT_EQ(null_text_input_client,
+ text_input_focus_manager->GetFocusedTextInputClient());
+
+ text_input_focus_manager->FocusTextInputClient(&text_input_client);
+ EXPECT_EQ(&text_input_client,
+ text_input_focus_manager->GetFocusedTextInputClient());
+ FocusWindowById(1);
+ // The focused text input client gets cleared when a window gets focused
+ // unless any of observers sets the focused text input client.
+ EXPECT_EQ(null_text_input_client,
+ text_input_focus_manager->GetFocusedTextInputClient());
+
+ ScopedFocusedTextInputClientChanger text_input_focus_changer(
+ root_window(), &text_input_client);
+ EXPECT_EQ(null_text_input_client,
+ text_input_focus_manager->GetFocusedTextInputClient());
+ FocusWindowById(2);
+ // |text_input_focus_changer| sets the focused text input client.
+ EXPECT_EQ(&text_input_client,
+ text_input_focus_manager->GetFocusedTextInputClient());
+
+ FocusWindow(NULL);
+ // The focused text input client gets cleared when a window loses the focus.
+ EXPECT_EQ(null_text_input_client,
+ text_input_focus_manager->GetFocusedTextInputClient());
+ }
+
private:
DISALLOW_COPY_AND_ASSIGN(FocusControllerDirectTestBase);
};
private:
// Overridden from FocusControllerTestBase:
- virtual void FocusWindowDirect(aura::Window* window) OVERRIDE {
- FocusWindow(window);
- }
- virtual void ActivateWindowDirect(aura::Window* window) OVERRIDE {
+ void FocusWindowDirect(aura::Window* window) override { FocusWindow(window); }
+ void ActivateWindowDirect(aura::Window* window) override {
ActivateWindow(window);
}
- virtual void DeactivateWindowDirect(aura::Window* window) OVERRIDE {
+ void DeactivateWindowDirect(aura::Window* window) override {
DeactivateWindow(window);
}
- virtual bool IsInputEvent() OVERRIDE { return false; }
+ bool IsInputEvent() override { return false; }
DISALLOW_COPY_AND_ASSIGN(FocusControllerApiTest);
};
public:
FocusControllerMouseEventTest() {}
+ // Tests that a handled mouse or gesture event does not trigger a window
+ // activation.
+ void IgnoreHandledEvent() {
+ EXPECT_EQ(NULL, GetActiveWindow());
+ aura::Window* w1 = root_window()->GetChildById(1);
+ SimpleEventHandler handler;
+ root_window()->PrependPreTargetHandler(&handler);
+ ui::test::EventGenerator generator(root_window(), w1);
+ generator.ClickLeftButton();
+ EXPECT_EQ(NULL, GetActiveWindow());
+ generator.GestureTapAt(w1->bounds().CenterPoint());
+ EXPECT_EQ(NULL, GetActiveWindow());
+ root_window()->RemovePreTargetHandler(&handler);
+ generator.ClickLeftButton();
+ EXPECT_EQ(1, GetActiveWindowId());
+ }
+
private:
// Overridden from FocusControllerTestBase:
- virtual void FocusWindowDirect(aura::Window* window) OVERRIDE {
- aura::test::EventGenerator generator(root_window(), window);
+ void FocusWindowDirect(aura::Window* window) override {
+ ui::test::EventGenerator generator(root_window(), window);
generator.ClickLeftButton();
}
- virtual void ActivateWindowDirect(aura::Window* window) OVERRIDE {
- aura::test::EventGenerator generator(root_window(), window);
+ void ActivateWindowDirect(aura::Window* window) override {
+ ui::test::EventGenerator generator(root_window(), window);
generator.ClickLeftButton();
}
- virtual void DeactivateWindowDirect(aura::Window* window) OVERRIDE {
+ void DeactivateWindowDirect(aura::Window* window) override {
aura::Window* next_activatable =
test_focus_rules()->GetNextActivatableWindow(window);
- aura::test::EventGenerator generator(root_window(), next_activatable);
+ ui::test::EventGenerator generator(root_window(), next_activatable);
generator.ClickLeftButton();
}
- virtual bool IsInputEvent() OVERRIDE { return true; }
+ bool IsInputEvent() override { return true; }
DISALLOW_COPY_AND_ASSIGN(FocusControllerMouseEventTest);
};
private:
// Overridden from FocusControllerTestBase:
- virtual void FocusWindowDirect(aura::Window* window) OVERRIDE {
- aura::test::EventGenerator generator(root_window(), window);
+ void FocusWindowDirect(aura::Window* window) override {
+ ui::test::EventGenerator generator(root_window(), window);
generator.GestureTapAt(window->bounds().CenterPoint());
}
- virtual void ActivateWindowDirect(aura::Window* window) OVERRIDE {
- aura::test::EventGenerator generator(root_window(), window);
+ void ActivateWindowDirect(aura::Window* window) override {
+ ui::test::EventGenerator generator(root_window(), window);
generator.GestureTapAt(window->bounds().CenterPoint());
}
- virtual void DeactivateWindowDirect(aura::Window* window) OVERRIDE {
+ void DeactivateWindowDirect(aura::Window* window) override {
aura::Window* next_activatable =
test_focus_rules()->GetNextActivatableWindow(window);
- aura::test::EventGenerator generator(root_window(), next_activatable);
+ ui::test::EventGenerator generator(root_window(), next_activatable);
generator.GestureTapAt(window->bounds().CenterPoint());
}
- virtual bool IsInputEvent() OVERRIDE { return true; }
+ bool IsInputEvent() override { return true; }
DISALLOW_COPY_AND_ASSIGN(FocusControllerGestureEventTest);
};
virtual void PostDispostionChangeExpectations() {}
// Overridden from FocusControllerTestBase:
- virtual void BasicFocus() OVERRIDE {
+ void BasicFocus() override {
EXPECT_EQ(NULL, GetFocusedWindow());
aura::Window* w211 = root_window()->GetChildById(211);
// BasicFocusRules passes focus to the parent.
EXPECT_EQ(parent_ ? 2 : 21, GetFocusedWindowId());
}
- virtual void BasicActivation() OVERRIDE {
+ void BasicActivation() override {
DCHECK(!parent_) << "Activation tests don't support parent changes.";
EXPECT_EQ(NULL, GetActiveWindow());
EXPECT_EQ(3, GetActiveWindowId());
PostDispostionChangeExpectations();
}
- virtual void FocusEvents() OVERRIDE {
+ void FocusEvents() override {
aura::Window* w211 = root_window()->GetChildById(211);
FocusWindow(w211);
root_observer.ExpectCounts(0, 1);
observer211.ExpectCounts(0, 1);
}
- virtual void ActivationEvents() OVERRIDE {
+ void ActivationEvents() override {
DCHECK(!parent_) << "Activation tests don't support parent changes.";
aura::Window* w2 = root_window()->GetChildById(2);
observer2.ExpectCounts(1, 1);
observer3.ExpectCounts(1, 1);
}
- virtual void FocusRulesOverride() OVERRIDE {
+ void FocusRulesOverride() override {
EXPECT_EQ(NULL, GetFocusedWindow());
aura::Window* w211 = root_window()->GetChildById(211);
FocusWindow(w211);
test_focus_rules()->set_focus_restriction(NULL);
}
- virtual void ActivationRulesOverride() OVERRIDE {
+ void ActivationRulesOverride() override {
DCHECK(!parent_) << "Activation tests don't support parent changes.";
aura::Window* w1 = root_window()->GetChildById(1);
: FocusControllerImplicitTestBase(parent) {}
// Overridden from FocusControllerImplicitTestBase:
- virtual void ChangeWindowDisposition(aura::Window* window) OVERRIDE {
+ void ChangeWindowDisposition(aura::Window* window) override {
GetDispositionWindow(window)->Hide();
}
: FocusControllerImplicitTestBase(parent) {}
// Overridden from FocusControllerImplicitTestBase:
- virtual void ChangeWindowDisposition(aura::Window* window) OVERRIDE {
+ void ChangeWindowDisposition(aura::Window* window) override {
delete GetDispositionWindow(window);
}
: FocusControllerImplicitTestBase(parent) {}
// Overridden from FocusControllerImplicitTestBase:
- virtual void ChangeWindowDisposition(aura::Window* window) OVERRIDE {
+ void ChangeWindowDisposition(aura::Window* window) override {
aura::Window* disposition_window = GetDispositionWindow(window);
disposition_window->parent()->RemoveChild(disposition_window);
window_owner_.reset(disposition_window);
}
- virtual void TearDown() OVERRIDE {
+ void TearDown() override {
window_owner_.reset();
FocusControllerImplicitTestBase::TearDown();
}
// See description above DontPassDeletedWindow() for details.
FOCUS_CONTROLLER_TEST(FocusControllerApiTest, DontPassDeletedWindow);
+// - Verifies that the focused text input client is cleard when the window focus
+// changes.
+ALL_FOCUS_TESTS(FocusedTextInputClient);
+
+// If a mouse event was handled, it should not activate a window.
+FOCUS_CONTROLLER_TEST(FocusControllerMouseEventTest, IgnoreHandledEvent);
+
} // namespace wm
projects / platform / framework / web / crosswalk.git / blobdiff