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 15 matching lines @@
 
 namespace {
 
 size_t ToPointerTypeIndex(WebPointerProperties::PointerType t) {
   return static_cast<size_t>(t);
 }
 bool HasPointerEventListener(const EventHandlerRegistry& registry) {
   return registry.HasEventHandlers(EventHandlerRegistry::kPointerEvent);
 }
 
+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 271 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);
+  // Calling this function |FlushEvents| will be moved to MainThreadEventQueue
+  // class. It will be called before rAF and also whenever we run in low latency
+  // mode as mentioned in crbug.com/728250.
+  return touch_event_manager_->FlushEvents();
 }
 
 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 45 matching lines @@
     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 &&
-      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