1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
10 #include "nsIScrollableFrame.h"
14 #include "mozilla/DefineEnum.h"
15 #include "mozilla/EventForwards.h"
16 #include "mozilla/TimeStamp.h"
17 #include "mozilla/WheelHandlingHelper.h" // for WheelDeltaAdjustmentStrategy
18 #include "mozilla/gfx/MatrixFwd.h"
19 #include "mozilla/layers/APZUtils.h"
20 #include "mozilla/layers/KeyboardScrollAction.h"
23 struct already_AddRefed
;
29 class APZInputBridgeChild
;
30 class PAPZInputBridgeParent
;
50 class MultiTouchInput
;
52 class PanGestureInput
;
53 class PinchGestureInput
;
54 class TapGestureInput
;
55 class ScrollWheelInput
;
58 // This looks unnecessary now, but as we add more and more classes that derive
59 // from InputType (eventually probably almost as many as *Events.h has), it
60 // will be more and more clear what's going on with a macro that shortens the
61 // definition of the RTTI functions.
62 #define INPUTDATA_AS_CHILD_TYPE(type, enumID) \
63 const type& As##type() const { \
64 MOZ_ASSERT(mInputType == enumID, "Invalid cast of InputData."); \
65 return (const type&)*this; \
68 MOZ_ASSERT(mInputType == enumID, "Invalid cast of InputData."); \
69 return (type&)*this; \
72 /** Base input data class. Should never be instantiated. */
75 // Warning, this class is serialized and sent over IPC. Any change to its
76 // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
78 // Time in milliseconds that this data is relevant to. This only really
79 // matters when this data is used as an event. We use uint32_t instead of
80 // TimeStamp because it is easier to convert from WidgetInputEvent. The time
81 // is platform-specific but it in the case of B2G and Fennec it is since
84 // Set in parallel to mTime until we determine it is safe to drop
85 // platform-specific event times (see bug 77992).
87 // The sequence number of the last potentially focus changing event handled
88 // by APZ. This is used to track when that event has been processed by
89 // content, and focus can be reconfirmed for async keyboard scrolling.
90 uint64_t mFocusSequenceNumber
;
92 // The LayersId of the content process that the corresponding WidgetEvent
93 // should be dispatched to.
94 layers::LayersId mLayersId
;
98 INPUTDATA_AS_CHILD_TYPE(MultiTouchInput
, MULTITOUCH_INPUT
)
99 INPUTDATA_AS_CHILD_TYPE(MouseInput
, MOUSE_INPUT
)
100 INPUTDATA_AS_CHILD_TYPE(PanGestureInput
, PANGESTURE_INPUT
)
101 INPUTDATA_AS_CHILD_TYPE(PinchGestureInput
, PINCHGESTURE_INPUT
)
102 INPUTDATA_AS_CHILD_TYPE(TapGestureInput
, TAPGESTURE_INPUT
)
103 INPUTDATA_AS_CHILD_TYPE(ScrollWheelInput
, SCROLLWHEEL_INPUT
)
104 INPUTDATA_AS_CHILD_TYPE(KeyboardInput
, KEYBOARD_INPUT
)
106 virtual ~InputData();
107 explicit InputData(InputType aInputType
);
110 InputData(InputType aInputType
, uint32_t aTime
, TimeStamp aTimeStamp
,
111 Modifiers aModifiers
);
115 * Data container for a single touch input. Similar to dom::Touch, but used in
116 * off-main-thread situations. This is more for just storing touch data, whereas
117 * dom::Touch is more useful for dispatching through the DOM (which can only
118 * happen on the main thread). dom::Touch also bears the problem of storing
119 * pointers to nsIWidget instances which can only be used on the main thread,
120 * so if instead we used dom::Touch and ever set these pointers
121 * off-main-thread, Bad Things Can Happen(tm).
123 * Note that this doesn't inherit from InputData because this itself is not an
124 * event. It is only a container/struct that should have any number of instances
125 * within a MultiTouchInput.
127 * fixme/bug 775746: Make dom::Touch inherit from this class.
129 class SingleTouchData
{
131 // Construct a SingleTouchData from a Screen point.
132 // mLocalScreenPoint remains (0,0) unless it's set later.
133 SingleTouchData(int32_t aIdentifier
, ScreenIntPoint aScreenPoint
,
134 ScreenSize aRadius
, float aRotationAngle
, float aForce
);
136 // Construct a SingleTouchData from a ParentLayer point.
137 // mScreenPoint remains (0,0) unless it's set later.
138 // Note: if APZ starts using the radius for anything, we should add a local
139 // version of that too, and have this constructor take it as a
141 SingleTouchData(int32_t aIdentifier
, ParentLayerPoint aLocalScreenPoint
,
142 ScreenSize aRadius
, float aRotationAngle
, float aForce
);
146 already_AddRefed
<dom::Touch
> ToNewDOMTouch() const;
148 // Warning, this class is serialized and sent over IPC. Any change to its
149 // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
151 // A unique number assigned to each SingleTouchData within a MultiTouchInput
152 // so that they can be easily distinguished when handling a touch
156 // Point on the screen that the touch hit, in device pixels. They are
157 // coordinates on the screen.
158 ScreenIntPoint mScreenPoint
;
160 // |mScreenPoint| transformed to the local coordinates of the APZC targeted
161 // by the hit. This is set and used by APZ.
162 ParentLayerPoint mLocalScreenPoint
;
164 // Radius that the touch covers, i.e. if you're using your thumb it will
165 // probably be larger than using your pinky, even with the same force.
166 // Radius can be different along x and y. For example, if you press down with
167 // your entire finger vertically, the y radius will be much larger than the x
171 float mRotationAngle
;
173 // How hard the screen is being pressed.
178 * Similar to WidgetTouchEvent, but for use off-main-thread. Also only stores a
179 * screen touch point instead of the many different coordinate spaces
180 * WidgetTouchEvent stores its touch point in. This includes a way to initialize
181 * itself from a WidgetTouchEvent by copying all relevant data over. Note that
182 * this copying from WidgetTouchEvent functionality can only be used on the main
185 * Stores an array of SingleTouchData.
187 class MultiTouchInput
: public InputData
{
190 MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
199 MultiTouchInput(MultiTouchType aType
, uint32_t aTime
, TimeStamp aTimeStamp
,
200 Modifiers aModifiers
);
202 MultiTouchInput(const MultiTouchInput
& aOther
);
203 explicit MultiTouchInput(const WidgetTouchEvent
& aTouchEvent
);
204 void Translate(const ScreenPoint
& aTranslation
);
206 WidgetTouchEvent
ToWidgetTouchEvent(nsIWidget
* aWidget
) const;
207 WidgetMouseEvent
ToWidgetMouseEvent(nsIWidget
* aWidget
) const;
209 // Return the index into mTouches of the SingleTouchData with the given
210 // identifier, or -1 if there is no such SingleTouchData.
211 int32_t IndexOfTouch(int32_t aTouchIdentifier
);
213 bool TransformToLocal(const ScreenToParentLayerMatrix4x4
& aTransform
);
215 // Warning, this class is serialized and sent over IPC. Any change to its
216 // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
217 MultiTouchType mType
;
218 nsTArray
<SingleTouchData
> mTouches
;
219 // The screen offset of the root widget. This can be changing along with
220 // the touch interaction, so we sstore it in the event.
221 ExternalPoint mScreenOffset
;
225 class MouseInput
: public InputData
{
227 friend mozilla::layers::APZInputBridgeChild
;
228 friend mozilla::layers::PAPZInputBridgeParent
;
234 MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
247 MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
256 MouseInput(MouseType aType
, ButtonType aButtonType
, uint16_t aInputSource
,
257 int16_t aButtons
, const ScreenPoint
& aPoint
, uint32_t aTime
,
258 TimeStamp aTimeStamp
, Modifiers aModifiers
);
259 explicit MouseInput(const WidgetMouseEventBase
& aMouseEvent
);
261 bool IsLeftButton() const;
263 bool TransformToLocal(const ScreenToParentLayerMatrix4x4
& aTransform
);
264 WidgetMouseEvent
ToWidgetMouseEvent(nsIWidget
* aWidget
) const;
266 // Warning, this class is serialized and sent over IPC. Any change to its
267 // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
269 ButtonType mButtonType
;
270 uint16_t mInputSource
;
273 ParentLayerPoint mLocalOrigin
;
278 * Encapsulation class for pan events, can be used off-main-thread.
279 * These events are currently only used for scrolling on desktop.
281 class PanGestureInput
: public InputData
{
283 friend mozilla::layers::APZInputBridgeChild
;
284 friend mozilla::layers::PAPZInputBridgeParent
;
290 MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
292 // MayStart: Dispatched before any actual panning has occurred but when a
293 // pan gesture is probably about to start, for example when the user
294 // starts touching the touchpad. Should interrupt any ongoing APZ
295 // animation and can be used to trigger scrollability indicators (e.g.
296 // flashing overlay scrollbars).
299 // Cancelled: Dispatched after MayStart when no pan gesture is going to
300 // happen after all, for example when the user lifts their fingers from a
301 // touchpad without having done any scrolling.
302 PANGESTURE_CANCELLED
,
304 // Start: A pan gesture is starting.
305 // For devices that do not support the MayStart event type, this event can
306 // be used to interrupt ongoing APZ animations.
309 // Pan: The actual pan motion by mPanDisplacement.
312 // End: The pan gesture has ended, for example because the user has lifted
313 // their fingers from a touchpad after scrolling.
314 // Any potential momentum events fire after this event.
317 // The following momentum event types are used in order to control the pan
318 // momentum animation. Using these instead of our own animation ensures
319 // that the animation curve is OS native and that the animation stops
320 // reliably if it is cancelled by the user.
322 // MomentumStart: Dispatched between the End event of the actual
323 // user-controlled pan, and the first MomentumPan event of the momentum
325 PANGESTURE_MOMENTUMSTART
,
327 // MomentumPan: The actual momentum motion by mPanDisplacement.
328 PANGESTURE_MOMENTUMPAN
,
330 // MomentumEnd: The momentum animation has ended, for example because the
331 // momentum velocity has gone below the stopping threshold, or because the
332 // user has stopped the animation by putting their fingers on a touchpad.
333 PANGESTURE_MOMENTUMEND
336 MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
338 // There are three kinds of scroll delta modes in Gecko: "page", "line"
339 // and "pixel". Touchpad pan gestures only support "page" and "pixel".
341 // NOTE: PANDELTA_PAGE currently replicates Gtk behavior
342 // (see AsyncPanZoomController::OnPan).
348 PanGestureInput(PanGestureType aType
, uint32_t aTime
, TimeStamp aTimeStamp
,
349 const ScreenPoint
& aPanStartPoint
,
350 const ScreenPoint
& aPanDisplacement
, Modifiers aModifiers
);
352 bool IsMomentum() const;
354 WidgetWheelEvent
ToWidgetWheelEvent(nsIWidget
* aWidget
) const;
356 bool TransformToLocal(const ScreenToParentLayerMatrix4x4
& aTransform
);
358 ScreenPoint
UserMultipliedPanDisplacement() const;
359 ParentLayerPoint
UserMultipliedLocalPanDisplacement() const;
361 // Warning, this class is serialized and sent over IPC. Any change to its
362 // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
363 PanGestureType mType
;
364 ScreenPoint mPanStartPoint
;
366 // The delta. This can be non-zero on any type of event.
367 ScreenPoint mPanDisplacement
;
369 // Versions of |mPanStartPoint| and |mPanDisplacement| in the local
370 // coordinates of the APZC receiving the pan. These are set and used by APZ.
371 ParentLayerPoint mLocalPanStartPoint
;
372 ParentLayerPoint mLocalPanDisplacement
;
374 // See lineOrPageDeltaX/Y on WidgetWheelEvent.
375 int32_t mLineOrPageDeltaX
;
376 int32_t mLineOrPageDeltaY
;
378 // User-set delta multipliers.
379 double mUserDeltaMultiplierX
;
380 double mUserDeltaMultiplierY
;
382 PanDeltaType mDeltaType
= PANDELTA_PIXEL
;
384 bool mHandledByAPZ
: 1;
386 // true if this is a PANGESTURE_END event that will be followed by a
387 // PANGESTURE_MOMENTUMSTART event.
388 bool mFollowedByMomentum
: 1;
390 // If this is true, and this event started a new input block that couldn't
391 // find a scrollable target which is scrollable in the horizontal component
392 // of the scroll start direction, then this input block needs to be put on
393 // hold until a content response has arrived, even if the block has a
395 // This is used by events that can result in a swipe instead of a scroll.
396 bool mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection
: 1;
398 // This is used by APZ to communicate to the macOS widget code whether
399 // the overscroll-behavior of the scroll frame handling this swipe allows
400 // non-local overscroll behaviors in the horizontal direction (such as
401 // swipe navigation).
402 bool mOverscrollBehaviorAllowsSwipe
: 1;
404 // true if APZ should do a fling animation after this pan ends, like
405 // it would with touchscreens. (For platforms that don't emit momentum
407 bool mSimulateMomentum
: 1;
409 void SetHandledByAPZ(bool aHandled
) { mHandledByAPZ
= aHandled
; }
410 void SetFollowedByMomentum(bool aFollowed
) {
411 mFollowedByMomentum
= aFollowed
;
413 void SetRequiresContentResponseIfCannotScrollHorizontallyInStartDirection(
415 mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection
=
418 void SetOverscrollBehaviorAllowsSwipe(bool aAllows
) {
419 mOverscrollBehaviorAllowsSwipe
= aAllows
;
421 void SetSimulateMomentum(bool aSimulate
) { mSimulateMomentum
= aSimulate
; }
425 * Encapsulation class for pinch events. In general, these will be generated by
426 * a gesture listener by looking at SingleTouchData/MultiTouchInput instances
427 * and determining whether or not the user was trying to do a gesture.
429 class PinchGestureInput
: public InputData
{
431 friend mozilla::layers::APZInputBridgeChild
;
432 friend mozilla::layers::PAPZInputBridgeParent
;
438 MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
446 // Construct a pinch gesture from a Screen point.
447 PinchGestureInput(PinchGestureType aType
, uint32_t aTime
,
448 TimeStamp aTimeStamp
, const ExternalPoint
& aScreenOffset
,
449 const ScreenPoint
& aFocusPoint
, ScreenCoord aCurrentSpan
,
450 ScreenCoord aPreviousSpan
, Modifiers aModifiers
);
452 bool TransformToLocal(const ScreenToParentLayerMatrix4x4
& aTransform
);
454 // Warning, this class is serialized and sent over IPC. Any change to its
455 // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
456 PinchGestureType mType
;
458 // Center point of the pinch gesture. That is, if there are two fingers on the
459 // screen, it is their midpoint. In the case of more than two fingers, the
460 // point is implementation-specific, but can for example be the midpoint
461 // between the very first and very last touch. This is in device pixels and
462 // are the coordinates on the screen of this midpoint.
463 // For PINCHGESTURE_END events, this instead will hold the coordinates of
464 // the remaining finger, if there is one. If there isn't one then it will
465 // store |BothFingersLifted()|.
466 ScreenPoint mFocusPoint
;
468 // The screen offset of the root widget. This can be changing along with
469 // the touch interaction, so we sstore it in the event.
470 ExternalPoint mScreenOffset
;
472 // |mFocusPoint| transformed to the local coordinates of the APZC targeted
473 // by the hit. This is set and used by APZ.
474 ParentLayerPoint mLocalFocusPoint
;
476 // The distance between the touches responsible for the pinch gesture.
477 ScreenCoord mCurrentSpan
;
479 // The previous |mCurrentSpan| in the PinchGestureInput preceding this one.
480 // This is only really relevant during a PINCHGESTURE_SCALE because when it is
481 // of this type then there must have been a history of spans.
482 ScreenCoord mPreviousSpan
;
484 // A special value for mFocusPoint used in PINCHGESTURE_END events to
485 // indicate that both fingers have been lifted. If only one finger has
486 // been lifted, the coordinates of the remaining finger are expected to
487 // be stored in mFocusPoint.
488 // For pinch events that were not triggered by touch gestures, the
489 // value of mFocusPoint in a PINCHGESTURE_END event is always expected
491 // For convenience, we allow retrieving this value in any coordinate system.
492 // Since it's a special value, no conversion is needed.
493 template <typename Units
= ParentLayerPixel
>
494 static gfx::PointTyped
<Units
> BothFingersLifted() {
495 return gfx::PointTyped
<Units
>{-1, -1};
500 * Encapsulation class for tap events. In general, these will be generated by
501 * a gesture listener by looking at SingleTouchData/MultiTouchInput instances
502 * and determining whether or not the user was trying to do a gesture.
504 class TapGestureInput
: public InputData
{
506 friend mozilla::layers::APZInputBridgeChild
;
507 friend mozilla::layers::PAPZInputBridgeParent
;
513 MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
518 TAPGESTURE_CONFIRMED
,
520 TAPGESTURE_SECOND
, // See GeckoContentController::TapType::eSecondTap
525 // Construct a tap gesture from a Screen point.
526 // mLocalPoint remains (0,0) unless it's set later.
527 TapGestureInput(TapGestureType aType
, uint32_t aTime
, TimeStamp aTimeStamp
,
528 const ScreenIntPoint
& aPoint
, Modifiers aModifiers
);
530 // Construct a tap gesture from a ParentLayer point.
531 // mPoint remains (0,0) unless it's set later.
532 TapGestureInput(TapGestureType aType
, uint32_t aTime
, TimeStamp aTimeStamp
,
533 const ParentLayerPoint
& aLocalPoint
, Modifiers aModifiers
);
535 bool TransformToLocal(const ScreenToParentLayerMatrix4x4
& aTransform
);
537 // Warning, this class is serialized and sent over IPC. Any change to its
538 // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
539 TapGestureType mType
;
541 // The location of the tap in screen pixels.
542 ScreenIntPoint mPoint
;
544 // The location of the tap in the local coordinates of the APZC receiving it.
545 // This is set and used by APZ.
546 ParentLayerPoint mLocalPoint
;
549 // Encapsulation class for scroll-wheel events. These are generated by mice
550 // with physical scroll wheels, and on Windows by most touchpads when using
552 class ScrollWheelInput
: public InputData
{
554 friend mozilla::layers::APZInputBridgeChild
;
555 friend mozilla::layers::PAPZInputBridgeParent
;
557 typedef mozilla::layers::APZWheelAction APZWheelAction
;
563 MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
565 // There are three kinds of scroll delta modes in Gecko: "page", "line"
572 MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
580 ScrollWheelInput(uint32_t aTime
, TimeStamp aTimeStamp
, Modifiers aModifiers
,
581 ScrollMode aScrollMode
, ScrollDeltaType aDeltaType
,
582 const ScreenPoint
& aOrigin
, double aDeltaX
, double aDeltaY
,
583 bool aAllowToOverrideSystemScrollSpeed
,
584 WheelDeltaAdjustmentStrategy aWheelDeltaAdjustmentStrategy
);
585 explicit ScrollWheelInput(const WidgetWheelEvent
& aEvent
);
587 static ScrollDeltaType
DeltaTypeForDeltaMode(uint32_t aDeltaMode
);
588 static uint32_t DeltaModeForDeltaType(ScrollDeltaType aDeltaType
);
589 static nsIScrollableFrame::ScrollUnit
ScrollUnitForDeltaType(
590 ScrollDeltaType aDeltaType
);
592 WidgetWheelEvent
ToWidgetWheelEvent(nsIWidget
* aWidget
) const;
593 bool TransformToLocal(const ScreenToParentLayerMatrix4x4
& aTransform
);
595 bool IsCustomizedByUserPrefs() const;
597 // The following two functions are for auto-dir scrolling. For detailed
598 // information on auto-dir, @see mozilla::WheelDeltaAdjustmentStrategy
599 bool IsAutoDir() const {
600 switch (mWheelDeltaAdjustmentStrategy
) {
601 case WheelDeltaAdjustmentStrategy::eAutoDir
:
602 case WheelDeltaAdjustmentStrategy::eAutoDirWithRootHonour
:
605 // Prevent compilation errors generated by -Werror=switch
610 // Indicates which element this scroll honours if it's an auto-dir scroll.
611 // If true, honour the root element; otherwise, honour the currently scrolling
613 // Note that if IsAutoDir() returns false, then this function also returns
614 // false, but false in this case is meaningless as IsAutoDir() indicates it's
615 // not an auto-dir scroll.
616 // For detailed information on auto-dir,
617 // @see mozilla::WheelDeltaAdjustmentStrategy
618 bool HonoursRoot() const {
619 return WheelDeltaAdjustmentStrategy::eAutoDirWithRootHonour
==
620 mWheelDeltaAdjustmentStrategy
;
623 // Warning, this class is serialized and sent over IPC. Any change to its
624 // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
625 ScrollDeltaType mDeltaType
;
626 ScrollMode mScrollMode
;
631 // Deltas are in units corresponding to the delta type. For line deltas, they
632 // are the number of line units to scroll. The number of device pixels for a
633 // horizontal and vertical line unit are in FrameMetrics::mLineScrollAmount.
634 // For pixel deltas, these values are in ScreenCoords.
636 // The horizontal (X) delta is > 0 for scrolling right and < 0 for scrolling
637 // left. The vertical (Y) delta is < 0 for scrolling up and > 0 for
642 // The location of the scroll in local coordinates. This is set and used by
644 ParentLayerPoint mLocalOrigin
;
646 // See lineOrPageDeltaX/Y on WidgetWheelEvent.
647 int32_t mLineOrPageDeltaX
;
648 int32_t mLineOrPageDeltaY
;
650 // Indicates the order in which this event was added to a transaction. The
651 // first event is 1; if not a member of a transaction, this is 0.
652 uint32_t mScrollSeriesNumber
;
654 // User-set delta multipliers.
655 double mUserDeltaMultiplierX
;
656 double mUserDeltaMultiplierY
;
658 bool mMayHaveMomentum
;
660 bool mAllowToOverrideSystemScrollSpeed
;
662 // Sometimes a wheel event input's wheel delta should be adjusted. This member
663 // specifies how to adjust the wheel delta.
664 WheelDeltaAdjustmentStrategy mWheelDeltaAdjustmentStrategy
;
666 APZWheelAction mAPZAction
;
669 class KeyboardInput
: public InputData
{
671 typedef mozilla::layers::KeyboardScrollAction KeyboardScrollAction
;
673 // Note that if you change the first member in this enum(I.e. KEY_DOWN) to one
674 // other member, don't forget to update the minimum value in
675 // ContiguousEnumSerializer for KeyboardEventType in widget/nsGUIEventIPC
677 enum KeyboardEventType
{
681 // Any other key event such as eKeyDownOnPlugin
684 // Used as an upper bound for ContiguousEnumSerializer
688 explicit KeyboardInput(const WidgetKeyboardEvent
& aEvent
);
690 // Warning, this class is serialized and sent over IPC. Any change to its
691 // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
693 KeyboardEventType mType
;
696 nsTArray
<ShortcutKeyCandidate
> mShortcutCandidates
;
700 // The scroll action to perform on a layer for this keyboard input. This is
701 // only used in APZ and is NOT serialized over IPC.
702 KeyboardScrollAction mAction
;
705 friend mozilla::layers::APZInputBridgeChild
;
706 friend mozilla::layers::PAPZInputBridgeParent
;
711 } // namespace mozilla
713 #endif // InputData_h__