Make a pen in eraser mode visible thru PointerEvent.buttons

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:
     case WebPointerProperties::PointerType::Eraser:
+        // TODO(mustaq): Fix when the spec starts supporting hovering erasers.
         return "pen";
     case WebPointerProperties::PointerType::Mouse:
         return "mouse";
     }
     NOTREACHED();
     return "";
 }
 
 const AtomicString& pointerEventNameForMouseEventName(
     const AtomicString& mouseEventName)
@@ skipping 36 matching lines @@
 
 } // 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;
 
 float getPointerEventPressure(float force, int buttons)
 {
-    if (std::isnan(force))
-        return buttons ? 0.5 : 0;
+    if (std::isnan(force)) {
+        // TODO(mustaq): Fix when the spec starts supporting hovering erasers.
+        return (buttons & ~static_cast<unsigned>(MouseEvent::Buttons::Eraser)) ? 0.5 : 0;
+    }
     return force;
 }
 
 void PointerEventFactory::setIdTypeButtons(PointerEventInit& pointerEventInit,
     const WebPointerProperties& pointerProperties, unsigned buttons)
 {
     const WebPointerProperties::PointerType pointerType = pointerProperties.pointerType;
     const IncomingId incomingId(pointerType, pointerProperties.id);
     int pointerId = addIdAndActiveButtons(incomingId, buttons != 0);
 
+    // Tweak the |buttons| to reflect pen eraser mode only if the pen is in
+    // active buttons state w/o even considering the eraser button.
+    // TODO(mustaq): Fix when the spec starts supporting hovering erasers.
+    if (pointerType == WebPointerProperties::PointerType::Eraser && buttons != 0)

[Navid Zolghadr, 2016/08/31 20:01:16]

I wonder if we can just do this when pointerType is Eraser regardless of the
fact that any other button is pressed or not. That would make buttons=32 as soon
as an eraser comes into the range of digitizer as oppose to the current model
which hides the fact that the eraser is near the screen and makes it similar to
pen near the screen case but as soon as the eraser touches the screen it shows
button=33.

[mustaq, 2016/08/31 20:29:37]

I don't like this for two reasons:

[A] That would mean that a flipped pen should either:
- fire a "pointerdown" at the moment if comes within the digitizer range while
hovering, or
- never fire a "pointerdown",
because it will never switch between active/inactive buttons states /after/
being in active state
https://w3c.github.io/pointerevents/#the-pointerdown-event.
Same applies for "pointerup".

[B] From another perspective of the spec, the eraser mode can only switch
between two states (inactive, and active+activeButton). Why should it be so
different from the pen mode that can switch between:
  inactive <-> active <-> activeButton
states?

I think conceptually "pointerdown" and "pointerup" marks the
active<->activeButton state transitions in the spec, and this is very intuitive.

+        buttons |= static_cast<unsigned>(MouseEvent::Buttons::Eraser);
     pointerEventInit.setButtons(buttons);
+
     pointerEventInit.setPointerId(pointerId);
     pointerEventInit.setPointerType(pointerTypeNameForWebPointPointerType(pointerType));
     pointerEventInit.setIsPrimary(isPrimary(pointerId));
 }
 
 void PointerEventFactory::setBubblesAndCancelable(
     PointerEventInit& pointerEventInit, const AtomicString& type)
 {
     pointerEventInit.setBubbles(type != EventTypeNames::pointerenter
         && type != EventTypeNames::pointerleave);
@@ skipping 291 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