Add m-esr52 at 52.6.0

1 files changed, 1514 insertions, 0 deletions

diff --git a/layout/xul/nsMenuFrame.cpp b/layout/xul/nsMenuFrame.cpp
new file mode 100644
index 000000000..ea968fab5
--- /dev/null
+++ b/layout/xul/nsMenuFrame.cpp
@@ -0,0 +1,1514 @@
+/* -*- Mode: C++; tab-width: 8; 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 "nsHTMLParts.h"
+#include "nsMenuFrame.h"
+#include "nsBoxFrame.h"
+#include "nsIContent.h"
+#include "nsIAtom.h"
+#include "nsPresContext.h"
+#include "nsIPresShell.h"
+#include "nsStyleContext.h"
+#include "nsCSSRendering.h"
+#include "nsNameSpaceManager.h"
+#include "nsMenuPopupFrame.h"
+#include "nsMenuBarFrame.h"
+#include "nsIDocument.h"
+#include "nsIDOMElement.h"
+#include "nsIComponentManager.h"
+#include "nsBoxLayoutState.h"
+#include "nsIScrollableFrame.h"
+#include "nsBindingManager.h"
+#include "nsIServiceManager.h"
+#include "nsCSSFrameConstructor.h"
+#include "nsIDOMKeyEvent.h"
+#include "nsXPIDLString.h"
+#include "nsReadableUtils.h"
+#include "nsUnicharUtils.h"
+#include "nsIStringBundle.h"
+#include "nsContentUtils.h"
+#include "nsDisplayList.h"
+#include "nsIReflowCallback.h"
+#include "nsISound.h"
+#include "nsIDOMXULMenuListElement.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/Likely.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Services.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/Event.h"
+#include <algorithm>
+
+using namespace mozilla;
+
+#define NS_MENU_POPUP_LIST_INDEX 0
+
+#if defined(XP_WIN)
+#define NSCONTEXTMENUISMOUSEUP 1
+#endif
+
+NS_DECLARE_FRAME_PROPERTY_FRAMELIST(PopupListProperty)
+
+// This global flag indicates that a menu just opened or closed and is used
+// to ignore the mousemove and mouseup events that would fire on the menu after
+// the mousedown occurred.
+static int32_t gMenuJustOpenedOrClosed = false;
+
+const int32_t kBlinkDelay = 67; // milliseconds
+
+// this class is used for dispatching menu activation events asynchronously.
+class nsMenuActivateEvent : public Runnable
+{
+public:
+  nsMenuActivateEvent(nsIContent *aMenu,
+                      nsPresContext* aPresContext,
+                      bool aIsActivate)
+    : mMenu(aMenu), mPresContext(aPresContext), mIsActivate(aIsActivate)
+  {
+  }
+
+  NS_IMETHOD Run() override
+  {
+    nsAutoString domEventToFire;
+
+    if (mIsActivate) {
+      // Highlight the menu.
+      mMenu->SetAttr(kNameSpaceID_None, nsGkAtoms::menuactive,
+                     NS_LITERAL_STRING("true"), true);
+      // The menuactivated event is used by accessibility to track the user's
+      // movements through menus
+      domEventToFire.AssignLiteral("DOMMenuItemActive");
+    }
+    else {
+      // Unhighlight the menu.
+      mMenu->UnsetAttr(kNameSpaceID_None, nsGkAtoms::menuactive, true);
+      domEventToFire.AssignLiteral("DOMMenuItemInactive");
+    }
+
+    RefPtr<Event> event = NS_NewDOMEvent(mMenu, mPresContext, nullptr);
+    event->InitEvent(domEventToFire, true, true);
+
+    event->SetTrusted(true);
+
+    EventDispatcher::DispatchDOMEvent(mMenu, nullptr, event,
+        mPresContext, nullptr);
+
+    return NS_OK;
+  }
+
+private:
+  nsCOMPtr<nsIContent> mMenu;
+  RefPtr<nsPresContext> mPresContext;
+  bool mIsActivate;
+};
+
+class nsMenuAttributeChangedEvent : public Runnable
+{
+public:
+  nsMenuAttributeChangedEvent(nsIFrame* aFrame, nsIAtom* aAttr)
+  : mFrame(aFrame), mAttr(aAttr)
+  {
+  }
+
+  NS_IMETHOD Run() override
+  {
+    nsMenuFrame* frame = static_cast<nsMenuFrame*>(mFrame.GetFrame());
+    NS_ENSURE_STATE(frame);
+    if (mAttr == nsGkAtoms::checked) {
+      frame->UpdateMenuSpecialState();
+    } else if (mAttr == nsGkAtoms::acceltext) {
+      // someone reset the accelText attribute,
+      // so clear the bit that says *we* set it
+      frame->RemoveStateBits(NS_STATE_ACCELTEXT_IS_DERIVED);
+      frame->BuildAcceleratorText(true);
+    }
+    else if (mAttr == nsGkAtoms::key) {
+      frame->BuildAcceleratorText(true);
+    } else if (mAttr == nsGkAtoms::type || mAttr == nsGkAtoms::name) {
+      frame->UpdateMenuType();
+    }
+    return NS_OK;
+  }
+protected:
+  nsWeakFrame       mFrame;
+  nsCOMPtr<nsIAtom> mAttr;
+};
+
+//
+// NS_NewMenuFrame and NS_NewMenuItemFrame
+//
+// Wrappers for creating a new menu popup container
+//
+nsIFrame*
+NS_NewMenuFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+  nsMenuFrame* it = new (aPresShell) nsMenuFrame(aContext);
+  it->SetIsMenu(true);
+  return it;
+}
+
+nsIFrame*
+NS_NewMenuItemFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+  nsMenuFrame* it = new (aPresShell) nsMenuFrame(aContext);
+  it->SetIsMenu(false);
+  return it;
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsMenuFrame)
+
+NS_QUERYFRAME_HEAD(nsMenuFrame)
+  NS_QUERYFRAME_ENTRY(nsMenuFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsBoxFrame)
+
+nsMenuFrame::nsMenuFrame(nsStyleContext* aContext):
+  nsBoxFrame(aContext),
+    mIsMenu(false),
+    mChecked(false),
+    mIgnoreAccelTextChange(false),
+    mType(eMenuType_Normal),
+    mBlinkState(0)
+{
+}
+
+nsMenuParent*
+nsMenuFrame::GetMenuParent() const
+{
+  nsContainerFrame* parent = GetParent();
+  for (; parent; parent = parent->GetParent()) {
+    nsMenuPopupFrame* popup = do_QueryFrame(parent);
+    if (popup) {
+      return popup;
+    }
+    nsMenuBarFrame* menubar = do_QueryFrame(parent);
+    if (menubar) {
+      return menubar;
+    }
+  }
+  return nullptr;
+}
+
+class nsASyncMenuInitialization final : public nsIReflowCallback
+{
+public:
+  explicit nsASyncMenuInitialization(nsIFrame* aFrame)
+    : mWeakFrame(aFrame)
+  {
+  }
+
+  virtual bool ReflowFinished() override
+  {
+    bool shouldFlush = false;
+    nsMenuFrame* menu = do_QueryFrame(mWeakFrame.GetFrame());
+    if (menu) {
+      menu->UpdateMenuType();
+      shouldFlush = true;
+    }
+    delete this;
+    return shouldFlush;
+  }
+
+  virtual void ReflowCallbackCanceled() override
+  {
+    delete this;
+  }
+
+  nsWeakFrame mWeakFrame;
+};
+
+void
+nsMenuFrame::Init(nsIContent*       aContent,
+                  nsContainerFrame* aParent,
+                  nsIFrame*         aPrevInFlow)
+{
+  nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
+
+  // Set up a mediator which can be used for callbacks on this frame.
+  mTimerMediator = new nsMenuTimerMediator(this);
+
+  BuildAcceleratorText(false);
+  nsIReflowCallback* cb = new nsASyncMenuInitialization(this);
+  PresContext()->PresShell()->PostReflowCallback(cb);
+}
+
+const nsFrameList&
+nsMenuFrame::GetChildList(ChildListID aListID) const
+{
+  if (kPopupList == aListID) {
+    nsFrameList* list = GetPopupList();
+    return list ? *list : nsFrameList::EmptyList();
+  }
+  return nsBoxFrame::GetChildList(aListID);
+}
+
+void
+nsMenuFrame::GetChildLists(nsTArray<ChildList>* aLists) const
+{
+  nsBoxFrame::GetChildLists(aLists);
+  nsFrameList* list = GetPopupList();
+  if (list) {
+    list->AppendIfNonempty(aLists, kPopupList);
+  }
+}
+
+nsMenuPopupFrame*
+nsMenuFrame::GetPopup()
+{
+  nsFrameList* popupList = GetPopupList();
+  return popupList ? static_cast<nsMenuPopupFrame*>(popupList->FirstChild()) :
+                     nullptr;
+}
+
+nsFrameList*
+nsMenuFrame::GetPopupList() const
+{
+  if (!HasPopup()) {
+    return nullptr;
+  }
+  nsFrameList* prop = Properties().Get(PopupListProperty());
+  NS_ASSERTION(prop && prop->GetLength() == 1 &&
+               prop->FirstChild()->GetType() == nsGkAtoms::menuPopupFrame,
+               "popup list should have exactly one nsMenuPopupFrame");
+  return prop;
+}
+
+void
+nsMenuFrame::DestroyPopupList()
+{
+  NS_ASSERTION(HasPopup(), "huh?");
+  nsFrameList* prop = Properties().Remove(PopupListProperty());
+  NS_ASSERTION(prop && prop->IsEmpty(),
+               "popup list must exist and be empty when destroying");
+  RemoveStateBits(NS_STATE_MENU_HAS_POPUP_LIST);
+  prop->Delete(PresContext()->PresShell());
+}
+
+void
+nsMenuFrame::SetPopupFrame(nsFrameList& aFrameList)
+{
+  for (nsFrameList::Enumerator e(aFrameList); !e.AtEnd(); e.Next()) {
+    nsMenuPopupFrame* popupFrame = do_QueryFrame(e.get());
+    if (popupFrame) {
+      // Remove the frame from the list and store it in a nsFrameList* property.
+      aFrameList.RemoveFrame(popupFrame);
+      nsFrameList* popupList = new (PresContext()->PresShell()) nsFrameList(popupFrame, popupFrame);
+      Properties().Set(PopupListProperty(), popupList);
+      AddStateBits(NS_STATE_MENU_HAS_POPUP_LIST);
+      break;
+    }
+  }
+}
+
+void
+nsMenuFrame::SetInitialChildList(ChildListID     aListID,
+                                 nsFrameList&    aChildList)
+{
+  if (aListID == kPrincipalList || aListID == kPopupList) {
+    NS_ASSERTION(!HasPopup(), "SetInitialChildList called twice?");
+    SetPopupFrame(aChildList);
+  }
+  nsBoxFrame::SetInitialChildList(aListID, aChildList);
+}
+
+void
+nsMenuFrame::DestroyFrom(nsIFrame* aDestructRoot)
+{
+  // Kill our timer if one is active. This is not strictly necessary as
+  // the pointer to this frame will be cleared from the mediator, but
+  // this is done for added safety.
+  if (mOpenTimer) {
+    mOpenTimer->Cancel();
+  }
+
+  StopBlinking();
+
+  // Null out the pointer to this frame in the mediator wrapper so that it 
+  // doesn't try to interact with a deallocated frame.
+  mTimerMediator->ClearFrame();
+
+  // if the menu content is just being hidden, it may be made visible again
+  // later, so make sure to clear the highlighting.
+  mContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::menuactive, false);
+
+  // are we our menu parent's current menu item?
+  nsMenuParent* menuParent = GetMenuParent();
+  if (menuParent && menuParent->GetCurrentMenuItem() == this) {
+    // yes; tell it that we're going away
+    menuParent->CurrentMenuIsBeingDestroyed();
+  }
+
+  nsFrameList* popupList = GetPopupList();
+  if (popupList) {
+    popupList->DestroyFramesFrom(aDestructRoot);
+    DestroyPopupList();
+  }
+
+  nsBoxFrame::DestroyFrom(aDestructRoot);
+}
+
+void
+nsMenuFrame::BuildDisplayListForChildren(nsDisplayListBuilder*   aBuilder,
+                                         const nsRect&           aDirtyRect,
+                                         const nsDisplayListSet& aLists)
+{
+  if (!aBuilder->IsForEventDelivery()) {
+    nsBoxFrame::BuildDisplayListForChildren(aBuilder, aDirtyRect, aLists);
+    return;
+  }
+    
+  nsDisplayListCollection set;
+  nsBoxFrame::BuildDisplayListForChildren(aBuilder, aDirtyRect, set);
+  
+  WrapListsInRedirector(aBuilder, set, aLists);
+}
+
+nsresult
+nsMenuFrame::HandleEvent(nsPresContext* aPresContext,
+                         WidgetGUIEvent* aEvent,
+                         nsEventStatus* aEventStatus)
+{
+  NS_ENSURE_ARG_POINTER(aEventStatus);
+  if (nsEventStatus_eConsumeNoDefault == *aEventStatus) {
+    return NS_OK;
+  }
+  nsMenuParent* menuParent = GetMenuParent();
+  if (menuParent && menuParent->IsMenuLocked()) {
+    return NS_OK;
+  }
+
+  nsWeakFrame weakFrame(this);
+  if (*aEventStatus == nsEventStatus_eIgnore)
+    *aEventStatus = nsEventStatus_eConsumeDoDefault;
+
+  // If a menu just opened, ignore the mouseup event that might occur after a
+  // the mousedown event that opened it. However, if a different mousedown
+  // event occurs, just clear this flag.
+  if (gMenuJustOpenedOrClosed) {
+    if (aEvent->mMessage == eMouseDown) {
+      gMenuJustOpenedOrClosed = false;
+    } else if (aEvent->mMessage == eMouseUp) {
+      return NS_OK;
+    }
+  }
+
+  bool onmenu = IsOnMenu();
+
+  if (aEvent->mMessage == eKeyPress && !IsDisabled()) {
+    WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent();
+    uint32_t keyCode = keyEvent->mKeyCode;
+#ifdef XP_MACOSX
+    // On mac, open menulist on either up/down arrow or space (w/o Cmd pressed)
+    if (!IsOpen() && ((keyEvent->mCharCode == ' ' && !keyEvent->IsMeta()) ||
+        (keyCode == NS_VK_UP || keyCode == NS_VK_DOWN))) {
+
+      // When pressing space, don't open the menu if performing an incremental search.
+      if (keyEvent->mCharCode != ' ' ||
+          !nsMenuPopupFrame::IsWithinIncrementalTime(keyEvent->mTime)) {
+        *aEventStatus = nsEventStatus_eConsumeNoDefault;
+        OpenMenu(false);
+      }
+    }
+#else
+    // On other platforms, toggle menulist on unmodified F4 or Alt arrow
+    if ((keyCode == NS_VK_F4 && !keyEvent->IsAlt()) ||
+        ((keyCode == NS_VK_UP || keyCode == NS_VK_DOWN) && keyEvent->IsAlt())) {
+      *aEventStatus = nsEventStatus_eConsumeNoDefault;
+      ToggleMenuState();
+    }
+#endif
+  }
+  else if (aEvent->mMessage == eMouseDown &&
+           aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton &&
+           !IsDisabled() && IsMenu()) {
+    // The menu item was selected. Bring up the menu.
+    // We have children.
+    // Don't prevent the default action here, since that will also cancel
+    // potential drag starts.
+    if (!menuParent || menuParent->IsMenuBar()) {
+      ToggleMenuState();
+    }
+    else {
+      if (!IsOpen()) {
+        menuParent->ChangeMenuItem(this, false, false);
+        OpenMenu(false);
+      }
+    }
+  }
+  else if (
+#ifndef NSCONTEXTMENUISMOUSEUP
+           (aEvent->mMessage == eMouseUp &&
+            aEvent->AsMouseEvent()->button == WidgetMouseEvent::eRightButton) &&
+#else
+           aEvent->mMessage == eContextMenu &&
+#endif
+           onmenu && !IsMenu() && !IsDisabled()) {
+    // if this menu is a context menu it accepts right-clicks...fire away!
+    // Make sure we cancel default processing of the context menu event so
+    // that it doesn't bubble and get seen again by the popuplistener and show
+    // another context menu.
+    //
+    // Furthermore (there's always more, isn't there?), on some platforms (win32
+    // being one of them) we get the context menu event on a mouse up while
+    // on others we get it on a mouse down. For the ones where we get it on a
+    // mouse down, we must continue listening for the right button up event to
+    // dismiss the menu.
+    if (menuParent->IsContextMenu()) {
+      *aEventStatus = nsEventStatus_eConsumeNoDefault;
+      Execute(aEvent);
+    }
+  }
+  else if (aEvent->mMessage == eMouseUp &&
+           aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton &&
+           !IsMenu() && !IsDisabled()) {
+    // Execute the execute event handler.
+    *aEventStatus = nsEventStatus_eConsumeNoDefault;
+    Execute(aEvent);
+  }
+  else if (aEvent->mMessage == eMouseOut) {
+    // Kill our timer if one is active.
+    if (mOpenTimer) {
+      mOpenTimer->Cancel();
+      mOpenTimer = nullptr;
+    }
+
+    // Deactivate the menu.
+    if (menuParent) {
+      bool onmenubar = menuParent->IsMenuBar();
+      if (!(onmenubar && menuParent->IsActive())) {
+        if (IsMenu() && !onmenubar && IsOpen()) {
+          // Submenus don't get closed up immediately.
+        }
+        else if (this == menuParent->GetCurrentMenuItem()
+#ifdef XP_WIN
+                 && GetParentMenuListType() == eNotMenuList
+#endif
+        ) {
+          menuParent->ChangeMenuItem(nullptr, false, false);
+        }
+      }
+    }
+  }
+  else if (aEvent->mMessage == eMouseMove &&
+           (onmenu || (menuParent && menuParent->IsMenuBar()))) {
+    if (gMenuJustOpenedOrClosed) {
+      gMenuJustOpenedOrClosed = false;
+      return NS_OK;
+    }
+
+    if (IsDisabled() && GetParentMenuListType() != eNotMenuList) {
+      return NS_OK;
+    }
+
+    // Let the menu parent know we're the new item.
+    menuParent->ChangeMenuItem(this, false, false);
+    NS_ENSURE_TRUE(weakFrame.IsAlive(), NS_OK);
+    NS_ENSURE_TRUE(menuParent, NS_OK);
+
+    // we need to check if we really became the current menu
+    // item or not
+    nsMenuFrame *realCurrentItem = menuParent->GetCurrentMenuItem();
+    if (realCurrentItem != this) {
+      // we didn't (presumably because a context menu was active)
+      return NS_OK;
+    }
+
+    // Hovering over a menu in a popup should open it without a need for a click.
+    // A timer is used so that it doesn't open if the user moves the mouse quickly
+    // past the menu. This conditional check ensures that only menus have this
+    // behaviour
+    if (!IsDisabled() && IsMenu() && !IsOpen() && !mOpenTimer && !menuParent->IsMenuBar()) {
+      int32_t menuDelay =
+        LookAndFeel::GetInt(LookAndFeel::eIntID_SubmenuDelay, 300); // ms
+
+      // We're a menu, we're built, we're closed, and no timer has been kicked off.
+      mOpenTimer = do_CreateInstance("@mozilla.org/timer;1");
+      mOpenTimer->InitWithCallback(mTimerMediator, menuDelay, nsITimer::TYPE_ONE_SHOT);
+    }
+  }
+  
+  return NS_OK;
+}
+
+void
+nsMenuFrame::ToggleMenuState()
+{
+  if (IsOpen())
+    CloseMenu(false);
+  else
+    OpenMenu(false);
+}
+
+void
+nsMenuFrame::PopupOpened()
+{
+  nsWeakFrame weakFrame(this);
+  mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::open,
+                    NS_LITERAL_STRING("true"), true);
+  if (!weakFrame.IsAlive())
+    return;
+
+  nsMenuParent* menuParent = GetMenuParent();
+  if (menuParent) {
+    menuParent->SetActive(true);
+    // Make sure the current menu which is being toggled on
+    // the menubar is highlighted
+    menuParent->SetCurrentMenuItem(this);
+  }
+}
+
+void
+nsMenuFrame::PopupClosed(bool aDeselectMenu)
+{
+  nsWeakFrame weakFrame(this);
+  nsContentUtils::AddScriptRunner(
+    new nsUnsetAttrRunnable(mContent, nsGkAtoms::open));
+  if (!weakFrame.IsAlive())
+    return;
+
+  // if the popup is for a menu on a menubar, inform menubar to deactivate
+  nsMenuParent* menuParent = GetMenuParent();
+  if (menuParent && menuParent->MenuClosed()) {
+    if (aDeselectMenu) {
+      SelectMenu(false);
+    } else {
+      // We are not deselecting the parent menu while closing the popup, so send
+      // a DOMMenuItemActive event to the menu to indicate that the menu is
+      // becoming active again.
+      nsMenuFrame *current = menuParent->GetCurrentMenuItem();
+      if (current) {
+        // However, if the menu is a descendant on a menubar, and the menubar
+        // has the 'stay active' flag set, it means that the menubar is switching
+        // to another toplevel menu entirely (for example from Edit to View), so
+        // don't fire the DOMMenuItemActive event or else we'll send extraneous
+        // events for submenus. nsMenuBarFrame::ChangeMenuItem has already deselected
+        // the old menu, so it doesn't need to happen again here, and the new
+        // menu can be selected right away.
+        nsIFrame* parent = current;
+        while (parent) {
+          nsMenuBarFrame* menubar = do_QueryFrame(parent);
+          if (menubar && menubar->GetStayActive())
+            return;
+
+          parent = parent->GetParent();
+        }
+
+        nsCOMPtr<nsIRunnable> event =
+          new nsMenuActivateEvent(current->GetContent(),
+                                  PresContext(), true);
+        NS_DispatchToCurrentThread(event);
+      }
+    }
+  }
+}
+
+NS_IMETHODIMP
+nsMenuFrame::SelectMenu(bool aActivateFlag)
+{
+  if (mContent) {
+    // When a menu opens a submenu, the mouse will often be moved onto a
+    // sibling before moving onto an item within the submenu, causing the
+    // parent to become deselected. We need to ensure that the parent menu
+    // is reselected when an item in the submenu is selected, so navigate up
+    // from the item to its popup, and then to the popup above that.
+    if (aActivateFlag) {
+      nsIFrame* parent = GetParent();
+      while (parent) {
+        nsMenuPopupFrame* menupopup = do_QueryFrame(parent);
+        if (menupopup) {
+          // a menu is always the direct parent of a menupopup
+          nsMenuFrame* menu = do_QueryFrame(menupopup->GetParent());
+          if (menu) {
+            // a popup however is not necessarily the direct parent of a menu
+            nsIFrame* popupParent = menu->GetParent();
+            while (popupParent) {
+              menupopup = do_QueryFrame(popupParent);
+              if (menupopup) {
+                menupopup->SetCurrentMenuItem(menu);
+                break;
+              }
+              popupParent = popupParent->GetParent();
+            }
+          }
+          break;
+        }
+        parent = parent->GetParent();
+      }
+    }
+
+    // cancel the close timer if selecting a menu within the popup to be closed
+    nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+    if (pm) {
+      nsMenuParent* menuParent = GetMenuParent();
+      pm->CancelMenuTimer(menuParent);
+    }
+
+    nsCOMPtr<nsIRunnable> event =
+      new nsMenuActivateEvent(mContent, PresContext(), aActivateFlag);
+    NS_DispatchToCurrentThread(event);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsMenuFrame::AttributeChanged(int32_t aNameSpaceID,
+                              nsIAtom* aAttribute,
+                              int32_t aModType)
+{
+  if (aAttribute == nsGkAtoms::acceltext && mIgnoreAccelTextChange) {
+    // Reset the flag so that only one change is ignored.
+    mIgnoreAccelTextChange = false;
+    return NS_OK;
+  }
+
+  if (aAttribute == nsGkAtoms::checked ||
+      aAttribute == nsGkAtoms::acceltext ||
+      aAttribute == nsGkAtoms::key ||
+      aAttribute == nsGkAtoms::type ||
+      aAttribute == nsGkAtoms::name) {
+    nsCOMPtr<nsIRunnable> event =
+      new nsMenuAttributeChangedEvent(this, aAttribute);
+    nsContentUtils::AddScriptRunner(event);
+  }
+  return NS_OK;
+}
+
+nsIContent*
+nsMenuFrame::GetAnchor()
+{
+  mozilla::dom::Element* anchor = nullptr;
+
+  nsAutoString id;
+  mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::anchor, id);
+  if (!id.IsEmpty()) {
+    nsIDocument* doc = mContent->OwnerDoc();
+
+    anchor =
+      doc->GetAnonymousElementByAttribute(mContent, nsGkAtoms::anonid, id);
+    if (!anchor) {
+      anchor = doc->GetElementById(id);
+    }
+  }
+
+  // Always return the menu's content if the anchor wasn't set or wasn't found.
+  return anchor && anchor->GetPrimaryFrame() ? anchor : mContent;
+}
+
+void
+nsMenuFrame::OpenMenu(bool aSelectFirstItem)
+{
+  if (!mContent)
+    return;
+
+  gMenuJustOpenedOrClosed = true;
+
+  nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+  if (pm) {
+    pm->KillMenuTimer();
+    // This opens the menu asynchronously
+    pm->ShowMenu(mContent, aSelectFirstItem, true);
+  }
+}
+
+void
+nsMenuFrame::CloseMenu(bool aDeselectMenu)
+{
+  gMenuJustOpenedOrClosed = true;
+
+  // Close the menu asynchronously
+  nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+  if (pm && HasPopup())
+    pm->HidePopup(GetPopup()->GetContent(), false, aDeselectMenu, true, false);
+}
+
+bool
+nsMenuFrame::IsSizedToPopup(nsIContent* aContent, bool aRequireAlways)
+{
+  nsAutoString sizedToPopup;
+  aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::sizetopopup, sizedToPopup);
+  return sizedToPopup.EqualsLiteral("always") ||
+         (!aRequireAlways && sizedToPopup.EqualsLiteral("pref"));
+}
+
+nsSize
+nsMenuFrame::GetXULMinSize(nsBoxLayoutState& aBoxLayoutState)
+{
+  nsSize size = nsBoxFrame::GetXULMinSize(aBoxLayoutState);
+  DISPLAY_MIN_SIZE(this, size);
+
+  if (IsSizedToPopup(mContent, true))
+    SizeToPopup(aBoxLayoutState, size);
+
+  return size;
+}
+
+NS_IMETHODIMP
+nsMenuFrame::DoXULLayout(nsBoxLayoutState& aState)
+{
+  // lay us out
+  nsresult rv = nsBoxFrame::DoXULLayout(aState);
+
+  nsMenuPopupFrame* popupFrame = GetPopup();
+  if (popupFrame) {
+    bool sizeToPopup = IsSizedToPopup(mContent, false);
+    popupFrame->LayoutPopup(aState, this, GetAnchor()->GetPrimaryFrame(), sizeToPopup);
+  }
+
+  return rv;
+}
+
+#ifdef DEBUG_LAYOUT
+nsresult
+nsMenuFrame::SetXULDebug(nsBoxLayoutState& aState, bool aDebug)
+{
+  // see if our state matches the given debug state
+  bool debugSet = mState & NS_STATE_CURRENTLY_IN_DEBUG;
+  bool debugChanged = (!aDebug && debugSet) || (aDebug && !debugSet);
+
+  // if it doesn't then tell each child below us the new debug state
+  if (debugChanged)
+  {
+      nsBoxFrame::SetXULDebug(aState, aDebug);
+      nsMenuPopupFrame* popupFrame = GetPopup();
+      if (popupFrame)
+        SetXULDebug(aState, popupFrame, aDebug);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsMenuFrame::SetXULDebug(nsBoxLayoutState& aState, nsIFrame* aList, bool aDebug)
+{
+      if (!aList)
+          return NS_OK;
+
+      while (aList) {
+        if (aList->IsXULBoxFrame())
+          aList->SetXULDebug(aState, aDebug);
+
+        aList = aList->GetNextSibling();
+      }
+
+      return NS_OK;
+}
+#endif
+
+//
+// Enter
+//
+// Called when the user hits the <Enter>/<Return> keys or presses the
+// shortcut key. If this is a leaf item, the item's action will be executed.
+// In either case, do nothing if the item is disabled.
+//
+nsMenuFrame*
+nsMenuFrame::Enter(WidgetGUIEvent* aEvent)
+{
+  if (IsDisabled()) {
+#ifdef XP_WIN
+    // behavior on Windows - close the popup chain
+    nsMenuParent* menuParent = GetMenuParent();
+    if (menuParent) {
+      nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+      if (pm) {
+        nsIFrame* popup = pm->GetTopPopup(ePopupTypeAny);
+        if (popup)
+          pm->HidePopup(popup->GetContent(), true, true, true, false);
+      }
+    }
+#endif   // #ifdef XP_WIN
+    // this menu item was disabled - exit
+    return nullptr;
+  }
+
+  if (!IsOpen()) {
+    // The enter key press applies to us.
+    nsMenuParent* menuParent = GetMenuParent();
+    if (!IsMenu() && menuParent)
+      Execute(aEvent);          // Execute our event handler
+    else
+      return this;
+  }
+
+  return nullptr;
+}
+
+bool
+nsMenuFrame::IsOpen()
+{
+  nsMenuPopupFrame* popupFrame = GetPopup();
+  return popupFrame && popupFrame->IsOpen();
+}
+
+bool
+nsMenuFrame::IsMenu()
+{
+  return mIsMenu;
+}
+
+nsMenuListType
+nsMenuFrame::GetParentMenuListType()
+{
+  nsMenuParent* menuParent = GetMenuParent();
+  if (menuParent && menuParent->IsMenu()) {
+    nsMenuPopupFrame* popupFrame = static_cast<nsMenuPopupFrame*>(menuParent);
+    nsIFrame* parentMenu = popupFrame->GetParent();
+    if (parentMenu) {
+      nsCOMPtr<nsIDOMXULMenuListElement> menulist = do_QueryInterface(parentMenu->GetContent());
+      if (menulist) {
+        bool isEditable = false;
+        menulist->GetEditable(&isEditable);
+        return isEditable ? eEditableMenuList : eReadonlyMenuList;
+      }
+    }
+  }
+  return eNotMenuList;
+}
+
+nsresult
+nsMenuFrame::Notify(nsITimer* aTimer)
+{
+  // Our timer has fired.
+  if (aTimer == mOpenTimer.get()) {
+    mOpenTimer = nullptr;
+
+    nsMenuParent* menuParent = GetMenuParent();
+    if (!IsOpen() && menuParent) {
+      // make sure we didn't open a context menu in the meantime
+      // (i.e. the user right-clicked while hovering over a submenu).
+      nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+      if (pm) {
+        if ((!pm->HasContextMenu(nullptr) || menuParent->IsContextMenu()) &&
+            mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::menuactive,
+                                  nsGkAtoms::_true, eCaseMatters)) {
+          OpenMenu(false);
+        }
+      }
+    }
+  } else if (aTimer == mBlinkTimer) {
+    switch (mBlinkState++) {
+      case 0:
+        NS_ASSERTION(false, "Blink timer fired while not blinking");
+        StopBlinking();
+        break;
+      case 1:
+        {
+          // Turn the highlight back on and wait for a while before closing the menu.
+          nsWeakFrame weakFrame(this);
+          mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::menuactive,
+                            NS_LITERAL_STRING("true"), true);
+          if (weakFrame.IsAlive()) {
+            aTimer->InitWithCallback(mTimerMediator, kBlinkDelay, nsITimer::TYPE_ONE_SHOT);
+          }
+        }
+        break;
+      default: {
+        nsMenuParent* menuParent = GetMenuParent();
+        if (menuParent) {
+          menuParent->LockMenuUntilClosed(false);
+        }
+        PassMenuCommandEventToPopupManager();
+        StopBlinking();
+        break;
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+bool 
+nsMenuFrame::IsDisabled()
+{
+  return mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
+                               nsGkAtoms::_true, eCaseMatters);
+}
+
+void
+nsMenuFrame::UpdateMenuType()
+{
+  static nsIContent::AttrValuesArray strings[] =
+    {&nsGkAtoms::checkbox, &nsGkAtoms::radio, nullptr};
+  switch (mContent->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::type,
+                                    strings, eCaseMatters)) {
+    case 0: mType = eMenuType_Checkbox; break;
+    case 1:
+      mType = eMenuType_Radio;
+      mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::name, mGroupName);
+      break;
+
+    default:
+      if (mType != eMenuType_Normal) {
+        nsWeakFrame weakFrame(this);
+        mContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::checked,
+                            true);
+        ENSURE_TRUE(weakFrame.IsAlive());
+      }
+      mType = eMenuType_Normal;
+      break;
+  }
+  UpdateMenuSpecialState();
+}
+
+/* update checked-ness for type="checkbox" and type="radio" */
+void
+nsMenuFrame::UpdateMenuSpecialState()
+{
+  bool newChecked =
+    mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::checked,
+                          nsGkAtoms::_true, eCaseMatters); 
+  if (newChecked == mChecked) {
+    /* checked state didn't change */
+
+    if (mType != eMenuType_Radio)
+      return; // only Radio possibly cares about other kinds of change
+
+    if (!mChecked || mGroupName.IsEmpty())
+      return;                   // no interesting change
+  } else { 
+    mChecked = newChecked;
+    if (mType != eMenuType_Radio || !mChecked)
+      /*
+       * Unchecking something requires no further changes, and only
+       * menuRadio has to do additional work when checked.
+       */
+      return;
+  }
+
+  /*
+   * If we get this far, we're type=radio, and:
+   * - our name= changed, or
+   * - we went from checked="false" to checked="true"
+   */
+
+  /*
+   * Behavioural note:
+   * If we're checked and renamed _into_ an existing radio group, we are
+   * made the new checked item, and we unselect the previous one.
+   *
+   * The only other reasonable behaviour would be to check for another selected
+   * item in that group.  If found, unselect ourselves, otherwise we're the
+   * selected item.  That, however, would be a lot more work, and I don't think
+   * it's better at all.
+   */
+
+  /* walk siblings, looking for the other checked item with the same name */
+  // get the first sibling in this menu popup. This frame may be it, and if we're
+  // being called at creation time, this frame isn't yet in the parent's child list.
+  // All I'm saying is that this may fail, but it's most likely alright.
+  nsIFrame* firstMenuItem = nsXULPopupManager::GetNextMenuItem(GetParent(), nullptr, true);
+  nsIFrame* sib = firstMenuItem;
+  while (sib) {
+    nsMenuFrame* menu = do_QueryFrame(sib);
+    if (sib != this) {
+      if (menu && menu->GetMenuType() == eMenuType_Radio &&
+          menu->IsChecked() && menu->GetRadioGroupName() == mGroupName) {
+        /* uncheck the old item */
+        sib->GetContent()->UnsetAttr(kNameSpaceID_None, nsGkAtoms::checked,
+                                     true);
+        /* XXX in DEBUG, check to make sure that there aren't two checked items */
+        return;
+      }
+    }
+    sib = nsXULPopupManager::GetNextMenuItem(GetParent(), menu, true);
+    if (sib == firstMenuItem) {
+      break;
+    }
+  } 
+}
+
+void 
+nsMenuFrame::BuildAcceleratorText(bool aNotify)
+{
+  nsAutoString accelText;
+
+  if ((GetStateBits() & NS_STATE_ACCELTEXT_IS_DERIVED) == 0) {
+    mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::acceltext, accelText);
+    if (!accelText.IsEmpty())
+      return;
+  }
+  // accelText is definitely empty here.
+
+  // Now we're going to compute the accelerator text, so remember that we did.
+  AddStateBits(NS_STATE_ACCELTEXT_IS_DERIVED);
+
+  // If anything below fails, just leave the accelerator text blank.
+  nsWeakFrame weakFrame(this);
+  mContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::acceltext, aNotify);
+  ENSURE_TRUE(weakFrame.IsAlive());
+
+  // See if we have a key node and use that instead.
+  nsAutoString keyValue;
+  mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::key, keyValue);
+  if (keyValue.IsEmpty())
+    return;
+
+  // Turn the document into a DOM document so we can use getElementById
+  nsIDocument *document = mContent->GetUncomposedDoc();
+  if (!document)
+    return;
+
+  //XXXsmaug If mContent is in shadow dom, should we use
+  //         ShadowRoot::GetElementById()?
+  nsIContent *keyElement = document->GetElementById(keyValue);
+  if (!keyElement) {
+#ifdef DEBUG
+    nsAutoString label;
+    mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::label, label);
+    nsAutoString msg = NS_LITERAL_STRING("Key '") +
+                       keyValue +
+                       NS_LITERAL_STRING("' of menu item '") +
+                       label +
+                       NS_LITERAL_STRING("' could not be found");
+    NS_WARNING(NS_ConvertUTF16toUTF8(msg).get());
+#endif
+    return;
+  }
+
+  // get the string to display as accelerator text
+  // check the key element's attributes in this order:
+  // |keytext|, |key|, |keycode|
+  nsAutoString accelString;
+  keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::keytext, accelString);
+
+  if (accelString.IsEmpty()) {
+    keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::key, accelString);
+
+    if (!accelString.IsEmpty()) {
+      ToUpperCase(accelString);
+    } else {
+      nsAutoString keyCode;
+      keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::keycode, keyCode);
+      ToUpperCase(keyCode);
+
+      nsresult rv;
+      nsCOMPtr<nsIStringBundleService> bundleService =
+        mozilla::services::GetStringBundleService();
+      if (bundleService) {
+        nsCOMPtr<nsIStringBundle> bundle;
+        rv = bundleService->CreateBundle("chrome://global/locale/keys.properties",
+                                         getter_AddRefs(bundle));
+
+        if (NS_SUCCEEDED(rv) && bundle) {
+          nsXPIDLString keyName;
+          rv = bundle->GetStringFromName(keyCode.get(), getter_Copies(keyName));
+          if (keyName)
+            accelString = keyName;
+        }
+      }
+
+      // nothing usable found, bail
+      if (accelString.IsEmpty())
+        return;
+    }
+  }
+
+  nsAutoString modifiers;
+  keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::modifiers, modifiers);
+  
+  char* str = ToNewCString(modifiers);
+  char* newStr;
+  char* token = nsCRT::strtok(str, ", \t", &newStr);
+
+  nsAutoString shiftText;
+  nsAutoString altText;
+  nsAutoString metaText;
+  nsAutoString controlText;
+  nsAutoString osText;
+  nsAutoString modifierSeparator;
+
+  nsContentUtils::GetShiftText(shiftText);
+  nsContentUtils::GetAltText(altText);
+  nsContentUtils::GetMetaText(metaText);
+  nsContentUtils::GetControlText(controlText);
+  nsContentUtils::GetOSText(osText);
+  nsContentUtils::GetModifierSeparatorText(modifierSeparator);
+
+  while (token) {
+      
+    if (PL_strcmp(token, "shift") == 0)
+      accelText += shiftText;
+    else if (PL_strcmp(token, "alt") == 0) 
+      accelText += altText; 
+    else if (PL_strcmp(token, "meta") == 0) 
+      accelText += metaText; 
+    else if (PL_strcmp(token, "os") == 0)
+      accelText += osText; 
+    else if (PL_strcmp(token, "control") == 0) 
+      accelText += controlText; 
+    else if (PL_strcmp(token, "accel") == 0) {
+      switch (WidgetInputEvent::AccelModifier()) {
+        case MODIFIER_META:
+          accelText += metaText;
+          break;
+        case MODIFIER_OS:
+          accelText += osText;
+          break;
+        case MODIFIER_ALT:
+          accelText += altText;
+          break;
+        case MODIFIER_CONTROL:
+          accelText += controlText;
+          break;
+        default:
+          MOZ_CRASH(
+            "Handle the new result of WidgetInputEvent::AccelModifier()");
+          break;
+      }
+    }
+    
+    accelText += modifierSeparator;
+
+    token = nsCRT::strtok(newStr, ", \t", &newStr);
+  }
+
+  free(str);
+
+  accelText += accelString;
+
+  mIgnoreAccelTextChange = true;
+  mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::acceltext, accelText, aNotify);
+  ENSURE_TRUE(weakFrame.IsAlive());
+
+  mIgnoreAccelTextChange = false;
+}
+
+void
+nsMenuFrame::Execute(WidgetGUIEvent* aEvent)
+{
+  // flip "checked" state if we're a checkbox menu, or an un-checked radio menu
+  bool needToFlipChecked = false;
+  if (mType == eMenuType_Checkbox || (mType == eMenuType_Radio && !mChecked)) {
+    needToFlipChecked = !mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::autocheck,
+                                               nsGkAtoms::_false, eCaseMatters);
+  }
+
+  nsCOMPtr<nsISound> sound(do_CreateInstance("@mozilla.org/sound;1"));
+  if (sound)
+    sound->PlayEventSound(nsISound::EVENT_MENU_EXECUTE);
+
+  StartBlinking(aEvent, needToFlipChecked);
+}
+
+bool
+nsMenuFrame::ShouldBlink()
+{
+  int32_t shouldBlink =
+    LookAndFeel::GetInt(LookAndFeel::eIntID_ChosenMenuItemsShouldBlink, 0);
+  if (!shouldBlink)
+    return false;
+
+  // Don't blink in editable menulists.
+  if (GetParentMenuListType() == eEditableMenuList)
+    return false;
+
+  return true;
+}
+
+void
+nsMenuFrame::StartBlinking(WidgetGUIEvent* aEvent, bool aFlipChecked)
+{
+  StopBlinking();
+  CreateMenuCommandEvent(aEvent, aFlipChecked);
+
+  if (!ShouldBlink()) {
+    PassMenuCommandEventToPopupManager();
+    return;
+  }
+
+  // Blink off.
+  nsWeakFrame weakFrame(this);
+  mContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::menuactive, true);
+  if (!weakFrame.IsAlive())
+    return;
+
+  nsMenuParent* menuParent = GetMenuParent();
+  if (menuParent) {
+    // Make this menu ignore events from now on.
+    menuParent->LockMenuUntilClosed(true);
+  }
+
+  // Set up a timer to blink back on.
+  mBlinkTimer = do_CreateInstance("@mozilla.org/timer;1");
+  mBlinkTimer->InitWithCallback(mTimerMediator, kBlinkDelay, nsITimer::TYPE_ONE_SHOT);
+  mBlinkState = 1;
+}
+
+void
+nsMenuFrame::StopBlinking()
+{
+  mBlinkState = 0;
+  if (mBlinkTimer) {
+    mBlinkTimer->Cancel();
+    mBlinkTimer = nullptr;
+  }
+  mDelayedMenuCommandEvent = nullptr;
+}
+
+void
+nsMenuFrame::CreateMenuCommandEvent(WidgetGUIEvent* aEvent, bool aFlipChecked)
+{
+  // Create a trusted event if the triggering event was trusted, or if
+  // we're called from chrome code (since at least one of our caller
+  // passes in a null event).
+  bool isTrusted = aEvent ? aEvent->IsTrusted() :
+                              nsContentUtils::IsCallerChrome();
+
+  bool shift = false, control = false, alt = false, meta = false;
+  WidgetInputEvent* inputEvent = aEvent ? aEvent->AsInputEvent() : nullptr;
+  if (inputEvent) {
+    shift = inputEvent->IsShift();
+    control = inputEvent->IsControl();
+    alt = inputEvent->IsAlt();
+    meta = inputEvent->IsMeta();
+  }
+
+  // Because the command event is firing asynchronously, a flag is needed to
+  // indicate whether user input is being handled. This ensures that a popup
+  // window won't get blocked.
+  bool userinput = EventStateManager::IsHandlingUserInput();
+
+  mDelayedMenuCommandEvent =
+    new nsXULMenuCommandEvent(mContent, isTrusted, shift, control, alt, meta,
+                              userinput, aFlipChecked);
+}
+
+void
+nsMenuFrame::PassMenuCommandEventToPopupManager()
+{
+  nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+  nsMenuParent* menuParent = GetMenuParent();
+  if (pm && menuParent && mDelayedMenuCommandEvent) {
+    pm->ExecuteMenu(mContent, mDelayedMenuCommandEvent);
+  }
+  mDelayedMenuCommandEvent = nullptr;
+}
+
+void
+nsMenuFrame::RemoveFrame(ChildListID     aListID,
+                         nsIFrame*       aOldFrame)
+{
+  nsFrameList* popupList = GetPopupList();
+  if (popupList && popupList->FirstChild() == aOldFrame) {
+    popupList->RemoveFirstChild();
+    aOldFrame->Destroy();
+    DestroyPopupList();
+    PresContext()->PresShell()->
+      FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+                       NS_FRAME_HAS_DIRTY_CHILDREN);
+    return;
+  }
+  nsBoxFrame::RemoveFrame(aListID, aOldFrame);
+}
+
+void
+nsMenuFrame::InsertFrames(ChildListID     aListID,
+                          nsIFrame*       aPrevFrame,
+                          nsFrameList&    aFrameList)
+{
+  if (!HasPopup() && (aListID == kPrincipalList || aListID == kPopupList)) {
+    SetPopupFrame(aFrameList);
+    if (HasPopup()) {
+#ifdef DEBUG_LAYOUT
+      nsBoxLayoutState state(PresContext());
+      SetXULDebug(state, aFrameList, mState & NS_STATE_CURRENTLY_IN_DEBUG);
+#endif
+
+      PresContext()->PresShell()->
+        FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+                         NS_FRAME_HAS_DIRTY_CHILDREN);
+    }
+  }
+
+  if (aFrameList.IsEmpty())
+    return;
+
+  if (MOZ_UNLIKELY(aPrevFrame && aPrevFrame == GetPopup())) {
+    aPrevFrame = nullptr;
+  }
+
+  nsBoxFrame::InsertFrames(aListID, aPrevFrame, aFrameList);
+}
+
+void
+nsMenuFrame::AppendFrames(ChildListID     aListID,
+                          nsFrameList&    aFrameList)
+{
+  if (!HasPopup() && (aListID == kPrincipalList || aListID == kPopupList)) {
+    SetPopupFrame(aFrameList);
+    if (HasPopup()) {
+
+#ifdef DEBUG_LAYOUT
+      nsBoxLayoutState state(PresContext());
+      SetXULDebug(state, aFrameList, mState & NS_STATE_CURRENTLY_IN_DEBUG);
+#endif
+      PresContext()->PresShell()->
+        FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+                         NS_FRAME_HAS_DIRTY_CHILDREN);
+    }
+  }
+
+  if (aFrameList.IsEmpty())
+    return;
+
+  nsBoxFrame::AppendFrames(aListID, aFrameList); 
+}
+
+bool
+nsMenuFrame::SizeToPopup(nsBoxLayoutState& aState, nsSize& aSize)
+{
+  if (!IsXULCollapsed()) {
+    bool widthSet, heightSet;
+    nsSize tmpSize(-1, 0);
+    nsIFrame::AddXULPrefSize(this, tmpSize, widthSet, heightSet);
+    if (!widthSet && GetXULFlex() == 0) {
+      nsMenuPopupFrame* popupFrame = GetPopup();
+      if (!popupFrame)
+        return false;
+      tmpSize = popupFrame->GetXULPrefSize(aState);
+
+      // Produce a size such that:
+      //  (1) the menu and its popup can be the same width
+      //  (2) there's enough room in the menu for the content and its
+      //      border-padding
+      //  (3) there's enough room in the popup for the content and its
+      //      scrollbar
+      nsMargin borderPadding;
+      GetXULBorderAndPadding(borderPadding);
+
+      // if there is a scroll frame, add the desired width of the scrollbar as well
+      nsIScrollableFrame* scrollFrame = do_QueryFrame(popupFrame->PrincipalChildList().FirstChild());
+      nscoord scrollbarWidth = 0;
+      if (scrollFrame) {
+        scrollbarWidth =
+          scrollFrame->GetDesiredScrollbarSizes(&aState).LeftRight();
+      }
+
+      aSize.width =
+        tmpSize.width + std::max(borderPadding.LeftRight(), scrollbarWidth);
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
+nsSize
+nsMenuFrame::GetXULPrefSize(nsBoxLayoutState& aState)
+{
+  nsSize size = nsBoxFrame::GetXULPrefSize(aState);
+  DISPLAY_PREF_SIZE(this, size);
+
+  // If we are using sizetopopup="always" then
+  // nsBoxFrame will already have enforced the minimum size
+  if (!IsSizedToPopup(mContent, true) &&
+      IsSizedToPopup(mContent, false) &&
+      SizeToPopup(aState, size)) {
+    // We now need to ensure that size is within the min - max range.
+    nsSize minSize = nsBoxFrame::GetXULMinSize(aState);
+    nsSize maxSize = GetXULMaxSize(aState);
+    size = BoundsCheck(minSize, size, maxSize);
+  }
+
+  return size;
+}
+
+NS_IMETHODIMP
+nsMenuFrame::GetActiveChild(nsIDOMElement** aResult)
+{
+  nsMenuPopupFrame* popupFrame = GetPopup();
+  if (!popupFrame)
+    return NS_ERROR_FAILURE;
+
+  nsMenuFrame* menuFrame = popupFrame->GetCurrentMenuItem();
+  if (!menuFrame) {
+    *aResult = nullptr;
+  }
+  else {
+    nsCOMPtr<nsIDOMElement> elt(do_QueryInterface(menuFrame->GetContent()));
+    *aResult = elt;
+    NS_IF_ADDREF(*aResult);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMenuFrame::SetActiveChild(nsIDOMElement* aChild)
+{
+  nsMenuPopupFrame* popupFrame = GetPopup();
+  if (!popupFrame)
+    return NS_ERROR_FAILURE;
+
+  if (!aChild) {
+    // Remove the current selection
+    popupFrame->ChangeMenuItem(nullptr, false, false);
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIContent> child(do_QueryInterface(aChild));
+
+  nsMenuFrame* menu = do_QueryFrame(child->GetPrimaryFrame());
+  if (menu)
+    popupFrame->ChangeMenuItem(menu, false, false);
+  return NS_OK;
+}
+
+nsIScrollableFrame* nsMenuFrame::GetScrollTargetFrame()
+{
+  nsMenuPopupFrame* popupFrame = GetPopup();
+  if (!popupFrame)
+    return nullptr;
+  nsIFrame* childFrame = popupFrame->PrincipalChildList().FirstChild();
+  if (childFrame)
+    return popupFrame->GetScrollFrame(childFrame);
+  return nullptr;
+}
+
+// nsMenuTimerMediator implementation.
+NS_IMPL_ISUPPORTS(nsMenuTimerMediator, nsITimerCallback)
+
+/**
+ * Constructs a wrapper around an nsMenuFrame.
+ * @param aFrame nsMenuFrame to create a wrapper around.
+ */
+nsMenuTimerMediator::nsMenuTimerMediator(nsMenuFrame *aFrame) :
+  mFrame(aFrame)
+{
+  NS_ASSERTION(mFrame, "Must have frame");
+}
+
+nsMenuTimerMediator::~nsMenuTimerMediator()
+{
+}
+
+/**
+ * Delegates the notification to the contained frame if it has not been destroyed.
+ * @param aTimer Timer which initiated the callback.
+ * @return NS_ERROR_FAILURE if the frame has been destroyed.
+ */
+NS_IMETHODIMP nsMenuTimerMediator::Notify(nsITimer* aTimer)
+{
+  if (!mFrame)
+    return NS_ERROR_FAILURE;
+
+  return mFrame->Notify(aTimer);
+}
+
+/**
+ * Clear the pointer to the contained nsMenuFrame. This should be called
+ * when the contained nsMenuFrame is destroyed.
+ */
+void nsMenuTimerMediator::ClearFrame()
+{
+  mFrame = nullptr;
+}