Add the actual location coordinates to the touch cancel event

ui/events/gestures/gesture_recognizer_impl.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 "ui/events/gestures/gesture_recognizer_impl.h"
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 114 matching lines @@
 
 void GestureRecognizerImpl::TransferEventsTo(GestureConsumer* current_consumer,
                                              GestureConsumer* new_consumer) {
   // Send cancel to all those save |new_consumer| and |current_consumer|.
   // Don't send a cancel to |current_consumer|, unless |new_consumer| is NULL.
   // Dispatching a touch-cancel event can end up altering |touch_id_target_|
   // (e.g. when the target of the event is destroyed, causing it to be removed
   // from |touch_id_target_| in |CleanupStateForConsumer()|). So create a list
   // of the touch-ids that need to be cancelled, and dispatch the cancel events
   // for them at the end.
-  std::vector<std::pair<int, GestureConsumer*> > ids;
-  for (TouchIdToConsumerMap::iterator i = touch_id_target_.begin();
-       i != touch_id_target_.end(); ++i) {
-    if (i->second && i->second != new_consumer &&
-        (i->second != current_consumer || new_consumer == NULL) &&
-        i->second) {
-      ids.push_back(std::make_pair(i->first, i->second));
+
+  std::vector<GestureConsumer*> consumers;
+  std::map<GestureConsumer*, GestureProviderAura*>::iterator i;
+  for (i = consumer_gesture_provider_.begin();
+       i != consumer_gesture_provider_.end();
+       ++i) {
+    if (i->first && i->first != new_consumer &&
+        (i->first != current_consumer || new_consumer == NULL)) {
+      consumers.push_back(i->first);
     }
   }
-
-  CancelTouches(&ids);
-
+  for (std::vector<GestureConsumer*>::iterator iter = consumers.begin();
+       iter != consumers.end();
+       ++iter) {
+    CancelActiveTouches(*iter);
+  }
   // Transfer events from |current_consumer| to |new_consumer|.
   if (current_consumer && new_consumer) {
     TransferTouchIdToConsumerMap(current_consumer, new_consumer,
                                  &touch_id_target_);
     TransferTouchIdToConsumerMap(current_consumer, new_consumer,
                                  &touch_id_target_for_gestures_);
     TransferConsumer(
         current_consumer, new_consumer, &consumer_gesture_provider_);
   }
 }
 
 bool GestureRecognizerImpl::GetLastTouchPointForTarget(
     GestureConsumer* consumer,
     gfx::PointF* point) {
     if (consumer_gesture_provider_.count(consumer) == 0)
       return false;
     const MotionEvent& pointer_state =
         consumer_gesture_provider_[consumer]->pointer_state();
     *point = gfx::PointF(pointer_state.GetX(), pointer_state.GetY());
     return true;
 }
 
 bool GestureRecognizerImpl::CancelActiveTouches(GestureConsumer* consumer) {
-  std::vector<std::pair<int, GestureConsumer*> > ids;
-  for (TouchIdToConsumerMap::const_iterator i = touch_id_target_.begin();
-       i != touch_id_target_.end(); ++i) {
-    if (i->second == consumer)
-      ids.push_back(std::make_pair(i->first, i->second));
+  bool cancelled_touch = false;
+  if (consumer_gesture_provider_.count(consumer) == 0)
+    return false;
+  const MotionEventAura& pointer_state =

[jdduke (slow), 2014/08/26 23:22:24]

Could the referenced MotionEventAura be mutated by the
|helper->DispatchCancelTouchEvent(&touch_event);| call below? 

Also, I see that the cancel dispatch is taking a pointer to an object on the
stack, does the cancel dispatch ever "consume" the pointer? Or does it simply
mutate it? (sorry for my ignorance here!)

[tdresser, 2014/08/27 13:07:09]

I think there is a risk of the MotionEventAura being mutated. We should either
clone it, or generate the full list of touch events before we start dispatching
them.

Hmmm, I don't think anyone will ever hold on to the touch event, but I'm not
100% positive. We've counted on this behavior for a while now, (see the removed
|CancelTouches| method). Sadrul, can you confirm that this should be safe?

+      consumer_gesture_provider_[consumer]->pointer_state();
+  size_t count = pointer_state.GetPointerCount();
+  for (size_t i = 0; i < count; ++i) {
+    gfx::PointF point(pointer_state.GetX(i), pointer_state.GetY(i));
+    TouchEvent touch_event(ui::ET_TOUCH_CANCELLED,
+                           point,
+                           ui::EF_IS_SYNTHESIZED,
+                           pointer_state.GetPointerId(i),
+                           ui::EventTimeForNow(),
+                           0.0f,
+                           0.0f,
+                           0.0f,
+                           0.0f);
+    GestureEventHelper* helper = FindDispatchHelperForConsumer(consumer);
+    if (helper)
+      helper->DispatchCancelTouchEvent(&touch_event);
+    cancelled_touch = true;
   }
-  bool cancelled_touch = !ids.empty();
-  CancelTouches(&ids);
   return cancelled_touch;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureRecognizerImpl, private:
 
 GestureProviderAura* GestureRecognizerImpl::GetGestureProviderForConsumer(
     GestureConsumer* consumer) {
   GestureProviderAura* gesture_provider = consumer_gesture_provider_[consumer];
   if (!gesture_provider) {
     gesture_provider = CreateGestureProvider(this);
     consumer_gesture_provider_[consumer] = gesture_provider;
   }
   return gesture_provider;
 }
 
 void GestureRecognizerImpl::SetupTargets(const TouchEvent& event,
                                          GestureConsumer* target) {
   if (event.type() == ui::ET_TOUCH_RELEASED ||
       event.type() == ui::ET_TOUCH_CANCELLED) {
     touch_id_target_.erase(event.touch_id());
   } else if (event.type() == ui::ET_TOUCH_PRESSED) {
     touch_id_target_[event.touch_id()] = target;
     if (target)
       touch_id_target_for_gestures_[event.touch_id()] = target;
   }
 }
 
-void GestureRecognizerImpl::CancelTouches(
-    std::vector<std::pair<int, GestureConsumer*> >* touches) {
-  while (!touches->empty()) {
-    int touch_id = touches->begin()->first;
-    GestureConsumer* target = touches->begin()->second;
-    TouchEvent touch_event(ui::ET_TOUCH_CANCELLED, gfx::PointF(0, 0),
-                           ui::EF_IS_SYNTHESIZED, touch_id,
-                           ui::EventTimeForNow(), 0.0f, 0.0f, 0.0f, 0.0f);
-    GestureEventHelper* helper = FindDispatchHelperForConsumer(target);
-    if (helper)
-      helper->DispatchCancelTouchEvent(&touch_event);
-    touches->erase(touches->begin());
-  }
-}
-
 void GestureRecognizerImpl::DispatchGestureEvent(GestureEvent* event) {
   GestureConsumer* consumer = GetTargetForGestureEvent(*event);
   if (consumer) {
     GestureEventHelper* helper = FindDispatchHelperForConsumer(consumer);
     if (helper)
       helper->DispatchGestureEvent(event);
   }
 }
 
 bool GestureRecognizerImpl::ProcessTouchEventPreDispatch(
@@ skipping 101 matching lines @@
   std::vector<GestureEventHelper*>::iterator it;
   for (it = helpers.begin(); it != helpers.end(); ++it)
     gesture_recognizer->AddGestureEventHelper(*it);
 
   helpers.clear();
   g_gesture_recognizer_instance =
       static_cast<GestureRecognizerImpl*>(gesture_recognizer);
 }
 
 }  // namespace ui