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): Continue eraser plumbing to web API.
-        // See crbug.com/642455
+        // 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 13 matching lines @@
 
 #undef RETURN_CORRESPONDING_PE_NAME
 
     NOTREACHED();
     return emptyAtom;
 }
 
 
 unsigned short buttonToButtonsBitfield(WebPointerProperties::Button button)
 {
+#define CASE_BUTTON_TO_BUTTONS(enumLabel) \
+    case WebPointerProperties::Button::enumLabel:\
+        return static_cast<unsigned short>(WebPointerProperties::Buttons::enumLabel)
+
     switch (button) {
-    case WebPointerProperties::Button::NoButton:
-        return static_cast<unsigned short>(MouseEvent::Buttons::None);
-    case WebPointerProperties::Button::Left:
-        return static_cast<unsigned short>(MouseEvent::Buttons::Left);
-    case WebPointerProperties::Button::Right:
-        return static_cast<unsigned short>(MouseEvent::Buttons::Right);
-    case WebPointerProperties::Button::Middle:
-        return static_cast<unsigned short>(MouseEvent::Buttons::Middle);
+        CASE_BUTTON_TO_BUTTONS(NoButton);
+        CASE_BUTTON_TO_BUTTONS(Left);
+        CASE_BUTTON_TO_BUTTONS(Right);
+        CASE_BUTTON_TO_BUTTONS(Middle);
+        CASE_BUTTON_TO_BUTTONS(X1);
+        CASE_BUTTON_TO_BUTTONS(X2);
+        CASE_BUTTON_TO_BUTTONS(Eraser);
     }
+
+#undef CASE_BUTTON_TO_BUTTONS
+
     NOTREACHED();
     return 0;
 }
 
 } // 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;
     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) {
+        buttons |= static_cast<unsigned>(WebPointerProperties::Buttons::Eraser);
+        buttons &= ~static_cast<unsigned>(WebPointerProperties::Buttons::Left);
+    }
     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 32 matching lines @@
         float scaleFactor = 1 / frame->pageZoomFactor();
         locationInFrameZoomed.scale(scaleFactor, scaleFactor);
     }
 
     // Set up initial values for coordinates.
     pointerEventInit.setClientX(locationInFrameZoomed.x());
     pointerEventInit.setClientY(locationInFrameZoomed.y());
 
     if (pointerEventName == EventTypeNames::pointerdown
         || pointerEventName == EventTypeNames::pointerup) {
-        pointerEventInit.setButton(static_cast<int>(mouseEvent.pointerProperties().button));
+        WebPointerProperties::Button button = mouseEvent.pointerProperties().button;
+        // TODO(mustaq): Fix when the spec starts supporting hovering erasers.
+        if (mouseEvent.pointerProperties().pointerType == WebPointerProperties::PointerType::Eraser
+            && button == WebPointerProperties::Button::Left)
+            button =  WebPointerProperties::Button::Eraser;
+        pointerEventInit.setButton(static_cast<int>(button));
     } else {
         DCHECK(pointerEventName == EventTypeNames::pointermove);
         pointerEventInit.setButton(static_cast<int>(WebPointerProperties::Button::NoButton));
     }
     pointerEventInit.setPressure(getPointerEventPressure(
         mouseEvent.pointerProperties().force, pointerEventInit.buttons()));
     pointerEventInit.setTiltX(mouseEvent.pointerProperties().tiltX);
     pointerEventInit.setTiltY(mouseEvent.pointerProperties().tiltY);
 
     UIEventWithKeyState::setFromPlatformModifiers(pointerEventInit, mouseEvent.getModifiers());
@@ skipping 238 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