Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 1335 insertions, 0 deletions

diff --git a/dom/events/EventStateManager.h b/dom/events/EventStateManager.h
new file mode 100644
index 0000000000..b3bb3b5170
--- /dev/null
+++ b/dom/events/EventStateManager.h
@@ -0,0 +1,1335 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_EventStateManager_h_
+#define mozilla_EventStateManager_h_
+
+#include "mozilla/EventForwards.h"
+
+#include "nsIObserver.h"
+#include "nsWeakReference.h"
+#include "nsCOMPtr.h"
+#include "nsCOMArray.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsRefPtrHashtable.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/layers/APZPublicUtils.h"
+#include "mozilla/dom/Record.h"
+#include "Units.h"
+#include "WheelHandlingHelper.h"  // for WheelDeltaAdjustmentStrategy
+
+class nsFrameLoader;
+class nsIContent;
+class nsICookieJarSettings;
+class nsIDocShell;
+class nsIDocShellTreeItem;
+class nsIFrame;
+class imgIContainer;
+class nsIDocumentViewer;
+class nsIScrollableFrame;
+class nsITimer;
+class nsPresContext;
+
+enum class FormControlType : uint8_t;
+
+namespace mozilla {
+
+class EditorBase;
+class EnterLeaveDispatcher;
+class IMEContentObserver;
+class ScrollbarsForWheel;
+class TextControlElement;
+class WheelTransaction;
+
+namespace dom {
+class DataTransfer;
+class Document;
+class Element;
+class Selection;
+class BrowserParent;
+class RemoteDragStartData;
+
+}  // namespace dom
+
+class OverOutElementsWrapper final : public nsISupports {
+  ~OverOutElementsWrapper();
+
+ public:
+  OverOutElementsWrapper();
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS(OverOutElementsWrapper)
+
+  void ContentRemoved(nsIContent& aContent);
+  void WillDispatchOverAndEnterEvent(nsIContent* aOverEventTarget) {
+    mDeepestEnterEventTarget = aOverEventTarget;
+    // Store the first "over" event target we fire and don't refire "over" event
+    // to that element while the first "over" event is still ongoing.
+    mDispatchingOverEventTarget = aOverEventTarget;
+    mDeepestEnterEventTargetIsOverEventTarget = true;
+  }
+  void DidDispatchOverAndEnterEvent() { mDispatchingOverEventTarget = nullptr; }
+  [[nodiscard]] bool IsDispatchingOverEventOn(
+      nsIContent* aOverEventTarget) const {
+    MOZ_ASSERT(aOverEventTarget);
+    return mDeepestEnterEventTargetIsOverEventTarget &&
+           mDeepestEnterEventTarget == aOverEventTarget;
+  }
+  void WillDispatchOutAndOrLeaveEvent() {
+    // Store the first "out" event target or the deepest "leave" event target
+    // which we fire and don't refire "out" event to that element while the
+    // first "out" event is still ongoing.
+    mDispatchingOutOrDeepestLeaveEventTarget = mDeepestEnterEventTarget;
+  }
+  void DidDispatchOutAndOrLeaveEvent() {
+    mLastOverFrame = nullptr;
+    mDeepestEnterEventTarget = mDispatchingOutOrDeepestLeaveEventTarget =
+        nullptr;
+  }
+  [[nodiscard]] bool IsDispatchingOutEventOnLastOverEventTarget() const {
+    return mDispatchingOutOrDeepestLeaveEventTarget &&
+           mDispatchingOutOrDeepestLeaveEventTarget == mDeepestEnterEventTarget;
+  }
+  void OverrideOverEventTarget(nsIContent* aOverEventTarget) {
+    mDeepestEnterEventTarget = aOverEventTarget;
+    mDeepestEnterEventTargetIsOverEventTarget = true;
+  }
+
+  [[nodiscard]] nsIContent* GetDeepestLeaveEventTarget() const {
+    // The last deepest "enter" event targe (it may be same as the last "over"
+    // target) is the deepest "leave" event target.
+    return mDeepestEnterEventTarget;
+  }
+  [[nodiscard]] nsIContent* GetOutEventTarget() const {
+    // The last deepest "enter" event target is same as the "over" event target
+    // unless it's never been removed from the DOM tree.  If and only if the
+    // last "over" event target has not been removed from the DOM tree, it's
+    // the next "out" event target.  Once the last "over" target is removed,
+    // "out" event should not be fired on the target nor its ancestor.
+    return mDeepestEnterEventTargetIsOverEventTarget
+               ? mDeepestEnterEventTarget.get()
+               : nullptr;
+  }
+
+ public:
+  WeakFrame mLastOverFrame;
+
+ private:
+  // The deepest event target of the last "enter" event.  If
+  // mDeepestEnterEventTargetIsOverEventTarget is true, this is the last "over"
+  // event target too.  If it's set to false, this is an ancestor of the last
+  // "over" event target which has not been removed from the DOM tree.
+  nsCOMPtr<nsIContent> mDeepestEnterEventTarget;
+
+  // While we're dispatching "over" and "enter" events, this is set to the
+  // "over" event target.  If it's removed from the DOM tree, this is set to
+  // nullptr.
+  nsCOMPtr<nsIContent> mDispatchingOverEventTarget;
+
+  // While we're dispatching "out" and/or "leave" events, this is set to the
+  // "out" event target or the deepest leave event target.  If it's removed from
+  // the DOM tree, this is set to nullptr.
+  nsCOMPtr<nsIContent> mDispatchingOutOrDeepestLeaveEventTarget;
+
+  // Once the last "over" element is removed from the tree, this is set
+  // to false.  Then, mDeepestEnterEventTarget may be an ancestor of the
+  // "over" element which should be the deepest target of next "leave"
+  // element but shouldn't be target of "out" event.
+  bool mDeepestEnterEventTargetIsOverEventTarget = true;
+};
+
+class EventStateManager : public nsSupportsWeakReference, public nsIObserver {
+  friend class mozilla::EnterLeaveDispatcher;
+  friend class mozilla::ScrollbarsForWheel;
+  friend class mozilla::WheelTransaction;
+
+  using ElementState = dom::ElementState;
+
+  virtual ~EventStateManager();
+
+ public:
+  EventStateManager();
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+
+  nsresult Init();
+  nsresult Shutdown();
+
+  /* The PreHandleEvent method is called before event dispatch to either
+   * the DOM or frames.  Any processing which must not be prevented or
+   * cancelled should occur here.  Any processing which is intended to
+   * be conditional based on either DOM or frame processing should occur in
+   * PostHandleEvent.  Any centralized event processing which must occur before
+   * DOM or frame event handling should occur here as well.
+   *
+   * aOverrideClickTarget can be used to indicate which element should be
+   * used as the *up target when deciding whether to send click event.
+   * This is used when releasing pointer capture. Otherwise null.
+   */
+  MOZ_CAN_RUN_SCRIPT
+  nsresult PreHandleEvent(nsPresContext* aPresContext, WidgetEvent* aEvent,
+                          nsIFrame* aTargetFrame, nsIContent* aTargetContent,
+                          nsEventStatus* aStatus,
+                          nsIContent* aOverrideClickTarget);
+
+  /* The PostHandleEvent method should contain all system processing which
+   * should occur conditionally based on DOM or frame processing.  It should
+   * also contain any centralized event processing which must occur after
+   * DOM and frame processing.
+   */
+  MOZ_CAN_RUN_SCRIPT
+  nsresult PostHandleEvent(nsPresContext* aPresContext, WidgetEvent* aEvent,
+                           nsIFrame* aTargetFrame, nsEventStatus* aStatus,
+                           nsIContent* aOverrideClickTarget);
+
+  MOZ_CAN_RUN_SCRIPT void PostHandleKeyboardEvent(
+      WidgetKeyboardEvent* aKeyboardEvent, nsIFrame* aTargetFrame,
+      nsEventStatus& aStatus);
+
+  /**
+   * DispatchLegacyMouseScrollEvents() dispatches eLegacyMouseLineOrPageScroll
+   * event and eLegacyMousePixelScroll event for compatibility with old Gecko.
+   */
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY void DispatchLegacyMouseScrollEvents(
+      nsIFrame* aTargetFrame, WidgetWheelEvent* aEvent, nsEventStatus* aStatus);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY void NotifyDestroyPresContext(
+      nsPresContext* aPresContext);
+
+  void ResetHoverState();
+
+  void SetPresContext(nsPresContext* aPresContext);
+  void ClearFrameRefs(nsIFrame* aFrame);
+
+  nsIFrame* GetEventTarget();
+  already_AddRefed<nsIContent> GetEventTargetContent(WidgetEvent* aEvent);
+
+  // We manage 4 states here: ACTIVE, HOVER, DRAGOVER, URLTARGET
+  static bool ManagesState(ElementState aState) {
+    return aState == ElementState::ACTIVE || aState == ElementState::HOVER ||
+           aState == ElementState::DRAGOVER ||
+           aState == ElementState::URLTARGET;
+  }
+
+  /**
+   * Notify that the given ElementState::* bit has changed for this content.
+   * @param aContent Content which has changed states
+   * @param aState   Corresponding state flags such as ElementState::FOCUS
+   * @return  Whether the content was able to change all states. Returns false
+   *                  if a resulting DOM event causes the content node passed in
+   *                  to not change states. Note, the frame for the content may
+   *                  change as a result of the content state change, because of
+   *                  frame reconstructions that may occur, but this does not
+   *                  affect the return value.
+   */
+  bool SetContentState(nsIContent* aContent, ElementState aState);
+
+  nsIContent* GetActiveContent() const { return mActiveContent; }
+
+  void NativeAnonymousContentRemoved(nsIContent* aAnonContent);
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY void ContentRemoved(dom::Document* aDocument,
+                                                  nsIContent* aContent);
+
+  /**
+   * Called when a native anonymous <div> element which is root element of
+   * text editor will be removed.
+   */
+  void TextControlRootWillBeRemoved(TextControlElement& aTextControlElement);
+
+  /**
+   * Called when a native anonymous <div> element which is root element of
+   * text editor is created.
+   */
+  void TextControlRootAdded(dom::Element& aAnonymousDivElement,
+                            TextControlElement& aTextControlElement);
+
+  bool EventStatusOK(WidgetGUIEvent* aEvent);
+
+  /**
+   * EventStateManager stores IMEContentObserver while it's observing contents.
+   * Following mehtods are called by IMEContentObserver when it starts to
+   * observe or stops observing the content.
+   */
+  void OnStartToObserveContent(IMEContentObserver* aIMEContentObserver);
+  void OnStopObservingContent(IMEContentObserver* aIMEContentObserver);
+
+  /**
+   * TryToFlushPendingNotificationsToIME() suggests flushing pending
+   * notifications to IME to IMEContentObserver.
+   * Doesn't do anything in child processes where flushing happens
+   * asynchronously.
+   */
+  void TryToFlushPendingNotificationsToIME();
+
+  static bool IsKeyboardEventUserActivity(WidgetEvent* aEvent);
+
+  /**
+   * Register accesskey on the given element. When accesskey is activated then
+   * the element will be notified via Element::PerformAccesskey() method.
+   *
+   * @param  aElement  the given element
+   * @param  aKey      accesskey
+   */
+  void RegisterAccessKey(dom::Element* aElement, uint32_t aKey);
+
+  /**
+   * Unregister accesskey for the given element.
+   *
+   * @param  aElement  the given element
+   * @param  aKey      accesskey
+   */
+  void UnregisterAccessKey(dom::Element* aElement, uint32_t aKey);
+
+  /**
+   * Get accesskey registered on the given element or 0 if there is none.
+   *
+   * @param  aElement  the given element (must not be null)
+   * @return           registered accesskey
+   */
+  uint32_t GetRegisteredAccessKey(dom::Element* aContent);
+
+  static void GetAccessKeyLabelPrefix(dom::Element* aElement,
+                                      nsAString& aPrefix);
+
+  /**
+   * HandleAccessKey() looks for access keys which matches with aEvent and
+   * execute when it matches with a chrome access key or some content access
+   * keys.
+   * If the event may match chrome access keys, this handles the access key
+   * synchronously (if there are nested ESMs, their HandleAccessKey() are
+   * also called recursively).
+   * If the event may match content access keys and focused target is a remote
+   * process, this does nothing for the content because when this is called,
+   * it should already have been handled in the remote process.
+   * If the event may match content access keys and focused target is not in
+   * remote process but there are some remote children, this will post
+   * HandleAccessKey messages to all remote children.
+   *
+   * @return            true if there is accesskey which aEvent and
+   *                    aAccessCharCodes match with.  Otherwise, false.
+   *                    I.e., when this returns true, a target is executed
+   *                    or focused.
+   *                    Note that even if this returns false, a target in
+   *                    remote process may be executed or focused
+   *                    asynchronously.
+   */
+  bool HandleAccessKey(WidgetKeyboardEvent* aEvent, nsPresContext* aPresContext,
+                       nsTArray<uint32_t>& aAccessCharCodes) {
+    return WalkESMTreeToHandleAccessKey(aEvent, aPresContext, aAccessCharCodes,
+                                        nullptr, eAccessKeyProcessingNormal,
+                                        true);
+  }
+
+  /**
+   * CheckIfEventMatchesAccessKey() looks for access key which matches with
+   * aEvent in the process but won't execute it.
+   *
+   * @return            true if there is accesskey which aEvent matches with
+   *                    in this process.  Otherwise, false.
+   */
+  bool CheckIfEventMatchesAccessKey(WidgetKeyboardEvent* aEvent,
+                                    nsPresContext* aPresContext);
+
+  nsresult SetCursor(StyleCursorKind, imgIContainer*, const ImageResolution&,
+                     const Maybe<gfx::IntPoint>& aHotspot, nsIWidget* aWidget,
+                     bool aLockCursor);
+
+  void StartHidingCursorWhileTyping(nsIWidget*);
+
+  /**
+   * Checks if the current mouse over element matches the given
+   * Element (which has a remote frame), and if so, notifies
+   * the BrowserParent of the mouse enter.
+   * Called when we reconstruct the BrowserParent and need to
+   * recompute state on the new object.
+   */
+  void RecomputeMouseEnterStateForRemoteFrame(dom::Element& aElement);
+
+  nsPresContext* GetPresContext() { return mPresContext; }
+
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(EventStateManager, nsIObserver)
+
+  // The manager in this process that is setting the cursor. In the parent
+  // process it might be null if a remote process is setting the cursor.
+  static EventStateManager* sCursorSettingManager;
+  static void ClearCursorSettingManager() { sCursorSettingManager = nullptr; }
+
+  static EventStateManager* GetActiveEventStateManager() { return sActiveESM; }
+
+  // Sets aNewESM to be the active event state manager, and
+  // if aContent is non-null, marks the object as active.
+  static void SetActiveManager(EventStateManager* aNewESM,
+                               nsIContent* aContent);
+
+  static bool IsRemoteTarget(nsIContent* target);
+
+  static bool IsTopLevelRemoteTarget(nsIContent* aTarget);
+
+  // Returns the kind of APZ action the given WidgetWheelEvent will perform.
+  static Maybe<layers::APZWheelAction> APZWheelActionFor(
+      const WidgetWheelEvent* aEvent);
+
+  // For some kinds of scrollings, the delta values of WidgetWheelEvent are
+  // possbile to be adjusted. This function is used to detect such scrollings
+  // and returns a wheel delta adjustment strategy to use, which is corresponded
+  // to the kind of the scrolling.
+  // It returns WheelDeltaAdjustmentStrategy::eAutoDir if the current default
+  // action is auto-dir scrolling which honours the scrolling target(The
+  // comments in WheelDeltaAdjustmentStrategy describes the concept in detail).
+  // It returns WheelDeltaAdjustmentStrategy::eAutoDirWithRootHonour if the
+  // current action is auto-dir scrolling which honours the root element in the
+  // document where the scrolling target is(The comments in
+  // WheelDeltaAdjustmentStrategy describes the concept in detail).
+  // It returns WheelDeltaAdjustmentStrategy::eHorizontalize if the current
+  // default action is horizontalized scrolling.
+  // It returns WheelDeltaAdjustmentStrategy::eNone to mean no delta adjustment
+  // strategy should be used if the scrolling is just a tranditional scrolling
+  // whose delta values are never possible to be adjusted.
+  static WheelDeltaAdjustmentStrategy GetWheelDeltaAdjustmentStrategy(
+      const WidgetWheelEvent& aEvent);
+
+  // Returns user-set multipliers for a wheel event.
+  static void GetUserPrefsForWheelEvent(const WidgetWheelEvent* aEvent,
+                                        double* aOutMultiplierX,
+                                        double* aOutMultiplierY);
+
+  // Holds the point in screen coords that a mouse event was dispatched to,
+  // before we went into pointer lock mode. This is constantly updated while
+  // the pointer is not locked, but we don't update it while the pointer is
+  // locked. This is used by dom::Event::GetScreenCoords() to make mouse
+  // events' screen coord appear frozen at the last mouse position while
+  // the pointer is locked.
+  static CSSIntPoint sLastScreenPoint;
+
+  // Holds the point in client coords of the last mouse event. Used by
+  // dom::Event::GetClientCoords() to make mouse events' client coords appear
+  // frozen at the last mouse position while the pointer is locked.
+  static CSSIntPoint sLastClientPoint;
+
+  /**
+   * If the absolute values of mMultiplierX and/or mMultiplierY are equal or
+   * larger than this value, the computed scroll amount isn't rounded down to
+   * the page width or height.
+   */
+  static constexpr double MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL =
+      1000.0;
+
+  /**
+   * HandleMiddleClickPaste() handles middle mouse button event as pasting
+   * clipboard text.  Note that if aEditorBase is nullptr, this only
+   * dispatches ePaste event because it's necessary for some web apps which
+   * want to implement their own editor and supports middle click paste.
+   *
+   * @param aPresShell              The PresShell for the ESM.  This lifetime
+   *                                should be guaranteed by the caller.
+   * @param aMouseEvent             The eMouseClick event which caused the
+   *                                paste.
+   * @param aStatus                 The event status of aMouseEvent.
+   * @param aEditorBase             EditorBase which may be pasted the
+   *                                clipboard text by the middle click.
+   *                                If there is no editor for aMouseEvent,
+   *                                set nullptr.
+   */
+  MOZ_CAN_RUN_SCRIPT
+  nsresult HandleMiddleClickPaste(PresShell* aPresShell,
+                                  WidgetMouseEvent* aMouseEvent,
+                                  nsEventStatus* aStatus,
+                                  EditorBase* aEditorBase);
+
+  static void ConsumeInteractionData(
+      dom::Record<nsString, dom::InteractionData>& aInteractions);
+
+  // Stop tracking a possible drag. If aClearInChildProcesses is true, send
+  // a notification to any child processes that are in the drag service that
+  // tried to start a drag.
+  void StopTrackingDragGesture(bool aClearInChildProcesses);
+
+ protected:
+  /*
+   * If aTargetFrame's widget has a cached cursor value, resets the cursor
+   * such that the next call to SetCursor on the widget will force an update
+   * of the native cursor. For use in getting puppet widget to update its
+   * cursor between mouse exit / enter transitions. This call basically wraps
+   * nsIWidget ClearCachedCursor.
+   */
+  void ClearCachedWidgetCursor(nsIFrame* aTargetFrame);
+
+  void UpdateCursor(nsPresContext*, WidgetMouseEvent*, nsIFrame* aTargetFrame,
+                    nsEventStatus* aStatus);
+  /**
+   * Turn a GUI mouse/pointer event into a mouse/pointer event targeted at the
+   * specified content.  This returns the primary frame for the content (or null
+   * if it goes away during the event).
+   */
+  MOZ_CAN_RUN_SCRIPT nsIFrame* DispatchMouseOrPointerEvent(
+      WidgetMouseEvent* aMouseEvent, EventMessage aMessage,
+      nsIContent* aTargetContent, nsIContent* aRelatedContent);
+  /**
+   * Synthesize DOM pointerover and pointerout events
+   */
+  void GeneratePointerEnterExit(EventMessage aMessage,
+                                WidgetMouseEvent* aEvent);
+  /**
+   * Synthesize DOM and frame mouseover and mouseout events from this
+   * MOUSE_MOVE or MOUSE_EXIT event.
+   */
+  void GenerateMouseEnterExit(WidgetMouseEvent* aMouseEvent);
+  /**
+   * Tell this ESM and ESMs in parent documents that the mouse is
+   * over some content in this document.
+   */
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY void NotifyMouseOver(
+      WidgetMouseEvent* aMouseEvent, nsIContent* aContent);
+  /**
+   * Tell this ESM and ESMs in affected child documents that the mouse
+   * has exited this document's currently hovered content.
+   * TODO: Convert this to MOZ_CAN_RUN_SCRIPT (bug 1415230)
+   *
+   * @param aMouseEvent the event that triggered the mouseout
+   * @param aMovingInto the content node we've moved into.  This is used to set
+   *        the relatedTarget for mouseout events.  Also, if it's non-null
+   *        NotifyMouseOut will NOT change the current hover content to null;
+   *        in that case the caller is responsible for updating hover state.
+   */
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY void NotifyMouseOut(WidgetMouseEvent* aMouseEvent,
+                                                  nsIContent* aMovingInto);
+  MOZ_CAN_RUN_SCRIPT void GenerateDragDropEnterExit(
+      nsPresContext* aPresContext, WidgetDragEvent* aDragEvent);
+
+  /**
+   * Return mMouseEnterLeaveHelper or relevant mPointersEnterLeaveHelper
+   * elements wrapper. If mPointersEnterLeaveHelper does not contain wrapper for
+   * pointerId it create new one
+   */
+  OverOutElementsWrapper* GetWrapperByEventID(WidgetMouseEvent* aMouseEvent);
+
+  /**
+   * Fire the dragenter and dragexit/dragleave events when the mouse moves to a
+   * new target.
+   *
+   * @param aRelatedTarget relatedTarget to set for the event
+   * @param aTargetContent target to set for the event
+   * @param aTargetFrame target frame for the event
+   */
+  MOZ_CAN_RUN_SCRIPT void FireDragEnterOrExit(nsPresContext* aPresContext,
+                                              WidgetDragEvent* aDragEvent,
+                                              EventMessage aMessage,
+                                              nsIContent* aRelatedTarget,
+                                              nsIContent* aTargetContent,
+                                              AutoWeakFrame& aTargetFrame);
+  /**
+   * Update the initial drag session data transfer with any changes that occur
+   * on cloned data transfer objects used for events.
+   */
+  void UpdateDragDataTransfer(WidgetDragEvent* dragEvent);
+
+  /**
+   * InitAndDispatchClickEvent() dispatches a click event.
+   *
+   * @param aMouseUpEvent           eMouseUp event which causes the click event.
+   *                                EventCausesClickEvents() must return true
+   *                                if this event is set to it.
+   * @param aStatus                 Returns the result of click event.
+   *                                If the status indicates consumed, the
+   *                                value won't be overwritten with
+   *                                nsEventStatus_eIgnore.
+   * @param aMessage                Should be eMouseClick, eMouseDoubleClick or
+   *                                eMouseAuxClick.
+   * @param aPresShell              The PresShell.
+   * @param aMouseUpContent         The event target of aMouseUpEvent.
+   * @param aCurrentTarget          Current target of the caller.
+   * @param aNoContentDispatch      true if the event shouldn't be exposed to
+   *                                web contents (although will be fired on
+   *                                document and window).
+   * @param aOverrideClickTarget    Preferred click event target.  If this is
+   *                                not nullptr, aMouseUpContent and
+   *                                aCurrentTarget are ignored.
+   */
+  MOZ_CAN_RUN_SCRIPT
+  static nsresult InitAndDispatchClickEvent(
+      WidgetMouseEvent* aMouseUpEvent, nsEventStatus* aStatus,
+      EventMessage aMessage, PresShell* aPresShell, nsIContent* aMouseUpContent,
+      AutoWeakFrame aCurrentTarget, bool aNoContentDispatch,
+      nsIContent* aOverrideClickTarget);
+
+  nsresult SetClickCount(WidgetMouseEvent* aEvent, nsEventStatus* aStatus,
+                         nsIContent* aOverrideClickTarget = nullptr);
+
+  /**
+   * EventCausesClickEvents() returns true when aMouseEvent is an eMouseUp
+   * event and it should cause eMouseClick, eMouseDoubleClick and/or
+   * eMouseAuxClick events.  Note that this method assumes that
+   * aMouseEvent.mClickCount has already been initialized with SetClickCount().
+   */
+  static bool EventCausesClickEvents(const WidgetMouseEvent& aMouseEvent);
+
+  /**
+   * PostHandleMouseUp() handles default actions of eMouseUp event.
+   *
+   * @param aMouseUpEvent           eMouseUp event which causes the click event.
+   *                                EventCausesClickEvents() must return true
+   *                                if this event is set to it.
+   * @param aStatus                 Returns the result of event status.
+   *                                If one of dispatching event is consumed or
+   *                                this does something as default action,
+   *                                returns nsEventStatus_eConsumeNoDefault.
+   * @param aOverrideClickTarget    Preferred click event target.  If nullptr,
+   *                                aMouseUpEvent target and current target
+   *                                are used.
+   */
+  MOZ_CAN_RUN_SCRIPT
+  nsresult PostHandleMouseUp(WidgetMouseEvent* aMouseUpEvent,
+                             nsEventStatus* aStatus,
+                             nsIContent* aOverrideClickTarget);
+
+  /**
+   * DispatchClickEvents() dispatches eMouseClick, eMouseDoubleClick and
+   * eMouseAuxClick events for aMouseUpEvent.  aMouseUpEvent should cause
+   * click event.
+   *
+   * @param aPresShell              The PresShell.
+   * @param aMouseUpEvent           eMouseUp event which causes the click event.
+   *                                EventCausesClickEvents() must return true
+   *                                if this event is set to it.
+   * @param aStatus                 Returns the result of event status.
+   *                                If one of dispatching click event is
+   *                                consumed, returns
+   *                                nsEventStatus_eConsumeNoDefault.
+   * @param aMouseUpContent         The event target of aMouseUpEvent.
+   * @param aOverrideClickTarget    Preferred click event target.  If this is
+   *                                not nullptr, aMouseUpContent and
+   *                                current target frame of the ESM are ignored.
+   */
+  MOZ_CAN_RUN_SCRIPT
+  nsresult DispatchClickEvents(PresShell* aPresShell,
+                               WidgetMouseEvent* aMouseUpEvent,
+                               nsEventStatus* aStatus,
+                               nsIContent* aMouseUpContent,
+                               nsIContent* aOverrideClickTarget);
+
+  void EnsureDocument(nsPresContext* aPresContext);
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  void FlushLayout(nsPresContext* aPresContext);
+
+  /**
+   * The phases of WalkESMTreeToHandleAccessKey processing. See below.
+   */
+  enum ProcessingAccessKeyState {
+    eAccessKeyProcessingNormal = 0,
+    eAccessKeyProcessingUp,
+    eAccessKeyProcessingDown
+  };
+
+  /**
+   * Walk EMS to look for access key and execute found access key when aExecute
+   * is true.
+   * If there is registered element for the accesskey given by the key event
+   * and modifier mask then call element.PerformAccesskey(), otherwise call
+   * WalkESMTreeToHandleAccessKey() recursively, on descendant docshells first,
+   * then on the ancestor (with |aBubbledFrom| set to the docshell associated
+   * with |this|), until something matches.
+   *
+   * @param aEvent the keyboard event triggering the acccess key
+   * @param aPresContext the presentation context
+   * @param aAccessCharCodes list of charcode candidates
+   * @param aBubbledFrom is used by an ancestor to avoid calling
+   *        WalkESMTreeToHandleAccessKey() on the child the call originally
+   *        came from, i.e. this is the child that recursively called us in
+   *        its Up phase. The initial caller passes |nullptr| here. This is to
+   *        avoid an infinite loop.
+   * @param aAccessKeyState Normal, Down or Up processing phase (see enums
+   *        above). The initial event receiver uses 'normal', then 'down' when
+   *        processing children and Up when recursively calling its ancestor.
+   * @param aExecute is true, execute an accesskey if it's found.  Otherwise,
+   *        found accesskey won't be executed.
+   *
+   * @return            true if there is a target which aEvent and
+   *                    aAccessCharCodes match with in this process.
+   *                    Otherwise, false.  I.e., when this returns true and
+   *                    aExecute is true, a target is executed or focused.
+   *                    Note that even if this returns false, a target in
+   *                    remote process may be executed or focused
+   *                    asynchronously.
+   */
+  bool WalkESMTreeToHandleAccessKey(WidgetKeyboardEvent* aEvent,
+                                    nsPresContext* aPresContext,
+                                    nsTArray<uint32_t>& aAccessCharCodes,
+                                    nsIDocShellTreeItem* aBubbledFrom,
+                                    ProcessingAccessKeyState aAccessKeyState,
+                                    bool aExecute);
+
+  /**
+   * Look for access key and execute found access key if aExecute is true in
+   * the instance.
+   *
+   * @return            true if there is a target which matches with
+   *                    aAccessCharCodes and aIsTrustedEvent.  Otherwise,
+   *                    false.  I.e., when this returns true and aExecute
+   *                    is true, a target is executed or focused.
+   */
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY bool LookForAccessKeyAndExecute(
+      nsTArray<uint32_t>& aAccessCharCodes, bool aIsTrustedEvent,
+      bool aIsRepeat, bool aExecute);
+
+  //---------------------------------------------
+  // DocShell Focus Traversal Methods
+  //---------------------------------------------
+
+  dom::Element* GetFocusedElement();
+  bool IsShellVisible(nsIDocShell* aShell);
+
+  // These functions are for mousewheel and pixel scrolling
+
+  class WheelPrefs {
+   public:
+    static WheelPrefs* GetInstance();
+    static void Shutdown();
+
+    /**
+     * ApplyUserPrefsToDelta() overrides the wheel event's delta values with
+     * user prefs.
+     */
+    void ApplyUserPrefsToDelta(WidgetWheelEvent* aEvent);
+
+    /**
+     * Returns whether or not ApplyUserPrefsToDelta() would change the delta
+     * values of an event.
+     */
+    void GetUserPrefsForEvent(const WidgetWheelEvent* aEvent,
+                              double* aOutMultiplierX, double* aOutMultiplierY);
+
+    /**
+     * If ApplyUserPrefsToDelta() changed the delta values with customized
+     * prefs, the overflowDelta values would be inflated.
+     * CancelApplyingUserPrefsFromOverflowDelta() cancels the inflation.
+     */
+    void CancelApplyingUserPrefsFromOverflowDelta(WidgetWheelEvent* aEvent);
+
+    /**
+     * Computes the default action for the aEvent with the prefs.
+     */
+    enum Action : uint8_t {
+      ACTION_NONE = 0,
+      ACTION_SCROLL,
+      ACTION_HISTORY,
+      ACTION_ZOOM,
+      // Horizontalized scrolling means treating vertical wheel scrolling as
+      // horizontal scrolling during the process of its default action and
+      // plugins handling scrolling. Note that delta values as the event object
+      // in a DOM event listener won't be affected, and will be still the
+      // original values. For more details, refer to
+      // mozilla::WheelDeltaAdjustmentStrategy::eHorizontalize
+      ACTION_HORIZONTALIZED_SCROLL,
+      ACTION_PINCH_ZOOM,
+      ACTION_LAST = ACTION_PINCH_ZOOM,
+      // Following actions are used only by internal processing.  So, cannot
+      // specified by prefs.
+      ACTION_SEND_TO_PLUGIN,
+    };
+    Action ComputeActionFor(const WidgetWheelEvent* aEvent);
+
+    /**
+     * NeedToComputeLineOrPageDelta() returns if the aEvent needs to be
+     * computed the lineOrPageDelta values.
+     */
+    bool NeedToComputeLineOrPageDelta(const WidgetWheelEvent* aEvent);
+
+    /**
+     * IsOverOnePageScrollAllowed*() checks whether wheel scroll amount should
+     * be rounded down to the page width/height (false) or not (true).
+     */
+    bool IsOverOnePageScrollAllowedX(const WidgetWheelEvent* aEvent);
+    bool IsOverOnePageScrollAllowedY(const WidgetWheelEvent* aEvent);
+
+   private:
+    WheelPrefs();
+    ~WheelPrefs();
+
+    static void OnPrefChanged(const char* aPrefName, void* aClosure);
+
+    enum Index {
+      INDEX_DEFAULT = 0,
+      INDEX_ALT,
+      INDEX_CONTROL,
+      INDEX_META,
+      INDEX_SHIFT,
+      COUNT_OF_MULTIPLIERS
+    };
+
+    /**
+     * GetIndexFor() returns the index of the members which should be used for
+     * the aEvent.  When only one modifier key of MODIFIER_ALT,
+     * MODIFIER_CONTROL, MODIFIER_META or MODIFIER_SHIFT is pressed, returns the
+     * index for the modifier.  Otherwise, this return the default index which
+     * is used at either no modifier key is pressed or two or modifier keys are
+     * pressed.
+     */
+    Index GetIndexFor(const WidgetWheelEvent* aEvent);
+
+    /**
+     * GetPrefNameBase() returns the base pref name for aEvent.
+     * It's decided by GetModifierForPref() which modifier should be used for
+     * the aEvent.
+     *
+     * @param aBasePrefName The result, must be "mousewheel.with_*." or
+     *                      "mousewheel.default.".
+     */
+    void GetBasePrefName(Index aIndex, nsACString& aBasePrefName);
+
+    void Init(Index aIndex);
+
+    void Reset();
+
+    /**
+     * Retrieve multiplier for aEvent->mDeltaX and aEvent->mDeltaY.
+     *
+     * Note that if the default action is ACTION_HORIZONTALIZED_SCROLL and the
+     * delta values have been adjusted by WheelDeltaHorizontalizer() before this
+     * function is called, this function will swap the X and Y multipliers. By
+     * doing this, multipliers will still apply to the delta values they
+     * originally corresponded to.
+     *
+     * @param aEvent    The event which is being handled.
+     * @param aIndex    The index of mMultiplierX and mMultiplierY.
+     *                  Should be result of GetIndexFor(aEvent).
+     * @param aMultiplierForDeltaX      Will be set to multiplier for
+     *                                  aEvent->mDeltaX.
+     * @param aMultiplierForDeltaY      Will be set to multiplier for
+     *                                  aEvent->mDeltaY.
+     */
+    void GetMultiplierForDeltaXAndY(const WidgetWheelEvent* aEvent,
+                                    Index aIndex, double* aMultiplierForDeltaX,
+                                    double* aMultiplierForDeltaY);
+
+    bool mInit[COUNT_OF_MULTIPLIERS];
+    double mMultiplierX[COUNT_OF_MULTIPLIERS];
+    double mMultiplierY[COUNT_OF_MULTIPLIERS];
+    double mMultiplierZ[COUNT_OF_MULTIPLIERS];
+    Action mActions[COUNT_OF_MULTIPLIERS];
+    /**
+     * action values overridden by .override_x pref.
+     * If an .override_x value is -1, same as the
+     * corresponding mActions value.
+     */
+    Action mOverriddenActionsX[COUNT_OF_MULTIPLIERS];
+
+    static WheelPrefs* sInstance;
+  };
+
+  /**
+   * DeltaDirection is used for specifying whether the called method should
+   * handle vertical delta or horizontal delta.
+   * This is clearer than using bool.
+   */
+  enum DeltaDirection { DELTA_DIRECTION_X = 0, DELTA_DIRECTION_Y };
+
+  struct MOZ_STACK_CLASS EventState {
+    bool mDefaultPrevented;
+    bool mDefaultPreventedByContent;
+
+    EventState()
+        : mDefaultPrevented(false), mDefaultPreventedByContent(false) {}
+  };
+
+  /**
+   * SendLineScrollEvent() dispatches a DOMMouseScroll event for the
+   * WidgetWheelEvent.  This method shouldn't be called for non-trusted
+   * wheel event because it's not necessary for compatiblity.
+   *
+   * @param aTargetFrame        The event target of wheel event.
+   * @param aEvent              The original Wheel event.
+   * @param aState              The event which should be set to the dispatching
+   *                            event.  This also returns the dispatched event
+   *                            state.
+   * @param aDelta              The delta value of the event.
+   * @param aDeltaDirection     The X/Y direction of dispatching event.
+   */
+  MOZ_CAN_RUN_SCRIPT void SendLineScrollEvent(nsIFrame* aTargetFrame,
+                                              WidgetWheelEvent* aEvent,
+                                              EventState& aState,
+                                              int32_t aDelta,
+                                              DeltaDirection aDeltaDirection);
+
+  /**
+   * SendPixelScrollEvent() dispatches a MozMousePixelScroll event for the
+   * WidgetWheelEvent.  This method shouldn't be called for non-trusted
+   * wheel event because it's not necessary for compatiblity.
+   *
+   * @param aTargetFrame        The event target of wheel event.
+   * @param aEvent              The original Wheel event.
+   * @param aState              The event which should be set to the dispatching
+   *                            event.  This also returns the dispatched event
+   *                            state.
+   * @param aPixelDelta         The delta value of the event.
+   * @param aDeltaDirection     The X/Y direction of dispatching event.
+   */
+  MOZ_CAN_RUN_SCRIPT void SendPixelScrollEvent(nsIFrame* aTargetFrame,
+                                               WidgetWheelEvent* aEvent,
+                                               EventState& aState,
+                                               int32_t aPixelDelta,
+                                               DeltaDirection aDeltaDirection);
+
+  /**
+   * ComputeScrollTargetAndMayAdjustWheelEvent() returns the scrollable frame
+   * which should be scrolled.
+   *
+   * @param aTargetFrame        The event target of the wheel event.
+   * @param aEvent              The handling mouse wheel event.
+   * @param aOptions            The options for finding the scroll target.
+   *                            Callers should use COMPUTE_*.
+   * @return                    The scrollable frame which should be scrolled.
+   */
+  // These flags are used in ComputeScrollTargetAndMayAdjustWheelEvent().
+  // Callers should use COMPUTE_*.
+  enum {
+    PREFER_MOUSE_WHEEL_TRANSACTION = 0x00000001,
+    PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS = 0x00000002,
+    PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS = 0x00000004,
+    START_FROM_PARENT = 0x00000008,
+    INCLUDE_PLUGIN_AS_TARGET = 0x00000010,
+    // Indicates the wheel scroll event being computed is an auto-dir scroll, so
+    // its delta may be adjusted after being computed.
+    MAY_BE_ADJUSTED_BY_AUTO_DIR = 0x00000020,
+  };
+  enum ComputeScrollTargetOptions {
+    // At computing scroll target for legacy mouse events, we should return
+    // first scrollable element even when it's not scrollable to the direction.
+    COMPUTE_LEGACY_MOUSE_SCROLL_EVENT_TARGET = 0,
+    // Default action prefers the scrolled element immediately before if it's
+    // still under the mouse cursor.  Otherwise, it prefers the nearest
+    // scrollable ancestor which will be scrolled actually.
+    COMPUTE_DEFAULT_ACTION_TARGET =
+        (PREFER_MOUSE_WHEEL_TRANSACTION |
+         PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS |
+         PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS),
+    COMPUTE_DEFAULT_ACTION_TARGET_WITH_AUTO_DIR =
+        (COMPUTE_DEFAULT_ACTION_TARGET | MAY_BE_ADJUSTED_BY_AUTO_DIR),
+    // Look for the nearest scrollable ancestor which can be scrollable with
+    // aEvent.
+    COMPUTE_SCROLLABLE_ANCESTOR_ALONG_X_AXIS =
+        (PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS | START_FROM_PARENT),
+    COMPUTE_SCROLLABLE_ANCESTOR_ALONG_Y_AXIS =
+        (PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS | START_FROM_PARENT),
+    COMPUTE_SCROLLABLE_ANCESTOR_ALONG_X_AXIS_WITH_AUTO_DIR =
+        (COMPUTE_SCROLLABLE_ANCESTOR_ALONG_X_AXIS |
+         MAY_BE_ADJUSTED_BY_AUTO_DIR),
+    COMPUTE_SCROLLABLE_ANCESTOR_ALONG_Y_AXIS_WITH_AUTO_DIR =
+        (COMPUTE_SCROLLABLE_ANCESTOR_ALONG_Y_AXIS |
+         MAY_BE_ADJUSTED_BY_AUTO_DIR),
+  };
+
+  // Compute the scroll target.
+  // The delta values in the wheel event may be changed if the event is for
+  // auto-dir scrolling. For information on auto-dir,
+  // @see mozilla::WheelDeltaAdjustmentStrategy
+  nsIFrame* ComputeScrollTargetAndMayAdjustWheelEvent(
+      nsIFrame* aTargetFrame, WidgetWheelEvent* aEvent,
+      ComputeScrollTargetOptions aOptions);
+
+  nsIFrame* ComputeScrollTargetAndMayAdjustWheelEvent(
+      nsIFrame* aTargetFrame, double aDirectionX, double aDirectionY,
+      WidgetWheelEvent* aEvent, ComputeScrollTargetOptions aOptions);
+
+  nsIFrame* ComputeScrollTarget(nsIFrame* aTargetFrame,
+                                WidgetWheelEvent* aEvent,
+                                ComputeScrollTargetOptions aOptions) {
+    MOZ_ASSERT(!(aOptions & MAY_BE_ADJUSTED_BY_AUTO_DIR),
+               "aEvent may be modified by auto-dir");
+    return ComputeScrollTargetAndMayAdjustWheelEvent(aTargetFrame, aEvent,
+                                                     aOptions);
+  }
+
+  nsIFrame* ComputeScrollTarget(nsIFrame* aTargetFrame, double aDirectionX,
+                                double aDirectionY, WidgetWheelEvent* aEvent,
+                                ComputeScrollTargetOptions aOptions) {
+    MOZ_ASSERT(!(aOptions & MAY_BE_ADJUSTED_BY_AUTO_DIR),
+               "aEvent may be modified by auto-dir");
+    return ComputeScrollTargetAndMayAdjustWheelEvent(
+        aTargetFrame, aDirectionX, aDirectionY, aEvent, aOptions);
+  }
+
+  /**
+   * GetScrollAmount() returns the scroll amount in app uints of one line or
+   * one page.  If the wheel event scrolls a page, returns the page width and
+   * height.  Otherwise, returns line height for both its width and height.
+   *
+   * @param aScrollableFrame    A frame which will be scrolled by the event.
+   *                            The result of
+   *                            ComputeScrollTargetAndMayAdjustWheelEvent() is
+   *                            expected for this value.
+   *                            This can be nullptr if there is no scrollable
+   *                            frame.  Then, this method uses root frame's
+   *                            line height or visible area's width and height.
+   */
+  nsSize GetScrollAmount(nsPresContext* aPresContext, WidgetWheelEvent* aEvent,
+                         nsIScrollableFrame* aScrollableFrame);
+
+  /**
+   * DoScrollText() scrolls the scrollable frame for aEvent.
+   */
+  void DoScrollText(nsIScrollableFrame* aScrollableFrame,
+                    WidgetWheelEvent* aEvent);
+
+  void DoScrollHistory(int32_t direction);
+  void DoScrollZoom(nsIFrame* aTargetFrame, int32_t adjustment);
+  void ChangeZoom(bool aIncrease);
+
+  /**
+   * DeltaAccumulator class manages delta values for dispatching DOMMouseScroll
+   * event.  If wheel events are caused by pixel scroll only devices or
+   * the delta values are customized by prefs, this class stores the delta
+   * values and set lineOrPageDelta values.
+   */
+  class DeltaAccumulator {
+   public:
+    static DeltaAccumulator* GetInstance() {
+      if (!sInstance) {
+        sInstance = new DeltaAccumulator;
+      }
+      return sInstance;
+    }
+
+    static void Shutdown() {
+      delete sInstance;
+      sInstance = nullptr;
+    }
+
+    bool IsInTransaction() { return mHandlingDeltaMode != UINT32_MAX; }
+
+    /**
+     * InitLineOrPageDelta() stores pixel delta values of WidgetWheelEvents
+     * which are caused if it's needed.  And if the accumulated delta becomes a
+     * line height, sets lineOrPageDeltaX and lineOrPageDeltaY automatically.
+     */
+    void InitLineOrPageDelta(nsIFrame* aTargetFrame, EventStateManager* aESM,
+                             WidgetWheelEvent* aEvent);
+
+    /**
+     * Reset() resets all members.
+     */
+    void Reset();
+
+    /**
+     * ComputeScrollAmountForDefaultAction() computes the default action's
+     * scroll amount in device pixels with mPendingScrollAmount*.
+     */
+    nsIntPoint ComputeScrollAmountForDefaultAction(
+        WidgetWheelEvent* aEvent, const nsIntSize& aScrollAmountInDevPixels);
+
+   private:
+    DeltaAccumulator()
+        : mX(0.0),
+          mY(0.0),
+          mPendingScrollAmountX(0.0),
+          mPendingScrollAmountY(0.0),
+          mHandlingDeltaMode(UINT32_MAX),
+          mIsNoLineOrPageDeltaDevice(false) {}
+
+    double mX;
+    double mY;
+
+    // When default action of a wheel event is scroll but some delta values
+    // are ignored because the computed amount values are not integer, the
+    // fractional values are saved by these members.
+    double mPendingScrollAmountX;
+    double mPendingScrollAmountY;
+
+    TimeStamp mLastTime;
+
+    uint32_t mHandlingDeltaMode;
+    bool mIsNoLineOrPageDeltaDevice;
+
+    static DeltaAccumulator* sInstance;
+  };
+
+  // end mousewheel functions
+
+  /*
+   * When a touch gesture is about to start, this function determines what
+   * kind of gesture interaction we will want to use, based on what is
+   * underneath the initial touch point.
+   * Currently it decides between panning (finger scrolling) or dragging
+   * the target element, as well as the orientation to trigger panning and
+   * display visual boundary feedback. The decision is stored back in aEvent.
+   */
+  void DecideGestureEvent(WidgetGestureNotifyEvent* aEvent,
+                          nsIFrame* targetFrame);
+
+  // routines for the d&d gesture tracking state machine
+  void BeginTrackingDragGesture(nsPresContext* aPresContext,
+                                WidgetMouseEvent* aDownEvent,
+                                nsIFrame* aDownFrame);
+
+  void SetGestureDownPoint(WidgetGUIEvent* aEvent);
+
+  LayoutDeviceIntPoint GetEventRefPoint(WidgetEvent* aEvent) const;
+
+  friend class mozilla::dom::BrowserParent;
+  void BeginTrackingRemoteDragGesture(nsIContent* aContent,
+                                      dom::RemoteDragStartData* aDragStartData);
+
+  MOZ_CAN_RUN_SCRIPT
+  void GenerateDragGesture(nsPresContext* aPresContext,
+                           WidgetInputEvent* aEvent);
+
+  /**
+   * When starting a dnd session, UA must fire a pointercancel event and stop
+   * firing the subsequent pointer events.
+   */
+  MOZ_CAN_RUN_SCRIPT
+  void MaybeFirePointerCancel(WidgetInputEvent* aEvent);
+
+  /**
+   * Determine which node the drag should be targeted at.
+   * This is either the node clicked when there is a selection, or, for HTML,
+   * the element with a draggable property set to true.
+   *
+   * aSelectionTarget - target to check for selection
+   * aDataTransfer - data transfer object that will contain the data to drag
+   * aAllowEmptyDataTransfer - [out] set to true, if dnd operation can be
+   *                           started even if DataTransfer is empty
+   * aSelection - [out] set to the selection to be dragged
+   * aTargetNode - [out] the draggable node, or null if there isn't one
+   * aPrincipal - [out] set to the triggering principal of the drag, or null
+   *                    if it's from browser chrome or OS
+   * aCookieJarSettings - [out] set to the cookieJarSettings of the drag, or
+   *                            null if it's from browser chrome or OS.
+   */
+  void DetermineDragTargetAndDefaultData(
+      nsPIDOMWindowOuter* aWindow, nsIContent* aSelectionTarget,
+      dom::DataTransfer* aDataTransfer, bool* aAllowEmptyDataTransfer,
+      dom::Selection** aSelection,
+      dom::RemoteDragStartData** aRemoteDragStartData, nsIContent** aTargetNode,
+      nsIPrincipal** aPrincipal, nsIContentSecurityPolicy** aCsp,
+      nsICookieJarSettings** aCookieJarSettings);
+
+  /*
+   * Perform the default handling for the dragstart event and set up a
+   * drag for aDataTransfer if it contains any data. Returns true if a drag has
+   * started.
+   *
+   * aDragEvent - the dragstart event
+   * aDataTransfer - the data transfer that holds the data to be dragged
+   * aAllowEmptyDataTransfer - if true, dnd can be started even if there is no
+   *                           data to drag
+   * aDragTarget - the target of the drag
+   * aSelection - the selection to be dragged
+   * aData - information pertaining to a drag started in a child process
+   * aPrincipal - the triggering principal of the drag, or null if it's from
+   *              browser chrome or OS
+   * aCookieJarSettings - the cookieJarSettings of the drag. or null if it's
+   *                      from browser chrome or OS.
+   */
+  MOZ_CAN_RUN_SCRIPT
+  bool DoDefaultDragStart(
+      nsPresContext* aPresContext, WidgetDragEvent* aDragEvent,
+      dom::DataTransfer* aDataTransfer, bool aAllowEmptyDataTransfer,
+      nsIContent* aDragTarget, dom::Selection* aSelection,
+      dom::RemoteDragStartData* aDragStartData, nsIPrincipal* aPrincipal,
+      nsIContentSecurityPolicy* aCsp, nsICookieJarSettings* aCookieJarSettings);
+
+  bool IsTrackingDragGesture() const { return mGestureDownContent != nullptr; }
+  /**
+   * Set the fields of aEvent to reflect the mouse position and modifier keys
+   * that were set when the user first pressed the mouse button (stored by
+   * BeginTrackingDragGesture). aEvent->mWidget must be
+   * mCurrentTarget->GetNearestWidget().
+   */
+  void FillInEventFromGestureDown(WidgetMouseEvent* aEvent);
+
+  MOZ_CAN_RUN_SCRIPT
+  nsresult DoContentCommandEvent(WidgetContentCommandEvent* aEvent);
+  MOZ_CAN_RUN_SCRIPT
+  nsresult DoContentCommandInsertTextEvent(WidgetContentCommandEvent* aEvent);
+  nsresult DoContentCommandScrollEvent(WidgetContentCommandEvent* aEvent);
+
+  dom::BrowserParent* GetCrossProcessTarget();
+  bool IsTargetCrossProcess(WidgetGUIEvent* aEvent);
+
+  /**
+   * DispatchCrossProcessEvent() try to post aEvent to target remote process.
+   * If you need to check if the event is posted to a remote process, you
+   * can use aEvent->HasBeenPostedToRemoteProcess().
+   */
+  void DispatchCrossProcessEvent(WidgetEvent* aEvent,
+                                 dom::BrowserParent* aRemoteTarget,
+                                 nsEventStatus* aStatus);
+  /**
+   * HandleCrossProcessEvent() may post aEvent to target remote processes.
+   * When it succeeded to post the event to at least one remote process,
+   * returns true.  Otherwise, including the case not tried to dispatch to
+   * post the event, returns false.
+   * If you need to check if the event is posted to at least one remote
+   * process, you can use aEvent->HasBeenPostedToRemoteProcess().
+   */
+  bool HandleCrossProcessEvent(WidgetEvent* aEvent, nsEventStatus* aStatus);
+
+  void ReleaseCurrentIMEContentObserver();
+
+  MOZ_CAN_RUN_SCRIPT void HandleQueryContentEvent(
+      WidgetQueryContentEvent* aEvent);
+
+ private:
+  // Removes a node from the :hover / :active chain if needed, notifying if the
+  // node is not a NAC subtree.
+  //
+  // Only meant to be called from ContentRemoved and
+  // NativeAnonymousContentRemoved.
+  void RemoveNodeFromChainIfNeeded(ElementState aState,
+                                   nsIContent* aContentRemoved, bool aNotify);
+
+  bool IsEventOutsideDragThreshold(WidgetInputEvent* aEvent) const;
+
+  static inline void DoStateChange(dom::Element* aElement, ElementState aState,
+                                   bool aAddState);
+  static inline void DoStateChange(nsIContent* aContent, ElementState aState,
+                                   bool aAddState);
+  static void UpdateAncestorState(nsIContent* aStartNode,
+                                  nsIContent* aStopBefore, ElementState aState,
+                                  bool aAddState);
+
+  /**
+   * Update the attribute mLastRefPoint of the mouse event. It should be
+   *     the center of the window while the pointer is locked.
+   *     the same value as mRefPoint while there is no known last ref point.
+   *     the same value as the last known mRefPoint.
+   */
+  static void UpdateLastRefPointOfMouseEvent(WidgetMouseEvent* aMouseEvent);
+
+  static void ResetPointerToWindowCenterWhilePointerLocked(
+      WidgetMouseEvent* aMouseEvent);
+
+  // Update the last known ref point to the current event's mRefPoint.
+  static void UpdateLastPointerPosition(WidgetMouseEvent* aMouseEvent);
+
+  /**
+   * Notify target when user has been interaction with some speicific user
+   * gestures which are eKeyUp, eMouseUp, eTouchEnd.
+   */
+  void NotifyTargetUserActivation(WidgetEvent* aEvent,
+                                  nsIContent* aTargetContent);
+
+  /**
+   * https://html.spec.whatwg.org/multipage/popover.html#light-dismiss-open-popovers.
+   */
+  MOZ_CAN_RUN_SCRIPT void LightDismissOpenPopovers(WidgetEvent* aEvent,
+                                                   nsIContent* aTargetContent);
+
+  already_AddRefed<EventStateManager> ESMFromContentOrThis(
+      nsIContent* aContent);
+
+  struct LastMouseDownInfo {
+    nsCOMPtr<nsIContent> mLastMouseDownContent;
+    Maybe<FormControlType> mLastMouseDownInputControlType;
+    uint32_t mClickCount = 0;
+  };
+
+  LastMouseDownInfo& GetLastMouseDownInfo(int16_t aButton);
+
+  // These variables are only relevant if we're the cursor-setting manager.
+  StyleCursorKind mLockCursor;
+  bool mHidingCursorWhileTyping = false;
+
+  // Last mouse event screen point (in device pixel) when mouse was locked, used
+  // to restore mouse position after unlocking.
+  static LayoutDeviceIntPoint sPreLockScreenPoint;
+
+  // Stores the mRefPoint of the last synthetic mouse move we dispatched
+  // to re-center the mouse when we were pointer locked. If this is (-1,-1) it
+  // means we've not recently dispatched a centering event. We use this to
+  // detect when we receive the synth event, so we can cancel and not send it
+  // to content.
+  static LayoutDeviceIntPoint sSynthCenteringPoint;
+
+  WeakFrame mCurrentTarget;
+  nsCOMPtr<nsIContent> mCurrentTargetContent;
+  static AutoWeakFrame sLastDragOverFrame;
+
+  // Stores the mRefPoint (the offset from the widget's origin in device
+  // pixels) of the last mouse event.
+  static LayoutDeviceIntPoint sLastRefPoint;
+
+  // member variables for the d&d gesture state machine
+  LayoutDeviceIntPoint mGestureDownPoint;  // screen coordinates
+  // The content to use as target if we start a d&d (what we drag).
+  RefPtr<nsIContent> mGestureDownContent;
+  // The content of the frame where the mouse-down event occurred. It's the same
+  // as the target in most cases but not always - for example when dragging
+  // an <area> of an image map this is the image. (bug 289667)
+  nsCOMPtr<nsIContent> mGestureDownFrameOwner;
+  // Data associated with a drag started in a content process.
+  RefPtr<dom::RemoteDragStartData> mGestureDownDragStartData;
+  // State of keys when the original gesture-down happened
+  Modifiers mGestureModifiers;
+  uint16_t mGestureDownButtons;
+
+  LastMouseDownInfo mLastLeftMouseDownInfo;
+  LastMouseDownInfo mLastMiddleMouseDownInfo;
+  LastMouseDownInfo mLastRightMouseDownInfo;
+
+  nsCOMPtr<nsIContent> mActiveContent;
+  nsCOMPtr<nsIContent> mHoverContent;
+  static nsCOMPtr<nsIContent> sDragOverContent;
+  nsCOMPtr<nsIContent> mURLTargetContent;
+  nsCOMPtr<nsINode> mPopoverPointerDownTarget;
+
+  nsPresContext* mPresContext;      // Not refcnted
+  RefPtr<dom::Document> mDocument;  // Doesn't necessarily need to be owner
+
+  RefPtr<IMEContentObserver> mIMEContentObserver;
+
+  bool mShouldAlwaysUseLineDeltas : 1;
+  bool mShouldAlwaysUseLineDeltasInitialized : 1;
+
+  bool mGestureDownInTextControl : 1;
+
+  bool mInTouchDrag;
+
+  bool m_haveShutdown;
+
+  RefPtr<OverOutElementsWrapper> mMouseEnterLeaveHelper;
+  nsRefPtrHashtable<nsUint32HashKey, OverOutElementsWrapper>
+      mPointersEnterLeaveHelper;
+
+  // Array for accesskey support
+  nsCOMArray<dom::Element> mAccessKeys;
+
+  bool ShouldAlwaysUseLineDeltas();
+
+ public:
+  static nsresult UpdateUserActivityTimer(void);
+
+  static bool sNormalLMouseEventInProcess;
+  static int16_t sCurrentMouseBtn;
+
+  static EventStateManager* sActiveESM;
+
+  static void ClearGlobalActiveContent(EventStateManager* aClearer);
+
+  // Functions used for click hold context menus
+  nsCOMPtr<nsITimer> mClickHoldTimer;
+  void CreateClickHoldTimer(nsPresContext* aPresContext, nsIFrame* aDownFrame,
+                            WidgetGUIEvent* aMouseDownEvent);
+  void KillClickHoldTimer();
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY void FireContextClick();
+
+  MOZ_CAN_RUN_SCRIPT static void SetPointerLock(nsIWidget* aWidget,
+                                                nsPresContext* aPresContext);
+  static void sClickHoldCallback(nsITimer* aTimer, void* aESM);
+};
+
+}  // namespace mozilla
+
+// Click and double-click events need to be handled even for content that
+// has no frame. This is required for Web compatibility.
+#define NS_EVENT_NEEDS_FRAME(event)          \
+  ((event)->mMessage != eMouseClick &&       \
+   (event)->mMessage != eMouseDoubleClick && \
+   (event)->mMessage != eMouseAuxClick)
+
+#endif  // mozilla_EventStateManager_h_