Stop sending an async touchmove for the app slop region

content/browser/renderer_host/input/touch_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/touch_event_queue.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/input/timeout_monitor.h"
@@ skipping 346 matching lines @@
     : touch_scrolling_mode(TOUCH_SCROLLING_MODE_DEFAULT),
       touch_ack_timeout_delay(base::TimeDelta::FromMilliseconds(200)),
       touch_ack_timeout_supported(false) {
 }
 
 TouchEventQueue::TouchEventQueue(TouchEventQueueClient* client,
                                  const Config& config)
     : client_(client),
       dispatching_touch_ack_(NULL),
       dispatching_touch_(false),
+      processing_touch_ack_(false),
       has_handlers_(true),
       drop_remaining_touches_in_sequence_(false),
       touchmove_slop_suppressor_(new TouchMoveSlopSuppressor),
       send_touch_events_async_(false),
       needs_async_touchmove_for_outer_slop_region_(false),
       last_sent_touch_timestamp_sec_(0),
       touch_scrolling_mode_(config.touch_scrolling_mode) {
   DCHECK(client);
   if (config.touch_ack_timeout_supported) {
     timeout_handler_.reset(
@@ skipping 36 matching lines @@
     CoalescedWebTouchEvent* last_event = touch_queue_.back();
     if (last_event->CoalesceEventIfPossible(event))
       return;
   }
   touch_queue_.push_back(new CoalescedWebTouchEvent(event, false));
 }
 
 void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result,
                                       const LatencyInfo& latency_info) {
   TRACE_EVENT0("input", "TouchEventQueue::ProcessTouchAck");
+  base::AutoReset<bool> processing_touch_ack(&processing_touch_ack_, true);
 
   DCHECK(!dispatching_touch_ack_);
   dispatching_touch_ = false;
 
   if (timeout_handler_ && timeout_handler_->ConfirmTouchEvent(ack_result))
     return;
 
   touchmove_slop_suppressor_->ConfirmTouchEvent(ack_result);
 
   if (touch_queue_.empty())
@@ skipping 31 matching lines @@
   DCHECK(!dispatching_touch_);
   TouchEventWithLatencyInfo touch = touch_queue_.front()->coalesced_event();
 
   if (send_touch_events_async_ &&
       touch.event.type == WebInputEvent::TouchMove) {
     // Throttling touchmove's in a continuous touchmove stream while scrolling
     // reduces the risk of jank. However, it's still important that the web
     // application be sent touches at key points in the gesture stream,
     // e.g., when the application slop region is exceeded or touchmove
     // coalescing fails because of different modifiers.
-    const bool send_touchmove_now =
-        size() > 1 ||
-        (touch.event.timeStampSeconds >=
-         last_sent_touch_timestamp_sec_ + kAsyncTouchMoveIntervalSec) ||
-        (needs_async_touchmove_for_outer_slop_region_ &&
-         OutsideApplicationSlopRegion(touch.event,
-                                      touch_sequence_start_position_)) ||
-        (pending_async_touchmove_ &&
-         !pending_async_touchmove_->CanCoalesceWith(touch));
+    bool send_touchmove_now = size() > 1;
+    send_touchmove_now |= pending_async_touchmove_ &&
+                          !pending_async_touchmove_->CanCoalesceWith(touch);
+    // Avoid async touch dispatch immediately after receipt of a touch ack. This
+    // reduces the likelihood of the async touch contending with gestures
+    // (and gesture side effects) triggered by the touch ack.
+    if (!processing_touch_ack_) {
+      send_touchmove_now |=
+          touch.event.timeStampSeconds >=
+          last_sent_touch_timestamp_sec_ + kAsyncTouchMoveIntervalSec;
+      send_touchmove_now |= needs_async_touchmove_for_outer_slop_region_ &&
+                            OutsideApplicationSlopRegion(
+                                touch.event, touch_sequence_start_position_);
+    }
 
     if (!send_touchmove_now) {
       if (!pending_async_touchmove_) {
         pending_async_touchmove_.reset(new TouchEventWithLatencyInfo(touch));
       } else {
         DCHECK(pending_async_touchmove_->CanCoalesceWith(touch));
         pending_async_touchmove_->CoalesceWith(touch);
       }
       DCHECK_EQ(1U, size());
       PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
@@ skipping 278 matching lines @@
         if (ack_result != INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS)
           touch_consumer_states_.mark_bit(point.id);
         else
           touch_consumer_states_.clear_bit(point.id);
       }
     }
   }
 }
 
 }  // namespace content