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 179 matching lines @@
     , m_widgetIsLatched(false)
     , m_touchPressed(false)
     , m_scrollGestureHandlingNode(nullptr)
     , m_lastGestureScrollOverWidget(false)
     , m_maxMouseMovedDuration(0)
     , m_longTapShouldInvokeContextMenu(false)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
     , m_lastShowPressTimestamp(0)
     , m_deltaConsumedForScrollSequence(false)
 {
+    m_primaryIdByPointerType.clear();
 }
 
 EventHandler::~EventHandler()
 {
     ASSERT(!m_fakeMouseMoveEventTimer.isActive());
+    m_primaryIdByPointerType.clear();
 }
 
 DEFINE_TRACE(EventHandler)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_mousePressNode);
     visitor->trace(m_capturingMouseEventsNode);
     visitor->trace(m_nodeUnderMouse);
     visitor->trace(m_lastNodeUnderMouse);
     visitor->trace(m_lastMouseMoveEventSubframe);
@@ skipping 47 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_primaryIdByPointerType.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.
     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:
+        // TouchStationary state is not converted to touch events, so fall through to assert.

[Rick Byers, 2015/06/11 04:14:56]

remove incorrect (and otherwise fairly useless) comment

[mustaq, 2015/06/12 16:05:23]

Done.

+    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;
 }
 
 bool EventHandler::handleTouchEvent(const PlatformTouchEvent& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleTouchEvent");
 
+    const String& PointerTypeTouch("touch");
     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.
+    using TouchInfo = struct {

[Rick Byers, 2015/06/11 04:14:56]

curious: how is this syntax different from the simpler 'struct TouchInfo {
...}'?

[mustaq, 2015/06/12 16:05:24]

I need to use 'typedef struct {...} TouchInfo' here because I am reusing the
definition later on. To me, typedef is slightly less intuitive here than it's
C++11 counterpart 'using'.

http://stackoverflow.com/questions/10747810/what-is-the-difference-between-ty...

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

Ah, cool - thanks!

+        EventTarget* touchTarget;
+        LocalFrame* targetFrame;
+        FloatPoint adjustedPagePoint;
+        FloatSize adjustedRadius;
+        bool knownTarget;
+        bool consumed;
+    };
+    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);

[Rick Byers, 2015/06/11 04:14:56]

kind of silly to create these locals just to assign below.  Remove the
temporaries.

[mustaq, 2015/06/12 16:05:24]

Done.

         FloatSize adjustedRadius = point.radius().scaledBy(scaleFactor);
 
+        TouchInfo& touchInfo = touchInfos[i];
+        touchInfo.touchTarget = touchTarget.get();
+        touchInfo.targetFrame = targetFrame;
+        touchInfo.adjustedPagePoint = adjustedPagePoint;
+        touchInfo.adjustedRadius = adjustedRadius;
+        touchInfo.knownTarget = knownTarget;
+        touchInfo.consumed = false;
+    }
+
+    if (RuntimeEnabledFeatures::pointerEventEnabled()) {

[Rick Byers, 2015/06/11 04:14:56]

could some of this be factored out to another function without too much pain? 
EventHandler::handleTouchEvent is already a bit of a monster!

[mustaq, 2015/06/12 16:05:23]

Done.

+        bool hasPrimaryIdForTouch = m_primaryIdByPointerType.contains(PointerTypeTouch);
+        unsigned primaryIdForTouch = hasPrimaryIdForTouch? m_primaryIdByPointerType.get(PointerTypeTouch) : 0;

[Rick Byers, 2015/06/11 04:14:56]

nit: space before ?

[mustaq, 2015/06/12 16:05:24]

Done.

+
+        // 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];
+
+            const PlatformTouchPoint::State pointState = point.state();
+            const AtomicString& eventName(pointerEventNameForTouchPointState(pointState));

[USE eero AT chromium.org, 2015/06/11 11:12:42]

This does not handle correctly touch points whose state is
PlatformTouchPoint::TouchStationary. Those cases seem to even cause some kind of
corruption resulting in an assert failure from line 4161.

Those touch points should probably be ignored by adding a conditional continue
statement.

[mustaq, 2015/06/12 16:05:23]

Done.

+
+            if (pointState == PlatformTouchPoint::TouchPressed && !hasPrimaryIdForTouch) {
+                primaryIdForTouch = point.id();
+                m_primaryIdByPointerType.set(PointerTypeTouch, primaryIdForTouch);
+                hasPrimaryIdForTouch = true;
+            }
+
+            bool isEnterOrLeave = false;
+            bool isCancelable = !(isEnterOrLeave || pointState == PlatformTouchPoint::TouchCancelled);
+            bool isBubbling = !isEnterOrLeave;
+
+            PointerEventInit pointerEventInit;
+            pointerEventInit.setPointerId(point.id());
+            pointerEventInit.setWidth(touchInfo.adjustedRadius.width());
+            pointerEventInit.setHeight(touchInfo.adjustedRadius.height());
+            pointerEventInit.setPressure(point.force());
+            pointerEventInit.setTiltX(0.0);
+            pointerEventInit.setTiltY(0.0);
+            pointerEventInit.setPointerType(PointerTypeTouch);
+            pointerEventInit.setIsPrimary(hasPrimaryIdForTouch && primaryIdForTouch == point.id());
+            pointerEventInit.setScreenX(point.screenPos().x());
+            pointerEventInit.setScreenY(point.screenPos().y());
+            pointerEventInit.setClientX(0);
+            pointerEventInit.setClientY(0);

[Rick Byers, 2015/06/11 04:14:56]

These are wrong - it should have client co-ordinates (same as in the touch
events).  Please add to test.

[mustaq, 2015/06/12 16:05:23]

Done.

+            pointerEventInit.setMovementX(0);
+            pointerEventInit.setMovementY(0);
+            pointerEventInit.setButton(0);
+            pointerEventInit.setButtons(0);

[Rick Byers, 2015/06/11 04:14:56]

This is wrong, should be 1
http://w3c.github.io/pointerevents/#button-states
Please test this too.

[mustaq, 2015/06/12 16:05:23]

Done.

+            pointerEventInit.setRelatedTarget(nullptr);
+
+            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();
+        }
+
+        if (allTouchReleased)
+            m_primaryIdByPointerType.remove(PointerTypeTouch);

[Rick Byers, 2015/06/11 04:14:56]

This logic deserves a test (at first I thought it was wrong, but I see it's
right) - eg.  Eg. pointerdown ID=1, pointerdown ID=2, pointerup ID=1.  Now
verify that a new pointerdown isn't considered primary (and 2 didn't suddenly
become primary).

[mustaq, 2015/06/12 16:05:23]

Done.

[mustaq, 2015/06/12 20:37:18]

Just discovered that Chrome reuses 'retired' pointerIds, and this is supported
by the spec! The current logic fails in the following reuse case:
- Finger1 touches the screen, id=0, primary.
- Finger2 touches the screen, id=1, not primary.
- Finger1 goes off the screen.
- Another finger (Finger3/Finger1) touches the screen, Chrome reuses id=0, which
is wrongly considered primary.

Solution:
- Track the set of current IDs.
- The first id that enters an empty set is primary.
- Store the id only as long the id is not touch-released.

I will work on a fix now.

+    }
+
+    bool swallowedEvent = 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.
+
+    // 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