Added PointerEvent firing on touch events.

Source/core/page/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 27 matching lines @@
 #include "core/dom/TouchList.h"
 #include "core/dom/shadow/ComposedTreeTraversal.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/htmlediting.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/events/EventPath.h"
 #include "core/events/KeyboardEvent.h"
 #include "core/events/MouseEvent.h"
+#include "core/events/PointerEvent.h"
 #include "core/events/TextEvent.h"
 #include "core/events/TouchEvent.h"
 #include "core/events/WheelEvent.h"
 #include "core/fetch/ImageResource.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/PinchViewport.h"
 #include "core/frame/Settings.h"
@@ skipping 251 matching lines @@
     m_previousWheelScrolledNode = nullptr;
     m_targetForTouchID.clear();
     m_touchSequenceDocument.clear();
     m_touchSequenceUserGestureToken.clear();
     m_scrollGestureHandlingNode = nullptr;
     m_lastGestureScrollOverWidget = false;
     m_previousGestureScrolledNode = nullptr;
     m_scrollbarHandlingScrollGesture = nullptr;
     m_maxMouseMovedDuration = 0;
     m_touchPressed = false;
+    m_pointerIdManager.clear();
     m_mouseDownMayStartSelect = false;
     m_mouseDownMayStartDrag = false;
     m_lastShowPressTimestamp = 0;
     m_lastDeferredTapElement = nullptr;
     m_eventHandlerWillResetCapturingMouseEventsNode = false;
     m_mouseDownWasSingleClickInSelection = false;
     m_selectionInitiationState = HaveNotStartedSelection;
     m_mouseDownMayStartAutoscroll = false;
     m_svgPan = false;
     m_mouseDownPos = IntPoint();
@@ skipping 3441 matching lines @@
             m_lastScrollbarUnderMouse->mouseExited();
 
         // Send mouse entered if we're setting a new scrollbar.
         if (scrollbar && setLast)
             scrollbar->mouseEntered();
 
         m_lastScrollbarUnderMouse = setLast ? scrollbar : nullptr;
     }
 }
 
-static const AtomicString& eventNameForTouchPointState(PlatformTouchPoint::State state)
+static const AtomicString& touchEventNameForTouchPointState(PlatformTouchPoint::State state)
 {
     switch (state) {
     case PlatformTouchPoint::TouchReleased:
         return EventTypeNames::touchend;
     case PlatformTouchPoint::TouchCancelled:
         return EventTypeNames::touchcancel;
     case PlatformTouchPoint::TouchPressed:
         return EventTypeNames::touchstart;
     case PlatformTouchPoint::TouchMoved:
         return EventTypeNames::touchmove;
     case PlatformTouchPoint::TouchStationary:
-        // TouchStationary state is not converted to touch events, so fall through to assert.
+        // Fall through to default
     default:
         ASSERT_NOT_REACHED();
         return emptyAtom;
+    }
+}
+
+static const AtomicString& pointerEventNameForTouchPointState(PlatformTouchPoint::State state)
+{
+    switch (state) {
+    case PlatformTouchPoint::TouchReleased:
+        return EventTypeNames::pointerup;
+    case PlatformTouchPoint::TouchCancelled:
+        return EventTypeNames::pointercancel;
+    case PlatformTouchPoint::TouchPressed:
+        return EventTypeNames::pointerdown;
+    case PlatformTouchPoint::TouchMoved:
+        return EventTypeNames::pointermove;
+    case PlatformTouchPoint::TouchStationary:
+        // Fall through to default
+    default:
+        ASSERT_NOT_REACHED();
+        return emptyAtom;
     }
 }
 
 HitTestResult EventHandler::hitTestResultInFrame(LocalFrame* frame, const LayoutPoint& point, HitTestRequest::HitTestRequestType hitType)
 {
     HitTestResult result(HitTestRequest(hitType), point);
 
     if (!frame || !frame->contentLayoutObject())
         return result;
     if (frame->view()) {
         IntRect rect = frame->view()->visibleContentRect(IncludeScrollbars);
         if (!rect.contains(roundedIntPoint(point)))
             return result;
     }
     frame->contentLayoutObject()->hitTest(result);
     return result;
 }
 
+void EventHandler::handlePointerEventsFromTouchEvent(const PlatformTouchEvent& event,
+    const Vector<PlatformTouchPoint>& points, Vector<TouchInfo>& touchInfos)
+{
+    const String& PointerTypeStrForTouch("touch");
+
+    // Iterate through the touch points, sending PointerEvents to the targets as required.
+    for (unsigned i = 0; i < points.size(); ++i) {
+        const PlatformTouchPoint& point = points[i];
+        TouchInfo& touchInfo = touchInfos[i];

[Rick Byers, 2015/06/16 17:25:39]

would it be a little cleaner to stick the PlatformTouchPoint into the TouchInfo
(then you're really just iterating across a single list)?

[mustaq, 2015/06/16 20:18:43]

Done.

+
+        unsigned pointerId = point.id();
+        const PlatformTouchPoint::State pointState = point.state();
+
+        if (pointState == PlatformTouchPoint::TouchStationary)
+            continue;
+        bool pointerReleasedOrCancelled =
+            pointState == PlatformTouchPoint::TouchReleased || pointState == PlatformTouchPoint::TouchCancelled;
+        const AtomicString& eventName(pointerEventNameForTouchPointState(pointState));
+
+        if (pointState == PlatformTouchPoint::TouchPressed)
+            m_pointerIdManager.add(PointerIdManager::PointerTypeTouch, pointerId);
+
+        bool isEnterOrLeave = false;
+        bool isCancelable = !(isEnterOrLeave || pointState == PlatformTouchPoint::TouchCancelled);
+        bool isBubbling = !isEnterOrLeave;

[Rick Byers, 2015/06/16 17:25:39]

nit isCancelable and isBubbling local variables only seem to decrease
readability to me - just stick the value right into the pointerEventInit?

[mustaq, 2015/06/16 20:18:43]

Done.

+
+        PointerEventInit pointerEventInit;
+        pointerEventInit.setPointerId(pointerId);
+        pointerEventInit.setWidth(touchInfo.adjustedRadius.width());
+        pointerEventInit.setHeight(touchInfo.adjustedRadius.height());
+        pointerEventInit.setPressure(point.force());
+        pointerEventInit.setPointerType(PointerTypeStrForTouch);
+        pointerEventInit.setIsPrimary(m_pointerIdManager.isPrimary(PointerIdManager::PointerTypeTouch, pointerId));
+        pointerEventInit.setScreenX(point.screenPos().x());
+        pointerEventInit.setScreenY(point.screenPos().y());
+        pointerEventInit.setClientX(touchInfo.adjustedPagePoint.x());
+        pointerEventInit.setClientY(touchInfo.adjustedPagePoint.y());
+        pointerEventInit.setButton(0);
+        pointerEventInit.setButtons(pointerReleasedOrCancelled ? 0 : 1);
+
+        pointerEventInit.setCtrlKey(event.ctrlKey());
+        pointerEventInit.setShiftKey(event.shiftKey());
+        pointerEventInit.setAltKey(event.altKey());
+        pointerEventInit.setMetaKey(event.metaKey());
+
+        pointerEventInit.setBubbles(isBubbling);
+        pointerEventInit.setCancelable(isCancelable);
+
+        RefPtrWillBeRawPtr<PointerEvent> pointerEvent = PointerEvent::create(eventName, pointerEventInit);
+        touchInfo.touchTarget->toNode()->dispatchPointerEvent(pointerEvent.get());
+        touchInfo.consumed = pointerEvent->defaultPrevented() || pointerEvent->defaultHandled();
+
+        // Remove the released/cancelled id at the end to correctly determine primary id above.
+        if (pointerReleasedOrCancelled)
+            m_pointerIdManager.remove(PointerIdManager::PointerTypeTouch, pointerId);
+    }
+}
+
 bool EventHandler::handleTouchEvent(const PlatformTouchEvent& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleTouchEvent");
 
     const Vector<PlatformTouchPoint>& points = event.touchPoints();
 
-    unsigned i;
     bool freshTouchEvents = true;
     bool allTouchReleased = true;
-    for (i = 0; i < points.size(); ++i) {
+    for (unsigned i = 0; i < points.size(); ++i) {
         const PlatformTouchPoint& point = points[i];
+
         if (point.state() != PlatformTouchPoint::TouchPressed)
             freshTouchEvents = false;
         if (point.state() != PlatformTouchPoint::TouchReleased && point.state() != PlatformTouchPoint::TouchCancelled)
             allTouchReleased = false;
     }
     if (freshTouchEvents) {
         // 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
@@ skipping 12 matching lines @@
     m_touchSequenceUserGestureToken = gestureIndicator->currentToken();
 
     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;
     }
 
     // First do hit tests for any new touch points.
-    for (i = 0; i < points.size(); ++i) {
+    for (unsigned i = 0; i < points.size(); ++i) {
         const PlatformTouchPoint& point = points[i];
 
         // 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 it can be read-only.
         if (point.state() == PlatformTouchPoint::TouchPressed) {
             HitTestRequest::HitTestRequestType hitType = HitTestRequest::TouchEvent | HitTestRequest::ReadOnly | HitTestRequest::Active;
             LayoutPoint pagePoint = roundedLayoutPoint(m_frame->view()->rootFrameToContents(point.pos()));
             HitTestResult result;
             if (!m_touchSequenceDocument) {
@@ skipping 41 matching lines @@
     // document set to receive the events, then we can skip all the rest of
     // this work.
     if (!m_touchSequenceDocument || !m_touchSequenceDocument->frameHost() || !m_touchSequenceDocument->frameHost()->eventHandlerRegistry().hasEventHandlers(EventHandlerRegistry::TouchEvent) || !m_touchSequenceDocument->frame()) {
         if (allTouchReleased) {
             m_touchSequenceDocument.clear();
             m_touchSequenceUserGestureToken.clear();
         }
         return false;
     }
 
-    // Build up the lists to use for the 'touches', 'targetTouches' and
-    // 'changedTouches' attributes in the JS event. See
-    // http://www.w3.org/TR/touch-events/#touchevent-interface for how these
-    // lists fit together.
+    // Compute and store the common info used by both PointerEvent and TouchEvent.
+    Vector<TouchInfo> touchInfos(points.size());
 
-    // Holds the complete set of touches on the screen.
-    RefPtrWillBeRawPtr<TouchList> touches = TouchList::create();
-
-    // A different view on the 'touches' list above, filtered and grouped by
-    // event target. Used for the 'targetTouches' list in the JS event.
-    using TargetTouchesHeapMap = WillBeHeapHashMap<EventTarget*, RefPtrWillBeMember<TouchList>>;
-    TargetTouchesHeapMap touchesByTarget;
-
-    // Array of touches per state, used to assemble the 'changedTouches' list.
-    using EventTargetSet = WillBeHeapHashSet<RefPtrWillBeMember<EventTarget>>;
-    struct {
-        // The touches corresponding to the particular change state this struct
-        // instance represents.
-        RefPtrWillBeMember<TouchList> m_touches;
-        // Set of targets involved in m_touches.
-        EventTargetSet m_targets;
-    } changedTouches[PlatformTouchPoint::TouchStateEnd];
-
-    for (i = 0; i < points.size(); ++i) {
+    for (unsigned i = 0; i < points.size(); ++i) {
         const PlatformTouchPoint& point = points[i];
         PlatformTouchPoint::State pointState = point.state();
         RefPtrWillBeRawPtr<EventTarget> touchTarget = nullptr;
 
         if (pointState == PlatformTouchPoint::TouchReleased || pointState == PlatformTouchPoint::TouchCancelled) {
             // The target should be the original target for this touch, so get
             // it from the hashmap. As it's a release or cancel we also remove
             // it from the map.
             touchTarget = m_targetForTouchID.take(point.id());
         } else {
@@ skipping 28 matching lines @@
             // a Touch is a Node so using the window could be a breaking change.
             // Since we know there was no handler invoked, the specific target
             // should be completely irrelevant to the application.
             touchTarget = m_touchSequenceDocument;
             targetFrame = m_touchSequenceDocument->frame();
         }
         ASSERT(targetFrame);
 
         // pagePoint should always be in the target element's document coordinates.
         FloatPoint pagePoint = targetFrame->view()->rootFrameToContents(point.pos());
-
         float scaleFactor = 1.0f / targetFrame->pageZoomFactor();
 
-        FloatPoint adjustedPagePoint = pagePoint.scaledBy(scaleFactor);
-        FloatSize adjustedRadius = point.radius().scaledBy(scaleFactor);
+        TouchInfo& touchInfo = touchInfos[i];
+        touchInfo.touchTarget = touchTarget.get();
+        touchInfo.targetFrame = targetFrame;
+        touchInfo.adjustedPagePoint = pagePoint.scaledBy(scaleFactor);
+        touchInfo.adjustedRadius = point.radius().scaledBy(scaleFactor);
+        touchInfo.knownTarget = knownTarget;
+        touchInfo.consumed = false;
+    }
+
+    if (RuntimeEnabledFeatures::pointerEventEnabled())
+        handlePointerEventsFromTouchEvent(event, points, touchInfos);

[Rick Byers, 2015/06/16 17:25:39]

nit: dispatchPointerEventsForTouchEvent?  We're not really "handle"ing pointer
events here (in the event handler sense).

[mustaq, 2015/06/16 20:18:43]

Done.

+
+    bool swallowedEvent = false;
+

[Rick Byers, 2015/06/16 17:25:39]

now that we have this TouchInfo, perhaps we should also move the firing of touch
events out into it's own function too to try to make this function more
readable?

[mustaq, 2015/06/16 20:18:43]

Done, thanks for observing this.

A quick thought: we are returning true when any TE is consumed, regardless of
the PE case. Is it really right?

[Rick Byers, 2015/06/18 17:40:07]

Yes, I think it's right but ideally would get some test coverage (a follow-up CL
is fine with me though).  In particular if I do a single touch drag and call
preventDefault on the pointer events, that should suppress the generation of
touch events but NOT suppress scrolling (since with pointer events scrolling is
only suppressed via touch-action).  So the return value here is really "was the
touch event consumed, disabling gesture generation".

This probably deserves a comment here.  Eg. "The disposition of any pointer
events affects only the generation of touch events.  If pointer events were
handled (and hence no touch events generated) that is still equivalent to the
touch events going unhandled because pointer event handler don't block scroll
gesture generation."

This is actually a little more subtle than this for GestureTap, but we can worry
about that later IMHO (the exact right behavior isn't necessarily obvious -
needs to get added to the spec: https://github.com/w3c/pointerevents/issues/7

[mustaq, 2015/06/18 18:20:53]

Done.

+    // Build up the lists to use for the 'touches', 'targetTouches' and
+    // 'changedTouches' attributes in the JS event. See
+    // http://www.w3.org/TR/touch-events/#touchevent-interface for how these
+    // lists fit together.
+
+    // Holds the complete set of touches on the screen.
+    RefPtrWillBeRawPtr<TouchList> touches = TouchList::create();
+
+    // A different view on the 'touches' list above, filtered and grouped by
+    // event target. Used for the 'targetTouches' list in the JS event.
+    using TargetTouchesHeapMap = WillBeHeapHashMap<EventTarget*, RefPtrWillBeMember<TouchList>>;
+    TargetTouchesHeapMap touchesByTarget;
+
+    // Array of touches per state, used to assemble the 'changedTouches' list.
+    using EventTargetSet = WillBeHeapHashSet<RefPtrWillBeMember<EventTarget>>;
+    struct {
+        // The touches corresponding to the particular change state this struct
+        // instance represents.
+        RefPtrWillBeMember<TouchList> m_touches;
+        // Set of targets involved in m_touches.
+        EventTargetSet m_targets;
+    } changedTouches[PlatformTouchPoint::TouchStateEnd];
+
+    for (unsigned i = 0; i < points.size(); ++i) {
+        const PlatformTouchPoint& point = points[i];
+        const TouchInfo& touchInfo = touchInfos[i];
+        PlatformTouchPoint::State pointState = point.state();
+
+        if (touchInfo.consumed)
+            continue;
 
         RefPtrWillBeRawPtr<Touch> touch = Touch::create(
-            targetFrame, touchTarget.get(), point.id(), point.screenPos(), adjustedPagePoint, adjustedRadius, point.rotationAngle(), point.force());
+            touchInfo.targetFrame,
+            touchInfo.touchTarget,
+            point.id(),
+            point.screenPos(),
+            touchInfo.adjustedPagePoint,
+            touchInfo.adjustedRadius,
+            point.rotationAngle(),
+            point.force());
 
         // Ensure this target's touch list exists, even if it ends up empty, so
         // it can always be passed to TouchEvent::Create below.
-        TargetTouchesHeapMap::iterator targetTouchesIterator = touchesByTarget.find(touchTarget.get());
+        TargetTouchesHeapMap::iterator targetTouchesIterator = touchesByTarget.find(touchInfo.touchTarget);
         if (targetTouchesIterator == touchesByTarget.end()) {
-            touchesByTarget.set(touchTarget.get(), TouchList::create());
-            targetTouchesIterator = touchesByTarget.find(touchTarget.get());
+            touchesByTarget.set(touchInfo.touchTarget, TouchList::create());
+            targetTouchesIterator = touchesByTarget.find(touchInfo.touchTarget);
         }
 
         // touches and targetTouches should only contain information about
         // touches still on the screen, so if this point is released or
         // cancelled it will only appear in the changedTouches list.
         if (pointState != PlatformTouchPoint::TouchReleased && pointState != PlatformTouchPoint::TouchCancelled) {
             touches->append(touch);
             targetTouchesIterator->value->append(touch);
         }
 
         // Now build up the correct list for changedTouches.
         // Note that  any touches that are in the TouchStationary state (e.g. if
         // the user had several points touched but did not move them all) should
         // never be in the changedTouches list so we do not handle them
         // explicitly here. See https://bugs.webkit.org/show_bug.cgi?id=37609
         // for further discussion about the TouchStationary state.
-        if (pointState != PlatformTouchPoint::TouchStationary && knownTarget) {
+        if (pointState != PlatformTouchPoint::TouchStationary && touchInfo.knownTarget) {
             ASSERT(pointState < PlatformTouchPoint::TouchStateEnd);
             if (!changedTouches[pointState].m_touches)
                 changedTouches[pointState].m_touches = TouchList::create();
             changedTouches[pointState].m_touches->append(touch);
-            changedTouches[pointState].m_targets.add(touchTarget);
+            changedTouches[pointState].m_targets.add(touchInfo.touchTarget);
         }
     }
     if (allTouchReleased) {
         m_touchSequenceDocument.clear();
         m_touchSequenceUserGestureToken.clear();
     }
 
-    // Now iterate the changedTouches list and m_targets within it, sending
-    // events to the targets as required.
-    bool swallowedEvent = false;
+    // Now iterate through the changedTouches list and m_targets within it, sending
+    // TouchEvents to the targets as required.
     for (unsigned state = 0; state != PlatformTouchPoint::TouchStateEnd; ++state) {
         if (!changedTouches[state].m_touches)
             continue;
 
-        const AtomicString& stateName(eventNameForTouchPointState(static_cast<PlatformTouchPoint::State>(state)));
+        const AtomicString& eventName(touchEventNameForTouchPointState(static_cast<PlatformTouchPoint::State>(state)));
         const EventTargetSet& targetsForState = changedTouches[state].m_targets;
         for (const RefPtrWillBeMember<EventTarget>& eventTarget : targetsForState) {
             EventTarget* touchEventTarget = eventTarget.get();
             RefPtrWillBeRawPtr<TouchEvent> touchEvent = TouchEvent::create(
                 touches.get(), touchesByTarget.get(touchEventTarget), changedTouches[state].m_touches.get(),
-                stateName, touchEventTarget->toNode()->document().domWindow(),
+                eventName, touchEventTarget->toNode()->document().domWindow(),
                 event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(), event.cancelable(), event.causesScrollingIfUncanceled(), event.timestamp());
             touchEventTarget->toNode()->dispatchTouchEvent(touchEvent.get());
             swallowedEvent = swallowedEvent || touchEvent->defaultPrevented() || touchEvent->defaultHandled();
         }
     }
 
     return swallowedEvent;
 }
 
 TouchAction EventHandler::intersectTouchAction(TouchAction action1, TouchAction action2)
@@ skipping 111 matching lines @@
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink