events: Clean up dispatching code for touch-events.

Unlike all other events, touch-events can be processed asynchronously, and
this complicates using the same code-path used for other events for touch
events. This change adds a generic EventResult::ER_ASYNC for these cases,
and updates the code in events, aura and gesture recognizer to use EventResult
instead of TouchStatus.

The code in views still uses TouchStatus. But it will be cleaned up.

BUG=none

Review URL: https://codereview.chromium.org/10964051

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@159059 0039d316-1c4b-4281-b951-d872f2087c98

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(

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:

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);
   }

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(

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:

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());
       }
     }

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(

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:

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;

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) {

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;
 };
 

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 {

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);
   }
 

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;
 }

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);

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) {

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_;

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) {

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_;

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(

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:

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 {

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

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();
 

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,

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 {

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;
 };

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) {

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_;

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

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());

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;

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)

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_; }
 

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',

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(

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:

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) {

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: