summaryrefslogtreecommitdiffstats
path: root/dom/events/EventStateManager.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /dom/events/EventStateManager.h
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/events/EventStateManager.h')
-rw-r--r--dom/events/EventStateManager.h1335
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_