Set the unique_event_id when converting from TouchEvent to WebTouchEvent

ui/events/gesture_detection/motion_event_generic.cc

 // Copyright 2014 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/gesture_detection/motion_event_generic.h"
 
 #include "base/logging.h"
+#include "ui/events/base_event_utils.h"
 
 namespace ui {
 
 PointerProperties::PointerProperties()
     : PointerProperties(0, 0, 0) {
 }
 
 PointerProperties::PointerProperties(float x, float y, float touch_major)
     : id(0),
       tool_type(MotionEvent::TOOL_TYPE_UNKNOWN),
@@ skipping 21 matching lines @@
       touch_minor(event.GetTouchMinor(pointer_index)),
       orientation(event.GetOrientation(pointer_index)),
       source_device_id(0) {
 }
 
 MotionEventGeneric::MotionEventGeneric(Action action,
                                        base::TimeTicks event_time,
                                        const PointerProperties& pointer)
     : action_(action),
       event_time_(event_time),
-      id_(0),
+      unique_event_id_(ui::GetNextTouchEventId()),
       action_index_(0),
       button_state_(0),
       flags_(0) {
   PushPointer(pointer);
 }
 
 MotionEventGeneric::MotionEventGeneric(const MotionEventGeneric& other)
     : action_(other.action_),
       event_time_(other.event_time_),
-      id_(other.id_),
+      unique_event_id_(other.unique_event_id_),
       action_index_(other.action_index_),
       button_state_(other.button_state_),
       flags_(other.flags_),
       pointers_(other.pointers_) {
   const size_t history_size = other.GetHistorySize();
   for (size_t h = 0; h < history_size; ++h)
     PushHistoricalEvent(other.historical_events_[h]->Clone());
 }
 
 MotionEventGeneric::~MotionEventGeneric() {
 }
 
-int MotionEventGeneric::GetId() const {
-  return id_;
+uint64 MotionEventGeneric::GetUniqueEventId() const {
+  return unique_event_id_;
 }
 
 MotionEvent::Action MotionEventGeneric::GetAction() const {
   return action_;
 }
 
 int MotionEventGeneric::GetActionIndex() const {
   DCHECK(action_ == ACTION_POINTER_DOWN || action_ == ACTION_POINTER_UP);
   DCHECK_GE(action_index_, 0);
   DCHECK_LT(action_index_, static_cast<int>(pointers_->size()));
@@ skipping 128 matching lines @@
   DCHECK(event);
   DCHECK_EQ(event->GetAction(), ACTION_MOVE);
   DCHECK_EQ(event->GetPointerCount(), GetPointerCount());
   DCHECK_EQ(event->GetAction(), GetAction());
   DCHECK_LE(event->GetEventTime().ToInternalValue(),
             GetEventTime().ToInternalValue());
   historical_events_.push_back(event.release());
 }
 
 MotionEventGeneric::MotionEventGeneric()
-    : action_(ACTION_CANCEL), id_(0), action_index_(0), button_state_(0) {
+    : action_(ACTION_CANCEL),
+      unique_event_id_(ui::GetNextTouchEventId()),

[jdduke (slow), 2015/04/21 22:40:16]

I can't say I love using globals, but this is probably the simplest thing to do
I guess.

[tdresser, 2015/04/22 12:59:00]

I agree, but I think that ensuring that these ids are unique across all forms of
input is worth it. I'm worries about cases where, for example, you're touching
the screen and using touch emulation at the same time, and you end up with
collisions.

[lanwei, 2015/04/22 20:51:31]

I also agree, in many cases such as for different platforms it does not matter
if they have same unique_event_id, but it is better to keep this way Tim gave an
good example.

+      action_index_(0),
+      button_state_(0) {
 }
 
 MotionEventGeneric::MotionEventGeneric(const MotionEvent& event,
                                        bool with_history)
     : action_(event.GetAction()),
       event_time_(event.GetEventTime()),
-      id_(event.GetId()),
+      unique_event_id_(event.GetUniqueEventId()),
       action_index_(
           (action_ == ACTION_POINTER_UP || action_ == ACTION_POINTER_DOWN)
               ? event.GetActionIndex()
               : 0),
       button_state_(event.GetButtonState()),
       flags_(event.GetFlags()) {
   const size_t pointer_count = event.GetPointerCount();
   for (size_t i = 0; i < pointer_count; ++i)
     PushPointer(PointerProperties(event, i));
 
@@ skipping 12 matching lines @@
                             event.GetHistoricalTouchMajor(i, h)));
     }
     PushHistoricalEvent(historical_event.Pass());
   }
 }
 
 MotionEventGeneric& MotionEventGeneric::operator=(
     const MotionEventGeneric& other) {
   action_ = other.action_;
   event_time_ = other.event_time_;
-  id_ = other.id_;
+  unique_event_id_ = other.unique_event_id_;
   action_index_ = other.action_index_;
   button_state_ = other.button_state_;
   flags_ = other.flags_;
   pointers_ = other.pointers_;
   const size_t history_size = other.GetHistorySize();
   for (size_t h = 0; h < history_size; ++h)
     PushHistoricalEvent(other.historical_events_[h]->Clone());
   return *this;
 }
 
 void MotionEventGeneric::PopPointer() {
   DCHECK_GT(pointers_->size(), 0U);
   pointers_->pop_back();
 }
 
 }  // namespace ui