Use touch events to report stylus events

third_party/WebKit/Source/core/dom/Touch.h

 /*
  * Copyright 2008, The Android Open Source Project
  *
  * 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 copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 17 matching lines @@
 
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "core/CoreExport.h"
 #include "core/dom/Document.h"
 #include "core/dom/TouchInit.h"
 #include "core/events/EventTarget.h"
 #include "platform/geometry/FloatPoint.h"
 #include "platform/geometry/FloatSize.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/heap/Handle.h"
+#include "public/platform/WebPointerProperties.h"
 
 namespace blink {
 
 class LocalFrame;
 
 class CORE_EXPORT Touch final : public GarbageCollectedFinalized<Touch>,
                                 public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
   static Touch* create(LocalFrame* frame,
                        EventTarget* target,
                        int identifier,
                        const FloatPoint& screenPos,
                        const FloatPoint& pagePos,
                        const FloatSize& radius,
                        float rotationAngle,
                        float force,
                        String region) {
-    return new Touch(frame, target, identifier, screenPos, pagePos, radius,
-                     rotationAngle, force, region);
+    WebPointerProperties properties;
+    properties.id = identifier;
+    properties.force = force;
+    return new Touch(frame, target, screenPos, pagePos, radius, rotationAngle,
+                     region, properties);
   }
-
+  static Touch* create(LocalFrame* frame,
+                       EventTarget* target,
+                       const FloatPoint& screenPos,
+                       const FloatPoint& pagePos,
+                       const FloatSize& radius,
+                       float rotationAngle,
+                       String region,
+                       const WebPointerProperties& properties) {
+    return new Touch(frame, target, screenPos, pagePos, radius, rotationAngle,
+                     region, properties);
+  }
   static Touch* create(const Document& document, const TouchInit& initializer) {
     return new Touch(document.frame(), initializer);
   }
 
   // DOM Touch implementation
   EventTarget* target() const { return m_target.get(); }
-  int identifier() const { return m_identifier; }
+  int identifier() const { return m_pointerProperties.id; }
   double clientX() const { return m_clientPos.x(); }
   double clientY() const { return m_clientPos.y(); }
   double screenX() const { return m_screenPos.x(); }
   double screenY() const { return m_screenPos.y(); }
   double pageX() const { return m_pagePos.x(); }
   double pageY() const { return m_pagePos.y(); }
   float radiusX() const { return m_radius.width(); }
   float radiusY() const { return m_radius.height(); }
   float rotationAngle() const { return m_rotationAngle; }
-  float force() const { return m_force; }
+  float force() const { return m_pointerProperties.force; }
   const String& region() const { return m_region; }
 
   // Blink-internal methods
   const LayoutPoint& absoluteLocation() const { return m_absoluteLocation; }
   const FloatPoint& screenLocation() const { return m_screenPos; }
   Touch* cloneWithNewTarget(EventTarget*) const;
+  const WebPointerProperties& pointerProperties() const {
+    return m_pointerProperties;
+  }
 
   DECLARE_TRACE();
 
  private:
   Touch(LocalFrame*,
         EventTarget*,
-        int identifier,
         const FloatPoint& screenPos,
         const FloatPoint& pagePos,
         const FloatSize& radius,
         float rotationAngle,
-        float force,
-        String region);
+        String region,
+        const WebPointerProperties&);

[mustaq, 2016/11/17 21:24:57]

I agree with Navid here: it's better to remove the repeated redundant
fields (id, pointerType) from here to the "enclosing class"
Source/core/events/TouchEvent.h. May be even all the fields because
in the stylus case a TouchEvent instance will contain only a single
Touch instance. Multiple Touch instances in TouchEvent are for a
multi-touch.

[denniskempin, 2016/11/28 19:40:48]

Besides not having hardware that supports this, there is not really anything
preventing us from having multiple styli or stylus combined with touch in a
single event. Which would be represented very well by the PointerEvents API. 
If we stay closer to that the transition to PointerEvents is probably going to
be easier. 

How about just adding a single field pointer type to Touch.h? That would get rid
of redundant fields. 

I don't feel strongly about this, if you would prefer to add that to just
TouchEvent.h and have it implicitly applied to all enclosed touches (which would
be just one) I am ok that. Let me know. 

 
   Touch(EventTarget*,
-        int identifier,
         const FloatPoint& clientPos,
         const FloatPoint& screenPos,
         const FloatPoint& pagePos,
         const FloatSize& radius,
         float rotationAngle,
-        float force,
         String region,
+        const WebPointerProperties&,
         LayoutPoint absoluteLocation);
 
   Touch(LocalFrame*, const TouchInit&);
 
   Member<EventTarget> m_target;
-  int m_identifier;
   // Position relative to the viewport in CSS px.
   FloatPoint m_clientPos;
   // Position relative to the screen in DIPs.
   FloatPoint m_screenPos;
   // Position relative to the page in CSS px.
   FloatPoint m_pagePos;
   // Radius in CSS px.
   FloatSize m_radius;
   float m_rotationAngle;
-  float m_force;
   String m_region;
   // FIXME(rbyers): Shouldn't we be able to migrate callers to relying on
   // screenPos, pagePos or clientPos? absoluteLocation appears to be the same as
   // pagePos but without browser scale applied.
   LayoutPoint m_absoluteLocation;
+  WebPointerProperties m_pointerProperties;
 };
 
 }  // namespace blink
 
 #endif  // Touch_h