Fix properties of got/lostpointercapture

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 {
 
 namespace {
 
 inline int toInt(WebPointerProperties::PointerType t) { return static_cast<int>(t); }
 
 const char* pointerTypeNameForWebPointPointerType(WebPointerProperties::PointerType type)
 {
     switch (type) {
     case WebPointerProperties::PointerType::Unknown:
         return "";
     case WebPointerProperties::PointerType::Touch:
         return "touch";
     case WebPointerProperties::PointerType::Pen:
         return "pen";
     case WebPointerProperties::PointerType::Mouse:
         return "mouse";
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return "";
 }
 
 const AtomicString& pointerEventNameForMouseEventName(
     const AtomicString& mouseEventName)
 {
 #define RETURN_CORRESPONDING_PE_NAME(eventSuffix) \
     if (mouseEventName == EventTypeNames::mouse##eventSuffix) {\
         return EventTypeNames::pointer##eventSuffix;\
     }
 
     RETURN_CORRESPONDING_PE_NAME(down);
     RETURN_CORRESPONDING_PE_NAME(enter);
     RETURN_CORRESPONDING_PE_NAME(leave);
     RETURN_CORRESPONDING_PE_NAME(move);
     RETURN_CORRESPONDING_PE_NAME(out);
     RETURN_CORRESPONDING_PE_NAME(over);
     RETURN_CORRESPONDING_PE_NAME(up);
 
 #undef RETURN_CORRESPONDING_PE_NAME
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return emptyAtom;
 }
 
 } // namespace
 
 const int PointerEventFactory::s_invalidId = 0;
 
 // Mouse id is 1 to behave the same as MS Edge for compatibility reasons.
 const int PointerEventFactory::s_mouseId = 1;
 
@@ skipping 10 matching lines @@
     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)
+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);
+        && type != EventTypeNames::pointerleave
+        && type != EventTypeNames::pointercancel
+        && type != EventTypeNames::gotpointercapture
+        && type != EventTypeNames::lostpointercapture);
 }
 
 PointerEvent* PointerEventFactory::create(
     const AtomicString& mouseEventName, const PlatformMouseEvent& mouseEvent,
     EventTarget* relatedTarget,
     LocalDOMWindow* view)
 {
     DCHECK(mouseEventName == EventTypeNames::mousemove
         || mouseEventName == EventTypeNames::mousedown
         || mouseEventName == EventTypeNames::mouseup);
@@ skipping 88 matching lines @@
 
     pointerEventInit.setBubbles(!isEnterOrLeave);
     pointerEventInit.setCancelable(!isEnterOrLeave && pointState != PlatformTouchPoint::TouchCancelled);
 
     return PointerEvent::create(type, pointerEventInit);
 }
 
 PointerEvent* PointerEventFactory::createPointerCancelEvent(
     const int pointerId, const WebPointerProperties::PointerType pointerType)
 {
-    ASSERT(m_pointerIdMapping.contains(pointerId));
+    DCHECK(m_pointerIdMapping.contains(pointerId));
     m_pointerIdMapping.set(pointerId, PointerAttributes(m_pointerIdMapping.get(pointerId).incomingId, false));
 
     PointerEventInit pointerEventInit;
 
     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 AtomicString& type)
-{
-    ASSERT(type == EventTypeNames::gotpointercapture
-        || type == EventTypeNames::lostpointercapture);
-
-    PointerEventInit pointerEventInit;
-    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* PointerEventFactory::createSecondaryPointerEvent(

[mustaq, 2016/08/05 15:51:22]

This is now a generic PE creator method, so "secondary" doesn't make sense. What
about "createFrom()"?

Please update the description in .h accordingly.

[Navid Zolghadr, 2016/08/05 17:08:03]

Done.

     PointerEvent* pointerEvent,
     const AtomicString& type,
     EventTarget* relatedTarget)
 {
-    ASSERT(type == EventTypeNames::pointerout
-        || type == EventTypeNames::pointerleave
-        || type == EventTypeNames::pointerover
-        || type == EventTypeNames::pointerenter);
-
     PointerEventInit pointerEventInit;
 
     pointerEventInit.setPointerId(pointerEvent->pointerId());
     pointerEventInit.setPointerType(pointerEvent->pointerType());
     pointerEventInit.setIsPrimary(pointerEvent->isPrimary());
     pointerEventInit.setWidth(pointerEvent->width());
     pointerEventInit.setHeight(pointerEvent->height());
     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.setTiltX(pointerEvent->tiltX());
     pointerEventInit.setTiltY(pointerEvent->tiltY());
     pointerEventInit.setView(pointerEvent->view());
 
     setBubblesAndCancelable(pointerEventInit, type);
 
     if (relatedTarget)
         pointerEventInit.setRelatedTarget(relatedTarget);
 
     return PointerEvent::create(type, pointerEventInit);
 }
 
+PointerEvent* PointerEventFactory::createPointerCaptureEvent(

[mustaq, 2016/08/05 15:51:22]

Let's drop createPointerCaptureEvent & createPointerBoundaryEvent to clean the
interface. The DCHECKs themselves don't add any value IMO.

[Navid Zolghadr, 2016/08/05 17:08:03]

I would say let's keep the APIs different as one needs a relatedTarget and the
other should not have a relatedTarget. So defaulting that to null doesn't make
it as clear as this possibly.

[mustaq, 2016/08/05 17:29:17]

Acknowledged.

+    PointerEvent* pointerEvent,
+    const AtomicString& type)
+{
+    DCHECK(type == EventTypeNames::gotpointercapture
+        || type == EventTypeNames::lostpointercapture);
+
+    return createSecondaryPointerEvent(
+        pointerEvent, type, pointerEvent->relatedTarget());
+}
+
+PointerEvent* PointerEventFactory::createPointerBoundaryEvent(
+    PointerEvent* pointerEvent,
+    const AtomicString& type,
+    EventTarget* relatedTarget)
+{
+    DCHECK(type == EventTypeNames::pointerout
+        || type == EventTypeNames::pointerleave
+        || type == EventTypeNames::pointerover
+        || type == EventTypeNames::pointerenter);
+
+    return createSecondaryPointerEvent(pointerEvent, type, relatedTarget);
+}
+
 PointerEventFactory::PointerEventFactory()
 {
     clear();
 }
 
 PointerEventFactory::~PointerEventFactory()
 {
     clear();
 }
 
@@ skipping 100 matching lines @@
     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