Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 925 insertions, 0 deletions

diff --git a/widget/InputData.cpp b/widget/InputData.cpp
new file mode 100644
index 0000000000..0265aab5a8
--- /dev/null
+++ b/widget/InputData.cpp
@@ -0,0 +1,925 @@
+/* -*- 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/MouseEventBinding.h"
+#include "mozilla/dom/Touch.h"
+#include "mozilla/dom/WheelEventBinding.h"
+#include "mozilla/TextEvents.h"
+#include "nsContentUtils.h"
+#include "nsDebug.h"
+#include "nsThreadUtils.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/TouchEvents.h"
+#include "mozilla/SwipeTracker.h"
+#include "UnitTransforms.h"
+
+namespace mozilla {
+
+using namespace dom;
+
+InputData::~InputData() = default;
+
+InputData::InputData(InputType aInputType)
+    : mInputType(aInputType),
+      mFocusSequenceNumber(0),
+      mLayersId{0},
+      modifiers(0) {}
+
+InputData::InputData(InputType aInputType, TimeStamp aTimeStamp,
+                     Modifiers aModifiers)
+    : mInputType(aInputType),
+      mTimeStamp(aTimeStamp),
+      mFocusSequenceNumber(0),
+      mLayersId{0},
+      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()
+    : mIdentifier(0), mRotationAngle(0.0), mForce(0.0) {}
+
+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);
+  touch->tiltX = mTiltX;
+  touch->tiltY = mTiltY;
+  touch->twist = mTwist;
+  return touch.forget();
+}
+
+MultiTouchInput::MultiTouchInput(MultiTouchType aType, uint32_t aTime,
+                                 TimeStamp aTimeStamp, Modifiers aModifiers)
+    : InputData(MULTITOUCH_INPUT, aTimeStamp, aModifiers),
+      mType(aType),
+      mHandledByAPZ(false) {}
+
+MultiTouchInput::MultiTouchInput()
+    : InputData(MULTITOUCH_INPUT),
+      mType(MULTITOUCH_START),
+      mHandledByAPZ(false) {}
+
+MultiTouchInput::MultiTouchInput(const WidgetTouchEvent& aTouchEvent)
+    : InputData(MULTITOUCH_INPUT, aTouchEvent.mTimeStamp,
+                aTouchEvent.mModifiers),
+      mHandledByAPZ(aTouchEvent.mFlags.mHandledByAPZ),
+      mButton(aTouchEvent.mButton),
+      mButtons(aTouchEvent.mButtons) {
+  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;
+  }
+
+  mScreenOffset = ViewAs<ExternalPixel>(
+      aTouchEvent.mWidget->WidgetToScreenOffset(),
+      PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent);
+
+  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(CallerType::System);
+    int32_t radiusY = domTouch->RadiusY(CallerType::System);
+    float rotationAngle = domTouch->RotationAngle(CallerType::System);
+    float force = domTouch->Force(CallerType::System);
+
+    SingleTouchData data(
+        identifier,
+        ViewAs<ScreenPixel>(
+            domTouch->mRefPoint,
+            PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent),
+        ScreenSize((float)radiusX, (float)radiusY), rotationAngle, force);
+
+    mTouches.AppendElement(data);
+  }
+}
+
+void MultiTouchInput::Translate(const ScreenPoint& aTranslation) {
+  const int32_t xTranslation = (int32_t)(aTranslation.x + 0.5f);
+  const int32_t yTranslation = (int32_t)(aTranslation.y + 0.5f);
+
+  for (auto& touchData : mTouches) {
+    for (auto& historicalData : touchData.mHistoricalData) {
+      historicalData.mScreenPoint.MoveBy(xTranslation, yTranslation);
+    }
+    touchData.mScreenPoint.MoveBy(xTranslation, yTranslation);
+  }
+}
+
+WidgetTouchEvent MultiTouchInput::ToWidgetEvent(nsIWidget* aWidget,
+                                                uint16_t aInputSource) const {
+  MOZ_ASSERT(NS_IsMainThread(),
+             "Can only convert To WidgetTouchEvent on main thread");
+  MOZ_ASSERT(aInputSource ==
+                 mozilla::dom::MouseEvent_Binding::MOZ_SOURCE_TOUCH ||
+             aInputSource == mozilla::dom::MouseEvent_Binding::MOZ_SOURCE_PEN);
+
+  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.mTimeStamp = this->mTimeStamp;
+  event.mFlags.mHandledByAPZ = mHandledByAPZ;
+  event.mFocusSequenceNumber = mFocusSequenceNumber;
+  event.mLayersId = mLayersId;
+  event.mInputSource = aInputSource;
+  event.mButton = mButton;
+  event.mButtons = mButtons;
+
+  for (size_t i = 0; i < mTouches.Length(); i++) {
+    *event.mTouches.AppendElement() = mTouches[i].ToNewDOMTouch();
+  }
+
+  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 (auto& touchData : mTouches) {
+    for (auto& historicalData : touchData.mHistoricalData) {
+      Maybe<ParentLayerIntPoint> historicalPoint =
+          UntransformBy(aTransform, historicalData.mScreenPoint);
+      if (!historicalPoint) {
+        return false;
+      }
+      historicalData.mLocalScreenPoint = *historicalPoint;
+    }
+    Maybe<ParentLayerIntPoint> point =
+        UntransformBy(aTransform, touchData.mScreenPoint);
+    if (!point) {
+      return false;
+    }
+    touchData.mLocalScreenPoint = *point;
+  }
+  return true;
+}
+
+MouseInput::MouseInput()
+    : InputData(MOUSE_INPUT),
+      mType(MOUSE_NONE),
+      mButtonType(NONE),
+      mInputSource(0),
+      mButtons(0),
+      mHandledByAPZ(false),
+      mPreventClickEvent(false) {}
+
+MouseInput::MouseInput(MouseType aType, ButtonType aButtonType,
+                       uint16_t aInputSource, int16_t aButtons,
+                       const ScreenPoint& aPoint, TimeStamp aTimeStamp,
+                       Modifiers aModifiers)
+    : InputData(MOUSE_INPUT, aTimeStamp, aModifiers),
+      mType(aType),
+      mButtonType(aButtonType),
+      mInputSource(aInputSource),
+      mButtons(aButtons),
+      mOrigin(aPoint),
+      mHandledByAPZ(false),
+      mPreventClickEvent(false) {}
+
+MouseInput::MouseInput(const WidgetMouseEventBase& aMouseEvent)
+    : InputData(MOUSE_INPUT, aMouseEvent.mTimeStamp, aMouseEvent.mModifiers),
+      mType(MOUSE_NONE),
+      mButtonType(NONE),
+      mInputSource(aMouseEvent.mInputSource),
+      mButtons(aMouseEvent.mButtons),
+      mHandledByAPZ(aMouseEvent.mFlags.mHandledByAPZ),
+      mPreventClickEvent(aMouseEvent.mClass == eMouseEventClass &&
+                         aMouseEvent.AsMouseEvent()->mClickEventPrevented) {
+  MOZ_ASSERT(NS_IsMainThread(),
+             "Can only copy from WidgetTouchEvent on main thread");
+
+  mButtonType = NONE;
+
+  switch (aMouseEvent.mButton) {
+    case MouseButton::ePrimary:
+      mButtonType = MouseInput::PRIMARY_BUTTON;
+      break;
+    case MouseButton::eMiddle:
+      mButtonType = MouseInput::MIDDLE_BUTTON;
+      break;
+    case MouseButton::eSecondary:
+      mButtonType = MouseInput::SECONDARY_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;
+    case eMouseExploreByTouch:
+      mType = MOUSE_EXPLORE_BY_TOUCH;
+      break;
+    case eMouseHitTest:
+      mType = MOUSE_HITTEST;
+      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 == PRIMARY_BUTTON; }
+
+bool MouseInput::TransformToLocal(
+    const ScreenToParentLayerMatrix4x4& aTransform) {
+  Maybe<ParentLayerPoint> point = UntransformBy(aTransform, mOrigin);
+  if (!point) {
+    return false;
+  }
+  mLocalOrigin = *point;
+
+  return true;
+}
+
+WidgetMouseEvent MouseInput::ToWidgetEvent(nsIWidget* aWidget) const {
+  MOZ_ASSERT(NS_IsMainThread(),
+             "Can only convert To WidgetTouchEvent on main thread");
+
+  EventMessage msg = eVoidEvent;
+  uint32_t clickCount = 0;
+  Maybe<WidgetMouseEvent::ExitFrom> exitFrom;
+  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;
+      exitFrom = Some(WidgetMouseEvent::ePlatformChild);
+      break;
+    case MOUSE_EXPLORE_BY_TOUCH:
+      msg = eMouseExploreByTouch;
+      break;
+    case MOUSE_HITTEST:
+      msg = eMouseHitTest;
+      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::PRIMARY_BUTTON:
+      event.mButton = MouseButton::ePrimary;
+      break;
+    case MouseInput::MIDDLE_BUTTON:
+      event.mButton = MouseButton::eMiddle;
+      break;
+    case MouseInput::SECONDARY_BUTTON:
+      event.mButton = MouseButton::eSecondary;
+      break;
+    case MouseInput::NONE:
+    default:
+      break;
+  }
+
+  event.mButtons = mButtons;
+  event.mModifiers = modifiers;
+  event.mTimeStamp = mTimeStamp;
+  event.mLayersId = mLayersId;
+  event.mFlags.mHandledByAPZ = mHandledByAPZ;
+  event.mRefPoint = RoundedToInt(ViewAs<LayoutDevicePixel>(
+      mOrigin,
+      PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+  event.mClickCount = clickCount;
+  event.mInputSource = mInputSource;
+  event.mFocusSequenceNumber = mFocusSequenceNumber;
+  event.mExitFrom = exitFrom;
+  event.mClickEventPrevented = mPreventClickEvent;
+
+  return event;
+}
+
+PanGestureInput::PanGestureInput()
+    : InputData(PANGESTURE_INPUT),
+      mType(PANGESTURE_MAYSTART),
+      mLineOrPageDeltaX(0),
+      mLineOrPageDeltaY(0),
+      mUserDeltaMultiplierX(1.0),
+      mUserDeltaMultiplierY(1.0),
+      mHandledByAPZ(false),
+      mOverscrollBehaviorAllowsSwipe(false),
+      mSimulateMomentum(false),
+      mIsNoLineOrPageDelta(true),
+      mMayTriggerSwipe(false) {}
+
+PanGestureInput::PanGestureInput(PanGestureType aType, TimeStamp aTimeStamp,
+                                 const ScreenPoint& aPanStartPoint,
+                                 const ScreenPoint& aPanDisplacement,
+                                 Modifiers aModifiers)
+    : InputData(PANGESTURE_INPUT, aTimeStamp, aModifiers),
+      mType(aType),
+      mPanStartPoint(aPanStartPoint),
+      mPanDisplacement(aPanDisplacement),
+      mLineOrPageDeltaX(0),
+      mLineOrPageDeltaY(0),
+      mUserDeltaMultiplierX(1.0),
+      mUserDeltaMultiplierY(1.0),
+      mHandledByAPZ(false),
+      mOverscrollBehaviorAllowsSwipe(false),
+      mSimulateMomentum(false),
+      mIsNoLineOrPageDelta(true) {
+  mMayTriggerSwipe = SwipeTracker::CanTriggerSwipe(*this);
+}
+
+PanGestureInput::PanGestureInput(PanGestureType aType, TimeStamp aTimeStamp,
+                                 const ScreenPoint& aPanStartPoint,
+                                 const ScreenPoint& aPanDisplacement,
+                                 Modifiers aModifiers,
+                                 IsEligibleForSwipe aIsEligibleForSwipe)
+    : PanGestureInput(aType, aTimeStamp, aPanStartPoint, aPanDisplacement,
+                      aModifiers) {
+  mMayTriggerSwipe &= bool(aIsEligibleForSwipe);
+}
+
+void PanGestureInput::SetLineOrPageDeltas(int32_t aLineOrPageDeltaX,
+                                          int32_t aLineOrPageDeltaY) {
+  mLineOrPageDeltaX = aLineOrPageDeltaX;
+  mLineOrPageDeltaY = aLineOrPageDeltaY;
+  mIsNoLineOrPageDelta = 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::ToWidgetEvent(nsIWidget* aWidget) const {
+  WidgetWheelEvent wheelEvent(true, eWheel, aWidget);
+  wheelEvent.mModifiers = this->modifiers;
+  wheelEvent.mTimeStamp = mTimeStamp;
+  wheelEvent.mLayersId = mLayersId;
+  wheelEvent.mRefPoint = RoundedToInt(ViewAs<LayoutDevicePixel>(
+      mPanStartPoint,
+      PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+  wheelEvent.mButtons = 0;
+  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;
+  wheelEvent.mFocusSequenceNumber = mFocusSequenceNumber;
+  wheelEvent.mIsNoLineOrPageDelta = mIsNoLineOrPageDelta;
+  if (mDeltaType == PanGestureInput::PANDELTA_PAGE) {
+    // widget/gtk is currently the only consumer that uses delta type
+    // PANDELTA_PAGE
+    // Emulate legacy widget/gtk behavior
+    wheelEvent.mDeltaMode = WheelEvent_Binding::DOM_DELTA_LINE;
+    wheelEvent.mScrollType = WidgetWheelEvent::SCROLL_ASYNCHRONOUSLY;
+    wheelEvent.mDeltaX *= 3;
+    wheelEvent.mDeltaY *= 3;
+  } else {
+    wheelEvent.mDeltaMode = WheelEvent_Binding::DOM_DELTA_PIXEL;
+  }
+  return wheelEvent;
+}
+
+bool PanGestureInput::TransformToLocal(
+    const ScreenToParentLayerMatrix4x4& aTransform) {
+  Maybe<ParentLayerPoint> panStartPoint =
+      UntransformBy(aTransform, mPanStartPoint);
+  if (!panStartPoint) {
+    return false;
+  }
+  mLocalPanStartPoint = *panStartPoint;
+
+  if (mDeltaType == PanGestureInput::PANDELTA_PAGE) {
+    // Skip transforming the pan displacement because we want
+    // raw page proportion counts.
+    mLocalPanDisplacement = ViewAs<ParentLayerPixel>(
+        mPanDisplacement, PixelCastJustification::DeltaIsPageProportion);
+    return true;
+  }
+
+  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);
+}
+
+static int32_t TakeLargestInt(gfx::Coord* aCoord) {
+  int32_t result(aCoord->value);  // truncate towards zero
+  aCoord->value -= result;
+  return result;
+}
+
+/* static */ gfx::IntPoint PanGestureInput::GetIntegerDeltaForEvent(
+    bool aIsStart, float x, float y) {
+  static gfx::Point sAccumulator(0.0f, 0.0f);
+  if (aIsStart) {
+    sAccumulator = gfx::Point(0.0f, 0.0f);
+  }
+  sAccumulator.x += x;
+  sAccumulator.y += y;
+  return gfx::IntPoint(TakeLargestInt(&sAccumulator.x),
+                       TakeLargestInt(&sAccumulator.y));
+}
+
+PinchGestureInput::PinchGestureInput()
+    : InputData(PINCHGESTURE_INPUT),
+      mType(PINCHGESTURE_START),
+      mSource(UNKNOWN),
+      mHandledByAPZ(false) {}
+
+PinchGestureInput::PinchGestureInput(
+    PinchGestureType aType, PinchGestureSource aSource, TimeStamp aTimeStamp,
+    const ExternalPoint& aScreenOffset, const ScreenPoint& aFocusPoint,
+    ScreenCoord aCurrentSpan, ScreenCoord aPreviousSpan, Modifiers aModifiers)
+    : InputData(PINCHGESTURE_INPUT, aTimeStamp, aModifiers),
+      mType(aType),
+      mSource(aSource),
+      mFocusPoint(aFocusPoint),
+      mScreenOffset(aScreenOffset),
+      mCurrentSpan(aCurrentSpan),
+      mPreviousSpan(aPreviousSpan),
+      mLineOrPageDeltaY(0),
+      mHandledByAPZ(false) {}
+
+bool PinchGestureInput::TransformToLocal(
+    const ScreenToParentLayerMatrix4x4& aTransform) {
+  Maybe<ParentLayerPoint> point = UntransformBy(aTransform, mFocusPoint);
+  if (!point) {
+    return false;
+  }
+  mLocalFocusPoint = *point;
+  return true;
+}
+
+WidgetWheelEvent PinchGestureInput::ToWidgetEvent(nsIWidget* aWidget) const {
+  WidgetWheelEvent wheelEvent(true, eWheel, aWidget);
+  wheelEvent.mModifiers = this->modifiers | MODIFIER_CONTROL;
+  wheelEvent.mTimeStamp = mTimeStamp;
+  wheelEvent.mLayersId = mLayersId;
+  wheelEvent.mRefPoint = RoundedToInt(ViewAs<LayoutDevicePixel>(
+      mFocusPoint,
+      PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+  wheelEvent.mButtons = 0;
+  wheelEvent.mFlags.mHandledByAPZ = mHandledByAPZ;
+  wheelEvent.mDeltaMode = WheelEvent_Binding::DOM_DELTA_PIXEL;
+
+  wheelEvent.mDeltaY = ComputeDeltaY(aWidget);
+
+  wheelEvent.mLineOrPageDeltaY = mLineOrPageDeltaY;
+
+  MOZ_ASSERT(mType == PINCHGESTURE_END || wheelEvent.mDeltaY != 0.0);
+
+  return wheelEvent;
+}
+
+double PinchGestureInput::ComputeDeltaY(nsIWidget* aWidget) const {
+#if defined(OS_MACOSX)
+  // This converts the pinch gesture value to a fake wheel event that has the
+  // control key pressed so that pages can implement custom pinch gesture
+  // handling. It may seem strange that this doesn't use a wheel event with
+  // the deltaZ property set, but this matches Chrome's behavior as described
+  // at https://code.google.com/p/chromium/issues/detail?id=289887
+  //
+  // The intent of the formula below is to produce numbers similar to Chrome's
+  // implementation of this feature. Chrome implements deltaY using the formula
+  // "-100 * log(1 + [event magnification])" which is unfortunately incorrect.
+  // All deltas for a single pinch gesture should sum to 0 if the start and end
+  // of a pinch gesture end up in the same place. This doesn't happen in Chrome
+  // because they followed Apple's misleading documentation, which implies that
+  // "1 + [event magnification]" is the scale factor. The scale factor is
+  // instead "pow(ratio, [event magnification])" so "[event magnification]" is
+  // already in log space.
+  //
+  // The multiplication by the backing scale factor below counteracts the
+  // division by the backing scale factor in WheelEvent.
+
+  // We want to set deltaY to |-100.0 * M * GetDefaultScaleInternal()| where M
+  // is [event magnification] but [event magnification] is only available in the
+  // macOS widget code so we have to reverse engineer from mCurrentSpan and
+  // mPreviousSpan (which are derived from [event magnification]) to get it.
+  // Specifically, we know |mCurrentSpan == 100.0| and |mPreviousSpan == 100.0 *
+  // (1.0 - M)|. We can calculate deltaY by solving the mPreviousSpan equation
+  // for M in terms of mPreviousSpan and plugging that into to the formula for
+  // deltaY.
+  return (mPreviousSpan - 100.0) *
+         (aWidget ? aWidget->GetDefaultScaleInternal() : 1.f);
+#else
+  // This calculation is based on what the Windows and Linux widget code does.
+  // Specifically, it creates a PinchGestureInput with |mCurrentSpan == 100.0 *
+  // currentScale| and |mPreviousSpan == 100.0 * lastScale| where currentScale
+  // is the scale from the current OS event and lastScale is the scale when the
+  // previous OS event happened. On macOS [event magnification] is a relative
+  // change in scale factor, ie if the scale factor changed from 1 to 1.1 it
+  // will be 0.1, similarly if it changed from 1 to 0.9 it will be -0.1. To
+  // calculate the relative scale change on Windows we would calculate |M =
+  // currentScale - lastScale = (mCurrentSpan-mPreviousSpan)/100| and use the
+  // same formula as the macOS code
+  // (|-100.0 * M * GetDefaultScaleInternal()|).
+
+  return (mPreviousSpan - mCurrentSpan) *
+         (aWidget ? aWidget->GetDefaultScaleInternal() : 1.f);
+#endif
+}
+
+bool PinchGestureInput::SetLineOrPageDeltaY(nsIWidget* aWidget) {
+  double deltaY = ComputeDeltaY(aWidget);
+  if (deltaY == 0 && mType != PINCHGESTURE_END) {
+    return false;
+  }
+  gfx::IntPoint lineOrPageDelta = PinchGestureInput::GetIntegerDeltaForEvent(
+      (mType == PINCHGESTURE_START), 0, deltaY);
+  mLineOrPageDeltaY = lineOrPageDelta.y;
+  if (mLineOrPageDeltaY == 0) {
+    // For PINCHGESTURE_SCALE events, don't dispatch them. Note that the delta
+    // isn't lost; it remains in the accumulator in GetIntegerDeltaForEvent().
+    if (mType == PINCHGESTURE_SCALE) {
+      return false;
+    }
+    // On Windows, drop PINCHGESTURE_START as well (the Windows widget code will
+    // defer the START event until we accumulate enough delta).
+    // The Linux widget code doesn't support this, so instead set the event's
+    // mLineOrPageDeltaY to the smallest nonzero amount in the relevant
+    // direction.
+    if (mType == PINCHGESTURE_START) {
+#ifdef XP_WIN
+      return false;
+#else
+      mLineOrPageDeltaY = (deltaY >= 0) ? 1 : -1;
+#endif
+    }
+    // For PINCHGESTURE_END events, not dispatching a DOMMouseScroll for them is
+    // fine.
+  }
+  return true;
+}
+
+/* static */ gfx::IntPoint PinchGestureInput::GetIntegerDeltaForEvent(
+    bool aIsStart, float x, float y) {
+  static gfx::Point sAccumulator(0.0f, 0.0f);
+  if (aIsStart) {
+    sAccumulator = gfx::Point(0.0f, 0.0f);
+  }
+  sAccumulator.x += x;
+  sAccumulator.y += y;
+  return gfx::IntPoint(TakeLargestInt(&sAccumulator.x),
+                       TakeLargestInt(&sAccumulator.y));
+}
+
+TapGestureInput::TapGestureInput()
+    : InputData(TAPGESTURE_INPUT), mType(TAPGESTURE_LONG) {}
+
+TapGestureInput::TapGestureInput(TapGestureType aType, TimeStamp aTimeStamp,
+                                 const ScreenIntPoint& aPoint,
+                                 Modifiers aModifiers)
+    : InputData(TAPGESTURE_INPUT, aTimeStamp, aModifiers),
+      mType(aType),
+      mPoint(aPoint) {}
+
+TapGestureInput::TapGestureInput(TapGestureType aType, TimeStamp aTimeStamp,
+                                 const ParentLayerPoint& aLocalPoint,
+                                 Modifiers aModifiers)
+    : InputData(TAPGESTURE_INPUT, 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;
+}
+
+WidgetSimpleGestureEvent TapGestureInput::ToWidgetEvent(
+    nsIWidget* aWidget) const {
+  WidgetSimpleGestureEvent event(true, eTapGesture, aWidget);
+
+  event.mTimeStamp = mTimeStamp;
+  event.mLayersId = mLayersId;
+  event.mRefPoint = ViewAs<LayoutDevicePixel>(
+      mPoint,
+      PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent);
+  event.mButtons = 0;
+  event.mClickCount = 1;
+  event.mModifiers = modifiers;
+
+  return event;
+}
+
+ScrollWheelInput::ScrollWheelInput()
+    : InputData(SCROLLWHEEL_INPUT),
+      mDeltaType(SCROLLDELTA_LINE),
+      mScrollMode(SCROLLMODE_INSTANT),
+      mHandledByAPZ(false),
+      mDeltaX(0.0),
+      mDeltaY(0.0),
+      mLineOrPageDeltaX(0),
+      mLineOrPageDeltaY(0),
+      mScrollSeriesNumber(0),
+      mUserDeltaMultiplierX(1.0),
+      mUserDeltaMultiplierY(1.0),
+      mMayHaveMomentum(false),
+      mIsMomentum(false),
+      mAPZAction(APZWheelAction::Scroll) {}
+
+ScrollWheelInput::ScrollWheelInput(
+    TimeStamp aTimeStamp, Modifiers aModifiers, ScrollMode aScrollMode,
+    ScrollDeltaType aDeltaType, const ScreenPoint& aOrigin, double aDeltaX,
+    double aDeltaY, bool aAllowToOverrideSystemScrollSpeed,
+    WheelDeltaAdjustmentStrategy aWheelDeltaAdjustmentStrategy)
+    : InputData(SCROLLWHEEL_INPUT, 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),
+      mWheelDeltaAdjustmentStrategy(aWheelDeltaAdjustmentStrategy),
+      mAPZAction(APZWheelAction::Scroll) {}
+
+ScrollWheelInput::ScrollWheelInput(const WidgetWheelEvent& aWheelEvent)
+    : InputData(SCROLLWHEEL_INPUT, aWheelEvent.mTimeStamp,
+                aWheelEvent.mModifiers),
+      mDeltaType(DeltaTypeForDeltaMode(aWheelEvent.mDeltaMode)),
+      mScrollMode(SCROLLMODE_INSTANT),
+      mHandledByAPZ(aWheelEvent.mFlags.mHandledByAPZ),
+      mDeltaX(aWheelEvent.mDeltaX),
+      mDeltaY(aWheelEvent.mDeltaY),
+      mWheelTicksX(aWheelEvent.mWheelTicksX),
+      mWheelTicksY(aWheelEvent.mWheelTicksX),
+      mLineOrPageDeltaX(aWheelEvent.mLineOrPageDeltaX),
+      mLineOrPageDeltaY(aWheelEvent.mLineOrPageDeltaY),
+      mScrollSeriesNumber(0),
+      mUserDeltaMultiplierX(1.0),
+      mUserDeltaMultiplierY(1.0),
+      mMayHaveMomentum(aWheelEvent.mMayHaveMomentum),
+      mIsMomentum(aWheelEvent.mIsMomentum),
+      mAllowToOverrideSystemScrollSpeed(
+          aWheelEvent.mAllowToOverrideSystemScrollSpeed),
+      mWheelDeltaAdjustmentStrategy(WheelDeltaAdjustmentStrategy::eNone),
+      mAPZAction(APZWheelAction::Scroll) {
+  mOrigin = ScreenPoint(ViewAs<ScreenPixel>(
+      aWheelEvent.mRefPoint,
+      PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+}
+
+ScrollWheelInput::ScrollDeltaType ScrollWheelInput::DeltaTypeForDeltaMode(
+    uint32_t aDeltaMode) {
+  switch (aDeltaMode) {
+    case WheelEvent_Binding::DOM_DELTA_LINE:
+      return SCROLLDELTA_LINE;
+    case WheelEvent_Binding::DOM_DELTA_PAGE:
+      return SCROLLDELTA_PAGE;
+    case WheelEvent_Binding::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 WheelEvent_Binding::DOM_DELTA_LINE;
+    case ScrollWheelInput::SCROLLDELTA_PAGE:
+      return WheelEvent_Binding::DOM_DELTA_PAGE;
+    case ScrollWheelInput::SCROLLDELTA_PIXEL:
+    default:
+      return WheelEvent_Binding::DOM_DELTA_PIXEL;
+  }
+}
+
+ScrollUnit ScrollWheelInput::ScrollUnitForDeltaType(
+    ScrollDeltaType aDeltaType) {
+  switch (aDeltaType) {
+    case SCROLLDELTA_LINE:
+      return ScrollUnit::LINES;
+    case SCROLLDELTA_PAGE:
+      return ScrollUnit::PAGES;
+    case SCROLLDELTA_PIXEL:
+      return ScrollUnit::DEVICE_PIXELS;
+    default:
+      MOZ_CRASH();
+  }
+  return ScrollUnit::LINES;
+}
+
+WidgetWheelEvent ScrollWheelInput::ToWidgetEvent(nsIWidget* aWidget) const {
+  WidgetWheelEvent wheelEvent(true, eWheel, aWidget);
+  wheelEvent.mModifiers = this->modifiers;
+  wheelEvent.mTimeStamp = mTimeStamp;
+  wheelEvent.mLayersId = mLayersId;
+  wheelEvent.mRefPoint = RoundedToInt(ViewAs<LayoutDevicePixel>(
+      mOrigin,
+      PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+  wheelEvent.mButtons = 0;
+  wheelEvent.mDeltaMode = DeltaModeForDeltaType(mDeltaType);
+  wheelEvent.mMayHaveMomentum = mMayHaveMomentum;
+  wheelEvent.mIsMomentum = mIsMomentum;
+  wheelEvent.mDeltaX = mDeltaX;
+  wheelEvent.mDeltaY = mDeltaY;
+  wheelEvent.mWheelTicksX = mWheelTicksX;
+  wheelEvent.mWheelTicksY = mWheelTicksY;
+  wheelEvent.mLineOrPageDeltaX = mLineOrPageDeltaX;
+  wheelEvent.mLineOrPageDeltaY = mLineOrPageDeltaY;
+  wheelEvent.mAllowToOverrideSystemScrollSpeed =
+      mAllowToOverrideSystemScrollSpeed;
+  wheelEvent.mFlags.mHandledByAPZ = mHandledByAPZ;
+  wheelEvent.mFocusSequenceNumber = mFocusSequenceNumber;
+  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;
+}
+
+KeyboardInput::KeyboardInput(const WidgetKeyboardEvent& aEvent)
+    : InputData(KEYBOARD_INPUT, aEvent.mTimeStamp, aEvent.mModifiers),
+      mKeyCode(aEvent.mKeyCode),
+      mCharCode(aEvent.mCharCode),
+      mHandledByAPZ(false) {
+  switch (aEvent.mMessage) {
+    case eKeyPress: {
+      mType = KeyboardInput::KEY_PRESS;
+      break;
+    }
+    case eKeyUp: {
+      mType = KeyboardInput::KEY_UP;
+      break;
+    }
+    case eKeyDown: {
+      mType = KeyboardInput::KEY_DOWN;
+      break;
+    }
+    default:
+      mType = KeyboardInput::KEY_OTHER;
+      break;
+  }
+
+  aEvent.GetShortcutKeyCandidates(mShortcutCandidates);
+}
+
+KeyboardInput::KeyboardInput()
+    : InputData(KEYBOARD_INPUT),
+      mType(KEY_DOWN),
+      mKeyCode(0),
+      mCharCode(0),
+      mHandledByAPZ(false) {}
+
+}  // namespace mozilla