Always reset touch action at the beginning of a new gesture sequence

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/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/input/timeout_monitor.h"
-#include "content/common/input/web_input_event_traits.h"
+#include "content/browser/renderer_host/input/web_touch_event_traits.h"
 #include "content/public/common/content_switches.h"
 #include "ui/gfx/geometry/point_f.h"
 
 using blink::WebInputEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using ui::LatencyInfo;
 
 namespace content {
 namespace {
 
 typedef std::vector<TouchEventWithLatencyInfo> WebTouchEventWithLatencyList;
 
 TouchEventWithLatencyInfo ObtainCancelEventForTouchEvent(
     const TouchEventWithLatencyInfo& event_to_cancel) {
   TouchEventWithLatencyInfo event = event_to_cancel;
   event.event.type = WebInputEvent::TouchCancel;
   for (size_t i = 0; i < event.event.touchesLength; i++)
     event.event.touches[i].state = WebTouchPoint::StateCancelled;
   return event;
 }
 
-bool IsNewTouchSequence(const WebTouchEvent& event) {
-  if (event.type != WebInputEvent::TouchStart)
-    return false;
-  if (!event.touchesLength)
-    return false;
-  for (size_t i = 0; i < event.touchesLength; i++) {
-    if (event.touches[i].state != WebTouchPoint::StatePressed)
-      return false;
-  }
-  return true;
-}
-
 bool ShouldTouchTypeTriggerTimeout(WebInputEvent::Type type) {
   return type == WebInputEvent::TouchStart ||
          type == WebInputEvent::TouchMove;
 }
 
 }  // namespace
 
 
 // Cancels a touch sequence if a touchstart or touchmove ack response is
 // sufficiently delayed.
@@ skipping 62 matching lines @@
     SetPendingAckState(PENDING_ACK_ORIGINAL_EVENT);
     touch_queue_->FlushQueue();
   }
 
   // Skip a cancel event if the timed-out event had no consumer and was the
   // initial event in the gesture.
   bool AckedTimeoutEventRequiresCancel(InputEventAckState ack_result) const {
     DCHECK(HasTimeoutEvent());
     if (ack_result != INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS)
       return true;
-    return !IsNewTouchSequence(timeout_event_.event);
+    return !WebTouchEventTraits::IsTouchSequenceStart(timeout_event_.event);
   }
 
   void SetPendingAckState(PendingAckState new_pending_ack_state) {
     DCHECK_NE(pending_ack_state_, new_pending_ack_state);
     switch (new_pending_ack_state) {
       case PENDING_ACK_ORIGINAL_EVENT:
         DCHECK_EQ(pending_ack_state_, PENDING_ACK_NONE);
         TRACE_EVENT_ASYNC_BEGIN0("input", "TouchEventTimeout", this);
         break;
       case PENDING_ACK_CANCEL_EVENT:
@@ skipping 37 matching lines @@
 class TouchEventQueue::TouchMoveSlopSuppressor {
  public:
   // TODO(jdduke): Remove int cast on suppression length, crbug.com/336807.
   TouchMoveSlopSuppressor(double slop_suppression_length_dips)
       : slop_suppression_length_dips_squared_(
             static_cast<int>(slop_suppression_length_dips) *
             static_cast<int>(slop_suppression_length_dips)),
         suppressing_touch_moves_(false) {}
 
   bool FilterEvent(const WebTouchEvent& event) {
-    if (IsNewTouchSequence(event)) {
+    if (WebTouchEventTraits::IsTouchSequenceStart(event)) {
       touch_sequence_start_position_ =
           gfx::Point(event.touches[0].position);
       suppressing_touch_moves_ = slop_suppression_length_dips_squared_ != 0;
     }
 
     if (event.type != WebInputEvent::TouchMove)
       return false;
 
     if (suppressing_touch_moves_) {
       // Movement with a secondary pointer should terminate suppression.
@@ skipping 116 matching lines @@
 void TouchEventQueue::QueueEvent(const TouchEventWithLatencyInfo& event) {
   TRACE_EVENT0("input", "TouchEventQueue::QueueEvent");
 
   // If the queueing of |event| was triggered by an ack dispatch, defer
   // processing the event until the dispatch has finished.
   if (touch_queue_.empty() && !dispatching_touch_ack_) {
     // Optimization of the case without touch handlers.  Removing this path
     // yields identical results, but this avoids unnecessary allocations.
     if (touch_filtering_state_ == DROP_ALL_TOUCHES ||
         (touch_filtering_state_ == DROP_TOUCHES_IN_SEQUENCE &&
-         !IsNewTouchSequence(event.event))) {
+         !WebTouchEventTraits::IsTouchSequenceStart(event.event))) {
       client_->OnTouchEventAck(event, INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
       return;
     }
 
     // There is no touch event in the queue. Forward it to the renderer
     // immediately.
     touch_queue_.push_back(new CoalescedWebTouchEvent(event, false));
     TryForwardNextEventToRenderer();
     return;
   }
@@ skipping 58 matching lines @@
   }
 }
 
 void TouchEventQueue::ForwardToRenderer(
     const TouchEventWithLatencyInfo& touch) {
   TRACE_EVENT0("input", "TouchEventQueue::ForwardToRenderer");
 
   DCHECK(!dispatching_touch_);
   DCHECK_NE(touch_filtering_state_, DROP_ALL_TOUCHES);
 
-  if (IsNewTouchSequence(touch.event)) {
+  if (WebTouchEventTraits::IsTouchSequenceStart(touch.event)) {
     touch_filtering_state_ =
         ack_timeout_enabled_ ? FORWARD_TOUCHES_UNTIL_TIMEOUT
                              : FORWARD_ALL_TOUCHES;
     touch_ack_states_.clear();
     absorbing_touch_moves_ = 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);
@@ skipping 153 matching lines @@
     return ACK_WITH_NO_CONSUMER_EXISTS;
 
   if (touchmove_slop_suppressor_->FilterEvent(event))
     return ACK_WITH_NOT_CONSUMED;
 
   if (touch_filtering_state_ == DROP_ALL_TOUCHES)
     return ACK_WITH_NO_CONSUMER_EXISTS;
 
   if (touch_filtering_state_ == DROP_TOUCHES_IN_SEQUENCE &&
       event.type != WebInputEvent::TouchCancel) {
-    if (IsNewTouchSequence(event))
+    if (WebTouchEventTraits::IsTouchSequenceStart(event))
       return FORWARD_TO_RENDERER;
     return ACK_WITH_NOT_CONSUMED;
   }
 
   if (absorbing_touch_moves_ && event.type == WebInputEvent::TouchMove)
     return ACK_WITH_NOT_CONSUMED;
 
   // Touch press events should always be forwarded to the renderer.
   if (event.type == WebInputEvent::TouchStart)
     return FORWARD_TO_RENDERER;
@@ skipping 33 matching lines @@
   } else if (event.type == WebInputEvent::TouchStart) {
     for (unsigned i = 0; i < event.touchesLength; ++i) {
       const WebTouchPoint& point = event.touches[i];
       if (point.state == WebTouchPoint::StatePressed)
         touch_ack_states_[point.id] = ack_result;
     }
   }
 }
 
 }  // namespace content