Add time stamp to the constructor of the events

third_party/WebKit/Source/core/events/PointerEventFactoryTest.cpp

 // Copyright 2015 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 "core/events/PointerEventFactory.h"
 
 #include "core/frame/FrameView.h"
 #include "core/page/Page.h"
 #include "public/platform/WebPointerProperties.h"
 #include <climits>
@@ skipping 52 matching lines @@
    public:
     WebTouchPointBuilder(WebPointerProperties::PointerType,
                          int,
                          WebTouchPoint::State);
   };
 
   class WebMouseEventBuilder : public WebMouseEvent {
    public:
     WebMouseEventBuilder(WebPointerProperties::PointerType,
                          int,
-                         WebInputEvent::Modifiers);
+                         WebInputEvent::Modifiers,
+                         double);
   };
 };
 
 void PointerEventFactoryTest::SetUp() {
   expected_mouse_id_ = 1;
   mapped_id_start_ = 2;
 }
 
 PointerEventFactoryTest::WebTouchPointBuilder::WebTouchPointBuilder(
     WebPointerProperties::PointerType pointer_type_param,
     int id_param,
     WebTouchPoint::State state_param) {
   id = id_param;
   pointer_type = pointer_type_param;
   force = 1.0;
   state = state_param;
 }
 
 PointerEventFactoryTest::WebMouseEventBuilder::WebMouseEventBuilder(
     WebPointerProperties::PointerType pointer_type_param,
     int id_param,
-    WebInputEvent::Modifiers modifiers_param) {
+    WebInputEvent::Modifiers modifiers_param,
+    double platform_time_stamp) {
   pointer_type = pointer_type_param;
   id = id_param;
   modifiers_ = modifiers_param;
   frame_scale_ = 1;
+  time_stamp_seconds_ = platform_time_stamp;
 }
 
 PointerEvent* PointerEventFactoryTest::CreateAndCheckTouchCancel(
     WebPointerProperties::PointerType pointer_type,
     int raw_id,
     int unique_id,
     bool is_primary) {
-  PointerEvent* pointer_event =
-      pointer_event_factory_.CreatePointerCancelEvent(unique_id, pointer_type);
+  TimeTicks now = TimeTicks::Now();
+  PointerEvent* pointer_event = pointer_event_factory_.CreatePointerCancelEvent(
+      unique_id, pointer_type, now);
   EXPECT_EQ(unique_id, pointer_event->pointerId());
   EXPECT_EQ(is_primary, pointer_event->isPrimary());
   EXPECT_EQ(PointerTypeNameForWebPointPointerType(pointer_type),
             pointer_event->pointerType());
+  EXPECT_EQ(now, pointer_event->PlatformTimeStamp());
   return pointer_event;
 }
 
 void PointerEventFactoryTest::CreateAndCheckPointerTransitionEvent(
     PointerEvent* pointer_event,
     const AtomicString& type) {
   PointerEvent* clone_pointer_event =
       pointer_event_factory_.CreatePointerBoundaryEvent(pointer_event, type,
                                                         nullptr);
   EXPECT_EQ(clone_pointer_event->pointerType(), pointer_event->pointerType());
   EXPECT_EQ(clone_pointer_event->pointerId(), pointer_event->pointerId());
   EXPECT_EQ(clone_pointer_event->isPrimary(), pointer_event->isPrimary());
   EXPECT_EQ(clone_pointer_event->type(), type);
 }
 
 PointerEvent* PointerEventFactoryTest::CreateAndCheckTouchEvent(
     WebPointerProperties::PointerType pointer_type,
     int raw_id,
     int unique_id,
     bool is_primary,
     WebTouchPoint::State state,
     size_t coalesced_event_count) {
-  Vector<WebTouchPoint> coalesced_events;
+  Vector<std::pair<WebTouchPoint, TimeTicks>> coalesced_events;
+  TimeTicks now = TimeTicks::Now();
   for (size_t i = 0; i < coalesced_event_count; i++) {
-    coalesced_events.push_back(PointerEventFactoryTest::WebTouchPointBuilder(
-        pointer_type, raw_id, state));
+    coalesced_events.push_back(std::pair<WebTouchPoint, TimeTicks>(
+        PointerEventFactoryTest::WebTouchPointBuilder(pointer_type, raw_id,
+                                                      state),
+        now));
   }
   PointerEvent* pointer_event = pointer_event_factory_.Create(
       PointerEventFactoryTest::WebTouchPointBuilder(pointer_type, raw_id,
                                                     state),
-      coalesced_events, WebInputEvent::kNoModifiers, nullptr, nullptr);
+      coalesced_events, WebInputEvent::kNoModifiers, now, nullptr, nullptr);
   EXPECT_EQ(unique_id, pointer_event->pointerId());
   EXPECT_EQ(is_primary, pointer_event->isPrimary());
+  EXPECT_EQ(now, pointer_event->PlatformTimeStamp());
   const char* expected_pointer_type =
       PointerTypeNameForWebPointPointerType(pointer_type);
   EXPECT_EQ(expected_pointer_type, pointer_event->pointerType());
   EXPECT_EQ(coalesced_event_count, pointer_event->getCoalescedEvents().size());
   for (size_t i = 0; i < coalesced_event_count; i++) {
     EXPECT_EQ(unique_id, pointer_event->getCoalescedEvents()[i]->pointerId());
     EXPECT_EQ(is_primary, pointer_event->getCoalescedEvents()[i]->isPrimary());
     EXPECT_EQ(expected_pointer_type, pointer_event->pointerType());
+    EXPECT_EQ(now, pointer_event->PlatformTimeStamp());
   }
   return pointer_event;
 }
 
 PointerEvent* PointerEventFactoryTest::CreateAndCheckMouseEvent(
     WebPointerProperties::PointerType pointer_type,
     int raw_id,
     int unique_id,
     bool is_primary,
     WebInputEvent::Modifiers modifiers,
     size_t coalesced_event_count) {
   Vector<WebMouseEvent> coalesced_events;
+  double base_time = 123;

[dtapuska, 2017/04/24 15:27:43]

Can we use
https://cs.chromium.org/chromium/src/third_party/WebKit/public/platform/WebIn...
here?

[Navid Zolghadr, 2017/04/24 15:51:45]

Makes sense. Done.

   for (size_t i = 0; i < coalesced_event_count; i++) {
     coalesced_events.push_back(PointerEventFactoryTest::WebMouseEventBuilder(
-        pointer_type, raw_id, modifiers));
+        pointer_type, raw_id, modifiers, 123 + i));

[dtapuska, 2017/04/24 15:27:43]

Can this be base_time + i (instead of 123 + i) ?

[Navid Zolghadr, 2017/04/24 15:51:45]

Done.

   }
   PointerEvent* pointer_event = pointer_event_factory_.Create(
       coalesced_event_count ? EventTypeNames::mousemove
                             : EventTypeNames::mousedown,
       PointerEventFactoryTest::WebMouseEventBuilder(pointer_type, raw_id,
-                                                    modifiers),
+                                                    modifiers, base_time),
       coalesced_events, nullptr);
   EXPECT_EQ(unique_id, pointer_event->pointerId());
   EXPECT_EQ(is_primary, pointer_event->isPrimary());
+  EXPECT_EQ(TimeTicks::FromSeconds(base_time),
+            pointer_event->PlatformTimeStamp());
   const char* expected_pointer_type =
       PointerTypeNameForWebPointPointerType(pointer_type);
   EXPECT_EQ(expected_pointer_type, pointer_event->pointerType());
   EXPECT_EQ(coalesced_event_count, pointer_event->getCoalescedEvents().size());
   for (size_t i = 0; i < coalesced_event_count; i++) {
     EXPECT_EQ(unique_id, pointer_event->getCoalescedEvents()[i]->pointerId());
     EXPECT_EQ(is_primary, pointer_event->getCoalescedEvents()[i]->isPrimary());
     EXPECT_EQ(expected_pointer_type, pointer_event->pointerType());
+    EXPECT_EQ(TimeTicks::FromSeconds(base_time + i),
+              pointer_event->getCoalescedEvents()[i]->PlatformTimeStamp());
   }
   return pointer_event;
 }
 
 TEST_F(PointerEventFactoryTest, MousePointer) {
   EXPECT_TRUE(pointer_event_factory_.IsActive(expected_mouse_id_));
   EXPECT_FALSE(pointer_event_factory_.IsActiveButtonsState(expected_mouse_id_));
 
   PointerEvent* pointer_event1 = CreateAndCheckMouseEvent(
       WebPointerProperties::PointerType::kMouse, 0, expected_mouse_id_, true);
@@ skipping 262 matching lines @@
 TEST_F(PointerEventFactoryTest, CoalescedEvents) {
   CreateAndCheckMouseEvent(WebPointerProperties::PointerType::kMouse, 0,
                            expected_mouse_id_, true,
                            WebInputEvent::kNoModifiers, 4);
   CreateAndCheckTouchEvent(WebPointerProperties::PointerType::kTouch, 0,
                            mapped_id_start_, true, WebTouchPoint::kStateMoved,
                            3);
 }
 
 }  // namespace blink