Pass real pointer type to be passed to PointerEvents.

Source/core/input/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 3471 matching lines @@
     case PlatformTouchPoint::TouchMoved:
         return EventTypeNames::pointermove;
     case PlatformTouchPoint::TouchStationary:
         // Fall through to default
     default:
         ASSERT_NOT_REACHED();
         return emptyAtom;
     }
 }
 
+PointerIdManager::PointerType pointerTypeForWebPointPointerType(WebPointerProperties::PointerType type)

[Rick Byers, 2015/07/31 13:13:35]

You could probably simplify this by changing PointerIdManager to use your new
enum rather than defining its own.  I don't have a strong preference though - up
to you and Mustaq.

[mustaq, 2015/08/06 20:37:28]

Yes, the enums defined only in WebPointerProperties would be a cleaner solution.

+{
+    switch (type) {
+    case WebPointerProperties::PointerTypeUnknown:
+        return PointerIdManager::PointerTypeUnknown;
+    case WebPointerProperties::PointerTypeTouch:
+        return PointerIdManager::PointerTypeTouch;
+    case WebPointerProperties::PointerTypePen:
+        return PointerIdManager::PointerTypePen;
+    case WebPointerProperties::PointerTypeMouse:
+        return PointerIdManager::PointerTypeMouse;
+    }
+    ASSERT_NOT_REACHED();
+    return PointerIdManager::PointerTypeUnknown;
+}
+
+static const char* pointerTypeNameForWebPointPointerType(WebPointerProperties::PointerType type)
+{
+    switch (type) {
+    case WebPointerProperties::PointerTypeUnknown:
+        return "";
+    case WebPointerProperties::PointerTypeTouch:
+        return "touch";
+    case WebPointerProperties::PointerTypePen:
+        return "pen";
+    case WebPointerProperties::PointerTypeMouse:
+        return "mouse";
+    }
+    ASSERT_NOT_REACHED();
+    return "";
+}
+
 HitTestResult EventHandler::hitTestResultInFrame(LocalFrame* frame, const LayoutPoint& point, HitTestRequest::HitTestRequestType hitType)
 {
     HitTestResult result(HitTestRequest(hitType), point);
 
     if (!frame || !frame->contentLayoutObject())
         return result;
     if (frame->view()) {
         IntRect rect = frame->view()->visibleContentRect(IncludeScrollbars);
         if (!rect.contains(roundedIntPoint(point)))
             return result;
     }
     frame->contentLayoutObject()->hitTest(result);
     return result;
 }
 
 void EventHandler::dispatchPointerEventsForTouchEvent(const PlatformTouchEvent& event,
     WillBeHeapVector<TouchInfo>& touchInfos)
 {
-    const String& PointerTypeStrForTouch("touch");
-
     // Iterate through the touch points, sending PointerEvents to the targets as required.
     for (unsigned i = 0; i < touchInfos.size(); ++i) {
         TouchInfo& touchInfo = touchInfos[i];
         const PlatformTouchPoint& point = touchInfo.point;
         const unsigned& pointerId = point.id();
         const PlatformTouchPoint::State pointState = point.state();
 
         if (pointState == PlatformTouchPoint::TouchStationary || !touchInfo.knownTarget)
             continue;
 
         bool pointerReleasedOrCancelled = pointState == PlatformTouchPoint::TouchReleased
             || pointState == PlatformTouchPoint::TouchCancelled;
+        const PointerIdManager::PointerType pointerType = pointerTypeForWebPointPointerType(point.pointerProperties().pointerType);
+        const String& pointerTypeStr = pointerTypeNameForWebPointPointerType(point.pointerProperties().pointerType);
 
         if (pointState == PlatformTouchPoint::TouchPressed)
-            m_pointerIdManager.add(PointerIdManager::PointerTypeTouch, pointerId);
+            m_pointerIdManager.add(pointerType, pointerId);
 
         const AtomicString& eventName = pointerEventNameForTouchPointState(pointState);
 
         bool isEnterOrLeave = false;
 
         PointerEventInit pointerEventInit;
         pointerEventInit.setPointerId(pointerId);
         pointerEventInit.setWidth(touchInfo.adjustedRadius.width());
         pointerEventInit.setHeight(touchInfo.adjustedRadius.height());
         pointerEventInit.setPressure(point.force());
         pointerEventInit.setTiltX(point.pointerProperties().tiltX);
         pointerEventInit.setTiltY(point.pointerProperties().tiltY);
-        pointerEventInit.setPointerType(PointerTypeStrForTouch);
-        pointerEventInit.setIsPrimary(m_pointerIdManager.isPrimary(PointerIdManager::PointerTypeTouch, pointerId));
+        pointerEventInit.setPointerType(pointerTypeStr);
+        pointerEventInit.setIsPrimary(m_pointerIdManager.isPrimary(pointerType, pointerId));
         pointerEventInit.setScreenX(point.screenPos().x());
         pointerEventInit.setScreenY(point.screenPos().y());
         pointerEventInit.setClientX(touchInfo.adjustedPagePoint.x());
         pointerEventInit.setClientY(touchInfo.adjustedPagePoint.y());
         pointerEventInit.setButton(0);
         pointerEventInit.setButtons(pointerReleasedOrCancelled ? 0 : 1);
 
         pointerEventInit.setCtrlKey(event.ctrlKey());
         pointerEventInit.setShiftKey(event.shiftKey());
         pointerEventInit.setAltKey(event.altKey());
         pointerEventInit.setMetaKey(event.metaKey());
 
         pointerEventInit.setBubbles(!isEnterOrLeave);
         pointerEventInit.setCancelable(!isEnterOrLeave && pointState != PlatformTouchPoint::TouchCancelled);
 
         RefPtrWillBeRawPtr<PointerEvent> pointerEvent = PointerEvent::create(eventName, pointerEventInit);
         touchInfo.touchTarget->dispatchEvent(pointerEvent.get());
         touchInfo.consumed = pointerEvent->defaultPrevented() || pointerEvent->defaultHandled();
 
         // Remove the released/cancelled id at the end to correctly determine primary id above.
         if (pointerReleasedOrCancelled)
-            m_pointerIdManager.remove(PointerIdManager::PointerTypeTouch, pointerId);
+            m_pointerIdManager.remove(pointerType, pointerId);
     }
 }
 
 void EventHandler::sendPointerCancels(WillBeHeapVector<TouchInfo>& touchInfos)
 {
     for (unsigned i = 0; i < touchInfos.size(); ++i) {
         TouchInfo& touchInfo = touchInfos[i];
         const PlatformTouchPoint& point = touchInfo.point;
         const unsigned& pointerId = point.id();
         const PlatformTouchPoint::State pointState = point.state();
@@ skipping 426 matching lines @@
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink