Add m-esr52 at 52.6.0

1 files changed, 777 insertions, 0 deletions

diff --git a/widget/InputData.cpp b/widget/InputData.cpp
new file mode 100644
index 000000000..70072778d
--- /dev/null
+++ b/widget/InputData.cpp
@@ -0,0 +1,777 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "InputData.h"
+
+#include "mozilla/dom/Touch.h"
+#include "nsDebug.h"
+#include "nsThreadUtils.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/TouchEvents.h"
+#include "UnitTransforms.h"
+
+namespace mozilla {
+
+using namespace dom;
+
+InputData::~InputData()
+{
+}
+
+InputData::InputData(InputType aInputType)
+  : mInputType(aInputType)
+  , mTime(0)
+  , modifiers(0)
+{
+}
+
+InputData::InputData(InputType aInputType, uint32_t aTime, TimeStamp aTimeStamp,
+                     Modifiers aModifiers)
+  : mInputType(aInputType)
+  , mTime(aTime)
+  , mTimeStamp(aTimeStamp)
+  , modifiers(aModifiers)
+{
+}
+
+SingleTouchData::SingleTouchData(int32_t aIdentifier, ScreenIntPoint aScreenPoint,
+                                 ScreenSize aRadius, float aRotationAngle,
+                                 float aForce)
+  : mIdentifier(aIdentifier)
+  , mScreenPoint(aScreenPoint)
+  , mRadius(aRadius)
+  , mRotationAngle(aRotationAngle)
+  , mForce(aForce)
+{
+}
+
+SingleTouchData::SingleTouchData(int32_t aIdentifier,
+                                 ParentLayerPoint aLocalScreenPoint,
+                                 ScreenSize aRadius, float aRotationAngle,
+                                 float aForce)
+  : mIdentifier(aIdentifier)
+  , mLocalScreenPoint(aLocalScreenPoint)
+  , mRadius(aRadius)
+  , mRotationAngle(aRotationAngle)
+  , mForce(aForce)
+{
+}
+
+SingleTouchData::SingleTouchData()
+{
+}
+
+already_AddRefed<Touch> SingleTouchData::ToNewDOMTouch() const
+{
+  MOZ_ASSERT(NS_IsMainThread(),
+             "Can only create dom::Touch instances on main thread");
+  RefPtr<Touch> touch = new Touch(mIdentifier,
+                                  LayoutDeviceIntPoint::Truncate(mScreenPoint.x, mScreenPoint.y),
+                                  LayoutDeviceIntPoint::Truncate(mRadius.width, mRadius.height),
+                                  mRotationAngle,
+                                  mForce);
+  return touch.forget();
+}
+
+MultiTouchInput::MultiTouchInput(MultiTouchType aType, uint32_t aTime,
+                                 TimeStamp aTimeStamp, Modifiers aModifiers)
+  : InputData(MULTITOUCH_INPUT, aTime, aTimeStamp, aModifiers)
+  , mType(aType)
+  , mHandledByAPZ(false)
+{
+}
+
+MultiTouchInput::MultiTouchInput()
+  : InputData(MULTITOUCH_INPUT)
+  , mHandledByAPZ(false)
+{
+}
+
+MultiTouchInput::MultiTouchInput(const MultiTouchInput& aOther)
+  : InputData(MULTITOUCH_INPUT, aOther.mTime, aOther.mTimeStamp, aOther.modifiers)
+  , mType(aOther.mType)
+  , mHandledByAPZ(aOther.mHandledByAPZ)
+{
+  mTouches.AppendElements(aOther.mTouches);
+}
+
+MultiTouchInput::MultiTouchInput(const WidgetTouchEvent& aTouchEvent)
+  : InputData(MULTITOUCH_INPUT, aTouchEvent.mTime, aTouchEvent.mTimeStamp,
+              aTouchEvent.mModifiers)
+  , mHandledByAPZ(aTouchEvent.mFlags.mHandledByAPZ)
+{
+  MOZ_ASSERT(NS_IsMainThread(),
+             "Can only copy from WidgetTouchEvent on main thread");
+
+  switch (aTouchEvent.mMessage) {
+    case eTouchStart:
+      mType = MULTITOUCH_START;
+      break;
+    case eTouchMove:
+      mType = MULTITOUCH_MOVE;
+      break;
+    case eTouchEnd:
+      mType = MULTITOUCH_END;
+      break;
+    case eTouchCancel:
+      mType = MULTITOUCH_CANCEL;
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Did not assign a type to a MultiTouchInput");
+      break;
+  }
+
+  for (size_t i = 0; i < aTouchEvent.mTouches.Length(); i++) {
+    const Touch* domTouch = aTouchEvent.mTouches[i];
+
+    // Extract data from weird interfaces.
+    int32_t identifier = domTouch->Identifier();
+    int32_t radiusX = domTouch->RadiusX();
+    int32_t radiusY = domTouch->RadiusY();
+    float rotationAngle = domTouch->RotationAngle();
+    float force = domTouch->Force();
+
+    SingleTouchData data(identifier,
+                         ViewAs<ScreenPixel>(domTouch->mRefPoint,
+                                             PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent),
+                         ScreenSize(radiusX, radiusY),
+                         rotationAngle,
+                         force);
+
+    mTouches.AppendElement(data);
+  }
+}
+
+MultiTouchInput::MultiTouchInput(const WidgetMouseEvent& aMouseEvent)
+  : InputData(MULTITOUCH_INPUT, aMouseEvent.mTime, aMouseEvent.mTimeStamp,
+              aMouseEvent.mModifiers)
+  , mHandledByAPZ(aMouseEvent.mFlags.mHandledByAPZ)
+{
+  MOZ_ASSERT(NS_IsMainThread(),
+             "Can only copy from WidgetMouseEvent on main thread");
+  switch (aMouseEvent.mMessage) {
+  case eMouseDown:
+    mType = MULTITOUCH_START;
+    break;
+  case eMouseMove:
+    mType = MULTITOUCH_MOVE;
+    break;
+  case eMouseUp:
+    mType = MULTITOUCH_END;
+    break;
+  // The mouse pointer has been interrupted in an implementation-specific
+  // manner, such as a synchronous event or action cancelling the touch, or a
+  // touch point leaving the document window and going into a non-document
+  // area capable of handling user interactions.
+  case eMouseExitFromWidget:
+    mType = MULTITOUCH_CANCEL;
+    break;
+  default:
+    NS_WARNING("Did not assign a type to a MultiTouchInput");
+    break;
+  }
+
+  mTouches.AppendElement(SingleTouchData(0,
+                                         ViewAs<ScreenPixel>(aMouseEvent.mRefPoint,
+                                                             PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent),
+                                         ScreenSize(1, 1),
+                                         180.0f,
+                                         1.0f));
+}
+
+WidgetTouchEvent
+MultiTouchInput::ToWidgetTouchEvent(nsIWidget* aWidget) const
+{
+  MOZ_ASSERT(NS_IsMainThread(),
+             "Can only convert To WidgetTouchEvent on main thread");
+
+  EventMessage touchEventMessage = eVoidEvent;
+  switch (mType) {
+  case MULTITOUCH_START:
+    touchEventMessage = eTouchStart;
+    break;
+  case MULTITOUCH_MOVE:
+    touchEventMessage = eTouchMove;
+    break;
+  case MULTITOUCH_END:
+    touchEventMessage = eTouchEnd;
+    break;
+  case MULTITOUCH_CANCEL:
+    touchEventMessage = eTouchCancel;
+    break;
+  default:
+    MOZ_ASSERT_UNREACHABLE("Did not assign a type to WidgetTouchEvent in MultiTouchInput");
+    break;
+  }
+
+  WidgetTouchEvent event(true, touchEventMessage, aWidget);
+  if (touchEventMessage == eVoidEvent) {
+    return event;
+  }
+
+  event.mModifiers = this->modifiers;
+  event.mTime = this->mTime;
+  event.mTimeStamp = this->mTimeStamp;
+  event.mFlags.mHandledByAPZ = mHandledByAPZ;
+
+  for (size_t i = 0; i < mTouches.Length(); i++) {
+    *event.mTouches.AppendElement() = mTouches[i].ToNewDOMTouch();
+  }
+
+  return event;
+}
+
+WidgetMouseEvent
+MultiTouchInput::ToWidgetMouseEvent(nsIWidget* aWidget) const
+{
+  MOZ_ASSERT(NS_IsMainThread(),
+             "Can only convert To WidgetMouseEvent on main thread");
+
+  EventMessage mouseEventMessage = eVoidEvent;
+  switch (mType) {
+    case MultiTouchInput::MULTITOUCH_START:
+      mouseEventMessage = eMouseDown;
+      break;
+    case MultiTouchInput::MULTITOUCH_MOVE:
+      mouseEventMessage = eMouseMove;
+      break;
+    case MultiTouchInput::MULTITOUCH_CANCEL:
+    case MultiTouchInput::MULTITOUCH_END:
+      mouseEventMessage = eMouseUp;
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Did not assign a type to WidgetMouseEvent");
+      break;
+  }
+
+  WidgetMouseEvent event(true, mouseEventMessage, aWidget,
+                         WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal);
+
+  const SingleTouchData& firstTouch = mTouches[0];
+  event.mRefPoint.x = firstTouch.mScreenPoint.x;
+  event.mRefPoint.y = firstTouch.mScreenPoint.y;
+
+  event.mTime = mTime;
+  event.button = WidgetMouseEvent::eLeftButton;
+  event.inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
+  event.mModifiers = modifiers;
+  event.mFlags.mHandledByAPZ = mHandledByAPZ;
+
+  if (mouseEventMessage != eMouseMove) {
+    event.mClickCount = 1;
+  }
+
+  return event;
+}
+
+int32_t
+MultiTouchInput::IndexOfTouch(int32_t aTouchIdentifier)
+{
+  for (size_t i = 0; i < mTouches.Length(); i++) {
+    if (mTouches[i].mIdentifier == aTouchIdentifier) {
+      return (int32_t)i;
+    }
+  }
+  return -1;
+}
+
+bool
+MultiTouchInput::TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform)
+{
+  for (size_t i = 0; i < mTouches.Length(); i++) {
+    Maybe<ParentLayerIntPoint> point = UntransformBy(aTransform, mTouches[i].mScreenPoint);
+    if (!point) { 
+      return false;
+    }
+    mTouches[i].mLocalScreenPoint = *point;
+  }
+  return true;
+}
+
+MouseInput::MouseInput()
+  : InputData(MOUSE_INPUT)
+  , mType(MOUSE_NONE)
+  , mButtonType(NONE)
+  , mInputSource(0)
+  , mButtons(0)
+  , mHandledByAPZ(false)
+{
+}
+
+MouseInput::MouseInput(MouseType aType, ButtonType aButtonType,
+                       uint16_t aInputSource, int16_t aButtons,
+                       const ScreenPoint& aPoint, uint32_t aTime,
+                       TimeStamp aTimeStamp, Modifiers aModifiers)
+  : InputData(MOUSE_INPUT, aTime, aTimeStamp, aModifiers)
+  , mType(aType)
+  , mButtonType(aButtonType)
+  , mInputSource(aInputSource)
+  , mButtons(aButtons)
+  , mOrigin(aPoint)
+  , mHandledByAPZ(false)
+{
+}
+
+MouseInput::MouseInput(const WidgetMouseEventBase& aMouseEvent)
+  : InputData(MOUSE_INPUT, aMouseEvent.mTime, aMouseEvent.mTimeStamp,
+              aMouseEvent.mModifiers)
+  , mType(MOUSE_NONE)
+  , mButtonType(NONE)
+  , mInputSource(aMouseEvent.inputSource)
+  , mButtons(aMouseEvent.buttons)
+  , mHandledByAPZ(aMouseEvent.mFlags.mHandledByAPZ)
+{
+  MOZ_ASSERT(NS_IsMainThread(),
+             "Can only copy from WidgetTouchEvent on main thread");
+
+  mButtonType = NONE;
+
+  switch (aMouseEvent.button) {
+    case WidgetMouseEventBase::eLeftButton:
+      mButtonType = MouseInput::LEFT_BUTTON;
+      break;
+    case WidgetMouseEventBase::eMiddleButton:
+      mButtonType = MouseInput::MIDDLE_BUTTON;
+      break;
+    case WidgetMouseEventBase::eRightButton:
+      mButtonType = MouseInput::RIGHT_BUTTON;
+      break;
+  }
+
+  switch (aMouseEvent.mMessage) {
+    case eMouseMove:
+      mType = MOUSE_MOVE;
+      break;
+    case eMouseUp:
+      mType = MOUSE_UP;
+      break;
+    case eMouseDown:
+      mType = MOUSE_DOWN;
+      break;
+    case eDragStart:
+      mType = MOUSE_DRAG_START;
+      break;
+    case eDragEnd:
+      mType = MOUSE_DRAG_END;
+      break;
+    case eMouseEnterIntoWidget:
+      mType = MOUSE_WIDGET_ENTER;
+      break;
+    case eMouseExitFromWidget:
+      mType = MOUSE_WIDGET_EXIT;
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Mouse event type not supported");
+      break;
+  }
+
+  mOrigin =
+    ScreenPoint(ViewAs<ScreenPixel>(aMouseEvent.mRefPoint,
+      PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+}
+
+bool
+MouseInput::IsLeftButton() const
+{
+  return mButtonType == LEFT_BUTTON;
+}
+
+bool
+MouseInput::TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform)
+{
+  Maybe<ParentLayerPoint> point = UntransformBy(aTransform, mOrigin);
+  if (!point) {
+    return false;
+  }
+  mLocalOrigin = *point;
+
+  return true;
+}
+
+WidgetMouseEvent
+MouseInput::ToWidgetMouseEvent(nsIWidget* aWidget) const
+{
+  MOZ_ASSERT(NS_IsMainThread(),
+             "Can only convert To WidgetTouchEvent on main thread");
+
+  EventMessage msg = eVoidEvent;
+  uint32_t clickCount = 0;
+  switch (mType) {
+    case MOUSE_MOVE:
+      msg = eMouseMove;
+      break;
+    case MOUSE_UP:
+      msg = eMouseUp;
+      clickCount = 1;
+      break;
+    case MOUSE_DOWN:
+      msg = eMouseDown;
+      clickCount = 1;
+      break;
+    case MOUSE_DRAG_START:
+      msg = eDragStart;
+      break;
+    case MOUSE_DRAG_END:
+      msg = eDragEnd;
+      break;
+    case MOUSE_WIDGET_ENTER:
+      msg = eMouseEnterIntoWidget;
+      break;
+    case MOUSE_WIDGET_EXIT:
+      msg = eMouseExitFromWidget;
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Did not assign a type to WidgetMouseEvent in MouseInput");
+      break;
+  }
+
+  WidgetMouseEvent event(true, msg, aWidget, WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal);
+
+  if (msg == eVoidEvent) {
+    return event;
+  }
+
+  switch (mButtonType) {
+    case MouseInput::LEFT_BUTTON:
+      event.button = WidgetMouseEventBase::eLeftButton;
+      break;
+    case MouseInput::MIDDLE_BUTTON:
+      event.button = WidgetMouseEventBase::eMiddleButton;
+      break;
+    case MouseInput::RIGHT_BUTTON:
+      event.button = WidgetMouseEventBase::eRightButton;
+      break;
+    case MouseInput::NONE:
+    default:
+      break;
+  }
+
+  event.buttons = mButtons;
+  event.mModifiers = modifiers;
+  event.mTime = mTime;
+  event.mTimeStamp = mTimeStamp;
+  event.mFlags.mHandledByAPZ = mHandledByAPZ;
+  event.mRefPoint =
+    RoundedToInt(ViewAs<LayoutDevicePixel>(mOrigin,
+      PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+  event.mClickCount = clickCount;
+  event.inputSource = mInputSource;
+  event.mIgnoreRootScrollFrame = true;
+
+  return event;
+}
+
+PanGestureInput::PanGestureInput()
+  : InputData(PANGESTURE_INPUT)
+  , mLineOrPageDeltaX(0)
+  , mLineOrPageDeltaY(0)
+  , mUserDeltaMultiplierX(1.0)
+  , mUserDeltaMultiplierY(1.0)
+  , mHandledByAPZ(false)
+  , mFollowedByMomentum(false)
+  , mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection(false)
+{
+}
+
+PanGestureInput::PanGestureInput(PanGestureType aType, uint32_t aTime,
+                                 TimeStamp aTimeStamp,
+                                 const ScreenPoint& aPanStartPoint,
+                                 const ScreenPoint& aPanDisplacement,
+                                 Modifiers aModifiers)
+  : InputData(PANGESTURE_INPUT, aTime, aTimeStamp, aModifiers)
+  , mType(aType)
+  , mPanStartPoint(aPanStartPoint)
+  , mPanDisplacement(aPanDisplacement)
+  , mLineOrPageDeltaX(0)
+  , mLineOrPageDeltaY(0)
+  , mUserDeltaMultiplierX(1.0)
+  , mUserDeltaMultiplierY(1.0)
+  , mHandledByAPZ(false)
+  , mFollowedByMomentum(false)
+  , mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection(false)
+{
+}
+
+bool
+PanGestureInput::IsMomentum() const
+{
+  switch (mType) {
+    case PanGestureInput::PANGESTURE_MOMENTUMSTART:
+    case PanGestureInput::PANGESTURE_MOMENTUMPAN:
+    case PanGestureInput::PANGESTURE_MOMENTUMEND:
+      return true;
+    default:
+      return false;
+  }
+}
+
+WidgetWheelEvent
+PanGestureInput::ToWidgetWheelEvent(nsIWidget* aWidget) const
+{
+  WidgetWheelEvent wheelEvent(true, eWheel, aWidget);
+  wheelEvent.mModifiers = this->modifiers;
+  wheelEvent.mTime = mTime;
+  wheelEvent.mTimeStamp = mTimeStamp;
+  wheelEvent.mRefPoint =
+    RoundedToInt(ViewAs<LayoutDevicePixel>(mPanStartPoint,
+      PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+  wheelEvent.buttons = 0;
+  wheelEvent.mDeltaMode = nsIDOMWheelEvent::DOM_DELTA_PIXEL;
+  wheelEvent.mMayHaveMomentum = true; // pan inputs may have momentum
+  wheelEvent.mIsMomentum = IsMomentum();
+  wheelEvent.mLineOrPageDeltaX = mLineOrPageDeltaX;
+  wheelEvent.mLineOrPageDeltaY = mLineOrPageDeltaY;
+  wheelEvent.mDeltaX = mPanDisplacement.x;
+  wheelEvent.mDeltaY = mPanDisplacement.y;
+  wheelEvent.mFlags.mHandledByAPZ = mHandledByAPZ;
+  return wheelEvent;
+}
+
+bool
+PanGestureInput::TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform)
+{ 
+  Maybe<ParentLayerPoint> panStartPoint = UntransformBy(aTransform, mPanStartPoint);
+  if (!panStartPoint) {
+    return false;
+  }
+  mLocalPanStartPoint = *panStartPoint;
+  
+  Maybe<ParentLayerPoint> panDisplacement = UntransformVector(aTransform, mPanDisplacement, mPanStartPoint);
+  if (!panDisplacement) {
+    return false;
+  }
+  mLocalPanDisplacement = *panDisplacement;
+  return true;
+}
+
+ScreenPoint
+PanGestureInput::UserMultipliedPanDisplacement() const
+{
+  return ScreenPoint(mPanDisplacement.x * mUserDeltaMultiplierX,
+                     mPanDisplacement.y * mUserDeltaMultiplierY);
+}
+
+ParentLayerPoint
+PanGestureInput::UserMultipliedLocalPanDisplacement() const
+{
+  return ParentLayerPoint(mLocalPanDisplacement.x * mUserDeltaMultiplierX,
+                          mLocalPanDisplacement.y * mUserDeltaMultiplierY);
+}
+
+PinchGestureInput::PinchGestureInput()
+  : InputData(PINCHGESTURE_INPUT)
+{
+}
+
+PinchGestureInput::PinchGestureInput(PinchGestureType aType, uint32_t aTime,
+                                     TimeStamp aTimeStamp,
+                                     const ParentLayerPoint& aLocalFocusPoint,
+                                     ParentLayerCoord aCurrentSpan,
+                                     ParentLayerCoord aPreviousSpan,
+                                     Modifiers aModifiers)
+  : InputData(PINCHGESTURE_INPUT, aTime, aTimeStamp, aModifiers)
+  , mType(aType)
+  , mLocalFocusPoint(aLocalFocusPoint)
+  , mCurrentSpan(aCurrentSpan)
+  , mPreviousSpan(aPreviousSpan)
+{
+}
+
+bool
+PinchGestureInput::TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform)
+{ 
+  Maybe<ParentLayerPoint> point = UntransformBy(aTransform, mFocusPoint);
+  if (!point) {
+    return false;
+  }
+  mLocalFocusPoint = *point;
+  return true;
+}
+
+TapGestureInput::TapGestureInput()
+  : InputData(TAPGESTURE_INPUT)
+{
+}
+
+TapGestureInput::TapGestureInput(TapGestureType aType, uint32_t aTime,
+                                 TimeStamp aTimeStamp,
+                                 const ScreenIntPoint& aPoint,
+                                 Modifiers aModifiers)
+  : InputData(TAPGESTURE_INPUT, aTime, aTimeStamp, aModifiers)
+  , mType(aType)
+  , mPoint(aPoint)
+{
+}
+
+TapGestureInput::TapGestureInput(TapGestureType aType, uint32_t aTime,
+                                 TimeStamp aTimeStamp,
+                                 const ParentLayerPoint& aLocalPoint,
+                                 Modifiers aModifiers)
+  : InputData(TAPGESTURE_INPUT, aTime, aTimeStamp, aModifiers)
+  , mType(aType)
+  , mLocalPoint(aLocalPoint)
+{
+}
+
+bool
+TapGestureInput::TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform)
+{
+  Maybe<ParentLayerIntPoint> point = UntransformBy(aTransform, mPoint);
+  if (!point) {
+    return false;
+  }
+  mLocalPoint = *point;
+  return true;
+}
+
+ScrollWheelInput::ScrollWheelInput()
+  : InputData(SCROLLWHEEL_INPUT)
+  , mHandledByAPZ(false)
+  , mLineOrPageDeltaX(0)
+  , mLineOrPageDeltaY(0)
+  , mScrollSeriesNumber(0)
+  , mUserDeltaMultiplierX(1.0)
+  , mUserDeltaMultiplierY(1.0)
+  , mMayHaveMomentum(false)
+  , mIsMomentum(false)
+{
+}
+
+ScrollWheelInput::ScrollWheelInput(uint32_t aTime, TimeStamp aTimeStamp,
+                                   Modifiers aModifiers, ScrollMode aScrollMode,
+                                   ScrollDeltaType aDeltaType,
+                                   const ScreenPoint& aOrigin, double aDeltaX,
+                                   double aDeltaY,
+                                   bool aAllowToOverrideSystemScrollSpeed)
+  : InputData(SCROLLWHEEL_INPUT, aTime, aTimeStamp, aModifiers)
+  , mDeltaType(aDeltaType)
+  , mScrollMode(aScrollMode)
+  , mOrigin(aOrigin)
+  , mHandledByAPZ(false)
+  , mDeltaX(aDeltaX)
+  , mDeltaY(aDeltaY)
+  , mLineOrPageDeltaX(0)
+  , mLineOrPageDeltaY(0)
+  , mScrollSeriesNumber(0)
+  , mUserDeltaMultiplierX(1.0)
+  , mUserDeltaMultiplierY(1.0)
+  , mMayHaveMomentum(false)
+  , mIsMomentum(false)
+  , mAllowToOverrideSystemScrollSpeed(aAllowToOverrideSystemScrollSpeed)
+{
+}
+
+ScrollWheelInput::ScrollWheelInput(const WidgetWheelEvent& aWheelEvent)
+  : InputData(SCROLLWHEEL_INPUT, aWheelEvent.mTime, aWheelEvent.mTimeStamp,
+              aWheelEvent.mModifiers)
+  , mDeltaType(DeltaTypeForDeltaMode(aWheelEvent.mDeltaMode))
+  , mScrollMode(SCROLLMODE_INSTANT)
+  , mHandledByAPZ(aWheelEvent.mFlags.mHandledByAPZ)
+  , mDeltaX(aWheelEvent.mDeltaX)
+  , mDeltaY(aWheelEvent.mDeltaY)
+  , mLineOrPageDeltaX(aWheelEvent.mLineOrPageDeltaX)
+  , mLineOrPageDeltaY(aWheelEvent.mLineOrPageDeltaY)
+  , mScrollSeriesNumber(0)
+  , mUserDeltaMultiplierX(1.0)
+  , mUserDeltaMultiplierY(1.0)
+  , mMayHaveMomentum(aWheelEvent.mMayHaveMomentum)
+  , mIsMomentum(aWheelEvent.mIsMomentum)
+  , mAllowToOverrideSystemScrollSpeed(
+      aWheelEvent.mAllowToOverrideSystemScrollSpeed)
+{
+  mOrigin =
+    ScreenPoint(ViewAs<ScreenPixel>(aWheelEvent.mRefPoint,
+      PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+}
+
+ScrollWheelInput::ScrollDeltaType
+ScrollWheelInput::DeltaTypeForDeltaMode(uint32_t aDeltaMode)
+{
+  switch (aDeltaMode) {
+  case nsIDOMWheelEvent::DOM_DELTA_LINE:
+    return SCROLLDELTA_LINE;
+  case nsIDOMWheelEvent::DOM_DELTA_PAGE:
+    return SCROLLDELTA_PAGE;
+  case nsIDOMWheelEvent::DOM_DELTA_PIXEL:
+    return SCROLLDELTA_PIXEL;
+  default:
+    MOZ_CRASH();
+  }
+  return SCROLLDELTA_LINE;
+}
+
+uint32_t
+ScrollWheelInput::DeltaModeForDeltaType(ScrollDeltaType aDeltaType)
+{
+  switch (aDeltaType) {
+  case ScrollWheelInput::SCROLLDELTA_LINE:
+    return nsIDOMWheelEvent::DOM_DELTA_LINE;
+  case ScrollWheelInput::SCROLLDELTA_PAGE:
+    return nsIDOMWheelEvent::DOM_DELTA_PAGE;
+  case ScrollWheelInput::SCROLLDELTA_PIXEL:
+  default:
+    return nsIDOMWheelEvent::DOM_DELTA_PIXEL;
+  }
+}
+
+nsIScrollableFrame::ScrollUnit
+ScrollWheelInput::ScrollUnitForDeltaType(ScrollDeltaType aDeltaType)
+{
+  switch (aDeltaType) {
+  case SCROLLDELTA_LINE:
+    return nsIScrollableFrame::LINES;
+  case SCROLLDELTA_PAGE:
+    return nsIScrollableFrame::PAGES;
+  case SCROLLDELTA_PIXEL:
+    return nsIScrollableFrame::DEVICE_PIXELS;
+  default:
+    MOZ_CRASH();
+  }
+  return nsIScrollableFrame::LINES;
+}
+
+WidgetWheelEvent
+ScrollWheelInput::ToWidgetWheelEvent(nsIWidget* aWidget) const
+{
+  WidgetWheelEvent wheelEvent(true, eWheel, aWidget);
+  wheelEvent.mModifiers = this->modifiers;
+  wheelEvent.mTime = mTime;
+  wheelEvent.mTimeStamp = mTimeStamp;
+  wheelEvent.mRefPoint =
+    RoundedToInt(ViewAs<LayoutDevicePixel>(mOrigin,
+      PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+  wheelEvent.buttons = 0;
+  wheelEvent.mDeltaMode = DeltaModeForDeltaType(mDeltaType);
+  wheelEvent.mMayHaveMomentum = mMayHaveMomentum;
+  wheelEvent.mIsMomentum = mIsMomentum;
+  wheelEvent.mDeltaX = mDeltaX;
+  wheelEvent.mDeltaY = mDeltaY;
+  wheelEvent.mLineOrPageDeltaX = mLineOrPageDeltaX;
+  wheelEvent.mLineOrPageDeltaY = mLineOrPageDeltaY;
+  wheelEvent.mAllowToOverrideSystemScrollSpeed =
+    mAllowToOverrideSystemScrollSpeed;
+  wheelEvent.mFlags.mHandledByAPZ = mHandledByAPZ;
+  return wheelEvent;
+}
+
+bool
+ScrollWheelInput::TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform)
+{
+  Maybe<ParentLayerPoint> point = UntransformBy(aTransform, mOrigin);
+  if (!point) {
+    return false;
+  }
+  mLocalOrigin = *point;
+  return true;
+}
+
+bool
+ScrollWheelInput::IsCustomizedByUserPrefs() const
+{
+  return mUserDeltaMultiplierX != 1.0 ||
+         mUserDeltaMultiplierY != 1.0;
+}
+
+} // namespace mozilla