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 147 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;
+  std::set<GestureConsumer*> consumers;

[tdresser, 2014/08/15 14:22:05]

Just use a vector, set has a lot more overhead.

[lanwei, 2014/08/27 03:54:03]

Done.

   for (TouchIdToConsumerMap::iterator i = touch_id_target_.begin();
-       i != touch_id_target_.end(); ++i) {
+      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));
+        (i->second != current_consumer || new_consumer == NULL)) {
+      consumers.insert(i->second);
     }
   }
-
-  CancelTouches(&ids);
-
+  for (std::set<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_);
     if (!use_unified_gesture_detector_)
       TransferConsumer(current_consumer, new_consumer, &consumer_sequence_);
     else
       TransferConsumer(
@@ skipping 13 matching lines @@
     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 (use_unified_gesture_detector_) {
+    if(consumer_gesture_provider_.count(consumer) == 0)
+      return false;
+    const MotionEventAura& pointer_state =
+        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, protected:
 
 GestureSequence* GestureRecognizerImpl::CreateSequence(
     GestureSequenceDelegate* delegate) {
   return new GestureSequence(delegate);
 }
@@ skipping 26 matching lines @@
   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 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