Add a passthrough touch event queue.

content/browser/renderer_host/input/passthrough_touch_event_queue.h

Index: content/browser/renderer_host/input/passthrough_touch_event_queue.h
diff --git a/content/browser/renderer_host/input/passthrough_touch_event_queue.h b/content/browser/renderer_host/input/passthrough_touch_event_queue.h
new file mode 100644
index 0000000000000000000000000000000000000000..598e9b86632fd56fb5fe4f2764df083a0f86e5de
--- /dev/null
+++ b/content/browser/renderer_host/input/passthrough_touch_event_queue.h
@@ -0,0 +1,137 @@
+// Copyright 2017 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_PASSTHROUGH_TOUCH_EVENT_QUEUE_H_
+#define CONTENT_BROWSER_RENDERER_HOST_INPUT_PASSTHROUGH_TOUCH_EVENT_QUEUE_H_
+
+#include "content/browser/renderer_host/input/touch_event_queue.h"
+
+#include <set>
+
+namespace content {
+
+class TouchTimeoutHandler;
+
+// A queue that processes a touch-event and forwards it on to the
+// renderer process immediately. This class assumes that queueing will
+// happen inside the renderer process. This class will hold onto the pending
+// events so that it can re-order the acks so that they appear in a
+// logical order to the rest of the browser process. Due to the threaded
+// model of the renderer it is possible that an ack for a touchend can
+// be sent before the corresponding ack for the touchstart. This class
+// corrects that state.
+class CONTENT_EXPORT PassthroughTouchEventQueue : public TouchEventQueue {
+ public:
+  PassthroughTouchEventQueue(TouchEventQueueClient* client,
+                             const Config& config);
+
+  ~PassthroughTouchEventQueue() override;
+
+  // TouchEventQueue overrides.
+  void QueueEvent(const TouchEventWithLatencyInfo& event) override;
+
+  void PrependTouchScrollNotification() override;
+
+  void ProcessTouchAck(InputEventAckState ack_result,
+                       const ui::LatencyInfo& latency_info,
+                       const uint32_t unique_touch_event_id) override;
+  void OnGestureScrollEvent(
+      const GestureEventWithLatencyInfo& gesture_event) override;
+
+  void OnGestureEventAck(const GestureEventWithLatencyInfo& event,
+                         InputEventAckState ack_result) override;
+
+  void OnHasTouchEventHandlers(bool has_handlers) override;
+
+  bool IsPendingAckTouchStart() const override;
+
+  void SetAckTimeoutEnabled(bool enabled) override;
+
+  void SetIsMobileOptimizedSite(bool mobile_optimized_site) override;
+
+  bool IsAckTimeoutEnabled() const override;
+
+  bool Empty() const override;
+
+ protected:
+  void SendTouchCancelEventForTouchEvent(
+      const TouchEventWithLatencyInfo& event_to_cancel) override;
+  void UpdateTouchConsumerStates(const blink::WebTouchEvent& event,
+                                 InputEventAckState ack_result) override;
+  // Empties the queue of touch events. This may result in any number of gesture
+  // events being sent to the renderer.
+  void FlushQueue() override;
+
+ private:
+  friend class PassthroughTouchEventQueueTest;
+
+  class TouchEventWithLatencyInfoAndAckState
+      : public TouchEventWithLatencyInfo {
+   public:
+    TouchEventWithLatencyInfoAndAckState(const TouchEventWithLatencyInfo&);
+    bool operator<(const TouchEventWithLatencyInfoAndAckState&) const;
+    InputEventAckState ack_state() const { return ack_state_; }
+    void set_ack_state(InputEventAckState state) { ack_state_ = state; }
+
+   private:
+    InputEventAckState ack_state_;
+  };
+
+  enum PreFilterResult {
+    ACK_WITH_NO_CONSUMER_EXISTS,
+    ACK_WITH_NOT_CONSUMED,
+    FORWARD_TO_RENDERER,
+  };
+  // Filter touches prior to forwarding to the renderer, e.g., if the renderer
+  // has no touch handler.
+  PreFilterResult FilterBeforeForwarding(const blink::WebTouchEvent& event);
+
+  void AckTouchEventToClient(const TouchEventWithLatencyInfo& acked_event,
+                             InputEventAckState ack_result);
+
+  void SendTouchEventImmediately(TouchEventWithLatencyInfo* touch,
+                                 bool wait_for_ack);
+
+  void AckCompletedEvents();
+
+  bool IsTimeoutRunningForTesting() const;
+  const TouchEventWithLatencyInfo& GetLatestEventForTesting() const;
+  size_t SizeForTesting() const;
+
+  // Handles touch event forwarding and ack'ed event dispatch.
+  TouchEventQueueClient* client_;
+
+  // Whether the renderer has at least one touch handler.
+  bool has_handlers_;
+
+  // Whether any pointer in the touch sequence may have having a consumer.
+  bool maybe_has_handler_for_current_sequence_;
+
+  // Whether to allow any remaining touches for the current sequence. Note that
+  // this is a stricter condition than an empty |touch_consumer_states_|, as it
+  // also prevents forwarding of touchstart events for new pointers in the
+  // current sequence. This is only used when the event is synthetically
+  // cancelled after a touch timeout.
+  bool drop_remaining_touches_in_sequence_;
+
+  // Optional handler for timed-out touch event acks.
+  std::unique_ptr<TouchTimeoutHandler> timeout_handler_;
+
+  // Whether touch events should be sent as uncancelable or not.
+  bool send_touch_events_async_;
+
+  // Event is saved to compare pointer positions for new touchmove events.
+  std::unique_ptr<blink::WebTouchEvent> last_sent_touchevent_;
+
+  // Stores outstanding touches that have been sent to the renderer but have
+  // not yet been ack'd by the renderer. The set is explicitly ordered based
+  // on the unique touch event id.
+  std::set<TouchEventWithLatencyInfoAndAckState> outstanding_touches_;
+
+  DISALLOW_COPY_AND_ASSIGN(PassthroughTouchEventQueue);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_PASSTHROUGH_TOUCH_EVENT_QUEUE_H_