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

ui/events/event_unittest.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/event.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 72 matching lines @@
 
 TEST(EventTest, RepeatedClick) {
   const gfx::Point origin(0, 0);
   MouseEvent mouse_ev1(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(), 0,
                        0);
   MouseEvent mouse_ev2(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(), 0,
                        0);
   LocatedEventTestApi test_ev1(&mouse_ev1);
   LocatedEventTestApi test_ev2(&mouse_ev2);
 
-  base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
-  base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1);
-  base::TimeDelta later = start + base::TimeDelta::FromMilliseconds(1000);
+  base::TimeTicks start = base::TimeTicks();
+  base::TimeTicks soon = start + base::TimeDelta::FromMilliseconds(1);
+  base::TimeTicks later = start + base::TimeDelta::FromMilliseconds(1000);
 
   // Same event.
   test_ev1.set_location(gfx::Point(0, 0));
   test_ev2.set_location(gfx::Point(1, 0));
   test_ev1.set_time_stamp(start);
   test_ev2.set_time_stamp(start);
   EXPECT_FALSE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2));
   MouseEvent mouse_ev3(mouse_ev1);
   EXPECT_FALSE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev3));
 
@@ skipping 20 matching lines @@
 }
 
 // Tests that an event only increases the click count and gets marked as a
 // double click if a release event was seen for the previous click. This
 // prevents the same PRESSED event from being processed twice:
 // http://crbug.com/389162
 TEST(EventTest, DoubleClickRequiresRelease) {
   const gfx::Point origin1(0, 0);
   const gfx::Point origin2(100, 0);
   std::unique_ptr<MouseEvent> ev;
-  base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
-  base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1);
+  base::TimeTicks start = base::TimeTicks();
+  base::TimeTicks soon = start + base::TimeDelta::FromMilliseconds(1);
 
   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin1, origin1, EventTimeForNow(),
                           0, 0));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin1, origin1, EventTimeForNow(),
                           0, 0));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
 
@@ skipping 14 matching lines @@
   ev->set_time_stamp(soon);
   EXPECT_EQ(2, MouseEvent::GetRepeatCount(*ev));
   MouseEvent::ResetLastClickForTest();
 }
 
 // Tests that clicking right and then left clicking does not generate a double
 // click.
 TEST(EventTest, SingleClickRightLeft) {
   const gfx::Point origin(0, 0);
   std::unique_ptr<MouseEvent> ev;
-  base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
-  base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1);
+  base::TimeTicks start = base::TimeTicks();
+  base::TimeTicks soon = start + base::TimeDelta::FromMilliseconds(1);
 
   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(),
                           ui::EF_RIGHT_MOUSE_BUTTON,
                           ui::EF_RIGHT_MOUSE_BUTTON));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(),
                           ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
@@ skipping 377 matching lines @@
     EXPECT_FALSE(key_a1.is_repeat());
 
     KeyEvent key_a1_with_same_event(native_event_a_pressed);
     EXPECT_FALSE(key_a1_with_same_event.is_repeat());
   }
 #endif
 }
 #endif  // USE_X11 || OS_WIN
 
 TEST(EventTest, TouchEventRadiusDefaultsToOtherAxis) {
-  const base::TimeDelta time = base::TimeDelta::FromMilliseconds(0);
+  const base::TimeTicks time = base::TimeTicks();
   const float non_zero_length1 = 30;
   const float non_zero_length2 = 46;
 
   TouchEvent event1(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
                     non_zero_length1, 0, 0, 0);
   EXPECT_EQ(non_zero_length1, event1.pointer_details().radius_x);
   EXPECT_EQ(non_zero_length1, event1.pointer_details().radius_y);
 
   TouchEvent event2(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
                     0, non_zero_length2, 0, 0);
   EXPECT_EQ(non_zero_length2, event2.pointer_details().radius_x);
   EXPECT_EQ(non_zero_length2, event2.pointer_details().radius_y);
 }
 
 TEST(EventTest, TouchEventRotationAngleFixing) {
-  const base::TimeDelta time = base::TimeDelta::FromMilliseconds(0);
+  const base::TimeTicks time = base::TimeTicks();
   const float radius_x = 20;
   const float radius_y = 10;
 
   {
     const float angle_in_range = 0;
     TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
                       radius_x, radius_y, angle_in_range, 0);
     EXPECT_FLOAT_EQ(angle_in_range, event.rotation_angle());
   }
 
@@ skipping 129 matching lines @@
   EXPECT_EQ(-45.0f, touch_event.pointer_details().tilt_y);
   EXPECT_EQ(5.0f, touch_event.pointer_details().radius_x);
   EXPECT_EQ(6.0f, touch_event.pointer_details().radius_y);
 
   ui::TouchEvent touch_event_copy(touch_event);
   EXPECT_EQ(touch_event.pointer_details(), touch_event_copy.pointer_details());
 }
 
 TEST(EventTest, PointerEventCanConvertFrom) {
   const gfx::Point point;
-  const base::TimeDelta time;
+  const base::TimeTicks time;
 
   // Common mouse events can be converted.
   const EventType mouse_allowed[] = {
       ET_MOUSE_PRESSED,
       ET_MOUSE_DRAGGED,
       ET_MOUSE_MOVED,
       ET_MOUSE_ENTERED,
       ET_MOUSE_EXITED,
       ET_MOUSE_RELEASED
   };
@@ skipping 41 matching lines @@
   };
   const ui::EventType kTouchTypeMap[][2] = {
       {ui::ET_TOUCH_PRESSED, ui::ET_POINTER_DOWN},
       {ui::ET_TOUCH_MOVED, ui::ET_POINTER_MOVED},
       {ui::ET_TOUCH_RELEASED, ui::ET_POINTER_UP},
       {ui::ET_TOUCH_CANCELLED, ui::ET_POINTER_CANCELLED},
   };
 
   for (size_t i = 0; i < arraysize(kMouseTypeMap); i++) {
     ui::MouseEvent mouse_event(kMouseTypeMap[i][0], gfx::Point(0, 0),
-                               gfx::Point(0, 0), base::TimeDelta(), 0, 0);
+                               gfx::Point(0, 0), base::TimeTicks(), 0, 0);
     ui::PointerEvent pointer_event(mouse_event);
     EXPECT_EQ(kMouseTypeMap[i][1], pointer_event.type());
     EXPECT_FALSE(pointer_event.IsMouseEvent());
     EXPECT_FALSE(pointer_event.IsTouchEvent());
     EXPECT_TRUE(pointer_event.IsPointerEvent());
   }
 
   for (size_t i = 0; i < arraysize(kTouchTypeMap); i++) {
     ui::TouchEvent touch_event(kTouchTypeMap[i][0], gfx::Point(0, 0), 0,
-                               base::TimeDelta());
+                               base::TimeTicks());
     ui::PointerEvent pointer_event(touch_event);
     EXPECT_EQ(kTouchTypeMap[i][1], pointer_event.type());
     EXPECT_FALSE(pointer_event.IsMouseEvent());
     EXPECT_FALSE(pointer_event.IsTouchEvent());
     EXPECT_TRUE(pointer_event.IsPointerEvent());
   }
 }
 
 TEST(EventTest, PointerEventId) {
   {
     ui::MouseEvent mouse_event(ui::ET_MOUSE_PRESSED, gfx::Point(0, 0),
-                               gfx::Point(0, 0), base::TimeDelta(), 0, 0);
+                               gfx::Point(0, 0), base::TimeTicks(), 0, 0);
     ui::PointerEvent pointer_event(mouse_event);
     EXPECT_EQ(pointer_event.pointer_id(), ui::PointerEvent::kMousePointerId);
   }
 
   for (int touch_id = 0; touch_id < 8; touch_id++) {
     ui::TouchEvent touch_event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), touch_id,
-                               base::TimeDelta());
+                               base::TimeTicks());
     ui::PointerEvent pointer_event(touch_event);
     EXPECT_EQ(pointer_event.pointer_id(), touch_id);
   }
 }
 
 TEST(EventTest, PointerDetailsPointer) {
   const float kRadiusX = 10.0f;
   const float kRadiusY = 5.0f;
   const float kForce = 15.0f;
   ui::TouchEvent touch_event(ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0,
@@ skipping 86 matching lines @@
       {ui::ET_POINTER_EXITED, ui::ET_MOUSE_EXITED, gfx::Point(5, 1),
        gfx::Point(1, 5), EF_RIGHT_MOUSE_BUTTON},
       {ui::ET_POINTER_UP, ui::ET_MOUSE_RELEASED, gfx::Point(1000, 1000),
        gfx::Point(14, 15), EF_MIDDLE_MOUSE_BUTTON}};
 
   for (size_t i = 0; i < arraysize(kTestData); i++) {
     ui::PointerEvent pointer_event(
         kTestData[i].in_type, kTestData[i].location, kTestData[i].root_location,
         kTestData[i].flags, 0,
         ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_MOUSE),
-        base::TimeDelta());
+        base::TimeTicks());
     ui::MouseEvent mouse_event(pointer_event);
 
     EXPECT_EQ(kTestData[i].out_type, mouse_event.type());
     EXPECT_EQ(kTestData[i].location, mouse_event.location());
     EXPECT_EQ(kTestData[i].root_location, mouse_event.root_location());
     EXPECT_EQ(kTestData[i].flags, mouse_event.flags());
   }
 }
 
 TEST(EventTest, PointerEventToTouchEventType) {
   ui::EventType kTouchTypeMap[][2] = {
       {ui::ET_POINTER_DOWN, ui::ET_TOUCH_PRESSED},
       {ui::ET_POINTER_MOVED, ui::ET_TOUCH_MOVED},
       {ui::ET_POINTER_UP, ui::ET_TOUCH_RELEASED},
       {ui::ET_POINTER_CANCELLED, ui::ET_TOUCH_CANCELLED},
   };
 
   for (size_t i = 0; i < arraysize(kTouchTypeMap); i++) {
     ui::PointerEvent pointer_event(
         kTouchTypeMap[i][0], gfx::Point(), gfx::Point(), 0, 0,
         ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH),
-        base::TimeDelta());
+        base::TimeTicks());
     ui::TouchEvent touch_event(pointer_event);
 
     EXPECT_EQ(kTouchTypeMap[i][1], touch_event.type());
   }
 }
 
 TEST(EventTest, PointerEventToTouchEventDetails) {
   ui::PointerEvent pointer_event(
       ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(12, 14), 0, 15,
                      EventTimeForNow(), 11.5, 13.5, 13.0, 0.5));
@@ skipping 52 matching lines @@
   XButtonEvent* button_event = &(native_event.xbutton);
   button_event->type = ButtonPress;
   button_event->button = 4; // A valid wheel button number between min and max.
   MouseWheelEvent mouse_ev(&native_event);
 
   histogram_tester.ExpectTotalCount("Event.Latency.OS.MOUSE_WHEEL", 1);
 #endif
 }
 
 }  // namespace ui