Remove WebTouchEvent from TouchEventManager APIs

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/ElementTraversal.h"
 #include "core/dom/UserGestureIndicator.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
@@ skipping 11 matching lines @@
 #include "public/platform/WebTouchEvent.h"
 
 namespace blink {
 
 namespace {
 
 size_t ToPointerTypeIndex(WebPointerProperties::PointerType t) {
   return static_cast<size_t>(t);
 }
 
+Vector<WebPointerEvent> GetCoalescedWebPointerEventsWithNoTransformation(
+    const Vector<WebTouchEvent>& coalesced_events,
+    int id) {
+  Vector<WebPointerEvent> related_pointer_events;
+  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_pointer_events.push_back(
+            WebPointerEvent(touch_event, touch_event.touches[i]));
+      }
+    }
+  }
+  return related_pointer_events;
+}
+
 Vector<std::pair<WebTouchPoint, TimeTicks>> GetCoalescedPoints(
     const Vector<WebTouchEvent>& coalesced_events,
     int id) {
   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(std::pair<WebTouchPoint, TimeTicks>(
             touch_event.TouchPointInRootFrame(i),
@@ skipping 269 matching lines @@
   // associated with so just pick the first finger.
   RefPtr<UserGestureToken> possible_gesture_token;
   if (event.GetType() == WebInputEvent::kTouchEnd &&
       !in_canceled_state_for_pointer_type_touch_ && event.touches_length &&
       first_pointer_event_target.target_frame) {
     possible_gesture_token = UserGestureToken::Create(
         first_pointer_event_target.target_frame->GetDocument());
   }
   UserGestureIndicator holder(possible_gesture_token);
 
-  HeapVector<EventHandlingUtil::PointerEventTarget> pointer_event_targets;
 
   for (unsigned touch_point_idx = 0; touch_point_idx < event.touches_length;
        ++touch_point_idx) {
     // Do any necessary hit-tests and compute the event targets for all pointers
     // in the event.
     const auto& touch_point = event.TouchPointInRootFrame(touch_point_idx);
     EventHandlingUtil::PointerEventTarget pointer_event_target =
         touch_point_idx ? ComputePointerEventTarget(touch_point)
                         : first_pointer_event_target;
-    pointer_event_targets.push_back(pointer_event_target);
 
-    DispatchTouchPointerEvent(
-        touch_point, pointer_event_target,
-        GetCoalescedPoints(coalesced_events, touch_point.id),
-        static_cast<WebInputEvent::Modifiers>(event.GetModifiers()),
-        event.TimeStampSeconds(), event.unique_touch_event_id);
+    if (touch_point.state != blink::WebTouchPoint::kStateStationary) {
+      DispatchTouchPointerEvent(
+          touch_point, pointer_event_target,
+          GetCoalescedPoints(coalesced_events, touch_point.id),
+          static_cast<WebInputEvent::Modifiers>(event.GetModifiers()),
+          event.TimeStampSeconds(), event.unique_touch_event_id);
+
+      touch_event_manager_->HandleTouchPoint(
+          WebPointerEvent(event, event.touches[touch_point_idx]),
+          GetCoalescedWebPointerEventsWithNoTransformation(
+              coalesced_events, event.touches[touch_point_idx].id),
+          pointer_event_target);
+    }
   }
 
-  return touch_event_manager_->HandleTouchEvent(event, coalesced_events,
-                                                pointer_event_targets);
+  return touch_event_manager_->HandleVSyncSignal();
 }
 
 EventHandlingUtil::PointerEventTarget
 PointerEventManager::ComputePointerEventTarget(
     const WebTouchPoint& touch_point) {
   EventHandlingUtil::PointerEventTarget pointer_event_target;
 
   int pointer_id = pointer_event_factory_.GetPointerEventId(touch_point);
   // Do the hit test either when the touch first starts or when the touch
   // is not captured. |m_pendingPointerCaptureTarget| indicates the target
@@ skipping 44 matching lines @@
 void PointerEventManager::DispatchTouchPointerEvent(
     const WebTouchPoint& touch_point,
     const EventHandlingUtil::PointerEventTarget& pointer_event_target,
     const Vector<std::pair<WebTouchPoint, TimeTicks>>& coalesced_events,
     WebInputEvent::Modifiers modifiers,
     double timestamp,
     uint32_t unique_touch_event_id) {
   // Iterate through the touch points, sending PointerEvents to the targets as
   // required.
   // Do not send pointer events for stationary touches or null targetFrame
   if (pointer_event_target.target_node && pointer_event_target.target_frame &&

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

Why are you not skipping the stationary points here?

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

I have moved the check outside of the function and basically ignore the
stationary points for all the actions including passing it to TouchEventManager
and firing the pointerevents. Later I'm going to move this if more and more
outside and basically this class will never get a stationary point.

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

Sg, thanks.

Please check the comments about stationary points in TEM & PEM, some are stale
now.

-      touch_point.state != WebTouchPoint::kStateStationary &&
       !in_canceled_state_for_pointer_type_touch_) {
     PointerEvent* pointer_event = pointer_event_factory_.Create(
         touch_point, coalesced_events,
         static_cast<WebInputEvent::Modifiers>(modifiers),
         TimeTicks::FromSeconds(timestamp), pointer_event_target.target_frame,
         pointer_event_target.target_node
             ? pointer_event_target.target_node->GetDocument().domWindow()
             : nullptr);
 
     WebInputEventResult result =
@@ skipping 327 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