Send got/lostpointercapture immediately if possible

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"
 
 #include "core/frame/FrameView.h"
 #include "platform/geometry/FloatSize.h"
 
 namespace blink {
@@ skipping 190 matching lines @@
     pointerEventInit.setPointerId(pointerId);
     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 int pointerId,
     const AtomicString& type)
 {
     ASSERT(type == EventTypeNames::gotpointercapture
         || type == EventTypeNames::lostpointercapture);
 
     PointerEventInit pointerEventInit;
-    pointerEventInit.setPointerId(pointerEvent->pointerId());
-    pointerEventInit.setPointerType(pointerEvent->pointerType());
-    pointerEventInit.setIsPrimary(pointerEvent->isPrimary());
+    pointerEventInit.setPointerId(pointerId);

[Rick Byers, 2016/07/15 17:35:31]

so for now you're just matching edge's behavior for deferred events here, right?
 Can you add a TODO tracking the spec bug, just to make sure it's really what we
want (since spec doesn't currently say).

[Navid Zolghadr, 2016/07/15 20:41:01]

Not quite. Edge does set the attributes for the gotpointercapture but it is not
possible without caching the last pointerevent. So in that sense this does not
agree with Edge on gotpointercapture. I was going to put this in the same spec
PR as not delaying the got/lostpointercapture.

     pointerEventInit.setBubbles(true);
     pointerEventInit.setCancelable(false);
 
     return PointerEvent::create(type, pointerEventInit);
 }
 
 PointerEvent* PointerEventFactory::createPointerBoundaryEvent(
     PointerEvent* pointerEvent,
     const AtomicString& type,
     EventTarget* relatedTarget)
@@ skipping 56 matching lines @@
     m_pointerIdMapping.add(s_mouseId, PointerAttributes(
         IncomingId(WebPointerProperties::PointerType::Mouse, 0), 0));
 
     m_currentId = PointerEventFactory::s_mouseId+1;
 }
 
 int PointerEventFactory::addIdAndActiveButtons(const IncomingId p,
     bool isActiveButtons)
 {
     // Do not add extra mouse pointer as it was added in initialization
-    if (p.pointerType() == toInt(WebPointerProperties::PointerType::Mouse)) {
+    if (p.pointerType() == WebPointerProperties::PointerType::Mouse) {
         m_pointerIdMapping.set(s_mouseId, PointerAttributes(p, isActiveButtons));
         return s_mouseId;
     }
 
-    int type = p.pointerType();
+    int type = p.pointerTypeInt();
     if (m_pointerIncomingIdMapping.contains(p)) {
         int mappedId = m_pointerIncomingIdMapping.get(p);
         m_pointerIdMapping.set(mappedId, PointerAttributes(p, isActiveButtons));
         return mappedId;
     }
     // 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 int mappedId)
 {
     // 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();
+    int type = p.pointerTypeInt();
     m_pointerIdMapping.remove(mappedId);
     m_pointerIncomingIdMapping.remove(p);
     if (m_primaryId[type] == mappedId)
         m_primaryId[type] = PointerEventFactory::s_invalidId;
     m_idCount[type]--;
     return true;
 }
 
 Vector<int> PointerEventFactory::getPointerIdsOfType(
     WebPointerProperties::PointerType pointerType) const
 {
     Vector<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))
+        if (iter->value.incomingId.pointerType() == 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;
+    return m_primaryId[p.pointerTypeInt()] == mappedId;
 }
 
 bool PointerEventFactory::isActive(const int pointerId) const
 {
     return m_pointerIdMapping.contains(pointerId);
 }
 
 bool PointerEventFactory::isActiveButtonsState(const int pointerId) const
 {
     return m_pointerIdMapping.contains(pointerId)
         && m_pointerIdMapping.get(pointerId).isActiveButtons;
 }
 
 int PointerEventFactory::getPointerEventId(
     const WebPointerProperties& properties) const
 {
     if (properties.pointerType
         == WebPointerProperties::PointerType::Mouse)
         return PointerEventFactory::s_mouseId;
     IncomingId id(properties.pointerType, properties.id);
     if (m_pointerIncomingIdMapping.contains(id))
         return m_pointerIncomingIdMapping.get(id);
     return PointerEventFactory::s_invalidId;
 }
 
 } // namespace blink