Add time stamp to the constructor of the events

third_party/WebKit/Source/core/input/PointerEventManager.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/input/PointerEventManager.h"
 
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
@@ skipping 15 matching lines @@
 namespace {
 
 size_t ToPointerTypeIndex(WebPointerProperties::PointerType t) {
   return static_cast<size_t>(t);
 }
 
 bool IsInDocument(EventTarget* n) {
   return n && n->ToNode() && n->ToNode()->isConnected();
 }
 
-Vector<WebTouchPoint> GetCoalescedPoints(
+Vector<std::pair<WebTouchPoint, TimeTicks>> GetCoalescedPoints(
     const Vector<WebTouchEvent>& coalesced_events,
     int id) {
-  Vector<WebTouchPoint> related_points;
+  Vector<std::pair<WebTouchPoint, TimeTicks>> related_points;
   for (const auto& touch_event : coalesced_events) {
     for (unsigned i = 0; i < touch_event.touches_length; ++i) {
       if (touch_event.touches[i].id == id &&
-          touch_event.touches[i].state != WebTouchPoint::kStateStationary)
-        related_points.push_back(touch_event.TouchPointInRootFrame(i));
+          touch_event.touches[i].state != WebTouchPoint::kStateStationary) {
+        related_points.push_back(std::pair<WebTouchPoint, TimeTicks>(
+            touch_event.TouchPointInRootFrame(i),
+            TimeTicks::FromSeconds(touch_event.TimeStampSeconds())));
+      }
     }
   }
   return related_points;
 }
 
 }  // namespace
 
 PointerEventManager::PointerEventManager(LocalFrame& frame,
                                          MouseEventManager& mouse_event_manager)
     : frame_(frame),
@@ skipping 174 matching lines @@
                               EventTargetAttributes(target, false));
     }
     SendBoundaryEvents(node.target, target, pointer_event);
   } else if (target) {
     node_under_pointer_.insert(pointer_event->pointerId(),
                                EventTargetAttributes(target, false));
     SendBoundaryEvents(nullptr, target, pointer_event);
   }
 }
 
-void PointerEventManager::BlockTouchPointers() {
+void PointerEventManager::BlockTouchPointers(TimeTicks platform_time_stamp) {
   if (in_canceled_state_for_pointer_type_touch_)
     return;
   in_canceled_state_for_pointer_type_touch_ = true;
 
   Vector<int> touch_pointer_ids = pointer_event_factory_.GetPointerIdsOfType(
       WebPointerProperties::PointerType::kTouch);
 
   for (int pointer_id : touch_pointer_ids) {
     PointerEvent* pointer_event =
         pointer_event_factory_.CreatePointerCancelEvent(
-            pointer_id, WebPointerProperties::PointerType::kTouch);
+            pointer_id, WebPointerProperties::PointerType::kTouch,
+            platform_time_stamp);
 
     DCHECK(node_under_pointer_.Contains(pointer_id));
     EventTarget* target = node_under_pointer_.at(pointer_id).target;
 
     ProcessCaptureAndPositionOfPointerEvent(pointer_event, target);
 
     // TODO(nzolghadr): This event follows implicit TE capture. The actual
     // target would depend on PE capturing. Perhaps need to split TE/PE event
     // path upstream?  crbug.com/579553.
     DispatchPointerEvent(
@@ skipping 12 matching lines @@
 }
 
 void PointerEventManager::UnblockTouchPointers() {
   in_canceled_state_for_pointer_type_touch_ = false;
 }
 
 WebInputEventResult PointerEventManager::HandleTouchEvents(
     const WebTouchEvent& event,
     const Vector<WebTouchEvent>& coalesced_events) {
   if (event.GetType() == WebInputEvent::kTouchScrollStarted) {
-    BlockTouchPointers();
+    BlockTouchPointers(TimeTicks::FromSeconds(event.TimeStampSeconds()));
     return WebInputEventResult::kHandledSystem;
   }
 
   bool new_touch_sequence = true;
   for (unsigned i = 0; i < event.touches_length; ++i) {
     if (event.touches[i].state != WebTouchPoint::kStatePressed) {
       new_touch_sequence = false;
       break;
     }
   }
@@ skipping 91 matching lines @@
   // required.
   for (auto touch_info : touch_infos) {
     const WebTouchPoint& touch_point = touch_info.point;
     // Do not send pointer events for stationary touches or null targetFrame
     if (touch_info.touch_node && touch_info.target_frame &&
         touch_point.state != WebTouchPoint::kStateStationary &&
         !in_canceled_state_for_pointer_type_touch_) {
       PointerEvent* pointer_event = pointer_event_factory_.Create(
           touch_point, GetCoalescedPoints(coalesced_events, touch_point.id),
           static_cast<WebInputEvent::Modifiers>(event.GetModifiers()),
+          TimeTicks::FromSeconds(event.TimeStampSeconds()),
           touch_info.target_frame,
           touch_info.touch_node
               ? touch_info.touch_node->GetDocument().domWindow()
               : nullptr);
 
       WebInputEventResult result =
           SendTouchPointerEvent(touch_info.touch_node, pointer_event);
 
       // If a pointerdown has been canceled, queue the unique id to allow
       // suppressing mouse events from gesture events. For mouse events
@@ skipping 306 matching lines @@
     if (first_id > unique_touch_event_id)
       return false;
     touch_ids_for_canceled_pointerdowns_.TakeFirst();
     if (first_id == unique_touch_event_id)
       return true;
   }
   return false;
 }
 
 }  // namespace blink