Set the unique_event_id when converting from TouchEvent to WebTouchEvent

content/browser/renderer_host/input/input_router_impl.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/input_router_impl.h"
 
 #include <math.h>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 339 matching lines @@
   output_stream_validator_.Validate(input_event);
 
   if (OfferToClient(input_event, latency_info))
     return;
 
   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);
+  uint64 unique_touch_event_id = 0;
   if (WebInputEvent::isTouchEventType(input_event.type)) {
     const WebTouchEvent& touch = static_cast<const WebTouchEvent&>(input_event);
+    unique_touch_event_id = touch.uniqueTouchEventId;
+    DCHECK_NE(unique_touch_event_id, 0UL);
     DCHECK_NE(ignores_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,
+                         unique_touch_event_id,
                          IGNORING_DISPOSITION);
   }
 }
 
 bool InputRouterImpl::OfferToClient(const WebInputEvent& input_event,
                                     const ui::LatencyInfo& latency_info) {
   bool consumed = false;
+  uint64 unique_touch_event_id = 0;
 
   InputEventAckState filter_ack =
       client_->FilterInputEvent(input_event, latency_info);
   switch (filter_ack) {
     case INPUT_EVENT_ACK_STATE_CONSUMED:
     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);
+      if (WebInputEvent::isTouchEventType(input_event.type)) {
+        const WebTouchEvent& touch =
+            static_cast<const WebTouchEvent&>(input_event);
+        unique_touch_event_id = touch.uniqueTouchEventId;
+      }
+      ProcessInputEventAck(input_event.type, filter_ack, latency_info,
+          unique_touch_event_id, CLIENT);
       // WARNING: |this| may be deleted at this point.
       consumed = true;
       break;
     case INPUT_EVENT_ACK_STATE_UNKNOWN:
       // Simply drop the event.
       consumed = true;
       break;
     default:
       break;
   }
@@ skipping 24 matching lines @@
 
   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
   UMA_HISTOGRAM_TIMES("MPArch.IIR_InputEventDelta", delta);
 
   if (ack.overscroll) {
     DCHECK(ack.type == WebInputEvent::MouseWheel ||
            ack.type == WebInputEvent::GestureScrollUpdate);
     OnDidOverscroll(*ack.overscroll);
   }
-
-  ProcessInputEventAck(ack.type, ack.state, ack.latency, RENDERER);
+  ProcessInputEventAck(ack.type, ack.state, ack.latency,
+      ack.unique_touch_event_id, 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);
@@ skipping 56 matching lines @@
 void InputRouterImpl::OnDidStopFlinging() {
   gesture_event_queue_.DidStopFlinging();
   SignalFlushedIfNecessary();
   client_->DidStopFlinging();
 }
 
 void InputRouterImpl::ProcessInputEventAck(
     WebInputEvent::Type event_type,
     InputEventAckState ack_result,
     const ui::LatencyInfo& latency_info,
+    uint64 uniqueEventId,

[tdresser, 2015/04/09 12:33:06]

unique_touch_event_id

     AckSource ack_source) {
   TRACE_EVENT2("input", "InputRouterImpl::ProcessInputEventAck",
                "type", WebInputEventTraits::GetName(event_type),
                "ack", GetEventAckName(ack_result));
 
   // Note: The keyboard ack must be treated carefully, as it may result in
   // synchronous destruction of |this|. Handling immediately guards against
   // future references to |this|, as with |auto_reset_current_ack_source| below.
   if (WebInputEvent::isKeyboardEventType(event_type)) {
     ProcessKeyboardAck(event_type, ack_result);
     // WARNING: |this| may be deleted at this point.
     return;
   }
 
   base::AutoReset<AckSource> auto_reset_current_ack_source(
       &current_ack_source_, ack_source);
 
   if (WebInputEvent::isMouseEventType(event_type)) {
     ProcessMouseAck(event_type, ack_result);
   } 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, uniqueEventId);
   } else if (WebInputEvent::isGestureEventType(event_type)) {
     ProcessGestureAck(event_type, ack_result, latency_info);
   } else if (event_type != WebInputEvent::Undefined) {
     ack_handler_->OnUnexpectedEventAck(InputAckHandler::BAD_ACK_MESSAGE);
   }
 
   SignalFlushedIfNecessary();
 }
 
 void InputRouterImpl::ProcessKeyboardAck(blink::WebInputEvent::Type type,
@@ skipping 60 matching lines @@
 
 void InputRouterImpl::ProcessGestureAck(WebInputEvent::Type type,
                                         InputEventAckState ack_result,
                                         const ui::LatencyInfo& latency) {
   // |gesture_event_queue_| will forward to OnGestureEventAck when appropriate.
   gesture_event_queue_.ProcessGestureAck(ack_result, type, latency);
 }
 
 void InputRouterImpl::ProcessTouchAck(
     InputEventAckState ack_result,
-    const ui::LatencyInfo& latency) {
+    const ui::LatencyInfo& latency,
+    uint64 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() {
   // Mobile sites tend to be well-behaved with respect to touch handling, so
   // they have less need for the touch timeout fallback.
   const bool fixed_page_scale = (current_view_flags_ & FIXED_PAGE_SCALE) != 0;
   const bool mobile_viewport = (current_view_flags_ & MOBILE_VIEWPORT) != 0;
 
   // TOUCH_ACTION_NONE will prevent scrolling, in which case the timeout serves
   // little purpose. It's also a strong signal that touch handling is critical
@@ skipping 12 matching lines @@
     return;
 
   if (HasPendingEvents())
     return;
 
   flush_requested_ = false;
   client_->DidFlush();
 }
 
 }  // namespace content