The Tor Browser: layout/xul/nsXULPopupManager.cpp@ac0c01689b40 (annotated)

layout/xul/nsXULPopupManager.cpp@ac0c01689b40 (annotated)

layout/xul/nsXULPopupManager.cpp

Thu, 15 Jan 2015 15:59:08 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:59:08 +0100
branch: TOR_BUG_9701
changeset 10: ac0c01689b40
permissions: -rw-r--r--

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- 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/. */
 #include "nsGkAtoms.h"
 #include "nsXULPopupManager.h"
 #include "nsMenuFrame.h"
 #include "nsMenuPopupFrame.h"
 #include "nsMenuBarFrame.h"
 #include "nsIPopupBoxObject.h"
 #include "nsMenuBarListener.h"
 #include "nsContentUtils.h"
 #include "nsIDOMDocument.h"
 #include "nsIDOMEvent.h"
 #include "nsIDOMXULElement.h"
 #include "nsIXULDocument.h"
 #include "nsIXULTemplateBuilder.h"
 #include "nsCSSFrameConstructor.h"
 #include "nsLayoutUtils.h"
 #include "nsViewManager.h"
 #include "nsIComponentManager.h"
 #include "nsITimer.h"
 #include "nsFocusManager.h"
 #include "nsIDocShell.h"
 #include "nsPIDOMWindow.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "nsIBaseWindow.h"
 #include "nsIDOMKeyEvent.h"
 #include "nsIDOMMouseEvent.h"
 #include "nsCaret.h"
 #include "nsIDocument.h"
 #include "nsPIWindowRoot.h"
 #include "nsFrameManager.h"
 #include "nsIObserverService.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/Event.h" // for nsIDOMEvent::InternalDOMEvent()
 #include "mozilla/EventDispatcher.h"
 #include "mozilla/EventStateManager.h"
 #include "mozilla/LookAndFeel.h"
 #include "mozilla/MouseEvents.h"
 #include "mozilla/Services.h"
 using namespace mozilla;
 using namespace mozilla::dom;
 static_assert(nsIDOMKeyEvent::DOM_VK_HOME  == nsIDOMKeyEvent::DOM_VK_END + 1 &&
               nsIDOMKeyEvent::DOM_VK_LEFT  == nsIDOMKeyEvent::DOM_VK_END + 2 &&
               nsIDOMKeyEvent::DOM_VK_UP    == nsIDOMKeyEvent::DOM_VK_END + 3 &&
               nsIDOMKeyEvent::DOM_VK_RIGHT == nsIDOMKeyEvent::DOM_VK_END + 4 &&
               nsIDOMKeyEvent::DOM_VK_DOWN  == nsIDOMKeyEvent::DOM_VK_END + 5,
               "nsXULPopupManager assumes some keyCode values are consecutive");
 const nsNavigationDirection DirectionFromKeyCodeTable[2][6] = {
   {
     eNavigationDirection_Last,   // nsIDOMKeyEvent::DOM_VK_END
     eNavigationDirection_First,  // nsIDOMKeyEvent::DOM_VK_HOME
     eNavigationDirection_Start,  // nsIDOMKeyEvent::DOM_VK_LEFT
     eNavigationDirection_Before, // nsIDOMKeyEvent::DOM_VK_UP
     eNavigationDirection_End,    // nsIDOMKeyEvent::DOM_VK_RIGHT
     eNavigationDirection_After   // nsIDOMKeyEvent::DOM_VK_DOWN
   },
   {
     eNavigationDirection_Last,   // nsIDOMKeyEvent::DOM_VK_END
     eNavigationDirection_First,  // nsIDOMKeyEvent::DOM_VK_HOME
     eNavigationDirection_End,    // nsIDOMKeyEvent::DOM_VK_LEFT
     eNavigationDirection_Before, // nsIDOMKeyEvent::DOM_VK_UP
     eNavigationDirection_Start,  // nsIDOMKeyEvent::DOM_VK_RIGHT
     eNavigationDirection_After   // nsIDOMKeyEvent::DOM_VK_DOWN
   }
 };
 nsXULPopupManager* nsXULPopupManager::sInstance = nullptr;
 nsIContent* nsMenuChainItem::Content()
 {
   return mFrame->GetContent();
 }
 void nsMenuChainItem::SetParent(nsMenuChainItem* aParent)
 {
   if (mParent) {
     NS_ASSERTION(mParent->mChild == this, "Unexpected - parent's child not set to this");
     mParent->mChild = nullptr;
   }
   mParent = aParent;
   if (mParent) {
     if (mParent->mChild)
       mParent->mChild->mParent = nullptr;
     mParent->mChild = this;
   }
 }
 void nsMenuChainItem::Detach(nsMenuChainItem** aRoot)
 {
   // If the item has a child, set the child's parent to this item's parent,
   // effectively removing the item from the chain. If the item has no child,
   // just set the parent to null.
   if (mChild) {
     NS_ASSERTION(this != *aRoot, "Unexpected - popup with child at end of chain");
     mChild->SetParent(mParent);
   }
   else {
     // An item without a child should be the first item in the chain, so set
     // the first item pointer, pointed to by aRoot, to the parent.
     NS_ASSERTION(this == *aRoot, "Unexpected - popup with no child not at end of chain");
     *aRoot = mParent;
     SetParent(nullptr);
   }
 }
 NS_IMPL_ISUPPORTS(nsXULPopupManager,
                   nsIDOMEventListener,
                   nsITimerCallback,
                   nsIObserver)
 nsXULPopupManager::nsXULPopupManager() :
   mRangeOffset(0),
   mCachedMousePoint(0, 0),
   mCachedModifiers(0),
   mActiveMenuBar(nullptr),
   mPopups(nullptr),
   mNoHidePanels(nullptr),
   mTimerMenu(nullptr)
 {
   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
   if (obs) {
     obs->AddObserver(this, "xpcom-shutdown", false);
   }
 }
 nsXULPopupManager::~nsXULPopupManager()
 {
   NS_ASSERTION(!mPopups && !mNoHidePanels, "XUL popups still open");
 }
 nsresult
 nsXULPopupManager::Init()
 {
   sInstance = new nsXULPopupManager();
   NS_ENSURE_TRUE(sInstance, NS_ERROR_OUT_OF_MEMORY);
   NS_ADDREF(sInstance);
   return NS_OK;
 }
 void
 nsXULPopupManager::Shutdown()
 {
   NS_IF_RELEASE(sInstance);
 }
 NS_IMETHODIMP
 nsXULPopupManager::Observe(nsISupports *aSubject,
                            const char *aTopic,
                            const char16_t *aData)
 {
   if (!nsCRT::strcmp(aTopic, "xpcom-shutdown")) {
     if (mKeyListener) {
       mKeyListener->RemoveEventListener(NS_LITERAL_STRING("keypress"), this, true);
       mKeyListener->RemoveEventListener(NS_LITERAL_STRING("keydown"), this, true);
       mKeyListener->RemoveEventListener(NS_LITERAL_STRING("keyup"), this, true);
       mKeyListener = nullptr;
     }
     mRangeParent = nullptr;
     // mOpeningPopup is cleared explicitly soon after using it.
     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
     if (obs) {
       obs->RemoveObserver(this, "xpcom-shutdown");
     }
   }
   return NS_OK;
 }
 nsXULPopupManager*
 nsXULPopupManager::GetInstance()
 {
   MOZ_ASSERT(sInstance);
   return sInstance;
 }
 bool
 nsXULPopupManager::Rollup(uint32_t aCount, const nsIntPoint* pos, nsIContent** aLastRolledUp)
 {
   bool consume = false;
   nsMenuChainItem* item = GetTopVisibleMenu();
   if (item) {
     if (aLastRolledUp) {
       // we need to get the popup that will be closed last, so that
       // widget can keep track of it so it doesn't reopen if a mouse
       // down event is going to processed.
       // Keep going up the menu chain to get the first level menu. This will
       // be the one that closes up last. It's possible that this menu doesn't
       // end up closing because the popuphiding event was cancelled, but in
       // that case we don't need to deal with the menu reopening as it will
       // already still be open.
       nsMenuChainItem* first = item;
       while (first->GetParent())
         first = first->GetParent();
       *aLastRolledUp = first->Content();
     }
     consume = item->Frame()->ConsumeOutsideClicks();
     // If the click was over the anchor, always consume the click. This way,
     // clicking on a menu doesn't reopen the menu.
     if (!consume && pos) {
       nsCOMPtr<nsIContent> anchor = item->Frame()->GetAnchor();
       if (anchor && anchor->GetPrimaryFrame()) {
         // It's possible that some other element is above the anchor at the same
         // position, but the only thing that would happen is that the mouse
         // event will get consumed, so here only a quick coordinates check is
         // done rather than a slower complete check of what is at that location.
         if (anchor->GetPrimaryFrame()->GetScreenRect().Contains(*pos)) {
           consume = true;
         }
       }
     }
     // if a number of popups to close has been specified, determine the last
     // popup to close
     nsIContent* lastPopup = nullptr;
     if (aCount != UINT32_MAX) {
       nsMenuChainItem* last = item;
       while (--aCount && last->GetParent()) {
         last = last->GetParent();
       }
       if (last) {
         lastPopup = last->Content();
       }
     }
     HidePopup(item->Content(), true, true, false, true, lastPopup);
   }
   return consume;
 }
 ////////////////////////////////////////////////////////////////////////
 bool nsXULPopupManager::ShouldRollupOnMouseWheelEvent()
 {
   // should rollup only for autocomplete widgets
   // XXXndeakin this should really be something the popup has more control over
   nsMenuChainItem* item = GetTopVisibleMenu();
   if (!item)
     return false;
   nsIContent* content = item->Frame()->GetContent();
   if (!content)
     return false;
   if (content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::rolluponmousewheel,
                            nsGkAtoms::_true, eCaseMatters))
     return true;
   if (content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::rolluponmousewheel,
                            nsGkAtoms::_false, eCaseMatters))
     return false;
   nsAutoString value;
   content->GetAttr(kNameSpaceID_None, nsGkAtoms::type, value);
   return StringBeginsWith(value, NS_LITERAL_STRING("autocomplete"));
 }
 bool nsXULPopupManager::ShouldConsumeOnMouseWheelEvent()
 {
   nsMenuChainItem* item = GetTopVisibleMenu();
   if (!item)
     return false;
   nsMenuPopupFrame* frame = item->Frame();
   if (frame->PopupType() != ePopupTypePanel)
     return true;
   nsIContent* content = frame->GetContent();
   return !(content && content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
                                            nsGkAtoms::arrow, eCaseMatters));
 }
 // a menu should not roll up if activated by a mouse activate message (eg. X-mouse)
 bool nsXULPopupManager::ShouldRollupOnMouseActivate()
 {
   return false;
 }
 uint32_t
 nsXULPopupManager::GetSubmenuWidgetChain(nsTArray<nsIWidget*> *aWidgetChain)
 {
   // this method is used by the widget code to determine the list of popups
   // that are open. If a mouse click occurs outside one of these popups, the
   // panels will roll up. If the click is inside a popup, they will not roll up
   uint32_t count = 0, sameTypeCount = 0;
   NS_ASSERTION(aWidgetChain, "null parameter");
   nsMenuChainItem* item = GetTopVisibleMenu();
   while (item) {
     nsCOMPtr<nsIWidget> widget = item->Frame()->GetWidget();
     NS_ASSERTION(widget, "open popup has no widget");
     aWidgetChain->AppendElement(widget.get());
     // In the case when a menulist inside a panel is open, clicking in the
     // panel should still roll up the menu, so if a different type is found,
     // stop scanning.
     nsMenuChainItem* parent = item->GetParent();
     if (!sameTypeCount) {
       count++;
       if (!parent || item->Frame()->PopupType() != parent->Frame()->PopupType() ||
                      item->IsContextMenu() != parent->IsContextMenu()) {
         sameTypeCount = count;
       }
     }
     item = parent;
   }
   return sameTypeCount;
 }
 nsIWidget*
 nsXULPopupManager::GetRollupWidget()
 {
   nsMenuChainItem* item = GetTopVisibleMenu();
   return item ? item->Frame()->GetWidget() : nullptr;
 }
 void
 nsXULPopupManager::AdjustPopupsOnWindowChange(nsPIDOMWindow* aWindow)
 {
   // When the parent window is moved, adjust any child popups. Dismissable
   // menus and panels are expected to roll up when a window is moved, so there
   // is no need to check these popups, only the noautohide popups.
   // The items are added to a list so that they can be adjusted bottom to top.
   nsTArray<nsMenuPopupFrame *> list;
   nsMenuChainItem* item = mNoHidePanels;
   while (item) {
     // only move popups that are within the same window and where auto
     // positioning has not been disabled
     nsMenuPopupFrame* frame = item->Frame();
     if (frame->GetAutoPosition()) {
       nsIContent* popup = frame->GetContent();
       if (popup) {
         nsIDocument* document = popup->GetCurrentDoc();
         if (document) {
           nsPIDOMWindow* window = document->GetWindow();
           if (window) {
             window = window->GetPrivateRoot();
             if (window == aWindow) {
               list.AppendElement(frame);
             }
           }
         }
       }
     }
     item = item->GetParent();
   }
   for (int32_t l = list.Length() - 1; l >= 0; l--) {
     list[l]->SetPopupPosition(nullptr, true, false);
   }
 }
 void nsXULPopupManager::AdjustPopupsOnWindowChange(nsIPresShell* aPresShell)
 {
   if (aPresShell->GetDocument()) {
     AdjustPopupsOnWindowChange(aPresShell->GetDocument()->GetWindow());
   }
 }
 static
 nsMenuPopupFrame* GetPopupToMoveOrResize(nsIFrame* aFrame)
 {
   nsMenuPopupFrame* menuPopupFrame = do_QueryFrame(aFrame);
   if (!menuPopupFrame)
     return nullptr;
   // no point moving or resizing hidden popups
   if (menuPopupFrame->PopupState() != ePopupOpenAndVisible)
     return nullptr;
   nsIWidget* widget = menuPopupFrame->GetWidget();
   if (widget && !widget->IsVisible())
     return nullptr;
   return menuPopupFrame;
 }
 void
 nsXULPopupManager::PopupMoved(nsIFrame* aFrame, nsIntPoint aPnt)
 {
   nsMenuPopupFrame* menuPopupFrame = GetPopupToMoveOrResize(aFrame);
   if (!menuPopupFrame)
     return;
   nsView* view = menuPopupFrame->GetView();
   if (!view)
     return;
   // Don't do anything if the popup is already at the specified location. This
   // prevents recursive calls when a popup is positioned.
   nsIntRect curDevSize = view->CalcWidgetBounds(eWindowType_popup);
   nsIWidget* widget = menuPopupFrame->GetWidget();
   if (curDevSize.x == aPnt.x && curDevSize.y == aPnt.y &&
       (!widget || widget->GetClientOffset() == menuPopupFrame->GetLastClientOffset())) {
     return;
   }
   // Update the popup's position using SetPopupPosition if the popup is
   // anchored and at the parent level as these maintain their position
   // relative to the parent window. Otherwise, just update the popup to
   // the specified screen coordinates.
   if (menuPopupFrame->IsAnchored() &&
       menuPopupFrame->PopupLevel() == ePopupLevelParent) {
     menuPopupFrame->SetPopupPosition(nullptr, true, false);
   }
   else {
     nsPresContext* presContext = menuPopupFrame->PresContext();
     aPnt.x = presContext->DevPixelsToIntCSSPixels(aPnt.x);
     aPnt.y = presContext->DevPixelsToIntCSSPixels(aPnt.y);
     menuPopupFrame->MoveTo(aPnt.x, aPnt.y, false);
   }
 }
 void
 nsXULPopupManager::PopupResized(nsIFrame* aFrame, nsIntSize aSize)
 {
   nsMenuPopupFrame* menuPopupFrame = GetPopupToMoveOrResize(aFrame);
   if (!menuPopupFrame)
     return;
   nsView* view = menuPopupFrame->GetView();
   if (!view)
     return;
   nsIntRect curDevSize = view->CalcWidgetBounds(eWindowType_popup);
   // If the size is what we think it is, we have nothing to do.
   if (curDevSize.width == aSize.width && curDevSize.height == aSize.height)
     return;
   // The size is different. Convert the actual size to css pixels and store it
   // as 'width' and 'height' attributes on the popup.
   nsPresContext* presContext = menuPopupFrame->PresContext();
   nsIntSize newCSS(presContext->DevPixelsToIntCSSPixels(aSize.width),
                    presContext->DevPixelsToIntCSSPixels(aSize.height));
   nsIContent* popup = menuPopupFrame->GetContent();
   nsAutoString width, height;
   width.AppendInt(newCSS.width);
   height.AppendInt(newCSS.height);
   popup->SetAttr(kNameSpaceID_None, nsGkAtoms::width, width, false);
   popup->SetAttr(kNameSpaceID_None, nsGkAtoms::height, height, true);
 }
 nsMenuPopupFrame*
 nsXULPopupManager::GetPopupFrameForContent(nsIContent* aContent, bool aShouldFlush)
 {
   if (aShouldFlush) {
     nsIDocument *document = aContent->GetCurrentDoc();
     if (document) {
       nsCOMPtr<nsIPresShell> presShell = document->GetShell();
       if (presShell)
         presShell->FlushPendingNotifications(Flush_Layout);
     }
   }
   return do_QueryFrame(aContent->GetPrimaryFrame());
 }
 nsMenuChainItem*
 nsXULPopupManager::GetTopVisibleMenu()
 {
   nsMenuChainItem* item = mPopups;
   while (item && item->Frame()->PopupState() == ePopupInvisible)
     item = item->GetParent();
   return item;
 }
 void
 nsXULPopupManager::GetMouseLocation(nsIDOMNode** aNode, int32_t* aOffset)
 {
   *aNode = mRangeParent;
   NS_IF_ADDREF(*aNode);
   *aOffset = mRangeOffset;
 }
 void
 nsXULPopupManager::InitTriggerEvent(nsIDOMEvent* aEvent, nsIContent* aPopup,
                                     nsIContent** aTriggerContent)
 {
   mCachedMousePoint = nsIntPoint(0, 0);
   if (aTriggerContent) {
     *aTriggerContent = nullptr;
     if (aEvent) {
       // get the trigger content from the event
       nsCOMPtr<nsIContent> target = do_QueryInterface(
         aEvent->InternalDOMEvent()->GetTarget());
       target.forget(aTriggerContent);
     }
   }
   mCachedModifiers = 0;
   nsCOMPtr<nsIDOMUIEvent> uiEvent = do_QueryInterface(aEvent);
   if (uiEvent) {
     uiEvent->GetRangeParent(getter_AddRefs(mRangeParent));
     uiEvent->GetRangeOffset(&mRangeOffset);
     // get the event coordinates relative to the root frame of the document
     // containing the popup.
     NS_ASSERTION(aPopup, "Expected a popup node");
     WidgetEvent* event = aEvent->GetInternalNSEvent();
     if (event) {
       WidgetInputEvent* inputEvent = event->AsInputEvent();
       if (inputEvent) {
         mCachedModifiers = inputEvent->modifiers;
       }
       nsIDocument* doc = aPopup->GetCurrentDoc();
       if (doc) {
         nsIPresShell* presShell = doc->GetShell();
         nsPresContext* presContext;
         if (presShell && (presContext = presShell->GetPresContext())) {
           nsPresContext* rootDocPresContext =
             presContext->GetRootPresContext();
           if (!rootDocPresContext)
             return;
           nsIFrame* rootDocumentRootFrame = rootDocPresContext->
               PresShell()->FrameManager()->GetRootFrame();
           if ((event->eventStructType == NS_MOUSE_EVENT ||
                event->eventStructType == NS_MOUSE_SCROLL_EVENT ||
                event->eventStructType == NS_WHEEL_EVENT) &&
                !event->AsGUIEvent()->widget) {
             // no widget, so just use the client point if available
             nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aEvent);
             nsIntPoint clientPt;
             mouseEvent->GetClientX(&clientPt.x);
             mouseEvent->GetClientY(&clientPt.y);
             // XXX this doesn't handle IFRAMEs in transforms
             nsPoint thisDocToRootDocOffset = presShell->FrameManager()->
               GetRootFrame()->GetOffsetToCrossDoc(rootDocumentRootFrame);
             // convert to device pixels
             mCachedMousePoint.x = presContext->AppUnitsToDevPixels(
                 nsPresContext::CSSPixelsToAppUnits(clientPt.x) + thisDocToRootDocOffset.x);
             mCachedMousePoint.y = presContext->AppUnitsToDevPixels(
                 nsPresContext::CSSPixelsToAppUnits(clientPt.y) + thisDocToRootDocOffset.y);
           }
           else if (rootDocumentRootFrame) {
             nsPoint pnt =
               nsLayoutUtils::GetEventCoordinatesRelativeTo(event, rootDocumentRootFrame);
             mCachedMousePoint = nsIntPoint(rootDocPresContext->AppUnitsToDevPixels(pnt.x),
                                            rootDocPresContext->AppUnitsToDevPixels(pnt.y));
           }
         }
       }
     }
   }
   else {
     mRangeParent = nullptr;
     mRangeOffset = 0;
   }
 }
 void
 nsXULPopupManager::SetActiveMenuBar(nsMenuBarFrame* aMenuBar, bool aActivate)
 {
   if (aActivate)
     mActiveMenuBar = aMenuBar;
   else if (mActiveMenuBar == aMenuBar)
     mActiveMenuBar = nullptr;
   UpdateKeyboardListeners();
 }
 void
 nsXULPopupManager::ShowMenu(nsIContent *aMenu,
                             bool aSelectFirstItem,
                             bool aAsynchronous)
 {
   // generate any template content first. Otherwise, the menupopup may not
   // have been created yet.
   if (aMenu) {
     nsIContent* element = aMenu;
     do {
       nsCOMPtr<nsIDOMXULElement> xulelem = do_QueryInterface(element);
       if (xulelem) {
         nsCOMPtr<nsIXULTemplateBuilder> builder;
         xulelem->GetBuilder(getter_AddRefs(builder));
         if (builder) {
           builder->CreateContents(aMenu, true);
           break;
         }
       }
       element = element->GetParent();
     } while (element);
   }
   nsMenuFrame* menuFrame = do_QueryFrame(aMenu->GetPrimaryFrame());
   if (!menuFrame || !menuFrame->IsMenu())
     return;
   nsMenuPopupFrame* popupFrame =  menuFrame->GetPopup();
   if (!popupFrame || !MayShowPopup(popupFrame))
     return;
   // inherit whether or not we're a context menu from the parent
   bool parentIsContextMenu = false;
   bool onMenuBar = false;
   bool onmenu = menuFrame->IsOnMenu();
   nsMenuParent* parent = menuFrame->GetMenuParent();
   if (parent && onmenu) {
     parentIsContextMenu = parent->IsContextMenu();
     onMenuBar = parent->IsMenuBar();
   }
   nsAutoString position;
   if (onMenuBar || !onmenu)
     position.AssignLiteral("after_start");
   else
     position.AssignLiteral("end_before");
   // there is no trigger event for menus
   InitTriggerEvent(nullptr, nullptr, nullptr);
   popupFrame->InitializePopup(menuFrame->GetAnchor(), nullptr, position, 0, 0, true);
   if (aAsynchronous) {
     nsCOMPtr<nsIRunnable> event =
       new nsXULPopupShowingEvent(popupFrame->GetContent(),
                                  parentIsContextMenu, aSelectFirstItem);
     NS_DispatchToCurrentThread(event);
   }
   else {
     nsCOMPtr<nsIContent> popupContent = popupFrame->GetContent();
     FirePopupShowingEvent(popupContent, parentIsContextMenu, aSelectFirstItem);
   }
 }
 void
 nsXULPopupManager::ShowPopup(nsIContent* aPopup,
                              nsIContent* aAnchorContent,
                              const nsAString& aPosition,
                              int32_t aXPos, int32_t aYPos,
                              bool aIsContextMenu,
                              bool aAttributesOverride,
                              bool aSelectFirstItem,
                              nsIDOMEvent* aTriggerEvent)
 {
   nsMenuPopupFrame* popupFrame = GetPopupFrameForContent(aPopup, true);
   if (!popupFrame || !MayShowPopup(popupFrame))
     return;
   nsCOMPtr<nsIContent> triggerContent;
   InitTriggerEvent(aTriggerEvent, aPopup, getter_AddRefs(triggerContent));
   popupFrame->InitializePopup(aAnchorContent, triggerContent, aPosition,
                               aXPos, aYPos, aAttributesOverride);
   FirePopupShowingEvent(aPopup, aIsContextMenu, aSelectFirstItem);
 }
 void
 nsXULPopupManager::ShowPopupAtScreen(nsIContent* aPopup,
                                      int32_t aXPos, int32_t aYPos,
                                      bool aIsContextMenu,
                                      nsIDOMEvent* aTriggerEvent)
 {
   nsMenuPopupFrame* popupFrame = GetPopupFrameForContent(aPopup, true);
   if (!popupFrame || !MayShowPopup(popupFrame))
     return;
   nsCOMPtr<nsIContent> triggerContent;
   InitTriggerEvent(aTriggerEvent, aPopup, getter_AddRefs(triggerContent));
   popupFrame->InitializePopupAtScreen(triggerContent, aXPos, aYPos, aIsContextMenu);
   FirePopupShowingEvent(aPopup, aIsContextMenu, false);
 }
 void
 nsXULPopupManager::ShowTooltipAtScreen(nsIContent* aPopup,
                                        nsIContent* aTriggerContent,
                                        int32_t aXPos, int32_t aYPos)
 {
   nsMenuPopupFrame* popupFrame = GetPopupFrameForContent(aPopup, true);
   if (!popupFrame || !MayShowPopup(popupFrame))
     return;
   InitTriggerEvent(nullptr, nullptr, nullptr);
   nsPresContext* pc = popupFrame->PresContext();
   mCachedMousePoint = nsIntPoint(pc->CSSPixelsToDevPixels(aXPos),
                                  pc->CSSPixelsToDevPixels(aYPos));
   // coordinates are relative to the root widget
   nsPresContext* rootPresContext = pc->GetRootPresContext();
   if (rootPresContext) {
     nsIWidget *rootWidget = rootPresContext->GetRootWidget();
     if (rootWidget) {
       mCachedMousePoint -= rootWidget->WidgetToScreenOffset();
     }
   }
   popupFrame->InitializePopupAtScreen(aTriggerContent, aXPos, aYPos, false);
   FirePopupShowingEvent(aPopup, false, false);
 }
 void
 nsXULPopupManager::ShowPopupWithAnchorAlign(nsIContent* aPopup,
                                             nsIContent* aAnchorContent,
                                             nsAString& aAnchor,
                                             nsAString& aAlign,
                                             int32_t aXPos, int32_t aYPos,
                                             bool aIsContextMenu)
 {
   nsMenuPopupFrame* popupFrame = GetPopupFrameForContent(aPopup, true);
   if (!popupFrame || !MayShowPopup(popupFrame))
     return;
   InitTriggerEvent(nullptr, nullptr, nullptr);
   popupFrame->InitializePopupWithAnchorAlign(aAnchorContent, aAnchor,
                                              aAlign, aXPos, aYPos);
   FirePopupShowingEvent(aPopup, aIsContextMenu, false);
 }
 static void
 CheckCaretDrawingState() {
   // There is 1 caret per document, we need to find the focused
   // document and erase its caret.
   nsIFocusManager* fm = nsFocusManager::GetFocusManager();
   if (fm) {
     nsCOMPtr<nsIDOMWindow> window;
     fm->GetFocusedWindow(getter_AddRefs(window));
     if (!window)
       return;
     nsCOMPtr<nsIDOMDocument> domDoc;
     nsCOMPtr<nsIDocument> focusedDoc;
     window->GetDocument(getter_AddRefs(domDoc));
     focusedDoc = do_QueryInterface(domDoc);
     if (!focusedDoc)
       return;
     nsIPresShell* presShell = focusedDoc->GetShell();
     if (!presShell)
       return;
     nsRefPtr<nsCaret> caret = presShell->GetCaret();
     if (!caret)
       return;
     caret->CheckCaretDrawingState();
   }
 }
 void
 nsXULPopupManager::ShowPopupCallback(nsIContent* aPopup,
                                      nsMenuPopupFrame* aPopupFrame,
                                      bool aIsContextMenu,
                                      bool aSelectFirstItem)
 {
   nsPopupType popupType = aPopupFrame->PopupType();
   bool ismenu = (popupType == ePopupTypeMenu);
   nsMenuChainItem* item =
     new nsMenuChainItem(aPopupFrame, aIsContextMenu, popupType);
   if (!item)
     return;
   // install keyboard event listeners for navigating menus. For panels, the
   // escape key may be used to close the panel. However, the ignorekeys
   // attribute may be used to disable adding these event listeners for popups
   // that want to handle their own keyboard events.
   if (aPopup->AttrValueIs(kNameSpaceID_None, nsGkAtoms::ignorekeys,
                            nsGkAtoms::_true, eCaseMatters))
     item->SetIgnoreKeys(true);
   if (ismenu) {
     // if the menu is on a menubar, use the menubar's listener instead
     nsMenuFrame* menuFrame = do_QueryFrame(aPopupFrame->GetParent());
     if (menuFrame) {
       item->SetOnMenuBar(menuFrame->IsOnMenuBar());
     }
   }
   // use a weak frame as the popup will set an open attribute if it is a menu
   nsWeakFrame weakFrame(aPopupFrame);
   aPopupFrame->ShowPopup(aIsContextMenu, aSelectFirstItem);
   ENSURE_TRUE(weakFrame.IsAlive());
   // popups normally hide when an outside click occurs. Panels may use
   // the noautohide attribute to disable this behaviour. It is expected
   // that the application will hide these popups manually. The tooltip
   // listener will handle closing the tooltip also.
   if (aPopupFrame->IsNoAutoHide() || popupType == ePopupTypeTooltip) {
     item->SetParent(mNoHidePanels);
     mNoHidePanels = item;
   }
   else {
     nsIContent* oldmenu = nullptr;
     if (mPopups)
       oldmenu = mPopups->Content();
     item->SetParent(mPopups);
     mPopups = item;
     SetCaptureState(oldmenu);
   }
   if (aSelectFirstItem) {
     nsMenuFrame* next = GetNextMenuItem(aPopupFrame, nullptr, true);
     aPopupFrame->SetCurrentMenuItem(next);
   }
   if (ismenu)
     UpdateMenuItems(aPopup);
   // Caret visibility may have been affected, ensure that
   // the caret isn't now drawn when it shouldn't be.
   CheckCaretDrawingState();
 }
 void
 nsXULPopupManager::HidePopup(nsIContent* aPopup,
                              bool aHideChain,
                              bool aDeselectMenu,
                              bool aAsynchronous,
                              bool aIsRollup,
                              nsIContent* aLastPopup)
 {
   // if the popup is on the nohide panels list, remove it but don't close any
   // other panels
   nsMenuPopupFrame* popupFrame = nullptr;
   bool foundPanel = false;
   nsMenuChainItem* item = mNoHidePanels;
   while (item) {
     if (item->Content() == aPopup) {
       foundPanel = true;
       popupFrame = item->Frame();
       break;
     }
     item = item->GetParent();
   }
   // when removing a menu, all of the child popups must be closed
   nsMenuChainItem* foundMenu = nullptr;
   item = mPopups;
   while (item) {
     if (item->Content() == aPopup) {
       foundMenu = item;
       break;
     }
     item = item->GetParent();
   }
   nsPopupType type = ePopupTypePanel;
   bool deselectMenu = false;
   nsCOMPtr<nsIContent> popupToHide, nextPopup, lastPopup;
   if (foundMenu) {
     // at this point, foundMenu will be set to the found item in the list. If
     // foundMenu is the topmost menu, the one to remove, then there are no other
     // popups to hide. If foundMenu is not the topmost menu, then there may be
     // open submenus below it. In this case, we need to make sure that those
     // submenus are closed up first. To do this, we scan up the menu list to
     // find the topmost popup with only menus between it and foundMenu and
     // close that menu first. In synchronous mode, the FirePopupHidingEvent
     // method will be called which in turn calls HidePopupCallback to close up
     // the next popup in the chain. These two methods will be called in
     // sequence recursively to close up all the necessary popups. In
     // asynchronous mode, a similar process occurs except that the
     // FirePopupHidingEvent method is called asynchronously. In either case,
     // nextPopup is set to the content node of the next popup to close, and
     // lastPopup is set to the last popup in the chain to close, which will be
     // aPopup, or null to close up all menus.
     nsMenuChainItem* topMenu = foundMenu;
     // Use IsMenu to ensure that foundMenu is a menu and scan down the child
     // list until a non-menu is found. If foundMenu isn't a menu at all, don't
     // scan and just close up this menu.
     if (foundMenu->IsMenu()) {
       item = topMenu->GetChild();
       while (item && item->IsMenu()) {
         topMenu = item;
         item = item->GetChild();
       }
     }
     deselectMenu = aDeselectMenu;
     popupToHide = topMenu->Content();
     popupFrame = topMenu->Frame();
     type = popupFrame->PopupType();
     nsMenuChainItem* parent = topMenu->GetParent();
     // close up another popup if there is one, and we are either hiding the
     // entire chain or the item to hide isn't the topmost popup.
     if (parent && (aHideChain || topMenu != foundMenu))
       nextPopup = parent->Content();
     lastPopup = aLastPopup ? aLastPopup : (aHideChain ? nullptr : aPopup);
   }
   else if (foundPanel) {
     popupToHide = aPopup;
   }
   if (popupFrame) {
     nsPopupState state = popupFrame->PopupState();
     // if the popup is already being hidden, don't attempt to hide it again
     if (state == ePopupHiding)
       return;
     // change the popup state to hiding. Don't set the hiding state if the
     // popup is invisible, otherwise nsMenuPopupFrame::HidePopup will
     // run again. In the invisible state, we just want the events to fire.
     if (state != ePopupInvisible)
       popupFrame->SetPopupState(ePopupHiding);
     // for menus, popupToHide is always the frontmost item in the list to hide.
     if (aAsynchronous) {
       nsCOMPtr<nsIRunnable> event =
         new nsXULPopupHidingEvent(popupToHide, nextPopup, lastPopup,
                                   type, deselectMenu, aIsRollup);
         NS_DispatchToCurrentThread(event);
     }
     else {
       FirePopupHidingEvent(popupToHide, nextPopup, lastPopup,
                            popupFrame->PresContext(), type, deselectMenu, aIsRollup);
     }
   }
 }
 // This is used to hide the popup after a transition finishes.
 class TransitionEnder : public nsIDOMEventListener
 {
 public:
   nsCOMPtr<nsIContent> mContent;
   bool mDeselectMenu;
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_CLASS(TransitionEnder)
   TransitionEnder(nsIContent* aContent, bool aDeselectMenu)
     : mContent(aContent), mDeselectMenu(aDeselectMenu)
   {
   }
   virtual ~TransitionEnder() { }
   NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent) MOZ_OVERRIDE
   {
     mContent->RemoveSystemEventListener(NS_LITERAL_STRING("transitionend"), this, false);
     nsMenuPopupFrame* popupFrame = do_QueryFrame(mContent->GetPrimaryFrame());
     // Now hide the popup. There could be other properties transitioning, but
     // we'll assume they all end at the same time and just hide the popup upon
     // the first one ending.
     nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
     if (pm && popupFrame) {
       pm->HidePopupCallback(mContent, popupFrame, nullptr, nullptr,
                             popupFrame->PopupType(), mDeselectMenu);
     }
     return NS_OK;
   }
 };
 NS_IMPL_CYCLE_COLLECTING_ADDREF(TransitionEnder)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(TransitionEnder)
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TransitionEnder)
   NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 NS_IMPL_CYCLE_COLLECTION(TransitionEnder, mContent);
 void
 nsXULPopupManager::HidePopupCallback(nsIContent* aPopup,
                                      nsMenuPopupFrame* aPopupFrame,
                                      nsIContent* aNextPopup,
                                      nsIContent* aLastPopup,
                                      nsPopupType aPopupType,
                                      bool aDeselectMenu)
 {
   if (mCloseTimer && mTimerMenu == aPopupFrame) {
     mCloseTimer->Cancel();
     mCloseTimer = nullptr;
     mTimerMenu = nullptr;
   }
   // The popup to hide is aPopup. Search the list again to find the item that
   // corresponds to the popup to hide aPopup. This is done because it's
   // possible someone added another item (attempted to open another popup)
   // or removed a popup frame during the event processing so the item isn't at
   // the front anymore.
   nsMenuChainItem* item = mNoHidePanels;
   while (item) {
     if (item->Content() == aPopup) {
       item->Detach(&mNoHidePanels);
       break;
     }
     item = item->GetParent();
   }
   if (!item) {
     item = mPopups;
     while (item) {
       if (item->Content() == aPopup) {
         item->Detach(&mPopups);
         SetCaptureState(aPopup);
         break;
       }
       item = item->GetParent();
     }
   }
   delete item;
   nsWeakFrame weakFrame(aPopupFrame);
   aPopupFrame->HidePopup(aDeselectMenu, ePopupClosed);
   ENSURE_TRUE(weakFrame.IsAlive());
   // send the popuphidden event synchronously. This event has no default
   // behaviour.
   nsEventStatus status = nsEventStatus_eIgnore;
   WidgetMouseEvent event(true, NS_XUL_POPUP_HIDDEN, nullptr,
                          WidgetMouseEvent::eReal);
   EventDispatcher::Dispatch(aPopup, aPopupFrame->PresContext(),
                             &event, nullptr, &status);
   ENSURE_TRUE(weakFrame.IsAlive());
   // if there are more popups to close, look for the next one
   if (aNextPopup && aPopup != aLastPopup) {
     nsMenuChainItem* foundMenu = nullptr;
     nsMenuChainItem* item = mPopups;
     while (item) {
       if (item->Content() == aNextPopup) {
         foundMenu = item;
         break;
       }
       item = item->GetParent();
     }
     // continue hiding the chain of popups until the last popup aLastPopup
     // is reached, or until a popup of a different type is reached. This
     // last check is needed so that a menulist inside a non-menu panel only
     // closes the menu and not the panel as well.
     if (foundMenu &&
         (aLastPopup || aPopupType == foundMenu->PopupType())) {
       nsCOMPtr<nsIContent> popupToHide = item->Content();
       nsMenuChainItem* parent = item->GetParent();
       nsCOMPtr<nsIContent> nextPopup;
       if (parent && popupToHide != aLastPopup)
         nextPopup = parent->Content();
       nsMenuPopupFrame* popupFrame = item->Frame();
       nsPopupState state = popupFrame->PopupState();
       if (state == ePopupHiding)
         return;
       if (state != ePopupInvisible)
         popupFrame->SetPopupState(ePopupHiding);
       FirePopupHidingEvent(popupToHide, nextPopup, aLastPopup,
                            popupFrame->PresContext(),
                            foundMenu->PopupType(), aDeselectMenu, false);
     }
   }
 }
 void
 nsXULPopupManager::HidePopup(nsIFrame* aFrame)
 {
   nsMenuPopupFrame* popup = do_QueryFrame(aFrame);
   if (popup)
     HidePopup(aFrame->GetContent(), false, true, false, false);
 }
 void
 nsXULPopupManager::HidePopupAfterDelay(nsMenuPopupFrame* aPopup)
 {
   // Don't close up immediately.
   // Kick off a close timer.
   KillMenuTimer();
   int32_t menuDelay =
     LookAndFeel::GetInt(LookAndFeel::eIntID_SubmenuDelay, 300); // ms
   // Kick off the timer.
   mCloseTimer = do_CreateInstance("@mozilla.org/timer;1");
   mCloseTimer->InitWithCallback(this, menuDelay, nsITimer::TYPE_ONE_SHOT);
   // the popup will call PopupDestroyed if it is destroyed, which checks if it
   // is set to mTimerMenu, so it should be safe to keep a reference to it
   mTimerMenu = aPopup;
 }
 void
 nsXULPopupManager::HidePopupsInList(const nsTArray<nsMenuPopupFrame *> &aFrames,
                                     bool aDeselectMenu)
 {
   // Create a weak frame list. This is done in a separate array with the
   // right capacity predetermined, otherwise the array would get resized and
   // move the weak frame pointers around.
   nsTArray<nsWeakFrame> weakPopups(aFrames.Length());
   uint32_t f;
   for (f = 0; f < aFrames.Length(); f++) {
     nsWeakFrame* wframe = weakPopups.AppendElement();
     if (wframe)
       *wframe = aFrames[f];
   }
   for (f = 0; f < weakPopups.Length(); f++) {
     // check to ensure that the frame is still alive before hiding it.
     if (weakPopups[f].IsAlive()) {
       nsMenuPopupFrame* frame =
         static_cast<nsMenuPopupFrame *>(weakPopups[f].GetFrame());
       frame->HidePopup(true, ePopupInvisible);
     }
   }
   SetCaptureState(nullptr);
 }
 bool
 nsXULPopupManager::IsChildOfDocShell(nsIDocument* aDoc, nsIDocShellTreeItem* aExpected)
 {
   nsCOMPtr<nsIDocShellTreeItem> docShellItem(aDoc->GetDocShell());
   while(docShellItem) {
     if (docShellItem == aExpected)
       return true;
     nsCOMPtr<nsIDocShellTreeItem> parent;
     docShellItem->GetParent(getter_AddRefs(parent));
     docShellItem = parent;
   }
   return false;
 }
 void
 nsXULPopupManager::HidePopupsInDocShell(nsIDocShellTreeItem* aDocShellToHide)
 {
   nsTArray<nsMenuPopupFrame *> popupsToHide;
   // iterate to get the set of popup frames to hide
   nsMenuChainItem* item = mPopups;
   while (item) {
     nsMenuChainItem* parent = item->GetParent();
     if (item->Frame()->PopupState() != ePopupInvisible &&
         IsChildOfDocShell(item->Content()->OwnerDoc(), aDocShellToHide)) {
       nsMenuPopupFrame* frame = item->Frame();
       item->Detach(&mPopups);
       delete item;
       popupsToHide.AppendElement(frame);
     }
     item = parent;
   }
   // now look for panels to hide
   item = mNoHidePanels;
   while (item) {
     nsMenuChainItem* parent = item->GetParent();
     if (item->Frame()->PopupState() != ePopupInvisible &&
         IsChildOfDocShell(item->Content()->OwnerDoc(), aDocShellToHide)) {
       nsMenuPopupFrame* frame = item->Frame();
       item->Detach(&mNoHidePanels);
       delete item;
       popupsToHide.AppendElement(frame);
     }
     item = parent;
   }
   HidePopupsInList(popupsToHide, true);
 }
 void
 nsXULPopupManager::ExecuteMenu(nsIContent* aMenu, nsXULMenuCommandEvent* aEvent)
 {
   CloseMenuMode cmm = CloseMenuMode_Auto;
   static nsIContent::AttrValuesArray strings[] =
     {&nsGkAtoms::none, &nsGkAtoms::single, nullptr};
   switch (aMenu->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::closemenu,
                                  strings, eCaseMatters)) {
     case 0:
       cmm = CloseMenuMode_None;
       break;
     case 1:
       cmm = CloseMenuMode_Single;
       break;
     default:
       break;
   }
   // When a menuitem is selected to be executed, first hide all the open
   // popups, but don't remove them yet. This is needed when a menu command
   // opens a modal dialog. The views associated with the popups needed to be
   // hidden and the accesibility events fired before the command executes, but
   // the popuphiding/popuphidden events are fired afterwards.
   nsTArray<nsMenuPopupFrame *> popupsToHide;
   nsMenuChainItem* item = GetTopVisibleMenu();
   if (cmm != CloseMenuMode_None) {
     while (item) {
       // if it isn't a <menupopup>, don't close it automatically
       if (!item->IsMenu())
         break;
       nsMenuChainItem* next = item->GetParent();
       popupsToHide.AppendElement(item->Frame());
       if (cmm == CloseMenuMode_Single) // only close one level of menu
         break;
       item = next;
     }
     // Now hide the popups. If the closemenu mode is auto, deselect the menu,
     // otherwise only one popup is closing, so keep the parent menu selected.
     HidePopupsInList(popupsToHide, cmm == CloseMenuMode_Auto);
   }
   aEvent->SetCloseMenuMode(cmm);
   nsCOMPtr<nsIRunnable> event = aEvent;
   NS_DispatchToCurrentThread(event);
 }
 void
 nsXULPopupManager::FirePopupShowingEvent(nsIContent* aPopup,
                                          bool aIsContextMenu,
                                          bool aSelectFirstItem)
 {
   nsCOMPtr<nsIContent> popup = aPopup; // keep a strong reference to the popup
   nsMenuPopupFrame* popupFrame = do_QueryFrame(aPopup->GetPrimaryFrame());
   if (!popupFrame)
     return;
   nsPresContext *presContext = popupFrame->PresContext();
   nsCOMPtr<nsIPresShell> presShell = presContext->PresShell();
   nsPopupType popupType = popupFrame->PopupType();
   // generate the child frames if they have not already been generated
   if (!popupFrame->HasGeneratedChildren()) {
     popupFrame->SetGeneratedChildren();
     presShell->FrameConstructor()->GenerateChildFrames(popupFrame);
   }
   // get the frame again
   nsIFrame* frame = aPopup->GetPrimaryFrame();
   if (!frame)
     return;
   presShell->FrameNeedsReflow(frame, nsIPresShell::eTreeChange,
                               NS_FRAME_HAS_DIRTY_CHILDREN);
   // cache the popup so that document.popupNode can retrieve the trigger node
   // during the popupshowing event. It will be cleared below after the event
   // has fired.
   mOpeningPopup = aPopup;
   nsEventStatus status = nsEventStatus_eIgnore;
   WidgetMouseEvent event(true, NS_XUL_POPUP_SHOWING, nullptr,
                          WidgetMouseEvent::eReal);
   // coordinates are relative to the root widget
   nsPresContext* rootPresContext =
     presShell->GetPresContext()->GetRootPresContext();
   if (rootPresContext) {
     rootPresContext->PresShell()->GetViewManager()->
       GetRootWidget(getter_AddRefs(event.widget));
   }
   else {
     event.widget = nullptr;
   }
   event.refPoint = LayoutDeviceIntPoint::FromUntyped(mCachedMousePoint);
   event.modifiers = mCachedModifiers;
   EventDispatcher::Dispatch(popup, presContext, &event, nullptr, &status);
   mCachedMousePoint = nsIntPoint(0, 0);
   mOpeningPopup = nullptr;
   mCachedModifiers = 0;
   // if a panel, blur whatever has focus so that the panel can take the focus.
   // This is done after the popupshowing event in case that event is cancelled.
   // Using noautofocus="true" will disable this behaviour, which is needed for
   // the autocomplete widget as it manages focus itself.
   if (popupType == ePopupTypePanel &&
       !popup->AttrValueIs(kNameSpaceID_None, nsGkAtoms::noautofocus,
                            nsGkAtoms::_true, eCaseMatters)) {
     nsIFocusManager* fm = nsFocusManager::GetFocusManager();
     if (fm) {
       nsIDocument* doc = popup->GetCurrentDoc();
       // Only remove the focus if the currently focused item is ouside the
       // popup. It isn't a big deal if the current focus is in a child popup
       // inside the popup as that shouldn't be visible. This check ensures that
       // a node inside the popup that is focused during a popupshowing event
       // remains focused.
       nsCOMPtr<nsIDOMElement> currentFocusElement;
       fm->GetFocusedElement(getter_AddRefs(currentFocusElement));
       nsCOMPtr<nsIContent> currentFocus = do_QueryInterface(currentFocusElement);
       if (doc && currentFocus &&
           !nsContentUtils::ContentIsCrossDocDescendantOf(currentFocus, popup)) {
         fm->ClearFocus(doc->GetWindow());
       }
     }
   }
   // clear these as they are no longer valid
   mRangeParent = nullptr;
   mRangeOffset = 0;
   // get the frame again in case it went away
   popupFrame = do_QueryFrame(aPopup->GetPrimaryFrame());
   if (popupFrame) {
     // if the event was cancelled, don't open the popup, reset its state back
     // to closed and clear its trigger content.
     if (status == nsEventStatus_eConsumeNoDefault) {
       popupFrame->SetPopupState(ePopupClosed);
       popupFrame->ClearTriggerContent();
     }
     else {
       ShowPopupCallback(aPopup, popupFrame, aIsContextMenu, aSelectFirstItem);
     }
   }
 }
 void
 nsXULPopupManager::FirePopupHidingEvent(nsIContent* aPopup,
                                         nsIContent* aNextPopup,
                                         nsIContent* aLastPopup,
                                         nsPresContext *aPresContext,
                                         nsPopupType aPopupType,
                                         bool aDeselectMenu,
                                         bool aIsRollup)
 {
   nsCOMPtr<nsIPresShell> presShell = aPresContext->PresShell();
   nsEventStatus status = nsEventStatus_eIgnore;
   WidgetMouseEvent event(true, NS_XUL_POPUP_HIDING, nullptr,
                          WidgetMouseEvent::eReal);
   EventDispatcher::Dispatch(aPopup, aPresContext, &event, nullptr, &status);
   // when a panel is closed, blur whatever has focus inside the popup
   if (aPopupType == ePopupTypePanel &&
       !aPopup->AttrValueIs(kNameSpaceID_None, nsGkAtoms::noautofocus,
                            nsGkAtoms::_true, eCaseMatters)) {
     nsIFocusManager* fm = nsFocusManager::GetFocusManager();
     if (fm) {
       nsIDocument* doc = aPopup->GetCurrentDoc();
       // Remove the focus from the focused node only if it is inside the popup.
       nsCOMPtr<nsIDOMElement> currentFocusElement;
       fm->GetFocusedElement(getter_AddRefs(currentFocusElement));
       nsCOMPtr<nsIContent> currentFocus = do_QueryInterface(currentFocusElement);
       if (doc && currentFocus &&
           nsContentUtils::ContentIsCrossDocDescendantOf(currentFocus, aPopup)) {
         fm->ClearFocus(doc->GetWindow());
       }
     }
   }
   // get frame again in case it went away
   nsMenuPopupFrame* popupFrame = do_QueryFrame(aPopup->GetPrimaryFrame());
   if (popupFrame) {
     // if the event was cancelled, don't hide the popup, and reset its
     // state back to open. Only popups in chrome shells can prevent a popup
     // from hiding.
     if (status == nsEventStatus_eConsumeNoDefault &&
         !popupFrame->IsInContentShell()) {
       popupFrame->SetPopupState(ePopupOpenAndVisible);
     }
     else {
       // If the popup has an animate attribute and it is not set to false, assume
       // that it has a closing transition and wait for it to finish. The transition
       // may still occur either way, but the view will be hidden and you won't be
       // able to see it. If there is a next popup, indicating that mutliple popups
       // are rolling up, don't wait and hide the popup right away since the effect
       // would likely be undesirable. This also does a quick check to see if the
       // popup has a transition defined, and skips the wait if not. Transitions
       // are currently disabled on Linux due to rendering issues on certain
       // configurations.
 #ifndef MOZ_WIDGET_GTK
       if (!aNextPopup && aPopup->HasAttr(kNameSpaceID_None, nsGkAtoms::animate) &&
           popupFrame->StyleDisplay()->mTransitionPropertyCount > 0) {
         nsAutoString animate;
         aPopup->GetAttr(kNameSpaceID_None, nsGkAtoms::animate, animate);
         // If animate="false" then don't transition at all. If animate="cancel",
         // only show the transition if cancelling the popup or rolling up.
         // Otherwise, always show the transition.
         if (!animate.EqualsLiteral("false") &&
             (!animate.EqualsLiteral("cancel") || aIsRollup)) {
           nsCOMPtr<TransitionEnder> ender = new TransitionEnder(aPopup, aDeselectMenu);
           aPopup->AddSystemEventListener(NS_LITERAL_STRING("transitionend"),
                                          ender, false, false);
           return;
         }
       }
 #endif
       HidePopupCallback(aPopup, popupFrame, aNextPopup, aLastPopup,
                         aPopupType, aDeselectMenu);
     }
   }
 }
 bool
 nsXULPopupManager::IsPopupOpen(nsIContent* aPopup)
 {
   // a popup is open if it is in the open list. The assertions ensure that the
   // frame is in the correct state. If the popup is in the hiding or invisible
   // state, it will still be in the open popup list until it is closed.
   nsMenuChainItem* item = mPopups;
   while (item) {
     if (item->Content() == aPopup) {
       NS_ASSERTION(item->Frame()->IsOpen() ||
                    item->Frame()->PopupState() == ePopupHiding ||
                    item->Frame()->PopupState() == ePopupInvisible,
                    "popup in open list not actually open");
       return true;
     }
     item = item->GetParent();
   }
   item = mNoHidePanels;
   while (item) {
     if (item->Content() == aPopup) {
       NS_ASSERTION(item->Frame()->IsOpen() ||
                    item->Frame()->PopupState() == ePopupHiding ||
                    item->Frame()->PopupState() == ePopupInvisible,
                    "popup in open list not actually open");
       return true;
     }
     item = item->GetParent();
   }
   return false;
 }
 bool
 nsXULPopupManager::IsPopupOpenForMenuParent(nsMenuParent* aMenuParent)
 {
   nsMenuChainItem* item = GetTopVisibleMenu();
   while (item) {
     nsMenuPopupFrame* popup = item->Frame();
     if (popup && popup->IsOpen()) {
       nsMenuFrame* menuFrame = do_QueryFrame(popup->GetParent());
       if (menuFrame && menuFrame->GetMenuParent() == aMenuParent) {
         return true;
       }
     }
     item = item->GetParent();
   }
   return false;
 }
 nsIFrame*
 nsXULPopupManager::GetTopPopup(nsPopupType aType)
 {
   if ((aType == ePopupTypePanel || aType == ePopupTypeTooltip) && mNoHidePanels)
     return mNoHidePanels->Frame();
   nsMenuChainItem* item = GetTopVisibleMenu();
   while (item) {
     if (item->PopupType() == aType || aType == ePopupTypeAny)
       return item->Frame();
     item = item->GetParent();
   }
   return nullptr;
 }
 void
 nsXULPopupManager::GetVisiblePopups(nsTArray<nsIFrame *>& aPopups)
 {
   aPopups.Clear();
   // Iterate over both lists of popups
   nsMenuChainItem* item = mPopups;
   for (int32_t list = 0; list < 2; list++) {
     while (item) {
       // Skip panels which are not open and visible as well as popups that
       // are transparent to mouse events.
       if (item->Frame()->PopupState() == ePopupOpenAndVisible &&
           !item->Frame()->IsMouseTransparent()) {
         aPopups.AppendElement(item->Frame());
       }
       item = item->GetParent();
     }
     item = mNoHidePanels;
   }
 }
 already_AddRefed<nsIDOMNode>
 nsXULPopupManager::GetLastTriggerNode(nsIDocument* aDocument, bool aIsTooltip)
 {
   if (!aDocument)
     return nullptr;
   nsCOMPtr<nsIDOMNode> node;
   // if mOpeningPopup is set, it means that a popupshowing event is being
   // fired. In this case, just use the cached node, as the popup is not yet in
   // the list of open popups.
   if (mOpeningPopup && mOpeningPopup->GetCurrentDoc() == aDocument &&
       aIsTooltip == (mOpeningPopup->Tag() == nsGkAtoms::tooltip)) {
     node = do_QueryInterface(nsMenuPopupFrame::GetTriggerContent(GetPopupFrameForContent(mOpeningPopup, false)));
   }
   else {
     nsMenuChainItem* item = aIsTooltip ? mNoHidePanels : mPopups;
     while (item) {
       // look for a popup of the same type and document.
       if ((item->PopupType() == ePopupTypeTooltip) == aIsTooltip &&
           item->Content()->GetCurrentDoc() == aDocument) {
         node = do_QueryInterface(nsMenuPopupFrame::GetTriggerContent(item->Frame()));
         if (node)
           break;
       }
       item = item->GetParent();
     }
   }
   return node.forget();
 }
 bool
 nsXULPopupManager::MayShowPopup(nsMenuPopupFrame* aPopup)
 {
   // if a popup's IsOpen method returns true, then the popup must always be in
   // the popup chain scanned in IsPopupOpen.
   NS_ASSERTION(!aPopup->IsOpen() || IsPopupOpen(aPopup->GetContent()),
                "popup frame state doesn't match XULPopupManager open state");
   nsPopupState state = aPopup->PopupState();
   // if the popup is not in the open popup chain, then it must have a state that
   // is either closed, in the process of being shown, or invisible.
   NS_ASSERTION(IsPopupOpen(aPopup->GetContent()) || state == ePopupClosed ||
                state == ePopupShowing || state == ePopupInvisible,
                "popup not in XULPopupManager open list is open");
   // don't show popups unless they are closed or invisible
   if (state != ePopupClosed && state != ePopupInvisible)
     return false;
   // Don't show popups that we already have in our popup chain
   if (IsPopupOpen(aPopup->GetContent())) {
     NS_WARNING("Refusing to show duplicate popup");
     return false;
   }
   // if the popup was just rolled up, don't reopen it
   nsCOMPtr<nsIWidget> widget = aPopup->GetWidget();
   if (widget && widget->GetLastRollup() == aPopup->GetContent())
       return false;
   nsCOMPtr<nsIDocShellTreeItem> dsti = aPopup->PresContext()->GetDocShell();
   nsCOMPtr<nsIBaseWindow> baseWin = do_QueryInterface(dsti);
   if (!baseWin)
     return false;
   // chrome shells can always open popups, but other types of shells can only
   // open popups when they are focused and visible
   if (dsti->ItemType() != nsIDocShellTreeItem::typeChrome) {
     // only allow popups in active windows
     nsCOMPtr<nsIDocShellTreeItem> root;
     dsti->GetRootTreeItem(getter_AddRefs(root));
     nsCOMPtr<nsIDOMWindow> rootWin = do_GetInterface(root);
     nsIFocusManager* fm = nsFocusManager::GetFocusManager();
     if (!fm || !rootWin)
       return false;
     nsCOMPtr<nsIDOMWindow> activeWindow;
     fm->GetActiveWindow(getter_AddRefs(activeWindow));
     if (activeWindow != rootWin)
       return false;
     // only allow popups in visible frames
     bool visible;
     baseWin->GetVisibility(&visible);
     if (!visible)
       return false;
   }
   // platforms respond differently when an popup is opened in a minimized
   // window, so this is always disabled.
   nsCOMPtr<nsIWidget> mainWidget;
   baseWin->GetMainWidget(getter_AddRefs(mainWidget));
   if (mainWidget && mainWidget->SizeMode() == nsSizeMode_Minimized) {
     return false;
   }
   // cannot open a popup that is a submenu of a menupopup that isn't open.
   nsMenuFrame* menuFrame = do_QueryFrame(aPopup->GetParent());
   if (menuFrame) {
     nsMenuParent* parentPopup = menuFrame->GetMenuParent();
     if (parentPopup && !parentPopup->IsOpen())
       return false;
   }
   return true;
 }
 void
 nsXULPopupManager::PopupDestroyed(nsMenuPopupFrame* aPopup)
 {
   // when a popup frame is destroyed, just unhook it from the list of popups
   if (mTimerMenu == aPopup) {
     if (mCloseTimer) {
       mCloseTimer->Cancel();
       mCloseTimer = nullptr;
     }
     mTimerMenu = nullptr;
   }
   nsMenuChainItem* item = mNoHidePanels;
   while (item) {
     if (item->Frame() == aPopup) {
       item->Detach(&mNoHidePanels);
       delete item;
       break;
     }
     item = item->GetParent();
   }
   nsTArray<nsMenuPopupFrame *> popupsToHide;
   item = mPopups;
   while (item) {
     nsMenuPopupFrame* frame = item->Frame();
     if (frame == aPopup) {
       if (frame->PopupState() != ePopupInvisible) {
         // Iterate through any child menus and hide them as well, since the
         // parent is going away. We won't remove them from the list yet, just
         // hide them, as they will be removed from the list when this function
         // gets called for that child frame.
         nsMenuChainItem* child = item->GetChild();
         while (child) {
           // if the popup is a child frame of the menu that was destroyed, add
           // it to the list of popups to hide. Don't bother with the events
           // since the frames are going away. If the child menu is not a child
           // frame, for example, a context menu, use HidePopup instead, but call
           // it asynchronously since we are in the middle of frame destruction.
           nsMenuPopupFrame* childframe = child->Frame();
           if (nsLayoutUtils::IsProperAncestorFrame(frame, childframe)) {
             popupsToHide.AppendElement(childframe);
           }
           else {
             // HidePopup will take care of hiding any of its children, so
             // break out afterwards
             HidePopup(child->Content(), false, false, true, false);
             break;
           }
           child = child->GetChild();
         }
       }
       item->Detach(&mPopups);
       delete item;
       break;
     }
     item = item->GetParent();
   }
   HidePopupsInList(popupsToHide, false);
 }
 bool
 nsXULPopupManager::HasContextMenu(nsMenuPopupFrame* aPopup)
 {
   nsMenuChainItem* item = GetTopVisibleMenu();
   while (item && item->Frame() != aPopup) {
     if (item->IsContextMenu())
       return true;
     item = item->GetParent();
   }
   return false;
 }
 void
 nsXULPopupManager::SetCaptureState(nsIContent* aOldPopup)
 {
   nsMenuChainItem* item = GetTopVisibleMenu();
   if (item && aOldPopup == item->Content())
     return;
   if (mWidget) {
     mWidget->CaptureRollupEvents(nullptr, false);
     mWidget = nullptr;
   }
   if (item) {
     nsMenuPopupFrame* popup = item->Frame();
     mWidget = popup->GetWidget();
     if (mWidget) {
       mWidget->CaptureRollupEvents(nullptr, true);
       popup->AttachedDismissalListener();
     }
   }
   UpdateKeyboardListeners();
 }
 void
 nsXULPopupManager::UpdateKeyboardListeners()
 {
   nsCOMPtr<EventTarget> newTarget;
   bool isForMenu = false;
   nsMenuChainItem* item = GetTopVisibleMenu();
   if (item) {
     if (!item->IgnoreKeys())
       newTarget = item->Content()->GetDocument();
     isForMenu = item->PopupType() == ePopupTypeMenu;
   }
   else if (mActiveMenuBar) {
     newTarget = mActiveMenuBar->GetContent()->GetDocument();
     isForMenu = true;
   }
   if (mKeyListener != newTarget) {
     if (mKeyListener) {
       mKeyListener->RemoveEventListener(NS_LITERAL_STRING("keypress"), this, true);
       mKeyListener->RemoveEventListener(NS_LITERAL_STRING("keydown"), this, true);
       mKeyListener->RemoveEventListener(NS_LITERAL_STRING("keyup"), this, true);
       mKeyListener = nullptr;
       nsContentUtils::NotifyInstalledMenuKeyboardListener(false);
     }
     if (newTarget) {
       newTarget->AddEventListener(NS_LITERAL_STRING("keypress"), this, true);
       newTarget->AddEventListener(NS_LITERAL_STRING("keydown"), this, true);
       newTarget->AddEventListener(NS_LITERAL_STRING("keyup"), this, true);
       nsContentUtils::NotifyInstalledMenuKeyboardListener(isForMenu);
       mKeyListener = newTarget;
     }
   }
 }
 void
 nsXULPopupManager::UpdateMenuItems(nsIContent* aPopup)
 {
   // Walk all of the menu's children, checking to see if any of them has a
   // command attribute. If so, then several attributes must potentially be updated.
   nsCOMPtr<nsIDocument> document = aPopup->GetCurrentDoc();
   if (!document) {
     return;
   }
   for (nsCOMPtr<nsIContent> grandChild = aPopup->GetFirstChild();
        grandChild;
        grandChild = grandChild->GetNextSibling()) {
     if (grandChild->NodeInfo()->Equals(nsGkAtoms::menuitem, kNameSpaceID_XUL)) {
       // See if we have a command attribute.
       nsAutoString command;
       grandChild->GetAttr(kNameSpaceID_None, nsGkAtoms::command, command);
       if (!command.IsEmpty()) {
         // We do! Look it up in our document
         nsRefPtr<dom::Element> commandElement =
           document->GetElementById(command);
         if (commandElement) {
           nsAutoString commandValue;
           // The menu's disabled state needs to be updated to match the command.
           if (commandElement->GetAttr(kNameSpaceID_None, nsGkAtoms::disabled, commandValue))
             grandChild->SetAttr(kNameSpaceID_None, nsGkAtoms::disabled, commandValue, true);
           else
             grandChild->UnsetAttr(kNameSpaceID_None, nsGkAtoms::disabled, true);
           // The menu's label, accesskey checked and hidden states need to be updated
           // to match the command. Note that unlike the disabled state if the
           // command has *no* value, we assume the menu is supplying its own.
           if (commandElement->GetAttr(kNameSpaceID_None, nsGkAtoms::label, commandValue))
             grandChild->SetAttr(kNameSpaceID_None, nsGkAtoms::label, commandValue, true);
           if (commandElement->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, commandValue))
             grandChild->SetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, commandValue, true);
           if (commandElement->GetAttr(kNameSpaceID_None, nsGkAtoms::checked, commandValue))
             grandChild->SetAttr(kNameSpaceID_None, nsGkAtoms::checked, commandValue, true);
           if (commandElement->GetAttr(kNameSpaceID_None, nsGkAtoms::hidden, commandValue))
             grandChild->SetAttr(kNameSpaceID_None, nsGkAtoms::hidden, commandValue, true);
         }
       }
     }
   }
 }
 // Notify
 //
 // The item selection timer has fired, we might have to readjust the
 // selected item. There are two cases here that we are trying to deal with:
 //   (1) diagonal movement from a parent menu to a submenu passing briefly over
 //       other items, and
 //   (2) moving out from a submenu to a parent or grandparent menu.
 // In both cases, |mTimerMenu| is the menu item that might have an open submenu and
 // the first item in |mPopups| is the item the mouse is currently over, which could be
 // none of them.
 //
 // case (1):
 //  As the mouse moves from the parent item of a submenu (we'll call 'A') diagonally into the
 //  submenu, it probably passes through one or more sibilings (B). As the mouse passes
 //  through B, it becomes the current menu item and the timer is set and mTimerMenu is
 //  set to A. Before the timer fires, the mouse leaves the menu containing A and B and
 //  enters the submenus. Now when the timer fires, |mPopups| is null (!= |mTimerMenu|)
 //  so we have to see if anything in A's children is selected (recall that even disabled
 //  items are selected, the style just doesn't show it). If that is the case, we need to
 //  set the selected item back to A.
 //
 // case (2);
 //  Item A has an open submenu, and in it there is an item (B) which also has an open
 //  submenu (so there are 3 menus displayed right now). The mouse then leaves B's child
 //  submenu and selects an item that is a sibling of A, call it C. When the mouse enters C,
 //  the timer is set and |mTimerMenu| is A and |mPopups| is C. As the timer fires,
 //  the mouse is still within C. The correct behavior is to set the current item to C
 //  and close up the chain parented at A.
 //
 //  This brings up the question of is the logic of case (1) enough? The answer is no,
 //  and is discussed in bugzilla bug 29400. Case (1) asks if A's submenu has a selected
 //  child, and if it does, set the selected item to A. Because B has a submenu open, it
 //  is selected and as a result, A is set to be the selected item even though the mouse
 //  rests in C -- very wrong.
 //
 //  The solution is to use the same idea, but instead of only checking one level,
 //  drill all the way down to the deepest open submenu and check if it has something
 //  selected. Since the mouse is in a grandparent, it won't, and we know that we can
 //  safely close up A and all its children.
 //
 // The code below melds the two cases together.
 //
 nsresult
 nsXULPopupManager::Notify(nsITimer* aTimer)
 {
   if (aTimer == mCloseTimer)
     KillMenuTimer();
   return NS_OK;
 }
 void
 nsXULPopupManager::KillMenuTimer()
 {
   if (mCloseTimer && mTimerMenu) {
     mCloseTimer->Cancel();
     mCloseTimer = nullptr;
     if (mTimerMenu->IsOpen())
       HidePopup(mTimerMenu->GetContent(), false, false, true, false);
   }
   mTimerMenu = nullptr;
 }
 void
 nsXULPopupManager::CancelMenuTimer(nsMenuParent* aMenuParent)
 {
   if (mCloseTimer && mTimerMenu == aMenuParent) {
     mCloseTimer->Cancel();
     mCloseTimer = nullptr;
     mTimerMenu = nullptr;
   }
 }
 bool
 nsXULPopupManager::HandleShortcutNavigation(nsIDOMKeyEvent* aKeyEvent,
                                             nsMenuPopupFrame* aFrame)
 {
   nsMenuChainItem* item = GetTopVisibleMenu();
   if (!aFrame && item)
     aFrame = item->Frame();
   if (aFrame) {
     bool action;
     nsMenuFrame* result = aFrame->FindMenuWithShortcut(aKeyEvent, action);
     if (result) {
       aFrame->ChangeMenuItem(result, false);
       if (action) {
         WidgetGUIEvent* evt = aKeyEvent->GetInternalNSEvent()->AsGUIEvent();
         nsMenuFrame* menuToOpen = result->Enter(evt);
         if (menuToOpen) {
           nsCOMPtr<nsIContent> content = menuToOpen->GetContent();
           ShowMenu(content, true, false);
         }
       }
       return true;
     }
     return false;
   }
   if (mActiveMenuBar) {
     nsMenuFrame* result = mActiveMenuBar->FindMenuWithShortcut(aKeyEvent);
     if (result) {
       mActiveMenuBar->SetActive(true);
       result->OpenMenu(true);
       return true;
     }
   }
   return false;
 }
 bool
 nsXULPopupManager::HandleKeyboardNavigation(uint32_t aKeyCode)
 {
   // navigate up through the open menus, looking for the topmost one
   // in the same hierarchy
   nsMenuChainItem* item = nullptr;
   nsMenuChainItem* nextitem = GetTopVisibleMenu();
   while (nextitem) {
     item = nextitem;
     nextitem = item->GetParent();
     if (nextitem) {
       // stop if the parent isn't a menu
       if (!nextitem->IsMenu())
         break;
       // check to make sure that the parent is actually the parent menu. It won't
       // be if the parent is in a different frame hierarchy, for example, for a
       // context menu opened on another menu.
       nsMenuParent* expectedParent = static_cast<nsMenuParent *>(nextitem->Frame());
       nsMenuFrame* menuFrame = do_QueryFrame(item->Frame()->GetParent());
       if (!menuFrame || menuFrame->GetMenuParent() != expectedParent) {
         break;
       }
     }
   }
   nsIFrame* itemFrame;
   if (item)
     itemFrame = item->Frame();
   else if (mActiveMenuBar)
     itemFrame = mActiveMenuBar;
   else
     return false;
   nsNavigationDirection theDirection;
   NS_ASSERTION(aKeyCode >= nsIDOMKeyEvent::DOM_VK_END &&
                  aKeyCode <= nsIDOMKeyEvent::DOM_VK_DOWN, "Illegal key code");
   theDirection = NS_DIRECTION_FROM_KEY_CODE(itemFrame, aKeyCode);
   // if a popup is open, first check for navigation within the popup
   if (item && HandleKeyboardNavigationInPopup(item, theDirection))
     return true;
   // no popup handled the key, so check the active menubar, if any
   if (mActiveMenuBar) {
     nsMenuFrame* currentMenu = mActiveMenuBar->GetCurrentMenuItem();
     if (NS_DIRECTION_IS_INLINE(theDirection)) {
       nsMenuFrame* nextItem = (theDirection == eNavigationDirection_End) ?
                               GetNextMenuItem(mActiveMenuBar, currentMenu, false) :
                               GetPreviousMenuItem(mActiveMenuBar, currentMenu, false);
       mActiveMenuBar->ChangeMenuItem(nextItem, true);
       return true;
     }
     else if (NS_DIRECTION_IS_BLOCK(theDirection)) {
       // Open the menu and select its first item.
       if (currentMenu) {
         nsCOMPtr<nsIContent> content = currentMenu->GetContent();
         ShowMenu(content, true, false);
       }
       return true;
     }
   }
   return false;
 }
 bool
 nsXULPopupManager::HandleKeyboardNavigationInPopup(nsMenuChainItem* item,
                                                    nsMenuPopupFrame* aFrame,
                                                    nsNavigationDirection aDir)
 {
   NS_ASSERTION(aFrame, "aFrame is null");
   NS_ASSERTION(!item || item->Frame() == aFrame,
                "aFrame is expected to be equal to item->Frame()");
   nsMenuFrame* currentMenu = aFrame->GetCurrentMenuItem();
   aFrame->ClearIncrementalString();
   // This method only gets called if we're open.
   if (!currentMenu && NS_DIRECTION_IS_INLINE(aDir)) {
     // We've been opened, but we haven't had anything selected.
     // We can handle End, but our parent handles Start.
     if (aDir == eNavigationDirection_End) {
       nsMenuFrame* nextItem = GetNextMenuItem(aFrame, nullptr, true);
       if (nextItem) {
         aFrame->ChangeMenuItem(nextItem, false);
         return true;
       }
     }
     return false;
   }
   bool isContainer = false;
   bool isOpen = false;
   if (currentMenu) {
     isOpen = currentMenu->IsOpen();
     isContainer = currentMenu->IsMenu();
     if (isOpen) {
       // for an open popup, have the child process the event
       nsMenuChainItem* child = item ? item->GetChild() : nullptr;
       if (child && HandleKeyboardNavigationInPopup(child, aDir))
         return true;
     }
     else if (aDir == eNavigationDirection_End &&
              isContainer && !currentMenu->IsDisabled()) {
       // The menu is not yet open. Open it and select the first item.
       nsCOMPtr<nsIContent> content = currentMenu->GetContent();
       ShowMenu(content, true, false);
       return true;
     }
   }
   // For block progression, we can move in either direction
   if (NS_DIRECTION_IS_BLOCK(aDir) ||
       NS_DIRECTION_IS_BLOCK_TO_EDGE(aDir)) {
     nsMenuFrame* nextItem;
     if (aDir == eNavigationDirection_Before)
       nextItem = GetPreviousMenuItem(aFrame, currentMenu, true);
     else if (aDir == eNavigationDirection_After)
       nextItem = GetNextMenuItem(aFrame, currentMenu, true);
     else if (aDir == eNavigationDirection_First)
       nextItem = GetNextMenuItem(aFrame, nullptr, true);
     else
       nextItem = GetPreviousMenuItem(aFrame, nullptr, true);
     if (nextItem) {
       aFrame->ChangeMenuItem(nextItem, false);
       return true;
     }
   }
   else if (currentMenu && isContainer && isOpen) {
     if (aDir == eNavigationDirection_Start) {
       // close a submenu when Left is pressed
       nsMenuPopupFrame* popupFrame = currentMenu->GetPopup();
       if (popupFrame)
         HidePopup(popupFrame->GetContent(), false, false, false, false);
       return true;
     }
   }
   return false;
 }
 bool
 nsXULPopupManager::HandleKeyboardEventWithKeyCode(
                         nsIDOMKeyEvent* aKeyEvent,
                         nsMenuChainItem* aTopVisibleMenuItem)
 {
   uint32_t keyCode;
   aKeyEvent->GetKeyCode(&keyCode);
   // Escape should close panels, but the other keys should have no effect.
   if (aTopVisibleMenuItem &&
       aTopVisibleMenuItem->PopupType() != ePopupTypeMenu) {
     if (keyCode == nsIDOMKeyEvent::DOM_VK_ESCAPE) {
       HidePopup(aTopVisibleMenuItem->Content(), false, false, false, true);
       aKeyEvent->StopPropagation();
       aKeyEvent->PreventDefault();
     }
     return true;
   }
   bool consume = (mPopups || mActiveMenuBar);
   switch (keyCode) {
     case nsIDOMKeyEvent::DOM_VK_LEFT:
     case nsIDOMKeyEvent::DOM_VK_RIGHT:
     case nsIDOMKeyEvent::DOM_VK_UP:
     case nsIDOMKeyEvent::DOM_VK_DOWN:
     case nsIDOMKeyEvent::DOM_VK_HOME:
     case nsIDOMKeyEvent::DOM_VK_END:
       HandleKeyboardNavigation(keyCode);
       break;
     case nsIDOMKeyEvent::DOM_VK_ESCAPE:
       // Pressing Escape hides one level of menus only. If no menu is open,
       // check if a menubar is active and inform it that a menu closed. Even
       // though in this latter case, a menu didn't actually close, the effect
       // ends up being the same. Similar for the tab key below.
       if (aTopVisibleMenuItem) {
         HidePopup(aTopVisibleMenuItem->Content(), false, false, false, true);
       } else if (mActiveMenuBar) {
         mActiveMenuBar->MenuClosed();
       }
       break;
     case nsIDOMKeyEvent::DOM_VK_TAB:
 #ifndef XP_MACOSX
     case nsIDOMKeyEvent::DOM_VK_F10:
 #endif
       // close popups or deactivate menubar when Tab or F10 are pressed
       if (aTopVisibleMenuItem) {
         Rollup(0, nullptr, nullptr);
       } else if (mActiveMenuBar) {
         mActiveMenuBar->MenuClosed();
       }
       break;
     case nsIDOMKeyEvent::DOM_VK_RETURN: {
       // If there is a popup open, check if the current item needs to be opened.
       // Otherwise, tell the active menubar, if any, to activate the menu. The
       // Enter method will return a menu if one needs to be opened as a result.
       nsMenuFrame* menuToOpen = nullptr;
       WidgetGUIEvent* GUIEvent = aKeyEvent->GetInternalNSEvent()->AsGUIEvent();
       if (aTopVisibleMenuItem) {
         menuToOpen = aTopVisibleMenuItem->Frame()->Enter(GUIEvent);
       } else if (mActiveMenuBar) {
         menuToOpen = mActiveMenuBar->Enter(GUIEvent);
       }
       if (menuToOpen) {
         nsCOMPtr<nsIContent> content = menuToOpen->GetContent();
         ShowMenu(content, true, false);
       }
       break;
     }
     default:
       return false;
   }
   if (consume) {
     aKeyEvent->StopPropagation();
     aKeyEvent->PreventDefault();
   }
   return true;
 }
 nsMenuFrame*
 nsXULPopupManager::GetNextMenuItem(nsIFrame* aParent,
                                    nsMenuFrame* aStart,
                                    bool aIsPopup)
 {
   nsPresContext* presContext = aParent->PresContext();
   nsIFrame* immediateParent = presContext->PresShell()->
     FrameConstructor()->GetInsertionPoint(aParent->GetContent(), nullptr);
   if (!immediateParent)
     immediateParent = aParent;
   nsIFrame* currFrame = nullptr;
   if (aStart)
     currFrame = aStart->GetNextSibling();
   else
     currFrame = immediateParent->GetFirstPrincipalChild();
   while (currFrame) {
     // See if it's a menu item.
     if (IsValidMenuItem(presContext, currFrame->GetContent(), aIsPopup)) {
       return do_QueryFrame(currFrame);
     }
     currFrame = currFrame->GetNextSibling();
   }
   currFrame = immediateParent->GetFirstPrincipalChild();
   // Still don't have anything. Try cycling from the beginning.
   while (currFrame && currFrame != aStart) {
     // See if it's a menu item.
     if (IsValidMenuItem(presContext, currFrame->GetContent(), aIsPopup)) {
       return do_QueryFrame(currFrame);
     }
     currFrame = currFrame->GetNextSibling();
   }
   // No luck. Just return our start value.
   return aStart;
 }
 nsMenuFrame*
 nsXULPopupManager::GetPreviousMenuItem(nsIFrame* aParent,
                                        nsMenuFrame* aStart,
                                        bool aIsPopup)
 {
   nsPresContext* presContext = aParent->PresContext();
   nsIFrame* immediateParent = presContext->PresShell()->
     FrameConstructor()->GetInsertionPoint(aParent->GetContent(), nullptr);
   if (!immediateParent)
     immediateParent = aParent;
   const nsFrameList& frames(immediateParent->PrincipalChildList());
   nsIFrame* currFrame = nullptr;
   if (aStart)
     currFrame = aStart->GetPrevSibling();
   else
     currFrame = frames.LastChild();
   while (currFrame) {
     // See if it's a menu item.
     if (IsValidMenuItem(presContext, currFrame->GetContent(), aIsPopup)) {
       return do_QueryFrame(currFrame);
     }
     currFrame = currFrame->GetPrevSibling();
   }
   currFrame = frames.LastChild();
   // Still don't have anything. Try cycling from the end.
   while (currFrame && currFrame != aStart) {
     // See if it's a menu item.
     if (IsValidMenuItem(presContext, currFrame->GetContent(), aIsPopup)) {
       return do_QueryFrame(currFrame);
     }
     currFrame = currFrame->GetPrevSibling();
   }
   // No luck. Just return our start value.
   return aStart;
 }
 bool
 nsXULPopupManager::IsValidMenuItem(nsPresContext* aPresContext,
                                    nsIContent* aContent,
                                    bool aOnPopup)
 {
   int32_t ns = aContent->GetNameSpaceID();
   nsIAtom *tag = aContent->Tag();
   if (ns == kNameSpaceID_XUL) {
     if (tag != nsGkAtoms::menu && tag != nsGkAtoms::menuitem)
       return false;
   }
   else if (ns != kNameSpaceID_XHTML || !aOnPopup || tag != nsGkAtoms::option) {
     return false;
   }
   bool skipNavigatingDisabledMenuItem = true;
   if (aOnPopup) {
     skipNavigatingDisabledMenuItem =
       LookAndFeel::GetInt(LookAndFeel::eIntID_SkipNavigatingDisabledMenuItem,
 ) != 0;
   }
   return !(skipNavigatingDisabledMenuItem &&
            aContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
                                  nsGkAtoms::_true, eCaseMatters));
 }
 nsresult
 nsXULPopupManager::HandleEvent(nsIDOMEvent* aEvent)
 {
   nsCOMPtr<nsIDOMKeyEvent> keyEvent = do_QueryInterface(aEvent);
   NS_ENSURE_TRUE(keyEvent, NS_ERROR_UNEXPECTED);
   //handlers shouldn't be triggered by non-trusted events.
   bool trustedEvent = false;
   aEvent->GetIsTrusted(&trustedEvent);
   if (!trustedEvent) {
     return NS_OK;
   }
   nsAutoString eventType;
   keyEvent->GetType(eventType);
   if (eventType.EqualsLiteral("keyup")) {
     return KeyUp(keyEvent);
   }
   if (eventType.EqualsLiteral("keydown")) {
     return KeyDown(keyEvent);
   }
   if (eventType.EqualsLiteral("keypress")) {
     return KeyPress(keyEvent);
   }
   NS_ABORT();
   return NS_OK;
 }
 nsresult
 nsXULPopupManager::KeyUp(nsIDOMKeyEvent* aKeyEvent)
 {
   // don't do anything if a menu isn't open or a menubar isn't active
   if (!mActiveMenuBar) {
     nsMenuChainItem* item = GetTopVisibleMenu();
     if (!item || item->PopupType() != ePopupTypeMenu)
       return NS_OK;
   }
   aKeyEvent->StopPropagation();
   aKeyEvent->PreventDefault();
   return NS_OK; // I am consuming event
 }
 nsresult
 nsXULPopupManager::KeyDown(nsIDOMKeyEvent* aKeyEvent)
 {
   nsMenuChainItem* item = GetTopVisibleMenu();
   if (item && item->Frame()->IsMenuLocked())
     return NS_OK;
   if (HandleKeyboardEventWithKeyCode(aKeyEvent, item)) {
     return NS_OK;
   }
   // don't do anything if a menu isn't open or a menubar isn't active
   if (!mActiveMenuBar && (!item || item->PopupType() != ePopupTypeMenu))
     return NS_OK;
   int32_t menuAccessKey = -1;
   // If the key just pressed is the access key (usually Alt),
   // dismiss and unfocus the menu.
   nsMenuBarListener::GetMenuAccessKey(&menuAccessKey);
   if (menuAccessKey) {
     uint32_t theChar;
     aKeyEvent->GetKeyCode(&theChar);
     if (theChar == (uint32_t)menuAccessKey) {
       bool ctrl = false;
       if (menuAccessKey != nsIDOMKeyEvent::DOM_VK_CONTROL)
         aKeyEvent->GetCtrlKey(&ctrl);
       bool alt=false;
       if (menuAccessKey != nsIDOMKeyEvent::DOM_VK_ALT)
         aKeyEvent->GetAltKey(&alt);
       bool shift=false;
       if (menuAccessKey != nsIDOMKeyEvent::DOM_VK_SHIFT)
         aKeyEvent->GetShiftKey(&shift);
       bool meta=false;
       if (menuAccessKey != nsIDOMKeyEvent::DOM_VK_META)
         aKeyEvent->GetMetaKey(&meta);
       if (!(ctrl || alt || shift || meta)) {
         // The access key just went down and no other
         // modifiers are already down.
         if (mPopups)
           Rollup(0, nullptr, nullptr);
         else if (mActiveMenuBar)
           mActiveMenuBar->MenuClosed();
       }
       aKeyEvent->PreventDefault();
     }
   }
   // Since a menu was open, stop propagation of the event to keep other event
   // listeners from becoming confused.
   aKeyEvent->StopPropagation();
   return NS_OK;
 }
 nsresult
 nsXULPopupManager::KeyPress(nsIDOMKeyEvent* aKeyEvent)
 {
   // Don't check prevent default flag -- menus always get first shot at key events.
   nsMenuChainItem* item = GetTopVisibleMenu();
   if (item &&
       (item->Frame()->IsMenuLocked() || item->PopupType() != ePopupTypeMenu)) {
     return NS_OK;
   }
   nsCOMPtr<nsIDOMKeyEvent> keyEvent = do_QueryInterface(aKeyEvent);
   NS_ENSURE_TRUE(keyEvent, NS_ERROR_UNEXPECTED);
   // if a menu is open or a menubar is active, it consumes the key event
   bool consume = (mPopups || mActiveMenuBar);
   HandleShortcutNavigation(keyEvent, nullptr);
   if (consume) {
     aKeyEvent->StopPropagation();
     aKeyEvent->PreventDefault();
   }
   return NS_OK; // I am consuming event
 }
 NS_IMETHODIMP
 nsXULPopupShowingEvent::Run()
 {
   nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
   if (pm) {
     pm->FirePopupShowingEvent(mPopup, mIsContextMenu, mSelectFirstItem);
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsXULPopupHidingEvent::Run()
 {
   nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
   nsIDocument *document = mPopup->GetCurrentDoc();
   if (pm && document) {
     nsIPresShell* presShell = document->GetShell();
     if (presShell) {
       nsPresContext* context = presShell->GetPresContext();
       if (context) {
         pm->FirePopupHidingEvent(mPopup, mNextPopup, mLastPopup,
                                  context, mPopupType, mDeselectMenu, mIsRollup);
       }
     }
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsXULMenuCommandEvent::Run()
 {
   nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
   if (!pm)
     return NS_OK;
   // The order of the nsViewManager and nsIPresShell COM pointers is
   // important below.  We want the pres shell to get released before the
   // associated view manager on exit from this function.
   // See bug 54233.
   // XXXndeakin is this still needed?
   nsCOMPtr<nsIContent> popup;
   nsMenuFrame* menuFrame = do_QueryFrame(mMenu->GetPrimaryFrame());
   nsWeakFrame weakFrame(menuFrame);
   if (menuFrame && mFlipChecked) {
     if (menuFrame->IsChecked()) {
       mMenu->UnsetAttr(kNameSpaceID_None, nsGkAtoms::checked, true);
     } else {
       mMenu->SetAttr(kNameSpaceID_None, nsGkAtoms::checked,
                      NS_LITERAL_STRING("true"), true);
     }
   }
   if (menuFrame && weakFrame.IsAlive()) {
     // Find the popup that the menu is inside. Below, this popup will
     // need to be hidden.
     nsIFrame* frame = menuFrame->GetParent();
     while (frame) {
       nsMenuPopupFrame* popupFrame = do_QueryFrame(frame);
       if (popupFrame) {
         popup = popupFrame->GetContent();
         break;
       }
       frame = frame->GetParent();
     }
     nsPresContext* presContext = menuFrame->PresContext();
     nsCOMPtr<nsIPresShell> shell = presContext->PresShell();
     nsRefPtr<nsViewManager> kungFuDeathGrip = shell->GetViewManager();
     // Deselect ourselves.
     if (mCloseMenuMode != CloseMenuMode_None)
       menuFrame->SelectMenu(false);
     AutoHandlingUserInputStatePusher userInpStatePusher(mUserInput, nullptr,
                                                         shell->GetDocument());
     nsContentUtils::DispatchXULCommand(mMenu, mIsTrusted, nullptr, shell,
                                        mControl, mAlt, mShift, mMeta);
   }
   if (popup && mCloseMenuMode != CloseMenuMode_None)
     pm->HidePopup(popup, mCloseMenuMode == CloseMenuMode_Auto, true, false, false);
   return NS_OK;
 }

The Tor Browser / annotate

layout/xul/nsXULPopupManager.cpp@ac0c01689b40 (annotated)

layout/xul/nsXULPopupManager.cpp