Remove PlatformTouchEvent/Point and use WebTouchEvent/Point instead

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"
 #include "core/frame/FrameView.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/input/EventHandler.h"
 #include "core/input/EventHandlingUtil.h"
 #include "core/input/MouseEventManager.h"
 #include "core/input/TouchActionUtil.h"
 #include "core/layout/HitTestCanvasResult.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
-#include "platform/PlatformTouchEvent.h"
+#include "public/platform/WebTouchEvent.h"
 
 namespace blink {
 
 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<PlatformTouchPoint> getCoalescedPoints(
-    const Vector<PlatformTouchEvent>& coalescedEvents,
+Vector<WebTouchPoint> getCoalescedPoints(
+    const Vector<WebTouchEvent>& coalescedEvents,
     int id) {
-  Vector<PlatformTouchPoint> relatedPoints;
+  Vector<WebTouchPoint> relatedPoints;
   for (const auto& touchEvent : coalescedEvents) {
-    for (auto& point : touchEvent.touchPoints()) {
+    for (unsigned i = 0; i < touchEvent.touchesLength; ++i) {
       // TODO(nzolghadr): Need to filter out stationary points
-      if (point.id() == id)
-        relatedPoints.push_back(point);
+      if (touchEvent.touches[i].id == id)
+        relatedPoints.push_back(touchEvent.touchPointInRootFrame(i));
     }
   }
   return relatedPoints;
 }
 
 }  // namespace
 
 PointerEventManager::PointerEventManager(LocalFrame& frame,
                                          MouseEventManager& mouseEventManager)
     : m_frame(frame),
@@ skipping 209 matching lines @@
 
     removePointer(pointerEvent);
   }
 }
 
 void PointerEventManager::unblockTouchPointers() {
   m_inCanceledStateForPointerTypeTouch = false;
 }
 
 WebInputEventResult PointerEventManager::handleTouchEvents(
-    const PlatformTouchEvent& event,
-    const Vector<PlatformTouchEvent>& coalescedEvents) {
-  if (event.type() == PlatformEvent::TouchScrollStarted) {
+    const WebTouchEvent& event,
+    const Vector<WebTouchEvent>& coalescedEvents) {
+  if (event.type() == WebInputEvent::TouchScrollStarted) {
     blockTouchPointers();
     return WebInputEventResult::HandledSystem;
   }
 
   bool newTouchSequence = true;
-  for (const auto& touchPoint : event.touchPoints()) {
-    if (touchPoint.state() != PlatformTouchPoint::TouchPressed) {
+  for (unsigned i = 0; i < event.touchesLength; ++i) {
+    if (event.touches[i].state != WebTouchPoint::StatePressed) {
       newTouchSequence = false;
       break;
     }
   }
   if (newTouchSequence)
     unblockTouchPointers();
 
   // Do any necessary hit-tests and compute the event targets for all pointers
   // in the event.
   HeapVector<TouchEventManager::TouchInfo> touchInfos;
   computeTouchTargets(event, touchInfos);
 
   // Any finger lifting is a user gesture only when it wasn't associated with a
   // scroll.
   // https://docs.google.com/document/d/1oF1T3O7_E4t1PYHV6gyCwHxOi3ystm0eSL5xZu7nvOg/edit#
   // Re-use the same UserGesture for touchend and pointerup (but not for the
   // mouse events generated by GestureTap).
   // For the rare case of multi-finger scenarios spanning documents, it
   // seems extremely unlikely to matter which document the gesture is
   // associated with so just pick the first finger.
   RefPtr<UserGestureToken> possibleGestureToken;
-  if (event.type() == PlatformEvent::TouchEnd &&
+  if (event.type() == WebInputEvent::TouchEnd &&
       !m_inCanceledStateForPointerTypeTouch && !touchInfos.isEmpty() &&
       touchInfos[0].targetFrame) {
     possibleGestureToken =
         DocumentUserGestureToken::create(touchInfos[0].targetFrame->document());
   }
   UserGestureIndicator holder(possibleGestureToken);
 
   dispatchTouchPointerEvents(event, coalescedEvents, touchInfos);
 
   return m_touchEventManager->handleTouchEvent(event, touchInfos);
 }
 
 void PointerEventManager::computeTouchTargets(
-    const PlatformTouchEvent& event,
+    const WebTouchEvent& event,
     HeapVector<TouchEventManager::TouchInfo>& touchInfos) {
-  for (const auto& touchPoint : event.touchPoints()) {
+  for (unsigned touchPoint = 0; touchPoint < event.touchesLength;
+       ++touchPoint) {
     TouchEventManager::TouchInfo touchInfo;
-    touchInfo.point = touchPoint;
+    touchInfo.point = event.touchPointInRootFrame(touchPoint);
 
-    int pointerId =
-        m_pointerEventFactory.getPointerEventId(touchPoint.pointerProperties());
+    int pointerId = m_pointerEventFactory.getPointerEventId(touchInfo.point);
     // Do the hit test either when the touch first starts or when the touch
     // is not captured. |m_pendingPointerCaptureTarget| indicates the target
     // that will be capturing this event. |m_pointerCaptureTarget| may not
     // have this target yet since the processing of that will be done right
     // before firing the event.
-    if (touchInfo.point.state() == PlatformTouchPoint::TouchPressed ||
+    if (touchInfo.point.state == WebTouchPoint::StatePressed ||
         !m_pendingPointerCaptureTarget.contains(pointerId)) {
       HitTestRequest::HitTestRequestType hitType = HitTestRequest::TouchEvent |
                                                    HitTestRequest::ReadOnly |
                                                    HitTestRequest::Active;
       LayoutPoint pagePoint = LayoutPoint(
-          m_frame->view()->rootFrameToContents(touchInfo.point.pos()));
+          m_frame->view()->rootFrameToContents(touchInfo.point.position));
       HitTestResult hitTestTesult =
           m_frame->eventHandler().hitTestResultAtPoint(pagePoint, hitType);
       Node* node = hitTestTesult.innerNode();
       if (node) {
         touchInfo.targetFrame = node->document().frame();
         if (isHTMLCanvasElement(node)) {
           HitTestCanvasResult* hitTestCanvasResult =
               toHTMLCanvasElement(node)->getControlAndIdIfHitRegionExists(
                   hitTestTesult.pointInInnerNodeFrame());
           if (hitTestCanvasResult->getControl())
@@ skipping 16 matching lines @@
       touchInfo.touchNode =
           m_pendingPointerCaptureTarget.get(pointerId)->toNode();
       touchInfo.targetFrame = touchInfo.touchNode->document().frame();
     }
 
     touchInfos.push_back(touchInfo);
   }
 }
 
 void PointerEventManager::dispatchTouchPointerEvents(
-    const PlatformTouchEvent& event,
-    const Vector<PlatformTouchEvent>& coalescedEvents,
+    const WebTouchEvent& event,
+    const Vector<WebTouchEvent>& coalescedEvents,
     HeapVector<TouchEventManager::TouchInfo>& touchInfos) {
   // Iterate through the touch points, sending PointerEvents to the targets as
   // required.
   for (auto touchInfo : touchInfos) {
-    const PlatformTouchPoint& touchPoint = touchInfo.point;
+    const WebTouchPoint& touchPoint = touchInfo.point;
     // Do not send pointer events for stationary touches or null targetFrame
     if (touchInfo.touchNode && touchInfo.targetFrame &&
-        touchPoint.state() != PlatformTouchPoint::TouchStationary &&
+        touchPoint.state != WebTouchPoint::StateStationary &&
         !m_inCanceledStateForPointerTypeTouch) {
       PointerEvent* pointerEvent = m_pointerEventFactory.create(
-          touchPoint, getCoalescedPoints(coalescedEvents, touchPoint.id()),
-          event.getModifiers(), touchInfo.targetFrame,
+          touchPoint, getCoalescedPoints(coalescedEvents, touchPoint.id),
+          static_cast<WebInputEvent::Modifiers>(event.modifiers()),
+          touchInfo.targetFrame,
           touchInfo.touchNode ? touchInfo.touchNode->document().domWindow()
                               : nullptr);
 
       WebInputEventResult result =
           sendTouchPointerEvent(touchInfo.touchNode, pointerEvent);
 
       // If a pointerdown has been canceled, queue the unique id to allow
       // suppressing mouse events from gesture events. For mouse events
       // fired from GestureTap & GestureLongPress (which are triggered by
       // single touches only), it is enough to queue the ids only for
       // primary pointers.
       // TODO(mustaq): What about other cases (e.g. GestureTwoFingerTap)?
       if (result != WebInputEventResult::NotHandled &&
           pointerEvent->type() == EventTypeNames::pointerdown &&
           pointerEvent->isPrimary()) {
-        m_touchIdsForCanceledPointerdowns.append(event.uniqueTouchEventId());
+        m_touchIdsForCanceledPointerdowns.append(event.uniqueTouchEventId);
       }
     }
   }
 }
 
 WebInputEventResult PointerEventManager::sendTouchPointerEvent(
     EventTarget* target,
     PointerEvent* pointerEvent) {
   if (m_inCanceledStateForPointerTypeTouch)
     return WebInputEventResult::NotHandled;
@@ skipping 278 matching lines @@
     if (firstId > uniqueTouchEventId)
       return false;
     m_touchIdsForCanceledPointerdowns.takeFirst();
     if (firstId == uniqueTouchEventId)
       return true;
   }
   return false;
 }
 
 }  // namespace blink