Add id properties to PointerEvent

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 <stddef.h>
 
 #include <limits>
 #include <memory>
@@ skipping 47 matching lines @@
 GestureRecognizerImpl::GestureRecognizerImpl() {
 }
 
 GestureRecognizerImpl::~GestureRecognizerImpl() {
 }
 
 // Checks if this finger is already down, if so, returns the current target.
 // Otherwise, returns NULL.
 GestureConsumer* GestureRecognizerImpl::GetTouchLockedTarget(
     const TouchEvent& event) {
-  return touch_id_target_[event.touch_id()];
+  return touch_id_target_[event.pointer_details().id];
 }
 
 GestureConsumer* GestureRecognizerImpl::GetTargetForLocation(
     const gfx::PointF& location, int source_device_id) {
   const float max_distance =
       GestureConfiguration::GetInstance()
           ->max_separation_for_gesture_touches_in_pixels();
 
   gfx::PointF closest_point;
   int closest_touch_id = 0;
@@ skipping 81 matching lines @@
   // but has some pointers down which need cancelling. In order to ensure that
   // the GR sees a valid event stream, inform it of these pointers via
   // OnTouchEnter, and then synthesize a touch cancel per pointer.
   if (should_cancel_touches ==
           GestureRecognizer::ShouldCancelTouches::Cancel &&
       helper) {
     GestureProviderAura* gesture_provider =
         GetGestureProviderForConsumer(current_consumer);
 
     for (std::unique_ptr<TouchEvent>& event : cancelling_touches) {
-      gesture_provider->OnTouchEnter(event->touch_id(), event->x(), event->y());
+      gesture_provider->OnTouchEnter(event->pointer_details().id, event->x(),
+                                     event->y());
       helper->DispatchSyntheticTouchEvent(event.get());
     }
   }
 
   for (int touch_id : touchids_targeted_at_current)
     touch_id_target_[touch_id] = new_consumer;
 }
 
 bool GestureRecognizerImpl::GetLastTouchPointForTarget(
     GestureConsumer* consumer,
@@ skipping 55 matching lines @@
     gesture_provider = new GestureProviderAura(consumer, this);
     consumer_gesture_provider_[consumer] = base::WrapUnique(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());
+    touch_id_target_.erase(event.pointer_details().id);
   } else if (event.type() == ui::ET_TOUCH_PRESSED) {
-    touch_id_target_[event.touch_id()] = target;
+    touch_id_target_[event.pointer_details().id] = target;
   }
 }
 
 void GestureRecognizerImpl::DispatchGestureEvent(
     GestureConsumer* raw_input_consumer,
     GestureEvent* event) {
   if (raw_input_consumer) {
     GestureEventHelper* helper =
         FindDispatchHelperForConsumer(raw_input_consumer);
     if (helper)
@@ skipping 91 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