Touch Events - changedTouches list includes non-changed touch points on Android

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 89 matching lines @@
       case PENDING_ACK_NONE:
         if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
           enabled_for_current_sequence_ = false;
         timeout_monitor_.Stop();
         return false;
       case PENDING_ACK_ORIGINAL_EVENT:
         if (AckedTimeoutEventRequiresCancel(ack_result)) {
           SetPendingAckState(PENDING_ACK_CANCEL_EVENT);
           TouchEventWithLatencyInfo cancel_event =
               ObtainCancelEventForTouchEvent(timeout_event_);
-          touch_queue_->SendTouchEventImmediately(cancel_event);
+          touch_queue_->SendTouchEventImmediately(&cancel_event);
         } else {
           SetPendingAckState(PENDING_ACK_NONE);
           touch_queue_->UpdateTouchConsumerStates(timeout_event_.event,
                                                   ack_result);
         }
         return true;
       case PENDING_ACK_CANCEL_EVENT:
         SetPendingAckState(PENDING_ACK_NONE);
         return true;
     }
@@ skipping 397 matching lines @@
     if (pending_async_touchmove_->CanCoalesceWith(touch)) {
       pending_async_touchmove_->CoalesceWith(touch);
       pending_async_touchmove_->event.cancelable = !send_touch_events_async_;
       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);
+      SendTouchEventImmediately(async_move.get());
       return;
     }
   }
 
   // Note: Marking touchstart events as not-cancelable prevents them from
   // blocking subsequent gestures, but it may not be the best long term solution
   // for tracking touch point dispatch.
   if (send_touch_events_async_)
     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);
+  SendTouchEventImmediately(&touch);
   if (dispatching_touch_ && timeout_handler_)
     timeout_handler_->StartIfNecessary(touch);
 }
 
 void TouchEventQueue::OnGestureScrollEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
   if (gesture_event.event.type == blink::WebInputEvent::GestureScrollBegin) {
     if (!touch_consumer_states_.is_empty() &&
         !drop_remaining_touches_in_sequence_) {
       DCHECK(!touchmove_slop_suppressor_->suppressing_touchmoves())
@@ skipping 143 matching lines @@
 }
 
 scoped_ptr<CoalescedWebTouchEvent> TouchEventQueue::PopTouchEvent() {
   DCHECK(!touch_queue_.empty());
   scoped_ptr<CoalescedWebTouchEvent> event(touch_queue_.front());
   touch_queue_.pop_front();
   return event.Pass();
 }
 
 void TouchEventQueue::SendTouchEventImmediately(
-    const TouchEventWithLatencyInfo& touch) {
+    TouchEventWithLatencyInfo* touch) {
   if (needs_async_touchmove_for_outer_slop_region_) {
     // Any event other than a touchmove (e.g., touchcancel or secondary
     // touchstart) after a scroll has started will interrupt the need to send a
     // an outer slop-region exceeding touchmove.
-    if (touch.event.type != WebInputEvent::TouchMove ||
-        OutsideApplicationSlopRegion(touch.event,
+    if (touch->event.type != WebInputEvent::TouchMove ||
+        OutsideApplicationSlopRegion(touch->event,
                                      touch_sequence_start_position_))
       needs_async_touchmove_for_outer_slop_region_ = false;
   }
 
-  client_->SendTouchEventImmediately(touch);
+  // For touchmove events, compare touch points position from current event
+  // to last sent event and update touch points state.
+  if (touch->event.type == WebInputEvent::TouchMove) {
+    for (unsigned int i = 0; i < last_sent_touchevent_->touchesLength; ++i) {

[jdduke (slow), 2015/01/06 17:57:29]

|CHECK(last_sent_touchevent_);| to make the crash clear.

Also maybe a |DCHECK_EQ(last_sent_touchevent_->touchesLength,
touch->event.touchesLength);}

[USE s.singapati at gmail.com, 2015/01/09 12:28:53]

CHECK(last_sent_touchevent_) is fine. Or making if (touch->event.type ==
WebInputEvent::TouchMove && last_sent_touchevent_) is even safer for not to
change current (baseline) behavior allowing event to be sent instead of
crashing. Theoretically i think, there should not be TouchMove event without
previous sent event.

About DCHECK_EQ of touchesLength, when for eg.,3 touches are continuously moving
and release one touch, then touchesLength is different in TouchEnd event and
next immediate TouchMove event and that is valid. Still in this case it is valid
to correct the touches state. Or atleast there is no need to crash.

+      const WebTouchPoint& last_touch_point =
+          last_sent_touchevent_->touches[i];
+
+      // touches with same id may not have same index in touches array

[jdduke (slow), 2015/01/06 17:57:29]

Nit: Capitalize 'Touches' and end comment with period.

[USE s.singapati at gmail.com, 2015/01/09 12:28:53]

Done.

+      for (unsigned int j = 0; j < touch->event.touchesLength; ++j) {
+        const WebTouchPoint& current_touchmove_point = touch->event.touches[j];
+        if (last_touch_point.id == current_touchmove_point.id) {
+          if (current_touchmove_point.position.x == last_touch_point.position.x
+              && current_touchmove_point.position.y ==
+                  last_touch_point.position.y)

[jdduke (slow), 2015/01/06 17:57:29]

Nit: Braces around this if body because the condition is multiline.

[USE s.singapati at gmail.com, 2015/01/09 12:28:53]

Done.

+            touch->event.touches[j].state = WebTouchPoint::StateStationary;
+
+          break;
+        }
+      }
+    }
+  }
+
+  if (last_sent_touchevent_)
+    *last_sent_touchevent_ = touch->event;
+  else
+    last_sent_touchevent_.reset(new WebTouchEvent(touch->event));
+
+  client_->SendTouchEventImmediately(*touch);
 }
 
 TouchEventQueue::PreFilterResult
 TouchEventQueue::FilterBeforeForwarding(const WebTouchEvent& event) {
   if (timeout_handler_ && timeout_handler_->FilterEvent(event))
     return ACK_WITH_NO_CONSUMER_EXISTS;
 
   if (touchmove_slop_suppressor_->FilterEvent(event))
     return ACK_WITH_NOT_CONSUMED;
 
   if (WebTouchEventTraits::IsTouchSequenceStart(event)) {
     touch_consumer_states_.clear();
     send_touch_events_async_ = false;
     pending_async_touchmove_.reset();
+    last_sent_touchevent_.reset();
+
     touch_sequence_start_position_ = gfx::PointF(event.touches[0].position);
     drop_remaining_touches_in_sequence_ = false;
     if (!has_handlers_) {
       drop_remaining_touches_in_sequence_ = true;
       return ACK_WITH_NO_CONSUMER_EXISTS;
     }
   }
 
   if (drop_remaining_touches_in_sequence_ &&
       event.type != WebInputEvent::TouchCancel) {
@@ skipping 35 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