Revert "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(
-    const int pointerId,
+    PointerEvent* pointerEvent,
     const AtomicString& type)
 {
     ASSERT(type == EventTypeNames::gotpointercapture
         || type == EventTypeNames::lostpointercapture);
 
-    // See https://github.com/w3c/pointerevents/issues/113 as why we don't set
-    // any other attributes for got/lostpointercapture.
     PointerEventInit pointerEventInit;
-    pointerEventInit.setPointerId(pointerId);
+    pointerEventInit.setPointerId(pointerEvent->pointerId());
+    pointerEventInit.setPointerType(pointerEvent->pointerType());
+    pointerEventInit.setIsPrimary(pointerEvent->isPrimary());
     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() == WebPointerProperties::PointerType::Mouse) {
+    if (p.pointerType() == toInt(WebPointerProperties::PointerType::Mouse)) {
         m_pointerIdMapping.set(s_mouseId, PointerAttributes(p, isActiveButtons));
         return s_mouseId;
     }
 
-    int type = p.pointerTypeInt();
+    int type = p.pointerType();
     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.pointerTypeInt();
+    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;
 }
 
 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() == pointerType)
+        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.pointerTypeInt()] == mappedId;
+    return m_primaryId[p.pointerType()] == 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