Change ui::Event::time_stamp from TimeDelta to TimeTicks

ui/events/ozone/evdev/touch_event_converter_evdev.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/ozone/evdev/touch_event_converter_evdev.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/input.h>
 #include <poll.h>
@@ skipping 354 matching lines @@
     default:
       DVLOG(5) << "unhandled code for EV_ABS: " << input.code;
       return;
   }
   events_[current_slot_].altered = true;
 }
 
 void TouchEventConverterEvdev::ProcessSyn(const input_event& input) {
   switch (input.code) {
     case SYN_REPORT:
-      ReportEvents(EventConverterEvdev::TimeDeltaFromInputEvent(input));
+      ReportEvents(EventConverterEvdev::TimeTicksFromInputEvent(input));
       break;
     case SYN_DROPPED:
       // Some buffer has overrun. We ignore all events up to and
       // including the next SYN_REPORT.
       dropped_events_ = true;
       break;
     default:
       NOTIMPLEMENTED() << "invalid code for EV_SYN: " << input.code;
   }
 }
 
 EventType TouchEventConverterEvdev::GetEventTypeForTouch(
     const InProgressTouchEvdev& touch) {
   if (touch.cancelled)
     return ET_UNKNOWN;
 
   if (touch_noise_finder_ && touch_noise_finder_->SlotHasNoise(touch.slot)) {
     if (touch.touching && !touch.was_touching)
       return ET_UNKNOWN;
     return ET_TOUCH_CANCELLED;
   }
 
   if (touch.touching)
     return touch.was_touching ? ET_TOUCH_MOVED : ET_TOUCH_PRESSED;
   return touch.was_touching ? ET_TOUCH_RELEASED : ET_UNKNOWN;
 }
 
 void TouchEventConverterEvdev::ReportEvent(const InProgressTouchEvdev& event,
                                            EventType event_type,
-                                           const base::TimeDelta& timestamp) {
+                                           base::TimeTicks timestamp) {
   PointerDetails details(GetPointerTypeFromEvent(event), event.radius_x,
                          event.radius_y, event.pressure,
                          /* tilt_x */ 0.0f,
                          /* tilt_y */ 0.0f);
   dispatcher_->DispatchTouchEvent(
       TouchEventParams(input_device_.id, event.slot, event_type,
                        gfx::PointF(event.x, event.y), details, timestamp));
 }
 
-void TouchEventConverterEvdev::ReportEvents(base::TimeDelta delta) {
+void TouchEventConverterEvdev::ReportEvents(base::TimeTicks timestamp) {
   if (dropped_events_) {
     Reinitialize();
     dropped_events_ = false;
   }
 
   if (touch_noise_finder_)
-    touch_noise_finder_->HandleTouches(events_, delta);
+    touch_noise_finder_->HandleTouches(events_, timestamp);
 
   for (size_t i = 0; i < events_.size(); i++) {
     InProgressTouchEvdev* event = &events_[i];
     if (!event->altered)
       continue;
 
     EventType event_type = GetEventTypeForTouch(*event);
     if (event_type == ET_UNKNOWN || event_type == ET_TOUCH_CANCELLED)
       event->cancelled = true;
 
     if (event_type != ET_UNKNOWN)
-      ReportEvent(*event, event_type, delta);
+      ReportEvent(*event, event_type, timestamp);
 
     event->was_touching = event->touching;
     event->altered = false;
   }
 }
 
 void TouchEventConverterEvdev::UpdateTrackingId(int slot, int tracking_id) {
   InProgressTouchEvdev* event = &events_[slot];
 
   if (event->tracking_id == tracking_id)
@@ skipping 19 matching lines @@
   if (pressure_max_ - pressure_min_)
     pressure /= pressure_max_ - pressure_min_;
   return pressure;
 }
 
 int TouchEventConverterEvdev::NextTrackingId() {
   return next_tracking_id_++ & kMaxTrackingId;
 }
 
 }  // namespace ui