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

ui/events/ozone/evdev/touch_event_converter_evdev_unittest.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 <linux/input.h>
 #include <stddef.h>
 #include <unistd.h>
@@ skipping 255 matching lines @@
       {time, EV_SYN, SYN_REPORT, 0},
   };
 
   // Press.
   dev->ConfigureReadMock(mock_kernel_queue_press,
                          arraysize(mock_kernel_queue_press), 0);
   dev->ReadNow();
   EXPECT_EQ(1u, size());
   ui::TouchEventParams event = dispatched_event(0);
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, event.type);
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(1427323282019203),
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(1427323282019203),
             event.timestamp);
   EXPECT_EQ(295, event.location.x());
   EXPECT_EQ(421, event.location.y());
   EXPECT_EQ(0, event.slot);
   EXPECT_EQ(EventPointerType::POINTER_TYPE_TOUCH,
             event.pointer_details.pointer_type);
   EXPECT_FLOAT_EQ(58.f, event.pointer_details.radius_x);
   EXPECT_FLOAT_EQ(0.13333334f, event.pointer_details.force);
 
   // Move.
   dev->ConfigureReadMock(mock_kernel_queue_move,
                          arraysize(mock_kernel_queue_move), 0);
   dev->ReadNow();
   EXPECT_EQ(2u, size());
   event = dispatched_event(1);
   EXPECT_EQ(ui::ET_TOUCH_MOVED, event.type);
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(1427323282034693),
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(1427323282034693),
             event.timestamp);
   EXPECT_EQ(312, event.location.x());
   EXPECT_EQ(432, event.location.y());
   EXPECT_EQ(0, event.slot);
   EXPECT_EQ(EventPointerType::POINTER_TYPE_TOUCH,
             event.pointer_details.pointer_type);
   EXPECT_FLOAT_EQ(50.f, event.pointer_details.radius_x);
   EXPECT_FLOAT_EQ(0.16862745f, event.pointer_details.force);
 
   // Release.
   dev->ConfigureReadMock(mock_kernel_queue_release,
                          arraysize(mock_kernel_queue_release), 0);
   dev->ReadNow();
   EXPECT_EQ(3u, size());
   event = dispatched_event(2);
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, event.type);
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(1427323282144540),
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(1427323282144540),
             event.timestamp);
   EXPECT_EQ(312, event.location.x());
   EXPECT_EQ(432, event.location.y());
   EXPECT_EQ(0, event.slot);
   EXPECT_EQ(EventPointerType::POINTER_TYPE_TOUCH,
             event.pointer_details.pointer_type);
   EXPECT_FLOAT_EQ(50.f, event.pointer_details.radius_x);
   EXPECT_FLOAT_EQ(0.16862745f, event.pointer_details.force);
 }
 
@@ skipping 32 matching lines @@
   };
   // Move on 0, press on 1.
   dev->ConfigureReadMock(mock_kernel_queue_move0press1, 9, 0);
   dev->ReadNow();
   EXPECT_EQ(4u, size());
   ui::TouchEventParams ev0 = dispatched_event(2);
   ui::TouchEventParams ev1 = dispatched_event(3);
 
   // Move
   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev0.type);
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev0.timestamp);
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev0.timestamp);
   EXPECT_EQ(40, ev0.location.x());
   EXPECT_EQ(51, ev0.location.y());
   EXPECT_EQ(0, ev0.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev0.pointer_details.force);
 
   // Press
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, ev1.type);
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1.timestamp);
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev1.timestamp);
   EXPECT_EQ(101, ev1.location.x());
   EXPECT_EQ(102, ev1.location.y());
   EXPECT_EQ(1, ev1.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev1.pointer_details.force);
 
   // Stationary 0, Moves 1.
   struct input_event mock_kernel_queue_stationary0_move1[] = {
     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
   };
   dev->ConfigureReadMock(mock_kernel_queue_stationary0_move1, 2, 0);
   dev->ReadNow();
   EXPECT_EQ(5u, size());
   ev1 = dispatched_event(4);
 
   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev1.type);
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1.timestamp);
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev1.timestamp);
   EXPECT_EQ(40, ev1.location.x());
   EXPECT_EQ(102, ev1.location.y());
   EXPECT_EQ(1, ev1.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev1.pointer_details.force);
 
   // Move 0, stationary 1.
   struct input_event mock_kernel_queue_move0_stationary1[] = {
     {{0, 0}, EV_ABS, ABS_MT_SLOT, 0}, {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 39},
     {{0, 0}, EV_SYN, SYN_REPORT, 0}
   };
   dev->ConfigureReadMock(mock_kernel_queue_move0_stationary1, 3, 0);
   dev->ReadNow();
   EXPECT_EQ(6u, size());
   ev0 = dispatched_event(5);
 
   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev0.type);
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev0.timestamp);
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev0.timestamp);
   EXPECT_EQ(39, ev0.location.x());
   EXPECT_EQ(51, ev0.location.y());
   EXPECT_EQ(0, ev0.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev0.pointer_details.force);
 
   // Release 0, move 1.
   struct input_event mock_kernel_queue_release0_move1[] = {
     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1}, {{0, 0}, EV_ABS, ABS_MT_SLOT, 1},
     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 38}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
   };
   dev->ConfigureReadMock(mock_kernel_queue_release0_move1, 4, 0);
   dev->ReadNow();
   EXPECT_EQ(8u, size());
   ev0 = dispatched_event(6);
   ev1 = dispatched_event(7);
 
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, ev0.type);
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev0.timestamp);
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev0.timestamp);
   EXPECT_EQ(39, ev0.location.x());
   EXPECT_EQ(51, ev0.location.y());
   EXPECT_EQ(0, ev0.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev0.pointer_details.force);
 
   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev1.type);
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1.timestamp);
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev1.timestamp);
   EXPECT_EQ(38, ev1.location.x());
   EXPECT_EQ(102, ev1.location.y());
   EXPECT_EQ(1, ev1.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev1.pointer_details.force);
 
   // Release 1.
   struct input_event mock_kernel_queue_release1[] = {
     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1}, {{0, 0}, EV_SYN, SYN_REPORT, 0},
   };
   dev->ConfigureReadMock(mock_kernel_queue_release1, 2, 0);
   dev->ReadNow();
   EXPECT_EQ(9u, size());
   ev1 = dispatched_event(8);
 
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, ev1.type);
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1.timestamp);
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev1.timestamp);
   EXPECT_EQ(38, ev1.location.x());
   EXPECT_EQ(102, ev1.location.y());
   EXPECT_EQ(1, ev1.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev1.pointer_details.force);
 }
 
 TEST_F(TouchEventConverterEvdevTest, Unsync) {
   ui::MockTouchEventConverterEvdev* dev = device();
 
   InitPixelTouchscreen(dev);
@@ skipping 202 matching lines @@
       {time, EV_SYN, SYN_REPORT, 0},
   };
 
   // Press.
   dev->ConfigureReadMock(mock_kernel_queue_press,
                          arraysize(mock_kernel_queue_press), 0);
   dev->ReadNow();
   EXPECT_EQ(1u, size());
   ui::TouchEventParams event = dispatched_event(0);
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, event.type);
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(1433965490837958),
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(1433965490837958),
             event.timestamp);
   EXPECT_EQ(3654, event.location.x());
   EXPECT_EQ(1055, event.location.y());
   EXPECT_EQ(0, event.slot);
   EXPECT_FLOAT_EQ(0.f, event.pointer_details.radius_x);
   EXPECT_FLOAT_EQ(0.f, event.pointer_details.force);
 
   // Move.
   dev->ConfigureReadMock(mock_kernel_queue_move,
                          arraysize(mock_kernel_queue_move), 0);
   dev->ReadNow();
   EXPECT_EQ(2u, size());
   event = dispatched_event(1);
   EXPECT_EQ(ui::ET_TOUCH_MOVED, event.type);
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(1433965491001953),
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(1433965491001953),
             event.timestamp);
   EXPECT_EQ(3644, event.location.x());
   EXPECT_EQ(1059, event.location.y());
   EXPECT_EQ(0, event.slot);
   EXPECT_FLOAT_EQ(0.f, event.pointer_details.radius_x);
   EXPECT_FLOAT_EQ(0.f, event.pointer_details.force);
 
   // Release.
   dev->ConfigureReadMock(mock_kernel_queue_release,
                          arraysize(mock_kernel_queue_release), 0);
   dev->ReadNow();
   EXPECT_EQ(3u, size());
   event = dispatched_event(2);
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, event.type);
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(1433965491225959),
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(1433965491225959),
             event.timestamp);
   EXPECT_EQ(3644, event.location.x());
   EXPECT_EQ(1059, event.location.y());
   EXPECT_EQ(0, event.slot);
   EXPECT_FLOAT_EQ(0.f, event.pointer_details.radius_x);
   EXPECT_FLOAT_EQ(0.f, event.pointer_details.force);
 
   // No dispatch on destruction.
   DestroyDevice();
   EXPECT_EQ(3u, size());
@@ skipping 74 matching lines @@
 // - Considers all events of type |noise_event_type| as noise.
 // - Keeps track of the events that it receives.
 class EventTypeTouchNoiseFilter : public TouchNoiseFilter {
  public:
   explicit EventTypeTouchNoiseFilter(EventType noise_event_type)
       : noise_event_type_(noise_event_type) {}
   ~EventTypeTouchNoiseFilter() override {}
 
   // TouchNoiseFilter:
   void Filter(const std::vector<InProgressTouchEvdev>& touches,
-              base::TimeDelta time,
+              base::TimeTicks time,
               std::bitset<kNumTouchEvdevSlots>* slots_with_noise) override {
     for (const InProgressTouchEvdev& touch : touches) {
       EventType event_type = EventTypeFromTouch(touch);
       ++counts_[event_type];
       if (event_type == noise_event_type_)
         slots_with_noise->set(touch.slot);
     }
   }
 
   // Returns the number of received events of |type|.
@@ skipping 238 matching lines @@
   event = dispatched_event(3);
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, event.type);
   EXPECT_EQ(8930, event.location.x());
   EXPECT_EQ(980, event.location.y());
   EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
             event.pointer_details.pointer_type);
   EXPECT_EQ(0.f / 1024, event.pointer_details.force);
 }
 
 }  // namespace ui