Change MouseEvent.button to be 'short' instead of 'unsigned short'

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 42 matching lines @@
         event.movementDelta().x(), event.movementDelta().y(),
         event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(), event.button(),
         platformModifiersToButtons(event.modifiers()),
         relatedTarget, nullptr, false, event.syntheticEventType(), event.timestamp());
 }
 
 PassRefPtrWillBeRawPtr<MouseEvent> MouseEvent::create(const AtomicString& type, bool canBubble, bool cancelable, PassRefPtrWillBeRawPtr<AbstractView> view,
     int detail, int screenX, int screenY, int windowX, int windowY,
     int movementX, int movementY,
     bool ctrlKey, bool altKey, bool shiftKey, bool metaKey,
-    unsigned short button, unsigned short buttons,
+    short button, unsigned short buttons,
     PassRefPtrWillBeRawPtr<EventTarget> relatedTarget, DataTransfer* dataTransfer, bool isSimulated, PlatformMouseEvent::SyntheticEventType syntheticEventType,
     double uiCreateTime)
 {
     return adoptRefWillBeNoop(new MouseEvent(type, canBubble, cancelable, view,
         detail, screenX, screenY, windowX, windowY,
         movementX, movementY,
         ctrlKey, altKey, shiftKey, metaKey, button, buttons, relatedTarget, dataTransfer, isSimulated, syntheticEventType, uiCreateTime));
 }
 
 MouseEvent::MouseEvent()
     : m_button(0)
     , m_buttons(0)
     , m_buttonDown(false)
     , m_relatedTarget(nullptr)
     , m_dataTransfer(nullptr)
     , m_syntheticEventType(PlatformMouseEvent::RealOrIndistinguishable)
 {
 }
 
 MouseEvent::MouseEvent(const AtomicString& eventType, bool canBubble, bool cancelable, PassRefPtrWillBeRawPtr<AbstractView> view,
     int detail, int screenX, int screenY, int windowX, int windowY,
     int movementX, int movementY,
     bool ctrlKey, bool altKey, bool shiftKey, bool metaKey,
-    unsigned short button, unsigned short buttons, PassRefPtrWillBeRawPtr<EventTarget> relatedTarget,
+    short button, unsigned short buttons, PassRefPtrWillBeRawPtr<EventTarget> relatedTarget,
     DataTransfer* dataTransfer, bool isSimulated, PlatformMouseEvent::SyntheticEventType syntheticEventType,
     double uiCreateTime)
     : MouseRelatedEvent(eventType, canBubble, cancelable, view, detail, IntPoint(screenX, screenY),
         IntPoint(windowX, windowY),
         IntPoint(movementX, movementY),
         ctrlKey, altKey, shiftKey, metaKey, isSimulated)
-    , m_button(button == (unsigned short)-1 ? 0 : button)
+    , m_button(button)
     , m_buttons(buttons)
-    , m_buttonDown(button != (unsigned short)-1)
+    , m_buttonDown(button != -1)

[philipj_slow, 2015/06/10 08:46:25]

Can the m_buttonDown member be removed? Just implement it has m_button != -1

[ramya.v, 2015/06/10 09:21:28]

buttonDown() function is used in other places like
HTMLSelectElement::listBoxDefaultEventHandler,
WebMouseEventBuilder::WebMouseEventBuilder, etc.
m_button is private, and button() returns 0 in place of -1. So it may not be
possible now to remove m_buttonDown variable completely.

[ramya.v, 2015/06/10 09:25:39]

Sorry, didn't get you,  yes the variable can be removed. In buttonDown()
function will use m_button != -1

[ramya.v, 2015/06/10 09:41:25]

Done.

     , m_relatedTarget(relatedTarget)
     , m_dataTransfer(dataTransfer)
     , m_syntheticEventType(syntheticEventType)
 {
     setUICreateTime(uiCreateTime);
 }
 
 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(initializer.movementX(), initializer.movementY()),
         initializer.ctrlKey(), initializer.altKey(), initializer.shiftKey(), initializer.metaKey(), false /* isSimulated */)
-    , m_button(initializer.button() == (unsigned short)-1 ? 0 : initializer.button())
+    , m_button(initializer.button())
     , m_buttons(initializer.buttons())
-    , m_buttonDown(initializer.button() != (unsigned short)-1)
+    , m_buttonDown(initializer.button() != -1)
     , m_relatedTarget(initializer.relatedTarget())
     , m_dataTransfer(nullptr)
     , m_syntheticEventType(PlatformMouseEvent::RealOrIndistinguishable)
 {
     initCoordinates(IntPoint(initializer.clientX(), initializer.clientY()));
 }
 
 MouseEvent::~MouseEvent()
 {
 }
 
 unsigned short MouseEvent::platformModifiersToButtons(unsigned modifiers)
 {
     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(ScriptState* scriptState, 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 buttons)
+                                short button, PassRefPtrWillBeRawPtr<EventTarget> relatedTarget, unsigned short buttons)
 {
     if (dispatched())
         return;
 
     if (scriptState && scriptState->world().isIsolatedWorld())
         UIEventWithKeyState::didCreateEventInIsolatedWorld(ctrlKey, altKey, shiftKey, metaKey);
 
     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_button = button;
     m_buttons = buttons;
-    m_buttonDown = button != (unsigned short)-1;
+    m_buttonDown = button != -1;
     m_relatedTarget = relatedTarget;
 
     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
 {
@@ skipping 10 matching lines @@
     const AtomicString& t = type();
     return t == EventTypeNames::dragenter || t == EventTypeNames::dragover || t == EventTypeNames::dragleave || t == EventTypeNames::drop
                || t == EventTypeNames::dragstart|| t == EventTypeNames::drag || t == EventTypeNames::dragend;
 }
 
 int MouseEvent::which() const
 {
     // For the DOM, the return values for left, middle and right mouse buttons are 0, 1, 2, respectively.
     // For the Netscape "which" property, the return values for left, middle and right mouse buttons are 1, 2, 3, respectively.
     // So we must add 1.
-    if (!m_buttonDown)
-        return 0;
     return m_button + 1;
 }
 
 Node* MouseEvent::toElement() const
 {
     // MSIE extension - "the object toward which the user is moving the mouse pointer"
     if (type() == EventTypeNames::mouseout || type() == EventTypeNames::mouseleave)
         return relatedTarget() ? relatedTarget()->toNode() : 0;
 
     return target() ? target()->toNode() : 0;
@@ skipping 97 matching lines @@
         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