Remove WebTouchEvent from TouchEventManager APIs

third_party/WebKit/Source/core/input/TouchEventManager.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/TouchEventManager.h"
 
 #include <memory>
 #include "core/dom/Document.h"
 #include "core/events/TouchEvent.h"
 #include "core/frame/Deprecation.h"
@@ skipping 19 matching lines @@
   return registry.HasEventHandlers(
              EventHandlerRegistry::kTouchStartOrMoveEventBlocking) ||
          registry.HasEventHandlers(
              EventHandlerRegistry::kTouchStartOrMoveEventPassive) ||
          registry.HasEventHandlers(
              EventHandlerRegistry::kTouchEndOrCancelEventBlocking) ||
          registry.HasEventHandlers(
              EventHandlerRegistry::kTouchEndOrCancelEventPassive);
 }
 
-const AtomicString& TouchEventNameForTouchPointState(
-    WebTouchPoint::State state) {
-  switch (state) {
-    case WebTouchPoint::kStateReleased:
+const AtomicString& TouchEventNameForPointerAction(WebInputEvent::Type action) {
+  switch (action) {
+    case WebInputEvent::kPointerUp:
       return EventTypeNames::touchend;
-    case WebTouchPoint::kStateCancelled:
+    case WebInputEvent::kPointerCancel:
       return EventTypeNames::touchcancel;
-    case WebTouchPoint::kStatePressed:
+    case WebInputEvent::kPointerDown:
       return EventTypeNames::touchstart;
-    case WebTouchPoint::kStateMoved:
+    case WebInputEvent::kPointerMove:
       return EventTypeNames::touchmove;
-    case WebTouchPoint::kStateStationary:
-    // Fall through to default
     default:
       NOTREACHED();
       return g_empty_atom;
   }
 }
 
 enum TouchEventDispatchResultType {
   kUnhandledTouches,  // Unhandled touch events.
   kHandledTouches,    // Handled touch events.
   kTouchEventDispatchResultTypeMax,
 };
 
-bool IsTouchSequenceStart(const WebTouchEvent& event) {
-  if (!event.touches_length)
-    return false;
-  if (event.GetType() != WebInputEvent::kTouchStart)
-    return false;
-  for (size_t i = 0; i < event.touches_length; ++i) {
-    if (event.touches[i].state != blink::WebTouchPoint::kStatePressed)
-      return false;
+WebTouchPoint::State TouchPointStateFromPointerEventAction(
+    WebInputEvent::Type type,
+    bool stale) {
+  if (stale)
+    return WebTouchPoint::kStateStationary;
+  switch (type) {
+    case WebInputEvent::Type::kPointerUp:
+      return WebTouchPoint::kStateReleased;
+    case WebInputEvent::Type::kPointerCancel:
+      return WebTouchPoint::kStateCancelled;
+    case WebInputEvent::Type::kPointerDown:
+      return WebTouchPoint::kStatePressed;
+    case WebInputEvent::Type::kPointerMove:
+      return WebTouchPoint::kStateMoved;
+    default:
+      NOTREACHED();
+      return WebTouchPoint::kStateUndefined;
   }
-  return true;
 }
 
 // Defining this class type local to dispatchTouchEvents() and annotating
 // it with STACK_ALLOCATED(), runs into MSVC(VS 2013)'s C4822 warning
 // that the local class doesn't provide a local definition for 'operator new'.
 // Which it intentionally doesn't and shouldn't.
 //
 // Work around such toolchain bugginess by lifting out the type, thereby
 // taking it out of C4822's reach.
 class ChangedTouches final {
   STACK_ALLOCATED();
 
  public:
   // The touches corresponding to the particular change state this struct
   // instance represents.
   Member<TouchList> touches_;
 
   using EventTargetSet = HeapHashSet<Member<EventTarget>>;
   // Set of targets involved in m_touches.
   EventTargetSet targets_;
-
-  WebPointerProperties::PointerType pointer_type_;
 };
 
 }  // namespace
 
 TouchEventManager::TouchEventManager(LocalFrame& frame) : frame_(frame) {
   Clear();
 }
 
 void TouchEventManager::Clear() {
   touch_sequence_document_.Clear();
-  target_for_touch_id_.clear();
-  region_for_touch_id_.clear();
-  touch_pressed_ = false;
+  touch_points_attributes_.clear();
   suppressing_touchmoves_within_slop_ = false;
   current_touch_action_ = TouchAction::kTouchActionAuto;
 }
 
 DEFINE_TRACE(TouchEventManager) {
   visitor->Trace(frame_);
   visitor->Trace(touch_sequence_document_);
-  visitor->Trace(target_for_touch_id_);
+  visitor->Trace(touch_points_attributes_);
 }
 
-Touch* TouchEventManager::CreateDomTouch(const WebTouchPoint& point,
-                                         bool* known_target) {
-  Node* touch_node = nullptr;
-  String region_id;
+Touch* TouchEventManager::CreateDomTouch(
+    const TouchEventManager::TouchPointAttributes* point_attr,
+    bool* known_target) {
+  Node* touch_node = point_attr->target_;
+  String region_id = point_attr->region_;
   *known_target = false;
   FloatPoint content_point;
   FloatSize adjusted_radius;
 
-  if (point.state == WebTouchPoint::kStateReleased ||
-      point.state == WebTouchPoint::kStateCancelled) {
-    // The target should be the original target for this touch, so get
-    // it from the hashmap. As it's a release or cancel we also remove
-    // it from the map.
-    touch_node = target_for_touch_id_.Take(point.id);
-    region_id = region_for_touch_id_.Take(point.id);
-  } else {
-    // No hittest is performed on move or stationary, since the target
-    // is not allowed to change anyway.
-    touch_node = target_for_touch_id_.at(point.id);
-    region_id = region_for_touch_id_.at(point.id);
-  }
-
   LocalFrame* target_frame = nullptr;
   if (touch_node) {
     Document& doc = touch_node->GetDocument();
     // If the target node has moved to a new document while it was being
     // touched, we can't send events to the new document because that could
     // leak nodes from one document to another. See http://crbug.com/394339.
     if (&doc == touch_sequence_document_.Get()) {
       target_frame = doc.GetFrame();
       *known_target = true;
     }
@@ skipping 10 matching lines @@
     // Document so that there's some valid node here. Perhaps this
     // should really be LocalDOMWindow, but in all other cases the target of
     // a Touch is a Node so using the window could be a breaking change.
     // Since we know there was no handler invoked, the specific target
     // should be completely irrelevant to the application.
     touch_node = touch_sequence_document_;
     target_frame = touch_sequence_document_->GetFrame();
   }
   DCHECK(target_frame);
 
+  WebPointerEvent transformed_event =
+      point_attr->event_.WebPointerEventInRootFrame();
   // pagePoint should always be in the target element's document coordinates.
-  FloatPoint page_point =
-      target_frame->View()->RootFrameToContents(point.PositionInWidget());
+  FloatPoint page_point = target_frame->View()->RootFrameToContents(
+      transformed_event.PositionInWidget());
   float scale_factor = 1.0f / target_frame->PageZoomFactor();
 
   content_point = page_point.ScaledBy(scale_factor);
-  adjusted_radius =
-      FloatSize(point.radius_x, point.radius_y).ScaledBy(scale_factor);
+  adjusted_radius = FloatSize(transformed_event.width, transformed_event.height)

[mustaq, 2017/06/08 20:02:52]

Radius = (width/2, height/2);

[Navid Zolghadr, 2017/06/08 21:18:41]

I can see what you mean. But this is not what we did when we create the DOM
pointerevent from touch points. We use the radius_x/y fields as is to set it the
width/height of the DOM pointerevent. So I used the same definition of width
height in WebPointerEvent. Do you think I should change the definition of width
height in WebPointerEvent and not having it matched with DOM pointerevent?

[mustaq, 2017/06/09 16:12:27]

Yikes, perhaps the blame goes to me!  Filed crbug.com/731725, please add a TODO
(or fix that bug first).  Makes sense to keep the fix separate.

+                        .ScaledBy(scale_factor);
 
-  return Touch::Create(target_frame, touch_node, point.id,
-                       point.PositionInScreen(), content_point, adjusted_radius,
-                       point.rotation_angle, point.force, region_id);
+  return Touch::Create(target_frame, touch_node, point_attr->event_.id,
+                       transformed_event.PositionInScreen(), content_point,
+                       adjusted_radius, transformed_event.rotation_angle,
+                       transformed_event.force, region_id);
 }
 
-WebInputEventResult TouchEventManager::DispatchTouchEvents(
-    const WebTouchEvent& event,
-    const Vector<WebTouchEvent>& coalesced_events,
-    bool all_touches_released) {
+WebCoalescedInputEvent TouchEventManager::GenerateWebCoalescedInputEvent() {
+  DCHECK(!touch_points_attributes_.IsEmpty());
+
+  WebTouchEvent event;
+
+  const auto& first_touch_pointer_event =
+      touch_points_attributes_.begin()->value->event_;
+  event.dispatch_type = first_touch_pointer_event.dispatch_type;
+  event.touch_start_or_first_touch_move =
+      first_touch_pointer_event.touch_start_or_first_touch_move;
+  event.moved_beyond_slop_region =
+      first_touch_pointer_event.moved_beyond_slop_region;
+  event.dispatch_type = first_touch_pointer_event.dispatch_type;
+  event.dispatch_type = first_touch_pointer_event.dispatch_type;
+  event.SetFrameScale(first_touch_pointer_event.FrameScale());
+  event.SetFrameTranslate(first_touch_pointer_event.FrameTranslate());
+  event.SetTimeStampSeconds(first_touch_pointer_event.TimeStampSeconds());
+  event.SetModifiers(first_touch_pointer_event.GetModifiers());
+
+  WebInputEvent::Type touch_event_type = WebInputEvent::kTouchMove;
+  Vector<WebPointerEvent> all_coalesced_events;
+  Vector<int> available_ids;
+  for (const auto& id : touch_points_attributes_.Keys())
+    available_ids.push_back(id);
+  std::sort(available_ids.begin(), available_ids.end());
+  for (const int& touch_point_id : available_ids) {
+    const auto& touch_point_attribute =
+        touch_points_attributes_.at(touch_point_id);
+    const WebPointerEvent& touch_pointer_event = touch_point_attribute->event_;
+    WebTouchPoint web_touch_point(touch_pointer_event);
+    web_touch_point.state = TouchPointStateFromPointerEventAction(
+        touch_pointer_event.GetType(), touch_point_attribute->stale_);
+    web_touch_point.radius_x = touch_pointer_event.width;
+    web_touch_point.radius_y = touch_pointer_event.height;
+    web_touch_point.rotation_angle = touch_pointer_event.rotation_angle;
+    event.touches[event.touches_length++] = web_touch_point;
+
+    // Only change the touch event type from move. So if we have two pointers
+    // in up and down state we just set the touch event type to the first one
+    // we see.
+    if (touch_event_type == WebInputEvent::kTouchMove) {
+      if (touch_pointer_event.GetType() == WebInputEvent::kPointerDown)
+        touch_event_type = WebInputEvent::kTouchStart;
+      else if (touch_pointer_event.GetType() == WebInputEvent::kPointerCancel)
+        touch_event_type = WebInputEvent::kTouchCancel;
+      else if (touch_pointer_event.GetType() == WebInputEvent::kPointerUp)
+        touch_event_type = WebInputEvent::kTouchEnd;
+    }
+
+    event.SetType(touch_event_type);
+
+    for (const WebPointerEvent& coalesced_event :
+         touch_point_attribute->coalesced_events_)
+      all_coalesced_events.push_back(coalesced_event);
+  }
+
+  // Create all coalesced touch events based on pointerevents
+  struct {
+    bool operator()(const WebPointerEvent& a, const WebPointerEvent& b) {
+      return a.TimeStampSeconds() < b.TimeStampSeconds();
+    }
+  } timestamp_based_event_comparison;
+  std::sort(all_coalesced_events.begin(), all_coalesced_events.end(),
+            timestamp_based_event_comparison);
+  WebCoalescedInputEvent result(event);
+  // This assumes that we only get move events as coalesced events.
+  for (const auto& web_pointer_event : all_coalesced_events) {
+    for (unsigned i = 0; i < event.touches_length; ++i) {
+      if (event.touches[i].id == web_pointer_event.id &&
+          event.touches[i].state == blink::WebTouchPoint::kStateMoved &&
+          web_pointer_event.GetType() == WebInputEvent::kPointerMove) {
+        event.touches[i].movement_x = web_pointer_event.movement_x;
+        event.touches[i].movement_y = web_pointer_event.movement_y;
+        event.SetTimeStampSeconds(web_pointer_event.TimeStampSeconds());
+        result.AddCoalescedEvent(event);
+        break;
+      }
+    }
+    for (unsigned i = 0; i < event.touches_length; ++i) {
+      event.touches[i].state = blink::WebTouchPoint::kStateStationary;
+      event.touches[i].movement_x = 0;
+      event.touches[i].movement_y = 0;
+    }
+  }
+
+  return result;
+}
+
+WebInputEventResult TouchEventManager::DispatchTouchEvents() {
   // Build up the lists to use for the |touches|, |targetTouches| and
   // |changedTouches| attributes in the JS event. See
   // http://www.w3.org/TR/touch-events/#touchevent-interface for how these
   // lists fit together.
 
-  if (event.GetType() == WebInputEvent::kTouchEnd ||
-      event.GetType() == WebInputEvent::kTouchCancel ||
-      event.touches_length > 1) {
-    suppressing_touchmoves_within_slop_ = false;
+  bool new_touch_point_since_last_raf = false;
+  bool any_touch_canceled_ended = false;
+  bool all_touch_points_pressed = true;
+
+  for (const auto& attr : touch_points_attributes_.Values()) {
+    if (!attr->stale_)
+      new_touch_point_since_last_raf = true;
+    if (attr->event_.GetType() == WebInputEvent::kPointerUp ||
+        attr->event_.GetType() == WebInputEvent::kPointerCancel)
+      any_touch_canceled_ended = true;
+    if (attr->event_.GetType() != WebInputEvent::kPointerDown)
+      all_touch_points_pressed = false;
   }
 
-  if (suppressing_touchmoves_within_slop_ &&
-      event.GetType() == WebInputEvent::kTouchMove) {
-    if (!event.moved_beyond_slop_region)
-      return WebInputEventResult::kHandledSuppressed;
+  if (!new_touch_point_since_last_raf)
+    return WebInputEventResult::kNotHandled;
+
+  if (any_touch_canceled_ended || touch_points_attributes_.size() > 1)
     suppressing_touchmoves_within_slop_ = false;
+
+  if (suppressing_touchmoves_within_slop_) {
+    // There is exactly one touch point here otherwise

[mustaq, 2017/06/08 20:02:52]

Please add a dcheck.

[Navid Zolghadr, 2017/06/08 21:18:40]

Done.

+    // |suppressing_touchmoves_within_slop_| would have been false.
+    const auto& touch_point_attribute = touch_points_attributes_.begin()->value;
+    if (touch_point_attribute->event_.GetType() ==
+        WebInputEvent::kPointerMove) {
+      if (!touch_point_attribute->event_.moved_beyond_slop_region)
+        return WebInputEventResult::kHandledSuppressed;
+      suppressing_touchmoves_within_slop_ = false;
+    }
   }
 
   // Holds the complete set of touches on the screen.
   TouchList* touches = TouchList::Create();
 
   // A different view on the 'touches' list above, filtered and grouped by
   // event target. Used for the |targetTouches| list in the JS event.
   using TargetTouchesHeapMap = HeapHashMap<EventTarget*, Member<TouchList>>;
   TargetTouchesHeapMap touches_by_target;
 
   // Array of touches per state, used to assemble the |changedTouches| list.
-  ChangedTouches changed_touches[WebTouchPoint::kStateMax + 1];
+  ChangedTouches changed_touches[WebInputEvent::kPointerActionLast -
+                                 WebInputEvent::kPointerActionFirst + 1];
 
-  for (unsigned touch_point_idx = 0; touch_point_idx < event.touches_length;
-       touch_point_idx++) {
-    const WebTouchPoint& point = event.TouchPointInRootFrame(touch_point_idx);
-    WebTouchPoint::State point_state = point.state;
+  Vector<int> available_ids;
+  for (const auto& id : touch_points_attributes_.Keys())
+    available_ids.push_back(id);
+  std::sort(available_ids.begin(), available_ids.end());
+  for (const int& touch_point_id : available_ids) {
+    const auto& touch_point_attribute =
+        touch_points_attributes_.at(touch_point_id);
+    WebInputEvent::Type pointer_action =
+        touch_point_attribute->event_.GetType();
+    size_t pointer_action_idx =
+        pointer_action - WebInputEvent::kPointerActionFirst;
     bool known_target;
 
-    Touch* touch = CreateDomTouch(point, &known_target);
+    Touch* touch = CreateDomTouch(touch_point_attribute, &known_target);
     EventTarget* touch_target = touch->target();
 
     // Ensure this target's touch list exists, even if it ends up empty, so
     // it can always be passed to TouchEvent::Create below.
     TargetTouchesHeapMap::iterator target_touches_iterator =
         touches_by_target.find(touch_target);
     if (target_touches_iterator == touches_by_target.end()) {
       touches_by_target.Set(touch_target, TouchList::Create());
       target_touches_iterator = touches_by_target.find(touch_target);
     }
 
     // |touches| and |targetTouches| should only contain information about
     // touches still on the screen, so if this point is released or
     // cancelled it will only appear in the |changedTouches| list.
-    if (point_state != WebTouchPoint::kStateReleased &&
-        point_state != WebTouchPoint::kStateCancelled) {
+    if (pointer_action != WebInputEvent::kPointerUp &&
+        pointer_action != WebInputEvent::kPointerCancel) {
       touches->Append(touch);
       target_touches_iterator->value->Append(touch);
     }
 
     // Now build up the correct list for |changedTouches|.
     // Note that  any touches that are in the TouchStationary state (e.g. if
     // the user had several points touched but did not move them all) should
     // never be in the |changedTouches| list so we do not handle them
     // explicitly here. See https://bugs.webkit.org/show_bug.cgi?id=37609
     // for further discussion about the TouchStationary state.
-    if (point_state != WebTouchPoint::kStateStationary && known_target) {
-      DCHECK_LE(point_state, WebTouchPoint::kStateMax);
-      if (!changed_touches[point_state].touches_)
-        changed_touches[point_state].touches_ = TouchList::Create();
-      changed_touches[point_state].touches_->Append(touch);
-      changed_touches[point_state].targets_.insert(touch_target);
-      changed_touches[point_state].pointer_type_ = point.pointer_type;
+    if (!touch_point_attribute->stale_ && known_target) {
+      if (!changed_touches[pointer_action_idx].touches_)
+        changed_touches[pointer_action_idx].touches_ = TouchList::Create();
+      changed_touches[pointer_action_idx].touches_->Append(touch);
+      changed_touches[pointer_action_idx].targets_.insert(touch_target);
     }
   }
 
-  if (all_touches_released) {
-    touch_sequence_document_.Clear();
-    current_touch_action_ = TouchAction::kTouchActionAuto;
-  }
+  WebInputEventResult event_result = WebInputEventResult::kNotHandled;
 
-  WebInputEventResult event_result = WebInputEventResult::kNotHandled;
   // First we construct the webcoalescedinputevent contains all the coalesced
   // touch event.
-  std::vector<const WebInputEvent*> coalesced_touches;
-  for (size_t i = 0; i < coalesced_events.size(); ++i) {
-    coalesced_touches.push_back(&coalesced_events[i]);
-  }
-  WebCoalescedInputEvent coalesced_event(event, coalesced_touches);
+  WebCoalescedInputEvent coalesced_event = GenerateWebCoalescedInputEvent();
 
   // Now iterate through the |changedTouches| list and |m_targets| within it,
   // sending TouchEvents to the targets as required.
-  for (unsigned state = 0; state <= WebTouchPoint::kStateMax; ++state) {
-    if (!changed_touches[state].touches_)
+  for (unsigned action = WebInputEvent::kPointerActionFirst;
+       action <= WebInputEvent::kPointerActionLast; ++action) {
+    size_t action_idx = action - WebInputEvent::kPointerActionFirst;
+    if (!changed_touches[action_idx].touches_)
       continue;
 
-    const AtomicString& event_name(TouchEventNameForTouchPointState(
-        static_cast<WebTouchPoint::State>(state)));
-    for (const auto& event_target : changed_touches[state].targets_) {
+    const AtomicString& event_name(TouchEventNameForPointerAction(
+        static_cast<WebInputEvent::Type>(action)));
+
+    for (const auto& event_target : changed_touches[action_idx].targets_) {
       EventTarget* touch_event_target = event_target;
       TouchEvent* touch_event = TouchEvent::Create(
           coalesced_event, touches, touches_by_target.at(touch_event_target),
-          changed_touches[state].touches_.Get(), event_name,
+          changed_touches[action_idx].touches_.Get(), event_name,
           touch_event_target->ToNode()->GetDocument().domWindow(),
           current_touch_action_);
 
       DispatchEventResult dom_dispatch_result =
           touch_event_target->DispatchEvent(touch_event);
 
       // Only report for top level documents with a single touch on
       // touch-start or the first touch-move.
-      if (event.touch_start_or_first_touch_move && event.touches_length == 1 &&
-          frame_->IsMainFrame()) {
-        // Record the disposition and latency of touch starts and first touch
-        // moves before and after the page is fully loaded respectively.
-        int64_t latency_in_micros =
-            (TimeTicks::Now() -
-             TimeTicks::FromSeconds(event.TimeStampSeconds()))
-                .InMicroseconds();
-        if (event.IsCancelable()) {
-          if (frame_->GetDocument()->IsLoadCompleted()) {
+      if (touch_points_attributes_.size() == 1 && frame_->IsMainFrame()) {
+        const auto& event = touch_points_attributes_.begin()->value->event_;
+        if (event.touch_start_or_first_touch_move) {
+          // Record the disposition and latency of touch starts and first touch
+          // moves before and after the page is fully loaded respectively.
+          int64_t latency_in_micros =
+              (TimeTicks::Now() -
+               TimeTicks::FromSeconds(event.TimeStampSeconds()))
+                  .InMicroseconds();
+          if (event.IsCancelable()) {
+            if (frame_->GetDocument()->IsLoadCompleted()) {
+              DEFINE_STATIC_LOCAL(EnumerationHistogram,
+                                  touch_dispositions_after_page_load_histogram,
+                                  ("Event.Touch.TouchDispositionsAfterPageLoad",
+                                   kTouchEventDispatchResultTypeMax));
+              touch_dispositions_after_page_load_histogram.Count(
+                  (dom_dispatch_result != DispatchEventResult::kNotCanceled)
+                      ? kHandledTouches
+                      : kUnhandledTouches);
+
+              DEFINE_STATIC_LOCAL(
+                  CustomCountHistogram, event_latency_after_page_load_histogram,
+                  ("Event.Touch.TouchLatencyAfterPageLoad", 1, 100000000, 50));
+              event_latency_after_page_load_histogram.Count(latency_in_micros);
+            } else {
+              DEFINE_STATIC_LOCAL(
+                  EnumerationHistogram,
+                  touch_dispositions_before_page_load_histogram,
+                  ("Event.Touch.TouchDispositionsBeforePageLoad",
+                   kTouchEventDispatchResultTypeMax));
+              touch_dispositions_before_page_load_histogram.Count(
+                  (dom_dispatch_result != DispatchEventResult::kNotCanceled)
+                      ? kHandledTouches
+                      : kUnhandledTouches);
+
+              DEFINE_STATIC_LOCAL(
+                  CustomCountHistogram,
+                  event_latency_before_page_load_histogram,
+                  ("Event.Touch.TouchLatencyBeforePageLoad", 1, 100000000, 50));
+              event_latency_before_page_load_histogram.Count(latency_in_micros);
+            }
+            // Report the touch disposition there is no active fling animation.
             DEFINE_STATIC_LOCAL(EnumerationHistogram,
-                                touch_dispositions_after_page_load_histogram,
-                                ("Event.Touch.TouchDispositionsAfterPageLoad",
+                                touch_dispositions_outside_fling_histogram,
+                                ("Event.Touch.TouchDispositionsOutsideFling2",
                                  kTouchEventDispatchResultTypeMax));
-            touch_dispositions_after_page_load_histogram.Count(
+            touch_dispositions_outside_fling_histogram.Count(
                 (dom_dispatch_result != DispatchEventResult::kNotCanceled)
                     ? kHandledTouches
                     : kUnhandledTouches);
+          }
 
-            DEFINE_STATIC_LOCAL(
-                CustomCountHistogram, event_latency_after_page_load_histogram,
-                ("Event.Touch.TouchLatencyAfterPageLoad", 1, 100000000, 50));
-            event_latency_after_page_load_histogram.Count(latency_in_micros);
-          } else {
+          // Report the touch disposition when there is an active fling
+          // animation.
+          //        if (event[0].first.dispatch_type ==
+          if (event.dispatch_type ==
+              WebInputEvent::kListenersForcedNonBlockingDueToFling) {
             DEFINE_STATIC_LOCAL(EnumerationHistogram,
-                                touch_dispositions_before_page_load_histogram,
-                                ("Event.Touch.TouchDispositionsBeforePageLoad",
+                                touch_dispositions_during_fling_histogram,
+                                ("Event.Touch.TouchDispositionsDuringFling2",
                                  kTouchEventDispatchResultTypeMax));
-            touch_dispositions_before_page_load_histogram.Count(
-                (dom_dispatch_result != DispatchEventResult::kNotCanceled)
+            touch_dispositions_during_fling_histogram.Count(
+                touch_event->PreventDefaultCalledOnUncancelableEvent()
                     ? kHandledTouches
                     : kUnhandledTouches);
-
-            DEFINE_STATIC_LOCAL(
-                CustomCountHistogram, event_latency_before_page_load_histogram,
-                ("Event.Touch.TouchLatencyBeforePageLoad", 1, 100000000, 50));
-            event_latency_before_page_load_histogram.Count(latency_in_micros);
           }
-          // Report the touch disposition there is no active fling animation.
-          DEFINE_STATIC_LOCAL(EnumerationHistogram,
-                              touch_dispositions_outside_fling_histogram,
-                              ("Event.Touch.TouchDispositionsOutsideFling2",
-                               kTouchEventDispatchResultTypeMax));
-          touch_dispositions_outside_fling_histogram.Count(
-              (dom_dispatch_result != DispatchEventResult::kNotCanceled)
-                  ? kHandledTouches
-                  : kUnhandledTouches);
-        }
-
-        // Report the touch disposition when there is an active fling animation.
-        if (event.dispatch_type ==
-            WebInputEvent::kListenersForcedNonBlockingDueToFling) {
-          DEFINE_STATIC_LOCAL(EnumerationHistogram,
-                              touch_dispositions_during_fling_histogram,
-                              ("Event.Touch.TouchDispositionsDuringFling2",
-                               kTouchEventDispatchResultTypeMax));
-          touch_dispositions_during_fling_histogram.Count(
-              touch_event->PreventDefaultCalledOnUncancelableEvent()
-                  ? kHandledTouches
-                  : kUnhandledTouches);
         }
       }
       event_result = EventHandlingUtil::MergeEventResult(
           event_result,
           EventHandlingUtil::ToWebInputEventResult(dom_dispatch_result));
     }
   }
 
-  // Do not suppress any touchmoves if the touchstart is consumed.
-  if (IsTouchSequenceStart(event) &&
+  // Suppress following touchmoves within the slop region if the touchstart is
+  // not consumed.
+  if (all_touch_points_pressed &&
       event_result == WebInputEventResult::kNotHandled) {
     suppressing_touchmoves_within_slop_ = true;
   }
 
   return event_result;
 }
 
-void TouchEventManager::UpdateTargetAndRegionMapsForTouchStart(
-    const WebTouchPoint& touch_point,
+void TouchEventManager::UpdateTouchAttributeMapsForPointerDown(
+    const WebPointerEvent& event,
     const EventHandlingUtil::PointerEventTarget& pointer_event_target) {
   // Touch events implicitly capture to the touched node, and don't change
   // active/hover states themselves (Gesture events do). So we only need
   // to hit-test on touchstart and when the target could be different than
   // the corresponding pointer event target.
-  DCHECK(touch_point.state == WebTouchPoint::kStatePressed);
+  DCHECK(event.GetType() == WebInputEvent::kPointerDown);
+  // Ideally we'd DCHECK(!touch_points_attributes_.Contains(event.id))
+  // since we shouldn't get a touchstart for a touch that's already
+  // down. However EventSender allows this to be violated and there's
+  // some tests that take advantage of it. There may also be edge
+  // cases in the browser where this happens.
+  // See http://crbug.com/345372.
+  touch_points_attributes_.Set(event.id, new TouchPointAttributes(event));
+
   Node* touch_node = pointer_event_target.target_node;
   String region = pointer_event_target.region;
 
   HitTestRequest::HitTestRequestType hit_type = HitTestRequest::kTouchEvent |
                                                 HitTestRequest::kReadOnly |
                                                 HitTestRequest::kActive;
   HitTestResult result;
   // For the touchPressed points hit-testing is done in
   // PointerEventManager. If it was the second touch there is a
   // capturing documents for the touch and |m_touchSequenceDocument|
   // is not null. So if PointerEventManager should hit-test again
   // against |m_touchSequenceDocument| if the target set by
   // PointerEventManager was either null or not in
   // |m_touchSequenceDocument|.
   if (touch_sequence_document_ &&
       (!touch_node || &touch_node->GetDocument() != touch_sequence_document_)) {
     if (touch_sequence_document_->GetFrame()) {
       LayoutPoint frame_point = LayoutPoint(
           touch_sequence_document_->GetFrame()->View()->RootFrameToContents(
-              touch_point.PositionInWidget()));
+              event.PositionInWidget()));
       result = EventHandlingUtil::HitTestResultInFrame(
           touch_sequence_document_->GetFrame(), frame_point, hit_type);
       Node* node = result.InnerNode();
       if (!node)
         return;
       if (isHTMLCanvasElement(node)) {
         HitTestCanvasResult* hit_test_canvas_result =
             toHTMLCanvasElement(node)->GetControlAndIdIfHitRegionExists(
                 result.PointInInnerNodeFrame());
         if (hit_test_canvas_result->GetControl())
@@ skipping 11 matching lines @@
   if (!touch_node)
     return;
   if (!touch_sequence_document_) {
     // Keep track of which document should receive all touch events
     // in the active sequence. This must be a single document to
     // ensure we don't leak Nodes between documents.
     touch_sequence_document_ = &(touch_node->GetDocument());
     DCHECK(touch_sequence_document_->GetFrame()->View());
   }
 
-  // Ideally we'd DCHECK(!m_targetForTouchID.contains(point.id())
-  // since we shouldn't get a touchstart for a touch that's already
-  // down. However EventSender allows this to be violated and there's
-  // some tests that take advantage of it. There may also be edge
-  // cases in the browser where this happens.
-  // See http://crbug.com/345372.
-  target_for_touch_id_.Set(touch_point.id, touch_node);
-
-  region_for_touch_id_.Set(touch_point.id, region);
+  TouchPointAttributes* attributes = touch_points_attributes_.at(event.id);
+  attributes->target_ = touch_node;
+  attributes->region_ = region;
 
   TouchAction effective_touch_action =
       TouchActionUtil::ComputeEffectiveTouchAction(*touch_node);
   if (effective_touch_action != TouchAction::kTouchActionAuto) {
     frame_->GetPage()->GetChromeClient().SetTouchAction(frame_,
                                                         effective_touch_action);
 
     // Combine the current touch action sequence with the touch action
     // for the current finger press.
     current_touch_action_ &= effective_touch_action;
   }
 }
 
-bool TouchEventManager::HitTestTouchPointsIfNeeded(
-    const WebTouchEvent& event,
-    const HeapVector<EventHandlingUtil::PointerEventTarget>&
-        pointer_event_targets) {
-  bool new_touch_sequence = true;
-  bool all_touches_released = true;
+void TouchEventManager::HandleTouchPoint(
+    const WebPointerEvent& event,
+    const Vector<WebPointerEvent>& coalesced_events,
+    const EventHandlingUtil::PointerEventTarget& pointer_event_target) {
+  DCHECK_GE(event.GetType(), WebInputEvent::kPointerActionFirst);
+  DCHECK_LE(event.GetType(), WebInputEvent::kPointerActionLast);
 
-  for (unsigned i = 0; i < event.touches_length; ++i) {
-    WebTouchPoint::State state = event.touches[i].state;
-    if (state != WebTouchPoint::kStatePressed)
-      new_touch_sequence = false;
-    if (state != WebTouchPoint::kStateReleased &&
-        state != WebTouchPoint::kStateCancelled)
-      all_touches_released = false;
-  }
-  if (new_touch_sequence) {
+  if (touch_points_attributes_.IsEmpty()) {
     // Ideally we'd DCHECK(!m_touchSequenceDocument) here since we should
     // have cleared the active document when we saw the last release. But we
     // have some tests that violate this, ClusterFuzz could trigger it, and
     // there may be cases where the browser doesn't reliably release all
     // touches. http://crbug.com/345372 tracks this.
-    touch_sequence_document_.Clear();
+    allTouchesReleasedCleanup();
   }
 
   DCHECK(frame_->View());
   if (touch_sequence_document_ &&
       (!touch_sequence_document_->GetFrame() ||
        !touch_sequence_document_->GetFrame()->View())) {
     // If the active touch document has no frame or view, it's probably being
     // destroyed so we can't dispatch events.
-    return false;
+    return;
   }
 
-  for (unsigned i = 0; i < event.touches_length; ++i) {
-    // In touch event model only touch starts can set the target and after that
-    // the touch event always goes to that target.
-    if (event.touches[i].state == WebTouchPoint::kStatePressed) {
-      UpdateTargetAndRegionMapsForTouchStart(event.TouchPointInRootFrame(i),
-                                             pointer_event_targets[i]);
+  // In touch event model only touch starts can set the target and after that
+  // the touch event always goes to that target.
+  if (event.GetType() == WebInputEvent::kPointerDown) {
+    UpdateTouchAttributeMapsForPointerDown(event, pointer_event_target);
+  }
+
+  // We might not receive the down action for a touch point. In that case we
+  // would have never added them to |touch_points_attributes_| or hit-tested
+  // them. For those just keep them in the map with a null target. Later they
+  // will be targeted at the |touch_sequence_document_|.
+  if (!touch_points_attributes_.Contains(event.id)) {
+    touch_points_attributes_.insert(event.id, new TouchPointAttributes(event));
+  }
+
+  TouchPointAttributes* attributes = touch_points_attributes_.at(event.id);
+  attributes->event_ = event;
+  attributes->coalesced_events_ = coalesced_events;
+  attributes->stale_ = false;
+}
+
+WebInputEventResult TouchEventManager::HandleVSyncSignal() {
+  // If there's no document receiving touch events, or no handlers on the
+  // document set to receive the events, then we can skip all the rest of
+  // sending the event.
+  WebInputEventResult result = WebInputEventResult::kNotHandled;
+  if (touch_sequence_document_ && touch_sequence_document_->GetPage() &&
+      HasTouchHandlers(
+          touch_sequence_document_->GetPage()->GetEventHandlerRegistry()) &&
+      touch_sequence_document_->GetFrame() &&
+      touch_sequence_document_->GetFrame()->View()) {
+    result = DispatchTouchEvents();
+  }
+
+  // Cleanup the |touch_points_attributes_| map from released and canceled
+  // touch points.
+  Vector<int> releasedCanceledPoints;
+  for (auto& attributes : touch_points_attributes_.Values()) {
+    if (attributes->event_.GetType() == WebInputEvent::kPointerUp ||
+        attributes->event_.GetType() == WebInputEvent::kPointerCancel) {
+      releasedCanceledPoints.push_back(attributes->event_.id);
+    } else {
+      attributes->stale_ = true;
+      attributes->event_.movement_x = 0;
+      attributes->event_.movement_y = 0;
     }
   }
-
-  touch_pressed_ = !all_touches_released;
-
-  // If there's no document receiving touch events, or no handlers on the
-  // document set to receive the events, then we can skip all the rest of
-  // this work.
-  if (!touch_sequence_document_ || !touch_sequence_document_->GetPage() ||
-      !HasTouchHandlers(
-          touch_sequence_document_->GetPage()->GetEventHandlerRegistry()) ||
-      !touch_sequence_document_->GetFrame()) {
-    if (all_touches_released) {
-      touch_sequence_document_.Clear();
-    }
-    return false;
+  for (int id : releasedCanceledPoints) {
+    touch_points_attributes_.erase(id);
   }
 
-  return true;
+  if (touch_points_attributes_.IsEmpty()) {
+    allTouchesReleasedCleanup();
+  }
+
+  return result;
 }
 
-WebInputEventResult TouchEventManager::HandleTouchEvent(
-    const WebTouchEvent& event,
-    const Vector<WebTouchEvent>& coalesced_events,
-    const HeapVector<EventHandlingUtil::PointerEventTarget>&
-        pointer_event_targets) {
-  DCHECK(event.touches_length == pointer_event_targets.size());
-
-  if (!HitTestTouchPointsIfNeeded(event, pointer_event_targets))
-    return WebInputEventResult::kNotHandled;
-
-  bool all_touches_released = true;
-  for (unsigned i = 0; i < event.touches_length; ++i) {
-    WebTouchPoint::State state = event.touches[i].state;
-    if (state != WebTouchPoint::kStateReleased &&
-        state != WebTouchPoint::kStateCancelled)
-      all_touches_released = false;
-  }
-
-  return DispatchTouchEvents(event, coalesced_events, all_touches_released);
+void TouchEventManager::allTouchesReleasedCleanup() {
+  touch_sequence_document_.Clear();
+  current_touch_action_ = TouchAction::kTouchActionAuto;
 }
 
 bool TouchEventManager::IsAnyTouchActive() const {
-  return touch_pressed_;
+  return !touch_points_attributes_.IsEmpty();
 }
 
 }  // namespace blink