Notify Blink about start of gesture scroll through a queued event.

third_party/WebKit/Source/core/events/PointerEventFactory.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/events/PointerEventFactory.h"
 
 namespace blink {
 
 namespace {
 
@@ skipping 44 matching lines @@
 // Mouse id is 1 to behave the same as MS Edge for compatibility reasons.
 const int PointerEventFactory::s_mouseId = 1;
 
 float getPointerEventPressure(float force, int buttons)
 {
     if (std::isnan(force))
         return buttons ? 0.5 : 0;
     return force;
 }
 
-void PointerEventFactory::setIdTypeButtons(PointerEventInit &pointerEventInit,
-    const WebPointerProperties &pointerProperties, unsigned buttons)
+void PointerEventFactory::setIdTypeButtons(PointerEventInit& pointerEventInit,
+    const WebPointerProperties& pointerProperties, unsigned buttons)
 {
     const WebPointerProperties::PointerType pointerType = pointerProperties.pointerType;
     const IncomingId incomingId(pointerType, pointerProperties.id);
     int pointerId = addIdAndActiveButtons(incomingId, buttons != 0);
 
     pointerEventInit.setButtons(buttons);
     pointerEventInit.setPointerId(pointerId);
     pointerEventInit.setPointerType(pointerTypeNameForWebPointPointerType(pointerType));
     pointerEventInit.setIsPrimary(isPrimary(pointerId));
 }
 
+void PointerEventFactory::setBubblesAndCancelable(PointerEventInit& pointerEventInit,
+    const AtomicString& type)
+{
+    pointerEventInit.setBubbles(type != EventTypeNames::pointerenter
+        && type != EventTypeNames::pointerleave);
+    pointerEventInit.setCancelable(type != EventTypeNames::pointerenter
+        && type != EventTypeNames::pointerleave && type != EventTypeNames::pointercancel);
+}
+
 PointerEvent* PointerEventFactory::create(
     const AtomicString& mouseEventName, const PlatformMouseEvent& mouseEvent,
     EventTarget* relatedTarget,
     AbstractView* view)
 {
     AtomicString pointerEventName = pointerEventNameForMouseEventName(mouseEventName);
     unsigned buttons = MouseEvent::platformModifiersToButtons(mouseEvent.getModifiers());
     PointerEventInit pointerEventInit;
 
     setIdTypeButtons(pointerEventInit, mouseEvent.pointerProperties(), buttons);
+    setBubblesAndCancelable(pointerEventInit, pointerEventName);
 
     pointerEventInit.setScreenX(mouseEvent.globalPosition().x());
     pointerEventInit.setScreenY(mouseEvent.globalPosition().y());
     pointerEventInit.setClientX(mouseEvent.position().x());
     pointerEventInit.setClientY(mouseEvent.position().y());
 
     if (pointerEventName == EventTypeNames::pointerdown
         || pointerEventName == EventTypeNames::pointerup) {
         pointerEventInit.setButton(mouseEvent.button());
     } else {
         // TODO(crbug.com/587955): We are setting NoButton for transition
         // pointerevents should be resolved as part of this bug
         pointerEventInit.setButton(NoButton);
     }
     pointerEventInit.setPressure(getPointerEventPressure(
         mouseEvent.pointerProperties().force, pointerEventInit.buttons()));
 
     UIEventWithKeyState::setFromPlatformModifiers(pointerEventInit, mouseEvent.getModifiers());
 
     // Make sure chorded buttons fire pointermove instead of pointerup/down.
     if ((pointerEventName == EventTypeNames::pointerdown
         && (buttons & ~MouseEvent::buttonToButtons(mouseEvent.button())) != 0)
         || (pointerEventName == EventTypeNames::pointerup && buttons != 0))
         pointerEventName = EventTypeNames::pointermove;
 
-    pointerEventInit.setBubbles(
-        pointerEventName != EventTypeNames::pointerenter
-        && pointerEventName != EventTypeNames::pointerleave);
-    pointerEventInit.setCancelable(
-        pointerEventName != EventTypeNames::pointerenter
-        && pointerEventName != EventTypeNames::pointerleave
-        && pointerEventName != EventTypeNames::pointercancel);
 
     pointerEventInit.setView(view);
     if (relatedTarget)
         pointerEventInit.setRelatedTarget(relatedTarget);
 
     return PointerEvent::create(pointerEventName, pointerEventInit);
 }
 
 PointerEvent* PointerEventFactory::create(const AtomicString& type,
     const PlatformTouchPoint& touchPoint, PlatformEvent::Modifiers modifiers,
@@ skipping 29 matching lines @@
         touchPoint.force(), pointerEventInit.buttons()));
 
     UIEventWithKeyState::setFromPlatformModifiers(pointerEventInit, modifiers);
 
     pointerEventInit.setBubbles(!isEnterOrLeave);
     pointerEventInit.setCancelable(!isEnterOrLeave && pointState != PlatformTouchPoint::TouchCancelled);
 
     return PointerEvent::create(type, pointerEventInit);
 }
 
-
-PointerEvent* PointerEventFactory::createPointerCancelEvent(const PlatformTouchPoint& touchPoint)
+PointerEvent* PointerEventFactory::createPointerCancelEvent(
+    const int pointerId, const WebPointerProperties::PointerType pointerType)
 {
     PointerEventInit pointerEventInit;
 
-    setIdTypeButtons(pointerEventInit, touchPoint.pointerProperties(), 0);
-
+    pointerEventInit.setPointerId(pointerId);

[bokan, 2016/04/12 22:42:45]

setIdTypeButtons used to add a bunch of data into some internal maps. That's no
longer needed because all of those were keeping track of Mouse/Touch events <->
Pointer event mappings and the cancel is no longer related to one. Is that
correct?

[mustaq, 2016/04/13 14:56:27]

You are right that we don't need those mappings: the mapping store pointer
specific states (JS-visible pointerId, incoming raw id, buttons state etc). Here
we have the |pointerId| specified directly, so no need to consult the maps. The
state |buttons| is irrelevant for pointercancel.

[bokan, 2016/04/13 22:59:48]

Acknowledged.

+    pointerEventInit.setPointerType(pointerTypeNameForWebPointPointerType(pointerType));
+    pointerEventInit.setIsPrimary(isPrimary(pointerId));
     pointerEventInit.setBubbles(true);
     pointerEventInit.setCancelable(false);
 
     return PointerEvent::create(EventTypeNames::pointercancel, pointerEventInit);
 }
 
 PointerEvent* PointerEventFactory::createPointerCaptureEvent(
     PointerEvent* pointerEvent,
     const AtomicString& type)
 {
@@ skipping 30 matching lines @@
     pointerEventInit.setTiltX(pointerEvent->tiltX());
     pointerEventInit.setTiltY(pointerEvent->tiltY());
     pointerEventInit.setScreenX(pointerEvent->screenX());
     pointerEventInit.setScreenY(pointerEvent->screenY());
     pointerEventInit.setClientX(pointerEvent->clientX());
     pointerEventInit.setClientY(pointerEvent->clientY());
     pointerEventInit.setButton(pointerEvent->button());
     pointerEventInit.setButtons(pointerEvent->buttons());
     pointerEventInit.setPressure(pointerEvent->pressure());
 
-    pointerEventInit.setBubbles(type != EventTypeNames::pointerenter
-        && type != EventTypeNames::pointerleave);
-    pointerEventInit.setCancelable(type != EventTypeNames::pointerenter
-        && type != EventTypeNames::pointerleave
-        && type != EventTypeNames::pointercancel);
+    setBubblesAndCancelable(pointerEventInit, type);
+
     if (relatedTarget)
         pointerEventInit.setRelatedTarget(relatedTarget);
 
     return PointerEvent::create(type, pointerEventInit);
 }
 
 PointerEventFactory::PointerEventFactory()
 {
     clear();
 }
@@ skipping 41 matching lines @@
     // We do not handle the overflow of m_currentId as it should be very rare
     int mappedId = m_currentId++;
     if (!m_idCount[type])
         m_primaryId[type] = mappedId;
     m_idCount[type]++;
     m_pointerIncomingIdMapping.add(p, mappedId);
     m_pointerIdMapping.add(mappedId, PointerAttributes(p, isActiveButtons));
     return mappedId;
 }
 
-bool PointerEventFactory::remove(
-    const PointerEvent* pointerEvent)
+bool PointerEventFactory::remove(const int mappedId)
 {
-    int mappedId = pointerEvent->pointerId();
     // Do not remove mouse pointer id as it should always be there
     if (mappedId == s_mouseId || !m_pointerIdMapping.contains(mappedId))
         return false;
 
     IncomingId p = m_pointerIdMapping.get(mappedId).incomingId;
     int type = p.pointerType();
     m_pointerIdMapping.remove(mappedId);
     m_pointerIncomingIdMapping.remove(p);
     if (m_primaryId[type] == mappedId)
         m_primaryId[type] = PointerEventFactory::s_invalidId;
     m_idCount[type]--;
     return true;
 }
 
+HeapVector<int> PointerEventFactory::getPointerIdsOfType(WebPointerProperties::PointerType pointerType)
+{
+    HeapVector<int> mappedIds;
+
+    for (auto iter = m_pointerIdMapping.begin(); iter != m_pointerIdMapping.end(); ++iter) {
+        int mappedId = iter->key;
+        if (iter->value.incomingId.pointerType() == static_cast<int>(pointerType))
+            mappedIds.append(mappedId);
+    }
+
+    // Sorting for a predictable ordering.
+    std::sort(mappedIds.begin(), mappedIds.end());
+    return mappedIds;
+}
+
 bool PointerEventFactory::isPrimary(int mappedId) const
 {
     if (!m_pointerIdMapping.contains(mappedId))
         return false;
 
     IncomingId p = m_pointerIdMapping.get(mappedId).incomingId;
     return m_primaryId[p.pointerType()] == mappedId;
 }
 
 WebPointerProperties::PointerType PointerEventFactory::getPointerType(
@@ skipping 11 matching lines @@
     return m_pointerIdMapping.contains(pointerId);
 }
 
 bool PointerEventFactory::isActiveButtonsState(const int pointerId)
 {
     return m_pointerIdMapping.contains(pointerId)
         && m_pointerIdMapping.get(pointerId).isActiveButtons;
 }
 
 } // namespace blink