Use touch events to report stylus events

third_party/WebKit/Source/web/WebInputEventConversion.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 660 matching lines @@
   else
     return;  // Skip all other keyboard events.
 
   modifiers = event.modifiers();
   timeStampSeconds = event.platformTimeStamp();
   windowsKeyCode = event.keyCode();
 }
 
 static WebTouchPoint toWebTouchPoint(const Touch* touch,
                                      const LayoutItem layoutItem,
-                                     WebTouchPoint::State state) {
+                                     WebTouchPoint::State state,
+                                     WebPointerProperties::PointerType type) {
   WebTouchPoint point;
-  point.pointerType = WebPointerProperties::PointerType::Touch;
+  point.pointerType = type;
   point.id = touch->identifier();
   point.screenPosition = touch->screenLocation();
   point.position = convertAbsoluteLocationForLayoutObjectFloat(
       DoublePoint(touch->absoluteLocation()), layoutItem);
   point.radiusX = touch->radiusX();
   point.radiusY = touch->radiusY();
   point.rotationAngle = touch->rotationAngle();
   point.force = touch->force();
   point.state = state;
   return point;
 }
 
 static unsigned indexOfTouchPointWithId(const WebTouchPoint* touchPoints,
                                         unsigned touchPointsLength,
                                         unsigned id) {
   for (unsigned i = 0; i < touchPointsLength; ++i) {
     if (touchPoints[i].id == static_cast<int>(id))
       return i;
   }
   return std::numeric_limits<unsigned>::max();
 }
 
-static void addTouchPointsUpdateStateIfNecessary(WebTouchPoint::State state,
-                                                 TouchList* touches,
-                                                 WebTouchPoint* touchPoints,
-                                                 unsigned* touchPointsLength,
-                                                 const LayoutItem layoutItem) {
+static void addTouchPointsUpdateStateIfNecessary(
+    WebTouchPoint::State state,
+    TouchList* touches,
+    WebTouchPoint* touchPoints,
+    unsigned* touchPointsLength,
+    const LayoutItem layoutItem,
+    WebPointerProperties::PointerType pointerType) {
   unsigned initialTouchPointsLength = *touchPointsLength;
   for (unsigned i = 0; i < touches->length(); ++i) {
     const unsigned pointIndex = *touchPointsLength;
     if (pointIndex >= static_cast<unsigned>(WebTouchEvent::kTouchesLengthCap))
       return;
 
     const Touch* touch = touches->item(i);
     unsigned existingPointIndex = indexOfTouchPointWithId(
         touchPoints, initialTouchPointsLength, touch->identifier());
     if (existingPointIndex != std::numeric_limits<unsigned>::max()) {
       touchPoints[existingPointIndex].state = state;
     } else {
-      touchPoints[pointIndex] = toWebTouchPoint(touch, layoutItem, state);
+      touchPoints[pointIndex] =
+          toWebTouchPoint(touch, layoutItem, state, pointerType);
       ++(*touchPointsLength);
     }
   }
 }
 
 WebTouchEventBuilder::WebTouchEventBuilder(const LayoutItem layoutItem,
                                            const TouchEvent& event) {
   if (event.type() == EventTypeNames::touchstart)
     type = TouchStart;
   else if (event.type() == EventTypeNames::touchmove)
@@ skipping 12 matching lines @@
   modifiers = event.modifiers();
   dispatchType = event.cancelable() ? WebInputEvent::Blocking
                                     : WebInputEvent::EventNonBlocking;
   movedBeyondSlopRegion = event.causesScrollingIfUncanceled();
 
   // Currently touches[] is empty, add stationary points as-is.
   for (unsigned i = 0;
        i < event.touches()->length() &&
        i < static_cast<unsigned>(WebTouchEvent::kTouchesLengthCap);
        ++i) {
-    touches[i] = toWebTouchPoint(event.touches()->item(i), layoutItem,
-                                 WebTouchPoint::StateStationary);
+    touches[i] =
+        toWebTouchPoint(event.touches()->item(i), layoutItem,
+                        WebTouchPoint::StateStationary, event.pointerType());
     ++touchesLength;
   }
   // If any existing points are also in the change list, we should update
   // their state, otherwise just add the new points.
-  addTouchPointsUpdateStateIfNecessary(toWebTouchPointState(event.type()),
-                                       event.changedTouches(), touches,
-                                       &touchesLength, layoutItem);
+  addTouchPointsUpdateStateIfNecessary(
+      toWebTouchPointState(event.type()), event.changedTouches(), touches,
+      &touchesLength, layoutItem, event.pointerType());
 }
 
 WebGestureEventBuilder::WebGestureEventBuilder(const LayoutItem layoutItem,
                                                const GestureEvent& event) {
   if (event.type() == EventTypeNames::gestureshowpress) {
     type = GestureShowPress;
   } else if (event.type() == EventTypeNames::gesturelongpress) {
     type = GestureLongPress;
   } else if (event.type() == EventTypeNames::gesturetapdown) {
     type = GestureTapDown;
@@ skipping 71 matching lines @@
   Vector<PlatformTouchEvent> result;
   for (const auto& event : coalescedEvents) {
     DCHECK(WebInputEvent::isTouchEventType(event->type));
     result.append(PlatformTouchEventBuilder(
         widget, static_cast<const WebTouchEvent&>(*event)));
   }
   return result;
 }
 
 }  // namespace blink