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 247 matching lines @@
       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) {

[tdresser, 2014/08/13 19:57:58]

Can't we just look up the GestureProvider here, and get the touch position?

GestureProviderAura* gesture_provider =
      consumer_gesture_provider_[consumer];
const MotionEventAura& pointer_state = gesture_provider->pointer_state();

and then get the index of the touch and look up it's position here?

I'm not clear on why we need the map etc.

[lanwei, 2014/08/14 00:38:46]

Yes, we can, but I feel if we do this for each touch_id, it is kind of slow,
because finding the index of the touch point will go through all the points in
the pointer_state. Thus I decide to go through the pointer_state once and get
the map and then find the corresponding touch location for the touch id will be
fast.

[tdresser, 2014/08/14 12:16:39]

An n^2 algorithm when n nearly always 1 or 2 isn't too bad, but it's a good
thought.

You could use a map local to this function, which I think would be a bit clearer
than what you currently have. On average though, I expect  the n^2 approach will
be faster.

Based on our small_map implementation
(https://code.google.com/p/chromium/codesearch#chromium/src/base/containers/sm...),
we think it's faster to use an n^2 search when n<=4. This will be true in almost
all cases, so I don't think it's worth the overhead.

+  std::map<int, gfx::PointF> map =
+      GroupGestureConsumerWithTouchPoints(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),
+    gfx::PointF point(0, 0);
+    if(map.count(touch_id) > 0) {
+      point = map[touch_id];
+    }
+    TouchEvent touch_event(ui::ET_TOUCH_CANCELLED, point,
                            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());
   }
 }
 
+std::map<int, gfx::PointF>
+GestureRecognizerImpl::GroupGestureConsumerWithTouchPoints(
+    std::vector<std::pair<int, GestureConsumer*> >* touches) {
+  std::map<int, gfx::PointF> map;
+  std::set<GestureConsumer*> consumerSet;
+  for (std::vector<std::pair<int, GestureConsumer*> >::iterator
+      it = touches->begin(); it != touches->end(); ++it) {
+    consumerSet.insert(it->second);
+  }
+  for (std::set<GestureConsumer*>::iterator iter = consumerSet.begin();
+      iter != consumerSet.end(); ++iter) {
+    std::map<int, gfx::PointF> subMap = MapTouchIDWithPointLocation(*iter);
+    map.insert(subMap.begin(), subMap.end());
+  }
+  return map;
+}
+
+std::map<int, gfx::PointF> GestureRecognizerImpl::MapTouchIDWithPointLocation(
+    GestureConsumer* consumer) {
+  std::map<int, gfx::PointF> map;
+  if (use_unified_gesture_detector_) {
+    GestureProviderAura* gesture_provider =
+        consumer_gesture_provider_[consumer];
+    const MotionEventAura& pointer_state = gesture_provider->pointer_state();
+    for (size_t i = 0; i < pointer_state.GetPointerCount(); ++i) {
+      gfx::PointF point(pointer_state.GetX(i), pointer_state.GetY(i));
+      map[pointer_state.GetPointerId(i)] = point;
+    }
+  }
+  return map;
+}
+
 void GestureRecognizerImpl::DispatchGestureEvent(GestureEvent* event) {
   GestureConsumer* consumer = GetTargetForGestureEvent(*event);
   if (consumer) {
     GestureEventHelper* helper = FindDispatchHelperForConsumer(consumer);
     if (helper)
       helper->DispatchGestureEvent(event);
   }
 }
 
 bool GestureRecognizerImpl::ProcessTouchEventPreDispatch(
@@ skipping 128 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