Move touch hit testing to PointerEventManager

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/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
 #include "core/frame/FrameView.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/input/EventHandler.h"
+#include "core/input/TouchActionUtil.h"
+#include "core/page/ChromeClient.h"
+#include "core/page/Page.h"
 #include "platform/PlatformTouchEvent.h"
 
 namespace blink {
 
 namespace {
 
 size_t toPointerTypeIndex(WebPointerProperties::PointerType t) { return static_cast<size_t>(t); }
 
 const AtomicString& pointerEventNameForTouchPointState(PlatformTouchPoint::TouchState state)
 {
@@ skipping 367 matching lines @@
     for (const auto &touchPoint : event.touchPoints()) {
         if (touchPoint.state() != PlatformTouchPoint::TouchPressed) {
             newTouchSequence = false;
             break;
         }
     }
     if (newTouchSequence)
         unblockTouchPointers();
     HeapVector<TouchEventManager::TouchInfo> touchInfos;
 
-    // TODO(crbug.com/606822): This will be moved after pointer events so
-    // pointer event operations will get the first shot to fill up this array.
-    if (!m_touchEventManager.generateTouchInfosAfterHittest(event, touchInfos))
-        return WebInputEventResult::NotHandled;
-
     dispatchTouchPointerEvents(event, touchInfos);
 
     return m_touchEventManager.handleTouchEvent(event, touchInfos);
 }
 
 void PointerEventManager::dispatchTouchPointerEvents(
     const PlatformTouchEvent& event,
     HeapVector<TouchEventManager::TouchInfo>& touchInfos)
 {
-    if (!RuntimeEnabledFeatures::pointerEventEnabled())
-        return;
+    // Iterate through the touch points, sending PointerEvents to the targets as required.
+    for (const auto& touchPoint : event.touchPoints()) {
+        TouchEventManager::TouchInfo touchInfo;
+        touchInfo.point = touchPoint;
 
-    if (m_inCanceledStateForPointerTypeTouch)
-        return;
+        int pointerId = m_pointerEventFactory.getPointerEventId(
+            touchPoint.pointerProperties());
+        // 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
+            || !m_pendingPointerCaptureTarget.contains(pointerId)) {
+            HitTestRequest::HitTestRequestType hitType = HitTestRequest::TouchEvent | HitTestRequest::ReadOnly | HitTestRequest::Active;
+            LayoutPoint pagePoint = roundedLayoutPoint(m_frame->view()->rootFrameToContents(touchInfo.point.pos()));
+            HitTestResult hitTestTesult = m_frame->eventHandler().hitTestResultAtPoint(pagePoint, hitType);
+            Node* node = hitTestTesult.innerNode();
+            if (node) {
+                touchInfo.targetFrame = node->document().frame();
+                if (isHTMLCanvasElement(node)) {
+                    std::pair<Element*, String> regionInfo = toHTMLCanvasElement(node)->getControlAndIdIfHitRegionExists(hitTestTesult.pointInInnerNodeFrame());
+                    if (regionInfo.first)
+                        node = regionInfo.first;
+                    touchInfo.region = regionInfo.second;
+                }
+                // TODO(crbug.com/612456): We need to investigate whether pointer
+                // events should go to text nodes or not. If so we need to
+                // update the mouse code as well. Also this logic looks similar
+                // to the one in TouchEventManager. We should be able to
+                // refactor it better after this investigation.
+                if (node->isTextNode())
+                    node = FlatTreeTraversal::parent(*node);
+                touchInfo.touchNode = node;
 
-    // Iterate through the touch points, sending PointerEvents to the targets as required.
-    for (auto& touchInfo: touchInfos) {
-        const PlatformTouchPoint &touchPoint = touchInfo.point;
+            }
+        } else {
+            // Set the target of pointer event to the captured node as this
+            // pointer is captured otherwise it would have gone to the if block
+            // and perform a hit-test.
+            touchInfo.touchNode = m_pendingPointerCaptureTarget
+                .get(pointerId)->toNode();
+            touchInfo.targetFrame = touchInfo.touchNode->document().frame();
+        }
+
         WebInputEventResult result = WebInputEventResult::NotHandled;
-        // Do not send pointer events for stationary touches.
-        if (touchPoint.state() != PlatformTouchPoint::TouchStationary) {
+
+        // Do not send pointer events for stationary touches or null targetFrame
+        if (touchInfo.touchNode
+            && touchPoint.state() != PlatformTouchPoint::TouchStationary
+            && !m_inCanceledStateForPointerTypeTouch) {
+            FloatPoint pagePoint = touchInfo.targetFrame->view()
+                ->rootFrameToContents(touchInfo.point.pos());
             float scaleFactor = 1.0f / touchInfo.targetFrame->pageZoomFactor();
             FloatPoint scrollPosition = touchInfo.targetFrame->view()->scrollPosition();
-            FloatPoint framePoint = touchInfo.contentPoint;
+            FloatPoint framePoint = pagePoint.scaledBy(scaleFactor);
             framePoint.moveBy(scrollPosition.scaledBy(-scaleFactor));
             PointerEvent* pointerEvent = m_pointerEventFactory.create(
                 pointerEventNameForTouchPointState(touchPoint.state()),
                 touchPoint, event.getModifiers(),
-                touchInfo.adjustedRadius,
+                touchPoint.radius().scaledBy(scaleFactor),
                 framePoint,
                 touchInfo.touchNode ?
                     touchInfo.touchNode->document().domWindow() : nullptr);
 
-            // Consume the touch point if its pointer event is anything but NotHandled
-            // (e.g. preventDefault is called in the listener for the pointer event).
             result = sendTouchPointerEvent(touchInfo.touchNode, pointerEvent);
-            touchInfo.consumed = result != WebInputEventResult::NotHandled;
+        }
+        // TODO(crbug.com/507408): Right now we add the touch point only if
+        // its pointer event is NotHandled (e.g. preventDefault is called in
+        // the pointer event listener). This behavior needs to change as it
+        // may create some inconsistent touch event sequence.
+        if (result == WebInputEventResult::NotHandled) {
+            touchInfos.append(touchInfo);
         }
     }
 }
 
 WebInputEventResult PointerEventManager::sendTouchPointerEvent(
     EventTarget* target, PointerEvent* pointerEvent)
 {
     if (m_inCanceledStateForPointerTypeTouch)
         return WebInputEventResult::NotHandled;
 
@@ skipping 282 matching lines @@
 {
     visitor->trace(m_frame);
     visitor->trace(m_nodeUnderPointer);
     visitor->trace(m_pointerCaptureTarget);
     visitor->trace(m_pendingPointerCaptureTarget);
     visitor->trace(m_touchEventManager);
 }
 
 
 } // namespace blink