Add m-esr52 at 52.6.0

1 files changed, 823 insertions, 0 deletions

diff --git a/layout/xul/nsXULPopupManager.h b/layout/xul/nsXULPopupManager.h
new file mode 100644
index 000000000..41644d7e9
--- /dev/null
+++ b/layout/xul/nsXULPopupManager.h
@@ -0,0 +1,823 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * The XUL Popup Manager keeps track of all open popups.
+ */
+
+#ifndef nsXULPopupManager_h__
+#define nsXULPopupManager_h__
+
+#include "mozilla/Logging.h"
+#include "nsIContent.h"
+#include "nsIRollupListener.h"
+#include "nsIDOMEventListener.h"
+#include "nsPoint.h"
+#include "nsCOMPtr.h"
+#include "nsTArray.h"
+#include "nsIObserver.h"
+#include "nsITimer.h"
+#include "nsIReflowCallback.h"
+#include "nsThreadUtils.h"
+#include "nsStyleConsts.h"
+#include "nsWidgetInitData.h"
+#include "mozilla/Attributes.h"
+#include "Units.h"
+
+// X.h defines KeyPress
+#ifdef KeyPress
+#undef KeyPress
+#endif
+
+/**
+ * There are two types that are used:
+ *   - dismissable popups such as menus, which should close up when there is a
+ *     click outside the popup. In this situation, the entire chain of menus
+ *     above should also be closed.
+ *   - panels, which stay open until a request is made to close them. This
+ *     type is used by tooltips.
+ *
+ * When a new popup is opened, it is appended to the popup chain, stored in a
+ * linked list in mPopups for dismissable menus and panels or mNoHidePanels
+ * for tooltips and panels with noautohide="true".
+ * Popups are stored in this list linked from newest to oldest. When a click
+ * occurs outside one of the open dismissable popups, the chain is closed by
+ * calling Rollup.
+ */
+
+class nsContainerFrame;
+class nsMenuFrame;
+class nsMenuPopupFrame;
+class nsMenuBarFrame;
+class nsMenuParent;
+class nsIDOMKeyEvent;
+class nsIDocShellTreeItem;
+class nsPIDOMWindowOuter;
+
+// when a menu command is executed, the closemenu attribute may be used
+// to define how the menu should be closed up
+enum CloseMenuMode {
+  CloseMenuMode_Auto, // close up the chain of menus, default value
+  CloseMenuMode_None, // don't close up any menus
+  CloseMenuMode_Single // close up only the menu the command is inside
+};
+
+/**
+ * nsNavigationDirection: an enum expressing navigation through the menus in
+ * terms which are independent of the directionality of the chrome. The
+ * terminology, derived from XSL-FO and CSS3 (e.g. 
+ * http://www.w3.org/TR/css3-text/#TextLayout), is BASE (Before, After, Start,
+ * End), with the addition of First and Last (mapped to Home and End
+ * respectively).
+ *
+ * In languages such as English where the inline progression is left-to-right
+ * and the block progression is top-to-bottom (lr-tb), these terms will map out
+ * as in the following diagram
+ *
+ *  --- inline progression --->
+ *
+ *           First              |
+ *           ...                |
+ *           Before             |
+ *         +--------+         block
+ *   Start |        | End  progression
+ *         +--------+           |
+ *           After              |
+ *           ...                |
+ *           Last               V
+ * 
+ */
+
+enum nsNavigationDirection {
+  eNavigationDirection_Last,
+  eNavigationDirection_First,
+  eNavigationDirection_Start,
+  eNavigationDirection_Before,
+  eNavigationDirection_End,
+  eNavigationDirection_After
+};
+
+enum nsIgnoreKeys {
+  eIgnoreKeys_False,
+  eIgnoreKeys_True,
+  eIgnoreKeys_Shortcuts,
+};
+
+#define NS_DIRECTION_IS_INLINE(dir) (dir == eNavigationDirection_Start ||     \
+                                     dir == eNavigationDirection_End)
+#define NS_DIRECTION_IS_BLOCK(dir) (dir == eNavigationDirection_Before || \
+                                    dir == eNavigationDirection_After)
+#define NS_DIRECTION_IS_BLOCK_TO_EDGE(dir) (dir == eNavigationDirection_First ||    \
+                                            dir == eNavigationDirection_Last)
+
+static_assert(NS_STYLE_DIRECTION_LTR == 0 && NS_STYLE_DIRECTION_RTL == 1,
+              "Left to Right should be 0 and Right to Left should be 1");
+
+/**
+ * DirectionFromKeyCodeTable: two arrays, the first for left-to-right and the
+ * other for right-to-left, that map keycodes to values of
+ * nsNavigationDirection.
+ */
+extern const nsNavigationDirection DirectionFromKeyCodeTable[2][6];
+
+#define NS_DIRECTION_FROM_KEY_CODE(frame, keycode)                     \
+  (DirectionFromKeyCodeTable[frame->StyleVisibility()->mDirection]  \
+                            [keycode - nsIDOMKeyEvent::DOM_VK_END])
+
+// nsMenuChainItem holds info about an open popup. Items are stored in a
+// doubly linked list. Note that the linked list is stored beginning from
+// the lowest child in a chain of menus, as this is the active submenu.
+class nsMenuChainItem
+{
+private:
+  nsMenuPopupFrame* mFrame; // the popup frame
+  nsPopupType mPopupType; // the popup type of the frame
+  bool mIsContext; // true for context menus
+  bool mOnMenuBar; // true if the menu is on a menu bar
+  nsIgnoreKeys mIgnoreKeys; // indicates how keyboard listeners should be used
+
+  nsMenuChainItem* mParent;
+  nsMenuChainItem* mChild;
+
+public:
+  nsMenuChainItem(nsMenuPopupFrame* aFrame, bool aIsContext, nsPopupType aPopupType)
+    : mFrame(aFrame),
+      mPopupType(aPopupType),
+      mIsContext(aIsContext),
+      mOnMenuBar(false),
+      mIgnoreKeys(eIgnoreKeys_False),
+      mParent(nullptr),
+      mChild(nullptr)
+  {
+    NS_ASSERTION(aFrame, "null frame passed to nsMenuChainItem constructor");
+    MOZ_COUNT_CTOR(nsMenuChainItem);
+  }
+
+  ~nsMenuChainItem()
+  {
+    MOZ_COUNT_DTOR(nsMenuChainItem);
+  }
+
+  nsIContent* Content();
+  nsMenuPopupFrame* Frame() { return mFrame; }
+  nsPopupType PopupType() { return mPopupType; }
+  bool IsMenu() { return mPopupType == ePopupTypeMenu; }
+  bool IsContextMenu() { return mIsContext; }
+  nsIgnoreKeys IgnoreKeys() { return mIgnoreKeys; }
+  void SetIgnoreKeys(nsIgnoreKeys aIgnoreKeys) { mIgnoreKeys = aIgnoreKeys; }
+  bool IsOnMenuBar() { return mOnMenuBar; }
+  void SetOnMenuBar(bool aOnMenuBar) { mOnMenuBar = aOnMenuBar; }
+  nsMenuChainItem* GetParent() { return mParent; }
+  nsMenuChainItem* GetChild() { return mChild; }
+
+  // set the parent of this item to aParent, also changing the parent
+  // to have this as a child.
+  void SetParent(nsMenuChainItem* aParent);
+
+  // removes an item from the chain. The root pointer must be supplied in case
+  // the item is the first item in the chain in which case the pointer will be
+  // set to the next item, or null if there isn't another item. After detaching,
+  // this item will not have a parent or a child.
+  void Detach(nsMenuChainItem** aRoot);
+};
+
+// this class is used for dispatching popupshowing events asynchronously.
+class nsXULPopupShowingEvent : public mozilla::Runnable
+{
+public:
+  nsXULPopupShowingEvent(nsIContent *aPopup,
+                         bool aIsContextMenu,
+                         bool aSelectFirstItem)
+    : mPopup(aPopup),
+      mIsContextMenu(aIsContextMenu),
+      mSelectFirstItem(aSelectFirstItem)
+  {
+    NS_ASSERTION(aPopup, "null popup supplied to nsXULPopupShowingEvent constructor");
+  }
+
+  NS_IMETHOD Run() override;
+
+private:
+  nsCOMPtr<nsIContent> mPopup;
+  bool mIsContextMenu;
+  bool mSelectFirstItem;
+};
+
+// this class is used for dispatching popuphiding events asynchronously.
+class nsXULPopupHidingEvent : public mozilla::Runnable
+{
+public:
+  nsXULPopupHidingEvent(nsIContent *aPopup,
+                        nsIContent* aNextPopup,
+                        nsIContent* aLastPopup,
+                        nsPopupType aPopupType,
+                        bool aDeselectMenu,
+                        bool aIsCancel)
+    : mPopup(aPopup),
+      mNextPopup(aNextPopup),
+      mLastPopup(aLastPopup),
+      mPopupType(aPopupType),
+      mDeselectMenu(aDeselectMenu),
+      mIsRollup(aIsCancel)
+  {
+    NS_ASSERTION(aPopup, "null popup supplied to nsXULPopupHidingEvent constructor");
+    // aNextPopup and aLastPopup may be null
+  }
+
+  NS_IMETHOD Run() override;
+
+private:
+  nsCOMPtr<nsIContent> mPopup;
+  nsCOMPtr<nsIContent> mNextPopup;
+  nsCOMPtr<nsIContent> mLastPopup;
+  nsPopupType mPopupType;
+  bool mDeselectMenu;
+  bool mIsRollup;
+};
+
+// this class is used for dispatching popuppositioned events asynchronously.
+class nsXULPopupPositionedEvent : public mozilla::Runnable
+{
+public:
+  explicit nsXULPopupPositionedEvent(nsIContent *aPopup,
+                                     bool aIsContextMenu,
+                                     bool aSelectFirstItem)
+    : mPopup(aPopup)
+    , mIsContextMenu(aIsContextMenu)
+    , mSelectFirstItem(aSelectFirstItem)
+  {
+    NS_ASSERTION(aPopup, "null popup supplied to nsXULPopupShowingEvent constructor");
+  }
+
+  NS_IMETHOD Run() override;
+
+  // Asynchronously dispatch a popuppositioned event at aPopup if this is a
+  // panel that should receieve such events. Return true if the event was sent.
+  static bool DispatchIfNeeded(nsIContent *aPopup,
+                               bool aIsContextMenu,
+                               bool aSelectFirstItem);
+
+private:
+  nsCOMPtr<nsIContent> mPopup;
+  bool mIsContextMenu;
+  bool mSelectFirstItem;
+};
+
+// this class is used for dispatching menu command events asynchronously.
+class nsXULMenuCommandEvent : public mozilla::Runnable
+{
+public:
+  nsXULMenuCommandEvent(nsIContent *aMenu,
+                        bool aIsTrusted,
+                        bool aShift,
+                        bool aControl,
+                        bool aAlt,
+                        bool aMeta,
+                        bool aUserInput,
+                        bool aFlipChecked)
+    : mMenu(aMenu),
+      mIsTrusted(aIsTrusted),
+      mShift(aShift),
+      mControl(aControl),
+      mAlt(aAlt),
+      mMeta(aMeta),
+      mUserInput(aUserInput),
+      mFlipChecked(aFlipChecked),
+      mCloseMenuMode(CloseMenuMode_Auto)
+  {
+    NS_ASSERTION(aMenu, "null menu supplied to nsXULMenuCommandEvent constructor");
+  }
+
+  NS_IMETHOD Run() override;
+
+  void SetCloseMenuMode(CloseMenuMode aCloseMenuMode) { mCloseMenuMode = aCloseMenuMode; }
+
+private:
+  nsCOMPtr<nsIContent> mMenu;
+  bool mIsTrusted;
+  bool mShift;
+  bool mControl;
+  bool mAlt;
+  bool mMeta;
+  bool mUserInput;
+  bool mFlipChecked;
+  CloseMenuMode mCloseMenuMode;
+};
+
+class nsXULPopupManager final : public nsIDOMEventListener,
+                                public nsIRollupListener,
+                                public nsITimerCallback,
+                                public nsIObserver
+{
+
+public:
+  friend class nsXULPopupShowingEvent;
+  friend class nsXULPopupHidingEvent;
+  friend class nsXULPopupPositionedEvent;
+  friend class nsXULMenuCommandEvent;
+  friend class TransitionEnder;
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+  NS_DECL_NSITIMERCALLBACK
+  NS_DECL_NSIDOMEVENTLISTENER
+
+  // nsIRollupListener
+  virtual bool Rollup(uint32_t aCount, bool aFlush,
+                      const nsIntPoint* pos, nsIContent** aLastRolledUp) override;
+  virtual bool ShouldRollupOnMouseWheelEvent() override;
+  virtual bool ShouldConsumeOnMouseWheelEvent() override;
+  virtual bool ShouldRollupOnMouseActivate() override;
+  virtual uint32_t GetSubmenuWidgetChain(nsTArray<nsIWidget*> *aWidgetChain) override;
+  virtual void NotifyGeometryChange() override {}
+  virtual nsIWidget* GetRollupWidget() override;
+
+  static nsXULPopupManager* sInstance;
+
+  // initialize and shutdown methods called by nsLayoutStatics
+  static nsresult Init();
+  static void Shutdown();
+
+  // returns a weak reference to the popup manager instance, could return null
+  // if a popup manager could not be allocated
+  static nsXULPopupManager* GetInstance();
+
+  // This should be called when a window is moved or resized to adjust the
+  // popups accordingly.
+  void AdjustPopupsOnWindowChange(nsPIDOMWindowOuter* aWindow);
+  void AdjustPopupsOnWindowChange(nsIPresShell* aPresShell);
+
+  // given a menu frame, find the prevous or next menu frame. If aPopup is
+  // true then navigate a menupopup, from one item on the menu to the previous
+  // or next one. This is used for cursor navigation between items in a popup
+  // menu. If aIsPopup is false, the navigation is on a menubar, so navigate
+  // between menus on the menubar. This is used for left/right cursor navigation.
+  //
+  // Items that are not valid, such as non-menu or non-menuitem elements are
+  // skipped, and the next or previous item after that is checked.
+  //
+  // If aStart is null, the first valid item is retrieved by GetNextMenuItem
+  // and the last valid item is retrieved by GetPreviousMenuItem.
+  //
+  // Both methods will loop around the beginning or end if needed.
+  //
+  // aParent - the parent menubar or menupopup
+  // aStart - the menu/menuitem to start navigation from. GetPreviousMenuItem
+  //          returns the item before it, while GetNextMenuItem returns the
+  //          item after it.
+  // aIsPopup - true for menupopups, false for menubars
+  static nsMenuFrame* GetPreviousMenuItem(nsContainerFrame* aParent,
+                                          nsMenuFrame* aStart,
+                                          bool aIsPopup);
+  static nsMenuFrame* GetNextMenuItem(nsContainerFrame* aParent,
+                                      nsMenuFrame* aStart,
+                                      bool aIsPopup);
+
+  // returns true if the menu item aContent is a valid menuitem which may
+  // be navigated to. aIsPopup should be true for items on a popup, or false
+  // for items on a menubar.
+  static bool IsValidMenuItem(nsIContent* aContent, bool aOnPopup);
+
+  // inform the popup manager that a menu bar has been activated or deactivated,
+  // either because one of its menus has opened or closed, or that the menubar
+  // has been focused such that its menus may be navigated with the keyboard.
+  // aActivate should be true when the menubar should be focused, and false
+  // when the active menu bar should be defocused. In the latter case, if
+  // aMenuBar isn't currently active, yet another menu bar is, that menu bar
+  // will remain active.
+  void SetActiveMenuBar(nsMenuBarFrame* aMenuBar, bool aActivate);
+
+  // retrieve the node and offset of the last mouse event used to open a
+  // context menu. This information is determined from the rangeParent and
+  // the rangeOffset of the event supplied to ShowPopup or ShowPopupAtScreen.
+  // This is used by the implementation of nsIDOMXULDocument::GetPopupRangeParent
+  // and nsIDOMXULDocument::GetPopupRangeOffset.
+  void GetMouseLocation(nsIDOMNode** aNode, int32_t* aOffset);
+
+  /**
+   * Open a <menu> given its content node. If aSelectFirstItem is
+   * set to true, the first item on the menu will automatically be
+   * selected. If aAsynchronous is true, the event will be dispatched
+   * asynchronously. This should be true when called from frame code.
+   */
+  void ShowMenu(nsIContent *aMenu, bool aSelectFirstItem, bool aAsynchronous);
+
+  /**
+   * Open a popup, either anchored or unanchored. If aSelectFirstItem is
+   * true, then the first item in the menu is selected. The arguments are
+   * similar to those for nsIPopupBoxObject::OpenPopup.
+   *
+   * aTriggerEvent should be the event that triggered the event. This is used
+   * to determine the coordinates and trigger node for the popup. This may be
+   * null if the popup was not triggered by an event.
+   *
+   * This fires the popupshowing event synchronously.
+   */
+  void ShowPopup(nsIContent* aPopup,
+                 nsIContent* aAnchorContent,
+                 const nsAString& aPosition,
+                 int32_t aXPos, int32_t aYPos,
+                 bool aIsContextMenu,
+                 bool aAttributesOverride,
+                 bool aSelectFirstItem,
+                 nsIDOMEvent* aTriggerEvent);
+
+  /**
+   * Open a popup at a specific screen position specified by aXPos and aYPos,
+   * measured in CSS pixels.
+   *
+   * This fires the popupshowing event synchronously.
+   * 
+   * If aIsContextMenu is true, the popup is positioned at a slight
+   * offset from aXPos/aYPos to ensure that it is not under the mouse
+   * cursor.
+   */
+  void ShowPopupAtScreen(nsIContent* aPopup,
+                         int32_t aXPos, int32_t aYPos,
+                         bool aIsContextMenu,
+                         nsIDOMEvent* aTriggerEvent);
+
+  /* Open a popup anchored at a screen rectangle specified by aRect.
+   * The remaining arguments are similar to ShowPopup.
+   */
+  void ShowPopupAtScreenRect(nsIContent* aPopup,
+                             const nsAString& aPosition,
+                             const nsIntRect& aRect,
+                             bool aIsContextMenu,
+                             bool aAttributesOverride,
+                             nsIDOMEvent* aTriggerEvent);
+
+  /**
+   * Open a tooltip at a specific screen position specified by aXPos and aYPos,
+   * measured in CSS pixels.
+   *
+   * This fires the popupshowing event synchronously.
+   */
+  void ShowTooltipAtScreen(nsIContent* aPopup,
+                           nsIContent* aTriggerContent,
+                           int32_t aXPos, int32_t aYPos);
+
+  /**
+   * This method is provided only for compatibility with an older popup API.
+   * New code should not call this function and should call ShowPopup instead.
+   *
+   * This fires the popupshowing event synchronously.
+   */
+  void ShowPopupWithAnchorAlign(nsIContent* aPopup,
+                                nsIContent* aAnchorContent,
+                                nsAString& aAnchor,
+                                nsAString& aAlign,
+                                int32_t aXPos, int32_t aYPos,
+                                bool aIsContextMenu);
+
+  /*
+   * Hide a popup aPopup. If the popup is in a <menu>, then also inform the
+   * menu that the popup is being hidden.
+   *
+   * aHideChain - true if the entire chain of menus should be closed. If false,
+   *              only this popup is closed.
+   * aDeselectMenu - true if the parent <menu> of the popup should be deselected.
+   *                 This will be false when the menu is closed by pressing the
+   *                 Escape key.
+   * aAsynchronous - true if the first popuphiding event should be sent
+   *                 asynchrously. This should be true if HidePopup is called
+   *                 from a frame.
+   * aIsCancel - true if this popup is hiding due to being cancelled.
+   * aLastPopup - optional popup to close last when hiding a chain of menus.
+   *              If null, then all popups will be closed.
+   */
+  void HidePopup(nsIContent* aPopup,
+                 bool aHideChain,
+                 bool aDeselectMenu,
+                 bool aAsynchronous,
+                 bool aIsCancel,
+                 nsIContent* aLastPopup = nullptr);
+
+  /**
+   * Hide the popup aFrame. This method is called by the view manager when the
+   * close button is pressed.
+   */
+  void HidePopup(nsIFrame* aFrame);
+
+  /**
+   * Hide a popup after a short delay. This is used when rolling over menu items.
+   * This timer is stored in mCloseTimer. The timer may be cancelled and the popup
+   * closed by calling KillMenuTimer.
+   */
+  void HidePopupAfterDelay(nsMenuPopupFrame* aPopup);
+
+  /**
+   * Hide all of the popups from a given docshell. This should be called when the
+   * document is hidden.
+   */
+  void HidePopupsInDocShell(nsIDocShellTreeItem* aDocShellToHide);
+
+  /**
+   * Enable or disable the dynamic noautohide state of a panel.
+   *
+   * aPanel - the panel whose state is to change
+   * aShouldRollup - whether the panel is no longer noautohide
+   */
+  void EnableRollup(nsIContent* aPopup, bool aShouldRollup);
+
+  /**
+   * Execute a menu command from the triggering event aEvent.
+   *
+   * aMenu - a menuitem to execute
+   * aEvent - an nsXULMenuCommandEvent that contains all the info from the mouse
+   *          event which triggered the menu to be executed, may not be null
+   */
+  void ExecuteMenu(nsIContent* aMenu, nsXULMenuCommandEvent* aEvent);
+
+  /**
+   * Return true if the popup for the supplied content node is open.
+   */
+  bool IsPopupOpen(nsIContent* aPopup);
+
+  /**
+   * Return true if the popup for the supplied menu parent is open.
+   */
+  bool IsPopupOpenForMenuParent(nsMenuParent* aMenuParent);
+
+  /**
+   * Return the frame for the topmost open popup of a given type, or null if
+   * no popup of that type is open. If aType is ePopupTypeAny, a menu of any
+   * type is returned, except for popups in the mNoHidePanels list.
+   */
+  nsIFrame* GetTopPopup(nsPopupType aType);
+
+  /**
+   * Return an array of all the open and visible popup frames for
+   * menus, in order from top to bottom.
+   */
+  void GetVisiblePopups(nsTArray<nsIFrame *>& aPopups);
+
+  /**
+   * Get the node that last triggered a popup or tooltip in the document
+   * aDocument. aDocument must be non-null and be a document contained within
+   * the same window hierarchy as the popup to retrieve.
+   */
+  already_AddRefed<nsIDOMNode> GetLastTriggerPopupNode(nsIDocument* aDocument)
+  {
+    return GetLastTriggerNode(aDocument, false);
+  }
+
+  already_AddRefed<nsIDOMNode> GetLastTriggerTooltipNode(nsIDocument* aDocument)
+  {
+    return GetLastTriggerNode(aDocument, true);
+  }
+
+  /**
+   * Return false if a popup may not be opened. This will return false if the
+   * popup is already open, if the popup is in a content shell that is not
+   * focused, or if it is a submenu of another menu that isn't open.
+   */
+  bool MayShowPopup(nsMenuPopupFrame* aFrame);
+
+  /**
+   * Indicate that the popup associated with aView has been moved to the
+   * specified screen coordiates.
+   */
+  void PopupMoved(nsIFrame* aFrame, nsIntPoint aPoint);
+
+  /**
+   * Indicate that the popup associated with aView has been resized to the
+   * given device pixel size aSize.
+   */
+  void PopupResized(nsIFrame* aFrame, mozilla::LayoutDeviceIntSize aSize);
+
+  /**
+   * Called when a popup frame is destroyed. In this case, just remove the
+   * item and later popups from the list. No point going through HidePopup as
+   * the frames have gone away.
+   */
+  void PopupDestroyed(nsMenuPopupFrame* aFrame);
+
+  /**
+   * Returns true if there is a context menu open. If aPopup is specified,
+   * then the context menu must be later in the chain than aPopup. If aPopup
+   * is null, returns true if any context menu at all is open.
+   */
+  bool HasContextMenu(nsMenuPopupFrame* aPopup);
+
+  /**
+   * Update the commands for the menus within the menu popup for a given
+   * content node. aPopup should be a XUL menupopup element. This method
+   * changes attributes on the children of aPopup, and deals only with the
+   * content of the popup, not the frames.
+   */
+  void UpdateMenuItems(nsIContent* aPopup);
+
+  /**
+   * Stop the timer which hides a popup after a delay, started by a previous
+   * call to HidePopupAfterDelay. In addition, the popup awaiting to be hidden
+   * is closed asynchronously.
+   */
+  void KillMenuTimer();
+
+  /**
+   * Cancel the timer which closes menus after delay, but only if the menu to
+   * close is aMenuParent. When a submenu is opened, the user might move the
+   * mouse over a sibling menuitem which would normally close the menu. This
+   * menu is closed via a timer. However, if the user moves the mouse over the
+   * submenu before the timer fires, we should instead cancel the timer. This
+   * ensures that the user can move the mouse diagonally over a menu.
+   */
+  void CancelMenuTimer(nsMenuParent* aMenuParent);
+
+  /**
+   * Handles navigation for menu accelkeys. If aFrame is specified, then the
+   * key is handled by that popup, otherwise if aFrame is null, the key is
+   * handled by the active popup or menubar.
+   */
+  bool HandleShortcutNavigation(nsIDOMKeyEvent* aKeyEvent,
+                                nsMenuPopupFrame* aFrame);
+
+  /**
+   * Handles cursor navigation within a menu. Returns true if the key has
+   * been handled.
+   */
+  bool HandleKeyboardNavigation(uint32_t aKeyCode);
+
+  /**
+   * Handle keyboard navigation within a menu popup specified by aFrame.
+   * Returns true if the key was handled and other default handling
+   * should not occur.
+   */
+  bool HandleKeyboardNavigationInPopup(nsMenuPopupFrame* aFrame,
+                                         nsNavigationDirection aDir)
+  {
+    return HandleKeyboardNavigationInPopup(nullptr, aFrame, aDir);
+  }
+
+  /**
+   * Handles the keyboard event with keyCode value. Returns true if the event
+   * has been handled.
+   */
+  bool HandleKeyboardEventWithKeyCode(nsIDOMKeyEvent* aKeyEvent,
+                                      nsMenuChainItem* aTopVisibleMenuItem);
+
+  nsresult KeyUp(nsIDOMKeyEvent* aKeyEvent);
+  nsresult KeyDown(nsIDOMKeyEvent* aKeyEvent);
+  nsresult KeyPress(nsIDOMKeyEvent* aKeyEvent);
+
+protected:
+  nsXULPopupManager();
+  ~nsXULPopupManager();
+
+  // get the nsMenuPopupFrame, if any, for the given content node
+  nsMenuPopupFrame* GetPopupFrameForContent(nsIContent* aContent, bool aShouldFlush);
+
+  // return the topmost menu, skipping over invisible popups
+  nsMenuChainItem* GetTopVisibleMenu();
+
+  // Hide all of the visible popups from the given list. This function can
+  // cause style changes and frame destruction.
+  void HidePopupsInList(const nsTArray<nsMenuPopupFrame *> &aFrames);
+
+  // set the event that was used to trigger the popup, or null to clear the
+  // event details. aTriggerContent will be set to the target of the event.
+  void InitTriggerEvent(nsIDOMEvent* aEvent, nsIContent* aPopup, nsIContent** aTriggerContent);
+
+  // callbacks for ShowPopup and HidePopup as events may be done asynchronously
+  void ShowPopupCallback(nsIContent* aPopup,
+                         nsMenuPopupFrame* aPopupFrame,
+                         bool aIsContextMenu,
+                         bool aSelectFirstItem);
+  void HidePopupCallback(nsIContent* aPopup,
+                         nsMenuPopupFrame* aPopupFrame,
+                         nsIContent* aNextPopup,
+                         nsIContent* aLastPopup,
+                         nsPopupType aPopupType,
+                         bool aDeselectMenu);
+
+  /**
+   * Fire a popupshowing event on the popup and then open the popup.
+   *
+   * aPopup - the popup to open
+   * aIsContextMenu - true for context menus
+   * aSelectFirstItem - true to select the first item in the menu
+   */
+  void FirePopupShowingEvent(nsIContent* aPopup,
+                             bool aIsContextMenu,
+                             bool aSelectFirstItem);
+
+  /**
+   * Fire a popuphiding event and then hide the popup. This will be called
+   * recursively if aNextPopup and aLastPopup are set in order to hide a chain
+   * of open menus. If these are not set, only one popup is closed. However,
+   * if the popup type indicates a menu, yet the next popup is not a menu,
+   * then this ends the closing of popups. This allows a menulist inside a
+   * non-menu to close up the menu but not close up the panel it is contained
+   * within.
+   *
+   * The caller must keep a strong reference to aPopup, aNextPopup and aLastPopup.
+   *
+   * aPopup - the popup to hide
+   * aNextPopup - the next popup to hide
+   * aLastPopup - the last popup in the chain to hide
+   * aPresContext - nsPresContext for the popup's frame
+   * aPopupType - the PopupType of the frame. 
+   * aDeselectMenu - true to unhighlight the menu when hiding it
+   * aIsCancel - true if this popup is hiding due to being cancelled.
+   */
+  void FirePopupHidingEvent(nsIContent* aPopup,
+                            nsIContent* aNextPopup,
+                            nsIContent* aLastPopup,
+                            nsPresContext *aPresContext,
+                            nsPopupType aPopupType,
+                            bool aDeselectMenu,
+                            bool aIsCancel);
+
+  /**
+   * Handle keyboard navigation within a menu popup specified by aItem.
+   */
+  bool HandleKeyboardNavigationInPopup(nsMenuChainItem* aItem,
+                                         nsNavigationDirection aDir)
+  {
+    return HandleKeyboardNavigationInPopup(aItem, aItem->Frame(), aDir);
+  }
+
+private:
+  /**
+   * Handle keyboard navigation within a menu popup aFrame. If aItem is
+   * supplied, then it is expected to have a frame equal to aFrame.
+   * If aItem is non-null, then the navigation may be redirected to
+   * an open submenu if one exists. Returns true if the key was
+   * handled and other default handling should not occur.
+   */
+  bool HandleKeyboardNavigationInPopup(nsMenuChainItem* aItem,
+                                         nsMenuPopupFrame* aFrame,
+                                         nsNavigationDirection aDir);
+
+protected:
+
+  already_AddRefed<nsIDOMNode> GetLastTriggerNode(nsIDocument* aDocument, bool aIsTooltip);
+
+  /**
+   * Set mouse capturing for the current popup. This traps mouse clicks that
+   * occur outside the popup so that it can be closed up. aOldPopup should be
+   * set to the popup that was previously the current popup.
+   */
+  void SetCaptureState(nsIContent *aOldPopup);
+
+  /**
+   * Key event listeners are attached to the document containing the current
+   * menu for menu and shortcut navigation. Only one listener is needed at a
+   * time, stored in mKeyListener, so switch it only if the document changes.
+   * Having menus in different documents is very rare, so the listeners will
+   * usually only be attached when the first menu opens and removed when all
+   * menus have closed.
+   *
+   * This is also used when only a menubar is active without any open menus,
+   * so that keyboard navigation between menus on the menubar may be done.
+   */
+  void UpdateKeyboardListeners();
+
+  /*
+   * Returns true if the docshell for aDoc is aExpected or a child of aExpected.
+   */
+  bool IsChildOfDocShell(nsIDocument* aDoc, nsIDocShellTreeItem* aExpected);
+
+  // the document the key event listener is attached to
+  nsCOMPtr<mozilla::dom::EventTarget> mKeyListener;
+
+  // widget that is currently listening to rollup events
+  nsCOMPtr<nsIWidget> mWidget;
+
+  // range parent and offset set in SetTriggerEvent
+  nsCOMPtr<nsIDOMNode> mRangeParent;
+  int32_t mRangeOffset;
+  // Device pixels relative to the showing popup's presshell's
+  // root prescontext's root frame.
+  mozilla::LayoutDeviceIntPoint mCachedMousePoint;
+
+  // cached modifiers
+  mozilla::Modifiers mCachedModifiers;
+
+  // set to the currently active menu bar, if any
+  nsMenuBarFrame* mActiveMenuBar;
+
+  // linked list of normal menus and panels.
+  nsMenuChainItem* mPopups;
+
+  // linked list of noautohide panels and tooltips.
+  nsMenuChainItem* mNoHidePanels;
+
+  // timer used for HidePopupAfterDelay
+  nsCOMPtr<nsITimer> mCloseTimer;
+
+  // a popup that is waiting on the timer
+  nsMenuPopupFrame* mTimerMenu;
+
+  // the popup that is currently being opened, stored only during the
+  // popupshowing event
+  nsCOMPtr<nsIContent> mOpeningPopup;
+
+  // If true, all popups won't hide automatically on blur
+  static bool sDevtoolsDisableAutoHide;
+};
+
+#endif