Add time stamp to the constructor of the events

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

 // Copyright 2016 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 "platform/geometry/FloatSize.h"
 
 namespace blink {
@@ skipping 268 matching lines @@
       // TODO(crbug.com/694742): We will set the id from low-level OS events
       // and enable this DCHECK again.
       // DCHECK_EQ(mouseEvent.id, coalescedMouseEvent.id);
 
       DCHECK_EQ(mouse_event.pointer_type, coalesced_mouse_event.pointer_type);
       PointerEventInit coalesced_event_init = pointer_event_init;
       coalesced_event_init.setCancelable(false);
       coalesced_event_init.setBubbles(false);
       UpdateMousePointerEventInit(coalesced_mouse_event, view,
                                   &coalesced_event_init);
-      PointerEvent* event =
-          PointerEvent::Create(pointer_event_name, coalesced_event_init);
+      PointerEvent* event = PointerEvent::Create(
+          pointer_event_name, coalesced_event_init,
+          TimeTicks::FromSeconds(coalesced_mouse_event.TimeStampSeconds()));
       // Set the trusted flag for the coalesced events at the creation time
       // as oppose to the normal events which is done at the dispatch time. This
       // is because we don't want to go over all the coalesced events at every
       // dispatch and add the implementation complexity while it has no sensible
       // usecase at this time.
       event->SetTrusted(true);
       coalesced_pointer_events.push_back(event);
     }
     pointer_event_init.setCoalescedEvents(coalesced_pointer_events);
   }
 
-  return PointerEvent::Create(pointer_event_name, pointer_event_init);
+  return PointerEvent::Create(
+      pointer_event_name, pointer_event_init,
+      TimeTicks::FromSeconds(mouse_event.TimeStampSeconds()));
 }
 
 PointerEvent* PointerEventFactory::Create(
     const WebTouchPoint& touch_point,
-    const Vector<WebTouchPoint>& coalesced_points,
+    const Vector<std::pair<WebTouchPoint, TimeTicks>>& coalesced_points,
     WebInputEvent::Modifiers modifiers,
+    TimeTicks event_platform_time_stamp,
     LocalFrame* target_frame,
     DOMWindow* view) {
   const WebTouchPoint::State point_state = touch_point.state;
   const AtomicString& type =
       PointerEventNameForTouchPointState(touch_point.state);
 
   bool pointer_released_or_cancelled =
       point_state == WebTouchPoint::State::kStateReleased ||
       point_state == WebTouchPoint::State::kStateCancelled;
   bool pointer_pressed_or_released =
@@ skipping 12 matching lines @@
   UpdateTouchPointerEventInit(touch_point, target_frame, &pointer_event_init);
 
   UIEventWithKeyState::SetFromWebInputEventModifiers(pointer_event_init,
                                                      modifiers);
 
   SetEventSpecificFields(pointer_event_init, type);
 
   if (type == EventTypeNames::pointermove) {
     HeapVector<Member<PointerEvent>> coalesced_pointer_events;
     for (const auto& coalesced_touch_point : coalesced_points) {
-      DCHECK_EQ(touch_point.state, coalesced_touch_point.state);
-      DCHECK_EQ(touch_point.id, coalesced_touch_point.id);
-      DCHECK_EQ(touch_point.pointer_type, coalesced_touch_point.pointer_type);
+      const auto& coalesced_point = coalesced_touch_point.first;
+      const auto& coalesced_point_time_stamp = coalesced_touch_point.second;
+      DCHECK_EQ(touch_point.state, coalesced_point.state);
+      DCHECK_EQ(touch_point.id, coalesced_point.id);
+      DCHECK_EQ(touch_point.pointer_type, coalesced_point.pointer_type);
       PointerEventInit coalesced_event_init = pointer_event_init;
       coalesced_event_init.setCancelable(false);
       coalesced_event_init.setBubbles(false);
-      UpdateTouchPointerEventInit(coalesced_touch_point, target_frame,
+      UpdateTouchPointerEventInit(coalesced_point, target_frame,
                                   &coalesced_event_init);
-      PointerEvent* event = PointerEvent::Create(type, coalesced_event_init);
+      PointerEvent* event = PointerEvent::Create(type, coalesced_event_init,
+                                                 coalesced_point_time_stamp);
       // Set the trusted flag for the coalesced events at the creation time
       // as oppose to the normal events which is done at the dispatch time. This
       // is because we don't want to go over all the coalesced events at every
       // dispatch and add the implementation complexity while it has no sensible
       // usecase at this time.
       event->SetTrusted(true);
       coalesced_pointer_events.push_back(event);
     }
     pointer_event_init.setCoalescedEvents(coalesced_pointer_events);
   }
 
-  return PointerEvent::Create(type, pointer_event_init);
+  return PointerEvent::Create(type, pointer_event_init,
+                              event_platform_time_stamp);
 }
 
 PointerEvent* PointerEventFactory::CreatePointerCancelEvent(
     const int pointer_id,
-    const WebPointerProperties::PointerType pointer_type) {
+    const WebPointerProperties::PointerType pointer_type,
+    TimeTicks platfrom_time_stamp) {
   DCHECK(pointer_id_mapping_.Contains(pointer_id));
   pointer_id_mapping_.Set(
       pointer_id,
       PointerAttributes(pointer_id_mapping_.at(pointer_id).incoming_id, false));
 
   PointerEventInit pointer_event_init;
 
   pointer_event_init.setPointerId(pointer_id);
   pointer_event_init.setPointerType(
       PointerTypeNameForWebPointPointerType(pointer_type));
   pointer_event_init.setIsPrimary(IsPrimary(pointer_id));
 
   SetEventSpecificFields(pointer_event_init, EventTypeNames::pointercancel);
 
-  return PointerEvent::Create(EventTypeNames::pointercancel,
-                              pointer_event_init);
+  return PointerEvent::Create(EventTypeNames::pointercancel, pointer_event_init,
+                              platfrom_time_stamp);
 }
 
 PointerEvent* PointerEventFactory::CreatePointerEventFrom(
     PointerEvent* pointer_event,
     const AtomicString& type,
     EventTarget* related_target) {
   PointerEventInit pointer_event_init;
 
   pointer_event_init.setPointerId(pointer_event->pointerId());
   pointer_event_init.setPointerType(pointer_event->pointerType());
@@ skipping 11 matching lines @@
   pointer_event_init.setTiltY(pointer_event->tiltY());
   pointer_event_init.setTangentialPressure(pointer_event->tangentialPressure());
   pointer_event_init.setTwist(pointer_event->twist());
   pointer_event_init.setView(pointer_event->view());
 
   SetEventSpecificFields(pointer_event_init, type);
 
   if (related_target)
     pointer_event_init.setRelatedTarget(related_target);
 
-  return PointerEvent::Create(type, pointer_event_init);
+  return PointerEvent::Create(type, pointer_event_init,
+                              pointer_event->PlatformTimeStamp());
 }
 
 PointerEvent* PointerEventFactory::CreatePointerCaptureEvent(
     PointerEvent* pointer_event,
     const AtomicString& type) {
   DCHECK(type == EventTypeNames::gotpointercapture ||
          type == EventTypeNames::lostpointercapture);
 
   return CreatePointerEventFrom(pointer_event, type,
                                 pointer_event->relatedTarget());
@@ skipping 124 matching lines @@
     const WebPointerProperties& properties) const {
   if (properties.pointer_type == WebPointerProperties::PointerType::kMouse)
     return PointerEventFactory::kMouseId;
   IncomingId id(properties.pointer_type, properties.id);
   if (pointer_incoming_id_mapping_.Contains(id))
     return pointer_incoming_id_mapping_.at(id);
   return PointerEventFactory::kInvalidId;
 }
 
 }  // namespace blink