Coalesce async touch move events until the ack back from render

content/renderer/render_widget.cc

 // Copyright (c) 2012 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/renderer/render_widget.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 1206 matching lines @@
           total_input_handling_time_this_frame_.InMicroseconds() >
           kInputHandlingTimeThrottlingThresholdMicroseconds;
   }
 
   TRACE_EVENT_SYNTHETIC_DELAY_END("blink.HandleInputEvent");
 
   // Note that we can't use handling_event_type_ here since it will be overriden
   // 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;
-    scoped_ptr<IPC::Message> response(
-        new InputHostMsg_HandleInputEvent_ACK(routing_id_, ack));
+
+  bool is_async_touch_move = false;
+  if (input_event->type == WebInputEvent::TouchMove) {
+    const WebTouchEvent& touch =
+        static_cast<const WebTouchEvent&>(*input_event);
+    if (!touch.cancelable)
+      is_async_touch_move = true;
+  }
+
+  if ((!WebInputEventTraits::IgnoresAckDisposition(*input_event) ||
+      is_async_touch_move) && !no_ack) {
+    // Send AsyncTouchEvent_ACK for async touch moves, and InputEvent_ACK for
+    // all other types of events.
+    scoped_ptr<IPC::Message> response;
+
+    if (is_async_touch_move) {
+      InputHostMsg_HandleUncancelableTouchMoveEvent_ACK_Params ack;
+      response = scoped_ptr<IPC::Message>(
+          new InputHostMsg_HandleUncancelableTouchMoveEvent_ACK(routing_id_,
+                                                                ack));
+    } else {
+      InputHostMsg_HandleInputEvent_ACK_Params ack;
+      ack.type = input_event->type;
+      ack.state = ack_result;
+      ack.latency = swap_latency_info;
+      response = scoped_ptr<IPC::Message>(
+          new InputHostMsg_HandleInputEvent_ACK(routing_id_, ack));
+    }
+
     if (rate_limiting_wanted && frame_pending && !is_hidden_) {
       // We want to rate limit the input events in this case, so we'll wait for
       // painting to finish before ACKing this message.
       TRACE_EVENT_INSTANT0("renderer",
         "RenderWidget::OnHandleInputEvent ack throttled",
         TRACE_EVENT_SCOPE_THREAD);
       if (pending_input_event_ack_) {
         TRACE_EVENT_ASYNC_END0("input", "RenderWidget::ThrottledInputEventAck",
                                pending_input_event_ack_.get());
         // As two different kinds of events could cause us to postpone an ack
@@ skipping 1179 matching lines @@
 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content