Changeset 280917 in webkit

Timestamp:

Aug 11, 2021, 10:22:04 AM (5 years ago)

Author:

Alan Coon

Message:

Apply patch. rdar://problem/80288774

Location:

branches/safari-611.3.10.0-branch/Source/WebCore/page

Files:

• PointerCaptureController.cpp (modified) (30 diffs)
• PointerCaptureController.h (modified) (3 diffs)

branches/safari-611.3.10.0-branch/Source/WebCore/page/PointerCaptureController.cpp

@@ -50 +50 @@
 Element* PointerCaptureController::pointerCaptureElement(Document* document, PointerID pointerId) const
 {
-    auto iterator = m_activePointerIdsToCapturingData.find(pointerId);
-    if (iterator != m_activePointerIdsToCapturingData.end()) {
-        auto pointerCaptureElement = iterator->value.targetOverride;
+    if (auto capturingData = m_activePointerIdsToCapturingData.get(pointerId)) {
+        auto pointerCaptureElement = capturingData->targetOverride;
         if (pointerCaptureElement && &pointerCaptureElement->document() == document)
             return pointerCaptureElement.get();
@@ -64 +63 @@
 
     // 1. If the pointerId provided as the method's argument does not match any of the active pointers, then throw a DOMException with the name NotFoundError.
-    auto iterator = m_activePointerIdsToCapturingData.find(pointerId);
-    if (iterator == m_activePointerIdsToCapturingData.end())
+    RefPtr capturingData = m_activePointerIdsToCapturingData.get(pointerId);
+    if (!capturingData)
         return Exception { NotFoundError };
 
@@ -82 +81 @@
     // 4. If the pointer is not in the active buttons state, then terminate these steps.
     // 5. For the specified pointerId, set the pending pointer capture target override to the Element on which this method was invoked.
-    auto& capturingData = iterator->value;
-    if (capturingData.pointerIsPressed)
-        capturingData.pendingTargetOverride = capturingTarget;
+    if (capturingData->pointerIsPressed)
+        capturingData->pendingTargetOverride = capturingTarget;
 
     updateHaveAnyCapturingElement();
@@ -99 +97 @@
     // 1. If the pointerId provided as the method's argument does not match any of the active pointers and these steps are not
     // being invoked as a result of the implicit release of pointer capture, then throw a DOMException with the name NotFoundError.
-    auto iterator = m_activePointerIdsToCapturingData.find(pointerId);
-    if (iterator == m_activePointerIdsToCapturingData.end())
+    RefPtr capturingData = m_activePointerIdsToCapturingData.get(pointerId);
+    if (!capturingData)
         return Exception { NotFoundError };
 
@@ -108 +106 @@
 
     // 3. For the specified pointerId, clear the pending pointer capture target override, if set.
-    iterator->value.pendingTargetOverride = nullptr;
+    capturingData->pendingTargetOverride = nullptr;
     
     // FIXME: This leaves value.targetOverride set: webkit.org/b/221342.
@@ -127 +125 @@
         return false;
 
-    auto iterator = m_activePointerIdsToCapturingData.find(pointerId);
-    return iterator != m_activePointerIdsToCapturingData.end() && iterator->value.pendingTargetOverride == capturingTarget;
+    auto capturingData = m_activePointerIdsToCapturingData.get(pointerId);
+    return capturingData && capturingData->pendingTargetOverride == capturingTarget;
 }
 
@@ -138 +136 @@
     // method has been called if any element is set to be captured or pending to be captured.
     for (auto& capturingData : m_activePointerIdsToCapturingData.values()) {
-        capturingData.pendingTargetOverride = nullptr;
-        capturingData.targetOverride = nullptr;
+        capturingData->pendingTargetOverride = nullptr;
+        capturingData->targetOverride = nullptr;
     }
 
@@ -150 +148 @@
         return;
 
-    for (auto& keyAndValue : m_activePointerIdsToCapturingData) {
-        auto& capturingData = keyAndValue.value;
-        if (capturingData.pendingTargetOverride == &element || capturingData.targetOverride == &element) {
+    for (auto [pointerId, capturingData] : m_activePointerIdsToCapturingData) {
+        if (capturingData->pendingTargetOverride == &element || capturingData->targetOverride == &element) {
             // https://w3c.github.io/pointerevents/#implicit-release-of-pointer-capture
             // When the pointer capture target override is no longer connected, the pending pointer capture target override and pointer capture target
             // override nodes SHOULD be cleared and also a PointerEvent named lostpointercapture corresponding to the captured pointer SHOULD be fired
             // at the document.
-            ASSERT(isInBounds<PointerID>(keyAndValue.key));
-            auto pointerId = static_cast<PointerID>(keyAndValue.key);
-            auto pointerType = capturingData.pointerType;
+            ASSERT(isInBounds<PointerID>(pointerId));
+            auto pointerType = capturingData->pointerType;
             releasePointerCapture(&element, pointerId);
             // FIXME: Spec doesn't specify which task source to use.
@@ -173 +169 @@
     m_haveAnyCapturingElement = false;
 
-    CapturingData capturingData;
-    capturingData.pointerType = PointerEvent::mousePointerType();
-    m_activePointerIdsToCapturingData.add(mousePointerID, capturingData);
+    m_activePointerIdsToCapturingData.add(mousePointerID, CapturingData::create(PointerEvent::mousePointerType()));
 }
 
@@ -181 +175 @@
 {
     m_haveAnyCapturingElement = WTF::anyOf(m_activePointerIdsToCapturingData.values(), [&](auto& capturingData) {
-        return capturingData.hasAnyElement();
+        return capturingData->hasAnyElement();
     });
 }
@@ -193 +187 @@
 bool PointerCaptureController::hasCancelledPointerEventForIdentifier(PointerID pointerId) const
 {
-    auto iterator = m_activePointerIdsToCapturingData.find(pointerId);
-    return iterator != m_activePointerIdsToCapturingData.end() && iterator->value.cancelled;
+    RefPtr capturingData = m_activePointerIdsToCapturingData.get(pointerId);
+    return capturingData && capturingData->cancelled;
 }
 
 bool PointerCaptureController::preventsCompatibilityMouseEventsForIdentifier(PointerID pointerId) const
 {
-    auto iterator = m_activePointerIdsToCapturingData.find(pointerId);
-    return iterator != m_activePointerIdsToCapturingData.end() && iterator->value.preventsCompatibilityMouseEvents;
+    RefPtr capturingData = m_activePointerIdsToCapturingData.get(pointerId);
+    return capturingData && capturingData->preventsCompatibilityMouseEvents;
 }
 
@@ -206 +200 @@
 static bool hierarchyHasCapturingEventListeners(Element* target, const AtomString& eventName)
 {
-    for (ContainerNode* curr = target; curr; curr = curr->parentInComposedTree()) {
-        if (curr->hasCapturingEventListeners(eventName))
+    for (RefPtr<ContainerNode> currentNode = target; currentNode; currentNode = currentNode->parentInComposedTree()) {
+        if (currentNode->hasCapturingEventListeners(eventName))
             return true;
     }
@@ -215 +209 @@
 void PointerCaptureController::dispatchEventForTouchAtIndex(EventTarget& target, const PlatformTouchEvent& platformTouchEvent, unsigned index, bool isPrimary, WindowProxy& view)
 {
-    ASSERT(is<Element>(target));
+    RELEASE_ASSERT(is<Element>(target));
 
     auto dispatchOverOrOutEvent = [&](const String& type, EventTarget* target) {
@@ -221 +215 @@
     };
 
-    auto dispatchEnterOrLeaveEvent = [&](const String& type) {
-        auto* targetElement = &downcast<Element>(target);
-
+    auto dispatchEnterOrLeaveEvent = [&](const String& type, Element& targetElement) {
         bool hasCapturingListenerInHierarchy = false;
-        for (ContainerNode* curr = targetElement; curr; curr = curr->parentInComposedTree()) {
-            if (curr->hasCapturingEventListeners(type)) {
+        for (RefPtr<ContainerNode> currentNode = &targetElement; currentNode; currentNode = currentNode->parentInComposedTree()) {
+            if (currentNode->hasCapturingEventListeners(type)) {
                 hasCapturingListenerInHierarchy = true;
                 break;
@@ -233 +225 @@
 
         Vector<Ref<Element>, 32> targetChain;
-        for (Element* element = targetElement; element; element = element->parentElementInComposedTree()) {
+        for (RefPtr element = &targetElement; element; element = element->parentElementInComposedTree()) {
             if (hasCapturingListenerInHierarchy || element->hasEventListeners(type))
                 targetChain.append(*element);
@@ -249 +241 @@
     auto pointerEvent = PointerEvent::create(platformTouchEvent, index, isPrimary, view);
 
-    auto& capturingData = ensureCapturingDataForPointerEvent(pointerEvent);
+    Ref capturingData = ensureCapturingDataForPointerEvent(pointerEvent);
 
     // Check if the target changed, which would require dispatching boundary events.
-    RefPtr<Element> previousTarget = capturingData.previousTarget;
+    RefPtr<Element> previousTarget = capturingData->previousTarget;
     RefPtr<Element> currentTarget = downcast<Element>(&target);
 
-    capturingData.previousTarget = currentTarget;
+    capturingData->previousTarget = currentTarget;
 
     if (pointerEvent->type() == eventNames().pointermoveEvent && previousTarget != currentTarget) {
@@ -266 +258 @@
 
         Vector<Ref<Element>, 32> leftElementsChain;
-        for (Element* element = previousTarget.get(); element; element = element->parentElementInComposedTree())
+        for (RefPtr element = previousTarget.get(); element; element = element->parentElementInComposedTree())
             leftElementsChain.append(*element);
         Vector<Ref<Element>, 32> enteredElementsChain;
-        for (Element* element = currentTarget.get(); element; element = element->parentElementInComposedTree())
+        for (RefPtr element = currentTarget.get(); element; element = element->parentElementInComposedTree())
             enteredElementsChain.append(*element);
 
@@ -305 +297 @@
         // pointerenter prior to dispatching the pointerdown event.
         dispatchOverOrOutEvent(eventNames().pointeroverEvent, currentTarget.get());
-        dispatchEnterOrLeaveEvent(eventNames().pointerenterEvent);
+        dispatchEnterOrLeaveEvent(eventNames().pointerenterEvent, *currentTarget);
     }
 
@@ -315 +307 @@
         // pointer event named pointerleave after dispatching the pointerup event.
         dispatchOverOrOutEvent(eventNames().pointeroutEvent, currentTarget.get());
-        dispatchEnterOrLeaveEvent(eventNames().pointerleaveEvent);
-        capturingData.previousTarget = nullptr;
+        dispatchEnterOrLeaveEvent(eventNames().pointerleaveEvent, *currentTarget);
+        capturingData->previousTarget = nullptr;
 
         touchWithIdentifierWasRemoved(pointerEvent->pointerId());
@@ -328 +320 @@
     // for instance in the case of a long press to initiate a system drag.
     for (auto& capturingData : m_activePointerIdsToCapturingData.values()) {
-        if (capturingData.pointerType == PointerEvent::touchPointerType() && capturingData.pointerIsPressed && !capturingData.cancelled)
+        if (capturingData->pointerType == PointerEvent::touchPointerType() && capturingData->pointerIsPressed && !capturingData->cancelled)
             return nullptr;
     }
@@ -335 +327 @@
     const auto& names = eventNames();
 
-    auto iterator = m_activePointerIdsToCapturingData.find(pointerId);
-    bool pointerIsPressed = iterator != m_activePointerIdsToCapturingData.end() ? iterator->value.pointerIsPressed : false;
+    RefPtr capturingData = m_activePointerIdsToCapturingData.get(pointerId);
+    bool pointerIsPressed = capturingData ? capturingData->pointerIsPressed : false;
 
     short newButton = mouseEvent.button();
-    short previousMouseButton = iterator != m_activePointerIdsToCapturingData.end() ? iterator->value.previousMouseButton : -1;
+    short previousMouseButton = capturingData ? capturingData->previousMouseButton : -1;
     short button = (type == names.mousemoveEvent && newButton == previousMouseButton) ? -1 : newButton;
 
@@ -361 +353 @@
 
     auto pointerEvent = PointerEvent::create(button, mouseEvent, pointerId, pointerType);
-    if (iterator != m_activePointerIdsToCapturingData.end())
-        iterator->value.previousMouseButton = newButton;
+    if (capturingData)
+        capturingData->previousMouseButton = newButton;
     else if (pointerEvent)
-        ensureCapturingDataForPointerEvent(*pointerEvent).previousMouseButton = newButton;
+        ensureCapturingDataForPointerEvent(*pointerEvent)->previousMouseButton = newButton;
 
     return pointerEvent;
@@ -398 +390 @@
 
     if (event.pointerType() != PointerEvent::touchPointerType()) {
-        auto iterator = m_activePointerIdsToCapturingData.find(pointerId);
-        if (iterator != m_activePointerIdsToCapturingData.end())
-            iterator->value.pointerIsPressed = isPointerdown;
+        if (RefPtr capturingData = m_activePointerIdsToCapturingData.get(pointerId))
+            capturingData->pointerIsPressed = isPointerdown;
         return;
     }
@@ -419 +410 @@
     // to the target (as normal) indicating that capture is active.
 
-    auto& capturingData = ensureCapturingDataForPointerEvent(event);
-    capturingData.pointerIsPressed = true;
+    auto capturingData = ensureCapturingDataForPointerEvent(event);
+    capturingData->pointerIsPressed = true;
     setPointerCapture(downcast<Element>(target), pointerId);
 }
 
-PointerCaptureController::CapturingData& PointerCaptureController::ensureCapturingDataForPointerEvent(const PointerEvent& event)
-{
-    return m_activePointerIdsToCapturingData.ensure(event.pointerId(), [&event] {
-        CapturingData capturingData;
-        capturingData.pointerType = event.pointerType();
-        return capturingData;
+auto PointerCaptureController::ensureCapturingDataForPointerEvent(const PointerEvent& event) -> Ref<CapturingData>
+{
+    return m_activePointerIdsToCapturingData.ensure(event.pointerId(), [pointerType = event.pointerType()] {
+        return CapturingData::create(pointerType);
     }).iterator->value;
 }
@@ -435 +424 @@
 void PointerCaptureController::pointerEventWasDispatched(const PointerEvent& event)
 {
-    auto iterator = m_activePointerIdsToCapturingData.find(event.pointerId());
-    if (iterator != m_activePointerIdsToCapturingData.end()) {
-        auto& capturingData = iterator->value;
-        capturingData.isPrimary = event.isPrimary();
-
-        // Immediately after firing the pointerup or pointercancel events, a user agent MUST clear the pending pointer capture target
-        // override for the pointerId of the pointerup or pointercancel event that was just dispatched, and then run Process Pending
-        // Pointer Capture steps to fire lostpointercapture if necessary.
-        // https://w3c.github.io/pointerevents/#implicit-release-of-pointer-capture
-        if (event.type() == eventNames().pointerupEvent) {
-            capturingData.pendingTargetOverride = nullptr;
-            processPendingPointerCapture(event.pointerId());
-        }
-
-        // If a mouse pointer has moved while it isn't pressed, make sure we reset the preventsCompatibilityMouseEvents flag since
-        // we could otherwise prevent compatibility mouse events while those are only supposed to be prevented while the pointer is pressed.
-        if (event.type() == eventNames().pointermoveEvent && capturingData.pointerType == PointerEvent::mousePointerType() && !capturingData.pointerIsPressed)
-            capturingData.preventsCompatibilityMouseEvents = false;
-
-        // If the pointer event dispatched was pointerdown and the event was canceled, then set the PREVENT MOUSE EVENT flag for this pointerType.
-        // https://www.w3.org/TR/pointerevents/#mapping-for-devices-that-support-hover
-        if (event.type() == eventNames().pointerdownEvent)
-            capturingData.preventsCompatibilityMouseEvents = event.defaultPrevented();
-    }
+    RefPtr capturingData = m_activePointerIdsToCapturingData.get(event.pointerId());
+    if (!capturingData)
+        return;
+
+    capturingData->isPrimary = event.isPrimary();
+
+    // Immediately after firing the pointerup or pointercancel events, a user agent MUST clear the pending pointer capture target
+    // override for the pointerId of the pointerup or pointercancel event that was just dispatched, and then run Process Pending
+    // Pointer Capture steps to fire lostpointercapture if necessary.
+    // https://w3c.github.io/pointerevents/#implicit-release-of-pointer-capture
+    if (event.type() == eventNames().pointerupEvent) {
+        capturingData->pendingTargetOverride = nullptr;
+        processPendingPointerCapture(event.pointerId());
+    }
+
+    // If a mouse pointer has moved while it isn't pressed, make sure we reset the preventsCompatibilityMouseEvents flag since
+    // we could otherwise prevent compatibility mouse events while those are only supposed to be prevented while the pointer is pressed.
+    if (event.type() == eventNames().pointermoveEvent && capturingData->pointerType == PointerEvent::mousePointerType() && !capturingData->pointerIsPressed)
+        capturingData->preventsCompatibilityMouseEvents = false;
+
+    // If the pointer event dispatched was pointerdown and the event was canceled, then set the PREVENT MOUSE EVENT flag for this pointerType.
+    // https://www.w3.org/TR/pointerevents/#mapping-for-devices-that-support-hover
+    if (event.type() == eventNames().pointerdownEvent)
+        capturingData->preventsCompatibilityMouseEvents = event.defaultPrevented();
 }
 
@@ -480 +469 @@
     // the pointer with no capture.
 
-    auto iterator = m_activePointerIdsToCapturingData.find(pointerId);
-    if (iterator == m_activePointerIdsToCapturingData.end())
-        return;
-
-    auto& capturingData = iterator->value;
-    if (capturingData.cancelled)
-        return;
-
-    capturingData.pendingTargetOverride = nullptr;
-    capturingData.cancelled = true;
+    RefPtr capturingData = m_activePointerIdsToCapturingData.get(pointerId);
+    if (!capturingData || capturingData->cancelled)
+        return;
+
+    capturingData->pendingTargetOverride = nullptr;
+    capturingData->cancelled = true;
 
 #if ENABLE(TOUCH_EVENTS) && PLATFORM(IOS_FAMILY)
-    capturingData.previousTarget = nullptr;
+    capturingData->previousTarget = nullptr;
 #endif
 
     auto target = [&]() -> RefPtr<Element> {
-        if (capturingData.targetOverride)
-            return capturingData.targetOverride;
+        if (capturingData->targetOverride)
+            return capturingData->targetOverride;
         constexpr OptionSet<HitTestRequest::RequestType> hitType { HitTestRequest::ReadOnly, HitTestRequest::Active, HitTestRequest::DisallowUserAgentShadowContent, HitTestRequest::AllowChildFrameContent };
-        return m_page.mainFrame().eventHandler().hitTestResultAtPoint(documentPoint, hitType).innerNonSharedElement();
+        return Ref(m_page.mainFrame())->eventHandler().hitTestResultAtPoint(documentPoint, hitType).innerNonSharedElement();
     }();
 
@@ -507 +492 @@
     // After firing the pointercancel event, a user agent MUST also fire a pointer event named pointerout
     // followed by firing a pointer event named pointerleave.
-    auto isPrimary = capturingData.isPrimary ? PointerEvent::IsPrimary::Yes : PointerEvent::IsPrimary::No;
-    auto cancelEvent = PointerEvent::create(eventNames().pointercancelEvent, pointerId, capturingData.pointerType, isPrimary);
+    auto isPrimary = capturingData->isPrimary ? PointerEvent::IsPrimary::Yes : PointerEvent::IsPrimary::No;
+    auto cancelEvent = PointerEvent::create(eventNames().pointercancelEvent, pointerId, capturingData->pointerType, isPrimary);
     target->dispatchEvent(cancelEvent);
-    target->dispatchEvent(PointerEvent::create(eventNames().pointeroutEvent, pointerId, capturingData.pointerType, isPrimary));
-    target->dispatchEvent(PointerEvent::create(eventNames().pointerleaveEvent, pointerId, capturingData.pointerType, isPrimary));
+    target->dispatchEvent(PointerEvent::create(eventNames().pointeroutEvent, pointerId, capturingData->pointerType, isPrimary));
+    target->dispatchEvent(PointerEvent::create(eventNames().pointerleaveEvent, pointerId, capturingData->pointerType, isPrimary));
     processPendingPointerCapture(pointerId);
 }
@@ -517 +502 @@
 void PointerCaptureController::processPendingPointerCapture(PointerID pointerId)
 {
-    auto iterator = m_activePointerIdsToCapturingData.find(pointerId);
-    if (iterator == m_activePointerIdsToCapturingData.end())
+    RefPtr capturingData = m_activePointerIdsToCapturingData.get(pointerId);
+    if (!capturingData)
         return;
 
@@ -526 +511 @@
     m_processingPendingPointerCapture = true;
 
-    auto& capturingData = iterator->value;
-
     // Cache the pending target override since it could be modified during the dispatch of events in this function.
-    auto pendingTargetOverride = capturingData.pendingTargetOverride;
+    auto pendingTargetOverride = capturingData->pendingTargetOverride;
 
     // https://w3c.github.io/pointerevents/#process-pending-pointer-capture
     // 1. If the pointer capture target override for this pointer is set and is not equal to the pending pointer capture target override,
     // then fire a pointer event named lostpointercapture at the pointer capture target override node.
-    if (capturingData.targetOverride && capturingData.targetOverride != pendingTargetOverride) {
-        if (capturingData.targetOverride->isConnected())
-            capturingData.targetOverride->dispatchEvent(PointerEvent::createForPointerCapture(eventNames().lostpointercaptureEvent, pointerId, capturingData.isPrimary, capturingData.pointerType));
-        if (capturingData.pointerType == PointerEvent::mousePointerType()) {
-            if (auto* frame = capturingData.targetOverride->document().frame())
+    if (capturingData->targetOverride && capturingData->targetOverride != pendingTargetOverride) {
+        if (capturingData->targetOverride->isConnected())
+            capturingData->targetOverride->dispatchEvent(PointerEvent::createForPointerCapture(eventNames().lostpointercaptureEvent, pointerId, capturingData->isPrimary, capturingData->pointerType));
+        if (capturingData->pointerType == PointerEvent::mousePointerType()) {
+            if (RefPtr frame = capturingData->targetOverride->document().frame())
                 frame->eventHandler().pointerCaptureElementDidChange(nullptr);
         }
@@ -545 +528 @@
     // 2. If the pending pointer capture target override for this pointer is set and is not equal to the pointer capture target override,
     // then fire a pointer event named gotpointercapture at the pending pointer capture target override.
-    if (capturingData.pendingTargetOverride && capturingData.targetOverride != pendingTargetOverride) {
-        if (capturingData.pointerType == PointerEvent::mousePointerType()) {
-            if (auto* frame = pendingTargetOverride->document().frame())
+    if (capturingData->pendingTargetOverride && capturingData->targetOverride != pendingTargetOverride) {
+        if (capturingData->pointerType == PointerEvent::mousePointerType()) {
+            if (RefPtr frame = pendingTargetOverride->document().frame())
                 frame->eventHandler().pointerCaptureElementDidChange(pendingTargetOverride.get());
         }
-        pendingTargetOverride->dispatchEvent(PointerEvent::createForPointerCapture(eventNames().gotpointercaptureEvent, pointerId, capturingData.isPrimary, capturingData.pointerType));
+        pendingTargetOverride->dispatchEvent(PointerEvent::createForPointerCapture(eventNames().gotpointercaptureEvent, pointerId, capturingData->isPrimary, capturingData->pointerType));
     }
 
     // 3. Set the pointer capture target override to the pending pointer capture target override, if set. Otherwise, clear the pointer
     // capture target override.
-    capturingData.targetOverride = pendingTargetOverride;
+    capturingData->targetOverride = pendingTargetOverride;
 
     m_processingPendingPointerCapture = false;

branches/safari-611.3.10.0-branch/Source/WebCore/page/PointerCaptureController.h

@@ -70 +70 @@
 
 private:
-    struct CapturingData {
+    struct CapturingData : public RefCounted<CapturingData> {
+        static Ref<CapturingData> create(const String& pointerType)
+        {
+            return adoptRef(*new CapturingData(pointerType));
+        }
+
         RefPtr<Element> pendingTargetOverride;
         RefPtr<Element> targetOverride;
@@ -89 +94 @@
         bool pointerIsPressed { false };
         short previousMouseButton { -1 };
+
+    private:
+        CapturingData(const String& pointerType)
+            : pointerType(pointerType)
+        { }
     };
 
-    CapturingData& ensureCapturingDataForPointerEvent(const PointerEvent&);
+    Ref<CapturingData> ensureCapturingDataForPointerEvent(const PointerEvent&);
     void pointerEventWillBeDispatched(const PointerEvent&, EventTarget*);
     void pointerEventWasDispatched(const PointerEvent&);
@@ -100 +110 @@
     // While PointerID is defined as int32_t, we use int64_t here so that we may use a value outside of the int32_t range to have safe
     // empty and removed values, allowing any int32_t to be provided through the API for lookup in this hashmap.
-    using PointerIdToCapturingDataMap = HashMap<int64_t, CapturingData, WTF::IntHash<int64_t>, WTF::SignedWithZeroKeyHashTraits<int64_t>>;
+    using PointerIdToCapturingDataMap = HashMap<int64_t, Ref<CapturingData>, WTF::IntHash<int64_t>, WTF::SignedWithZeroKeyHashTraits<int64_t>>;
     PointerIdToCapturingDataMap m_activePointerIdsToCapturingData;
     bool m_processingPendingPointerCapture { false };