[Android] Perform eager gesture recognition on MotionEvents

content/browser/renderer_host/input/gesture_event_queue.cc

+// 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.
+
+#include "content/browser/renderer_host/input/gesture_event_queue.h"
+
+#include "base/auto_reset.h"
+#include "base/bind.h"
+#include "base/logging.h"
+#include "content/common/input/web_input_event_traits.h"
+
+using blink::WebGestureEvent;
+using blink::WebInputEvent;
+using blink::WebTouchEvent;
+using blink::WebTouchPoint;
+
+namespace content {
+namespace {
+
+WebGestureEvent CreateGesture(WebInputEvent::Type type) {
+  DCHECK(WebInputEvent::isGestureEventType(type));
+  WebGestureEvent event;
+  event.type = type;
+  event.sourceDevice = WebGestureEvent::Touchscreen;
+  return event;
+}
+
+}  // namespace
+
+GestureEventQueue::GestureEventQueue(GestureEventQueueClient* client)
+    : client_(client),
+      packet_sender_(base::Bind(&GestureEventQueue::SendPacket,
+                                base::Unretained(this))),
+      outstanding_tap_(false),
+      outstanding_fling_(false) {
+  DCHECK(client_);
+}
+
+GestureEventQueue::~GestureEventQueue() {}
+
+void GestureEventQueue::OnGestureEventPacket(const GestureEventPacket& packet) {
+  switch (packet.gesture_source()) {
+    case GestureEventPacket::TOUCH_BEGIN:
+      sequences_.push_back(GestureSequence());
+      break;
+
+    case GestureEventPacket::TOUCH:
+      break;
+
+    case GestureEventPacket::TOUCH_TIMEOUT:
+      // Handle the timeout packet immediately if the packet preceding the
+      // timeout has already been dispatched.
+      if (Tail().IsEmpty()) {
+        if (!Tail().IsGesturePrevented())
+          SendPacket(packet);
+        return;
+      }
+      break;
+
+    case GestureEventPacket::SYNTHETIC:

[tdresser, 2014/01/23 16:32:43]

If this is only for things like WebView's zoom controls, do we care about out of
order dispatch? I think it might be safe to always dispatch events like that
immediately. (Sorry I've been switching back and forth on this). Are there any
synthetic events which would cause issues if they were dispatched out of order?

[jdduke (slow), 2014/01/23 22:52:34]

Honestly I have no idea.  I don't think it hurts to dispatch them in-order, but
there are probably scenarios under both approaches that could confuse the
gesture stream.  I just don't know if any of them happen in practice.

+      // Handle the synthetic packet immediately if no other packets pending.
+      if (sequences_.empty() || Tail().IsEmpty()) {
+        SendPacket(packet);
+        return;
+      }
+      // Otherwise, queue the packet and process it in-order, irrespective
+      // of the touch sequence disposition.
+      break;
+  }
+
+  Tail().Push(packet);
+}
+
+void GestureEventQueue::OnTouchEventAck(InputEventAckState ack_state) {

[tdresser, 2014/01/23 16:32:43]

A DCHECK(!sequences.empty()) might be good here.

[jdduke (slow), 2014/01/23 22:52:34]

Sure. The |Head()| call performs that check, but I can be more explicit if you
like, same below, your call.

[tdresser, 2014/01/24 13:47:30]

Oh, good point. In that case I have no strong feeling either way.

+  if (Head().IsEmpty()) {
+    CancelTapIfNecessary();
+    CancelFlingIfNecessary();
+    sequences_.pop_front();
+  }
+

[tdresser, 2014/01/23 16:32:43]

A DCHECK(!sequences.empty()) might be good here too.

[jdduke (slow), 2014/01/24 05:34:40]

Done.

+  Head().OnTouchEventAck(ack_state, packet_sender_);
+
+  // Immediately cancel a TapDown if TouchStart went unconsumed, but a
+  // subsequent TouchMove is consumed.
+  if (Head().IsGesturePrevented())
+    CancelTapIfNecessary();
+}
+
+void GestureEventQueue::SendPacket(const GestureEventPacket& packet) {
+  for (size_t i = 0; i < packet.gesture_count(); ++i)
+    SendGesture(packet.gesture(i));
+}
+
+void GestureEventQueue::SendGesture(const WebGestureEvent& event) {
+  switch (event.type) {
+    case WebInputEvent::GestureScrollBegin:
+    case WebInputEvent::GestureLongTap:
+      CancelTapIfNecessary();
+      break;
+    case WebInputEvent::GestureTapDown:
+      outstanding_tap_ = true;
+      break;
+    case WebInputEvent::GestureTapCancel:
+    case WebInputEvent::GestureTap:
+    case WebInputEvent::GestureTapUnconfirmed:
+    case WebInputEvent::GestureDoubleTap:
+      outstanding_tap_ = false;
+      break;
+    case WebInputEvent::GestureFlingStart:
+      CancelFlingIfNecessary();
+      outstanding_fling_ = true;
+      break;
+    case WebInputEvent::GestureFlingCancel:
+      outstanding_fling_ = false;
+      break;
+    default:
+      break;
+  }
+  client_->ForwardGestureEvent(event);
+}
+
+void GestureEventQueue::CancelTapIfNecessary() {
+  if (!outstanding_tap_)
+    return;
+
+  SendGesture(CreateGesture(WebInputEvent::GestureTapCancel));
+  DCHECK(!outstanding_tap_);
+}
+
+void GestureEventQueue::CancelFlingIfNecessary() {
+  if (!outstanding_fling_)
+    return;
+
+  SendGesture(CreateGesture(WebInputEvent::GestureFlingCancel));
+  DCHECK(!outstanding_fling_);
+}
+
+GestureEventQueue::GestureSequence& GestureEventQueue::Head() {
+  DCHECK(!sequences_.empty());
+  return sequences_.front();
+}
+
+GestureEventQueue::GestureSequence& GestureEventQueue::Tail() {
+  DCHECK(!sequences_.empty());
+  return sequences_.back();
+}
+
+

[tdresser, 2014/01/23 16:32:43]

Perhaps a comment separating GestureEventQueue methods from
GestureEventQueue::GestureSequence methods?

[jdduke (slow), 2014/01/23 22:52:34]

Done.

+GestureEventQueue::GestureSequence::GestureSequence()
+    : state_(PENDING) {}
+
+GestureEventQueue::GestureSequence::~GestureSequence() {}
+
+void GestureEventQueue::GestureSequence::Push(
+    const GestureEventPacket& packet) {
+  if (packet.gesture_source() == GestureEventPacket::TOUCH_TIMEOUT ||
+      packet.gesture_source() == GestureEventPacket::SYNTHETIC) {
+    // Timeout-derived gestures should have been forwarded or dropped
+    // immediately if the sequence was empty.
+    DCHECK(!IsEmpty());
+  }
+  sequence_.push_back(packet);
+}
+
+void GestureEventQueue::GestureSequence::OnTouchEventAck(
+    InputEventAckState ack_state,
+    const PacketSender& packet_sender) {
+  DCHECK_NE(INPUT_EVENT_ACK_STATE_UNKNOWN, ack_state);
+
+  if (state_ == PENDING || state_ == ALLOWED) {
+    // |NO_CONSUMER| should only be effective when the *first* touch is ack'ed.

[tdresser, 2014/01/23 16:32:43]

If we get an INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, shouldn't all future acks
in the sequence be INPUT_EVENT_ACK_STATE_NOT_CONSUMED?

[jdduke (slow), 2014/01/23 22:52:34]

If the primary pointer press was NOT_CONSUMED, but remains stationary and the
secondary pointer press is NO_CONSUMER, there's still the possibility that the
primary pointer will then move and be CONSUMED. This was first reported in
crbug/135102.

[tdresser, 2014/01/24 13:47:30]

That's unfortunate. Looks good then.

+    if (state_ == PENDING &&
+        ack_state == INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS)
+      state_ = ALWAYS_ALLOWED;
+    else if (ack_state == INPUT_EVENT_ACK_STATE_CONSUMED)
+      state_ = ALWAYS_PREVENTED;
+    else
+      state_ = ALLOWED;
+  }
+
+  bool packet_for_current_ack_handled = false;
+  while (!IsEmpty()) {
+    const GestureEventPacket& packet = sequence_.front();
+
+    switch (packet.gesture_source()) {
+      case GestureEventPacket::TOUCH_BEGIN:
+      case GestureEventPacket::TOUCH:
+        // We should handle at most one packet corresponding to a given ack.
+        if (packet_for_current_ack_handled)
+          return;
+        packet_for_current_ack_handled = true;
+
+        if (!IsGesturePrevented())
+          packet_sender.Run(packet);
+        break;
+
+      case GestureEventPacket::TOUCH_TIMEOUT:
+        if (!IsGesturePrevented())
+          packet_sender.Run(packet);
+        break;
+
+      case GestureEventPacket::SYNTHETIC:
+        // Synthetic gestures should be dispatched regardless of the touch
+        // sequence disposition.
+        packet_sender.Run(packet);
+        break;
+    };
+
+    sequence_.pop_front();
+  }
+  DCHECK(packet_for_current_ack_handled);
+}
+
+bool GestureEventQueue::GestureSequence::IsGesturePrevented() const {
+  return state_ == ALWAYS_PREVENTED;
+}
+
+bool GestureEventQueue::GestureSequence::IsEmpty() const {
+  return sequence_.empty();
+}
+
+}  // namespace content