Changeset 238344 in webkit

Timestamp:

Nov 17, 2018 1:29:52 AM (6 years ago)

Author:

graouts@webkit.org

Message:

[Pointer Events] event.isPrimary doesn't always represent the oldest active touch
​https://bugs.webkit.org/show_bug.cgi?id=191752
<rdar://problem/46129270>

Reviewed by Dean Jackson.

Source/WebCore:

Provide isPrimary to the constructor so its value can be determined at the call site.

Test: pointerevents/ios/pointer-events-is-primary.html

• dom/PointerEvent.h:
• dom/ios/PointerEventIOS.cpp:

(WebCore::PointerEvent::create):
(WebCore::PointerEvent::PointerEvent):
(WebCore::m_isPrimary):

LayoutTests:

Add a new test that checks that adding a touch after another existing touch does not make it be
the primary touch, but that removing the first touch makes the second touch become the primary touch.

To do this we add a new ui.sequence() method that allows a series of touch actions to be performed
in a linear sequence. The test author can create a finger and call various actions on it, currently
begin(), move() and end().

When these actions are processed, we compute all "stationary" actions for each part of the sequence
so that we can provide this to the uiController.sendEventStream() function.

Finally, we add a way to track events received by the target and assert that the events that were
received match those that were expected.

• pointerevents/ios/pointer-events-is-primary-expected.txt: Added.
• pointerevents/ios/pointer-events-is-primary.html: Added.
• pointerevents/utils.js:

(prototype.handleEvent):
(prototype.assertMatchesEvents):
(const.ui.new.UIController):
(const.ui.new.UIController.prototype.finger):
(const.ui.new.UIController.prototype.pinchOut):
(const.ui.new.UIController.prototype.sequence):
(const.ui.new.UIController.prototype._runEvents):
(prototype.begin):
(prototype.move):
(prototype.end):
(prototype.stationary):
(prototype._action):

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/pointerevents/ios/pointer-events-is-primary-expected.txt (added)
• LayoutTests/pointerevents/ios/pointer-events-is-primary.html (added)
• LayoutTests/pointerevents/utils.js (modified) (4 diffs)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/dom/PointerEvent.h (modified) (2 diffs)
• Source/WebCore/dom/ios/PointerEventIOS.cpp (modified) (2 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2018-11-16  Antoine Quint  <graouts@apple.com>
+
+        [Pointer Events] event.isPrimary doesn't always represent the oldest active touch
+        https://bugs.webkit.org/show_bug.cgi?id=191752
+        <rdar://problem/46129270>
+
+        Reviewed by Dean Jackson.
+
+        Add a new test that checks that adding a touch after another existing touch does not make it be
+        the primary touch, but that removing the first touch makes the second touch become the primary touch.
+
+        To do this we add a new ui.sequence() method that allows a series of touch actions to be performed
+        in a linear sequence. The test author can create a finger and call various actions on it, currently
+        begin(), move() and end().
+
+        When these actions are processed, we compute all "stationary" actions for each part of the sequence
+        so that we can provide this to the uiController.sendEventStream() function.
+
+        Finally, we add a way to track events received by the target and assert that the events that were
+        received match those that were expected.
+
+        * pointerevents/ios/pointer-events-is-primary-expected.txt: Added.
+        * pointerevents/ios/pointer-events-is-primary.html: Added.
+        * pointerevents/utils.js:
+        (prototype.handleEvent):
+        (prototype.assertMatchesEvents):
+        (const.ui.new.UIController):
+        (const.ui.new.UIController.prototype.finger):
+        (const.ui.new.UIController.prototype.pinchOut):
+        (const.ui.new.UIController.prototype.sequence):
+        (const.ui.new.UIController.prototype._runEvents):
+        (prototype.begin):
+        (prototype.move):
+        (prototype.end):
+        (prototype.stationary):
+        (prototype._action):
+
 2018-11-16  Devin Rousso  <drousso@apple.com>
 

trunk/LayoutTests/pointerevents/utils.js

@@ -33 +33 @@
 }
 
+class EventTracker
+{
+
+    constructor(target, eventNames)
+    {
+        this.target = target;
+        this.events = [];
+        this.pointerIdToTouchIdMap = {};
+
+        for (let eventName of eventNames)
+            target.addEventListener(eventName, this);
+    }
+
+    handleEvent(event)
+    {
+        if (!this.pointerIdToTouchIdMap[event.pointerId])
+            this.pointerIdToTouchIdMap[event.pointerId] = Object.keys(this.pointerIdToTouchIdMap).length + 1;
+
+        const id = this.pointerIdToTouchIdMap[event.pointerId];
+        this.events.push({
+            id,
+            type: event.type,
+            x: event.clientX,
+            y: event.clientY,
+            isPrimary: event.isPrimary
+        });
+    }
+
+    assertMatchesEvents(expectedEvents)
+    {
+        assert_true(!!this.events.length, "Event tracker saw some events.");
+        assert_equals(expectedEvents.length, this.events.length, "Expected events and actual events have the same length.");
+        for (let i = 0; i < expectedEvents.length; ++i) {
+            const expectedEvent = expectedEvents[i];
+            const actualEvent = this.events[i];
+            for (let property of Object.getOwnPropertyNames(expectedEvent))
+                assert_equals(expectedEvent[property], actualEvent[property], `Property ${property} matches for event at index ${i}.`);
+        }
+    }
+
+}
+
 const ui = new (class UIController {
+
+    constructor()
+    {
+        this.fingers = {};
+    }
+
+    finger()
+    {
+        const id = Object.keys(this.fingers).length + 1;
+        return this.fingers[id] = new Finger(id);
+    }
 
     beginTouches(options)
@@ -93 +146 @@
         };
 
-        return this._runEvents({
+        return this._runEvents([{
             interpolate : "linear",
             timestep: 0.1,
@@ -99 +152 @@
             startEvent: startEvent,
             endEvent: endEvent
-        });
+        }]);
+    }
+
+    sequence(touches)
+    {
+        const activeFingers = {};
+
+        return this._runEvents(touches.map((touches, index) => {
+            if (!Array.isArray(touches))
+                touches = [touches];
+
+            const processedIDs = {};
+
+            // Update the list of active touches.
+            touches.forEach(touch => {
+                processedIDs[touch.id] = true;
+                if (touch.phase === "ended")
+                    delete activeFingers[touch.id];
+                else
+                    activeFingers[touch.id] = { x: touch.x, y: touch.y };
+            });
+
+            // Now go through the active touches and check that they're all listed in the new touches.
+            for (let id in activeFingers) {
+                if (!processedIDs[id])
+                    touches.push(this.fingers[id].stationary(activeFingers[id]));
+            }
+
+            return {
+                inputType : "hand",
+                timeOffset : index * 0.05,
+                coordinateSpace : "content",
+                touches : touches
+            }
+        }));
     }
 
     _runEvents(events)
     {
-        return this._run(`uiController.sendEventStream('${JSON.stringify({ events: [events] })}')`);
+        return this._run(`uiController.sendEventStream('${JSON.stringify({ events })}')`);
     }
 
@@ -116 +203 @@
 
 })();
+
+class Finger
+{
+
+    constructor(id)
+    {
+        this.id = id;
+    }
+
+    begin(options)
+    {
+        return this._action("began", options.x || 0, options.y || 0);
+    }
+
+    move(options)
+    {
+        return this._action("moved", options.x || 0, options.y || 0);
+    }
+
+    end(options)
+    {
+        return this._action("ended", this._lastX, this._lastY);
+    }
+
+    stationary(options)
+    {
+        return this._action("stationary", options.x || 0, options.y || 0);
+    }
+
+    _action(phase, x, y)
+    {
+        this._lastX = x;
+        this._lastY = y;
+        return { inputType: "finger", id: this.id, phase, x, y };
+    }
+
+}

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2018-11-16  Antoine Quint  <graouts@apple.com>
+
+        [Pointer Events] event.isPrimary doesn't always represent the oldest active touch
+        https://bugs.webkit.org/show_bug.cgi?id=191752
+        <rdar://problem/46129270>
+
+        Reviewed by Dean Jackson.
+
+        Provide isPrimary to the constructor so its value can be determined at the call site.
+
+        Test: pointerevents/ios/pointer-events-is-primary.html
+
+        * dom/PointerEvent.h:
+        * dom/ios/PointerEventIOS.cpp:
+        (WebCore::PointerEvent::create):
+        (WebCore::PointerEvent::PointerEvent):
+        (WebCore::m_isPrimary):
+
 2018-11-16  Alex Christensen  <achristensen@webkit.org>
 

trunk/Source/WebCore/dom/PointerEvent.h

@@ -61 +61 @@
 
 #if ENABLE(TOUCH_EVENTS) && PLATFORM(IOS_FAMILY)
-    static Ref<PointerEvent> create(const PlatformTouchEvent&, unsigned touchIndex, Ref<WindowProxy>&&);
+    static Ref<PointerEvent> create(const PlatformTouchEvent&, unsigned touchIndex, bool isPrimary, Ref<WindowProxy>&&);
 #endif
 
@@ -85 +85 @@
     PointerEvent(const AtomicString&, Init&&);
 #if ENABLE(TOUCH_EVENTS) && PLATFORM(IOS_FAMILY)
-    PointerEvent(const AtomicString& type, const PlatformTouchEvent&, IsCancelable isCancelable, unsigned touchIndex, Ref<WindowProxy>&&);
+    PointerEvent(const AtomicString& type, const PlatformTouchEvent&, IsCancelable isCancelable, unsigned touchIndex, bool isPrimary, Ref<WindowProxy>&&);
 #endif
 

trunk/Source/WebCore/dom/ios/PointerEventIOS.cpp

@@ -58 +58 @@
 }
 
-Ref<PointerEvent> PointerEvent::create(const PlatformTouchEvent& event, unsigned index, Ref<WindowProxy>&& view)
+Ref<PointerEvent> PointerEvent::create(const PlatformTouchEvent& event, unsigned index, bool isPrimary, Ref<WindowProxy>&& view)
 {
     auto phase = event.touchPhaseAtIndex(index);
-    return adoptRef(*new PointerEvent(eventType(phase), event, phaseIsCancelable(phase), index, WTFMove(view)));
+    return adoptRef(*new PointerEvent(eventType(phase), event, phaseIsCancelable(phase), index, isPrimary, WTFMove(view)));
 }
 
-PointerEvent::PointerEvent(const AtomicString& type, const PlatformTouchEvent& event, IsCancelable isCancelable, unsigned index, Ref<WindowProxy>&& view)
+PointerEvent::PointerEvent(const AtomicString& type, const PlatformTouchEvent& event, IsCancelable isCancelable, unsigned index, bool isPrimary, Ref<WindowProxy>&& view)
     : MouseEvent(type, CanBubble::Yes, isCancelable, IsComposed::Yes, event.timestamp().approximateMonotonicTime(), WTFMove(view), 0, event.touchLocationAtIndex(index), event.touchLocationAtIndex(index), { }, event.modifiers(), 0, 0, nullptr, 0, 0, nullptr, IsSimulated::No, IsTrusted::Yes)
     , m_pointerId(event.touchIdentifierAtIndex(index))
@@ -70 +70 @@
     , m_height(2 * event.radiusYAtIndex(index))
     , m_pointerType(event.touchTypeAtIndex(index) == PlatformTouchPoint::TouchType::Stylus ? "pen"_s : "touch"_s)
-    , m_isPrimary(!index)
+    , m_isPrimary(isPrimary)
 {
 }