Coalesce async touch move events until the ack back from render.

In order to avoid the touch event queue keep growing when render handles
async touchmove events longer than 200ms, which is the async touchmove
interval, we keep coalesce touch moves and send the next touchmove
until passing the async touchmove interval and receive the ACK from render.

BUG=448760

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

Cr-Commit-Position: refs/heads/master@{#330548}

content/browser/renderer_host/input/input_router_impl.cc

@@ -358,19 +358,22 @@ void InputRouterImpl::OfferToHandlers(const WebInputEvent& input_event,
   OfferToRenderer(input_event, latency_info, is_keyboard_shortcut);
 
   // Touch events should always indicate in the event whether they are
-  // cancelable (respect ACK disposition) or not.
-  bool ignores_ack = WebInputEventTraits::IgnoresAckDisposition(input_event);
-  if (WebInputEvent::isTouchEventType(input_event.type)) {
+  // cancelable (respect ACK disposition) or not except touchmove.
+  bool needs_synthetic_ack =
+      !WebInputEventTraits::WillReceiveAckFromRenderer(input_event);
+
+  if (WebInputEvent::isTouchEventType(input_event.type) &&
+      input_event.type != WebInputEvent::TouchMove) {
     const WebTouchEvent& touch = static_cast<const WebTouchEvent&>(input_event);
-    DCHECK_NE(ignores_ack, !!touch.cancelable);
+    DCHECK_EQ(needs_synthetic_ack, !touch.cancelable);
   }
 
-  // If we don't care about the ack disposition, send the ack immediately.
-  if (ignores_ack) {
-    ProcessInputEventAck(input_event.type,
-                         INPUT_EVENT_ACK_STATE_IGNORED,
-                         latency_info,
-                         IGNORING_DISPOSITION);
+  // The synthetic acks are sent immediately.
+  if (needs_synthetic_ack) {
+    ProcessInputEventAck(
+        input_event.type, INPUT_EVENT_ACK_STATE_IGNORED, latency_info,
+        WebInputEventTraits::GetUniqueTouchEventId(input_event),
+        IGNORING_DISPOSITION);
   }
 }
 
@@ -385,7 +388,9 @@ bool InputRouterImpl::OfferToClient(const WebInputEvent& input_event,
     case INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS:
       // Send the ACK and early exit.
       next_mouse_move_.reset();
-      ProcessInputEventAck(input_event.type, filter_ack, latency_info, CLIENT);
+      ProcessInputEventAck(
+          input_event.type, filter_ack, latency_info,
+          WebInputEventTraits::GetUniqueTouchEventId(input_event), CLIENT);
       // WARNING: |this| may be deleted at this point.
       consumed = true;
       break;
@@ -408,7 +413,7 @@ bool InputRouterImpl::OfferToRenderer(const WebInputEvent& input_event,
     // Ack messages for ignored ack event types should never be sent by the
     // renderer. Consequently, such event types should not affect event time
     // or in-flight event count metrics.
-    if (!WebInputEventTraits::IgnoresAckDisposition(input_event)) {
+    if (WebInputEventTraits::WillReceiveAckFromRenderer(input_event)) {
       input_event_start_time_ = TimeTicks::Now();
       client_->IncrementInFlightEventCount();
     }
@@ -417,10 +422,8 @@ bool InputRouterImpl::OfferToRenderer(const WebInputEvent& input_event,
   return false;
 }
 
-void InputRouterImpl::OnInputEventAck(
-    const InputHostMsg_HandleInputEvent_ACK_Params& ack) {
+void InputRouterImpl::OnInputEventAck(const InputEventAck& ack) {
   client_->DecrementInFlightEventCount();
-
   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
   UMA_HISTOGRAM_TIMES("MPArch.IIR_InputEventDelta", delta);
@@ -431,21 +434,8 @@ void InputRouterImpl::OnInputEventAck(
     OnDidOverscroll(*ack.overscroll);
   }
 
-  ProcessInputEventAck(ack.type, ack.state, ack.latency, RENDERER);
-  // WARNING: |this| may be deleted at this point.
-
-  // This is used only for testing, and the other end does not use the
-  // source object.  On linux, specifying
-  // Source<RenderWidgetHost> results in a very strange
-  // runtime error in the epilogue of the enclosing
-  // (ProcessInputEventAck) method, but not on other platforms; using
-  // 'void' instead is just as safe (since NotificationSource
-  // is not actually typesafe) and avoids this error.
-  int type = static_cast<int>(ack.type);
-  NotificationService::current()->Notify(
-      NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
-      Source<void>(this),
-      Details<int>(&type));
+  ProcessInputEventAck(ack.type, ack.state, ack.latency,
+                       ack.unique_touch_event_id, RENDERER);
 }
 
 void InputRouterImpl::OnDidOverscroll(const DidOverscrollParams& params) {
@@ -509,11 +499,11 @@ void InputRouterImpl::OnDidStopFlinging() {
   client_->DidStopFlinging();
 }
 
-void InputRouterImpl::ProcessInputEventAck(
-    WebInputEvent::Type event_type,
-    InputEventAckState ack_result,
-    const ui::LatencyInfo& latency_info,
-    AckSource ack_source) {
+void InputRouterImpl::ProcessInputEventAck(WebInputEvent::Type event_type,
+                                           InputEventAckState ack_result,
+                                           const ui::LatencyInfo& latency_info,
+                                           uint32 unique_touch_event_id,
+                                           AckSource ack_source) {
   TRACE_EVENT2("input", "InputRouterImpl::ProcessInputEventAck",
                "type", WebInputEventTraits::GetName(event_type),
                "ack", GetEventAckName(ack_result));
@@ -535,7 +525,7 @@ void InputRouterImpl::ProcessInputEventAck(
   } else if (event_type == WebInputEvent::MouseWheel) {
     ProcessWheelAck(ack_result, latency_info);
   } else if (WebInputEvent::isTouchEventType(event_type)) {
-    ProcessTouchAck(ack_result, latency_info);
+    ProcessTouchAck(ack_result, latency_info, unique_touch_event_id);
   } else if (WebInputEvent::isGestureEventType(event_type)) {
     ProcessGestureAck(event_type, ack_result, latency_info);
   } else if (event_type != WebInputEvent::Undefined) {
@@ -620,11 +610,12 @@ void InputRouterImpl::ProcessGestureAck(WebInputEvent::Type type,
   gesture_event_queue_.ProcessGestureAck(ack_result, type, latency);
 }
 
-void InputRouterImpl::ProcessTouchAck(
-    InputEventAckState ack_result,
-    const ui::LatencyInfo& latency) {
+void InputRouterImpl::ProcessTouchAck(InputEventAckState ack_result,
+                                      const ui::LatencyInfo& latency,
+                                      uint32 unique_touch_event_id) {
   // |touch_event_queue_| will forward to OnTouchEventAck when appropriate.
-  touch_event_queue_.ProcessTouchAck(ack_result, latency);
+  touch_event_queue_.ProcessTouchAck(ack_result, latency,
+                                     unique_touch_event_id);
 }
 
 void InputRouterImpl::UpdateTouchAckTimeoutEnabled() {

content/browser/renderer_host/input/input_router_impl.h

@@ -18,8 +18,6 @@
 #include "content/common/input/input_event_stream_validator.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 
-struct InputHostMsg_HandleInputEvent_ACK_Params;
-
 namespace IPC {
 class Sender;
 }
@@ -34,6 +32,7 @@ class InputAckHandler;
 class InputRouterClient;
 class OverscrollController;
 struct DidOverscrollParams;
+struct InputEventAck;
 
 // A default implementation for browser input event routing.
 class CONTENT_EXPORT InputRouterImpl
@@ -124,7 +123,7 @@ private:
                        bool is_keyboard_shortcut);
 
   // IPC message handlers
-  void OnInputEventAck(const InputHostMsg_HandleInputEvent_ACK_Params& ack);
+  void OnInputEventAck(const InputEventAck& ack);
   void OnDidOverscroll(const DidOverscrollParams& params);
   void OnMsgMoveCaretAck();
   void OnSelectMessageAck();
@@ -145,6 +144,7 @@ private:
   void ProcessInputEventAck(blink::WebInputEvent::Type event_type,
                             InputEventAckState ack_result,
                             const ui::LatencyInfo& latency_info,
+                            uint32 unique_touch_event_id,
                             AckSource ack_source);
 
   // Dispatches the ack'ed event to |ack_handler_|.
@@ -169,7 +169,8 @@ private:
   // Forwards the event ack to |touch_event_queue_|, potentially triggering
   // dispatch of queued touch events, or the creation of gesture events.
   void ProcessTouchAck(InputEventAckState ack_result,
-                       const ui::LatencyInfo& latency);
+                       const ui::LatencyInfo& latency,
+                       uint32 unique_touch_event_id);
 
   // Called when a touch timeout-affecting bit has changed, in turn toggling the
   // touch ack timeout feature of the |touch_event_queue_| as appropriate. Input

content/browser/renderer_host/input/input_router_impl_perftest.cc

@@ -233,11 +233,9 @@ class InputRouterImplPerfTest : public testing::Test {
 
   void SendEventAckIfNecessary(const blink::WebInputEvent& event,
                                InputEventAckState ack_result) {
-    if (WebInputEventTraits::IgnoresAckDisposition(event))
+    if (!WebInputEventTraits::WillReceiveAckFromRenderer(event))
       return;
-    InputHostMsg_HandleInputEvent_ACK_Params ack;
-    ack.type = event.type;
-    ack.state = ack_result;
+    InputEventAck ack(event.type, ack_result);
     InputHostMsg_HandleInputEvent_ACK response(0, ack);
     input_router_->OnMessageReceived(response);
   }

content/browser/renderer_host/input/touch_event_queue.cc

@@ -42,7 +42,8 @@ TouchEventWithLatencyInfo ObtainCancelEventForTouchEvent(
 bool ShouldTouchTriggerTimeout(const WebTouchEvent& event) {
   return (event.type == WebInputEvent::TouchStart ||
           event.type == WebInputEvent::TouchMove) &&
-         !WebInputEventTraits::IgnoresAckDisposition(event);
+         WebInputEventTraits::WillReceiveAckFromRenderer(event) &&
+         event.cancelable;
 }
 
 // Compare all properties of touch points to determine the state.
@@ -82,7 +83,9 @@ class TouchEventQueue::TouchTimeoutHandler {
   ~TouchTimeoutHandler() {}
 
   void StartIfNecessary(const TouchEventWithLatencyInfo& event) {
-    DCHECK_EQ(pending_ack_state_, PENDING_ACK_NONE);
+    if (pending_ack_state_ != PENDING_ACK_NONE)
+      return;
+
     if (!enabled_)
       return;
 
@@ -420,9 +423,28 @@ void TouchEventQueue::QueueEvent(const TouchEventWithLatencyInfo& event) {
 }
 
 void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result,
-                                      const LatencyInfo& latency_info) {
+                                      const LatencyInfo& latency_info,
+                                      const uint32 unique_touch_event_id) {
   TRACE_EVENT0("input", "TouchEventQueue::ProcessTouchAck");
 
+  // We receive an ack for async touchmove from render.
+  if (!ack_pending_async_touchmove_ids_.empty() &&
+      ack_pending_async_touchmove_ids_.front() == unique_touch_event_id) {
+    // Remove the first touchmove from the ack_pending_async_touchmove queue.
+    ack_pending_async_touchmove_ids_.pop_front();
+    // Send the next pending async touch move once we receive all acks back.
+    if (pending_async_touchmove_ && ack_pending_async_touchmove_ids_.empty()) {
+      DCHECK(touch_queue_.empty());
+
+      // Dispatch the next pending async touch move when time expires.
+      if (pending_async_touchmove_->event.timeStampSeconds >=
+          last_sent_touch_timestamp_sec_ + kAsyncTouchMoveIntervalSec) {
+        FlushPendingAsyncTouchmove();
+      }
+    }
+    return;
+  }
+
   DCHECK(!dispatching_touch_ack_);
   dispatching_touch_ = false;
 
@@ -434,6 +456,9 @@ void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result,
   if (touch_queue_.empty())
     return;
 
+  DCHECK_EQ(touch_queue_.front()->coalesced_event().event.uniqueTouchEventId,
+            unique_touch_event_id);
+
   PopTouchEventToClient(ack_result, latency_info);
   TryForwardNextEventToRenderer();
 }
@@ -477,8 +502,9 @@ void TouchEventQueue::ForwardNextEventToRenderer() {
     send_touchmove_now |= pending_async_touchmove_ &&
                           !pending_async_touchmove_->CanCoalesceWith(touch);
     send_touchmove_now |=
-        touch.event.timeStampSeconds >=
-        last_sent_touch_timestamp_sec_ + kAsyncTouchMoveIntervalSec;
+        ack_pending_async_touchmove_ids_.empty() &&
+        (touch.event.timeStampSeconds >=
+         last_sent_touch_timestamp_sec_ + kAsyncTouchMoveIntervalSec);
 
     if (!send_touchmove_now) {
       if (!pending_async_touchmove_) {
@@ -510,11 +536,7 @@ void TouchEventQueue::ForwardNextEventToRenderer() {
       touch = *pending_async_touchmove_;
       pending_async_touchmove_.reset();
     } else {
-      scoped_ptr<TouchEventWithLatencyInfo> async_move =
-          pending_async_touchmove_.Pass();
-      async_move->event.cancelable = false;
-      touch_queue_.push_front(new CoalescedWebTouchEvent(*async_move, true));
-      SendTouchEventImmediately(async_move.get());
+      FlushPendingAsyncTouchmove();
       return;
     }
   }
@@ -525,12 +547,15 @@ void TouchEventQueue::ForwardNextEventToRenderer() {
   if (send_touch_events_async_ && touch.event.type != WebInputEvent::TouchStart)
     touch.event.cancelable = false;
 
-  // A synchronous ack will reset |dispatching_touch_|, in which case
-  // the touch timeout should not be started.
-  base::AutoReset<bool> dispatching_touch(&dispatching_touch_, true);
   SendTouchEventImmediately(&touch);
-  if (dispatching_touch_ && timeout_handler_)
-    timeout_handler_->StartIfNecessary(touch);
+}
+
+void TouchEventQueue::FlushPendingAsyncTouchmove() {
+  DCHECK(!dispatching_touch_);
+  scoped_ptr<TouchEventWithLatencyInfo> touch = pending_async_touchmove_.Pass();
+  touch->event.cancelable = false;
+  touch_queue_.push_front(new CoalescedWebTouchEvent(*touch, true));
+  SendTouchEventImmediately(touch.get());
 }
 
 void TouchEventQueue::OnGestureScrollEvent(
@@ -670,7 +695,30 @@ void TouchEventQueue::SendTouchEventImmediately(
   else
     last_sent_touchevent_.reset(new WebTouchEvent(touch->event));
 
+  base::AutoReset<bool> dispatching_touch(&dispatching_touch_, true);
+
   client_->SendTouchEventImmediately(*touch);
+
+  // A synchronous ack will reset |dispatching_touch_|, in which case the touch
+  // timeout should not be started and the count also should not be increased.
+  if (dispatching_touch_) {
+    if (touch->event.type == WebInputEvent::TouchMove &&
+        !touch->event.cancelable) {
+      // When we send out a uncancelable touch move, we increase the count and
+      // we do not process input event ack any more, we will just ack to client
+      // and wait for the ack from render. Also we will remove it from the front
+      // of the queue.
+      ack_pending_async_touchmove_ids_.push_back(
+          touch->event.uniqueTouchEventId);
+      dispatching_touch_ = false;
+      PopTouchEventToClient(INPUT_EVENT_ACK_STATE_IGNORED);
+      TryForwardNextEventToRenderer();
+      return;
+    }
+
+    if (timeout_handler_)
+      timeout_handler_->StartIfNecessary(*touch);
+  }
 }
 
 TouchEventQueue::PreFilterResult

content/browser/renderer_host/input/touch_event_queue.h

@@ -61,10 +61,13 @@ class CONTENT_EXPORT TouchEventQueue {
   void QueueEvent(const TouchEventWithLatencyInfo& event);
 
   // Notifies the queue that a touch-event has been processed by the renderer.
-  // At this point, the queue may send one or more gesture events and/or
-  // additional queued touch-events to the renderer.
+  // At this point, if the ack is for async touchmove, remove the uncancelable
+  // touchmove from the front of the queue and decide if it should dispatch the
+  // next pending async touch move event, otherwise the queue may send one or
+  // more gesture events and/or additional queued touch-events to the renderer.
   void ProcessTouchAck(InputEventAckState ack_result,
-                       const ui::LatencyInfo& latency_info);
+                       const ui::LatencyInfo& latency_info,
+                       const uint32 unique_touch_event_id);
 
   // When GestureScrollBegin is received, we send a touch cancel to renderer,
   // route all the following touch events directly to client, and ignore the
@@ -102,6 +105,10 @@ class CONTENT_EXPORT TouchEventQueue {
 
   bool has_handlers() const { return has_handlers_; }
 
+  size_t uncancelable_touch_moves_pending_ack_count() const {
+    return ack_pending_async_touchmove_ids_.size();
+  }
+
  private:
   class TouchTimeoutHandler;
   class TouchMoveSlopSuppressor;
@@ -156,6 +163,7 @@ class CONTENT_EXPORT TouchEventQueue {
   void ForwardToRenderer(const TouchEventWithLatencyInfo& event);
   void UpdateTouchConsumerStates(const blink::WebTouchEvent& event,
                                  InputEventAckState ack_result);
+  void FlushPendingAsyncTouchmove();
 
   // Handles touch event forwarding and ack'ed event dispatch.
   TouchEventQueueClient* client_;
@@ -171,8 +179,9 @@ class CONTENT_EXPORT TouchEventQueue {
   // True within the scope of |AckTouchEventToClient()|.
   bool dispatching_touch_ack_;
 
-  // Used to prevent touch timeout scheduling if we receive a synchronous
-  // ack after forwarding a touch event to the client.
+  // Used to prevent touch timeout scheduling and increase the count for async
+  // touchmove if we receive a synchronous ack after forwarding a touch event
+  // to the client.
   bool dispatching_touch_;
 
   // Whether the renderer has at least one touch handler.
@@ -202,6 +211,17 @@ class CONTENT_EXPORT TouchEventQueue {
   // For details see the design doc at http://goo.gl/lVyJAa.
   bool send_touch_events_async_;
   scoped_ptr<TouchEventWithLatencyInfo> pending_async_touchmove_;
+
+  // For uncancelable touch moves, not only we send a fake ack, but also a real
+  // ack from render, which we use to decide when to send the next async
+  // touchmove. This can help avoid the touch event queue keep growing when
+  // render handles touchmove slow. We use a queue
+  // ack_pending_async_touchmove_ids to store the recent dispatched
+  // uncancelable touchmoves which are still waiting for their acks back from
+  // render. We do not put them back to the front the touch_event_queue any
+  // more.
+  std::deque<uint32> ack_pending_async_touchmove_ids_;
+
   double last_sent_touch_timestamp_sec_;
 
   // Event is saved to compare pointer positions for new touchmove events.

content/browser/renderer_host/render_widget_host_unittest.cc

@@ -466,9 +466,8 @@ class RenderWidgetHostTest : public testing::Test {
 
   void SendInputEventACK(WebInputEvent::Type type,
                          InputEventAckState ack_result) {
-    InputHostMsg_HandleInputEvent_ACK_Params ack;
-    ack.type = type;
-    ack.state = ack_result;
+    DCHECK(!WebInputEvent::isTouchEventType(type));
+    InputEventAck ack(type, ack_result);
     host_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack));
   }
 
@@ -551,10 +550,12 @@ class RenderWidgetHostTest : public testing::Test {
 
   // Sends a touch event (irrespective of whether the page has a touch-event
   // handler or not).
-  void SendTouchEvent() {
+  uint32 SendTouchEvent() {
+    uint32 touch_event_id = touch_event_.uniqueTouchEventId;
     host_->ForwardTouchEventWithLatencyInfo(touch_event_, ui::LatencyInfo());
 
     touch_event_.ResetPoints();
+    return touch_event_id;
   }
 
   int PressTouchPoint(int x, int y) {
@@ -1482,10 +1483,12 @@ TEST_F(RenderWidgetHostTest, InputEventRWHLatencyComponent) {
 
   // Tests RWHI::ForwardTouchEventWithLatencyInfo().
   PressTouchPoint(0, 1);
-  SendTouchEvent();
+  uint32 touch_event_id = SendTouchEvent();
+  InputEventAck ack(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED,
+                    touch_event_id);
+  host_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack));
   CheckLatencyInfoComponentInMessage(
       process_, GetLatencyComponentId(), WebInputEvent::TouchStart);
-  SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
 }
 
 TEST_F(RenderWidgetHostTest, RendererExitedResetsInputRouter) {

content/browser/renderer_host/render_widget_host_view_aura_unittest.cc

@@ -445,9 +445,17 @@ class RenderWidgetHostViewAuraTest : public testing::Test {
 
   void SendInputEventACK(WebInputEvent::Type type,
       InputEventAckState ack_result) {
-    InputHostMsg_HandleInputEvent_ACK_Params ack;
-    ack.type = type;
-    ack.state = ack_result;
+    DCHECK(!WebInputEvent::isTouchEventType(type));
+    InputEventAck ack(type, ack_result);
+    InputHostMsg_HandleInputEvent_ACK response(0, ack);
+    widget_host_->OnMessageReceived(response);
+  }
+
+  void SendTouchEventACK(WebInputEvent::Type type,
+                         InputEventAckState ack_result,
+                         uint32 event_id) {
+    DCHECK(WebInputEvent::isTouchEventType(type));
+    InputEventAck ack(type, ack_result, event_id);
     InputHostMsg_HandleInputEvent_ACK response(0, ack);
     widget_host_->OnMessageReceived(response);
   }
@@ -468,10 +476,12 @@ class RenderWidgetHostViewAuraTest : public testing::Test {
       return;
     }
 
-    if (WebInputEventTraits::IgnoresAckDisposition(*get<0>(params)))
+    if (!WebInputEventTraits::WillReceiveAckFromRenderer(*get<0>(params)))
       return;
 
-    SendInputEventACK(get<0>(params)->type, ack_result);
+    const blink::WebInputEvent* event = get<0>(params);
+    SendTouchEventACK(event->type, ack_result,
+        WebInputEventTraits::GetUniqueTouchEventId(*event));
   }
 
  protected:
@@ -698,25 +708,24 @@ class RenderWidgetHostViewAuraOverscrollTest
     return overscroll_delegate_.get();
   }
 
-  void SendTouchEvent() {
+  uint32 SendTouchEvent() {
+    uint32 touch_event_id = touch_event_.uniqueTouchEventId;
     widget_host_->ForwardTouchEventWithLatencyInfo(touch_event_,
                                                    ui::LatencyInfo());
     touch_event_.ResetPoints();
+    return touch_event_id;
   }
 
   void PressTouchPoint(int x, int y) {
     touch_event_.PressPoint(x, y);
-    SendTouchEvent();
   }
 
   void MoveTouchPoint(int index, int x, int y) {
     touch_event_.MovePoint(index, x, y);
-    SendTouchEvent();
   }
 
   void ReleaseTouchPoint(int index) {
     touch_event_.ReleasePoint(index);
-    SendTouchEvent();
   }
 
   SyntheticWebTouchEvent touch_event_;
@@ -1104,9 +1113,9 @@ TEST_F(RenderWidgetHostViewAuraTest, TouchEventState) {
   widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, false));
 
   // Ack'ing the outstanding event should flush the pending touch queue.
-  InputHostMsg_HandleInputEvent_ACK_Params ack;
-  ack.type = blink::WebInputEvent::TouchStart;
-  ack.state = INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
+  InputEventAck ack(blink::WebInputEvent::TouchStart,
+                    INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS,
+                    press.unique_event_id());
   widget_host_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack));
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 
@@ -1138,8 +1147,9 @@ TEST_F(RenderWidgetHostViewAuraTest, MultiTouchPointsStates) {
                         ui::EventTimeForNow());
 
   view_->OnTouchEvent(&press0);
-  SendInputEventACK(blink::WebInputEvent::TouchStart,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(blink::WebInputEvent::TouchStart,
+                    INPUT_EVENT_ACK_STATE_CONSUMED,
+                    press0.unique_event_id());
   EXPECT_EQ(blink::WebInputEvent::TouchStart, view_->touch_event_->type);
   EXPECT_EQ(1U, view_->touch_event_->touchesLength);
   EXPECT_EQ(1U, view_->dispatcher_->GetAndResetProcessedTouchEventCount());
@@ -1148,8 +1158,9 @@ TEST_F(RenderWidgetHostViewAuraTest, MultiTouchPointsStates) {
                        ui::EventTimeForNow());
 
   view_->OnTouchEvent(&move0);
-  SendInputEventACK(blink::WebInputEvent::TouchMove,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(blink::WebInputEvent::TouchMove,
+                    INPUT_EVENT_ACK_STATE_CONSUMED,
+                    move0.unique_event_id());
   EXPECT_EQ(blink::WebInputEvent::TouchMove, view_->touch_event_->type);
   EXPECT_EQ(1U, view_->touch_event_->touchesLength);
   EXPECT_EQ(1U, view_->dispatcher_->GetAndResetProcessedTouchEventCount());
@@ -1160,8 +1171,9 @@ TEST_F(RenderWidgetHostViewAuraTest, MultiTouchPointsStates) {
                         ui::EventTimeForNow());
 
   view_->OnTouchEvent(&press1);
-  SendInputEventACK(blink::WebInputEvent::TouchStart,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(blink::WebInputEvent::TouchStart,
+                    INPUT_EVENT_ACK_STATE_CONSUMED,
+                    press1.unique_event_id());
   EXPECT_EQ(blink::WebInputEvent::TouchStart, view_->touch_event_->type);
   EXPECT_EQ(2U, view_->touch_event_->touchesLength);
   EXPECT_EQ(1U, view_->dispatcher_->GetAndResetProcessedTouchEventCount());
@@ -1172,8 +1184,9 @@ TEST_F(RenderWidgetHostViewAuraTest, MultiTouchPointsStates) {
                        ui::EventTimeForNow());
 
   view_->OnTouchEvent(&move1);
-  SendInputEventACK(blink::WebInputEvent::TouchMove,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(blink::WebInputEvent::TouchMove,
+                    INPUT_EVENT_ACK_STATE_CONSUMED,
+                    move1.unique_event_id());
   EXPECT_EQ(blink::WebInputEvent::TouchMove, view_->touch_event_->type);
   EXPECT_EQ(2U, view_->touch_event_->touchesLength);
   EXPECT_EQ(1U, view_->dispatcher_->GetAndResetProcessedTouchEventCount());
@@ -1184,8 +1197,9 @@ TEST_F(RenderWidgetHostViewAuraTest, MultiTouchPointsStates) {
                        ui::EventTimeForNow());
 
   view_->OnTouchEvent(&move2);
-  SendInputEventACK(blink::WebInputEvent::TouchMove,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(blink::WebInputEvent::TouchMove,
+                    INPUT_EVENT_ACK_STATE_CONSUMED,
+                    move2.unique_event_id());
   EXPECT_EQ(blink::WebInputEvent::TouchMove, view_->touch_event_->type);
   EXPECT_EQ(2U, view_->touch_event_->touchesLength);
   EXPECT_EQ(1U, view_->dispatcher_->GetAndResetProcessedTouchEventCount());
@@ -2868,14 +2882,16 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollWithTouchEvents) {
 
   // The test sends an intermingled sequence of touch and gesture events.
   PressTouchPoint(0, 1);
-  SendInputEventACK(WebInputEvent::TouchStart,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  uint32 touch_press_event_id1 = SendTouchEvent();
+  SendTouchEventACK(WebInputEvent::TouchStart,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED, touch_press_event_id1);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   MoveTouchPoint(0, 20, 5);
+  uint32 touch_move_event_id1 = SendTouchEvent();
+  SendTouchEventACK(WebInputEvent::TouchMove,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED, touch_move_event_id1);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
-  SendInputEventACK(WebInputEvent::TouchMove,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
@@ -2894,6 +2910,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollWithTouchEvents) {
   // started yet.  Note that touch events sent during the scroll period may
   // not require an ack (having been marked uncancelable).
   MoveTouchPoint(0, 65, 10);
+  SendTouchEvent();
   AckLastSentInputEventIfNecessary(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
@@ -2910,6 +2927,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollWithTouchEvents) {
   // Send another touch event. The page should get the touch-move event, even
   // though overscroll has started.
   MoveTouchPoint(0, 55, 5);
+  SendTouchEvent();
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode());
   EXPECT_EQ(65.f, overscroll_delta_x());
@@ -2927,6 +2945,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollWithTouchEvents) {
   EXPECT_EQ(0.f, overscroll_delegate()->delta_y());
 
   PressTouchPoint(255, 5);
+  SendTouchEvent();
   AckLastSentInputEventIfNecessary(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
@@ -2941,9 +2960,11 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollWithTouchEvents) {
   // The touch-end/cancel event should always reach the renderer if the page has
   // touch handlers.
   ReleaseTouchPoint(1);
+  SendTouchEvent();
   AckLastSentInputEventIfNecessary(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   ReleaseTouchPoint(0);
+  SendTouchEvent();
   AckLastSentInputEventIfNecessary(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
@@ -3400,14 +3421,14 @@ TEST_F(RenderWidgetHostViewAuraTest, CorrectNumberOfAcksAreDispatched) {
       ui::ET_TOUCH_PRESSED, gfx::Point(30, 30), 0, ui::EventTimeForNow());
 
   view_->OnTouchEvent(&press1);
-  SendInputEventACK(blink::WebInputEvent::TouchStart,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(blink::WebInputEvent::TouchStart,
+                    INPUT_EVENT_ACK_STATE_CONSUMED, press1.unique_event_id());
 
   ui::TouchEvent press2(
       ui::ET_TOUCH_PRESSED, gfx::Point(20, 20), 1, ui::EventTimeForNow());
   view_->OnTouchEvent(&press2);
-  SendInputEventACK(blink::WebInputEvent::TouchStart,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(blink::WebInputEvent::TouchStart,
+                    INPUT_EVENT_ACK_STATE_CONSUMED, press2.unique_event_id());
 
   EXPECT_EQ(2U, view_->dispatcher_->GetAndResetProcessedTouchEventCount());
 }

content/browser/renderer_host/render_widget_host_view_mac_unittest.mm

@@ -711,9 +711,8 @@ TEST_F(RenderWidgetHostViewMacTest, ScrollWheelEndEventDelivery) {
   ASSERT_EQ(1U, process_host->sink().message_count());
 
   // Send an ACK for the first wheel event, so that the queue will be flushed.
-  InputHostMsg_HandleInputEvent_ACK_Params ack;
-  ack.type = blink::WebInputEvent::MouseWheel;
-  ack.state = INPUT_EVENT_ACK_STATE_CONSUMED;
+  InputEventAck ack(blink::WebInputEvent::MouseWheel,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
   scoped_ptr<IPC::Message> response(
       new InputHostMsg_HandleInputEvent_ACK(0, ack));
   host->OnMessageReceived(*response);
@@ -757,9 +756,8 @@ TEST_F(RenderWidgetHostViewMacTest, IgnoreEmptyUnhandledWheelEvent) {
   process_host->sink().ClearMessages();
 
   // Indicate that the wheel event was unhandled.
-  InputHostMsg_HandleInputEvent_ACK_Params unhandled_ack;
-  unhandled_ack.type = blink::WebInputEvent::MouseWheel;
-  unhandled_ack.state = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
+  InputEventAck unhandled_ack(blink::WebInputEvent::MouseWheel,
+                              INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   scoped_ptr<IPC::Message> response1(
       new InputHostMsg_HandleInputEvent_ACK(0, unhandled_ack));
   host->OnMessageReceived(*response1);
@@ -914,9 +912,8 @@ TEST_F(RenderWidgetHostViewMacPinchTest, PinchThresholding) {
   RenderWidgetHostViewMac* view = new RenderWidgetHostViewMac(host, false);
 
   // We'll use this IPC message to ack events.
-  InputHostMsg_HandleInputEvent_ACK_Params ack;
-  ack.type = blink::WebInputEvent::GesturePinchUpdate;
-  ack.state = INPUT_EVENT_ACK_STATE_CONSUMED;
+  InputEventAck ack(blink::WebInputEvent::GesturePinchUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
   scoped_ptr<IPC::Message> response(
       new InputHostMsg_HandleInputEvent_ACK(0, ack));
 

content/common/input/input_event_ack.cc

+// Copyright 2015 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/common/input/input_event_ack.h"
+
+namespace content {
+
+InputEventAck::InputEventAck(
+    blink::WebInputEvent::Type type,
+    InputEventAckState state,
+    const ui::LatencyInfo& latency,
+    scoped_ptr<content::DidOverscrollParams> overscroll,
+    uint32 unique_touch_event_id)
+    : type(type),
+      state(state),
+      latency(latency),
+      overscroll(overscroll.Pass()),
+      unique_touch_event_id(unique_touch_event_id) {
+}
+
+InputEventAck::InputEventAck(blink::WebInputEvent::Type type,
+                             InputEventAckState state,
+                             const ui::LatencyInfo& latency,
+                             uint32 unique_touch_event_id)
+    : InputEventAck(type, state, latency, nullptr, unique_touch_event_id) {
+}
+
+InputEventAck::InputEventAck(blink::WebInputEvent::Type type,
+                             InputEventAckState state,
+                             uint32 unique_touch_event_id)
+    : InputEventAck(type, state, ui::LatencyInfo(), unique_touch_event_id) {
+}
+
+InputEventAck::InputEventAck(blink::WebInputEvent::Type type,
+                             InputEventAckState state)
+    : InputEventAck(type, state, 0) {
+}
+
+InputEventAck::InputEventAck()
+    : InputEventAck(blink::WebInputEvent::Undefined,
+                    INPUT_EVENT_ACK_STATE_UNKNOWN) {
+}
+
+InputEventAck::~InputEventAck() {
+}
+
+}  // namespace content

content/common/input/input_event_ack.h

+// Copyright 2015 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_COMMON_INPUT_INPUT_EVENT_ACK_H_
+#define CONTENT_COMMON_INPUT_INPUT_EVENT_ACK_H_
+
+#include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
+#include "content/common/content_export.h"
+#include "content/common/input/did_overscroll_params.h"
+#include "content/common/input/input_event_ack_state.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "ui/events/latency_info.h"
+
+namespace content {
+
+// InputEventAck.
+struct CONTENT_EXPORT InputEventAck {
+  InputEventAck(blink::WebInputEvent::Type type,
+                InputEventAckState state,
+                const ui::LatencyInfo& latency,
+                scoped_ptr<content::DidOverscrollParams> overscroll,
+                uint32 unique_touch_event_id);
+  InputEventAck(blink::WebInputEvent::Type type,
+                InputEventAckState state,
+                const ui::LatencyInfo& latency,
+                uint32 unique_touch_event_id);
+  InputEventAck(blink::WebInputEvent::Type type,
+                InputEventAckState state,
+                uint32 unique_touch_event_id);
+  InputEventAck(blink::WebInputEvent::Type type, InputEventAckState state);
+  InputEventAck();
+  ~InputEventAck();
+
+  blink::WebInputEvent::Type type;
+  InputEventAckState state;
+  ui::LatencyInfo latency;
+  scoped_ptr<content::DidOverscrollParams> overscroll;
+  uint32 unique_touch_event_id;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_COMMON_INPUT_INPUT_EVENT_ACK_H_

content/common/input/synthetic_web_input_event_builders.cc

@@ -168,6 +168,7 @@ void SyntheticWebTouchEvent::ResetPoints() {
   touchesLength = point;
   type = WebInputEvent::Undefined;
   causesScrollingIfUncanceled = false;
+  uniqueTouchEventId = ui::GetNextTouchEventId();
 }
 
 int SyntheticWebTouchEvent::PressPoint(float x, float y) {

content/common/input/web_input_event_traits.cc

@@ -110,10 +110,8 @@ void ApppendEventDetails(const WebTouchEvent& event, std::string* result) {
   StringAppendF(result,
                 "{\n Touches: %u, Cancelable: %d, CausesScrolling: %d,"
                 " uniqueTouchEventId: %u\n[\n",
-                event.touchesLength,
-                event.cancelable,
-                event.causesScrollingIfUncanceled,
-                static_cast<uint32>(event.uniqueTouchEventId));
+                event.touchesLength, event.cancelable,
+                event.causesScrollingIfUncanceled, event.uniqueTouchEventId);
   for (unsigned i = 0; i < event.touchesLength; ++i)
     ApppendTouchPointDetails(event.touches[i], result);
   result->append(" ]\n}");
@@ -463,7 +461,8 @@ void WebInputEventTraits::Coalesce(const WebInputEvent& event_to_coalesce,
   Apply(WebInputEventCoalesce(), event->type, event_to_coalesce, event);
 }
 
-bool WebInputEventTraits::IgnoresAckDisposition(const WebInputEvent& event) {
+bool WebInputEventTraits::WillReceiveAckFromRenderer(
+    const WebInputEvent& event) {
   switch (event.type) {
     case WebInputEvent::MouseDown:
     case WebInputEvent::MouseUp:
@@ -479,14 +478,20 @@ bool WebInputEventTraits::IgnoresAckDisposition(const WebInputEvent& event) {
     case WebInputEvent::GesturePinchBegin:
     case WebInputEvent::GesturePinchEnd:
     case WebInputEvent::TouchCancel:
-      return true;
+      return false;
     case WebInputEvent::TouchStart:
-    case WebInputEvent::TouchMove:
     case WebInputEvent::TouchEnd:
-      return !static_cast<const WebTouchEvent&>(event).cancelable;
+      return static_cast<const WebTouchEvent&>(event).cancelable;
     default:
-      return false;
+      return true;
+  }
+}
+
+uint32 WebInputEventTraits::GetUniqueTouchEventId(const WebInputEvent& event) {
+  if (WebInputEvent::isTouchEventType(event.type)) {
+    return static_cast<const WebTouchEvent&>(event).uniqueTouchEventId;
   }
+  return 0U;
 }
 
 }  // namespace content

content/common/input/web_input_event_traits.h

@@ -25,7 +25,10 @@ class CONTENT_EXPORT WebInputEventTraits {
                           const blink::WebInputEvent& event);
   static void Coalesce(const blink::WebInputEvent& event_to_coalesce,
                        blink::WebInputEvent* event);
-  static bool IgnoresAckDisposition(const blink::WebInputEvent& event);
+  static bool WillReceiveAckFromRenderer(const blink::WebInputEvent& event);
+
+  // Return uniqueTouchEventId for WebTouchEvent, otherwise return 0.
+  static uint32 GetUniqueTouchEventId(const blink::WebInputEvent& event);
 };
 
 }  // namespace content

content/common/input_messages.h

@@ -12,6 +12,7 @@
 #include "content/common/edit_command.h"
 #include "content/common/input/did_overscroll_params.h"
 #include "content/common/input/input_event.h"
+#include "content/common/input/input_event_ack.h"
 #include "content/common/input/input_event_ack_state.h"
 #include "content/common/input/input_param_traits.h"
 #include "content/common/input/synthetic_gesture_packet.h"
@@ -106,13 +107,13 @@ IPC_STRUCT_TRAITS_BEGIN(content::SyntheticTapGestureParams)
   IPC_STRUCT_TRAITS_MEMBER(duration_ms)
 IPC_STRUCT_TRAITS_END()
 
-IPC_STRUCT_BEGIN(InputHostMsg_HandleInputEvent_ACK_Params)
-  IPC_STRUCT_MEMBER(blink::WebInputEvent::Type, type)
-  IPC_STRUCT_MEMBER(content::InputEventAckState, state)
-  IPC_STRUCT_MEMBER(ui::LatencyInfo, latency)
-  // TODO(jdduke): Use Optional<T> type to avoid heap alloc, crbug.com/375002.
-  IPC_STRUCT_MEMBER(scoped_ptr<content::DidOverscrollParams>, overscroll)
-IPC_STRUCT_END()
+IPC_STRUCT_TRAITS_BEGIN(content::InputEventAck)
+  IPC_STRUCT_TRAITS_MEMBER(type)
+  IPC_STRUCT_TRAITS_MEMBER(state)
+  IPC_STRUCT_TRAITS_MEMBER(latency)
+  IPC_STRUCT_TRAITS_MEMBER(overscroll)
+  IPC_STRUCT_TRAITS_MEMBER(unique_touch_event_id)
+IPC_STRUCT_TRAITS_END()
 
 // Sends an input event to the render widget.
 IPC_MESSAGE_ROUTED3(InputMsg_HandleInputEvent,
@@ -239,7 +240,7 @@ IPC_MESSAGE_ROUTED0(InputMsg_SyntheticGestureCompleted)
 
 // Acknowledges receipt of a InputMsg_HandleInputEvent message.
 IPC_MESSAGE_ROUTED1(InputHostMsg_HandleInputEvent_ACK,
-                    InputHostMsg_HandleInputEvent_ACK_Params)
+                    content::InputEventAck /* ack */)
 
 IPC_MESSAGE_ROUTED1(InputHostMsg_QueueSyntheticGesture,
                     content::SyntheticGesturePacket)

content/content_common.gypi

@@ -367,6 +367,8 @@
       'common/input/gesture_event_stream_validator.h',
       'common/input/input_event.cc',
       'common/input/input_event.h',
+      'common/input/input_event_ack.cc',
+      'common/input/input_event_ack.h',
       'common/input/input_event_stream_validator.cc',
       'common/input/input_event_stream_validator.h',
       'common/input/input_param_traits.cc',

content/renderer/input/input_event_filter.cc

@@ -150,7 +150,7 @@ void InputEventFilter::ForwardToHandler(const IPC::Message& message) {
   bool is_keyboard_shortcut = get<2>(params);
   DCHECK(event);
 
-  const bool send_ack = !WebInputEventTraits::IgnoresAckDisposition(*event);
+  const bool send_ack = WebInputEventTraits::WillReceiveAckFromRenderer(*event);
 
   // Intercept |DidOverscroll| notifications, bundling any triggered overscroll
   // response with the input event ack.
@@ -176,11 +176,9 @@ void InputEventFilter::ForwardToHandler(const IPC::Message& message) {
   if (!send_ack)
     return;
 
-  InputHostMsg_HandleInputEvent_ACK_Params ack;
-  ack.type = event->type;
-  ack.state = ack_state;
-  ack.latency = latency_info;
-  ack.overscroll = overscroll_params.Pass();
+  InputEventAck ack(event->type, ack_state, latency_info,
+                    overscroll_params.Pass(),
+                    WebInputEventTraits::GetUniqueTouchEventId(*event));
   SendMessage(scoped_ptr<IPC::Message>(
       new InputHostMsg_HandleInputEvent_ACK(routing_id, ack)));
 }

content/renderer/render_widget.cc

@@ -1239,11 +1239,10 @@ void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
   // by reentrant calls for events after the paused one.
   bool no_ack = ignore_ack_for_mouse_move_from_debugger_ &&
       input_event->type == WebInputEvent::MouseMove;
-  if (!WebInputEventTraits::IgnoresAckDisposition(*input_event) && !no_ack) {
-    InputHostMsg_HandleInputEvent_ACK_Params ack;
-    ack.type = input_event->type;
-    ack.state = ack_result;
-    ack.latency = swap_latency_info;
+  if (WebInputEventTraits::WillReceiveAckFromRenderer(*input_event) &&
+      !no_ack) {
+    InputEventAck ack(input_event->type, ack_result, swap_latency_info,
+                      WebInputEventTraits::GetUniqueTouchEventId(*input_event));
     scoped_ptr<IPC::Message> response(
         new InputHostMsg_HandleInputEvent_ACK(routing_id_, ack));
     if (rate_limiting_wanted && frame_pending && !is_hidden_) {
@@ -1794,9 +1793,7 @@ bool RenderWidget::SendAckForMouseMoveFromDebugger() {
     // If we pause multiple times during a single mouse move event, we should
     // only send ACK once.
     if (!ignore_ack_for_mouse_move_from_debugger_) {
-      InputHostMsg_HandleInputEvent_ACK_Params ack;
-      ack.type = handling_event_type_;
-      ack.state = INPUT_EVENT_ACK_STATE_CONSUMED;
+      InputEventAck ack(handling_event_type_, INPUT_EVENT_ACK_STATE_CONSUMED);
       Send(new InputHostMsg_HandleInputEvent_ACK(routing_id_, ack));
       return true;
     }

ui/events/event.h

@@ -518,7 +518,7 @@ class EVENTS_EXPORT TouchEvent : public LocatedEvent {
   // The id of the pointer this event modifies.
   int touch_id() const { return touch_id_; }
   // A unique identifier for this event.
-  uint64 unique_event_id() const { return unique_event_id_; }
+  uint32 unique_event_id() const { return unique_event_id_; }
   // If we aren't provided with a radius on one axis, use the
   // information from the other axis.
   float radius_x() const { return radius_x_ > 0 ? radius_x_ : radius_y_; }
@@ -558,7 +558,7 @@ class EVENTS_EXPORT TouchEvent : public LocatedEvent {
   const int touch_id_;
 
   // A unique identifier for the touch event.
-  const uint64 unique_event_id_;
+  const uint32 unique_event_id_;
 
   // Radius of the X (major) axis of the touch ellipse. 0.0 if unknown.
   float radius_x_;