diff --git a/ash/wm/toplevel_window_event_handler.cc b/ash/wm/toplevel_window_event_handler.cc
index 0d0349de07d34..8206a33cb67e1 100644
--- a/ash/wm/toplevel_window_event_handler.cc
+++ b/ash/wm/toplevel_window_event_handler.cc
@@ -147,9 +147,9 @@ ui::EventResult ToplevelWindowEventHandler::OnScrollEvent(
return ui::ER_UNHANDLED;
}
-ui::TouchStatus ToplevelWindowEventHandler::OnTouchEvent(
+ui::EventResult ToplevelWindowEventHandler::OnTouchEvent(
ui::TouchEvent* event) {
- return ui::TOUCH_STATUS_UNKNOWN;
+ return ui::ER_UNHANDLED;
}
ui::EventResult ToplevelWindowEventHandler::OnGestureEvent(
diff --git a/ash/wm/toplevel_window_event_handler.h b/ash/wm/toplevel_window_event_handler.h
index 48deaea21bfd0..295ba8c1ddbea 100644
--- a/ash/wm/toplevel_window_event_handler.h
+++ b/ash/wm/toplevel_window_event_handler.h
@@ -41,7 +41,7 @@ class ASH_EXPORT ToplevelWindowEventHandler
virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
// Overridden form aura::client::WindowMoveClient:
diff --git a/ash/wm/window_modality_controller_unittest.cc b/ash/wm/window_modality_controller_unittest.cc
index d749bd6e4bbb6..f6f4271d24542 100644
--- a/ash/wm/window_modality_controller_unittest.cc
+++ b/ash/wm/window_modality_controller_unittest.cc
@@ -294,7 +294,7 @@ class TouchTrackerWindowDelegate : public aura::test::TestWindowDelegate {
private:
// Overridden from aura::test::TestWindowDelegate.
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
received_touch_ = true;
return aura::test::TestWindowDelegate::OnTouchEvent(event);
}
diff --git a/content/browser/renderer_host/render_widget_host_view_aura.cc b/content/browser/renderer_host/render_widget_host_view_aura.cc
index 8d4124abd4fb9..b5905bc84b14a 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura.cc
+++ b/content/browser/renderer_host/render_widget_host_view_aura.cc
@@ -111,15 +111,6 @@ BOOL CALLBACK ShowWindowsCallback(HWND window, LPARAM param) {
}
#endif
-ui::TouchStatus DecideTouchStatus(const WebKit::WebTouchEvent& event,
- WebKit::WebTouchPoint* point) {
- if (event.type == WebKit::WebInputEvent::TouchEnd &&
- event.touchesLength == 0)
- return ui::TOUCH_STATUS_QUEUED_END;
-
- return ui::TOUCH_STATUS_QUEUED;
-}
-
void UpdateWebTouchEventAfterDispatch(WebKit::WebTouchEvent* event,
WebKit::WebTouchPoint* point) {
if (point->state != WebKit::WebTouchPoint::StateReleased)
@@ -1546,8 +1537,7 @@ ui::EventResult RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) {
return ui::ER_HANDLED;
}
-ui::TouchStatus RenderWidgetHostViewAura::OnTouchEvent(
- ui::TouchEvent* event) {
+ui::EventResult RenderWidgetHostViewAura::OnTouchEvent(ui::TouchEvent* event) {
TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnTouchEvent");
// Update the touch event first.
WebKit::WebTouchPoint* point = UpdateWebTouchEvent(event,
@@ -1558,10 +1548,10 @@ ui::TouchStatus RenderWidgetHostViewAura::OnTouchEvent(
if (point && host_->has_touch_handler()) {
host_->ForwardTouchEvent(touch_event_);
UpdateWebTouchEventAfterDispatch(&touch_event_, point);
- return DecideTouchStatus(touch_event_, point);
+ return ui::ER_ASYNC;
}
- return ui::TOUCH_STATUS_UNKNOWN;
+ return ui::ER_UNHANDLED;
}
ui::EventResult RenderWidgetHostViewAura::OnGestureEvent(
diff --git a/content/browser/renderer_host/render_widget_host_view_aura.h b/content/browser/renderer_host/render_widget_host_view_aura.h
index 47533cd64a002..022236b9846c1 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura.h
+++ b/content/browser/renderer_host/render_widget_host_view_aura.h
@@ -187,7 +187,7 @@ class RenderWidgetHostViewAura
// Overridden from ui::EventHandler:
virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
// Overridden from aura::client::ActivationDelegate:
diff --git a/content/browser/renderer_host/render_widget_host_view_win.cc b/content/browser/renderer_host/render_widget_host_view_win.cc
index 1d8dab36608a0..42d60cf67fad8 100644
--- a/content/browser/renderer_host/render_widget_host_view_win.cc
+++ b/content/browser/renderer_host/render_widget_host_view_win.cc
@@ -2246,7 +2246,7 @@ LRESULT RenderWidgetHostViewWin::OnTouchEvent(UINT message, WPARAM wparam,
scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(
TouchEventFromWebTouchPoint(touch_event.touches[i], timestamp),
- ui::TOUCH_STATUS_UNKNOWN, this));
+ ui::ER_UNHANDLED, this));
ProcessGestures(gestures.get());
}
}
diff --git a/content/browser/web_contents/web_contents_view_aura.cc b/content/browser/web_contents/web_contents_view_aura.cc
index ddb410fc1ff5a..28819f4cb86c3 100644
--- a/content/browser/web_contents/web_contents_view_aura.cc
+++ b/content/browser/web_contents/web_contents_view_aura.cc
@@ -594,8 +594,8 @@ ui::EventResult WebContentsViewAura::OnMouseEvent(ui::MouseEvent* event) {
return ui::ER_UNHANDLED;
}
-ui::TouchStatus WebContentsViewAura::OnTouchEvent(ui::TouchEvent* event) {
- return ui::TOUCH_STATUS_UNKNOWN;
+ui::EventResult WebContentsViewAura::OnTouchEvent(ui::TouchEvent* event) {
+ return ui::ER_UNHANDLED;
}
ui::EventResult WebContentsViewAura::OnGestureEvent(
diff --git a/content/browser/web_contents/web_contents_view_aura.h b/content/browser/web_contents/web_contents_view_aura.h
index 93a17dbd23e5b..260d37eb08fdf 100644
--- a/content/browser/web_contents/web_contents_view_aura.h
+++ b/content/browser/web_contents/web_contents_view_aura.h
@@ -114,7 +114,7 @@ class CONTENT_EXPORT WebContentsViewAura
// Overridden from ui::EventHandler:
virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
// Overridden from aura::client::DragDropDelegate:
diff --git a/ui/aura/demo/demo_main.cc b/ui/aura/demo/demo_main.cc
index b3475ed9fe1df..6a6d43b5b6bd3 100644
--- a/ui/aura/demo/demo_main.cc
+++ b/ui/aura/demo/demo_main.cc
@@ -77,8 +77,8 @@ class DemoWindowDelegate : public aura::WindowDelegate {
virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
return ui::ER_HANDLED;
}
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
- return ui::TOUCH_STATUS_END;
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
+ return ui::ER_UNHANDLED;
}
virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
return ui::ER_UNHANDLED;
diff --git a/ui/aura/event_filter.cc b/ui/aura/event_filter.cc
index d7f4719b46859..d8c4f287096a2 100644
--- a/ui/aura/event_filter.cc
+++ b/ui/aura/event_filter.cc
@@ -41,8 +41,10 @@ ui::EventResult EventFilter::OnScrollEvent(ui::ScrollEvent* event) {
return ui::ER_UNHANDLED;
}
-ui::TouchStatus EventFilter::OnTouchEvent(ui::TouchEvent* event) {
- return PreHandleTouchEvent(static_cast<Window*>(event->target()), event);
+ui::EventResult EventFilter::OnTouchEvent(ui::TouchEvent* event) {
+ ui::TouchStatus status = PreHandleTouchEvent(
+ static_cast<Window*>(event->target()), event);
+ return ui::EventResultFromTouchStatus(status);
}
ui::EventResult EventFilter::OnGestureEvent(ui::GestureEvent* event) {
diff --git a/ui/aura/event_filter.h b/ui/aura/event_filter.h
index f6b0378e7e831..7af680b8cc051 100644
--- a/ui/aura/event_filter.h
+++ b/ui/aura/event_filter.h
@@ -66,7 +66,7 @@ class AURA_EXPORT EventFilter : public ui::EventHandler {
virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
virtual ui::EventResult OnGestureEvent(ui::GestureEvent* e) OVERRIDE;
};
diff --git a/ui/aura/event_filter_unittest.cc b/ui/aura/event_filter_unittest.cc
index 616f80323042b..010fbfbbdb7dc 100644
--- a/ui/aura/event_filter_unittest.cc
+++ b/ui/aura/event_filter_unittest.cc
@@ -67,10 +67,10 @@ class TestEventFilterWindowDelegate : public test::TestWindowDelegate {
return mouse_event_handling_result_;
}
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
++touch_event_count_;
// TODO(sadrul): !
- return ui::TOUCH_STATUS_UNKNOWN;
+ return ui::ER_UNHANDLED;
}
virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
diff --git a/ui/aura/gestures/gesture_recognizer_unittest.cc b/ui/aura/gestures/gesture_recognizer_unittest.cc
index b64ec7df2874c..788fbf47e06af 100644
--- a/ui/aura/gestures/gesture_recognizer_unittest.cc
+++ b/ui/aura/gestures/gesture_recognizer_unittest.cc
@@ -287,11 +287,8 @@ class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
}
virtual ~QueueTouchEventDelegate() {}
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
- if (!queue_events_)
- return ui::TOUCH_STATUS_UNKNOWN;
- return event->type() == ui::ET_TOUCH_RELEASED ?
- ui::TOUCH_STATUS_QUEUED_END : ui::TOUCH_STATUS_QUEUED;
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
+ return queue_events_ ? ui::ER_ASYNC : ui::ER_UNHANDLED;
}
void ReceivedAck() {
@@ -2556,9 +2553,9 @@ class ConsumesTouchMovesDelegate : public GestureEventConsumeDelegate {
void set_consume_touch_move(bool consume) { consume_touch_move_ = consume; }
private:
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* touch) OVERRIDE {
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* touch) OVERRIDE {
if (consume_touch_move_ && touch->type() == ui::ET_TOUCH_MOVED)
- return ui::TOUCH_STATUS_CONTINUE;
+ return ui::ER_HANDLED;
return GestureEventConsumeDelegate::OnTouchEvent(touch);
}
diff --git a/ui/aura/root_window.cc b/ui/aura/root_window.cc
index b44deffaff4cf..833a0b6701dd1 100644
--- a/ui/aura/root_window.cc
+++ b/ui/aura/root_window.cc
@@ -661,55 +661,12 @@ bool RootWindow::ProcessKeyEvent(Window* target, ui::KeyEvent* event) {
return false;
}
-ui::TouchStatus RootWindow::ProcessTouchEvent(Window* target,
+ui::EventResult RootWindow::ProcessTouchEvent(Window* target,
ui::TouchEvent* event) {
- if (ProcessEvent(NULL, event) != ui::ER_UNHANDLED)
- return ui::TOUCH_STATUS_CONTINUE;
-
- if (!target->IsVisible())
- return ui::TOUCH_STATUS_UNKNOWN;
-
- ui::Event::DispatcherApi dispatch_helper(event);
- dispatch_helper.set_target(target);
-
- // It is necessary to dispatch the event to the event-handlers on env first.
- // TODO(sad): Fix touch-event handling so it can use the same
- // event-dispatching code used for other events.
- ui::EventTarget::DispatcherApi dispatch_target_helper(Env::GetInstance());
- const ui::EventHandlerList& pre_target =
- dispatch_target_helper.pre_target_list();
- for (ui::EventHandlerList::const_iterator iter = pre_target.begin();
- iter != pre_target.end(); ++iter) {
- ui::TouchStatus status = (*iter)->OnTouchEvent(event);
- if (status != ui::TOUCH_STATUS_UNKNOWN)
- return status;
- }
-
- EventFilters filters;
- if (target == this)
- GetEventFiltersToNotify(target, &filters);
- else
- GetEventFiltersToNotify(target->parent(), &filters);
-
- // |target| can be deleted by any of the handlers below.
- WindowTracker tracker;
- tracker.Add(target);
-
- for (EventFilters::const_reverse_iterator it = filters.rbegin(),
- rend = filters.rend();
- it != rend; ++it) {
- ui::TouchStatus status = (*it)->PreHandleTouchEvent(target, event);
- if (status != ui::TOUCH_STATUS_UNKNOWN)
- return status;
- }
-
- if (tracker.Contains(target) && target->delegate()) {
- ui::TouchStatus status = target->delegate()->OnTouchEvent(event);
- if (status != ui::TOUCH_STATUS_UNKNOWN)
- return status;
- }
-
- return ui::TOUCH_STATUS_UNKNOWN;
+ if (!target)
+ target = this;
+ AutoReset<Window*> reset(&event_dispatch_target_, target);
+ return static_cast<ui::EventResult>(ProcessEvent(target, event));
}
ui::EventResult RootWindow::ProcessGestureEvent(Window* target,
@@ -917,7 +874,7 @@ bool RootWindow::OnHostTouchEvent(ui::TouchEvent* event) {
transform.ConcatScale(scale, scale);
event->UpdateForRootTransform(transform);
bool handled = false;
- ui::TouchStatus status = ui::TOUCH_STATUS_UNKNOWN;
+ ui::EventResult result = ui::ER_UNHANDLED;
Window* target = client::GetCaptureWindow(this);
if (!target) {
target = ConsumerToWindow(
@@ -931,8 +888,8 @@ bool RootWindow::OnHostTouchEvent(ui::TouchEvent* event) {
if (!target && !bounds().Contains(event->location())) {
// If the initial touch is outside the root window, target the root.
target = this;
- status = ProcessTouchEvent(target, event);
- CHECK_EQ(ui::TOUCH_STATUS_UNKNOWN, status);
+ result = ProcessTouchEvent(target, event);
+ CHECK_EQ(ui::ER_UNHANDLED, result);
} else {
// We only come here when the first contact was within the root window.
if (!target) {
@@ -943,11 +900,10 @@ bool RootWindow::OnHostTouchEvent(ui::TouchEvent* event) {
ui::TouchEvent translated_event(
*event, static_cast<Window*>(this), target);
- status = ProcessTouchEvent(target, &translated_event);
- handled = status != ui::TOUCH_STATUS_UNKNOWN;
+ result = ProcessTouchEvent(target, &translated_event);
+ handled = result != ui::ER_UNHANDLED;
- if (status == ui::TOUCH_STATUS_QUEUED ||
- status == ui::TOUCH_STATUS_QUEUED_END) {
+ if (result & ui::ER_ASYNC) {
gesture_recognizer_->QueueTouchEventForGesture(target, *event);
return true;
}
@@ -956,7 +912,7 @@ bool RootWindow::OnHostTouchEvent(ui::TouchEvent* event) {
// Get the list of GestureEvents from GestureRecognizer.
scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(
- *event, status, target));
+ *event, result, target));
return ProcessGestures(gestures.get()) ? true : handled;
}
diff --git a/ui/aura/root_window.h b/ui/aura/root_window.h
index 0f56aad40bbca..71b72f0a2d16f 100644
--- a/ui/aura/root_window.h
+++ b/ui/aura/root_window.h
@@ -290,7 +290,7 @@ class AURA_EXPORT RootWindow : public ui::CompositorDelegate,
bool ProcessMouseEvent(Window* target, ui::MouseEvent* event);
bool ProcessKeyEvent(Window* target, ui::KeyEvent* event);
- ui::TouchStatus ProcessTouchEvent(Window* target, ui::TouchEvent* event);
+ ui::EventResult ProcessTouchEvent(Window* target, ui::TouchEvent* event);
ui::EventResult ProcessGestureEvent(Window* target,
ui::GestureEvent* event);
bool ProcessGestures(ui::GestureRecognizer::Gestures* gestures);
diff --git a/ui/aura/shared/compound_event_filter.cc b/ui/aura/shared/compound_event_filter.cc
index 0471819c91b10..c8758f22ec5b4 100644
--- a/ui/aura/shared/compound_event_filter.cc
+++ b/ui/aura/shared/compound_event_filter.cc
@@ -129,19 +129,16 @@ ui::EventResult CompoundEventFilter::FilterMouseEvent(ui::MouseEvent* event) {
return static_cast<ui::EventResult>(result);
}
-ui::TouchStatus CompoundEventFilter::FilterTouchEvent(
- Window* target,
- ui::TouchEvent* event) {
- ui::TouchStatus status = ui::TOUCH_STATUS_UNKNOWN;
+ui::EventResult CompoundEventFilter::FilterTouchEvent(ui::TouchEvent* event) {
+ int result = ui::ER_UNHANDLED;
if (filters_.might_have_observers()) {
ObserverListBase<EventFilter>::Iterator it(filters_);
EventFilter* filter;
- while (status == ui::TOUCH_STATUS_UNKNOWN &&
- (filter = it.GetNext()) != NULL) {
- status = filter->OnTouchEvent(event);
+ while (!(result & ui::ER_CONSUMED) && (filter = it.GetNext()) != NULL) {
+ result |= filter->OnTouchEvent(event);
}
}
- return status;
+ return static_cast<ui::EventResult>(result);
}
void CompoundEventFilter::SetCursorVisibilityOnEvent(aura::Window* target,
@@ -163,22 +160,6 @@ void CompoundEventFilter::SetCursorVisibilityOnEvent(aura::Window* target,
}
}
-////////////////////////////////////////////////////////////////////////////////
-// CompoundEventFilter, EventFilter implementation:
-
-ui::TouchStatus CompoundEventFilter::PreHandleTouchEvent(
- Window* target,
- ui::TouchEvent* event) {
- // TODO(sad): Move the implementation into OnTouchEvent once touch-events are
- // hooked up to go through EventDispatcher.
- ui::TouchStatus status = FilterTouchEvent(target, event);
- if (status == ui::TOUCH_STATUS_UNKNOWN &&
- event->type() == ui::ET_TOUCH_PRESSED) {
- SetCursorVisibilityOnEvent(target, event, false);
- }
- return status;
-}
-
////////////////////////////////////////////////////////////////////////////////
// CompoundEventFilter, ui::EventHandler implementation:
@@ -229,8 +210,14 @@ ui::EventResult CompoundEventFilter::OnScrollEvent(ui::ScrollEvent* event) {
return ui::ER_UNHANDLED;
}
-ui::TouchStatus CompoundEventFilter::OnTouchEvent(ui::TouchEvent* event) {
- return EventFilter::OnTouchEvent(event);
+ui::EventResult CompoundEventFilter::OnTouchEvent(ui::TouchEvent* event) {
+ ui::EventResult result = FilterTouchEvent(event);
+ if (result == ui::ER_UNHANDLED &&
+ event->type() == ui::ET_TOUCH_PRESSED) {
+ SetCursorVisibilityOnEvent(
+ static_cast<aura::Window*>(event->target()), event, false);
+ }
+ return result;
}
ui::EventResult CompoundEventFilter::OnGestureEvent(ui::GestureEvent* event) {
diff --git a/ui/aura/shared/compound_event_filter.h b/ui/aura/shared/compound_event_filter.h
index 5b35df1898709..9c0318c03cff9 100644
--- a/ui/aura/shared/compound_event_filter.h
+++ b/ui/aura/shared/compound_event_filter.h
@@ -55,7 +55,7 @@ class AURA_EXPORT CompoundEventFilter : public EventFilter {
// Dispatches event to additional filters.
ui::EventResult FilterKeyEvent(ui::KeyEvent* event);
ui::EventResult FilterMouseEvent(ui::MouseEvent* event);
- ui::TouchStatus FilterTouchEvent(Window* target, ui::TouchEvent* event);
+ ui::EventResult FilterTouchEvent(ui::TouchEvent* event);
// Sets the visibility of the cursor if the event is not synthesized and
// 1) it's hiding (show=false) when the cursor is currently shown, or
@@ -67,15 +67,11 @@ class AURA_EXPORT CompoundEventFilter : public EventFilter {
ui::Event* event,
bool show);
- // Overridden from EventFilter:
- virtual ui::TouchStatus PreHandleTouchEvent(Window* target,
- ui::TouchEvent* event) OVERRIDE;
-
// Overridden from ui::EventHandler:
virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
// Additional event filters that pre-handles events.
ObserverList<EventFilter, true> filters_;
diff --git a/ui/aura/test/test_event_filter.cc b/ui/aura/test/test_event_filter.cc
index 74613f07dae5b..cd56b36aff2e1 100644
--- a/ui/aura/test/test_event_filter.cc
+++ b/ui/aura/test/test_event_filter.cc
@@ -39,10 +39,10 @@ ui::EventResult TestEventFilter::OnScrollEvent(ui::ScrollEvent* event) {
return ui::ER_UNHANDLED;
}
-ui::TouchStatus TestEventFilter::OnTouchEvent(ui::TouchEvent* event) {
+ui::EventResult TestEventFilter::OnTouchEvent(ui::TouchEvent* event) {
++touch_event_count_;
// TODO(sadrul): !
- return ui::TOUCH_STATUS_UNKNOWN;
+ return ui::ER_UNHANDLED;
}
ui::EventResult TestEventFilter::OnGestureEvent(ui::GestureEvent* event) {
diff --git a/ui/aura/test/test_event_filter.h b/ui/aura/test/test_event_filter.h
index a5016003cd5f3..11c1bdde3b7b3 100644
--- a/ui/aura/test/test_event_filter.h
+++ b/ui/aura/test/test_event_filter.h
@@ -42,7 +42,7 @@ class TestEventFilter : public EventFilter {
virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
private:
int key_event_count_;
diff --git a/ui/aura/test/test_window_delegate.cc b/ui/aura/test/test_window_delegate.cc
index 8815c92a7ce48..62f5d8df42212 100644
--- a/ui/aura/test/test_window_delegate.cc
+++ b/ui/aura/test/test_window_delegate.cc
@@ -105,8 +105,8 @@ ui::EventResult TestWindowDelegate::OnMouseEvent(ui::MouseEvent* event) {
return ui::ER_UNHANDLED;
}
-ui::TouchStatus TestWindowDelegate::OnTouchEvent(ui::TouchEvent* event) {
- return ui::TOUCH_STATUS_UNKNOWN;
+ui::EventResult TestWindowDelegate::OnTouchEvent(ui::TouchEvent* event) {
+ return ui::ER_UNHANDLED;
}
ui::EventResult TestWindowDelegate::OnGestureEvent(
diff --git a/ui/aura/test/test_window_delegate.h b/ui/aura/test/test_window_delegate.h
index 8076690a19d14..ba626914536d3 100644
--- a/ui/aura/test/test_window_delegate.h
+++ b/ui/aura/test/test_window_delegate.h
@@ -54,7 +54,7 @@ class TestWindowDelegate : public WindowDelegate {
// Overridden from ui::EventHandler:
virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
private:
diff --git a/ui/aura/window_unittest.cc b/ui/aura/window_unittest.cc
index 5c93819534877..1330742c44887 100644
--- a/ui/aura/window_unittest.cc
+++ b/ui/aura/window_unittest.cc
@@ -171,9 +171,9 @@ class CaptureWindowDelegateImpl : public TestWindowDelegate {
mouse_event_count_++;
return ui::ER_UNHANDLED;
}
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
touch_event_count_++;
- return ui::TOUCH_STATUS_UNKNOWN;
+ return ui::ER_UNHANDLED;
}
virtual ui::EventResult OnGestureEvent(
ui::GestureEvent* event) OVERRIDE {
diff --git a/ui/base/events/event_constants.cc b/ui/base/events/event_constants.cc
new file mode 100644
index 0000000000000..fd95b35906ee7
--- /dev/null
+++ b/ui/base/events/event_constants.cc
@@ -0,0 +1,30 @@
+// 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 "ui/base/events/event_constants.h"
+
+#include "base/logging.h"
+
+namespace ui {
+
+EventResult EventResultFromTouchStatus(TouchStatus status) {
+ switch (status) {
+ case TOUCH_STATUS_UNKNOWN:
+ return ER_UNHANDLED;
+
+ case TOUCH_STATUS_START:
+ case TOUCH_STATUS_CONTINUE:
+ case TOUCH_STATUS_END:
+ return ER_CONSUMED;
+
+ case TOUCH_STATUS_QUEUED:
+ case TOUCH_STATUS_QUEUED_END:
+ return ER_ASYNC;
+ }
+
+ NOTREACHED();
+ return ER_UNHANDLED;
+}
+
+} // namespace ui
diff --git a/ui/base/events/event_constants.h b/ui/base/events/event_constants.h
index 6785633f7782a..bd966eafb0e75 100644
--- a/ui/base/events/event_constants.h
+++ b/ui/base/events/event_constants.h
@@ -98,12 +98,14 @@ enum MouseEventFlags {
// Result of dispatching an event.
enum EventResult {
- ER_UNHANDLED = 0, // The event hasn't been handled. The event can be
- // propagated to other handlers.
- ER_HANDLED, // The event has already been handled, but it can still be
- // propagated to other handlers.
- ER_CONSUMED, // The event has been handled, and it should not be
- // propagated to other handlers.
+ ER_UNHANDLED = 0, // The event hasn't been handled. The event can be
+ // propagated to other handlers.
+ ER_HANDLED = 1 << 0, // The event has already been handled, but it can
+ // still be propagated to other handlers.
+ ER_CONSUMED = 1 << 1, // The event has been handled, and it should not be
+ // propagated to other handlers.
+ ER_ASYNC = 1 << 2, // The event will be processed asynchronously. The
+ // event can still be propagated to other handlers.
};
// Phase of the event dispatch.
@@ -122,9 +124,6 @@ enum TouchStatus {
TOUCH_STATUS_CONTINUE, // The touch event is part of a previously
// started touch sequence.
TOUCH_STATUS_END, // The touch event ended the touch sequence.
- TOUCH_STATUS_SYNTH_MOUSE, // The touch event was not processed, but a
- // synthetic mouse event generated from the
- // unused touch event was handled.
TOUCH_STATUS_QUEUED, // The touch event has not been processed yet, but
// may be processed asynchronously later. This also
// places a lock on touch-events (i.e. all
@@ -135,6 +134,9 @@ enum TouchStatus {
// handler.
};
+// Returns an equivalent EventResult from a TouchStatus.
+UI_EXPORT EventResult EventResultFromTouchStatus(TouchStatus status);
+
// Updates the list of devices for cached properties.
UI_EXPORT void UpdateDeviceList();
diff --git a/ui/base/events/event_dispatcher.cc b/ui/base/events/event_dispatcher.cc
index 23bad57e82cf8..ce0452e88090e 100644
--- a/ui/base/events/event_dispatcher.cc
+++ b/ui/base/events/event_dispatcher.cc
@@ -32,11 +32,7 @@ EventResult EventDispatcher::DispatchEventToSingleHandler(EventHandler* handler,
EventResult EventDispatcher::DispatchEventToSingleHandler(EventHandler* handler,
TouchEvent* event) {
- // TODO(sad): This needs fixing (especially for the QUEUED_ status).
- TouchStatus status = handler->OnTouchEvent(event);
- return status == ui::TOUCH_STATUS_UNKNOWN ? ER_UNHANDLED :
- status == ui::TOUCH_STATUS_QUEUED_END ? ER_CONSUMED :
- ER_HANDLED;
+ return handler->OnTouchEvent(event);
}
EventResult EventDispatcher::DispatchEventToSingleHandler(EventHandler* handler,
diff --git a/ui/base/events/event_dispatcher_unittest.cc b/ui/base/events/event_dispatcher_unittest.cc
index 74e2ef8f6658b..7033be968bb71 100644
--- a/ui/base/events/event_dispatcher_unittest.cc
+++ b/ui/base/events/event_dispatcher_unittest.cc
@@ -91,9 +91,9 @@ class TestEventHandler : public EventHandler {
return event_result_;
}
- virtual TouchStatus OnTouchEvent(TouchEvent* event) OVERRIDE {
+ virtual EventResult OnTouchEvent(TouchEvent* event) OVERRIDE {
ReceivedEvent(event);
- return ui::TOUCH_STATUS_UNKNOWN;
+ return event_result_;
}
virtual EventResult OnGestureEvent(GestureEvent* event) OVERRIDE {
diff --git a/ui/base/events/event_handler.h b/ui/base/events/event_handler.h
index 3e2e9c52405dc..84e6b6e2b9b6b 100644
--- a/ui/base/events/event_handler.h
+++ b/ui/base/events/event_handler.h
@@ -32,7 +32,7 @@ class UI_EXPORT EventHandler {
virtual EventResult OnScrollEvent(ScrollEvent* event) = 0;
- virtual TouchStatus OnTouchEvent(TouchEvent* event) = 0;
+ virtual EventResult OnTouchEvent(TouchEvent* event) = 0;
virtual EventResult OnGestureEvent(GestureEvent* event) = 0;
};
diff --git a/ui/base/events/event_target.cc b/ui/base/events/event_target.cc
index a11ec5b7938bf..505c299b236b6 100644
--- a/ui/base/events/event_target.cc
+++ b/ui/base/events/event_target.cc
@@ -84,10 +84,10 @@ EventResult EventTarget::OnScrollEvent(ScrollEvent* event) {
return target_handler_ ? target_handler_->OnScrollEvent(event) : ER_UNHANDLED;
}
-TouchStatus EventTarget::OnTouchEvent(TouchEvent* event) {
+EventResult EventTarget::OnTouchEvent(TouchEvent* event) {
CHECK_EQ(this, event->target());
return target_handler_ ? target_handler_->OnTouchEvent(event) :
- TOUCH_STATUS_UNKNOWN;
+ ER_UNHANDLED;
}
EventResult EventTarget::OnGestureEvent(GestureEvent* event) {
diff --git a/ui/base/events/event_target.h b/ui/base/events/event_target.h
index 5687c6b5729ea..4215dcb89b7fa 100644
--- a/ui/base/events/event_target.h
+++ b/ui/base/events/event_target.h
@@ -87,7 +87,7 @@ class UI_EXPORT EventTarget : public EventHandler {
virtual EventResult OnKeyEvent(KeyEvent* event) OVERRIDE;
virtual EventResult OnMouseEvent(MouseEvent* event) OVERRIDE;
virtual EventResult OnScrollEvent(ScrollEvent* event) OVERRIDE;
- virtual TouchStatus OnTouchEvent(TouchEvent* event) OVERRIDE;
+ virtual EventResult OnTouchEvent(TouchEvent* event) OVERRIDE;
virtual EventResult OnGestureEvent(GestureEvent* event) OVERRIDE;
EventHandlerList pre_target_list_;
diff --git a/ui/base/gestures/gesture_recognizer.h b/ui/base/gestures/gesture_recognizer.h
index af3af54da7055..a49997faaa532 100644
--- a/ui/base/gestures/gesture_recognizer.h
+++ b/ui/base/gestures/gesture_recognizer.h
@@ -29,7 +29,7 @@ class UI_EXPORT GestureRecognizer {
// TouchEvent.
// Caller would be responsible for freeing up Gestures.
virtual Gestures* ProcessTouchEventForGesture(const TouchEvent& event,
- ui::TouchStatus status,
+ ui::EventResult result,
GestureConsumer* consumer) = 0;
// Touch-events can be queued to be played back at a later time. The queues
diff --git a/ui/base/gestures/gesture_recognizer_impl.cc b/ui/base/gestures/gesture_recognizer_impl.cc
index a6db5a1eee612..7cb686ed1ced9 100644
--- a/ui/base/gestures/gesture_recognizer_impl.cc
+++ b/ui/base/gestures/gesture_recognizer_impl.cc
@@ -56,18 +56,18 @@ class MirroredTouchEvent : public TouchEvent {
class QueuedTouchEvent : public MirroredTouchEvent {
public:
- QueuedTouchEvent(const TouchEvent* real, TouchStatus status)
+ QueuedTouchEvent(const TouchEvent* real, EventResult result)
: MirroredTouchEvent(real),
- status_(status) {
+ result_(result) {
}
virtual ~QueuedTouchEvent() {
}
- TouchStatus status() const { return status_; }
+ EventResult result() const { return result_; }
private:
- TouchStatus status_;
+ EventResult result_;
DISALLOW_COPY_AND_ASSIGN(QueuedTouchEvent);
};
@@ -258,41 +258,41 @@ void GestureRecognizerImpl::SetupTargets(const TouchEvent& event,
GestureSequence::Gestures* GestureRecognizerImpl::AdvanceTouchQueueByOne(
GestureConsumer* consumer,
- ui::TouchStatus status) {
+ ui::EventResult result) {
CHECK(event_queue_[consumer]);
CHECK(!event_queue_[consumer]->empty());
ScopedPop pop(event_queue_[consumer]);
TouchEvent* event = event_queue_[consumer]->front();
GestureSequence* sequence = GetGestureSequenceForConsumer(consumer);
- if (status != ui::TOUCH_STATUS_UNKNOWN &&
- event->type() == ui::ET_TOUCH_RELEASED) {
+ if (result != ER_UNHANDLED &&
+ event->type() == ET_TOUCH_RELEASED) {
// A touch release was was processed (e.g. preventDefault()ed by a
// web-page), but we still need to process a touch cancel.
CancelledTouchEvent cancelled(event);
return sequence->ProcessTouchEventForGesture(cancelled,
- ui::TOUCH_STATUS_UNKNOWN);
+ ER_UNHANDLED);
}
- return sequence->ProcessTouchEventForGesture(*event, status);
+ return sequence->ProcessTouchEventForGesture(*event, result);
}
GestureSequence::Gestures* GestureRecognizerImpl::ProcessTouchEventForGesture(
const TouchEvent& event,
- ui::TouchStatus status,
+ ui::EventResult result,
GestureConsumer* target) {
if (event_queue_[target] && event_queue_[target]->size() > 0) {
// There are some queued touch-events for this target. Processing |event|
// before those queued events will result in unexpected gestures. So
// postpone the processing of the events until the queued events have been
// processed.
- event_queue_[target]->push(new QueuedTouchEvent(&event, status));
+ event_queue_[target]->push(new QueuedTouchEvent(&event, result));
return NULL;
}
SetupTargets(event, target);
GestureSequence* gesture_sequence = GetGestureSequenceForConsumer(target);
- return gesture_sequence->ProcessTouchEventForGesture(event, status);
+ return gesture_sequence->ProcessTouchEventForGesture(event, result);
}
void GestureRecognizerImpl::QueueTouchEventForGesture(GestureConsumer* consumer,
@@ -300,7 +300,7 @@ void GestureRecognizerImpl::QueueTouchEventForGesture(GestureConsumer* consumer,
if (!event_queue_[consumer])
event_queue_[consumer] = new std::queue<TouchEvent*>();
event_queue_[consumer]->push(
- new QueuedTouchEvent(&event, TOUCH_STATUS_QUEUED));
+ new QueuedTouchEvent(&event, ER_ASYNC));
SetupTargets(event, consumer);
}
@@ -314,18 +314,18 @@ GestureSequence::Gestures* GestureRecognizerImpl::AdvanceTouchQueue(
}
scoped_ptr<GestureSequence::Gestures> gestures(
- AdvanceTouchQueueByOne(consumer, processed ? TOUCH_STATUS_CONTINUE :
- TOUCH_STATUS_UNKNOWN));
+ AdvanceTouchQueueByOne(consumer, processed ? ER_HANDLED :
+ ER_UNHANDLED));
// Are there any queued touch-events that should be auto-dequeued?
while (!event_queue_[consumer]->empty()) {
QueuedTouchEvent* event =
static_cast<QueuedTouchEvent*>(event_queue_[consumer]->front());
- if (event->status() == TOUCH_STATUS_QUEUED)
+ if (event->result() == ER_ASYNC)
break;
scoped_ptr<GestureSequence::Gestures> current_gestures(
- AdvanceTouchQueueByOne(consumer, event->status()));
+ AdvanceTouchQueueByOne(consumer, event->result()));
if (current_gestures.get()) {
if (!gestures.get()) {
gestures.reset(current_gestures.release());
diff --git a/ui/base/gestures/gesture_recognizer_impl.h b/ui/base/gestures/gesture_recognizer_impl.h
index 0af2a6cfd7ce2..e4cabbdf917b1 100644
--- a/ui/base/gestures/gesture_recognizer_impl.h
+++ b/ui/base/gestures/gesture_recognizer_impl.h
@@ -53,12 +53,12 @@ class UI_EXPORT GestureRecognizerImpl : public GestureRecognizer {
// called must take ownership of the returned gestures and free them when they
// are not needed anymore.
Gestures* AdvanceTouchQueueByOne(GestureConsumer* consumer,
- ui::TouchStatus status);
+ ui::EventResult result);
// Overridden from GestureRecognizer
virtual Gestures* ProcessTouchEventForGesture(
const TouchEvent& event,
- ui::TouchStatus status,
+ ui::EventResult result,
GestureConsumer* target) OVERRIDE;
virtual void QueueTouchEventForGesture(GestureConsumer* consumer,
const TouchEvent& event) OVERRIDE;
diff --git a/ui/base/gestures/gesture_sequence.cc b/ui/base/gestures/gesture_sequence.cc
index e56bfca8d026c..7105aa9f14440 100644
--- a/ui/base/gestures/gesture_sequence.cc
+++ b/ui/base/gestures/gesture_sequence.cc
@@ -30,7 +30,7 @@ enum TouchState {
TS_UNKNOWN,
};
-// ui::TouchStatus is mapped to TouchStatusInternal to simply indicate whether a
+// ui::EventResult is mapped to TouchStatusInternal to simply indicate whether a
// processed touch-event should affect gesture-recognition or not.
enum TouchStatusInternal {
TSI_NOT_PROCESSED, // The touch-event should take-part into
@@ -307,11 +307,10 @@ GestureSequence::~GestureSequence() {
GestureSequence::Gestures* GestureSequence::ProcessTouchEventForGesture(
const TouchEvent& event,
- ui::TouchStatus status) {
+ EventResult result) {
StopLongPressTimerIfRequired(event);
last_touch_location_ = event.location();
- if (status == ui::TOUCH_STATUS_QUEUED ||
- status == ui::TOUCH_STATUS_QUEUED_END)
+ if (result & ER_ASYNC)
return NULL;
// Set a limit on the number of simultaneous touches in a gesture.
@@ -351,7 +350,8 @@ GestureSequence::Gestures* GestureSequence::ProcessTouchEventForGesture(
if (event.type() == ui::ET_TOUCH_PRESSED)
AppendBeginGestureEvent(point, gestures.get());
- TouchStatusInternal status_internal = (status == ui::TOUCH_STATUS_UNKNOWN) ?
+ CHECK_NE(ER_ASYNC, result);
+ TouchStatusInternal status_internal = (result == ER_UNHANDLED) ?
TSI_NOT_PROCESSED : TSI_PROCESSED;
EdgeStateSignatureType signature = Signature(state_, point_id,
@@ -577,7 +577,7 @@ bool GestureSequence::IsSecondTouchDownCloseEnoughForTwoFingerTap() {
gfx::Point p1 = GetPointByPointId(0)->last_touch_position();
gfx::Point p2 = GetPointByPointId(1)->last_touch_position();
double max_distance =
- ui::GestureConfiguration::max_distance_for_two_finger_tap_in_pixels();
+ GestureConfiguration::max_distance_for_two_finger_tap_in_pixels();
double distance = (p1.x() - p2.x()) * (p1.x() - p2.x()) +
(p1.y() - p2.y()) * (p1.y() - p2.y());
if (distance < max_distance * max_distance)
diff --git a/ui/base/gestures/gesture_sequence.h b/ui/base/gestures/gesture_sequence.h
index 0581f1ea9b6ea..6849ae37a55c7 100644
--- a/ui/base/gestures/gesture_sequence.h
+++ b/ui/base/gestures/gesture_sequence.h
@@ -46,7 +46,7 @@ class UI_EXPORT GestureSequence {
// TouchEvent.
// Caller would be responsible for freeing up Gestures.
virtual Gestures* ProcessTouchEventForGesture(const TouchEvent& event,
- ui::TouchStatus status);
+ EventResult status);
const GesturePoint* points() const { return points_; }
int point_count() const { return point_count_; }
diff --git a/ui/ui.gyp b/ui/ui.gyp
index 66ee4ed880d8d..dd23816d65edc 100644
--- a/ui/ui.gyp
+++ b/ui/ui.gyp
@@ -218,6 +218,7 @@
'base/dragdrop/os_exchange_data_provider_win.h',
'base/events/event.cc',
'base/events/event.h',
+ 'base/events/event_constants.cc',
'base/events/event_constants.h',
'base/events/event_functions.cc',
'base/events/event_functions.h',
diff --git a/ui/views/widget/desktop_native_widget_aura.cc b/ui/views/widget/desktop_native_widget_aura.cc
index 7d36459b8757f..159265a94e743 100644
--- a/ui/views/widget/desktop_native_widget_aura.cc
+++ b/ui/views/widget/desktop_native_widget_aura.cc
@@ -436,8 +436,9 @@ ui::EventResult DesktopNativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
ui::ER_HANDLED : ui::ER_UNHANDLED;
}
-ui::TouchStatus DesktopNativeWidgetAura::OnTouchEvent(ui::TouchEvent* event) {
- return native_widget_delegate_->OnTouchEvent(*event);
+ui::EventResult DesktopNativeWidgetAura::OnTouchEvent(ui::TouchEvent* event) {
+ ui::TouchStatus status = native_widget_delegate_->OnTouchEvent(*event);
+ return ui::EventResultFromTouchStatus(status);
}
ui::EventResult DesktopNativeWidgetAura::OnGestureEvent(
diff --git a/ui/views/widget/desktop_native_widget_aura.h b/ui/views/widget/desktop_native_widget_aura.h
index d6903b6208e1f..e382824c1d9e8 100644
--- a/ui/views/widget/desktop_native_widget_aura.h
+++ b/ui/views/widget/desktop_native_widget_aura.h
@@ -131,7 +131,7 @@ class VIEWS_EXPORT DesktopNativeWidgetAura
// Overridden from ui::EventHandler:
virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
private:
diff --git a/ui/views/widget/native_widget_aura.cc b/ui/views/widget/native_widget_aura.cc
index b7c0404b3fbc9..be4dee4307435 100644
--- a/ui/views/widget/native_widget_aura.cc
+++ b/ui/views/widget/native_widget_aura.cc
@@ -875,9 +875,10 @@ ui::EventResult NativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
return delegate_->OnMouseEvent(*event) ? ui::ER_HANDLED : ui::ER_UNHANDLED;
}
-ui::TouchStatus NativeWidgetAura::OnTouchEvent(ui::TouchEvent* event) {
+ui::EventResult NativeWidgetAura::OnTouchEvent(ui::TouchEvent* event) {
DCHECK(window_->IsVisible());
- return delegate_->OnTouchEvent(*event);
+ ui::TouchStatus status = delegate_->OnTouchEvent(*event);
+ return ui::EventResultFromTouchStatus(status);
}
ui::EventResult NativeWidgetAura::OnGestureEvent(ui::GestureEvent* event) {
diff --git a/ui/views/widget/native_widget_aura.h b/ui/views/widget/native_widget_aura.h
index 28dbb698f813a..ed65407a896de 100644
--- a/ui/views/widget/native_widget_aura.h
+++ b/ui/views/widget/native_widget_aura.h
@@ -153,7 +153,7 @@ class VIEWS_EXPORT NativeWidgetAura : public internal::NativeWidgetPrivate,
// Overridden from ui::EventHandler:
virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
- virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+ virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
// Overridden from aura::client::ActivationDelegate: