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_->UpdateTouchesStateIfNeededAndSendTouchEvent(
+              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);
+      UpdateTouchesStateIfNeededAndSendTouchEvent(*async_move);
       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);
+  UpdateTouchesStateIfNeededAndSendTouchEvent(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 142 matching lines @@
   acked_event->DispatchAckToClient(ack_result, optional_latency_info, client_);
 }
 
 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::UpdateTouchesStateIfNeededAndSendTouchEvent(
+    TouchEventWithLatencyInfo& touch) {

[jdduke (slow), 2014/12/09 20:30:25]

This logic can probably be folded into SendTouchEventImmediately; we already do
some bookkeeping there.

[USE s.singapati at gmail.com, 2014/12/13 07:46:05]

Done.

+  if (touch.event.type == WebInputEvent::TouchMove) {
+    if (last_sent_touchmove_) {
+      WebTouchEvent last_touchmove_event = last_sent_touchmove_->event;
+      // compare touch points position from current event to last sent event
+      // and update touch points state. touchesLength & order of touches
+      // (point ids) should be same in consecutive TouchMoves
+      for (unsigned int i = 0; i < last_touchmove_event.touchesLength; ++i) {
+        const WebTouchPoint& last_touchmove_point =
+            last_touchmove_event.touches[i];
+        WebTouchPoint& current_touchmove_point = touch.event.touches[i];
+
+        // current touches state would have been set to "StateMoved"
+        // in web_input_event_util. This check may not be needed!?
+        if (current_touchmove_point.state == WebTouchPoint::StateMoved

[jdduke (slow), 2014/12/09 20:30:25]

I don't think there are any guarantees that pointers with the same ID will have
the same index in the touches array.

[USE s.singapati at gmail.com, 2014/12/13 07:46:05]

Done. Form testing it is found that most of the times (i can not say 100%)
pointer ids are same in same index. But i agree that it is not guaranteed. So,
to eliminate margin of error, i used nested loops. With current nature of
touches it takes O(n(n+1)/2) complexity. And practically there would be few
touches on screen at a time, so other techniques like hash table etc is probably
not needed.

+            && last_touchmove_point.id == current_touchmove_point.id) {
+
+          if (fabs(current_touchmove_point.position.x -
+              last_touchmove_point.position.x) < 0.000001
+              && fabs(current_touchmove_point.position.y -
+                  last_touchmove_point.position.y) < 0.000001)
+            current_touchmove_point.state = WebTouchPoint::StateStationary;
+        }
+      }
+    }
+    last_sent_touchmove_.reset(new TouchEventWithLatencyInfo(touch));

[jdduke (slow), 2014/12/09 20:30:25]

Do we need to store the LatencyInfo? I think we can just store a TouchEvent? And
to avoid unnecessary allocations, we could do something like:

if (last_sent_touchmove_)
  *last_sent_touchmove_ = touch.event;
else
  last_sent_touchmove_.reset(new WebTouchEvent(touch.event));

Alternatively, you could not use a scoped_ptr and implicitly reset the event
with
  last_sent_touchmove_ = WebInputEvent();

then you just check for a valid event type... but maybe that's abusive...

[USE s.singapati at gmail.com, 2014/12/13 07:46:05]

Done.

+  } else {
+    if (last_sent_touchmove_)
+      last_sent_touchmove_.reset();
+  }
+
+  SendTouchEventImmediately(touch);
+}
+
 void TouchEventQueue::SendTouchEventImmediately(
     const 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,
                                      touch_sequence_start_position_))
       needs_async_touchmove_for_outer_slop_region_ = false;
   }
 
   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_touchmove_.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