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& TouchEventNameForPointerEventType(
+    WebInputEvent::Type type) {
+  switch (type) {
+    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 TouchPointStateFromPointerEventType(
+    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)
+                        .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 = TouchPointStateFromPointerEventType(
+        touch_pointer_event.GetType(), touch_point_attribute->stale_);
+    web_touch_point.radius_x = touch_pointer_event.width;

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

Repeat the TODO here for radius/width problem.

[Navid Zolghadr, 2017/06/12 16:17:31]

I didn't have TODO anywhere else. I added a TODO here and one in WebPointerEvent
which I do the other side of translation.

+    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) {

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

You already hardcoded the event type in Line 197 above.

[Navid Zolghadr, 2017/06/12 16:17:31]

This is in a for loop. So the value of the touch_event_type is not necessary
kTouchMove. Although I just realized I can do the event.SetType out of this
loop.

+      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.

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

This comment also applies to the above hardcoded kTouchMove type.  I suggest
adding a DCHECK to enforce this early on in this function.

[Navid Zolghadr, 2017/06/12 16:17:31]

I added a DCHECK. However, I also changed the code to handle more cases and
updated the test in WebPluginContainerTest.

+  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) {

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

After adding to the coalesced events, |event| is not used anywhere. Why do you
need this 2nd loop?

[Navid Zolghadr, 2017/06/12 16:17:31]

It's used for the next coalesced event (i.e. next iteration of the outer loop).
Basically each coalesced event should be compared to its previous coalesced
event to set the states and movement_x/y.

+      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;

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

Let's not use "raf" here since this method will eventually be called at both
VSync signals and discrete events.  It seems s/_last_raf/_last_dispatch/ covers
both the cases.

[Navid Zolghadr, 2017/06/12 16:17:31]

Done.

+  bool any_touch_canceled_ended = false;

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

..._canceled_or_ended?

[Navid Zolghadr, 2017/06/12 16:17:32]

Done.

+  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
+    // |suppressing_touchmoves_within_slop_| would have been false.
+    DCHECK_EQ(touch_points_attributes_.size(), 1);
+    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::kPointerTypeLast -
+                                 WebInputEvent::kPointerTypeFirst + 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 =

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

s/pointer_action/pointer_event_type/

[Navid Zolghadr, 2017/06/12 16:17:31]

Done.

+        touch_point_attribute->event_.GetType();
+    size_t pointer_action_idx =

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

event_type_idx?

[Navid Zolghadr, 2017/06/12 16:17:31]

Done.

+        pointer_action - WebInputEvent::kPointerTypeFirst;
     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

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

/containing/

[Navid Zolghadr, 2017/06/12 16:17:31]

Done.

   // 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::kPointerTypeFirst;
+       action <= WebInputEvent::kPointerTypeLast; ++action) {
+    size_t action_idx = action - WebInputEvent::kPointerTypeFirst;
+    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(TouchEventNameForPointerEventType(
+        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);

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

Consider these event sequece, all within the same vsync window:
touchstart (id=11)   => dispatched immediately
touchstart (id=22)   => dispatched immediately
touchmove (id=22)    => queued.
touchmove (id=22)    => queued
touchend (id=x)      => dispatch touchmoves then touchend, regardless of x

So ultimately we will need to include timestamp order somehow.

Since the current logic works now (because we are dispatching at every event for
now), you may add a TODO and move on.

[Navid Zolghadr, 2017/06/12 16:17:31]

This code does not handle that. My understanding at the moment is that the
main_thread_event_queue will take care of calling HandleVSyncSignal whenever it
desires. Note that Dave also added another API that let the extension to choose
the events being sent as the come without any coalescing. So in that case the
main_thread_event_queue class will send an event and immediately call the
HandleVsyncSignal. Now that I'm thinking since I have those usecases maybe the
name HandleVsyncSignal it not very fitting here. I changed it to FlushEvents
instead.

 
       // Only report for top level documents with a single touch on

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

The UMA block is too long and a bit distracting here.  Can we please move this
off to a separate method?

[Navid Zolghadr, 2017/06/12 16:17:31]

Done.

       // 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::kPointerTypeFirst);
+  DCHECK_LE(event.GetType(), WebInputEvent::kPointerTypeLast);
 
-  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);

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

Can use .erase(releasedCanceledPoints) instead?

[Navid Zolghadr, 2017/06/12 16:17:31]

Not quite. But there seems to be a RemoveAll function.

   }
 
-  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