Move touch hit testing to PointerEventManager

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 "core/dom/Document.h"
 #include "core/events/TouchEvent.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameHost.h"
@@ skipping 151 matching lines @@
     TargetTouchesHeapMap touchesByTarget;
 
     // Array of touches per state, used to assemble the |changedTouches| list.
     ChangedTouches changedTouches[PlatformTouchPoint::TouchStateEnd];
 
     for (unsigned i = 0; i < touchInfos.size(); ++i) {
         const TouchInfo& touchInfo = touchInfos[i];
         const PlatformTouchPoint& point = touchInfo.point;
         PlatformTouchPoint::TouchState pointState = point.state();
 
-        if (touchInfo.consumed)
-            continue;
-
         Touch* touch = Touch::create(
             touchInfo.targetFrame.get(),
             touchInfo.touchNode.get(),
             point.id(),
             point.screenPos(),
             touchInfo.adjustedPagePoint,
             touchInfo.adjustedRadius,
             point.rotationAngle(),
             point.force(),
             touchInfo.region);
@@ skipping 77 matching lines @@
 void TouchEventManager::updateTargetAndRegionMapsForTouchStarts(
     HeapVector<TouchInfo>& touchInfos)
 {
     for (auto& touchInfo : touchInfos) {
         // 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.
         if (touchInfo.point.state() == PlatformTouchPoint::TouchPressed) {
             HitTestRequest::HitTestRequestType hitType = HitTestRequest::TouchEvent | HitTestRequest::ReadOnly | HitTestRequest::Active;
-            LayoutPoint pagePoint = roundedLayoutPoint(m_frame->view()->rootFrameToContents(touchInfo.point.pos()));
             HitTestResult result;
-            if (!m_touchSequenceDocument) {
-                result = m_frame->eventHandler().hitTestResultAtPoint(pagePoint, hitType);

[mustaq, 2016/05/11 14:30:55]

Looks like we are not covering this case anymore. We should be careful not to
change the touch behavior in any way.

[Navid Zolghadr, 2016/05/11 16:43:42]

We are not. This scenario (which is generally the first touch) is handled by
using the hit test result of pointer event that is already populated in
TouchInfo struct.

-            } else if (m_touchSequenceDocument->frame()) {
-                LayoutPoint framePoint = roundedLayoutPoint(m_touchSequenceDocument->frame()->view()->rootFrameToContents(touchInfo.point.pos()));
-                result = EventHandler::hitTestResultInFrame(m_touchSequenceDocument->frame(), framePoint, hitType);
-            } else {
+            if (m_touchSequenceDocument && (!touchInfo.touchNode

[dtapuska, 2016/05/13 16:51:36]

Can we add a comment what the intent of this code is. I understand it but since
it is complex it deserves a comment.

[Navid Zolghadr, 2016/05/16 20:01:50]

Done.

+                || &touchInfo.touchNode->document() != m_touchSequenceDocument)) {
+                if (m_touchSequenceDocument->frame()) {
+                    LayoutPoint framePoint = roundedLayoutPoint(m_touchSequenceDocument->frame()->view()->rootFrameToContents(touchInfo.point.pos()));
+                    result = EventHandler::hitTestResultInFrame(m_touchSequenceDocument->frame(), framePoint, hitType);
+                    Node* node = result.innerNode();
+                    if (!node)
+                        continue;
+                    if (isHTMLCanvasElement(node)) {
+                        std::pair<Element*, String> regionInfo = toHTMLCanvasElement(node)->getControlAndIdIfHitRegionExists(result.pointInInnerNodeFrame());
+                        if (regionInfo.first)
+                            node = regionInfo.first;
+                        touchInfo.region = regionInfo.second;
+                    }
+                    // Touch events should not go to text nodes.
+                    if (node->isTextNode())
+                        node = FlatTreeTraversal::parent(*node);
+                    touchInfo.touchNode = node;
+                } else {
+                    continue;
+                }
+            }
+            if (!touchInfo.touchNode)
                 continue;
-            }
-
-            Node* node = result.innerNode();
-            if (!node)
-                continue;
-            if (isHTMLCanvasElement(node)) {
-                std::pair<Element*, String> regionInfo = toHTMLCanvasElement(node)->getControlAndIdIfHitRegionExists(result.pointInInnerNodeFrame());
-                if (regionInfo.first)
-                    node = regionInfo.first;
-                touchInfo.region = regionInfo.second;
-            }
-            // Touch events should not go to text nodes.
-            if (node->isTextNode())
-                node = FlatTreeTraversal::parent(*node);
-            touchInfo.touchNode = node;
-
             if (!m_touchSequenceDocument) {
                 // 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.
                 m_touchSequenceDocument = &(touchInfo.touchNode->document());
                 ASSERT(m_touchSequenceDocument->frame()->view());
             }
 
             // Ideally we'd ASSERT(!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.
             m_targetForTouchID.set(touchInfo.point.id(), touchInfo.touchNode);
 
             m_regionForTouchID.set(touchInfo.point.id(), touchInfo.region);
-
-            TouchAction effectiveTouchAction =
-                TouchActionUtil::computeEffectiveTouchAction(
-                    *touchInfo.touchNode);
-            if (effectiveTouchAction != TouchActionAuto)
-                m_frame->page()->chromeClient().setTouchAction(effectiveTouchAction);
         }
     }
 }
 
 void TouchEventManager::setAllPropertiesOfTouchInfos(
     HeapVector<TouchInfo>& touchInfos)
 {
     for (auto& touchInfo : touchInfos) {
         PlatformTouchPoint::TouchState pointState = touchInfo.point.state();
         Node* touchNode = nullptr;
@@ skipping 47 matching lines @@
         // pagePoint should always be in the target element's document coordinates.
         FloatPoint pagePoint = targetFrame->view()->rootFrameToContents(
             touchInfo.point.pos());
         float scaleFactor = 1.0f / targetFrame->pageZoomFactor();
 
         touchInfo.touchNode = touchNode;
         touchInfo.targetFrame = targetFrame;
         touchInfo.adjustedPagePoint = pagePoint.scaledBy(scaleFactor);
         touchInfo.adjustedRadius = touchInfo.point.radius().scaledBy(scaleFactor);
         touchInfo.knownTarget = knownTarget;
-        touchInfo.consumed = false;
         touchInfo.region = regionID;
     }
 }
 
-bool TouchEventManager::generateTouchInfosAfterHittest(
+bool TouchEventManager::reHitTestTouchPointsIfNeeded(
     const PlatformTouchEvent& event,
     HeapVector<TouchInfo>& touchInfos)
 {
     bool newTouchSequence = true;
     bool allTouchesReleased = true;
 
     for (const auto& point : event.touchPoints()) {
         if (point.state() != PlatformTouchPoint::TouchPressed)
             newTouchSequence = false;
         if (point.state() != PlatformTouchPoint::TouchReleased && point.state() != PlatformTouchPoint::TouchCancelled)
             allTouchesReleased = false;
     }
     if (newTouchSequence) {
         // Ideally we'd ASSERT(!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.
         m_touchSequenceDocument.clear();
         m_touchSequenceUserGestureToken.clear();
     }
 
     ASSERT(m_frame->view());
     if (m_touchSequenceDocument && (!m_touchSequenceDocument->frame() || !m_touchSequenceDocument->frame()->view())) {
         // If the active touch document has no frame or view, it's probably being destroyed
         // so we can't dispatch events.
         return false;
     }
 
-    for (const auto& point : event.touchPoints()) {
-        TouchEventManager::TouchInfo touchInfo;
-        touchInfo.point = point;
-        touchInfos.append(touchInfo);
-    }
-
     updateTargetAndRegionMapsForTouchStarts(touchInfos);
 
     m_touchPressed = !allTouchesReleased;
 
     // 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 (!m_touchSequenceDocument || !m_touchSequenceDocument->frameHost() || !hasTouchHandlers(m_touchSequenceDocument->frameHost()->eventHandlerRegistry()) || !m_touchSequenceDocument->frame()) {
         if (allTouchesReleased) {
             m_touchSequenceDocument.clear();
             m_touchSequenceUserGestureToken.clear();
         }
         return false;
     }
 
     setAllPropertiesOfTouchInfos(touchInfos);
 
     return true;
 }
 
 WebInputEventResult TouchEventManager::handleTouchEvent(
     const PlatformTouchEvent& event,
-    const HeapVector<TouchInfo>& touchInfos)
+    HeapVector<TouchInfo>& touchInfos)
 {
+    if (!reHitTestTouchPointsIfNeeded(event, touchInfos))
+        return WebInputEventResult::NotHandled;
+
     // Note that the disposition of any pointer events affects only the generation of touch
     // events. If all pointer events were handled (and hence no touch events were fired), that
     // is still equivalent to the touch events going unhandled because pointer event handler
     // don't block scroll gesture generation.
 
     // TODO(crbug.com/507408): If PE handlers always call preventDefault, we won't see TEs until after
     // scrolling starts because the scrolling would suppress upcoming PEs. This sudden "break" in TE
     // suppression can make the visible TEs inconsistent (e.g. touchmove without a touchstart).
 
     bool allTouchesReleased = true;
@@ skipping 42 matching lines @@
 }
 
 DEFINE_TRACE(TouchEventManager)
 {
     visitor->trace(m_frame);
     visitor->trace(m_touchSequenceDocument);
     visitor->trace(m_targetForTouchID);
 }
 
 } // namespace blink