summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--ui/aura/root_window.cc47
-rw-r--r--ui/aura/root_window.h11
-rw-r--r--ui/base/events/event.cc11
-rw-r--r--ui/base/events/event.h9
-rw-r--r--ui/base/events/event_dispatcher.cc5
-rw-r--r--ui/base/events/event_dispatcher.h49
-rw-r--r--ui/base/events/event_dispatcher_unittest.cc43
-rw-r--r--ui/base/events/event_handler.cc27
-rw-r--r--ui/base/events/event_handler.h2
-rw-r--r--ui/views/corewm/activation_change_shim.cc4
-rw-r--r--ui/views/corewm/activation_change_shim.h2
-rw-r--r--ui/views/corewm/focus_change_shim.cc4
-rw-r--r--ui/views/corewm/focus_change_shim.h2
-rw-r--r--ui/views/corewm/focus_controller.cc3
-rw-r--r--ui/views/corewm/focus_controller_unittest.cc7
15 files changed, 125 insertions, 101 deletions
diff --git a/ui/aura/root_window.cc b/ui/aura/root_window.cc
index dbcce02..33347cb 100644
--- a/ui/aura/root_window.cc
+++ b/ui/aura/root_window.cc
@@ -261,8 +261,8 @@ bool RootWindow::DispatchGestureEvent(ui::GestureEvent* event) {
if (target) {
event->ConvertLocationToTarget(static_cast<Window*>(this), target);
- ui::EventResult status = ProcessGestureEvent(target, event);
- return status != ui::ER_UNHANDLED;
+ ProcessGestureEvent(target, event);
+ return event->handled();
}
return false;
@@ -615,37 +615,35 @@ void RootWindow::HandleMouseMoved(const ui::MouseEvent& event, Window* target) {
}
}
-bool RootWindow::ProcessMouseEvent(Window* target, ui::MouseEvent* event) {
+void RootWindow::ProcessMouseEvent(Window* target, ui::MouseEvent* event) {
base::AutoReset<Window*> reset(&event_dispatch_target_, target);
- return ProcessEvent(target, event) != ui::ER_UNHANDLED;
+ ProcessEvent(target, event);
}
-bool RootWindow::ProcessKeyEvent(Window* target, ui::KeyEvent* event) {
+void RootWindow::ProcessKeyEvent(Window* target, ui::KeyEvent* event) {
if (!target)
target = this;
base::AutoReset<Window*> reset(&event_dispatch_target_, target);
- return ProcessEvent(target, event) != ui::ER_UNHANDLED;
+ ProcessEvent(target, event);
}
-bool RootWindow::ProcessScrollEvent(Window* target, ui::ScrollEvent* event) {
+void RootWindow::ProcessScrollEvent(Window* target, ui::ScrollEvent* event) {
base::AutoReset<Window*> reset(&event_dispatch_target_, target);
- return ProcessEvent(target, event) != ui::ER_UNHANDLED;
+ ProcessEvent(target, event);
}
-ui::EventResult RootWindow::ProcessTouchEvent(Window* target,
- ui::TouchEvent* event) {
+void RootWindow::ProcessTouchEvent(Window* target, ui::TouchEvent* event) {
if (!target)
target = this;
base::AutoReset<Window*> reset(&event_dispatch_target_, target);
- return static_cast<ui::EventResult>(ProcessEvent(target, event));
+ ProcessEvent(target, event);
}
-ui::EventResult RootWindow::ProcessGestureEvent(Window* target,
- ui::GestureEvent* event) {
+void RootWindow::ProcessGestureEvent(Window* target, ui::GestureEvent* event) {
if (!target)
target = this;
base::AutoReset<Window*> reset(&event_dispatch_target_, target);
- return static_cast<ui::EventResult>(ProcessEvent(target, event));
+ ProcessEvent(target, event);
}
bool RootWindow::ProcessGestures(ui::GestureRecognizer::Gestures* gestures) {
@@ -788,7 +786,8 @@ bool RootWindow::OnHostKeyEvent(ui::KeyEvent* event) {
client::GetFocusClient(this)->FocusWindow(NULL, NULL);
return false;
}
- return ProcessKeyEvent(focused_window, event);
+ ProcessKeyEvent(focused_window, event);
+ return event->handled();
}
bool RootWindow::OnHostMouseEvent(ui::MouseEvent* event) {
@@ -831,7 +830,8 @@ bool RootWindow::OnHostScrollEvent(ui::ScrollEvent* event) {
flags |= ui::EF_IS_NON_CLIENT;
event->set_flags(flags);
event->ConvertLocationToTarget(static_cast<Window*>(this), target);
- return ProcessScrollEvent(target, event);
+ ProcessScrollEvent(target, event);
+ return event->handled();
}
return false;
}
@@ -856,7 +856,6 @@ bool RootWindow::OnHostTouchEvent(ui::TouchEvent* event) {
}
TransformEventForDeviceScaleFactor(event);
bool handled = false;
- ui::EventResult result = ui::ER_UNHANDLED;
Window* target = client::GetCaptureWindow(this);
if (!target) {
target = ConsumerToWindow(
@@ -867,11 +866,13 @@ bool RootWindow::OnHostTouchEvent(ui::TouchEvent* event) {
}
}
+ ui::EventResult result = ui::ER_UNHANDLED;
if (!target && !bounds().Contains(event->location())) {
// If the initial touch is outside the root window, target the root.
target = this;
- result = ProcessTouchEvent(target, event);
- CHECK_EQ(ui::ER_UNHANDLED, result);
+ ProcessTouchEvent(target, event);
+ CHECK_EQ(ui::ER_UNHANDLED, event->result());
+ result = event->result();
} else {
// We only come here when the first contact was within the root window.
if (!target) {
@@ -882,8 +883,9 @@ bool RootWindow::OnHostTouchEvent(ui::TouchEvent* event) {
ui::TouchEvent translated_event(
*event, static_cast<Window*>(this), target);
- result = ProcessTouchEvent(target, &translated_event);
- handled = result != ui::ER_UNHANDLED;
+ ProcessTouchEvent(target, &translated_event);
+ handled = translated_event.handled();
+ result = translated_event.result();
}
// Get the list of GestureEvents from GestureRecognizer.
@@ -991,7 +993,8 @@ bool RootWindow::DispatchMouseEventToTarget(ui::MouseEvent* event,
event->ConvertLocationToTarget(static_cast<Window*>(this), target);
if (IsNonClientLocation(target, event->location()))
event->set_flags(event->flags() | ui::EF_IS_NON_CLIENT);
- return ProcessMouseEvent(target, event);
+ ProcessMouseEvent(target, event);
+ return event->handled();
}
return false;
}
diff --git a/ui/aura/root_window.h b/ui/aura/root_window.h
index 67498cf..3770d9e 100644
--- a/ui/aura/root_window.h
+++ b/ui/aura/root_window.h
@@ -280,12 +280,11 @@ class AURA_EXPORT RootWindow : public ui::CompositorDelegate,
// sending exited and entered events as its value changes.
void HandleMouseMoved(const ui::MouseEvent& event, Window* target);
- bool ProcessMouseEvent(Window* target, ui::MouseEvent* event);
- bool ProcessKeyEvent(Window* target, ui::KeyEvent* event);
- bool ProcessScrollEvent(Window* target, ui::ScrollEvent* event);
- ui::EventResult ProcessTouchEvent(Window* target, ui::TouchEvent* event);
- ui::EventResult ProcessGestureEvent(Window* target,
- ui::GestureEvent* event);
+ void ProcessMouseEvent(Window* target, ui::MouseEvent* event);
+ void ProcessKeyEvent(Window* target, ui::KeyEvent* event);
+ void ProcessScrollEvent(Window* target, ui::ScrollEvent* event);
+ void ProcessTouchEvent(Window* target, ui::TouchEvent* event);
+ void ProcessGestureEvent(Window* target, ui::GestureEvent* event);
bool ProcessGestures(ui::GestureRecognizer::Gestures* gestures);
// Called when a Window is attached or detached from the RootWindow.
diff --git a/ui/base/events/event.cc b/ui/base/events/event.cc
index 4658e46..a489eae 100644
--- a/ui/base/events/event.cc
+++ b/ui/base/events/event.cc
@@ -71,6 +71,17 @@ bool Event::HasNativeEvent() const {
return !!std::memcmp(&native_event_, &null_event, sizeof(null_event));
}
+void Event::StopPropagation() {
+ CHECK(phase_ != EP_PREDISPATCH && phase_ != EP_POSTDISPATCH);
+ result_ = static_cast<ui::EventResult>(result_ | ER_CONSUMED);
+ CHECK(stopped_propagation());
+}
+
+void Event::SetHandled() {
+ CHECK(phase_ != EP_PREDISPATCH && phase_ != EP_POSTDISPATCH);
+ result_ = static_cast<ui::EventResult>(result_ | ER_HANDLED);
+}
+
Event::Event(EventType type, base::TimeDelta time_stamp, int flags)
: type_(type),
time_stamp_(time_stamp),
diff --git a/ui/base/events/event.h b/ui/base/events/event.h
index 06687be..2ca865b 100644
--- a/ui/base/events/event.h
+++ b/ui/base/events/event.h
@@ -161,6 +161,15 @@ class UI_EXPORT Event {
// Returns true if the event has a valid |native_event_|.
bool HasNativeEvent() const;
+ // Immediately stops the propagation of the event. This must be called only
+ // from an EventHandler during an event-dispatch. Any event handler that may
+ // be in the list will not receive the event after this is called.
+ void StopPropagation();
+ bool stopped_propagation() const { return !!(result_ & ui::ER_CONSUMED); }
+
+ void SetHandled();
+ bool handled() const { return result_ != ui::ER_UNHANDLED; }
+
protected:
Event(EventType type, base::TimeDelta time_stamp, int flags);
Event(const base::NativeEvent& native_event, EventType type, int flags);
diff --git a/ui/base/events/event_dispatcher.cc b/ui/base/events/event_dispatcher.cc
index 188523d..1be0421 100644
--- a/ui/base/events/event_dispatcher.cc
+++ b/ui/base/events/event_dispatcher.cc
@@ -19,9 +19,9 @@ EventDispatcher::~EventDispatcher() {
////////////////////////////////////////////////////////////////////////////////
// EventDispatcher, private:
-EventResult EventDispatcher::DispatchEventToSingleHandler(EventHandler* handler,
+void EventDispatcher::DispatchEventToSingleHandler(EventHandler* handler,
Event* event) {
- return handler->OnEvent(event);
+ handler->OnEvent(event);
}
////////////////////////////////////////////////////////////////////////////////
@@ -29,6 +29,7 @@ EventResult EventDispatcher::DispatchEventToSingleHandler(EventHandler* handler,
EventDispatcher::ScopedDispatchHelper::ScopedDispatchHelper(Event* event)
: Event::DispatcherApi(event) {
+ set_result(ui::ER_UNHANDLED);
}
EventDispatcher::ScopedDispatchHelper::~ScopedDispatchHelper() {
diff --git a/ui/base/events/event_dispatcher.h b/ui/base/events/event_dispatcher.h
index 4177848..e179c67 100644
--- a/ui/base/events/event_dispatcher.h
+++ b/ui/base/events/event_dispatcher.h
@@ -24,9 +24,9 @@ class UI_EXPORT EventDispatcher {
virtual bool CanDispatchToTarget(EventTarget* target) = 0;
template<class T>
- int ProcessEvent(EventTarget* target, T* event) {
+ void ProcessEvent(EventTarget* target, T* event) {
if (!target || !target->CanAcceptEvents())
- return ER_UNHANDLED;
+ return;
ScopedDispatchHelper dispatch_helper(event);
dispatch_helper.set_target(target);
@@ -34,9 +34,9 @@ class UI_EXPORT EventDispatcher {
EventHandlerList list;
target->GetPreTargetHandlers(&list);
dispatch_helper.set_phase(EP_PRETARGET);
- int result = DispatchEventToEventHandlers(list, event);
- if (result & ER_CONSUMED)
- return result;
+ DispatchEventToEventHandlers(list, event);
+ if (event->stopped_propagation())
+ return;
// If the event hasn't been consumed, trigger the default handler. Note that
// even if the event has already been handled (i.e. return result has
@@ -45,20 +45,18 @@ class UI_EXPORT EventDispatcher {
// abstraction.
if (CanDispatchToTarget(target)) {
dispatch_helper.set_phase(EP_TARGET);
- result |= DispatchEvent(target, event);
- dispatch_helper.set_result(event->result() | result);
- if (result & ER_CONSUMED)
- return result;
+ DispatchEvent(target, event);
+ if (event->stopped_propagation())
+ return;
}
if (!CanDispatchToTarget(target))
- return result;
+ return;
list.clear();
target->GetPostTargetHandlers(&list);
dispatch_helper.set_phase(EP_POSTTARGET);
- result |= DispatchEventToEventHandlers(list, event);
- return result;
+ DispatchEventToEventHandlers(list, event);
}
const Event* current_event() const { return current_event_; }
@@ -75,27 +73,25 @@ class UI_EXPORT EventDispatcher {
};
template<class T>
- int DispatchEventToEventHandlers(EventHandlerList& list, T* event) {
- int result = ER_UNHANDLED;
- Event::DispatcherApi dispatch_helper(event);
+ void DispatchEventToEventHandlers(EventHandlerList& list, T* event) {
for (EventHandlerList::const_iterator it = list.begin(),
end = list.end(); it != end; ++it) {
- result |= DispatchEvent((*it), event);
- dispatch_helper.set_result(event->result() | result);
- if (result & ER_CONSUMED)
- return result;
+ DispatchEvent((*it), event);
+ if (event->stopped_propagation())
+ return;
}
- return result;
}
// Dispatches an event, and makes sure it sets ER_CONSUMED on the
// event-handling result if the dispatcher itself has been destroyed during
// dispatching the event to the event handler.
template<class T>
- int DispatchEvent(EventHandler* handler, T* event) {
+ void DispatchEvent(EventHandler* handler, T* event) {
// If the target has been invalidated or deleted, don't dispatch the event.
- if (!CanDispatchToTarget(event->target()))
- return ui::ER_CONSUMED;
+ if (!CanDispatchToTarget(event->target())) {
+ event->StopPropagation();
+ return;
+ }
bool destroyed = false;
set_on_destroy_ = &destroyed;
@@ -104,17 +100,16 @@ class UI_EXPORT EventDispatcher {
// cause invalid memory-write when AutoReset tries to restore the value.
Event* old_event = current_event_;
current_event_ = event;
- int result = DispatchEventToSingleHandler(handler, event);
+ DispatchEventToSingleHandler(handler, event);
if (destroyed) {
- result |= ui::ER_CONSUMED;
+ event->StopPropagation();
} else {
current_event_ = old_event;
set_on_destroy_ = NULL;
}
- return result;
}
- EventResult DispatchEventToSingleHandler(EventHandler* handler, Event* event);
+ void DispatchEventToSingleHandler(EventHandler* handler, Event* event);
// This is used to track whether the dispatcher has been destroyed in the
// middle of dispatching an event.
diff --git a/ui/base/events/event_dispatcher_unittest.cc b/ui/base/events/event_dispatcher_unittest.cc
index 89285e4..00eca7a 100644
--- a/ui/base/events/event_dispatcher_unittest.cc
+++ b/ui/base/events/event_dispatcher_unittest.cc
@@ -202,9 +202,9 @@ TEST(EventDispatcherTest, EventDispatchOrder) {
MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4),
gfx::Point(3, 4), 0);
Event::DispatcherApi event_mod(&mouse);
- int result = dispatcher.ProcessEvent(&child, &mouse);
- EXPECT_FALSE(result & ER_CONSUMED);
- EXPECT_FALSE(result & ER_HANDLED);
+ dispatcher.ProcessEvent(&child, &mouse);
+ EXPECT_FALSE(mouse.stopped_propagation());
+ EXPECT_FALSE(mouse.handled());
int expected[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
EXPECT_EQ(
@@ -216,11 +216,10 @@ TEST(EventDispatcherTest, EventDispatchOrder) {
event_mod.set_result(ER_UNHANDLED);
h1.set_event_result(ER_HANDLED);
- result = dispatcher.ProcessEvent(&child, &mouse);
- EXPECT_EQ(result, mouse.result());
+ dispatcher.ProcessEvent(&child, &mouse);
EXPECT_EQ(EP_POSTDISPATCH, mouse.phase());
- EXPECT_FALSE(result & ER_CONSUMED);
- EXPECT_TRUE(result & ER_HANDLED);
+ EXPECT_FALSE(mouse.stopped_propagation());
+ EXPECT_TRUE(mouse.handled());
EXPECT_EQ(
std::vector<int>(expected, expected + sizeof(expected) / sizeof(int)),
child.handler_list());
@@ -231,11 +230,10 @@ TEST(EventDispatcherTest, EventDispatchOrder) {
int nexpected[] = { 1, 2, 3, 4, 5 };
h5.set_event_result(ER_CONSUMED);
- result = dispatcher.ProcessEvent(&child, &mouse);
- EXPECT_EQ(result, mouse.result());
+ dispatcher.ProcessEvent(&child, &mouse);
EXPECT_EQ(EP_POSTDISPATCH, mouse.phase());
- EXPECT_TRUE(result & ER_CONSUMED);
- EXPECT_TRUE(result & ER_HANDLED);
+ EXPECT_TRUE(mouse.stopped_propagation());
+ EXPECT_TRUE(mouse.handled());
EXPECT_EQ(
std::vector<int>(nexpected, nexpected + sizeof(nexpected) / sizeof(int)),
child.handler_list());
@@ -246,11 +244,10 @@ TEST(EventDispatcherTest, EventDispatchOrder) {
int exp[] = { 1 };
h1.set_event_result(ER_CONSUMED);
- result = dispatcher.ProcessEvent(&child, &mouse);
+ dispatcher.ProcessEvent(&child, &mouse);
EXPECT_EQ(EP_POSTDISPATCH, mouse.phase());
- EXPECT_EQ(result, mouse.result());
- EXPECT_TRUE(result & ER_CONSUMED);
- EXPECT_FALSE(result & ER_HANDLED);
+ EXPECT_TRUE(mouse.stopped_propagation());
+ EXPECT_TRUE(mouse.handled());
EXPECT_EQ(
std::vector<int>(exp, exp + sizeof(exp) / sizeof(int)),
child.handler_list());
@@ -271,8 +268,8 @@ TEST(EventDispatcherTest, EventDispatchPhase) {
MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4),
gfx::Point(3, 4), 0);
Event::DispatcherApi event_mod(&mouse);
- int result = dispatcher.ProcessEvent(&target, &mouse);
- EXPECT_EQ(ER_UNHANDLED, result);
+ dispatcher.ProcessEvent(&target, &mouse);
+ EXPECT_EQ(ER_UNHANDLED, mouse.result());
int handlers[] = { 11, 11 };
EXPECT_EQ(
@@ -303,8 +300,8 @@ TEST(EventDispatcherTest, EventDispatcherDestroyTarget) {
MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4),
gfx::Point(3, 4), 0);
Event::DispatcherApi event_mod(&mouse);
- int result = dispatcher->ProcessEvent(&target, &mouse);
- EXPECT_EQ(ER_CONSUMED, result);
+ dispatcher->ProcessEvent(&target, &mouse);
+ EXPECT_EQ(ER_CONSUMED, mouse.result());
EXPECT_EQ(2U, target.handler_list().size());
EXPECT_EQ(1, target.handler_list()[0]);
EXPECT_EQ(5, target.handler_list()[1]);
@@ -330,8 +327,8 @@ TEST(EventDispatcherTest, EventDispatcherDestroyTarget) {
MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4),
gfx::Point(3, 4), 0);
Event::DispatcherApi event_mod(&mouse);
- int result = dispatcher->ProcessEvent(&target, &mouse);
- EXPECT_EQ(ER_CONSUMED, result);
+ dispatcher->ProcessEvent(&target, &mouse);
+ EXPECT_EQ(ER_CONSUMED, mouse.result());
EXPECT_EQ(2U, target.handler_list().size());
EXPECT_EQ(1, target.handler_list()[0]);
EXPECT_EQ(5, target.handler_list()[1]);
@@ -357,9 +354,9 @@ TEST(EventDispatcherTest, EventDispatcherInvalidateTarget) {
h3.set_expect_pre_target(false);
MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4), 0);
- int result = dispatcher.ProcessEvent(&target, &mouse);
+ dispatcher.ProcessEvent(&target, &mouse);
EXPECT_FALSE(target.valid());
- EXPECT_EQ(ER_CONSUMED, result);
+ EXPECT_TRUE(mouse.stopped_propagation());
EXPECT_EQ(2U, target.handler_list().size());
EXPECT_EQ(1, target.handler_list()[0]);
EXPECT_EQ(2, target.handler_list()[1]);
diff --git a/ui/base/events/event_handler.cc b/ui/base/events/event_handler.cc
index ea9048e..d6fcea7 100644
--- a/ui/base/events/event_handler.cc
+++ b/ui/base/events/event_handler.cc
@@ -14,18 +14,23 @@ EventHandler::EventHandler() {
EventHandler::~EventHandler() {
}
-EventResult EventHandler::OnEvent(Event* event) {
+void EventHandler::OnEvent(Event* event) {
+ ui::EventResult result = ui::ER_UNHANDLED;
if (event->IsKeyEvent())
- return OnKeyEvent(static_cast<KeyEvent*>(event));
- if (event->IsMouseEvent())
- return OnMouseEvent(static_cast<MouseEvent*>(event));
- if (event->IsScrollEvent())
- return OnScrollEvent(static_cast<ScrollEvent*>(event));
- if (event->IsTouchEvent())
- return OnTouchEvent(static_cast<TouchEvent*>(event));
- if (event->IsGestureEvent())
- return OnGestureEvent(static_cast<GestureEvent*>(event));
- return ui::ER_UNHANDLED;
+ result = OnKeyEvent(static_cast<KeyEvent*>(event));
+ else if (event->IsMouseEvent())
+ result = OnMouseEvent(static_cast<MouseEvent*>(event));
+ else if (event->IsScrollEvent())
+ result = OnScrollEvent(static_cast<ScrollEvent*>(event));
+ else if (event->IsTouchEvent())
+ result = OnTouchEvent(static_cast<TouchEvent*>(event));
+ else if (event->IsGestureEvent())
+ result = OnGestureEvent(static_cast<GestureEvent*>(event));
+
+ if (result & ui::ER_CONSUMED)
+ event->StopPropagation();
+ if (result & ui::ER_HANDLED)
+ event->SetHandled();
}
EventResult EventHandler::OnKeyEvent(KeyEvent* event) {
diff --git a/ui/base/events/event_handler.h b/ui/base/events/event_handler.h
index 5f06521..405c65d 100644
--- a/ui/base/events/event_handler.h
+++ b/ui/base/events/event_handler.h
@@ -32,7 +32,7 @@ class UI_EXPORT EventHandler {
// to one of the event-specific callbacks (OnKeyEvent, OnMouseEvent etc.). If
// this is overridden, then normally, the override should chain into the
// default implementation for un-handled events.
- virtual EventResult OnEvent(Event* event);
+ virtual void OnEvent(Event* event);
virtual EventResult OnKeyEvent(KeyEvent* event);
diff --git a/ui/views/corewm/activation_change_shim.cc b/ui/views/corewm/activation_change_shim.cc
index 6184606..f182291 100644
--- a/ui/views/corewm/activation_change_shim.cc
+++ b/ui/views/corewm/activation_change_shim.cc
@@ -34,14 +34,14 @@ void ActivationChangeShim::OnWindowActivated(aura::Window* active,
aura::Window* old_active) {
}
-ui::EventResult ActivationChangeShim::OnEvent(ui::Event* event) {
+void ActivationChangeShim::OnEvent(ui::Event* event) {
if (event->type() == FocusChangeEvent::activation_changed_event_type()) {
DCHECK(UseFocusController());
FocusChangeEvent* fce = static_cast<FocusChangeEvent*>(event);
OnWindowActivated(static_cast<aura::Window*>(event->target()),
static_cast<aura::Window*>(fce->last_focus()));
}
- return EventHandler::OnEvent(event);
+ EventHandler::OnEvent(event);
}
} // namespace corewm
diff --git a/ui/views/corewm/activation_change_shim.h b/ui/views/corewm/activation_change_shim.h
index 75c8edd..77bed97 100644
--- a/ui/views/corewm/activation_change_shim.h
+++ b/ui/views/corewm/activation_change_shim.h
@@ -34,7 +34,7 @@ class VIEWS_EXPORT ActivationChangeShim
aura::Window* old_active) OVERRIDE;
// Overridden from ui::EventHandler:
- virtual ui::EventResult OnEvent(ui::Event* event) OVERRIDE;
+ virtual void OnEvent(ui::Event* event) OVERRIDE;
private:
ui::EventTarget* target_;
diff --git a/ui/views/corewm/focus_change_shim.cc b/ui/views/corewm/focus_change_shim.cc
index 4e0f6a4..0ad1070 100644
--- a/ui/views/corewm/focus_change_shim.cc
+++ b/ui/views/corewm/focus_change_shim.cc
@@ -33,12 +33,12 @@ FocusChangeShim::~FocusChangeShim() {
void FocusChangeShim::OnWindowFocused(aura::Window* window) {
}
-ui::EventResult FocusChangeShim::OnEvent(ui::Event* event) {
+void FocusChangeShim::OnEvent(ui::Event* event) {
if (event->type() == FocusChangeEvent::focus_changed_event_type()) {
DCHECK(UseFocusController());
OnWindowFocused(static_cast<aura::Window*>(event->target()));
}
- return EventHandler::OnEvent(event);
+ EventHandler::OnEvent(event);
}
} // namespace corewm
diff --git a/ui/views/corewm/focus_change_shim.h b/ui/views/corewm/focus_change_shim.h
index 1e9b091..57355af 100644
--- a/ui/views/corewm/focus_change_shim.h
+++ b/ui/views/corewm/focus_change_shim.h
@@ -33,7 +33,7 @@ class VIEWS_EXPORT FocusChangeShim
virtual void OnWindowFocused(aura::Window* window) OVERRIDE;
// Overridden from ui::EventHandler:
- virtual ui::EventResult OnEvent(ui::Event* event) OVERRIDE;
+ virtual void OnEvent(ui::Event* event) OVERRIDE;
private:
ui::EventTarget* target_;
diff --git a/ui/views/corewm/focus_controller.cc b/ui/views/corewm/focus_controller.cc
index 826a65a..2d89a34 100644
--- a/ui/views/corewm/focus_controller.cc
+++ b/ui/views/corewm/focus_controller.cc
@@ -40,7 +40,8 @@ void DispatchEventsAndUpdateState(ui::EventDispatcher* dispatcher,
{
base::AutoReset<ui::EventTarget*> reset(event_dispatch_target, *state);
FocusChangeEvent changing_event(changing_event_type);
- result = dispatcher->ProcessEvent(*state, &changing_event);
+ dispatcher->ProcessEvent(*state, &changing_event);
+ result = changing_event.result();
}
DCHECK(!(result & ui::ER_CONSUMED))
<< "Focus and Activation events cannot be consumed";
diff --git a/ui/views/corewm/focus_controller_unittest.cc b/ui/views/corewm/focus_controller_unittest.cc
index 6fb0751..ee4b834 100644
--- a/ui/views/corewm/focus_controller_unittest.cc
+++ b/ui/views/corewm/focus_controller_unittest.cc
@@ -42,9 +42,12 @@ class FocusEventsTestHandler : public ui::EventHandler,
private:
// Overridden from ui::EventHandler:
- virtual ui::EventResult OnEvent(ui::Event* event) OVERRIDE {
+ virtual void OnEvent(ui::Event* event) OVERRIDE {
event_counts_[event->type()] += 1;
- return result_;
+ if (result_ & ui::ER_CONSUMED)
+ event->StopPropagation();
+ else if (result_ & ui::ER_HANDLED)
+ event->SetHandled();
}
// Overridden from aura::WindowObserver:
generated by cgit v1.1 at 2025-02-14 05:08:52 +0000