Add m-esr52 at 52.6.0

1 files changed, 1051 insertions, 0 deletions

diff --git a/dom/events/EventStateManager.h b/dom/events/EventStateManager.h
new file mode 100644
index 000000000..49ecf0586
--- /dev/null
+++ b/dom/events/EventStateManager.h
@@ -0,0 +1,1051 @@
+/* -*- 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 "mozilla/TimeStamp.h"
+#include "nsIFrame.h"
+#include "Units.h"
+
+class nsFrameLoader;
+class nsIContent;
+class nsIDocument;
+class nsIDocShell;
+class nsIDocShellTreeItem;
+class imgIContainer;
+class EnterLeaveDispatcher;
+class nsIContentViewer;
+class nsIScrollableFrame;
+class nsITimer;
+class nsPresContext;
+
+namespace mozilla {
+
+class EnterLeaveDispatcher;
+class EventStates;
+class IMEContentObserver;
+class ScrollbarsForWheel;
+class WheelTransaction;
+
+namespace dom {
+class DataTransfer;
+class Element;
+class TabParent;
+} // namespace dom
+
+class OverOutElementsWrapper final : public nsISupports
+{
+  ~OverOutElementsWrapper();
+
+public:
+  OverOutElementsWrapper();
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS(OverOutElementsWrapper)
+
+  nsWeakFrame mLastOverFrame;
+
+  nsCOMPtr<nsIContent> mLastOverElement;
+
+  // The last element on which we fired a over event, or null if
+  // the last over event we fired has finished processing.
+  nsCOMPtr<nsIContent> mFirstOverEventElement;
+
+  // The last element on which we fired a out event, or null if
+  // the last out event we fired has finished processing.
+  nsCOMPtr<nsIContent> mFirstOutEventElement;
+};
+
+class EventStateManager : public nsSupportsWeakReference,
+                          public nsIObserver
+{
+  friend class mozilla::EnterLeaveDispatcher;
+  friend class mozilla::ScrollbarsForWheel;
+  friend class mozilla::WheelTransaction;
+
+  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.
+   */
+  nsresult PreHandleEvent(nsPresContext* aPresContext,
+                          WidgetEvent* aEvent,
+                          nsIFrame* aTargetFrame,
+                          nsIContent* aTargetContent,
+                          nsEventStatus* aStatus);
+
+  /* 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.
+   */
+  nsresult PostHandleEvent(nsPresContext* aPresContext,
+                           WidgetEvent* aEvent,
+                           nsIFrame* aTargetFrame,
+                           nsEventStatus* aStatus);
+
+  void PostHandleKeyboardEvent(WidgetKeyboardEvent* aKeyboardEvent,
+                               nsEventStatus& aStatus,
+                               bool dispatchedToContentProcess);
+
+  /**
+   * DispatchLegacyMouseScrollEvents() dispatches eLegacyMouseLineOrPageScroll
+   * event and eLegacyMousePixelScroll event for compatibility with old Gecko.
+   */
+  void DispatchLegacyMouseScrollEvents(nsIFrame* aTargetFrame,
+                                       WidgetWheelEvent* aEvent,
+                                       nsEventStatus* aStatus);
+
+  void NotifyDestroyPresContext(nsPresContext* aPresContext);
+  void SetPresContext(nsPresContext* aPresContext);
+  void ClearFrameRefs(nsIFrame* aFrame);
+
+  nsIFrame* GetEventTarget();
+  already_AddRefed<nsIContent> GetEventTargetContent(WidgetEvent* aEvent);
+
+  /**
+   * Notify that the given NS_EVENT_STATE_* bit has changed for this content.
+   * @param aContent Content which has changed states
+   * @param aState   Corresponding state flags such as NS_EVENT_STATE_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, EventStates aState);
+  void ContentRemoved(nsIDocument* aDocument, nsIContent* aContent);
+  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.
+   */
+  void TryToFlushPendingNotificationsToIME();
+
+  /**
+   * Register accesskey on the given element. When accesskey is activated then
+   * the element will be notified via nsIContent::PerformAccesskey() method.
+   *
+   * @param  aContent  the given element
+   * @param  aKey      accesskey
+   */
+  void RegisterAccessKey(nsIContent* aContent, uint32_t aKey);
+
+  /**
+   * Unregister accesskey for the given element.
+   *
+   * @param  aContent  the given element
+   * @param  aKey      accesskey
+   */
+  void UnregisterAccessKey(nsIContent* aContent, uint32_t aKey);
+
+  /**
+   * Get accesskey registered on the given element or 0 if there is none.
+   *
+   * @param  aContent  the given element (must not be null)
+   * @return           registered accesskey
+   */
+  uint32_t GetRegisteredAccessKey(nsIContent* aContent);
+
+  static void GetAccessKeyLabelPrefix(dom::Element* aElement, nsAString& aPrefix);
+
+  bool HandleAccessKey(WidgetKeyboardEvent* aEvent,
+                       nsPresContext* aPresContext,
+                       nsTArray<uint32_t>& aAccessCharCodes,
+                       int32_t aModifierMask,
+                       bool aMatchesContentAccessKey)
+  {
+    return HandleAccessKey(aEvent, aPresContext, aAccessCharCodes,
+                           aMatchesContentAccessKey, nullptr,
+                           eAccessKeyProcessingNormal, aModifierMask);
+  }
+
+  nsresult SetCursor(int32_t aCursor, imgIContainer* aContainer,
+                     bool aHaveHotspot, float aHotspotX, float aHotspotY,
+                     nsIWidget* aWidget, bool aLockCursor); 
+
+  static void StartHandlingUserInput()
+  {
+    ++sUserInputEventDepth;
+    ++sUserInputCounter;
+    if (sUserInputEventDepth == 1) {
+      sLatestUserInputStart = sHandlingInputStart = TimeStamp::Now();
+    }
+  }
+
+  static void StopHandlingUserInput()
+  {
+    --sUserInputEventDepth;
+    if (sUserInputEventDepth == 0) {
+      sHandlingInputStart = TimeStamp();
+    }
+  }
+
+  /**
+   * Returns true if the current code is being executed as a result of
+   * user input.  This includes anything that is initiated by user,
+   * with the exception of page load events or mouse over events. If
+   * this method is called from asynchronously executed code, such as
+   * during layout reflows, it will return false. If more time has
+   * elapsed since the user input than is specified by the
+   * dom.event.handling-user-input-time-limit pref (default 1 second),
+   * this function also returns false.
+   */
+  static bool IsHandlingUserInput();
+
+  /**
+   * Get the number of user inputs handled since process start. This
+   * includes anything that is initiated by user, with the exception
+   * of page load events or mouse over events.
+   */
+  static uint64_t UserInputCount()
+  {
+    return sUserInputCounter;
+  }
+
+  /**
+   * Get the timestamp at which the latest user input was handled.
+   *
+   * Guaranteed to be monotonic. Until the first user input, return
+   * the epoch.
+   */
+  static TimeStamp LatestUserInputStart()
+  {
+    return sLatestUserInputStart;
+  }
+
+  nsPresContext* GetPresContext() { return mPresContext; }
+
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(EventStateManager,
+                                           nsIObserver)
+
+  static nsIDocument* sMouseOverDocument;
+
+  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);
+
+  // Sets the full-screen event state on aElement to aIsFullScreen.
+  static void SetFullScreenState(dom::Element* aElement, bool aIsFullScreen);
+
+  static bool IsRemoteTarget(nsIContent* aTarget);
+
+  // Returns true if the given WidgetWheelEvent will resolve to a scroll action.
+  static bool WheelEventIsScrollAction(WidgetWheelEvent* aEvent);
+
+  // Returns user-set multipliers for a wheel event.
+  static void GetUserPrefsForWheelEvent(WidgetWheelEvent* aEvent,
+                                        double* aOutMultiplierX,
+                                        double* aOutMultiplierY);
+
+  // Returns whether or not a frame can be vertically scrolled with a mouse
+  // wheel (as opposed to, say, a selection or touch scroll).
+  static bool CanVerticallyScrollFrameWithWheel(nsIFrame* aFrame);
+
+  // 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;
+
+  static bool sIsPointerLocked;
+  static nsWeakPtr sPointerLockedElement;
+  static nsWeakPtr sPointerLockedDoc;
+
+  /**
+   * 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.
+   */
+  enum {
+    MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL = 1000
+  };
+
+protected:
+  /**
+   * Prefs class capsules preference management.
+   */
+  class Prefs
+  {
+  public:
+    static bool KeyCausesActivation() { return sKeyCausesActivation; }
+    static bool ClickHoldContextMenu() { return sClickHoldContextMenu; }
+    static int32_t ChromeAccessModifierMask();
+    static int32_t ContentAccessModifierMask();
+
+    static void Init();
+    static void OnChange(const char* aPrefName, void*);
+    static void Shutdown();
+
+  private:
+    static bool sKeyCausesActivation;
+    static bool sClickHoldContextMenu;
+    static int32_t sGenericAccessModifierKey;
+    static int32_t sChromeAccessModifierMask;
+    static int32_t sContentAccessModifierMask;
+
+    static int32_t GetAccessModifierMask(int32_t aItemType);
+  };
+
+  /**
+   * Get appropriate access modifier mask for the aDocShell.  Returns -1 if
+   * access key isn't available.
+   */
+  static int32_t GetAccessModifierMaskFor(nsISupports* aDocShell);
+
+  /*
+   * 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* aPresContext,
+                    WidgetEvent* aEvent,
+                    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).
+   */
+  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.
+   */
+  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.
+   * @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.
+   */
+  void NotifyMouseOut(WidgetMouseEvent* aMouseEvent,
+                      nsIContent* aMovingInto);
+  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
+   */
+  void FireDragEnterOrExit(nsPresContext* aPresContext,
+                           WidgetDragEvent* aDragEvent,
+                           EventMessage aMessage,
+                           nsIContent* aRelatedTarget,
+                           nsIContent* aTargetContent,
+                           nsWeakFrame& 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);
+
+  nsresult SetClickCount(WidgetMouseEvent* aEvent, nsEventStatus* aStatus);
+  nsresult CheckForAndDispatchClick(WidgetMouseEvent* aEvent,
+                                    nsEventStatus* aStatus);
+  void EnsureDocument(nsPresContext* aPresContext);
+  void FlushPendingEvents(nsPresContext* aPresContext);
+
+  /**
+   * The phases of HandleAccessKey processing. See below.
+   */
+  typedef enum {
+    eAccessKeyProcessingNormal = 0,
+    eAccessKeyProcessingUp,
+    eAccessKeyProcessingDown
+  } ProcessingAccessKeyState;
+
+  /**
+   * Access key handling.  If there is registered content for the accesskey
+   * given by the key event and modifier mask then call
+   * content.PerformAccesskey(), otherwise call HandleAccessKey() 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 aMatchesContentAccessKey true if the content accesskey modifier is pressed
+   * @param aBubbledFrom is used by an ancestor to avoid calling HandleAccessKey()
+   *        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 aModifierMask modifier mask for the key event
+   */
+  bool HandleAccessKey(WidgetKeyboardEvent* aEvent,
+                       nsPresContext* aPresContext,
+                       nsTArray<uint32_t>& aAccessCharCodes,
+                       bool aMatchesContentAccessKey,
+                       nsIDocShellTreeItem* aBubbledFrom,
+                       ProcessingAccessKeyState aAccessKeyState,
+                       int32_t aModifierMask);
+
+  bool ExecuteAccessKey(nsTArray<uint32_t>& aAccessCharCodes,
+                        bool aIsTrustedEvent);
+
+  //---------------------------------------------
+  // DocShell Focus Traversal Methods
+  //---------------------------------------------
+
+  nsIContent* GetFocusedContent();
+  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(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,
+      ACTION_LAST = ACTION_ZOOM,
+      // Following actions are used only by internal processing.  So, cannot
+      // specified by prefs.
+      ACTION_SEND_TO_PLUGIN
+    };
+    Action ComputeActionFor(WidgetWheelEvent* aEvent);
+
+    /**
+     * NeedToComputeLineOrPageDelta() returns if the aEvent needs to be
+     * computed the lineOrPageDelta values.
+     */
+    bool NeedToComputeLineOrPageDelta(WidgetWheelEvent* aEvent);
+
+    /**
+     * IsOverOnePageScrollAllowed*() checks whether wheel scroll amount should
+     * be rounded down to the page width/height (false) or not (true).
+     */
+    bool IsOverOnePageScrollAllowedX(WidgetWheelEvent* aEvent);
+    bool IsOverOnePageScrollAllowedY(WidgetWheelEvent* aEvent);
+
+    /**
+     * WheelEventsEnabledOnPlugins() returns true if user wants to use mouse
+     * wheel on plugins.
+     */
+    static bool WheelEventsEnabledOnPlugins();
+
+  private:
+    WheelPrefs();
+    ~WheelPrefs();
+
+    static void OnPrefChanged(const char* aPrefName, void* aClosure);
+
+    enum Index
+    {
+      INDEX_DEFAULT = 0,
+      INDEX_ALT,
+      INDEX_CONTROL,
+      INDEX_META,
+      INDEX_SHIFT,
+      INDEX_OS,
+      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, MODIFIER_SHIFT or MODIFIER_OS 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(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();
+
+    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;
+
+    static bool sWheelEventsEnabledOnPlugins;
+  };
+
+  /**
+   * 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.
+   */
+  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.
+   */
+  void SendPixelScrollEvent(nsIFrame* aTargetFrame,
+                            WidgetWheelEvent* aEvent,
+                            EventState& aState,
+                            int32_t aPixelDelta,
+                            DeltaDirection aDeltaDirection);
+
+  /**
+   * ComputeScrollTarget() 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 ComputeScrollTarget(). 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
+  };
+  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_EXCEPT_PLUGIN  =
+      (PREFER_MOUSE_WHEEL_TRANSACTION |
+       PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS |
+       PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS),
+    // When this is specified, the result may be nsPluginFrame.  In such case,
+    // the frame doesn't have nsIScrollableFrame interface.
+    COMPUTE_DEFAULT_ACTION_TARGET                =
+      (COMPUTE_DEFAULT_ACTION_TARGET_EXCEPT_PLUGIN |
+       INCLUDE_PLUGIN_AS_TARGET),
+    // 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)
+  };
+  static ComputeScrollTargetOptions RemovePluginFromTarget(
+                                      ComputeScrollTargetOptions aOptions)
+  {
+    switch (aOptions) {
+      case COMPUTE_DEFAULT_ACTION_TARGET:
+        return COMPUTE_DEFAULT_ACTION_TARGET_EXCEPT_PLUGIN;
+      default:
+        MOZ_ASSERT(!(aOptions & INCLUDE_PLUGIN_AS_TARGET));
+        return aOptions;
+    }
+  }
+  nsIFrame* ComputeScrollTarget(nsIFrame* aTargetFrame,
+                                WidgetWheelEvent* aEvent,
+                                ComputeScrollTargetOptions aOptions);
+
+  nsIFrame* ComputeScrollTarget(nsIFrame* aTargetFrame,
+                                double aDirectionX,
+                                double aDirectionY,
+                                WidgetWheelEvent* aEvent,
+                                ComputeScrollTargetOptions 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 ComputeScrollTarget() 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);
+  nsresult GetContentViewer(nsIContentViewer** aCv);
+  nsresult ChangeTextSize(int32_t change);
+  nsresult ChangeFullZoom(int32_t change);
+
+  /**
+   * 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);
+
+  friend class mozilla::dom::TabParent;
+  void BeginTrackingRemoteDragGesture(nsIContent* aContent);
+  void StopTrackingDragGesture();
+  void GenerateDragGesture(nsPresContext* aPresContext,
+                           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
+   * aSelection - [out] set to the selection to be dragged
+   * aTargetNode - [out] the draggable node, or null if there isn't one
+   */
+  void DetermineDragTargetAndDefaultData(nsPIDOMWindowOuter* aWindow,
+                                         nsIContent* aSelectionTarget,
+                                         dom::DataTransfer* aDataTransfer,
+                                         nsISelection** aSelection,
+                                         nsIContent** aTargetNode);
+
+  /*
+   * 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
+   * aDragTarget - the target of the drag
+   * aSelection - the selection to be dragged
+   */
+  bool DoDefaultDragStart(nsPresContext* aPresContext,
+                          WidgetDragEvent* aDragEvent,
+                          dom::DataTransfer* aDataTransfer,
+                          nsIContent* aDragTarget,
+                          nsISelection* aSelection);
+
+  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);
+
+  nsresult DoContentCommandEvent(WidgetContentCommandEvent* aEvent);
+  nsresult DoContentCommandScrollEvent(WidgetContentCommandEvent* aEvent);
+
+  dom::TabParent *GetCrossProcessTarget();
+  bool IsTargetCrossProcess(WidgetGUIEvent* aEvent);
+
+  bool DispatchCrossProcessEvent(WidgetEvent* aEvent,
+                                 nsFrameLoader* aRemote,
+                                 nsEventStatus *aStatus);
+  bool HandleCrossProcessEvent(WidgetEvent* aEvent,
+                               nsEventStatus* aStatus);
+
+  void ReleaseCurrentIMEContentObserver();
+
+  void HandleQueryContentEvent(WidgetQueryContentEvent* aEvent);
+
+private:
+  static inline void DoStateChange(dom::Element* aElement,
+                                   EventStates aState, bool aAddState);
+  static inline void DoStateChange(nsIContent* aContent, EventStates aState,
+                                   bool aAddState);
+  static void UpdateAncestorState(nsIContent* aStartNode,
+                                  nsIContent* aStopBefore,
+                                  EventStates aState,
+                                  bool aAddState);
+  static void ResetLastOverForContent(const uint32_t& aIdx,
+                                      RefPtr<OverOutElementsWrapper>& aChunk,
+                                      nsIContent* aClosure);
+
+  int32_t     mLockCursor;
+  bool mLastFrameConsumedSetCursor;
+
+  // Last mouse event mRefPoint (the offset from the widget's origin in
+  // device pixels) when mouse was locked, used to restore mouse position
+  // after unlocking.
+  static LayoutDeviceIntPoint sPreLockPoint;
+
+  // 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;
+
+  nsWeakFrame mCurrentTarget;
+  nsCOMPtr<nsIContent> mCurrentTargetContent;
+  static nsWeakFrame 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).
+  nsCOMPtr<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;
+  // State of keys when the original gesture-down happened
+  Modifiers mGestureModifiers;
+  uint16_t mGestureDownButtons;
+
+  nsCOMPtr<nsIContent> mLastLeftMouseDownContent;
+  nsCOMPtr<nsIContent> mLastLeftMouseDownContentParent;
+  nsCOMPtr<nsIContent> mLastMiddleMouseDownContent;
+  nsCOMPtr<nsIContent> mLastMiddleMouseDownContentParent;
+  nsCOMPtr<nsIContent> mLastRightMouseDownContent;
+  nsCOMPtr<nsIContent> mLastRightMouseDownContentParent;
+
+  nsCOMPtr<nsIContent> mActiveContent;
+  nsCOMPtr<nsIContent> mHoverContent;
+  static nsCOMPtr<nsIContent> sDragOverContent;
+  nsCOMPtr<nsIContent> mURLTargetContent;
+
+  nsPresContext* mPresContext;      // Not refcnted
+  nsCOMPtr<nsIDocument> mDocument;   // Doesn't necessarily need to be owner
+
+  RefPtr<IMEContentObserver> mIMEContentObserver;
+
+  uint32_t mLClickCount;
+  uint32_t mMClickCount;
+  uint32_t mRClickCount;
+
+  bool mInTouchDrag;
+
+  bool m_haveShutdown;
+
+  // Time at which we began handling user input. Reset to the epoch
+  // once we have finished handling user input.
+  static TimeStamp sHandlingInputStart;
+
+  // Time at which we began handling the latest user input. Not reset
+  // at the end of the input.
+  static TimeStamp sLatestUserInputStart;
+
+  RefPtr<OverOutElementsWrapper> mMouseEnterLeaveHelper;
+  nsRefPtrHashtable<nsUint32HashKey, OverOutElementsWrapper> mPointersEnterLeaveHelper;
+
+public:
+  static nsresult UpdateUserActivityTimer(void);
+  // Array for accesskey support
+  nsCOMArray<nsIContent> mAccessKeys;
+
+  // The number of user inputs handled since process start. This
+  // includes anything that is initiated by user, with the exception
+  // of page load events or mouse over events.
+  static uint64_t sUserInputCounter;
+
+  // The current depth of user inputs. This includes anything that is
+  // initiated by user, with the exception of page load events or
+  // mouse over events. Incremented whenever we start handling a user
+  // input, decremented when we have finished handling a user
+  // input. This depth is *not* reset in case of nested event loops.
+  static int32_t sUserInputEventDepth;
+  
+  static bool sNormalLMouseEventInProcess;
+
+  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();
+  void FireContextClick();
+
+  static void SetPointerLock(nsIWidget* aWidget, nsIContent* aElement) ;
+  static void sClickHoldCallback ( nsITimer* aTimer, void* aESM ) ;
+};
+
+/**
+ * This class is used while processing real user input. During this time, popups
+ * are allowed. For mousedown events, mouse capturing is also permitted.
+ */
+class AutoHandlingUserInputStatePusher
+{
+public:
+  AutoHandlingUserInputStatePusher(bool aIsHandlingUserInput,
+                                   WidgetEvent* aEvent,
+                                   nsIDocument* aDocument);
+  ~AutoHandlingUserInputStatePusher();
+
+protected:
+  bool mIsHandlingUserInput;
+  bool mIsMouseDown;
+  bool mResetFMMouseButtonHandlingState;
+
+  nsCOMPtr<nsIDocument> mMouseButtonEventHandlingDocument;
+
+private:
+  // Hide so that this class can only be stack-allocated
+  static void* operator new(size_t /*size*/) CPP_THROW_NEW { return nullptr; }
+  static void operator delete(void* /*memory*/) {}
+};
+
+} // 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)->HasPluginActivationEventMessage() && \
+     (event)->mMessage != eMouseClick && \
+     (event)->mMessage != eMouseDoubleClick)
+
+#endif // mozilla_EventStateManager_h_