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_;
+uint32 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 103 matching lines @@
   return make_scoped_ptr(new MotionEventGeneric(event, with_history));
 }
 
 // static
 scoped_ptr<MotionEventGeneric> MotionEventGeneric::CancelEvent(
     const MotionEvent& event) {
   bool with_history = false;
   scoped_ptr<MotionEventGeneric> cancel_event(
       new MotionEventGeneric(event, with_history));
   cancel_event->set_action(ACTION_CANCEL);
+  cancel_event->set_unique_event_id(ui::GetNextTouchEventId());
   return cancel_event.Pass();
 }
 
 size_t MotionEventGeneric::PushPointer(const PointerProperties& pointer) {
   DCHECK_EQ(0U, GetHistorySize());
   pointers_->push_back(pointer);
   return pointers_->size() - 1;
 }
 
 void MotionEventGeneric::RemovePointerAt(size_t index) {
   DCHECK_LT(index, pointers_->size());
   pointers_->erase(pointers_->begin() + index);
 }
 
 void MotionEventGeneric::PushHistoricalEvent(scoped_ptr<MotionEvent> event) {
   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()),
+      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