Implement MouseEvent buttons attribute.

Source/core/events/MouseEvent.cpp

 /*
  * Copyright (C) 2001 Peter Kelly (pmk@post.com)
  * Copyright (C) 2001 Tobias Anton (anton@stud.fbi.fh-darmstadt.de)
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2003, 2005, 2006, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 22 matching lines @@
 MouseEventInit::MouseEventInit()
     : screenX(0)
     , screenY(0)
     , clientX(0)
     , clientY(0)
     , ctrlKey(false)
     , altKey(false)
     , shiftKey(false)
     , metaKey(false)
     , button(0)
+    , buttons(0)
     , relatedTarget(nullptr)
 {
 }
 
 PassRefPtrWillBeRawPtr<MouseEvent> MouseEvent::create(const AtomicString& type, const MouseEventInit& initializer)
 {
     return adoptRefWillBeNoop(new MouseEvent(type, initializer));
 }
 
 PassRefPtrWillBeRawPtr<MouseEvent> MouseEvent::create(const AtomicString& eventType, PassRefPtrWillBeRawPtr<AbstractView> view, const PlatformMouseEvent& event, int detail, PassRefPtrWillBeRawPtr<Node> relatedTarget)
 {
     ASSERT(event.type() == PlatformEvent::MouseMoved || event.button() != NoButton);
 
     bool isMouseEnterOrLeave = eventType == EventTypeNames::mouseenter || eventType == EventTypeNames::mouseleave;
     bool isCancelable = !isMouseEnterOrLeave;
     bool isBubbling = !isMouseEnterOrLeave;
 
     return MouseEvent::create(
         eventType, isBubbling, isCancelable, view,
         detail, event.globalPosition().x(), event.globalPosition().y(), event.position().x(), event.position().y(),
         event.movementDelta().x(), event.movementDelta().y(),
-        event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(), event.button(),
+        event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(), event.button(), event.modifiers(),
         relatedTarget, nullptr, false, event.syntheticEventType());
 }
 
 PassRefPtrWillBeRawPtr<MouseEvent> MouseEvent::create(const AtomicString& type, bool canBubble, bool cancelable, PassRefPtrWillBeRawPtr<AbstractView> view,
     int detail, int screenX, int screenY, int pageX, int pageY,
     int movementX, int movementY,
-    bool ctrlKey, bool altKey, bool shiftKey, bool metaKey, unsigned short button,
+    bool ctrlKey, bool altKey, bool shiftKey, bool metaKey,
+    unsigned short button, unsigned modifiers,
     PassRefPtrWillBeRawPtr<EventTarget> relatedTarget, PassRefPtrWillBeRawPtr<DataTransfer> dataTransfer, bool isSimulated, PlatformMouseEvent::SyntheticEventType syntheticEventType)
 {
     return adoptRefWillBeNoop(new MouseEvent(type, canBubble, cancelable, view,
         detail, screenX, screenY, pageX, pageY,
         movementX, movementY,
-        ctrlKey, altKey, shiftKey, metaKey, button, relatedTarget, dataTransfer, isSimulated, syntheticEventType));
+        ctrlKey, altKey, shiftKey, metaKey, button, modifiers,
+        relatedTarget, dataTransfer, isSimulated, syntheticEventType));
 }
 
 MouseEvent::MouseEvent()
     : m_button(0)
+    , m_buttons(0)
     , m_buttonDown(false)
 {
 }
 
 MouseEvent::MouseEvent(const AtomicString& eventType, bool canBubble, bool cancelable, PassRefPtrWillBeRawPtr<AbstractView> view,
     int detail, int screenX, int screenY, int pageX, int pageY,
     int movementX, int movementY,
     bool ctrlKey, bool altKey, bool shiftKey, bool metaKey,
-    unsigned short button, PassRefPtrWillBeRawPtr<EventTarget> relatedTarget,
+    unsigned short button, unsigned modifiers, PassRefPtrWillBeRawPtr<EventTarget> relatedTarget,
     PassRefPtrWillBeRawPtr<DataTransfer> dataTransfer, bool isSimulated, PlatformMouseEvent::SyntheticEventType syntheticEventType)
     : MouseRelatedEvent(eventType, canBubble, cancelable, view, detail, IntPoint(screenX, screenY),
                         IntPoint(pageX, pageY),
                         IntPoint(movementX, movementY),
                         ctrlKey, altKey, shiftKey, metaKey, isSimulated)
     , m_button(button == (unsigned short)-1 ? 0 : button)
+    , m_buttons(modifiersToButtons(eventType, button, modifiers))
     , m_buttonDown(button != (unsigned short)-1)
     , m_relatedTarget(relatedTarget)
     , m_dataTransfer(dataTransfer)
     , m_syntheticEventType(syntheticEventType)
 {
 }
 
 MouseEvent::MouseEvent(const AtomicString& eventType, const MouseEventInit& initializer)
     : MouseRelatedEvent(eventType, initializer.bubbles, initializer.cancelable, initializer.view, initializer.detail, IntPoint(initializer.screenX, initializer.screenY),
         IntPoint(0 /* pageX */, 0 /* pageY */),
         IntPoint(0 /* movementX */, 0 /* movementY */),
         initializer.ctrlKey, initializer.altKey, initializer.shiftKey, initializer.metaKey, false /* isSimulated */)
     , m_button(initializer.button == (unsigned short)-1 ? 0 : initializer.button)
+    , m_buttons(initializer.buttons == (unsigned short)-1 ? 0 : initializer.buttons)
     , m_buttonDown(initializer.button != (unsigned short)-1)
     , m_relatedTarget(initializer.relatedTarget)
     , m_dataTransfer(nullptr)
 {
     initCoordinates(IntPoint(initializer.clientX, initializer.clientY));
 }
 
 MouseEvent::~MouseEvent()
 {
 }
 
+unsigned short MouseEvent::modifiersToButtons(const AtomicString& type, unsigned short button, unsigned modifiers)
+{
+    const unsigned buttonToModifier[] = {
+        PlatformEvent::LeftButtonDown,
+        PlatformEvent::MiddleButtonDown,
+        PlatformEvent::RightButtonDown
+    };
+    if (type == EventTypeNames::mouseup)

[Rick Byers, 2014/11/25 17:44:28]

I don't think checking for mouseup here is sufficient, this logic also applies
to other events triggered as a result of mouseup (eg. click, dblclick).  I
suggest you do the modifier clearing stuff sooner on the PlatformMouseEvent -
eg. at the top of  EventHandler::handleMouseReleaseEvent (but that would require
you to make a copy you can modify) or maybe best in
PlatformMouseEventBuilder::PlatformMouseEventBuilder.

Also please add a comment since this is a little subtle.  Eg. something like:
// The MouseEvent spec requires that buttons indicates the state immediately
after the event takes place.  To ensure consistency between platforms here, we
explicitly clear the button that is in the process of being released.

[zino, 2014/11/28 12:29:28]

Done.

+        modifiers &= ~buttonToModifier[button];
+
+    unsigned short buttons = 0;
+    if (modifiers & PlatformEvent::LeftButtonDown)
+        buttons |= 1;
+    if (modifiers & PlatformEvent::RightButtonDown)
+        buttons |= 2;
+    if (modifiers & PlatformEvent::MiddleButtonDown)
+        buttons |= 4;
+
+    return buttons;
+}
+
 void MouseEvent::initMouseEvent(const AtomicString& type, bool canBubble, bool cancelable, PassRefPtrWillBeRawPtr<AbstractView> view,
                                 int detail, int screenX, int screenY, int clientX, int clientY,
                                 bool ctrlKey, bool altKey, bool shiftKey, bool metaKey,
-                                unsigned short button, PassRefPtrWillBeRawPtr<EventTarget> relatedTarget)
+                                unsigned short button, PassRefPtrWillBeRawPtr<EventTarget> relatedTarget, unsigned short buttons)
 {
     if (dispatched())
         return;
 
     initUIEvent(type, canBubble, cancelable, view, detail);
 
     m_screenLocation = IntPoint(screenX, screenY);
     m_ctrlKey = ctrlKey;
     m_altKey = altKey;
     m_shiftKey = shiftKey;
     m_metaKey = metaKey;
     m_button = button == (unsigned short)-1 ? 0 : button;
     m_buttonDown = button != (unsigned short)-1;
     m_relatedTarget = relatedTarget;
+    m_buttons = buttons;
 
     initCoordinates(IntPoint(clientX, clientY));
 
     // FIXME: m_isSimulated is not set to false here.
     // FIXME: m_dataTransfer is not set to nullptr here.
 }
 
 const AtomicString& MouseEvent::interfaceName() const
 {
     return EventNames::MouseEvent;
@@ skipping 49 matching lines @@
 PassRefPtrWillBeRawPtr<SimulatedMouseEvent> SimulatedMouseEvent::create(const AtomicString& eventType, PassRefPtrWillBeRawPtr<AbstractView> view, PassRefPtrWillBeRawPtr<Event> underlyingEvent)
 {
     return adoptRefWillBeNoop(new SimulatedMouseEvent(eventType, view, underlyingEvent));
 }
 
 SimulatedMouseEvent::~SimulatedMouseEvent()
 {
 }
 
 SimulatedMouseEvent::SimulatedMouseEvent(const AtomicString& eventType, PassRefPtrWillBeRawPtr<AbstractView> view, PassRefPtrWillBeRawPtr<Event> underlyingEvent)
-    : MouseEvent(eventType, true, true, view, 0, 0, 0, 0, 0, 0, 0, false, false, false, false, 0,
+    : MouseEvent(eventType, true, true, view, 0, 0, 0, 0, 0, 0, 0, false, false, false, false, 0, 0,
         nullptr, nullptr, true, PlatformMouseEvent::RealOrIndistinguishable)
 {
     if (UIEventWithKeyState* keyStateEvent = findEventWithKeyState(underlyingEvent.get())) {
         m_ctrlKey = keyStateEvent->ctrlKey();
         m_altKey = keyStateEvent->altKey();
         m_shiftKey = keyStateEvent->shiftKey();
         m_metaKey = keyStateEvent->metaKey();
     }
     setUnderlyingEvent(underlyingEvent);
 
@@ skipping 46 matching lines @@
     bool swallowEvent = event()->defaultHandled() || event()->defaultPrevented();
 
     if (event()->type() != EventTypeNames::click || event()->detail() != 2)
         return !swallowEvent;
 
     // Special case: If it's a double click event, we also send the dblclick event. This is not part
     // of the DOM specs, but is used for compatibility with the ondblclick="" attribute. This is treated
     // as a separate event in other DOM-compliant browsers like Firefox, and so we do the same.
     RefPtrWillBeRawPtr<MouseEvent> doubleClickEvent = MouseEvent::create();
     doubleClickEvent->initMouseEvent(EventTypeNames::dblclick, event()->bubbles(), event()->cancelable(), event()->view(),
-                                     event()->detail(), event()->screenX(), event()->screenY(), event()->clientX(), event()->clientY(),
-                                     event()->ctrlKey(), event()->altKey(), event()->shiftKey(), event()->metaKey(),
-                                     event()->button(), relatedTarget);
+        event()->detail(), event()->screenX(), event()->screenY(), event()->clientX(), event()->clientY(),
+        event()->ctrlKey(), event()->altKey(), event()->shiftKey(), event()->metaKey(),
+        event()->button(), relatedTarget, event()->buttons());
     if (event()->defaultHandled())
         doubleClickEvent->setDefaultHandled();
     EventDispatcher::dispatchEvent(dispatcher->node(), MouseEventDispatchMediator::create(doubleClickEvent));
     if (doubleClickEvent->defaultHandled() || doubleClickEvent->defaultPrevented())
         return false;
     return !swallowEvent;
 }
 
 } // namespace blink