[Android] Perform eager gesture recognition on MotionEvents

content/browser/renderer_host/input/gesture_event_queue.h

+// Copyright 2013 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 CONTENT_BROWSER_RENDERER_HOST_INPUT_GESTURE_EVENT_QUEUE_H_
+#define CONTENT_BROWSER_RENDERER_HOST_INPUT_GESTURE_EVENT_QUEUE_H_
+
+#include <deque>
+
+#include "base/callback.h"
+#include "content/browser/renderer_host/input/gesture_event_packet.h"
+#include "content/common/content_export.h"
+#include "content/port/common/input_event_ack_state.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+
+namespace content {
+
+class CONTENT_EXPORT GestureEventQueueClient {
+ public:
+  virtual void ForwardGestureEvent(const blink::WebGestureEvent&) = 0;
+ protected:
+  virtual ~GestureEventQueueClient() {}
+};
+
+// Handles dispatch of gestures created by the system.  Gestures derived from
+// touches are forwarded or dropped depending on the disposition of the
+// generating touch sequence.  Synthetic gestures are dispatched immediately.
+class CONTENT_EXPORT GestureEventQueue {

[Rick Byers, 2014/01/21 20:10:10]

I think we need either more discussion of the design here, or a link to the
design doc (not sure if you guys are still maintaining the one Tim started
with).  I may be slow (or short on caffine right now), but a bunch of the
details/motivation here are non-obvious to me (and eager GR was my idea to begin
with <grin>).  I'll add a few comments throughout.

[jdduke (slow), 2014/01/21 20:52:38]

aelias@ and I talked about an eager GR a *long* time ago.  The chief motivation
then, for Android, was to prevent gesture detection issues that inevitably arise
from either partial or delayed touch event streams (e.g., a misfiring ShowPress,
or a disappearing TouchEnd).  

Added benefits include complete decoupling of detection from the final output
(making it easier to experiment, and simplifying gesture detection), and a
consistent way of enforcing whether a particular gesture should or should not be
forwarded.

I think there's a lot of room for refinement here, but this implements fully the
current Android touch handling logic, and can certainly be extended for more
nuanced behavior.

+ public:
+  explicit GestureEventQueue(GestureEventQueueClient* client);
+  ~GestureEventQueue();
+
+  // To be called upon receipt of gesture-related events.  In particular,
+  // |packet| contains [0, n] gestures that correspond to a given event.  That
+  // event may be a touch, a touch timeout, or some other synthetic source.
+  // It is imperative that a single packet is received for *each* touch event,
+  // even those that did not produce a gesture.
+  void OnGestureEventPacket(const GestureEventPacket& packet);
+
+  // To be called upon receipt of *all* touch event acks.
+  void OnTouchEventAck(InputEventAckState ack_state);
+
+  // Determine the most restrictive touch handling state given the current touch
+  // sequence disposition and a new touch disposition.
+  static InputEventAckState GetMostRestrictiveState(InputEventAckState ack_old,
+                                                    InputEventAckState ack_new);
+
+ private:
+  typedef base::Callback<void(const GestureEventPacket& packet)> PacketSender;
+
+  // Utility class for tracking gesture events and dispositions for a single
+  // gesture sequence. A single sequence corresponds to all gestures created
+  // between the first finger down and the last finger up.
+  class GestureSequence {
+   public:
+    GestureSequence();
+    ~GestureSequence();
+
+    void Push(const GestureEventPacket& packet);
+    void OnTouchEventAck(InputEventAckState ack_state,
+                         const PacketSender& packet_handler);
+    bool IsGestureAllowed() const;
+    bool IsEmpty() const;
+
+   private:
+    std::deque<GestureEventPacket> sequence_;
+    InputEventAckState ack_state_;

[Rick Byers, 2014/01/21 20:10:10]

maybe call this 'aggregate_ack_state' or something?  To me it's not really an
individual "ack state" at all anymore, but some representation of all the acks
that have been received for this sequence.  Eg. I believe I'll need to modify
this to track a bit more state for some stuff I'm doing.

[jdduke (slow), 2014/01/21 20:52:38]

As noted below, using the ack here is just bad on my part.  I'll switch to a
more appropriate (and localized) state variable.

+  };
+
+  void SendPacket(const GestureEventPacket& packet);
+  void SendGesture(const blink::WebGestureEvent& gesture);
+  void CancelTapIfNecessary();
+  void CancelFlingIfNecessary();
+  GestureSequence& Head();
+  GestureSequence& Tail();
+
+  GestureEventQueueClient* client_;
+  PacketSender packet_sender_;
+  std::deque<GestureSequence> sequences_;
+  bool outstanding_tap_;
+  bool outstanding_fling_;
+
+  DISALLOW_COPY_AND_ASSIGN(GestureEventQueue);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_GESTURE_EVENT_QUEUE_H_