events: Clean up dispatching code for touch-events.

ui/base/events/event_constants.h

 // 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.
 
 #ifndef UI_BASE_EVENTS_EVENT_CONSTANTS_H_
 #define UI_BASE_EVENTS_EVENT_CONSTANTS_H_
 
 #include "base/event_types.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/gfx/native_widget_types.h"
@@ skipping 80 matching lines @@
   EF_IS_DOUBLE_CLICK    = 1 << 16,
   EF_IS_TRIPLE_CLICK    = 1 << 17,
   EF_IS_NON_CLIENT      = 1 << 18,
   EF_IS_SYNTHESIZED     = 1 << 19,  // Only for Aura.  See ui/aura/root_window.h
   EF_FROM_TOUCH         = 1 << 20,  // Indicates this mouse event is generated
                                     // from an unconsumed touch/gesture event.
 };
 
 // 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

[Ben Goodger (Google), 2012/09/26 19:42:48]

Can you tell me how 'asynchronously' works and what this return code would be
interpreted by the caller?

[sadrul, 2012/09/26 21:26:05]

Right now, ASYNC is only used for touch-events, and this is returned only by
RenderWidgetHostViewAura. (I don't think there will be any other places that
will do this in the future)

For each touch-event that is processed as ASYNC, the RootWindow adds it in a
queue in the GestureRecognizer. For each such ASYNC touch event, the RWHVA calls
RootWindow::AdvanceQueuedTouchEvent asynchronously (after it receives an ACK
from renderer/WebKit). At this point, the GR removes the event from the queue
and processes it (and may generate gesture events, which are then dispatched by
the RootWindow).

There is plan to move the touch-event queue out of the GR and into content/,
since that will allow other platforms (e.g. android) to use the same queueing
code: crbug.com/138153. Once that happens, this ER_SYNC will no longer be
necessary.

+                          // event can still be propagated to other handlers.
 };
 
 // Phase of the event dispatch.
 enum EventPhase {
   EP_PREDISPATCH,
   EP_PRETARGET,
   EP_TARGET,
   EP_POSTTARGET,
   EP_POSTDISPATCH
 };
 
 enum TouchStatus {
   TOUCH_STATUS_UNKNOWN = 0,  // Unknown touch status. This is used to indicate
                              // that the touch event was not handled.
   TOUCH_STATUS_START,        // The touch event initiated a touch sequence.
   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
                              // subsequent touch-events should be sent to the
                              // current handler).
   TOUCH_STATUS_QUEUED_END,   // Similar to TOUCH_STATUS_QUEUED, except that
                              // subsequent touch-events can be sent to any
                              // handler.
 };
 
@@ skipping 94 matching lines @@
 UI_EXPORT int GetModifiersFromKeyState();
 
 // Returns true if |message| identifies a mouse event that was generated as the
 // result of a touch event.
 UI_EXPORT bool IsMouseEventFromTouch(UINT message);
 #endif
 
 }  // namespace ui
 
 #endif  // UI_BASE_EVENTS_EVENT_CONSTANTS_H_