WheelEvent's deltaX/deltaY should report real amount of pixels scrolled

Source/core/dom/WheelEvent.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, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Samsung Electronics. 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
@@ skipping 12 matching lines @@
 
 #include "config.h"
 #include "core/dom/WheelEvent.h"
 
 #include "core/dom/Clipboard.h"
 #include "core/dom/EventNames.h"
 #include "core/platform/PlatformWheelEvent.h"
 
 namespace WebCore {
 
-static inline double wheelTicksToPixels(double ticks)
-{
-    // Make sure we use +0 for all zeros.
-    if (!ticks)
-        return 0;
-    return -ticks * WheelEvent::TickMultiplier;
-}
-
 WheelEventInit::WheelEventInit()
     : deltaX(0)
     , deltaY(0)
     , deltaZ(0)
     , wheelDeltaX(0)
     , wheelDeltaY(0)
     , deltaMode(WheelEvent::DOM_DELTA_PIXEL)
 {
 }
 
 WheelEvent::WheelEvent()
     : m_deltaX(0)
     , m_deltaY(0)
     , m_deltaZ(0)
     , m_deltaMode(DOM_DELTA_PIXEL)
     , m_directionInvertedFromDevice(false)
 {
     ScriptWrappable::init(this);
 }
 
 WheelEvent::WheelEvent(const AtomicString& type, const WheelEventInit& initializer)
     : MouseEvent(type, initializer)
+    , m_wheelDelta(initializer.wheelDeltaX ? initializer.wheelDeltaX : -initializer.deltaX, initializer.wheelDeltaY ? initializer.wheelDeltaY : -initializer.deltaY)

[arv (Not doing code reviews), 2013/08/22 14:15:49]

Is this correct? What if initializer.wheelDeltaX was initialized to 0?

[do-not-use, 2013/08/22 14:46:03]

I am not sure I understand the question. If initializer.wheelDeltaX was
initialized to zero, then we will attempt to deduce its value from
initializer.deltaX if its was provided.

We need such fallback so that wheelEvent.wheelDeltaX() will return something
even though the event was initialized with the new deltaX.

[do-not-use, 2013/08/22 15:08:21]

If the caller constructs the WheelEvent from JS and provides deltaX/deltaY but
not wheelDeltaX/wheelDeltaY then we are missing information about the number of
wheel ticks (since wheelDeltaX == ticksX * TickMultiplier).

To make sure that wheelDeltaX/wheelDeltaY do not return 0 in that case, we make
the assumption that ticksX * TickMultiplier is close to -deltaX. This is not
perfect but I don't see what else we could do here.

[arv (Not doing code reviews), 2013/08/22 15:25:15]

My point was that if wheelDeltaX was initialized to 0 we treat that as false
(not present) and fall back to deltaX. There needs to be a way of knowing if it
was set to 0 or whether it is missing.

     , m_deltaX(initializer.deltaX ? initializer.deltaX : -initializer.wheelDeltaX)
     , m_deltaY(initializer.deltaY ? initializer.deltaY : -initializer.wheelDeltaY)
     , m_deltaZ(initializer.deltaZ)
     , m_deltaMode(initializer.deltaMode)
 {
     ScriptWrappable::init(this);
 }
 
 WheelEvent::WheelEvent(const FloatPoint& wheelTicks, const FloatPoint& rawDelta, unsigned deltaMode,
     PassRefPtr<AbstractView> view, const IntPoint& screenLocation, const IntPoint& pageLocation,
     bool ctrlKey, bool altKey, bool shiftKey, bool metaKey, bool directionInvertedFromDevice)
     : MouseEvent(eventNames().wheelEvent,
                  true, true, view, 0, screenLocation.x(), screenLocation.y(),
                  pageLocation.x(), pageLocation.y(),
                  0, 0,
                  ctrlKey, altKey, shiftKey, metaKey, 0, 0, 0, false)
-    , m_deltaX(wheelTicksToPixels(wheelTicks.x()))
-    , m_deltaY(wheelTicksToPixels(wheelTicks.y()))
-    , m_deltaZ(0) // FIXME: Not supported.
-    , m_rawDelta(roundedIntPoint(rawDelta))
+    , m_wheelDelta(wheelTicks.x() * TickMultiplier, wheelTicks.y() * TickMultiplier)
+    , m_deltaX(-rawDelta.x())
+    , m_deltaY(-rawDelta.y())
+    , m_deltaZ(0)
     , m_deltaMode(deltaMode)
     , m_directionInvertedFromDevice(directionInvertedFromDevice)
 {
     ScriptWrappable::init(this);
 }
 
 void WheelEvent::initWheelEvent(int rawDeltaX, int rawDeltaY, PassRefPtr<AbstractView> view,
                                 int screenX, int screenY, int pageX, int pageY,
                                 bool ctrlKey, bool altKey, bool shiftKey, bool metaKey)
 {
     if (dispatched())
         return;
 
     initUIEvent(eventNames().wheelEvent, true, true, view, 0);
 
     m_screenLocation = IntPoint(screenX, screenY);
     m_ctrlKey = ctrlKey;
     m_altKey = altKey;
     m_shiftKey = shiftKey;
     m_metaKey = metaKey;
 
-    m_deltaX = wheelTicksToPixels(rawDeltaX);
-    m_deltaY = wheelTicksToPixels(rawDeltaY);
-    m_rawDelta = IntPoint(rawDeltaX, rawDeltaY);
+    m_wheelDelta = IntPoint(rawDeltaX * TickMultiplier, rawDeltaY * TickMultiplier);
+    m_deltaX = -rawDeltaX;
+    m_deltaY = -rawDeltaY;
     m_deltaMode = DOM_DELTA_PIXEL;
     m_directionInvertedFromDevice = false;
 
     initCoordinates(IntPoint(pageX, pageY));
 }
 
 void WheelEvent::initWebKitWheelEvent(int rawDeltaX, int rawDeltaY, PassRefPtr<AbstractView> view,
                                       int screenX, int screenY, int pageX, int pageY,
                                       bool ctrlKey, bool altKey, bool shiftKey, bool metaKey)
 {
@@ skipping 36 matching lines @@
     return static_cast<WheelEvent*>(EventDispatchMediator::event());
 }
 
 bool WheelEventDispatchMediator::dispatchEvent(EventDispatcher* dispatcher) const
 {
     ASSERT(event());
     return EventDispatchMediator::dispatchEvent(dispatcher) && !event()->defaultHandled();
 }
 
 } // namespace WebCore