60.1.1-1

7 files changed, 5784 insertions, 73 deletions

diff --git a/.SRCINFO b/.SRCINFO
index e05d935daa74..4b67f0b2e882 100644
--- a/.SRCINFO
+++ b/.SRCINFO
@@ -1,8 +1,8 @@
 pkgbase = firefox-appmenu
 	pkgdesc = Firefox from extra with appmenu patch
-	pkgver = 60.0.2
+	pkgver = 61.0.1
 	pkgrel = 1
-	url = https://www.mozilla.org/firefox/
+	url = https://aur.archlinux.org/packages/firefox-appmenu/
 	arch = x86_64
 	license = MPL
 	license = GPL
@@ -24,6 +24,7 @@ pkgbase = firefox-appmenu
 	makedepends = llvm
 	makedepends = jack
 	makedepends = gtk2
+	makedepends = python
 	depends = gtk3
 	depends = mozilla-common
 	depends = libxt
@@ -32,7 +33,7 @@ pkgbase = firefox-appmenu
 	depends = dbus-glib
 	depends = ffmpeg
 	depends = nss
-	depends = hunspell
+	depends = hunspell-en_US
 	depends = sqlite
 	depends = ttf-font
 	depends = libpulse
@@ -42,25 +43,19 @@ pkgbase = firefox-appmenu
 	optdepends = libnotify: Notification integration
 	optdepends = pulseaudio: Audio support
 	optdepends = speech-dispatcher: Text-to-Speech
-	provides = firefox=60.0.2
+	provides = firefox=61.0.1
 	conflicts = firefox
 	options = !emptydirs
 	options = !makeflags
 	options = !strip
-	source = hg+https://hg.mozilla.org/mozilla-unified#tag=FIREFOX_60_0_2_RELEASE
-	source = unity-menubar.patch.tar.xz
-	source = complete-csd-window-offset-mozilla-1457691.patch.xz
-	source = 0001-Bug-1435212-Add-support-for-FFmpeg-4.0.-r-bryce.patch.xz
+	source = hg+https://hg.mozilla.org/mozilla-unified#tag=FIREFOX_61_0_1_RELEASE
 	source = firefox.desktop
 	source = firefox-symbolic.svg
-	source = no-crmf.diff
+	source = unity-menubar.patch
 	sha256sums = SKIP
-	sha256sums = 3fd0f41b3ec5fe524a2b24089e1493a9a41167702a6208d1571c1cf28d23df72
-	sha256sums = a3fb3c3b6fb775c99afdbad507848b77c5e4bbaac2e8ceeb1bfb47699c4b6268
-	sha256sums = 8422030440032535d918844263fbd92d39bff207acb5fff55ed0afee38bcf582
 	sha256sums = 2adca824b52ab5bc6e7e4fa486c1ecb47d283832bd4b75d10494b033f1cab911
 	sha256sums = 9a1a572dc88014882d54ba2d3079a1cf5b28fa03c5976ed2cb763c93dabbd797
-	sha256sums = 02000d185e647aa20ca336e595b4004bb29cdae9d8f317f90078bdcc7a36e873
+	sha256sums = 4465aa66734452597d4d797847de0c34c15bc08f21e9e8b6bf9f6ff270908f6f
 
 pkgname = firefox-appmenu
 
diff --git a/0001-Bug-1435212-Add-support-for-FFmpeg-4.0.-r-bryce.patch.xz b/0001-Bug-1435212-Add-support-for-FFmpeg-4.0.-r-bryce.patch.xz
deleted file mode 100644
index 721851592ca1..000000000000
--- a/0001-Bug-1435212-Add-support-for-FFmpeg-4.0.-r-bryce.patch.xz
+++ /dev/null
diff --git a/PKGBUILD b/PKGBUILD
index f20371b71e2e..a04920254bb7 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -6,37 +6,31 @@
 
 _pkgname=firefox
 pkgname=firefox-appmenu
-pkgver=60.0.2
+pkgver=61.0.1
 pkgrel=1
 pkgdesc="Firefox from extra with appmenu patch"
 arch=(x86_64)
 license=(MPL GPL LGPL)
-url="https://www.mozilla.org/firefox/"
+url="https://aur.archlinux.org/packages/firefox-appmenu/"
 depends=(gtk3 mozilla-common libxt startup-notification mime-types dbus-glib ffmpeg
-         nss hunspell sqlite ttf-font libpulse libvpx icu)
+         nss hunspell-en_US sqlite ttf-font libpulse libvpx icu)
 makedepends=(unzip zip diffutils python2 yasm mesa imake gconf inetutils xorg-server-xvfb
-             autoconf2.13 rust mercurial clang llvm jack gtk2)
+             autoconf2.13 rust mercurial clang llvm jack gtk2 python)
 optdepends=('networkmanager: Location detection via available WiFi networks'
             'libnotify: Notification integration'
             'pulseaudio: Audio support'
             'speech-dispatcher: Text-to-Speech')
 provides=("firefox=$pkgver")          
-conflicts=("firefox")                     
+conflicts=("firefox")
 options=(!emptydirs !makeflags !strip)
 _repo=https://hg.mozilla.org/mozilla-unified
 source=("hg+$_repo#tag=FIREFOX_${pkgver//./_}_RELEASE"
-        unity-menubar.patch.tar.xz 
-        complete-csd-window-offset-mozilla-1457691.patch.xz
-        0001-Bug-1435212-Add-support-for-FFmpeg-4.0.-r-bryce.patch.xz
         $_pkgname.desktop firefox-symbolic.svg
-        no-crmf.diff)
+        unity-menubar.patch)
 sha256sums=('SKIP'
-            '3fd0f41b3ec5fe524a2b24089e1493a9a41167702a6208d1571c1cf28d23df72'
-            'a3fb3c3b6fb775c99afdbad507848b77c5e4bbaac2e8ceeb1bfb47699c4b6268'
-            '8422030440032535d918844263fbd92d39bff207acb5fff55ed0afee38bcf582'
             '2adca824b52ab5bc6e7e4fa486c1ecb47d283832bd4b75d10494b033f1cab911'
             '9a1a572dc88014882d54ba2d3079a1cf5b28fa03c5976ed2cb763c93dabbd797'
-            '02000d185e647aa20ca336e595b4004bb29cdae9d8f317f90078bdcc7a36e873')
+            '4465aa66734452597d4d797847de0c34c15bc08f21e9e8b6bf9f6ff270908f6f')
 
 # Google API keys (see http://www.chromium.org/developers/how-tos/api-keys)
 # Note: These are for Arch Linux use ONLY. For your own distribution, please
@@ -51,23 +45,11 @@ _google_api_key=AIzaSyDwr302FpOSkGRpLlUpPThNTDPbXcIn_FM
 _mozilla_api_key=16674381-f021-49de-8622-3021c5942aff
 
 prepare() {
-  mkdir path
-  ln -s /usr/bin/python2 path/python
-
   cd mozilla-unified
-
+  
   # actual appmenu patch from ubuntu repos
   patch -Np1 -i ../unity-menubar.patch
 
-  # https://bugzilla.mozilla.org/show_bug.cgi?id=1283299#c158
-  patch -Np1 -i ../complete-csd-window-offset-mozilla-1457691.patch
-
-  # https://bugzilla.mozilla.org/show_bug.cgi?id=1435212
-  patch -Np1 -i ../0001-Bug-1435212-Add-support-for-FFmpeg-4.0.-r-bryce.patch
-
-  # https://bugzilla.mozilla.org/show_bug.cgi?id=1371991
-  patch -Np1 -i ../no-crmf.diff
-
   echo -n "$_google_api_key" >google-api-key
   echo -n "$_mozilla_api_key" >mozilla-api-key
 
@@ -76,9 +58,9 @@ ac_add_options --enable-application=browser
 
 ac_add_options --prefix=/usr
 ac_add_options --enable-release
-ac_add_options --enable-gold
-ac_add_options --enable-pie
-ac_add_options --enable-optimize="-O2"
+ac_add_options --enable-linker=gold
+ac_add_options --enable-hardening
+ac_add_options --enable-optimize
 ac_add_options --enable-rust-simd
 
 # Branding
@@ -102,7 +84,6 @@ ac_add_options --with-system-jpeg
 ac_add_options --with-system-libvpx
 ac_add_options --with-system-nspr
 ac_add_options --with-system-nss
-ac_add_options --enable-system-hunspell
 ac_add_options --enable-system-sqlite
 ac_add_options --enable-system-ffi
 
@@ -118,15 +99,8 @@ END
 build() {
   cd mozilla-unified
 
-  # _FORTIFY_SOURCE causes configure failures
-  CPPFLAGS+=" -O2"
-
-  export PATH="$srcdir/path:$PATH"
   export MOZ_SOURCE_REPO="$_repo"
 
-  # Do PGO
-  #xvfb-run -a -n 95 -s "-extension GLX -screen 0 1280x1024x24" \
-  #  MOZ_PGO=1 ./mach build
   ./mach build
   ./mach buildsymbols
 }
@@ -141,15 +115,15 @@ package() {
 // Use LANG environment variable to choose locale
 pref("intl.locale.requested", "");
 
+// Use system-provided dictionaries
+pref("spellchecker.dictionary_path", "/usr/share/hunspell");
+
 // Disable default browser checking.
 pref("browser.shell.checkDefaultBrowser", false);
 
 // Don't disable our bundled extensions in the application directory
 pref("extensions.autoDisableScopes", 11);
 pref("extensions.shownSelectionUI", true);
-
-// Opt all of us into e10s, instead of just 50%
-pref("browser.tabs.remote.autostart", true);
 END
 
   _distini="$pkgdir/usr/lib/$_pkgname/distribution/distribution.ini"
@@ -179,11 +153,6 @@ END
   install -Dm644 ../$_pkgname.desktop \
     "$pkgdir/usr/share/applications/$_pkgname.desktop"
 
-  # Use system-provided dictionaries
-  rm -r "$pkgdir/usr/lib/$_pkgname/dictionaries"
-  ln -Ts /usr/share/hunspell "$pkgdir/usr/lib/$_pkgname/dictionaries"
-  ln -Ts /usr/share/hyphen "$pkgdir/usr/lib/$_pkgname/hyphenation"
-
   # Install a wrapper to avoid confusion about binary path
   install -Dm755 /dev/stdin "$pkgdir/usr/bin/$_pkgname" <<END
 #!/bin/sh
diff --git a/complete-csd-window-offset-mozilla-1457691.patch.xz b/complete-csd-window-offset-mozilla-1457691.patch.xz
deleted file mode 100644
index 9c6e88f7a476..000000000000
--- a/complete-csd-window-offset-mozilla-1457691.patch.xz
+++ /dev/null
diff --git a/no-crmf.diff b/no-crmf.diff
deleted file mode 100644
index 682ba3fc0fd2..000000000000
--- a/no-crmf.diff
+++ /dev/null
@@ -1,15 +0,0 @@
-diff --git i/old-configure.in w/old-configure.in
-index 12170a47568f..dbbaa0bc9194 100644
---- i/old-configure.in
-+++ w/old-configure.in
-@@ -1808,9 +1808,7 @@ if test -n "$_USE_SYSTEM_NSS"; then
-     AM_PATH_NSS(3.35, [MOZ_SYSTEM_NSS=1], [AC_MSG_ERROR([you don't have NSS installed or your version is too old])])
- fi
- 
--if test -n "$MOZ_SYSTEM_NSS"; then
--   NSS_LIBS="$NSS_LIBS -lcrmf"
--else
-+if test -z "$MOZ_SYSTEM_NSS"; then
-    NSS_CFLAGS="-I${DIST}/include/nss"
-    case "${OS_ARCH}" in
-         # Only few platforms have been tested with GYP
diff --git a/unity-menubar.patch b/unity-menubar.patch
new file mode 100644
index 000000000000..fcf8bbb8a8da
--- /dev/null
+++ b/unity-menubar.patch
@@ -0,0 +1,5762 @@
+diff --git a/browser/base/content/browser-menubar.inc b/browser/base/content/browser-menubar.inc
+--- a/browser/base/content/browser-menubar.inc
++++ b/browser/base/content/browser-menubar.inc
+@@ -1,16 +1,20 @@
+ # -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ # 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/.
+ 
+        <menubar id="main-menubar"
+                 onpopupshowing="if (event.target.parentNode.parentNode == this &amp;&amp;
++#ifdef MOZ_WIDGET_GTK
++                                    document.documentElement.getAttribute('shellshowingmenubar') != 'true')
++#else
+                                     !('@mozilla.org/widget/nativemenuservice;1' in Cc))
++#endif
+                                   this.setAttribute('openedwithkey',
+                                                     event.target.parentNode.openedWithKey);">
+             <menu id="file-menu" label="&fileMenu.label;"
+                   accesskey="&fileMenu.accesskey;">
+               <menupopup id="menu_FilePopup"
+                          onpopupshowing="updateUserContextUIVisibility();">
+                 <menuitem id="menu_newNavigatorTab"
+                           label="&tabCmd.label;"
+diff --git a/browser/base/content/browser.js b/browser/base/content/browser.js
+--- a/browser/base/content/browser.js
++++ b/browser/base/content/browser.js
+@@ -5573,21 +5573,27 @@ function onViewToolbarsPopupShowing(aEve
+     if (deadItem.hasAttribute("toolbarId"))
+       popup.removeChild(deadItem);
+   }
+ 
+   var firstMenuItem = aInsertPoint || popup.firstChild;
+ 
+   let toolbarNodes = gNavToolbox.childNodes;
+ 
++  let shellShowingMenubar = document.documentElement.getAttribute("shellshowingmenubar") == "true";
++
+   for (let toolbar of toolbarNodes) {
+     if (!toolbar.hasAttribute("toolbarname")) {
+       continue;
+     }
+ 
++    if (shellShowingMenubar && toolbar.id == "toolbar-menubar") {
++      continue;
++    }
++
+     let menuItem = document.createElement("menuitem");
+     let hidingAttribute = toolbar.getAttribute("type") == "menubar" ?
+                           "autohide" : "collapsed";
+     menuItem.setAttribute("id", "toggle_" + toolbar.id);
+     menuItem.setAttribute("toolbarId", toolbar.id);
+     menuItem.setAttribute("type", "checkbox");
+     menuItem.setAttribute("label", toolbar.getAttribute("toolbarname"));
+     menuItem.setAttribute("checked", toolbar.getAttribute(hidingAttribute) != "true");
+diff --git a/browser/components/places/content/places.xul b/browser/components/places/content/places.xul
+--- a/browser/components/places/content/places.xul
++++ b/browser/components/places/content/places.xul
+@@ -181,17 +181,17 @@
+                      command="OrganizerCommand:Forward"
+                      tooltiptext="&forwardButton.tooltip;"
+                      disabled="true"/>
+ 
+ #ifdef XP_MACOSX
+         <toolbarbutton type="menu" class="tabbable"
+               onpopupshowing="document.getElementById('placeContent').focus()"
+ #else
+-      <menubar id="placesMenu">
++      <menubar id="placesMenu" _moz-menubarkeeplocal="true">
+         <menu accesskey="&organize.accesskey;" class="menu-iconic"
+ #endif
+               id="organizeButton" label="&organize.label;"
+               tooltiptext="&organize.tooltip;">
+           <menupopup id="organizeButtonPopup">
+             <menuitem id="newbookmark"
+                       command="placesCmd_new:bookmark"
+                       label="&cmd.new_bookmark.label;"
+diff --git a/dom/xul/XULPopupElement.cpp b/dom/xul/XULPopupElement.cpp
+--- a/dom/xul/XULPopupElement.cpp
++++ b/dom/xul/XULPopupElement.cpp
+@@ -14,16 +14,20 @@
+ #include "nsView.h"
+ #include "mozilla/AppUnits.h"
+ #include "mozilla/dom/DOMRect.h"
+ #include "mozilla/dom/Element.h"
+ #include "mozilla/dom/Event.h"
+ #include "mozilla/dom/XULPopupElement.h"
+ #include "mozilla/dom/XULPopupElementBinding.h"
+ 
++#ifdef MOZ_WIDGET_GTK
++#include "nsNativeMenuAtoms.h"
++#endif
++
+ namespace mozilla {
+ namespace dom {
+ 
+ nsXULElement*
+ NS_NewXULPopupElement(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)
+ {
+   return new XULPopupElement(aNodeInfo);
+ }
+@@ -189,16 +193,20 @@ XULPopupElement::SetAutoPosition(bool aS
+ }
+ 
+ void
+ XULPopupElement::GetState(nsString& aState)
+ {
+   // set this here in case there's no frame for the popup
+   aState.AssignLiteral("closed");
+ 
++#ifdef MOZ_WIDGET_GTK
++  nsAutoString nativeState;
++#endif
++
+   nsMenuPopupFrame *menuPopupFrame = do_QueryFrame(GetPrimaryFrame());
+   if (menuPopupFrame) {
+     switch (menuPopupFrame->PopupState()) {
+       case ePopupShown:
+         aState.AssignLiteral("open");
+         break;
+       case ePopupShowing:
+       case ePopupPositioning:
+@@ -212,16 +220,21 @@ XULPopupElement::GetState(nsString& aSta
+         break;
+       case ePopupClosed:
+         break;
+       default:
+         NS_NOTREACHED("Bad popup state");
+         break;
+     }
+   }
++#ifdef MOZ_WIDGET_GTK
++    else if (GetAttr(kNameSpaceID_None, nsNativeMenuAtoms::_moz_nativemenupopupstate, nativeState)) {
++      aState = nativeState;
++  }
++#endif
+ }
+ 
+ nsINode*
+ XULPopupElement::GetTriggerNode() const
+ {
+   nsMenuPopupFrame *menuPopupFrame = do_QueryFrame(GetPrimaryFrame());
+   return nsMenuPopupFrame::GetTriggerContent(menuPopupFrame);
+ }
+diff --git a/dom/xul/moz.build b/dom/xul/moz.build
+--- a/dom/xul/moz.build
++++ b/dom/xul/moz.build
+@@ -59,12 +59,17 @@ LOCAL_INCLUDES += [
+     '/dom/xbl',
+     '/dom/xml',
+     '/layout/base',
+     '/layout/generic',
+     '/layout/style',
+     '/layout/xul',
+ ]
+ 
++if 'gtk' in CONFIG['MOZ_WIDGET_TOOLKIT']:
++    LOCAL_INCLUDES += [
++        '/widget/gtk',
++    ]
++
+ FINAL_LIBRARY = 'xul'
+ 
+ if CONFIG['CC_TYPE'] in ('clang', 'gcc'):
+     CXXFLAGS += ['-Wno-error=shadow']
+diff --git a/layout/build/moz.build b/layout/build/moz.build
+--- a/layout/build/moz.build
++++ b/layout/build/moz.build
+@@ -65,16 +65,20 @@ elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'co
+     LOCAL_INCLUDES += [
+         '/dom/system/mac',
+     ]
+ elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'android':
+     LOCAL_INCLUDES += [
+         '/dom/system',
+         '/dom/system/android',
+     ]
++elif 'gtk' in CONFIG['MOZ_WIDGET_TOOLKIT']:
++    LOCAL_INCLUDES += [
++        '/widget/gtk',
++    ]
+ 
+ if CONFIG['MOZ_WEBSPEECH']:
+     LOCAL_INCLUDES += [
+         '/dom/media/webspeech/recognition',
+         '/dom/media/webspeech/synth',
+     ]
+ 
+ FINAL_LIBRARY = 'xul'
+diff --git a/layout/build/nsLayoutStatics.cpp b/layout/build/nsLayoutStatics.cpp
+--- a/layout/build/nsLayoutStatics.cpp
++++ b/layout/build/nsLayoutStatics.cpp
+@@ -108,16 +108,20 @@
+ #include "mozilla/StaticPresData.h"
+ #include "mozilla/dom/WebIDLGlobalNameHash.h"
+ #include "mozilla/dom/ipc/IPCBlobInputStreamStorage.h"
+ #include "mozilla/dom/U2FTokenManager.h"
+ #include "mozilla/dom/PointerEventHandler.h"
+ #include "nsHostObjectProtocolHandler.h"
+ #include "nsThreadManager.h"
+ 
++#ifdef MOZ_WIDGET_GTK
++#include "nsNativeMenuAtoms.h"
++#endif
++
+ using namespace mozilla;
+ using namespace mozilla::net;
+ using namespace mozilla::dom;
+ using namespace mozilla::dom::ipc;
+ 
+ nsrefcnt nsLayoutStatics::sLayoutStaticRefcnt = 0;
+ 
+ nsresult
+@@ -136,16 +140,19 @@ nsLayoutStatics::Initialize()
+ 
+   // Register static atoms. Note that nsGkAtoms must be initialized earlier
+   // than here, so it's done in NS_InitAtomTable() instead.
+   nsCSSAnonBoxes::RegisterStaticAtoms();
+   nsCSSPseudoElements::RegisterStaticAtoms();
+   nsCSSKeywords::AddRefTable();
+   nsCSSProps::AddRefTable();
+   nsColorNames::AddRefTable();
++#ifdef MOZ_WIDGET_GTK
++  nsNativeMenuAtoms::RegisterAtoms();
++#endif
+ 
+   NS_SetStaticAtomsDone();
+ 
+   StartupJSEnvironment();
+ 
+   nsGlobalWindowInner::Init();
+   nsGlobalWindowOuter::Init();
+   Navigator::Init();
+diff --git a/modules/libpref/init/all.js b/modules/libpref/init/all.js
+--- a/modules/libpref/init/all.js
++++ b/modules/libpref/init/all.js
+@@ -272,16 +272,19 @@ pref("dom.script_loader.bytecode_cache.e
+ // look at: ScriptLoader::ShouldCacheBytecode function.
+ pref("dom.script_loader.bytecode_cache.strategy", 0);
+ 
+ // Fastback caching - if this pref is negative, then we calculate the number
+ // of content viewers to cache based on the amount of available memory.
+ pref("browser.sessionhistory.max_total_viewers", -1);
+ 
+ pref("ui.use_native_colors", true);
++#ifdef MOZ_WIDGET_GTK
++pref("ui.use_unity_menubar", true);
++#endif
+ pref("ui.click_hold_context_menus", false);
+ 
+ // Pop up context menu on mouseup instead of mousedown, if that's the OS default.
+ // Note: ignored on Windows (context menus always use mouseup)
+ pref("ui.context_menus.after_mouseup", false);
+ // Duration of timeout of incremental search in menus (ms).  0 means infinite.
+ pref("ui.menu.incremental_search.timeout", 1000);
+ // If true, all popups won't hide automatically on blur
+diff --git a/toolkit/content/xul.css b/toolkit/content/xul.css
+--- a/toolkit/content/xul.css
++++ b/toolkit/content/xul.css
+@@ -297,16 +297,28 @@ toolbar[type="menubar"][autohide="true"]
+ toolbar[type="menubar"][autohide="true"][inactive="true"]:not([customizing="true"]) {
+   min-height: 0 !important;
+   height: 0 !important;
+   -moz-appearance: none !important;
+   border-style: none !important;
+ }
+ %endif
+ 
++%ifdef MOZ_WIDGET_GTK
++window[shellshowingmenubar="true"] menubar {
++  display: none !important;
++}
++
++window[shellshowingmenubar="true"]
++toolbar[type="menubar"]:not([customizing="true"]) {
++  min-height: 0 !important;
++  border: 0 !important;
++}
++%endif
++
+ toolbarspring {
+   -moz-box-flex: 1000;
+ }
+ 
+ toolbarpaletteitem {
+   -moz-binding: url("chrome://global/content/bindings/toolbar.xml#toolbarpaletteitem");
+ }
+ 
+diff --git a/widget/gtk/moz.build b/widget/gtk/moz.build
+--- a/widget/gtk/moz.build
++++ b/widget/gtk/moz.build
+@@ -34,32 +34,42 @@ EXPORTS.mozilla += [
+ 
+ UNIFIED_SOURCES += [
+     'IMContextWrapper.cpp',
+     'mozcontainer.cpp',
+     'NativeKeyBindings.cpp',
+     'nsAppShell.cpp',
+     'nsBidiKeyboard.cpp',
+     'nsColorPicker.cpp',
++    'nsDbusmenu.cpp',
+     'nsFilePicker.cpp',
+     'nsGtkKeyUtils.cpp',
+     'nsImageToPixbuf.cpp',
+     'nsLookAndFeel.cpp',
++    'nsMenuBar.cpp',
++    'nsMenuContainer.cpp',
++    'nsMenuItem.cpp',
++    'nsMenuObject.cpp',
++    'nsMenuSeparator.cpp',
++    'nsNativeMenuAtoms.cpp',
++    'nsNativeMenuDocListener.cpp',
+     'nsNativeThemeGTK.cpp',
+     'nsSound.cpp',
+     'nsToolkit.cpp',
+     'nsWidgetFactory.cpp',
+     'ScreenHelperGTK.cpp',
+     'TaskbarProgress.cpp',
+     'WakeLockListener.cpp',
+     'WidgetTraceEvent.cpp',
+     'WidgetUtilsGtk.cpp',
+ ]
+ 
+ SOURCES += [
++    'nsMenu.cpp', # conflicts with X11 headers
++    'nsNativeMenuService.cpp',
+     'nsWindow.cpp', # conflicts with X11 headers
+ ]
+ 
+ if CONFIG['MOZ_X11']:
+     UNIFIED_SOURCES += [
+         'CompositorWidgetChild.cpp',
+         'CompositorWidgetParent.cpp',
+         'GtkCompositorWidget.cpp',
+@@ -120,16 +130,17 @@ else:
+     ]
+ 
+ include('/ipc/chromium/chromium-config.mozbuild')
+ 
+ FINAL_LIBRARY = 'xul'
+ 
+ LOCAL_INCLUDES += [
+     '/layout/generic',
++    '/layout/style',
+     '/layout/xul',
+     '/other-licenses/atk-1.0',
+     '/widget',
+     '/widget/headless',
+ ]
+ 
+ if CONFIG['MOZ_X11']:
+     LOCAL_INCLUDES += [
+diff --git a/widget/gtk/nsDbusmenu.cpp b/widget/gtk/nsDbusmenu.cpp
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsDbusmenu.cpp
+@@ -0,0 +1,63 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* 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 "nsDbusmenu.h"
++#include "prlink.h"
++#include "mozilla/ArrayUtils.h"
++
++#define FUNC(name, type, params) \
++nsDbusmenuFunctions::_##name##_fn nsDbusmenuFunctions::s_##name;
++DBUSMENU_GLIB_FUNCTIONS
++DBUSMENU_GTK_FUNCTIONS
++#undef FUNC
++
++static PRLibrary *gDbusmenuGlib = nullptr;
++static PRLibrary *gDbusmenuGtk = nullptr;
++
++typedef void (*nsDbusmenuFunc)();
++struct nsDbusmenuDynamicFunction {
++    const char *functionName;
++    nsDbusmenuFunc *function;
++};
++
++/* static */ nsresult
++nsDbusmenuFunctions::Init()
++{
++#define FUNC(name, type, params) \
++    { #name, (nsDbusmenuFunc *)&nsDbusmenuFunctions::s_##name },
++    static const nsDbusmenuDynamicFunction kDbusmenuGlibSymbols[] = {
++        DBUSMENU_GLIB_FUNCTIONS
++    };
++    static const nsDbusmenuDynamicFunction kDbusmenuGtkSymbols[] = {
++        DBUSMENU_GTK_FUNCTIONS
++    };
++
++#define LOAD_LIBRARY(symbol, name) \
++    if (!g##symbol) { \
++        g##symbol = PR_LoadLibrary(name); \
++        if (!g##symbol) { \
++            return NS_ERROR_FAILURE; \
++        } \
++    } \
++    for (uint32_t i = 0; i < mozilla::ArrayLength(k##symbol##Symbols); ++i) { \
++        *k##symbol##Symbols[i].function = \
++            PR_FindFunctionSymbol(g##symbol, k##symbol##Symbols[i].functionName); \
++        if (!*k##symbol##Symbols[i].function) { \
++            return NS_ERROR_FAILURE; \
++        } \
++    }
++
++    LOAD_LIBRARY(DbusmenuGlib, "libdbusmenu-glib.so.4")
++#if (MOZ_WIDGET_GTK == 3)
++    LOAD_LIBRARY(DbusmenuGtk, "libdbusmenu-gtk3.so.4")
++#else
++    LOAD_LIBRARY(DbusmenuGtk, "libdbusmenu-gtk.so.4")
++#endif
++#undef LOAD_LIBRARY
++
++    return NS_OK;
++}
+diff --git a/widget/gtk/nsDbusmenu.h b/widget/gtk/nsDbusmenu.h
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsDbusmenu.h
+@@ -0,0 +1,101 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* This Source Code Form is subject to the terms of the Mozilla Public
++ * License, v. 2.0. If a copy of the MPL was not distributed with this
++ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++
++#ifndef __nsDbusmenu_h__
++#define __nsDbusmenu_h__
++
++#include "nsError.h"
++
++#include <glib.h>
++#include <gdk/gdk.h>
++
++#define DBUSMENU_GLIB_FUNCTIONS \
++    FUNC(dbusmenu_menuitem_child_add_position, gboolean, (DbusmenuMenuitem *mi, DbusmenuMenuitem *child, guint position)) \
++    FUNC(dbusmenu_menuitem_child_append, gboolean, (DbusmenuMenuitem *mi, DbusmenuMenuitem *child)) \
++    FUNC(dbusmenu_menuitem_child_delete, gboolean, (DbusmenuMenuitem *mi, DbusmenuMenuitem *child)) \
++    FUNC(dbusmenu_menuitem_get_children, GList*, (DbusmenuMenuitem *mi)) \
++    FUNC(dbusmenu_menuitem_new, DbusmenuMenuitem*, (void)) \
++    FUNC(dbusmenu_menuitem_property_get, const gchar*, (DbusmenuMenuitem *mi, const gchar *property)) \
++    FUNC(dbusmenu_menuitem_property_get_bool, gboolean, (DbusmenuMenuitem *mi, const gchar *property)) \
++    FUNC(dbusmenu_menuitem_property_remove, void, (DbusmenuMenuitem *mi, const gchar *property)) \
++    FUNC(dbusmenu_menuitem_property_set, gboolean, (DbusmenuMenuitem *mi, const gchar *property, const gchar *value)) \
++    FUNC(dbusmenu_menuitem_property_set_bool, gboolean, (DbusmenuMenuitem *mi, const gchar *property, const gboolean value)) \
++    FUNC(dbusmenu_menuitem_property_set_int, gboolean, (DbusmenuMenuitem *mi, const gchar *property, const gint value)) \
++    FUNC(dbusmenu_menuitem_show_to_user, void, (DbusmenuMenuitem *mi, guint timestamp)) \
++    FUNC(dbusmenu_menuitem_take_children, GList*, (DbusmenuMenuitem *mi)) \
++    FUNC(dbusmenu_server_new, DbusmenuServer*, (const gchar *object)) \
++    FUNC(dbusmenu_server_set_root, void, (DbusmenuServer *server, DbusmenuMenuitem *root)) \
++    FUNC(dbusmenu_server_set_status, void, (DbusmenuServer *server, DbusmenuStatus status))
++
++#define DBUSMENU_GTK_FUNCTIONS \
++    FUNC(dbusmenu_menuitem_property_set_image, gboolean, (DbusmenuMenuitem *menuitem, const gchar *property, const GdkPixbuf *data)) \
++    FUNC(dbusmenu_menuitem_property_set_shortcut, gboolean, (DbusmenuMenuitem *menuitem, guint key, GdkModifierType modifier))
++
++typedef struct _DbusmenuMenuitem DbusmenuMenuitem;
++typedef struct _DbusmenuServer DbusmenuServer;
++
++enum DbusmenuStatus {
++    DBUSMENU_STATUS_NORMAL,
++    DBUSMENU_STATUS_NOTICE
++};
++
++#define DBUSMENU_MENUITEM_CHILD_DISPLAY_SUBMENU "submenu"
++#define DBUSMENU_MENUITEM_PROP_CHILD_DISPLAY "children-display"
++#define DBUSMENU_MENUITEM_PROP_ENABLED "enabled"
++#define DBUSMENU_MENUITEM_PROP_ICON_DATA "icon-data"
++#define DBUSMENU_MENUITEM_PROP_LABEL "label"
++#define DBUSMENU_MENUITEM_PROP_SHORTCUT "shortcut"
++#define DBUSMENU_MENUITEM_PROP_TYPE "type"
++#define DBUSMENU_MENUITEM_PROP_TOGGLE_STATE "toggle-state"
++#define DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE "toggle-type"
++#define DBUSMENU_MENUITEM_PROP_VISIBLE "visible"
++#define DBUSMENU_MENUITEM_SIGNAL_ABOUT_TO_SHOW "about-to-show"
++#define DBUSMENU_MENUITEM_SIGNAL_EVENT "event"
++#define DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED "item-activated"
++#define DBUSMENU_MENUITEM_TOGGLE_CHECK "checkmark"
++#define DBUSMENU_MENUITEM_TOGGLE_RADIO "radio"
++#define DBUSMENU_MENUITEM_TOGGLE_STATE_CHECKED 1
++#define DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED 0
++#define DBUSMENU_SERVER_PROP_DBUS_OBJECT "dbus-object"
++
++class nsDbusmenuFunctions
++{
++public:
++    nsDbusmenuFunctions() = delete;
++
++    static nsresult Init();
++
++#define FUNC(name, type, params) \
++    typedef type (*_##name##_fn) params; \
++    static _##name##_fn s_##name;
++    DBUSMENU_GLIB_FUNCTIONS
++    DBUSMENU_GTK_FUNCTIONS
++#undef FUNC
++
++};
++
++#define dbusmenu_menuitem_child_add_position nsDbusmenuFunctions::s_dbusmenu_menuitem_child_add_position
++#define dbusmenu_menuitem_child_append nsDbusmenuFunctions::s_dbusmenu_menuitem_child_append
++#define dbusmenu_menuitem_child_delete nsDbusmenuFunctions::s_dbusmenu_menuitem_child_delete
++#define dbusmenu_menuitem_get_children nsDbusmenuFunctions::s_dbusmenu_menuitem_get_children
++#define dbusmenu_menuitem_new nsDbusmenuFunctions::s_dbusmenu_menuitem_new
++#define dbusmenu_menuitem_property_get nsDbusmenuFunctions::s_dbusmenu_menuitem_property_get
++#define dbusmenu_menuitem_property_get_bool nsDbusmenuFunctions::s_dbusmenu_menuitem_property_get_bool
++#define dbusmenu_menuitem_property_remove nsDbusmenuFunctions::s_dbusmenu_menuitem_property_remove
++#define dbusmenu_menuitem_property_set nsDbusmenuFunctions::s_dbusmenu_menuitem_property_set
++#define dbusmenu_menuitem_property_set_bool nsDbusmenuFunctions::s_dbusmenu_menuitem_property_set_bool
++#define dbusmenu_menuitem_property_set_int nsDbusmenuFunctions::s_dbusmenu_menuitem_property_set_int
++#define dbusmenu_menuitem_show_to_user nsDbusmenuFunctions::s_dbusmenu_menuitem_show_to_user
++#define dbusmenu_menuitem_take_children nsDbusmenuFunctions::s_dbusmenu_menuitem_take_children
++#define dbusmenu_server_new nsDbusmenuFunctions::s_dbusmenu_server_new
++#define dbusmenu_server_set_root nsDbusmenuFunctions::s_dbusmenu_server_set_root
++#define dbusmenu_server_set_status nsDbusmenuFunctions::s_dbusmenu_server_set_status
++
++#define dbusmenu_menuitem_property_set_image nsDbusmenuFunctions::s_dbusmenu_menuitem_property_set_image
++#define dbusmenu_menuitem_property_set_shortcut nsDbusmenuFunctions::s_dbusmenu_menuitem_property_set_shortcut
++
++#endif /* __nsDbusmenu_h__ */
+diff --git a/widget/gtk/nsMenu.cpp b/widget/gtk/nsMenu.cpp
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsMenu.cpp
+@@ -0,0 +1,849 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* 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/. */
++
++#define _IMPL_NS_LAYOUT
++
++#include "mozilla/dom/Element.h"
++#include "mozilla/Assertions.h"
++#include "mozilla/ComputedStyle.h"
++#include "mozilla/ComputedStyleInlines.h"
++#include "mozilla/EventDispatcher.h"
++#include "mozilla/GuardObjects.h"
++#include "mozilla/MouseEvents.h"
++#include "mozilla/Move.h"
++#include "nsAutoPtr.h"
++#include "nsBindingManager.h"
++#include "nsComponentManagerUtils.h"
++#include "nsContentUtils.h"
++#include "nsCSSValue.h"
++#include "nsGkAtoms.h"
++#include "nsGtkUtils.h"
++#include "nsAtom.h"
++#include "nsIContent.h"
++#include "nsIDocument.h"
++#include "nsIPresShell.h"
++#include "nsIRunnable.h"
++#include "nsITimer.h"
++#include "nsString.h"
++#include "nsStyleStruct.h"
++#include "nsThreadUtils.h"
++#include "nsXBLBinding.h"
++#include "nsXBLService.h"
++
++#include "nsNativeMenuAtoms.h"
++#include "nsNativeMenuDocListener.h"
++
++#include <glib-object.h>
++
++#include "nsMenu.h"
++
++using namespace mozilla;
++
++class nsMenuContentInsertedEvent : public Runnable
++{
++public:
++    nsMenuContentInsertedEvent(nsMenu *aMenu,
++                               nsIContent *aContainer,
++                               nsIContent *aChild,
++                               nsIContent *aPrevSibling) :
++        Runnable("nsMenuContentInsertedEvent"),
++        mWeakMenu(aMenu),
++        mContainer(aContainer),
++        mChild(aChild),
++        mPrevSibling(aPrevSibling) { }
++
++    NS_IMETHODIMP Run()
++    {
++        if (!mWeakMenu) {
++            return NS_OK;
++        }
++
++        static_cast<nsMenu *>(mWeakMenu.get())->HandleContentInserted(mContainer,
++                                                                      mChild,
++                                                                      mPrevSibling);
++        return NS_OK;
++    }
++
++private:
++    nsWeakMenuObject mWeakMenu;
++
++    nsCOMPtr<nsIContent> mContainer;
++    nsCOMPtr<nsIContent> mChild;
++    nsCOMPtr<nsIContent> mPrevSibling;
++};
++
++class nsMenuContentRemovedEvent : public Runnable
++{
++public:
++    nsMenuContentRemovedEvent(nsMenu *aMenu,
++                              nsIContent *aContainer,
++                              nsIContent *aChild) :
++        Runnable("nsMenuContentRemovedEvent"),
++        mWeakMenu(aMenu),
++        mContainer(aContainer),
++        mChild(aChild) { }
++
++    NS_IMETHODIMP Run()
++    {
++        if (!mWeakMenu) {
++            return NS_OK;
++        }
++
++        static_cast<nsMenu *>(mWeakMenu.get())->HandleContentRemoved(mContainer,
++                                                                     mChild);
++        return NS_OK;
++    }
++
++private:
++    nsWeakMenuObject mWeakMenu;
++
++    nsCOMPtr<nsIContent> mContainer;
++    nsCOMPtr<nsIContent> mChild;
++};
++
++static void
++DispatchMouseEvent(nsIContent *aTarget, mozilla::EventMessage aMsg)
++{
++    if (!aTarget) {
++        return;
++    }
++
++    WidgetMouseEvent event(true, aMsg, nullptr, WidgetMouseEvent::eReal);
++    EventDispatcher::Dispatch(aTarget, nullptr, &event);
++}
++
++static void
++AttachXBLBindings(nsIContent *aContent)
++{
++    nsIDocument *doc = aContent->OwnerDoc();
++    nsIPresShell *shell = doc->GetShell();
++    if (!shell) {
++        return;
++    }
++
++    RefPtr<ComputedStyle> style =
++        shell->StyleSet()->ResolveStyleFor(aContent->AsElement(),
++                                           nullptr,
++                                           LazyComputeBehavior::Allow);
++
++    if (!style) {
++        return;
++    }
++
++    const nsStyleDisplay* display = style->StyleDisplay();
++    if (!display->mBinding) {
++        return;
++    }
++
++    nsXBLService* xbl = nsXBLService::GetInstance();
++    if (!xbl) {
++        return;
++    }
++
++    RefPtr<nsXBLBinding> binding;
++    bool dummy;
++    nsresult rv = xbl->LoadBindings(aContent->AsElement(),
++                                    display->mBinding->GetURI(),
++                                    display->mBinding->mExtraData->GetPrincipal(),
++                                    getter_AddRefs(binding), &dummy);
++    if ((NS_FAILED(rv) && rv != NS_ERROR_XBL_BLOCKED) || !binding) {
++        return;
++    }
++
++    doc->BindingManager()->AddToAttachedQueue(binding);
++}
++
++void
++nsMenu::SetPopupState(EPopupState aState)
++{
++    mPopupState = aState;
++
++    if (!mPopupContent) {
++        return;
++    }
++
++    nsAutoString state;
++    switch (aState) {
++        case ePopupState_Showing:
++            state.Assign(NS_LITERAL_STRING("showing"));
++            break;
++        case ePopupState_Open:
++            state.Assign(NS_LITERAL_STRING("open"));
++            break;
++        case ePopupState_Hiding:
++            state.Assign(NS_LITERAL_STRING("hiding"));
++            break;
++        default:
++            break;
++    }
++
++    if (state.IsEmpty()) {
++        mPopupContent->AsElement()->UnsetAttr(
++            kNameSpaceID_None, nsNativeMenuAtoms::_moz_nativemenupopupstate,
++            false);
++    } else {
++        mPopupContent->AsElement()->SetAttr(
++            kNameSpaceID_None, nsNativeMenuAtoms::_moz_nativemenupopupstate,
++            state, false);
++    }
++}
++
++/* static */ void
++nsMenu::DoOpenCallback(nsITimer *aTimer, void *aClosure)
++{
++    nsMenu* self = static_cast<nsMenu *>(aClosure);
++
++    dbusmenu_menuitem_show_to_user(self->GetNativeData(), 0);
++
++    self->mOpenDelayTimer = nullptr;
++}
++
++/* static */ void
++nsMenu::menu_event_cb(DbusmenuMenuitem *menu,
++                      const gchar *name,
++                      GVariant *value,
++                      guint timestamp,
++                      gpointer user_data)
++{
++    nsMenu *self = static_cast<nsMenu *>(user_data);
++
++    nsAutoCString event(name);
++
++    if (event.Equals(NS_LITERAL_CSTRING("closed"))) {
++        self->OnClose();
++        return;
++    }
++
++    if (event.Equals(NS_LITERAL_CSTRING("opened"))) {
++        self->OnOpen();
++        return;
++    }
++}
++
++void
++nsMenu::MaybeAddPlaceholderItem()
++{
++    MOZ_ASSERT(!IsInBatchedUpdate(),
++               "Shouldn't be modifying the native menu structure now");
++
++    GList *children = dbusmenu_menuitem_get_children(GetNativeData());
++    if (!children) {
++        MOZ_ASSERT(!mPlaceholderItem);
++
++        mPlaceholderItem = dbusmenu_menuitem_new();
++        if (!mPlaceholderItem) {
++            return;
++        }
++
++        dbusmenu_menuitem_property_set_bool(mPlaceholderItem,
++                                            DBUSMENU_MENUITEM_PROP_VISIBLE,
++                                            false);
++
++        MOZ_ALWAYS_TRUE(
++            dbusmenu_menuitem_child_append(GetNativeData(), mPlaceholderItem));
++    }
++}
++
++void
++nsMenu::EnsureNoPlaceholderItem()
++{
++    MOZ_ASSERT(!IsInBatchedUpdate(),
++               "Shouldn't be modifying the native menu structure now");
++
++    if (!mPlaceholderItem) {
++        return;
++    }
++
++    MOZ_ALWAYS_TRUE(
++        dbusmenu_menuitem_child_delete(GetNativeData(), mPlaceholderItem));
++    MOZ_ASSERT(!dbusmenu_menuitem_get_children(GetNativeData()));
++
++    g_object_unref(mPlaceholderItem);
++    mPlaceholderItem = nullptr;
++}
++
++void
++nsMenu::OnOpen()
++{
++    if (mNeedsRebuild) {
++        Build();
++    }
++
++    nsWeakMenuObject self(this);
++    nsCOMPtr<nsIContent> origPopupContent(mPopupContent);
++    {
++        nsNativeMenuDocListener::BlockUpdatesScope updatesBlocker;
++
++        SetPopupState(ePopupState_Showing);
++        DispatchMouseEvent(mPopupContent, eXULPopupShowing);
++
++        ContentNode()->AsElement()->SetAttr(kNameSpaceID_None, nsGkAtoms::open,
++                                            NS_LITERAL_STRING("true"), true);
++    }
++
++    if (!self) {
++        // We were deleted!
++        return;
++    }
++
++    // I guess that the popup could have changed
++    if (origPopupContent != mPopupContent) {
++        return;
++    }
++
++    nsNativeMenuDocListener::BlockUpdatesScope updatesBlocker;
++
++    size_t count = ChildCount();
++    for (size_t i = 0; i < count; ++i) {
++        ChildAt(i)->ContainerIsOpening();
++    }
++
++    SetPopupState(ePopupState_Open);
++    DispatchMouseEvent(mPopupContent, eXULPopupShown);
++}
++
++void
++nsMenu::Build()
++{
++    mNeedsRebuild = false;
++
++    while (ChildCount() > 0) {
++        RemoveChildAt(0);
++    }
++
++    InitializePopup();
++
++    if (!mPopupContent) {
++        return;
++    }
++
++    uint32_t count = mPopupContent->GetChildCount();
++    for (uint32_t i = 0; i < count; ++i) {
++        nsIContent *childContent = mPopupContent->GetChildAt_Deprecated(i);
++
++        UniquePtr<nsMenuObject> child = CreateChild(childContent);
++
++        if (!child) {
++            continue;
++        }
++
++        AppendChild(Move(child));
++    }
++}
++
++void
++nsMenu::InitializePopup()
++{
++    nsCOMPtr<nsIContent> oldPopupContent;
++    oldPopupContent.swap(mPopupContent);
++
++    for (uint32_t i = 0; i < ContentNode()->GetChildCount(); ++i) {
++        nsIContent *child = ContentNode()->GetChildAt_Deprecated(i);
++
++        int32_t dummy;
++        nsAtom* tag = child->OwnerDoc()->BindingManager()->ResolveTag(child, &dummy);
++        if (tag == nsGkAtoms::menupopup) {
++            mPopupContent = child;
++            break;
++        }
++    }
++
++    if (oldPopupContent == mPopupContent) {
++        return;
++    }
++
++    // The popup has changed
++
++    if (oldPopupContent) {
++        DocListener()->UnregisterForContentChanges(oldPopupContent);
++    }
++
++    SetPopupState(ePopupState_Closed);
++
++    if (!mPopupContent) {
++        return;
++    }
++
++    AttachXBLBindings(mPopupContent);
++
++    DocListener()->RegisterForContentChanges(mPopupContent, this);
++}
++
++void
++nsMenu::RemoveChildAt(size_t aIndex)
++{
++    MOZ_ASSERT(IsInBatchedUpdate() || !mPlaceholderItem,
++               "Shouldn't have a placeholder menuitem");
++
++    nsMenuContainer::RemoveChildAt(aIndex, !IsInBatchedUpdate());
++    StructureMutated();
++
++    if (!IsInBatchedUpdate()) {
++        MaybeAddPlaceholderItem();
++    }
++}
++
++void
++nsMenu::RemoveChild(nsIContent *aChild)
++{
++    size_t index = IndexOf(aChild);
++    if (index == NoIndex) {
++        return;
++    }
++
++    RemoveChildAt(index);
++}
++
++void
++nsMenu::InsertChildAfter(UniquePtr<nsMenuObject> aChild,
++                         nsIContent *aPrevSibling)
++{
++    if (!IsInBatchedUpdate()) {
++        EnsureNoPlaceholderItem();
++    }
++
++    nsMenuContainer::InsertChildAfter(Move(aChild), aPrevSibling,
++                                      !IsInBatchedUpdate());
++    StructureMutated();
++}
++
++void
++nsMenu::AppendChild(UniquePtr<nsMenuObject> aChild)
++{
++    if (!IsInBatchedUpdate()) {
++        EnsureNoPlaceholderItem();
++    }
++
++    nsMenuContainer::AppendChild(Move(aChild), !IsInBatchedUpdate());
++    StructureMutated();
++}
++
++bool 
++nsMenu::IsInBatchedUpdate() const
++{
++    return mBatchedUpdateState != eBatchedUpdateState_Inactive;
++}
++
++void
++nsMenu::StructureMutated()
++{
++    if (!IsInBatchedUpdate()) {
++        return;
++    }
++
++    mBatchedUpdateState = eBatchedUpdateState_DidMutate;
++}
++
++bool
++nsMenu::CanOpen() const
++{
++    bool isVisible = dbusmenu_menuitem_property_get_bool(GetNativeData(),
++                                                         DBUSMENU_MENUITEM_PROP_VISIBLE);
++    bool isDisabled = ContentNode()->AsElement()->AttrValueIs(kNameSpaceID_None,
++                                                              nsGkAtoms::disabled,
++                                                              nsGkAtoms::_true,
++                                                              eCaseMatters);
++
++    return (isVisible && !isDisabled);
++}
++
++void
++nsMenu::HandleContentInserted(nsIContent *aContainer,
++                              nsIContent *aChild,
++                              nsIContent *aPrevSibling)
++{
++    if (aContainer == mPopupContent) {
++        UniquePtr<nsMenuObject> child = CreateChild(aChild);
++
++        if (child) {
++            InsertChildAfter(Move(child), aPrevSibling);
++        }
++    } else {
++        Build();
++    }
++}
++
++void
++nsMenu::HandleContentRemoved(nsIContent *aContainer, nsIContent *aChild)
++{
++    if (aContainer == mPopupContent) {
++        RemoveChild(aChild);
++    } else {
++        Build();
++    }
++}
++
++void
++nsMenu::InitializeNativeData()
++{
++    // Dbusmenu provides an "about-to-show" signal, and also "opened" and
++    // "closed" events. However, Unity is the only thing that sends
++    // both "about-to-show" and "opened" events. Unity 2D and the HUD only
++    // send "opened" events, so we ignore "about-to-show" (I don't think
++    // there's any real difference between them anyway).
++    // To complicate things, there are certain conditions where we don't
++    // get a "closed" event, so we need to be able to handle this :/
++    g_signal_connect(G_OBJECT(GetNativeData()), "event",
++                     G_CALLBACK(menu_event_cb), this);
++
++    mNeedsRebuild = true;
++    mNeedsUpdate = true;
++
++    MaybeAddPlaceholderItem();
++
++    AttachXBLBindings(ContentNode());
++}
++
++void
++nsMenu::Update(ComputedStyle *aComputedStyle)
++{
++    if (mNeedsUpdate) {
++        mNeedsUpdate = false;
++
++        UpdateLabel();
++        UpdateSensitivity();
++    }
++
++    UpdateVisibility(aComputedStyle);
++    UpdateIcon(aComputedStyle);
++}
++
++nsMenuObject::PropertyFlags
++nsMenu::SupportedProperties() const
++{
++    return static_cast<nsMenuObject::PropertyFlags>(
++        nsMenuObject::ePropLabel |
++        nsMenuObject::ePropEnabled |
++        nsMenuObject::ePropVisible |
++        nsMenuObject::ePropIconData |
++        nsMenuObject::ePropChildDisplay
++    );
++}
++
++void
++nsMenu::OnAttributeChanged(nsIContent *aContent, nsAtom *aAttribute)
++{
++    MOZ_ASSERT(aContent == ContentNode() || aContent == mPopupContent,
++               "Received an event that wasn't meant for us!");
++
++    if (mNeedsUpdate) {
++        return;
++    }
++
++    if (aContent != ContentNode()) {
++        return;
++    }
++
++    if (!Parent()->IsBeingDisplayed()) {
++        mNeedsUpdate = true;
++        return;
++    }
++
++    if (aAttribute == nsGkAtoms::disabled) {
++        UpdateSensitivity();
++    } else if (aAttribute == nsGkAtoms::label || 
++               aAttribute == nsGkAtoms::accesskey ||
++               aAttribute == nsGkAtoms::crop) {
++        UpdateLabel();
++    } else if (aAttribute == nsGkAtoms::hidden ||
++        aAttribute == nsGkAtoms::collapsed) {
++        RefPtr<ComputedStyle> style = GetComputedStyle();
++        UpdateVisibility(style);
++    } else if (aAttribute == nsGkAtoms::image) {
++        RefPtr<ComputedStyle> style = GetComputedStyle();
++        UpdateIcon(style);
++    }
++}
++
++void
++nsMenu::OnContentInserted(nsIContent *aContainer, nsIContent *aChild,
++                          nsIContent *aPrevSibling)
++{
++    MOZ_ASSERT(aContainer == ContentNode() || aContainer == mPopupContent,
++               "Received an event that wasn't meant for us!");
++
++    if (mNeedsRebuild) {
++        return;
++    }
++
++    if (mPopupState == ePopupState_Closed) {
++        mNeedsRebuild = true;
++        return;
++    }
++
++    nsContentUtils::AddScriptRunner(
++        new nsMenuContentInsertedEvent(this, aContainer, aChild,
++                                       aPrevSibling));
++}
++
++void
++nsMenu::OnContentRemoved(nsIContent *aContainer, nsIContent *aChild)
++{
++    MOZ_ASSERT(aContainer == ContentNode() || aContainer == mPopupContent,
++               "Received an event that wasn't meant for us!");
++
++    if (mNeedsRebuild) {
++        return;
++    }
++
++    if (mPopupState == ePopupState_Closed) {
++        mNeedsRebuild = true;
++        return;
++    }
++
++    nsContentUtils::AddScriptRunner(
++        new nsMenuContentRemovedEvent(this, aContainer, aChild));
++}
++
++/*
++ * Some menus (eg, the History menu in Firefox) refresh themselves on
++ * opening by removing all children and then re-adding new ones. As this
++ * happens whilst the menu is opening in Unity, it causes some flickering
++ * as the menu popup is resized multiple times. To avoid this, we try to
++ * reuse native menu items when the menu structure changes during a
++ * batched update. If we can handle menu structure changes from Gecko
++ * just by updating properties of native menu items (rather than destroying
++ * and creating new ones), then we eliminate any flickering that occurs as
++ * the menu is opened. To do this, we don't modify any native menu items
++ * until the end of the update batch.
++ */
++
++void
++nsMenu::OnBeginUpdates(nsIContent *aContent)
++{
++    MOZ_ASSERT(aContent == ContentNode() || aContent == mPopupContent,
++               "Received an event that wasn't meant for us!");
++    MOZ_ASSERT(!IsInBatchedUpdate(), "Already in an update batch!");
++
++    if (aContent != mPopupContent) {
++        return;
++    }
++
++    mBatchedUpdateState = eBatchedUpdateState_Active;
++}
++
++void
++nsMenu::OnEndUpdates()
++{
++    if (!IsInBatchedUpdate()) {
++        return;
++    }
++
++    bool didMutate = mBatchedUpdateState == eBatchedUpdateState_DidMutate;
++    mBatchedUpdateState = eBatchedUpdateState_Inactive;
++
++    /* Optimize for the case where we only had attribute changes */
++    if (!didMutate) {
++        return;
++    }
++
++    EnsureNoPlaceholderItem();
++
++    GList *nextNativeChild = dbusmenu_menuitem_get_children(GetNativeData());
++    DbusmenuMenuitem *nextOwnedNativeChild = nullptr;
++
++    size_t count = ChildCount();
++
++    // Find the first native menu item that is `owned` by a corresponding
++    // Gecko menuitem
++    for (size_t i = 0; i < count; ++i) {
++        if (ChildAt(i)->GetNativeData()) {
++            nextOwnedNativeChild = ChildAt(i)->GetNativeData();
++            break;
++        }
++    }
++
++    // Now iterate over all Gecko menuitems
++    for (size_t i = 0; i < count; ++i) {
++        nsMenuObject *child = ChildAt(i);
++
++        if (child->GetNativeData()) {
++            // This child already has a corresponding native menuitem.
++            // Remove all preceding orphaned native items. At this point, we
++            // modify the native menu structure.
++            while (nextNativeChild &&
++                   nextNativeChild->data != nextOwnedNativeChild) {
++
++                DbusmenuMenuitem *data =
++                    static_cast<DbusmenuMenuitem *>(nextNativeChild->data);
++                nextNativeChild = nextNativeChild->next;
++
++                MOZ_ALWAYS_TRUE(dbusmenu_menuitem_child_delete(GetNativeData(),
++                                                               data));
++            }
++
++            if (nextNativeChild) {
++                nextNativeChild = nextNativeChild->next;
++            }
++
++            // Now find the next native menu item that is `owned`
++            nextOwnedNativeChild = nullptr;
++            for (size_t j = i + 1; j < count; ++j) {
++                if (ChildAt(j)->GetNativeData()) {
++                    nextOwnedNativeChild = ChildAt(j)->GetNativeData();
++                    break;
++                }
++            }
++        } else {
++            // This child is new, and doesn't have a native menu item. Find one!
++            if (nextNativeChild &&
++                nextNativeChild->data != nextOwnedNativeChild) {
++
++                DbusmenuMenuitem *data =
++                    static_cast<DbusmenuMenuitem *>(nextNativeChild->data);
++
++                if (NS_SUCCEEDED(child->AdoptNativeData(data))) {
++                    nextNativeChild = nextNativeChild->next;
++                }
++            }
++
++            // There wasn't a suitable one available, so create a new one.
++            // At this point, we modify the native menu structure.
++            if (!child->GetNativeData()) {
++                child->CreateNativeData();
++                MOZ_ALWAYS_TRUE(
++                    dbusmenu_menuitem_child_add_position(GetNativeData(),
++                                                         child->GetNativeData(),
++                                                         i));
++            }
++        }
++    }
++
++    while (nextNativeChild) {
++        DbusmenuMenuitem *data =
++            static_cast<DbusmenuMenuitem *>(nextNativeChild->data);
++        nextNativeChild = nextNativeChild->next;
++
++        MOZ_ALWAYS_TRUE(dbusmenu_menuitem_child_delete(GetNativeData(), data));
++    }
++
++    MaybeAddPlaceholderItem();
++}
++
++nsMenu::nsMenu(nsMenuContainer *aParent, nsIContent *aContent) :
++    nsMenuContainer(aParent, aContent),
++    mNeedsRebuild(false),
++    mNeedsUpdate(false),
++    mPlaceholderItem(nullptr),
++    mPopupState(ePopupState_Closed),
++    mBatchedUpdateState(eBatchedUpdateState_Inactive)
++{
++    MOZ_COUNT_CTOR(nsMenu);
++}
++
++nsMenu::~nsMenu()
++{
++    if (IsInBatchedUpdate()) {
++        OnEndUpdates();
++    }
++
++    // Although nsTArray will take care of this in its destructor,
++    // we have to manually ensure children are removed from our native menu
++    // item, just in case our parent recycles us
++    while (ChildCount() > 0) {
++        RemoveChildAt(0);
++    }
++
++    EnsureNoPlaceholderItem();
++
++    if (DocListener() && mPopupContent) {
++        DocListener()->UnregisterForContentChanges(mPopupContent);
++    }
++
++    if (GetNativeData()) {
++        g_signal_handlers_disconnect_by_func(GetNativeData(),
++                                             FuncToGpointer(menu_event_cb),
++                                             this);
++    }
++
++    MOZ_COUNT_DTOR(nsMenu);
++}
++
++nsMenuObject::EType
++nsMenu::Type() const
++{
++    return eType_Menu;
++}
++
++bool
++nsMenu::IsBeingDisplayed() const
++{
++    return mPopupState == ePopupState_Open;
++}
++
++bool
++nsMenu::NeedsRebuild() const
++{
++    return mNeedsRebuild;
++}
++
++void
++nsMenu::OpenMenu()
++{
++    if (!CanOpen()) {
++        return;
++    }
++
++    if (mOpenDelayTimer) {
++        return;
++    }
++
++    // Here, we synchronously fire popupshowing and popupshown events and then
++    // open the menu after a short delay. This allows the menu to refresh before
++    // it's shown, and avoids an issue where keyboard focus is not on the first
++    // item of the history menu in Firefox when opening it with the keyboard,
++    // because extra items to appear at the top of the menu
++
++    OnOpen();
++
++    mOpenDelayTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
++    if (!mOpenDelayTimer) {
++        return;
++    }
++
++    if (NS_FAILED(mOpenDelayTimer->InitWithNamedFuncCallback(DoOpenCallback,
++                                                             this,
++                                                             100,
++                                                             nsITimer::TYPE_ONE_SHOT,
++                                                             "nsMenu::DoOpenCallback"))) {
++        mOpenDelayTimer = nullptr;
++    }
++}
++
++void
++nsMenu::OnClose()
++{
++    if (mPopupState == ePopupState_Closed) {
++        return;
++    }
++
++    MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
++
++    // We do this to avoid mutating our view of the menu until
++    // after we have finished
++    nsNativeMenuDocListener::BlockUpdatesScope updatesBlocker;
++
++    SetPopupState(ePopupState_Hiding);
++    DispatchMouseEvent(mPopupContent, eXULPopupHiding);
++
++    // Sigh, make sure all of our descendants are closed, as we don't
++    // always get closed events for submenus when scrubbing quickly through
++    // the menu
++    size_t count = ChildCount();
++    for (size_t i = 0; i < count; ++i) {
++        if (ChildAt(i)->Type() == nsMenuObject::eType_Menu) {
++            static_cast<nsMenu *>(ChildAt(i))->OnClose();
++        }
++    }
++
++    SetPopupState(ePopupState_Closed);
++    DispatchMouseEvent(mPopupContent, eXULPopupHidden);
++
++    ContentNode()->AsElement()->UnsetAttr(kNameSpaceID_None, nsGkAtoms::open,
++                                          true);
++}
++
+diff --git a/widget/gtk/nsMenu.h b/widget/gtk/nsMenu.h
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsMenu.h
+@@ -0,0 +1,123 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* This Source Code Form is subject to the terms of the Mozilla Public
++ * License, v. 2.0. If a copy of the MPL was not distributed with this
++ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++
++#ifndef __nsMenu_h__
++#define __nsMenu_h__
++
++#include "mozilla/Attributes.h"
++#include "mozilla/UniquePtr.h"
++#include "nsCOMPtr.h"
++
++#include "nsDbusmenu.h"
++#include "nsMenuContainer.h"
++#include "nsMenuObject.h"
++
++#include <glib.h>
++
++class nsAtom;
++class nsIContent;
++class nsITimer;
++
++#define NSMENU_NUMBER_OF_POPUPSTATE_BITS 2U
++#define NSMENU_NUMBER_OF_FLAGS           4U
++
++// This class represents a menu
++class nsMenu final : public nsMenuContainer
++{
++public:
++    nsMenu(nsMenuContainer *aParent, nsIContent *aContent);
++    ~nsMenu();
++
++    nsMenuObject::EType Type() const override;
++
++    bool IsBeingDisplayed() const override;
++    bool NeedsRebuild() const override;
++
++    // Tell the desktop shell to display this menu
++    void OpenMenu();
++
++    // Normally called via the shell, but it's public so that child
++    // menuitems can do the shells work. Sigh....
++    void OnClose();
++
++private:
++    friend class nsMenuContentInsertedEvent;
++    friend class nsMenuContentRemovedEvent;
++
++    enum EPopupState {
++        ePopupState_Closed,
++        ePopupState_Showing,
++        ePopupState_Open,
++        ePopupState_Hiding
++    };
++
++    void SetPopupState(EPopupState aState);
++
++    static void DoOpenCallback(nsITimer *aTimer, void *aClosure);
++    static void menu_event_cb(DbusmenuMenuitem *menu,
++                              const gchar *name,
++                              GVariant *value,
++                              guint timestamp,
++                              gpointer user_data);
++
++    // We add a placeholder item to empty menus so that Unity actually treats
++    // us as a proper menu, rather than a menuitem without a submenu
++    void MaybeAddPlaceholderItem();
++
++    // Removes a placeholder item if it exists and asserts that this succeeds
++    void EnsureNoPlaceholderItem();
++
++    void OnOpen();
++    void Build();
++    void InitializePopup();
++    void RemoveChildAt(size_t aIndex);
++    void RemoveChild(nsIContent *aChild);
++    void InsertChildAfter(mozilla::UniquePtr<nsMenuObject> aChild,
++                          nsIContent *aPrevSibling);
++    void AppendChild(mozilla::UniquePtr<nsMenuObject> aChild);
++    bool IsInBatchedUpdate() const;
++    void StructureMutated();
++    bool CanOpen() const;
++
++    void HandleContentInserted(nsIContent *aContainer,
++                               nsIContent *aChild,
++                               nsIContent *aPrevSibling);
++    void HandleContentRemoved(nsIContent *aContainer,
++                              nsIContent *aChild);
++
++    void InitializeNativeData() override;
++    void Update(mozilla::ComputedStyle *aComputedStyle) override;
++    nsMenuObject::PropertyFlags SupportedProperties() const override;
++
++    void OnAttributeChanged(nsIContent *aContent, nsAtom *aAttribute) override;
++    void OnContentInserted(nsIContent *aContainer, nsIContent *aChild,
++                           nsIContent *aPrevSibling) override;
++    void OnContentRemoved(nsIContent *aContainer, nsIContent *aChild) override;
++    void OnBeginUpdates(nsIContent *aContent) override;
++    void OnEndUpdates() override;
++
++    bool mNeedsRebuild;
++    bool mNeedsUpdate;
++
++    DbusmenuMenuitem *mPlaceholderItem;
++
++    EPopupState mPopupState;
++
++    enum EBatchedUpdateState {
++        eBatchedUpdateState_Inactive,
++        eBatchedUpdateState_Active,
++        eBatchedUpdateState_DidMutate
++    };
++
++    EBatchedUpdateState mBatchedUpdateState;
++
++    nsCOMPtr<nsIContent> mPopupContent;
++
++    nsCOMPtr<nsITimer> mOpenDelayTimer;
++};
++
++#endif /* __nsMenu_h__ */
+diff --git a/widget/gtk/nsMenuBar.cpp b/widget/gtk/nsMenuBar.cpp
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsMenuBar.cpp
+@@ -0,0 +1,551 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* 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 "mozilla/Assertions.h"
++#include "mozilla/DebugOnly.h"
++#include "mozilla/dom/Element.h"
++#include "mozilla/dom/Event.h"
++#include "mozilla/dom/KeyboardEvent.h"
++#include "mozilla/dom/KeyboardEventBinding.h"
++#include "mozilla/Move.h"
++#include "mozilla/Preferences.h"
++#include "nsAutoPtr.h"
++#include "nsContentUtils.h"
++#include "nsIDocument.h"
++#include "nsIDOMEventListener.h"
++#include "nsIRunnable.h"
++#include "nsIWidget.h"
++#include "nsTArray.h"
++#include "nsUnicharUtils.h"
++
++#include "nsMenu.h"
++#include "nsNativeMenuAtoms.h"
++#include "nsNativeMenuService.h"
++
++#include <gdk/gdk.h>
++#include <gdk/gdkx.h>
++#include <glib.h>
++#include <glib-object.h>
++
++#include "nsMenuBar.h"
++
++using namespace mozilla;
++
++static bool
++ShouldHandleKeyEvent(dom::KeyboardEvent *aEvent)
++{
++    return !aEvent->DefaultPrevented() && aEvent->IsTrusted();
++}
++
++class nsMenuBarContentInsertedEvent : public Runnable
++{
++public:
++    nsMenuBarContentInsertedEvent(nsMenuBar *aMenuBar,
++                                  nsIContent *aChild,
++                                  nsIContent *aPrevSibling) :
++        Runnable("nsMenuBarContentInsertedEvent"),
++        mWeakMenuBar(aMenuBar),
++        mChild(aChild),
++        mPrevSibling(aPrevSibling) { }
++
++    NS_IMETHODIMP Run()
++    {
++        if (!mWeakMenuBar) {
++            return NS_OK;
++        }
++
++        static_cast<nsMenuBar *>(mWeakMenuBar.get())->HandleContentInserted(mChild,
++                                                                            mPrevSibling);
++        return NS_OK;
++    }
++
++private:
++    nsWeakMenuObject mWeakMenuBar;
++
++    nsCOMPtr<nsIContent> mChild;
++    nsCOMPtr<nsIContent> mPrevSibling;
++};
++
++class nsMenuBarContentRemovedEvent : public Runnable
++{
++public:
++    nsMenuBarContentRemovedEvent(nsMenuBar *aMenuBar,
++                                 nsIContent *aChild) :
++        Runnable("nsMenuBarContentRemovedEvent"),
++        mWeakMenuBar(aMenuBar),
++        mChild(aChild) { }
++
++    NS_IMETHODIMP Run()
++    {
++        if (!mWeakMenuBar) {
++            return NS_OK;
++        }
++
++        static_cast<nsMenuBar *>(mWeakMenuBar.get())->HandleContentRemoved(mChild);
++        return NS_OK;
++    }
++
++private:
++    nsWeakMenuObject mWeakMenuBar;
++
++    nsCOMPtr<nsIContent> mChild;
++};
++
++class nsMenuBar::DocEventListener final : public nsIDOMEventListener
++{
++public:
++    NS_DECL_ISUPPORTS
++    NS_DECL_NSIDOMEVENTLISTENER
++
++    DocEventListener(nsMenuBar *aOwner) : mOwner(aOwner) { };
++
++private:
++    ~DocEventListener() { };
++
++    nsMenuBar *mOwner;
++};
++
++NS_IMPL_ISUPPORTS(nsMenuBar::DocEventListener, nsIDOMEventListener)
++
++NS_IMETHODIMP
++nsMenuBar::DocEventListener::HandleEvent(dom::Event *aEvent)
++{
++    nsAutoString type;
++    aEvent->GetType(type);
++
++    if (type.Equals(NS_LITERAL_STRING("focus"))) {
++        mOwner->Focus();
++    } else if (type.Equals(NS_LITERAL_STRING("blur"))) {
++        mOwner->Blur();
++    }
++
++    RefPtr<dom::KeyboardEvent> keyEvent = aEvent->AsKeyboardEvent();
++    if (!keyEvent) {
++        return NS_OK;
++    }
++
++    if (type.Equals(NS_LITERAL_STRING("keypress"))) {
++        return mOwner->Keypress(keyEvent);
++    } else if (type.Equals(NS_LITERAL_STRING("keydown"))) {
++        return mOwner->KeyDown(keyEvent);
++    } else if (type.Equals(NS_LITERAL_STRING("keyup"))) {
++        return mOwner->KeyUp(keyEvent);
++    }
++
++    return NS_OK;
++}
++
++nsMenuBar::nsMenuBar(nsIContent *aMenuBarNode) :
++    nsMenuContainer(new nsNativeMenuDocListener(aMenuBarNode), aMenuBarNode),
++    mTopLevel(nullptr),
++    mServer(nullptr),
++    mIsActive(false)
++{
++    MOZ_COUNT_CTOR(nsMenuBar);
++}
++
++nsresult
++nsMenuBar::Init(nsIWidget *aParent)
++{
++    MOZ_ASSERT(aParent);
++
++    GdkWindow *gdkWin = static_cast<GdkWindow *>(
++        aParent->GetNativeData(NS_NATIVE_WINDOW));
++    if (!gdkWin) {
++        return NS_ERROR_FAILURE;
++    }
++
++    gpointer user_data = nullptr;
++    gdk_window_get_user_data(gdkWin, &user_data);
++    if (!user_data || !GTK_IS_CONTAINER(user_data)) {
++        return NS_ERROR_FAILURE;
++    }
++
++    mTopLevel = gtk_widget_get_toplevel(GTK_WIDGET(user_data));
++    if (!mTopLevel) {
++        return NS_ERROR_FAILURE;
++    }
++
++    g_object_ref(mTopLevel);
++
++    nsAutoCString path;
++    path.Append(NS_LITERAL_CSTRING("/com/canonical/menu/"));
++    char xid[10];
++    sprintf(xid, "%X", static_cast<uint32_t>(
++        GDK_WINDOW_XID(gtk_widget_get_window(mTopLevel))));
++    path.Append(xid);
++
++    mServer = dbusmenu_server_new(path.get());
++    if (!mServer) {
++        return NS_ERROR_FAILURE;
++    }
++
++    CreateNativeData();
++    if (!GetNativeData()) {
++        return NS_ERROR_FAILURE;
++    }
++
++    dbusmenu_server_set_root(mServer, GetNativeData());
++
++    mEventListener = new DocEventListener(this);
++
++    mDocument = do_QueryInterface(ContentNode()->OwnerDoc());
++
++    mAccessKey = Preferences::GetInt("ui.key.menuAccessKey");
++    if (mAccessKey == dom::KeyboardEventBinding::DOM_VK_SHIFT) {
++        mAccessKeyMask = eModifierShift;
++    } else if (mAccessKey == dom::KeyboardEventBinding::DOM_VK_CONTROL) {
++        mAccessKeyMask = eModifierCtrl;
++    } else if (mAccessKey == dom::KeyboardEventBinding::DOM_VK_ALT) {
++        mAccessKeyMask = eModifierAlt;
++    } else if (mAccessKey == dom::KeyboardEventBinding::DOM_VK_META) {
++        mAccessKeyMask = eModifierMeta;
++    } else {
++        mAccessKeyMask = eModifierAlt;
++    }
++
++    return NS_OK;
++}
++
++void
++nsMenuBar::Build()
++{
++    uint32_t count = ContentNode()->GetChildCount();
++    for (uint32_t i = 0; i < count; ++i) {
++        nsIContent *childContent = ContentNode()->GetChildAt_Deprecated(i);
++
++        UniquePtr<nsMenuObject> child = CreateChild(childContent);
++
++        if (!child) {
++            continue;
++        }
++
++        AppendChild(Move(child));
++    }
++}
++
++void
++nsMenuBar::DisconnectDocumentEventListeners()
++{
++    mDocument->RemoveEventListener(NS_LITERAL_STRING("focus"),
++                                   mEventListener,
++                                   true);
++    mDocument->RemoveEventListener(NS_LITERAL_STRING("blur"),
++                                   mEventListener,
++                                   true);
++    mDocument->RemoveEventListener(NS_LITERAL_STRING("keypress"),
++                                   mEventListener,
++                                   false);
++    mDocument->RemoveEventListener(NS_LITERAL_STRING("keydown"),
++                                   mEventListener,
++                                   false);
++    mDocument->RemoveEventListener(NS_LITERAL_STRING("keyup"),
++                                   mEventListener,
++                                   false);
++}
++
++void
++nsMenuBar::SetShellShowingMenuBar(bool aShowing)
++{
++    ContentNode()->OwnerDoc()->GetRootElement()->SetAttr(
++        kNameSpaceID_None, nsNativeMenuAtoms::shellshowingmenubar,
++        aShowing ? NS_LITERAL_STRING("true") : NS_LITERAL_STRING("false"),
++        true);
++}
++
++void
++nsMenuBar::Focus()
++{
++    ContentNode()->AsElement()->SetAttr(kNameSpaceID_None,
++                                        nsNativeMenuAtoms::openedwithkey,
++                                        NS_LITERAL_STRING("false"), true);
++}
++
++void
++nsMenuBar::Blur()
++{
++    // We do this here in case we lose focus before getting the
++    // keyup event, which leaves the menubar state looking like
++    // the alt key is stuck down
++    dbusmenu_server_set_status(mServer, DBUSMENU_STATUS_NORMAL);
++}
++
++nsMenuBar::ModifierFlags
++nsMenuBar::GetModifiersFromEvent(dom::KeyboardEvent *aEvent)
++{
++    ModifierFlags modifiers = static_cast<ModifierFlags>(0);
++
++    if (aEvent->AltKey()) {
++        modifiers = static_cast<ModifierFlags>(modifiers | eModifierAlt);
++    }
++
++    if (aEvent->ShiftKey()) {
++        modifiers = static_cast<ModifierFlags>(modifiers | eModifierShift);
++    }
++
++    if (aEvent->CtrlKey()) {
++        modifiers = static_cast<ModifierFlags>(modifiers | eModifierCtrl);
++    }
++
++    if (aEvent->MetaKey()) {
++        modifiers = static_cast<ModifierFlags>(modifiers | eModifierMeta);
++    }
++
++    return modifiers;
++}
++
++nsresult
++nsMenuBar::Keypress(dom::KeyboardEvent *aEvent)
++{
++    if (!ShouldHandleKeyEvent(aEvent)) {
++        return NS_OK;
++    }
++
++    ModifierFlags modifiers = GetModifiersFromEvent(aEvent);
++    if (((modifiers & mAccessKeyMask) == 0) ||
++        ((modifiers & ~mAccessKeyMask) != 0)) {
++        return NS_OK;
++    }
++
++    uint32_t charCode = aEvent->CharCode();
++    if (charCode == 0) {
++        return NS_OK;
++    }
++
++    char16_t ch = char16_t(charCode);
++    char16_t chl = ToLowerCase(ch);
++    char16_t chu = ToUpperCase(ch);
++
++    nsMenuObject *found = nullptr;
++    uint32_t count = ChildCount();
++    for (uint32_t i = 0; i < count; ++i) {
++        nsAutoString accesskey;
++        ChildAt(i)->ContentNode()->AsElement()->GetAttr(kNameSpaceID_None,
++                                                        nsGkAtoms::accesskey,
++                                                        accesskey);
++        const nsAutoString::char_type *key = accesskey.BeginReading();
++        if (*key == chu || *key == chl) {
++            found = ChildAt(i);
++            break;
++        }
++    }
++
++    if (!found || found->Type() != nsMenuObject::eType_Menu) {
++        return NS_OK;
++    }
++
++    ContentNode()->AsElement()->SetAttr(kNameSpaceID_None,
++                                        nsNativeMenuAtoms::openedwithkey,
++                                        NS_LITERAL_STRING("true"), true);
++    static_cast<nsMenu *>(found)->OpenMenu();
++
++    aEvent->StopPropagation();
++    aEvent->PreventDefault();
++
++    return NS_OK;
++}
++
++nsresult
++nsMenuBar::KeyDown(dom::KeyboardEvent *aEvent)
++{
++    if (!ShouldHandleKeyEvent(aEvent)) {
++        return NS_OK;
++    }
++
++    uint32_t keyCode = aEvent->KeyCode();
++    ModifierFlags modifiers = GetModifiersFromEvent(aEvent);
++    if ((keyCode != mAccessKey) || ((modifiers & ~mAccessKeyMask) != 0)) {
++        return NS_OK;
++    }
++
++    dbusmenu_server_set_status(mServer, DBUSMENU_STATUS_NOTICE);
++
++    return NS_OK;
++}
++
++nsresult
++nsMenuBar::KeyUp(dom::KeyboardEvent *aEvent)
++{
++    if (!ShouldHandleKeyEvent(aEvent)) {
++        return NS_OK;
++    }
++
++    uint32_t keyCode = aEvent->KeyCode();
++    if (keyCode == mAccessKey) {
++        dbusmenu_server_set_status(mServer, DBUSMENU_STATUS_NORMAL);
++    }
++
++    return NS_OK;
++}
++
++void
++nsMenuBar::HandleContentInserted(nsIContent *aChild, nsIContent *aPrevSibling)
++{
++    UniquePtr<nsMenuObject> child = CreateChild(aChild);
++
++    if (!child) {
++        return;
++    }
++
++    InsertChildAfter(Move(child), aPrevSibling);
++}
++
++void
++nsMenuBar::HandleContentRemoved(nsIContent *aChild)
++{
++    RemoveChild(aChild);
++}
++
++void
++nsMenuBar::OnContentInserted(nsIContent *aContainer, nsIContent *aChild,
++                             nsIContent *aPrevSibling)
++{
++    MOZ_ASSERT(aContainer == ContentNode(),
++               "Received an event that wasn't meant for us");
++
++    nsContentUtils::AddScriptRunner(
++        new nsMenuBarContentInsertedEvent(this, aChild, aPrevSibling));
++}
++
++void
++nsMenuBar::OnContentRemoved(nsIContent *aContainer, nsIContent *aChild)
++{
++    MOZ_ASSERT(aContainer == ContentNode(),
++               "Received an event that wasn't meant for us");
++
++    nsContentUtils::AddScriptRunner(
++        new nsMenuBarContentRemovedEvent(this, aChild));
++}
++
++nsMenuBar::~nsMenuBar()
++{
++    nsNativeMenuService *service = nsNativeMenuService::GetSingleton();
++    if (service) {
++        service->NotifyNativeMenuBarDestroyed(this);
++    }
++
++    if (ContentNode()) {
++        SetShellShowingMenuBar(false);
++    }
++
++    // We want to destroy all children before dropping our reference
++    // to the doc listener
++    while (ChildCount() > 0) {
++        RemoveChildAt(0);
++    }
++
++    if (mTopLevel) {
++        g_object_unref(mTopLevel);
++    }
++
++    if (DocListener()) {
++        DocListener()->Stop();
++    }
++
++    if (mDocument) {
++        DisconnectDocumentEventListeners();
++    }
++
++    if (mServer) {
++        g_object_unref(mServer);
++    }
++
++    MOZ_COUNT_DTOR(nsMenuBar);
++}
++
++/* static */ UniquePtr<nsMenuBar>
++nsMenuBar::Create(nsIWidget *aParent, nsIContent *aMenuBarNode)
++{
++    UniquePtr<nsMenuBar> menubar(new nsMenuBar(aMenuBarNode));
++    if (NS_FAILED(menubar->Init(aParent))) {
++        return nullptr;
++    }
++
++    return Move(menubar);
++}
++
++nsMenuObject::EType
++nsMenuBar::Type() const
++{
++    return eType_MenuBar;
++}
++
++bool
++nsMenuBar::IsBeingDisplayed() const
++{
++    return true;
++}
++
++uint32_t
++nsMenuBar::WindowId() const
++{
++    return static_cast<uint32_t>(GDK_WINDOW_XID(gtk_widget_get_window(mTopLevel)));
++}
++
++nsCString
++nsMenuBar::ObjectPath() const
++{
++    gchar *tmp;
++    g_object_get(mServer, DBUSMENU_SERVER_PROP_DBUS_OBJECT, &tmp, NULL);
++
++    nsCString result;
++    result.Adopt(tmp);
++
++    return result;
++}
++
++void
++nsMenuBar::Activate()
++{
++    if (mIsActive) {
++        return;
++    }
++
++    mIsActive = true;
++
++    mDocument->AddEventListener(NS_LITERAL_STRING("focus"),
++                                mEventListener,
++                                true);
++    mDocument->AddEventListener(NS_LITERAL_STRING("blur"),
++                                mEventListener,
++                                true);
++    mDocument->AddEventListener(NS_LITERAL_STRING("keypress"),
++                                mEventListener,
++                                false);
++    mDocument->AddEventListener(NS_LITERAL_STRING("keydown"),
++                                mEventListener,
++                                false);
++    mDocument->AddEventListener(NS_LITERAL_STRING("keyup"),
++                                mEventListener,
++                                false);
++
++    // Clear this. Not sure if we really need to though
++    ContentNode()->AsElement()->SetAttr(kNameSpaceID_None,
++                                        nsNativeMenuAtoms::openedwithkey,
++                                        NS_LITERAL_STRING("false"), true);
++
++    DocListener()->Start();
++    Build();
++    SetShellShowingMenuBar(true);
++}
++
++void
++nsMenuBar::Deactivate()
++{
++    if (!mIsActive) {
++        return;
++    }
++
++    mIsActive = false;
++
++    SetShellShowingMenuBar(false);
++    while (ChildCount() > 0) {
++        RemoveChildAt(0);
++    }
++    DocListener()->Stop();
++    DisconnectDocumentEventListeners();
++}
+diff --git a/widget/gtk/nsMenuBar.h b/widget/gtk/nsMenuBar.h
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsMenuBar.h
+@@ -0,0 +1,111 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* This Source Code Form is subject to the terms of the Mozilla Public
++ * License, v. 2.0. If a copy of the MPL was not distributed with this
++ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++
++#ifndef __nsMenuBar_h__
++#define __nsMenuBar_h__
++
++#include "mozilla/Attributes.h"
++#include "mozilla/UniquePtr.h"
++#include "nsCOMPtr.h"
++#include "nsString.h"
++
++#include "nsDbusmenu.h"
++#include "nsMenuContainer.h"
++#include "nsMenuObject.h"
++
++#include <gtk/gtk.h>
++
++class nsIContent;
++class nsIDocument;
++class nsIWidget;
++class nsMenuBarDocEventListener;
++
++namespace mozilla {
++namespace dom {
++class KeyboardEvent;
++}
++}
++
++/*
++ * The menubar class. There is one of these per window (and the window
++ * owns its menubar). Each menubar has an object path, and the service is
++ * responsible for telling the desktop shell which object path corresponds
++ * to a particular window. A menubar and its hierarchy also own a
++ * nsNativeMenuDocListener.
++ */
++class nsMenuBar final : public nsMenuContainer
++{
++public:
++    ~nsMenuBar() override;
++
++    static mozilla::UniquePtr<nsMenuBar> Create(nsIWidget *aParent,
++                                                nsIContent *aMenuBarNode);
++
++    nsMenuObject::EType Type() const override;
++
++    bool IsBeingDisplayed() const override;
++
++    // Get the native window ID for this menubar
++    uint32_t WindowId() const;
++
++    // Get the object path for this menubar
++    nsCString ObjectPath() const;
++
++    // Get the top-level GtkWindow handle
++    GtkWidget* TopLevelWindow() { return mTopLevel; }
++
++    // Called from the menuservice when the menubar is about to be registered.
++    // Causes the native menubar to be created, and the XUL menubar to be hidden
++    void Activate();
++
++    // Called from the menuservice when the menubar is no longer registered
++    // with the desktop shell. Will cause the XUL menubar to be shown again
++    void Deactivate();
++
++private:
++    class DocEventListener;
++    friend class nsMenuBarContentInsertedEvent;
++    friend class nsMenuBarContentRemovedEvent;
++
++    enum ModifierFlags {
++        eModifierShift = (1 << 0),
++        eModifierCtrl = (1 << 1),
++        eModifierAlt = (1 << 2),
++        eModifierMeta = (1 << 3)
++    };
++
++    nsMenuBar(nsIContent *aMenuBarNode);
++    nsresult Init(nsIWidget *aParent);
++    void Build();
++    void DisconnectDocumentEventListeners();
++    void SetShellShowingMenuBar(bool aShowing);
++    void Focus();
++    void Blur();
++    ModifierFlags GetModifiersFromEvent(mozilla::dom::KeyboardEvent *aEvent);
++    nsresult Keypress(mozilla::dom::KeyboardEvent *aEvent);
++    nsresult KeyDown(mozilla::dom::KeyboardEvent *aEvent);
++    nsresult KeyUp(mozilla::dom::KeyboardEvent *aEvent);
++
++    void HandleContentInserted(nsIContent *aChild,
++                               nsIContent *aPrevSibling);
++    void HandleContentRemoved(nsIContent *aChild);
++
++    void OnContentInserted(nsIContent *aContainer, nsIContent *aChild,
++                           nsIContent *aPrevSibling) override;
++    void OnContentRemoved(nsIContent *aContainer, nsIContent *aChild) override;
++
++    GtkWidget *mTopLevel;
++    DbusmenuServer *mServer;
++    nsCOMPtr<nsIDocument> mDocument;
++    RefPtr<DocEventListener> mEventListener;
++
++    uint32_t mAccessKey;
++    ModifierFlags mAccessKeyMask;
++    bool mIsActive;
++};
++
++#endif /* __nsMenuBar_h__ */
+diff --git a/widget/gtk/nsMenuContainer.cpp b/widget/gtk/nsMenuContainer.cpp
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsMenuContainer.cpp
+@@ -0,0 +1,171 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* 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 "mozilla/DebugOnly.h"
++#include "mozilla/Move.h"
++#include "nsGkAtoms.h"
++#include "nsIContent.h"
++
++#include "nsDbusmenu.h"
++#include "nsMenu.h"
++#include "nsMenuItem.h"
++#include "nsMenuSeparator.h"
++
++#include "nsMenuContainer.h"
++
++using namespace mozilla;
++
++const nsMenuContainer::ChildTArray::index_type nsMenuContainer::NoIndex = nsMenuContainer::ChildTArray::NoIndex;
++
++typedef UniquePtr<nsMenuObject> (*nsMenuObjectConstructor)(nsMenuContainer*,
++                                                           nsIContent*);
++
++template<class T>
++static UniquePtr<nsMenuObject> CreateMenuObject(nsMenuContainer *aContainer,
++                                                nsIContent *aContent)
++{
++    return UniquePtr<T>(new T(aContainer, aContent));
++}
++
++static nsMenuObjectConstructor
++GetMenuObjectConstructor(nsIContent *aContent)
++{
++    if (aContent->IsXULElement(nsGkAtoms::menuitem)) {
++        return CreateMenuObject<nsMenuItem>;
++    } else if (aContent->IsXULElement(nsGkAtoms::menu)) {
++        return CreateMenuObject<nsMenu>;
++    } else if (aContent->IsXULElement(nsGkAtoms::menuseparator)) {
++        return CreateMenuObject<nsMenuSeparator>;
++    }
++
++    return nullptr;
++}
++
++static bool
++ContentIsSupported(nsIContent *aContent)
++{
++    return GetMenuObjectConstructor(aContent) ? true : false;
++}
++
++nsMenuContainer::nsMenuContainer(nsMenuContainer *aParent,
++                                 nsIContent *aContent) :
++    nsMenuObject(aParent, aContent)
++{
++}
++
++nsMenuContainer::nsMenuContainer(nsNativeMenuDocListener *aListener,
++                                 nsIContent *aContent) :
++    nsMenuObject(aListener, aContent)
++{
++}
++
++UniquePtr<nsMenuObject>
++nsMenuContainer::CreateChild(nsIContent *aContent)
++{
++    nsMenuObjectConstructor ctor = GetMenuObjectConstructor(aContent);
++    if (!ctor) {
++        // There are plenty of node types we might stumble across that
++        // aren't supported
++        return nullptr;
++    }
++
++    UniquePtr<nsMenuObject> res = ctor(this, aContent);
++    return Move(res);
++}
++
++size_t
++nsMenuContainer::IndexOf(nsIContent *aChild) const
++{
++    if (!aChild) {
++        return NoIndex;
++    }
++
++    size_t count = ChildCount();
++    for (size_t i = 0; i < count; ++i) {
++        if (ChildAt(i)->ContentNode() == aChild) {
++            return i;
++        }
++    }
++
++    return NoIndex;
++}
++
++void
++nsMenuContainer::RemoveChildAt(size_t aIndex, bool aUpdateNative)
++{
++    MOZ_ASSERT(aIndex < ChildCount());
++
++    if (aUpdateNative) {
++        MOZ_ALWAYS_TRUE(
++            dbusmenu_menuitem_child_delete(GetNativeData(),
++                                           ChildAt(aIndex)->GetNativeData()));
++    }
++
++    mChildren.RemoveElementAt(aIndex);
++}
++
++void
++nsMenuContainer::RemoveChild(nsIContent *aChild, bool aUpdateNative)
++{
++    size_t index = IndexOf(aChild);
++    if (index == NoIndex) {
++        return;
++    }
++
++    RemoveChildAt(index, aUpdateNative);
++}
++
++void
++nsMenuContainer::InsertChildAfter(UniquePtr<nsMenuObject> aChild,
++                                  nsIContent *aPrevSibling,
++                                  bool aUpdateNative)
++{
++    size_t index = IndexOf(aPrevSibling);
++    MOZ_ASSERT(!aPrevSibling || index != NoIndex);
++
++    ++index;
++
++    if (aUpdateNative) {
++        aChild->CreateNativeData();
++        MOZ_ALWAYS_TRUE(
++            dbusmenu_menuitem_child_add_position(GetNativeData(),
++                                                 aChild->GetNativeData(),
++                                                 index));
++    }
++
++    MOZ_ALWAYS_TRUE(mChildren.InsertElementAt(index, Move(aChild)));
++}
++
++void
++nsMenuContainer::AppendChild(UniquePtr<nsMenuObject> aChild,
++                             bool aUpdateNative)
++{
++    if (aUpdateNative) {
++        aChild->CreateNativeData();
++        MOZ_ALWAYS_TRUE(
++            dbusmenu_menuitem_child_append(GetNativeData(),
++                                           aChild->GetNativeData()));
++    }
++
++    MOZ_ALWAYS_TRUE(mChildren.AppendElement(Move(aChild)));
++}
++
++bool
++nsMenuContainer::NeedsRebuild() const
++{
++    return false;
++}
++
++/* static */ nsIContent*
++nsMenuContainer::GetPreviousSupportedSibling(nsIContent *aContent)
++{
++    do {
++        aContent = aContent->GetPreviousSibling();
++    } while (aContent && !ContentIsSupported(aContent));
++
++    return aContent;
++}
+diff --git a/widget/gtk/nsMenuContainer.h b/widget/gtk/nsMenuContainer.h
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsMenuContainer.h
+@@ -0,0 +1,70 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* This Source Code Form is subject to the terms of the Mozilla Public
++ * License, v. 2.0. If a copy of the MPL was not distributed with this
++ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++
++#ifndef __nsMenuContainer_h__
++#define __nsMenuContainer_h__
++
++#include "mozilla/UniquePtr.h"
++#include "nsTArray.h"
++
++#include "nsMenuObject.h"
++
++class nsIContent;
++class nsNativeMenuDocListener;
++
++// Base class for containers (menus and menubars)
++class nsMenuContainer : public nsMenuObject
++{
++public:
++    typedef nsTArray<mozilla::UniquePtr<nsMenuObject> > ChildTArray;
++
++    // Determine if this container is being displayed on screen. Must be
++    // implemented by subclasses. Must return true if the container is
++    // in the fully open state, or false otherwise
++    virtual bool IsBeingDisplayed() const = 0;
++
++    // Determine if this container will be rebuilt the next time it opens.
++    // Returns false by default but can be overridden by subclasses
++    virtual bool NeedsRebuild() const;
++
++    // Return the first previous sibling that is of a type supported by the
++    // menu system
++    static nsIContent* GetPreviousSupportedSibling(nsIContent *aContent);
++
++    static const ChildTArray::index_type NoIndex;
++
++protected:
++    nsMenuContainer(nsMenuContainer *aParent, nsIContent *aContent);
++    nsMenuContainer(nsNativeMenuDocListener *aListener, nsIContent *aContent);
++
++    // Create a new child element for the specified content node
++    mozilla::UniquePtr<nsMenuObject> CreateChild(nsIContent *aContent);
++
++    // Return the index of the child for the specified content node
++    size_t IndexOf(nsIContent *aChild) const;
++
++    size_t ChildCount() const { return mChildren.Length(); }
++    nsMenuObject* ChildAt(size_t aIndex) const { return mChildren[aIndex].get(); }
++
++    void RemoveChildAt(size_t aIndex, bool aUpdateNative = true);
++
++    // Remove the child that owns the specified content node
++    void RemoveChild(nsIContent *aChild, bool aUpdateNative = true);
++
++    // Insert a new child after the child that owns the specified content node
++    void InsertChildAfter(mozilla::UniquePtr<nsMenuObject> aChild,
++                          nsIContent *aPrevSibling,
++                          bool aUpdateNative = true);
++
++    void AppendChild(mozilla::UniquePtr<nsMenuObject> aChild,
++                     bool aUpdateNative = true);
++
++private:
++    ChildTArray mChildren;
++};
++
++#endif /* __nsMenuContainer_h__ */
+diff --git a/widget/gtk/nsMenuItem.cpp b/widget/gtk/nsMenuItem.cpp
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsMenuItem.cpp
+@@ -0,0 +1,767 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* 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 "mozilla/ArrayUtils.h"
++#include "mozilla/Assertions.h"
++#include "mozilla/ComputedStyle.h"
++#include "mozilla/dom/Element.h"
++#include "mozilla/dom/KeyboardEventBinding.h"
++#include "mozilla/dom/XULCommandEvent.h"
++#include "mozilla/Move.h"
++#include "mozilla/Preferences.h"
++#include "mozilla/TextEvents.h"
++#include "nsAutoPtr.h"
++#include "nsContentUtils.h"
++#include "nsCRT.h"
++#include "nsGkAtoms.h"
++#include "nsGlobalWindowInner.h"
++#include "nsGtkUtils.h"
++#include "nsIContent.h"
++#include "nsIDocument.h"
++#include "nsIRunnable.h"
++#include "nsQueryObject.h"
++#include "nsReadableUtils.h"
++#include "nsString.h"
++#include "nsThreadUtils.h"
++
++#include "nsMenu.h"
++#include "nsMenuBar.h"
++#include "nsMenuContainer.h"
++#include "nsNativeMenuDocListener.h"
++
++#include <gdk/gdk.h>
++#include <gdk/gdkkeysyms.h>
++#if (MOZ_WIDGET_GTK == 3)
++#include <gdk/gdkkeysyms-compat.h>
++#endif
++#include <gdk/gdkx.h>
++#include <gtk/gtk.h>
++
++#include "nsMenuItem.h"
++
++using namespace mozilla;
++
++struct KeyCodeData {
++    const char* str;
++    size_t strlength;
++    uint32_t keycode;
++};
++
++static struct KeyCodeData gKeyCodes[] = {
++#define NS_DEFINE_VK(aDOMKeyName, aDOMKeyCode) \
++  { #aDOMKeyName, sizeof(#aDOMKeyName) - 1, aDOMKeyCode },
++#include "mozilla/VirtualKeyCodeList.h"
++#undef NS_DEFINE_VK
++  { nullptr, 0, 0 }
++};
++
++struct KeyPair {
++    uint32_t DOMKeyCode;
++    guint GDKKeyval;
++};
++
++//
++// Netscape keycodes are defined in widget/public/nsGUIEvent.h
++// GTK keycodes are defined in <gdk/gdkkeysyms.h>
++//
++static const KeyPair gKeyPairs[] = {
++    { NS_VK_CANCEL,     GDK_Cancel },
++    { NS_VK_BACK,       GDK_BackSpace },
++    { NS_VK_TAB,        GDK_Tab },
++    { NS_VK_TAB,        GDK_ISO_Left_Tab },
++    { NS_VK_CLEAR,      GDK_Clear },
++    { NS_VK_RETURN,     GDK_Return },
++    { NS_VK_SHIFT,      GDK_Shift_L },
++    { NS_VK_SHIFT,      GDK_Shift_R },
++    { NS_VK_SHIFT,      GDK_Shift_Lock },
++    { NS_VK_CONTROL,    GDK_Control_L },
++    { NS_VK_CONTROL,    GDK_Control_R },
++    { NS_VK_ALT,        GDK_Alt_L },
++    { NS_VK_ALT,        GDK_Alt_R },
++    { NS_VK_META,       GDK_Meta_L },
++    { NS_VK_META,       GDK_Meta_R },
++
++    // Assume that Super or Hyper is always mapped to physical Win key.
++    { NS_VK_WIN,        GDK_Super_L },
++    { NS_VK_WIN,        GDK_Super_R },
++    { NS_VK_WIN,        GDK_Hyper_L },
++    { NS_VK_WIN,        GDK_Hyper_R },
++
++    // GTK's AltGraph key is similar to Mac's Option (Alt) key.  However,
++    // unfortunately, browsers on Mac are using NS_VK_ALT for it even though
++    // it's really different from Alt key on Windows.
++    // On the other hand, GTK's AltGrapsh keys are really different from
++    // Alt key.  However, there is no AltGrapsh key on Windows.  On Windows,
++    // both Ctrl and Alt keys are pressed internally when AltGr key is pressed.
++    // For some languages' users, AltGraph key is important, so, web
++    // applications on such locale may want to know AltGraph key press.
++    // Therefore, we should map AltGr keycode for them only on GTK.
++    { NS_VK_ALTGR,      GDK_ISO_Level3_Shift },
++    { NS_VK_ALTGR,      GDK_ISO_Level5_Shift },
++    // We assume that Mode_switch is always used for level3 shift.
++    { NS_VK_ALTGR,      GDK_Mode_switch },
++
++    { NS_VK_PAUSE,      GDK_Pause },
++    { NS_VK_CAPS_LOCK,  GDK_Caps_Lock },
++    { NS_VK_KANA,       GDK_Kana_Lock },
++    { NS_VK_KANA,       GDK_Kana_Shift },
++    { NS_VK_HANGUL,     GDK_Hangul },
++    // { NS_VK_JUNJA,      GDK_XXX },
++    // { NS_VK_FINAL,      GDK_XXX },
++    { NS_VK_HANJA,      GDK_Hangul_Hanja },
++    { NS_VK_KANJI,      GDK_Kanji },
++    { NS_VK_ESCAPE,     GDK_Escape },
++    { NS_VK_CONVERT,    GDK_Henkan },
++    { NS_VK_NONCONVERT, GDK_Muhenkan },
++    // { NS_VK_ACCEPT,     GDK_XXX },
++    // { NS_VK_MODECHANGE, GDK_XXX },
++    { NS_VK_SPACE,      GDK_space },
++    { NS_VK_PAGE_UP,    GDK_Page_Up },
++    { NS_VK_PAGE_DOWN,  GDK_Page_Down },
++    { NS_VK_END,        GDK_End },
++    { NS_VK_HOME,       GDK_Home },
++    { NS_VK_LEFT,       GDK_Left },
++    { NS_VK_UP,         GDK_Up },
++    { NS_VK_RIGHT,      GDK_Right },
++    { NS_VK_DOWN,       GDK_Down },
++    { NS_VK_SELECT,     GDK_Select },
++    { NS_VK_PRINT,      GDK_Print },
++    { NS_VK_EXECUTE,    GDK_Execute },
++    { NS_VK_PRINTSCREEN, GDK_Print },
++    { NS_VK_INSERT,     GDK_Insert },
++    { NS_VK_DELETE,     GDK_Delete },
++    { NS_VK_HELP,       GDK_Help },
++
++    // keypad keys
++    { NS_VK_LEFT,       GDK_KP_Left },
++    { NS_VK_RIGHT,      GDK_KP_Right },
++    { NS_VK_UP,         GDK_KP_Up },
++    { NS_VK_DOWN,       GDK_KP_Down },
++    { NS_VK_PAGE_UP,    GDK_KP_Page_Up },
++    // Not sure what these are
++    //{ NS_VK_,       GDK_KP_Prior },
++    //{ NS_VK_,        GDK_KP_Next },
++    { NS_VK_CLEAR,      GDK_KP_Begin }, // Num-unlocked 5
++    { NS_VK_PAGE_DOWN,  GDK_KP_Page_Down },
++    { NS_VK_HOME,       GDK_KP_Home },
++    { NS_VK_END,        GDK_KP_End },
++    { NS_VK_INSERT,     GDK_KP_Insert },
++    { NS_VK_DELETE,     GDK_KP_Delete },
++    { NS_VK_RETURN,     GDK_KP_Enter },
++
++    { NS_VK_NUM_LOCK,   GDK_Num_Lock },
++    { NS_VK_SCROLL_LOCK,GDK_Scroll_Lock },
++
++    // Function keys
++    { NS_VK_F1,         GDK_F1 },
++    { NS_VK_F2,         GDK_F2 },
++    { NS_VK_F3,         GDK_F3 },
++    { NS_VK_F4,         GDK_F4 },
++    { NS_VK_F5,         GDK_F5 },
++    { NS_VK_F6,         GDK_F6 },
++    { NS_VK_F7,         GDK_F7 },
++    { NS_VK_F8,         GDK_F8 },
++    { NS_VK_F9,         GDK_F9 },
++    { NS_VK_F10,        GDK_F10 },
++    { NS_VK_F11,        GDK_F11 },
++    { NS_VK_F12,        GDK_F12 },
++    { NS_VK_F13,        GDK_F13 },
++    { NS_VK_F14,        GDK_F14 },
++    { NS_VK_F15,        GDK_F15 },
++    { NS_VK_F16,        GDK_F16 },
++    { NS_VK_F17,        GDK_F17 },
++    { NS_VK_F18,        GDK_F18 },
++    { NS_VK_F19,        GDK_F19 },
++    { NS_VK_F20,        GDK_F20 },
++    { NS_VK_F21,        GDK_F21 },
++    { NS_VK_F22,        GDK_F22 },
++    { NS_VK_F23,        GDK_F23 },
++    { NS_VK_F24,        GDK_F24 },
++
++    // context menu key, keysym 0xff67, typically keycode 117 on 105-key (Microsoft) 
++    // x86 keyboards, located between right 'Windows' key and right Ctrl key
++    { NS_VK_CONTEXT_MENU, GDK_Menu },
++    { NS_VK_SLEEP,      GDK_Sleep },
++
++    { NS_VK_ATTN,       GDK_3270_Attn },
++    { NS_VK_CRSEL,      GDK_3270_CursorSelect },
++    { NS_VK_EXSEL,      GDK_3270_ExSelect },
++    { NS_VK_EREOF,      GDK_3270_EraseEOF },
++    { NS_VK_PLAY,       GDK_3270_Play },
++    //{ NS_VK_ZOOM,       GDK_XXX },
++    { NS_VK_PA1,        GDK_3270_PA1 },
++};
++
++static guint
++ConvertGeckoKeyNameToGDKKeyval(nsAString& aKeyName)
++{
++    NS_ConvertUTF16toUTF8 keyName(aKeyName);
++    ToUpperCase(keyName); // We want case-insensitive comparison with data
++                          // stored as uppercase.
++
++    uint32_t keyCode = 0;
++
++    uint32_t keyNameLength = keyName.Length();
++    const char* keyNameStr = keyName.get();
++    for (uint16_t i = 0; i < ArrayLength(gKeyCodes); ++i) {
++        if (keyNameLength == gKeyCodes[i].strlength &&
++            !nsCRT::strcmp(gKeyCodes[i].str, keyNameStr)) {
++            keyCode = gKeyCodes[i].keycode;
++            break;
++        }
++    }
++
++    // First, try to handle alphanumeric input, not listed in nsKeycodes:
++    // most likely, more letters will be getting typed in than things in
++    // the key list, so we will look through these first.
++
++    if (keyCode >= NS_VK_A && keyCode <= NS_VK_Z) {
++        // gdk and DOM both use the ASCII codes for these keys.
++        return keyCode;
++    }
++
++    // numbers
++    if (keyCode >= NS_VK_0 && keyCode <= NS_VK_9) {
++        // gdk and DOM both use the ASCII codes for these keys.
++        return keyCode - NS_VK_0 + GDK_0;
++    }
++
++    switch (keyCode) {
++        // keys in numpad
++        case NS_VK_MULTIPLY:  return GDK_KP_Multiply;
++        case NS_VK_ADD:       return GDK_KP_Add;
++        case NS_VK_SEPARATOR: return GDK_KP_Separator;
++        case NS_VK_SUBTRACT:  return GDK_KP_Subtract;
++        case NS_VK_DECIMAL:   return GDK_KP_Decimal;
++        case NS_VK_DIVIDE:    return GDK_KP_Divide;
++        case NS_VK_NUMPAD0:   return GDK_KP_0;
++        case NS_VK_NUMPAD1:   return GDK_KP_1;
++        case NS_VK_NUMPAD2:   return GDK_KP_2;
++        case NS_VK_NUMPAD3:   return GDK_KP_3;
++        case NS_VK_NUMPAD4:   return GDK_KP_4;
++        case NS_VK_NUMPAD5:   return GDK_KP_5;
++        case NS_VK_NUMPAD6:   return GDK_KP_6;
++        case NS_VK_NUMPAD7:   return GDK_KP_7;
++        case NS_VK_NUMPAD8:   return GDK_KP_8;
++        case NS_VK_NUMPAD9:   return GDK_KP_9;
++        // other prinable keys
++        case NS_VK_SPACE:               return GDK_space;
++        case NS_VK_COLON:               return GDK_colon;
++        case NS_VK_SEMICOLON:           return GDK_semicolon;
++        case NS_VK_LESS_THAN:           return GDK_less;
++        case NS_VK_EQUALS:              return GDK_equal;
++        case NS_VK_GREATER_THAN:        return GDK_greater;
++        case NS_VK_QUESTION_MARK:       return GDK_question;
++        case NS_VK_AT:                  return GDK_at;
++        case NS_VK_CIRCUMFLEX:          return GDK_asciicircum;
++        case NS_VK_EXCLAMATION:         return GDK_exclam;
++        case NS_VK_DOUBLE_QUOTE:        return GDK_quotedbl;
++        case NS_VK_HASH:                return GDK_numbersign;
++        case NS_VK_DOLLAR:              return GDK_dollar;
++        case NS_VK_PERCENT:             return GDK_percent;
++        case NS_VK_AMPERSAND:           return GDK_ampersand;
++        case NS_VK_UNDERSCORE:          return GDK_underscore;
++        case NS_VK_OPEN_PAREN:          return GDK_parenleft;
++        case NS_VK_CLOSE_PAREN:         return GDK_parenright;
++        case NS_VK_ASTERISK:            return GDK_asterisk;
++        case NS_VK_PLUS:                return GDK_plus;
++        case NS_VK_PIPE:                return GDK_bar;
++        case NS_VK_HYPHEN_MINUS:        return GDK_minus;
++        case NS_VK_OPEN_CURLY_BRACKET:  return GDK_braceleft;
++        case NS_VK_CLOSE_CURLY_BRACKET: return GDK_braceright;
++        case NS_VK_TILDE:               return GDK_asciitilde;
++        case NS_VK_COMMA:               return GDK_comma;
++        case NS_VK_PERIOD:              return GDK_period;
++        case NS_VK_SLASH:               return GDK_slash;
++        case NS_VK_BACK_QUOTE:          return GDK_grave;
++        case NS_VK_OPEN_BRACKET:        return GDK_bracketleft;
++        case NS_VK_BACK_SLASH:          return GDK_backslash;
++        case NS_VK_CLOSE_BRACKET:       return GDK_bracketright;
++        case NS_VK_QUOTE:               return GDK_apostrophe;
++    }
++
++    // misc other things
++    for (uint32_t i = 0; i < ArrayLength(gKeyPairs); ++i) {
++        if (gKeyPairs[i].DOMKeyCode == keyCode) {
++            return gKeyPairs[i].GDKKeyval;
++        }
++    }
++
++    return 0;
++}
++
++class nsMenuItemUncheckSiblingsRunnable final : public Runnable
++{
++public:
++    NS_IMETHODIMP Run()
++    {
++        if (mMenuItem) {
++            static_cast<nsMenuItem *>(mMenuItem.get())->UncheckSiblings();
++        }
++        return NS_OK;
++    }
++
++    nsMenuItemUncheckSiblingsRunnable(nsMenuItem *aMenuItem) :
++        Runnable("nsMenuItemUncheckSiblingsRunnable"),
++        mMenuItem(aMenuItem) { };
++
++private:
++    nsWeakMenuObject mMenuItem;
++};
++
++bool
++nsMenuItem::IsCheckboxOrRadioItem() const
++{
++    return mType == eMenuItemType_Radio ||
++           mType == eMenuItemType_CheckBox;
++}
++
++/* static */ void
++nsMenuItem::item_activated_cb(DbusmenuMenuitem *menuitem,
++                              guint timestamp,
++                              gpointer user_data)
++{
++    nsMenuItem *item = static_cast<nsMenuItem *>(user_data);
++    item->Activate(timestamp);
++}
++
++void
++nsMenuItem::Activate(uint32_t aTimestamp)
++{
++    GdkWindow *window = gtk_widget_get_window(MenuBar()->TopLevelWindow());
++    gdk_x11_window_set_user_time(
++        window, std::min(aTimestamp, gdk_x11_get_server_time(window)));
++
++    // We do this to avoid mutating our view of the menu until
++    // after we have finished
++    nsNativeMenuDocListener::BlockUpdatesScope updatesBlocker;
++
++    if (!ContentNode()->AsElement()->AttrValueIs(kNameSpaceID_None,
++                                                 nsGkAtoms::autocheck,
++                                                 nsGkAtoms::_false,
++                                                 eCaseMatters) &&
++        (mType == eMenuItemType_CheckBox ||
++         (mType == eMenuItemType_Radio && !mIsChecked))) {
++        ContentNode()->AsElement()->SetAttr(kNameSpaceID_None,
++                                            nsGkAtoms::checked,
++                                            mIsChecked ?
++                                                NS_LITERAL_STRING("false")
++                                                : NS_LITERAL_STRING("true"),
++                                            true);
++    }
++
++    nsIDocument *doc = ContentNode()->OwnerDoc();
++    ErrorResult rv;
++    RefPtr<dom::Event> event =
++        doc->CreateEvent(NS_LITERAL_STRING("xulcommandevent"),
++                         dom::CallerType::System, rv);
++    if (!rv.Failed()) {
++        RefPtr<dom::XULCommandEvent> command = event->AsXULCommandEvent();
++        if (command) {
++            command->InitCommandEvent(NS_LITERAL_STRING("command"), true, true,
++                                      nsGlobalWindowInner::Cast(doc->GetInnerWindow()),
++                                      0, false, false, false, false, nullptr, 0, rv);
++            if (!rv.Failed()) {
++                event->SetTrusted(true);
++                ContentNode()->DispatchEvent(*event, rv);
++                if (rv.Failed()) {
++                    NS_WARNING("Failed to dispatch event");
++                    rv.SuppressException();
++                }
++            } else {
++                NS_WARNING("Failed to initialize command event");
++                rv.SuppressException();
++            }
++        }
++    } else {
++        NS_WARNING("CreateEvent failed");
++        rv.SuppressException();
++    }
++
++    // This kinda sucks, but Unity doesn't send a closed event
++    // after activating a menuitem
++    nsMenuObject *ancestor = Parent();
++    while (ancestor && ancestor->Type() == eType_Menu) {
++        static_cast<nsMenu *>(ancestor)->OnClose();
++        ancestor = ancestor->Parent();
++    }
++}
++
++void
++nsMenuItem::CopyAttrFromNodeIfExists(nsIContent *aContent, nsAtom *aAttribute)
++{
++    nsAutoString value;
++    if (aContent->AsElement()->GetAttr(kNameSpaceID_None, aAttribute, value)) {
++        ContentNode()->AsElement()->SetAttr(kNameSpaceID_None, aAttribute,
++                                            value, true);
++    }
++}
++
++void
++nsMenuItem::UpdateState()
++{
++    if (!IsCheckboxOrRadioItem()) {
++        return;
++    }
++
++    mIsChecked = ContentNode()->AsElement()->AttrValueIs(kNameSpaceID_None,
++                                                         nsGkAtoms::checked,
++                                                         nsGkAtoms::_true,
++                                                         eCaseMatters);
++    dbusmenu_menuitem_property_set_int(GetNativeData(),
++                                       DBUSMENU_MENUITEM_PROP_TOGGLE_STATE,
++                                       mIsChecked ?
++                                         DBUSMENU_MENUITEM_TOGGLE_STATE_CHECKED : 
++                                         DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED);
++}
++
++void
++nsMenuItem::UpdateTypeAndState()
++{
++    static mozilla::dom::Element::AttrValuesArray attrs[] =
++        { &nsGkAtoms::checkbox, &nsGkAtoms::radio, nullptr };
++    int32_t type = ContentNode()->AsElement()->FindAttrValueIn(kNameSpaceID_None,
++                                                               nsGkAtoms::type,
++                                                               attrs, eCaseMatters);
++
++    if (type >= 0 && type < 2) {
++        if (type == 0) {
++            dbusmenu_menuitem_property_set(GetNativeData(),
++                                           DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE,
++                                           DBUSMENU_MENUITEM_TOGGLE_CHECK);
++            mType = eMenuItemType_CheckBox;
++        } else if (type == 1) {
++            dbusmenu_menuitem_property_set(GetNativeData(),
++                                           DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE,
++                                           DBUSMENU_MENUITEM_TOGGLE_RADIO);
++            mType = eMenuItemType_Radio;
++        }
++
++        UpdateState();
++    } else {
++        dbusmenu_menuitem_property_remove(GetNativeData(),
++                                          DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE);
++        dbusmenu_menuitem_property_remove(GetNativeData(),
++                                          DBUSMENU_MENUITEM_PROP_TOGGLE_STATE);
++        mType = eMenuItemType_Normal;
++    }
++}
++
++void
++nsMenuItem::UpdateAccel()
++{
++    nsIDocument *doc = ContentNode()->GetUncomposedDoc();
++    if (doc) {
++        nsCOMPtr<nsIContent> oldKeyContent;
++        oldKeyContent.swap(mKeyContent);
++
++        nsAutoString key;
++        ContentNode()->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::key,
++                                            key);
++        if (!key.IsEmpty()) {
++            mKeyContent = doc->GetElementById(key);
++        }
++
++        if (mKeyContent != oldKeyContent) {
++            if (oldKeyContent) {
++                DocListener()->UnregisterForContentChanges(oldKeyContent);
++            }
++            if (mKeyContent) {
++                DocListener()->RegisterForContentChanges(mKeyContent, this);
++            }
++        }
++    }
++
++    if (!mKeyContent) {
++        dbusmenu_menuitem_property_remove(GetNativeData(),
++                                          DBUSMENU_MENUITEM_PROP_SHORTCUT);
++        return;
++    }
++
++    nsAutoString modifiers;
++    mKeyContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::modifiers,
++                                      modifiers);
++
++    uint32_t modifier = 0;
++
++    if (!modifiers.IsEmpty()) {
++        char* str = ToNewUTF8String(modifiers);
++        char *token = strtok(str, ", \t");
++        while(token) {
++            if (nsCRT::strcmp(token, "shift") == 0) {
++                modifier |= GDK_SHIFT_MASK;
++            } else if (nsCRT::strcmp(token, "alt") == 0) {
++                modifier |= GDK_MOD1_MASK;
++            } else if (nsCRT::strcmp(token, "meta") == 0) {
++                modifier |= GDK_META_MASK;
++            } else if (nsCRT::strcmp(token, "control") == 0) {
++                modifier |= GDK_CONTROL_MASK;
++            } else if (nsCRT::strcmp(token, "accel") == 0) {
++                int32_t accel = Preferences::GetInt("ui.key.accelKey");
++                if (accel == dom::KeyboardEventBinding::DOM_VK_META) {
++                    modifier |= GDK_META_MASK;
++                } else if (accel == dom::KeyboardEventBinding::DOM_VK_ALT) {
++                    modifier |= GDK_MOD1_MASK;
++                } else {
++                    modifier |= GDK_CONTROL_MASK;
++                }
++            }
++
++            token = strtok(nullptr, ", \t");
++        }
++
++        free(str);
++    }
++
++    nsAutoString keyStr;
++    mKeyContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::key,
++                                      keyStr);
++
++    guint key = 0;
++    if (!keyStr.IsEmpty()) {
++        key = gdk_unicode_to_keyval(*keyStr.BeginReading());
++    }
++
++    if (key == 0) {
++        mKeyContent->AsElement()->GetAttr(kNameSpaceID_None,
++                                          nsGkAtoms::keycode, keyStr);
++        if (!keyStr.IsEmpty()) {
++            key = ConvertGeckoKeyNameToGDKKeyval(keyStr);
++        }
++    }
++
++    if (key == 0) {
++        key = GDK_VoidSymbol;
++    }
++
++    if (key != GDK_VoidSymbol) {
++        dbusmenu_menuitem_property_set_shortcut(GetNativeData(), key,
++                                                static_cast<GdkModifierType>(modifier));
++    } else {
++        dbusmenu_menuitem_property_remove(GetNativeData(),
++                                          DBUSMENU_MENUITEM_PROP_SHORTCUT);
++    }
++}
++
++nsMenuBar*
++nsMenuItem::MenuBar()
++{
++    nsMenuObject *tmp = this;
++    while (tmp->Parent()) {
++        tmp = tmp->Parent();
++    }
++
++    MOZ_ASSERT(tmp->Type() == eType_MenuBar, "The top-level should be a menubar");
++
++    return static_cast<nsMenuBar *>(tmp);
++}
++
++void
++nsMenuItem::UncheckSiblings()
++{
++    if (!ContentNode()->AsElement()->AttrValueIs(kNameSpaceID_None,
++                                                 nsGkAtoms::type,
++                                                 nsGkAtoms::radio,
++                                                 eCaseMatters)) {
++        // If we're not a radio button, we don't care
++        return;
++    }
++
++    nsAutoString name;
++    ContentNode()->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::name,
++                                        name);
++
++    nsIContent *parent = ContentNode()->GetParent();
++    if (!parent) {
++        return;
++    }
++
++    uint32_t count = parent->GetChildCount();
++    for (uint32_t i = 0; i < count; ++i) {
++        nsIContent *sibling = parent->GetChildAt_Deprecated(i);
++
++        nsAutoString otherName;
++        sibling->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::name,
++                                      otherName);
++
++        if (sibling != ContentNode() && otherName == name && 
++            sibling->AsElement()->AttrValueIs(kNameSpaceID_None,
++                                              nsGkAtoms::type,
++                                              nsGkAtoms::radio,
++                                              eCaseMatters)) {
++            sibling->AsElement()->UnsetAttr(kNameSpaceID_None,
++                                            nsGkAtoms::checked, true);
++        }
++    }
++}
++
++void
++nsMenuItem::InitializeNativeData()
++{
++    g_signal_connect(G_OBJECT(GetNativeData()),
++                     DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
++                     G_CALLBACK(item_activated_cb), this);
++    mNeedsUpdate = true;
++}
++
++void
++nsMenuItem::UpdateContentAttributes()
++{
++    nsIDocument *doc = ContentNode()->GetUncomposedDoc();
++    if (!doc) {
++        return;
++    }
++
++    nsAutoString command;
++    ContentNode()->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::command,
++                                        command);
++    if (command.IsEmpty()) {
++        return;
++    }
++
++    nsCOMPtr<nsIContent> commandContent = doc->GetElementById(command);
++    if (!commandContent) {
++        return;
++    }
++
++    if (commandContent->AsElement()->AttrValueIs(kNameSpaceID_None,
++                                                 nsGkAtoms::disabled,
++                                                 nsGkAtoms::_true,
++                                                 eCaseMatters)) {
++        ContentNode()->AsElement()->SetAttr(kNameSpaceID_None,
++                                            nsGkAtoms::disabled,
++                                            NS_LITERAL_STRING("true"), true);
++    } else {
++        ContentNode()->AsElement()->UnsetAttr(kNameSpaceID_None,
++                                              nsGkAtoms::disabled, true);
++    }
++
++    CopyAttrFromNodeIfExists(commandContent, nsGkAtoms::checked);
++    CopyAttrFromNodeIfExists(commandContent, nsGkAtoms::accesskey);
++    CopyAttrFromNodeIfExists(commandContent, nsGkAtoms::label);
++    CopyAttrFromNodeIfExists(commandContent, nsGkAtoms::hidden);
++}
++
++void
++nsMenuItem::Update(ComputedStyle *aComputedStyle)
++{
++    if (mNeedsUpdate) {
++        mNeedsUpdate = false;
++
++        UpdateTypeAndState();
++        UpdateAccel();
++        UpdateLabel();
++        UpdateSensitivity();
++    }
++
++    UpdateVisibility(aComputedStyle);
++    UpdateIcon(aComputedStyle);
++}
++
++bool
++nsMenuItem::IsCompatibleWithNativeData(DbusmenuMenuitem *aNativeData) const
++{
++    return nsCRT::strcmp(dbusmenu_menuitem_property_get(aNativeData,
++                                                        DBUSMENU_MENUITEM_PROP_TYPE),
++                         "separator") != 0;
++}
++
++nsMenuObject::PropertyFlags
++nsMenuItem::SupportedProperties() const
++{
++    return static_cast<nsMenuObject::PropertyFlags>(
++        nsMenuObject::ePropLabel |
++        nsMenuObject::ePropEnabled |
++        nsMenuObject::ePropVisible |
++        nsMenuObject::ePropIconData |
++        nsMenuObject::ePropShortcut |
++        nsMenuObject::ePropToggleType |
++        nsMenuObject::ePropToggleState
++    );
++}
++
++void
++nsMenuItem::OnAttributeChanged(nsIContent *aContent, nsAtom *aAttribute)
++{
++    MOZ_ASSERT(aContent == ContentNode() || aContent == mKeyContent,
++               "Received an event that wasn't meant for us!");
++
++    if (aContent == ContentNode() && aAttribute == nsGkAtoms::checked &&
++        aContent->AsElement()->AttrValueIs(kNameSpaceID_None,
++                                           nsGkAtoms::checked,
++                                           nsGkAtoms::_true, eCaseMatters)) {
++        nsContentUtils::AddScriptRunner(
++            new nsMenuItemUncheckSiblingsRunnable(this));
++    }
++
++    if (mNeedsUpdate) {
++        return;
++    }
++
++    if (!Parent()->IsBeingDisplayed()) {
++        mNeedsUpdate = true;
++        return;
++    }
++
++    if (aContent == ContentNode()) {
++        if (aAttribute == nsGkAtoms::key) {
++            UpdateAccel();
++        } else if (aAttribute == nsGkAtoms::label ||
++                   aAttribute == nsGkAtoms::accesskey ||
++                   aAttribute == nsGkAtoms::crop) {
++            UpdateLabel();
++        } else if (aAttribute == nsGkAtoms::disabled) {
++            UpdateSensitivity();
++        } else if (aAttribute == nsGkAtoms::type) {
++            UpdateTypeAndState();
++        } else if (aAttribute == nsGkAtoms::checked) {
++            UpdateState();
++        } else if (aAttribute == nsGkAtoms::hidden ||
++                   aAttribute == nsGkAtoms::collapsed) {
++            RefPtr<ComputedStyle> style = GetComputedStyle();
++            UpdateVisibility(style);
++        } else if (aAttribute == nsGkAtoms::image) {
++            RefPtr<ComputedStyle> style = GetComputedStyle();
++            UpdateIcon(style);
++        }
++    } else if (aContent == mKeyContent &&
++               (aAttribute == nsGkAtoms::key ||
++                aAttribute == nsGkAtoms::keycode ||
++                aAttribute == nsGkAtoms::modifiers)) {
++        UpdateAccel();
++    }
++}
++
++nsMenuItem::nsMenuItem(nsMenuContainer *aParent, nsIContent *aContent) :
++    nsMenuObject(aParent, aContent),
++    mType(eMenuItemType_Normal),
++    mIsChecked(false),
++    mNeedsUpdate(false)
++{
++    MOZ_COUNT_CTOR(nsMenuItem);
++}
++
++nsMenuItem::~nsMenuItem()
++{
++    if (DocListener() && mKeyContent) {
++        DocListener()->UnregisterForContentChanges(mKeyContent);
++    }
++
++    if (GetNativeData()) {
++        g_signal_handlers_disconnect_by_func(GetNativeData(),
++                                             FuncToGpointer(item_activated_cb),
++                                             this);
++    }
++
++    MOZ_COUNT_DTOR(nsMenuItem);
++}
++
++nsMenuObject::EType
++nsMenuItem::Type() const
++{
++    return eType_MenuItem;
++}
+diff --git a/widget/gtk/nsMenuItem.h b/widget/gtk/nsMenuItem.h
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsMenuItem.h
+@@ -0,0 +1,80 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* This Source Code Form is subject to the terms of the Mozilla Public
++ * License, v. 2.0. If a copy of the MPL was not distributed with this
++ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++
++#ifndef __nsMenuItem_h__
++#define __nsMenuItem_h__
++
++#include "mozilla/Attributes.h"
++#include "nsCOMPtr.h"
++
++#include "nsDbusmenu.h"
++#include "nsMenuObject.h"
++
++#include <glib.h>
++
++class nsAtom;
++class nsIContent;
++class nsMenuBar;
++class nsMenuContainer;
++
++/*
++ * This class represents 3 main classes of menuitems: labels, checkboxes and
++ * radio buttons (with/without an icon)
++ */
++class nsMenuItem final : public nsMenuObject
++{
++public:
++    nsMenuItem(nsMenuContainer *aParent, nsIContent *aContent);
++    ~nsMenuItem() override;
++
++    nsMenuObject::EType Type() const override;
++
++private:
++    friend class nsMenuItemUncheckSiblingsRunnable;
++
++    enum {
++        eMenuItemFlag_ToggleState = (1 << 0)
++    };
++
++    enum EMenuItemType {
++        eMenuItemType_Normal,
++        eMenuItemType_Radio,
++        eMenuItemType_CheckBox
++    };
++
++    bool IsCheckboxOrRadioItem() const;
++
++    static void item_activated_cb(DbusmenuMenuitem *menuitem,
++                                  guint timestamp,
++                                  gpointer user_data);
++    void Activate(uint32_t aTimestamp);
++
++    void CopyAttrFromNodeIfExists(nsIContent *aContent, nsAtom *aAtom);
++    void UpdateState();
++    void UpdateTypeAndState();
++    void UpdateAccel();
++    nsMenuBar* MenuBar();
++    void UncheckSiblings();
++
++    void InitializeNativeData() override;
++    void UpdateContentAttributes() override;
++    void Update(mozilla::ComputedStyle *aComputedStyle) override;
++    bool IsCompatibleWithNativeData(DbusmenuMenuitem *aNativeData) const override;
++    nsMenuObject::PropertyFlags SupportedProperties() const override;
++
++    void OnAttributeChanged(nsIContent *aContent, nsAtom *aAttribute) override;
++
++    EMenuItemType mType;
++
++    bool mIsChecked;
++
++    bool mNeedsUpdate;
++
++    nsCOMPtr<nsIContent> mKeyContent;
++};
++
++#endif /* __nsMenuItem_h__ */
+diff --git a/widget/gtk/nsMenuObject.cpp b/widget/gtk/nsMenuObject.cpp
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsMenuObject.cpp
+@@ -0,0 +1,664 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* 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 "ImageOps.h"
++#include "imgIContainer.h"
++#include "imgINotificationObserver.h"
++#include "imgLoader.h"
++#include "imgRequestProxy.h"
++#include "mozilla/ArrayUtils.h"
++#include "mozilla/Assertions.h"
++#include "mozilla/ComputedStyle.h"
++#include "mozilla/dom/Element.h"
++#include "mozilla/Preferences.h"
++#include "nsAttrValue.h"
++#include "nsComputedDOMStyle.h"
++#include "nsContentUtils.h"
++#include "nsGkAtoms.h"
++#include "nsIContent.h"
++#include "nsIContentPolicy.h"
++#include "nsIDocument.h"
++#include "nsILoadGroup.h"
++#include "nsImageToPixbuf.h"
++#include "nsIPresShell.h"
++#include "nsIURI.h"
++#include "nsNetUtil.h"
++#include "nsPresContext.h"
++#include "nsRect.h"
++#include "nsServiceManagerUtils.h"
++#include "nsString.h"
++#include "nsStyleConsts.h"
++#include "nsStyleStruct.h"
++#include "nsUnicharUtils.h"
++
++#include "nsMenuContainer.h"
++#include "nsNativeMenuAtoms.h"
++#include "nsNativeMenuDocListener.h"
++
++#include <gdk/gdk.h>
++#include <glib-object.h>
++#include <pango/pango.h>
++
++#include "nsMenuObject.h"
++
++// X11's None clashes with StyleDisplay::None
++#include "X11UndefineNone.h"
++
++#undef None
++
++using namespace mozilla;
++using mozilla::image::ImageOps;
++
++#define MAX_WIDTH 350000
++
++const char *gPropertyStrings[] = {
++#define DBUSMENU_PROPERTY(e, s, b) s,
++    DBUSMENU_PROPERTIES
++#undef DBUSMENU_PROPERTY
++    nullptr
++};
++
++nsWeakMenuObject* nsWeakMenuObject::sHead;
++PangoLayout* gPangoLayout = nullptr;
++
++class nsMenuObjectIconLoader final : public imgINotificationObserver
++{
++public:
++    NS_DECL_ISUPPORTS
++    NS_DECL_IMGINOTIFICATIONOBSERVER
++
++    nsMenuObjectIconLoader(nsMenuObject *aOwner) : mOwner(aOwner) { };
++
++    void LoadIcon(ComputedStyle *aComputedStyle);
++    void Destroy();
++
++private:
++    ~nsMenuObjectIconLoader() { };
++
++    nsMenuObject *mOwner;
++    RefPtr<imgRequestProxy> mImageRequest;
++    nsCOMPtr<nsIURI> mURI;
++    nsIntRect mImageRect;
++};
++
++NS_IMPL_ISUPPORTS(nsMenuObjectIconLoader, imgINotificationObserver)
++
++NS_IMETHODIMP
++nsMenuObjectIconLoader::Notify(imgIRequest *aProxy,
++                               int32_t aType, const nsIntRect *aRect)
++{
++    if (!mOwner) {
++        return NS_OK;
++    }
++
++    if (aProxy != mImageRequest) {
++        return NS_ERROR_FAILURE;
++    }
++
++    if (aType == imgINotificationObserver::LOAD_COMPLETE) {
++        uint32_t status = imgIRequest::STATUS_ERROR;
++        if (NS_FAILED(mImageRequest->GetImageStatus(&status)) ||
++            (status & imgIRequest::STATUS_ERROR)) {
++            mImageRequest->Cancel(NS_BINDING_ABORTED);
++            mImageRequest = nullptr;
++            return NS_ERROR_FAILURE;
++        }
++
++        nsCOMPtr<imgIContainer> image;
++        mImageRequest->GetImage(getter_AddRefs(image));
++        MOZ_ASSERT(image);
++
++        // Ask the image to decode at its intrinsic size.
++        int32_t width = 0, height = 0;
++        image->GetWidth(&width);
++        image->GetHeight(&height);
++        image->RequestDecodeForSize(nsIntSize(width, height), imgIContainer::FLAG_NONE);
++        return NS_OK;
++    }
++
++    if (aType == imgINotificationObserver::DECODE_COMPLETE) {
++        mImageRequest->Cancel(NS_BINDING_ABORTED);
++        mImageRequest = nullptr;
++        return NS_OK;
++    }
++
++    if (aType != imgINotificationObserver::FRAME_COMPLETE) {
++        return NS_OK;
++    }
++
++    nsCOMPtr<imgIContainer> img;
++    mImageRequest->GetImage(getter_AddRefs(img));
++    if (!img) {
++        return NS_ERROR_FAILURE;
++    }
++
++    if (!mImageRect.IsEmpty()) {
++        img = ImageOps::Clip(img, mImageRect);
++    }
++
++    int32_t width, height;
++    img->GetWidth(&width);
++    img->GetHeight(&height);
++
++    if (width <= 0 || height <= 0) {
++        mOwner->ClearIcon();
++        return NS_OK;
++    }
++
++    if (width > 100 || height > 100) {
++        // The icon data needs to go across DBus. Make sure the icon
++        // data isn't too large, else our connection gets terminated and
++        // GDbus helpfully aborts the application. Thank you :)
++        NS_WARNING("Icon data too large");
++        mOwner->ClearIcon();
++        return NS_OK;
++    }
++
++    GdkPixbuf *pixbuf = nsImageToPixbuf::ImageToPixbuf(img);
++    if (pixbuf) {
++        dbusmenu_menuitem_property_set_image(mOwner->GetNativeData(),
++                                             DBUSMENU_MENUITEM_PROP_ICON_DATA,
++                                             pixbuf);
++        g_object_unref(pixbuf);
++    }
++
++    return NS_OK;
++}
++
++void
++nsMenuObjectIconLoader::LoadIcon(ComputedStyle *aComputedStyle)
++{
++    nsIDocument *doc = mOwner->ContentNode()->OwnerDoc();
++
++    nsCOMPtr<nsIURI> uri;
++    nsIntRect imageRect;
++    imgRequestProxy *imageRequest = nullptr;
++
++    nsAutoString uriString;
++    if (mOwner->ContentNode()->AsElement()->GetAttr(kNameSpaceID_None,
++                                                    nsGkAtoms::image,
++                                                    uriString)) {
++        NS_NewURI(getter_AddRefs(uri), uriString);
++    } else {
++        nsIPresShell *shell = doc->GetShell();
++        if (!shell) {
++            return;
++        }
++
++        nsPresContext *pc = shell->GetPresContext();
++        if (!pc || !aComputedStyle) {
++            return;
++        }
++
++        const nsStyleList *list = aComputedStyle->StyleList();
++        imageRequest = list->GetListStyleImage();
++        if (imageRequest) {
++            imageRequest->GetURI(getter_AddRefs(uri));
++            imageRect = list->mImageRegion.ToNearestPixels(
++                            pc->AppUnitsPerDevPixel());
++        }
++    }
++
++    if (!uri) {
++        mOwner->ClearIcon();
++        mURI = nullptr;
++
++        if (mImageRequest) {
++            mImageRequest->Cancel(NS_BINDING_ABORTED);
++            mImageRequest = nullptr;
++        }
++
++        return;
++    }
++
++    bool same;
++    if (mURI && NS_SUCCEEDED(mURI->Equals(uri, &same)) && same && 
++        (!imageRequest || imageRect == mImageRect)) {
++        return;
++    }
++
++    if (mImageRequest) {
++        mImageRequest->Cancel(NS_BINDING_ABORTED);
++        mImageRequest = nullptr;
++    }
++
++    mURI = uri;
++
++    if (imageRequest) {
++        mImageRect = imageRect;
++        imageRequest->Clone(this, nullptr, getter_AddRefs(mImageRequest));
++    } else {
++        mImageRect.SetEmpty();
++        nsCOMPtr<nsILoadGroup> loadGroup = doc->GetDocumentLoadGroup();
++        RefPtr<imgLoader> loader =
++            nsContentUtils::GetImgLoaderForDocument(doc);
++        if (!loader || !loadGroup) {
++            NS_WARNING("Failed to get loader or load group for image load");
++            return;
++        }
++
++        loader->LoadImage(uri, nullptr, nullptr, mozilla::net::RP_Unset,
++                          nullptr, 0, loadGroup, this, nullptr, nullptr,
++                          nsIRequest::LOAD_NORMAL, nullptr,
++                          nsIContentPolicy::TYPE_IMAGE, EmptyString(),
++                          false, getter_AddRefs(mImageRequest));
++    }
++}
++
++void
++nsMenuObjectIconLoader::Destroy()
++{
++    if (mImageRequest) {
++        mImageRequest->CancelAndForgetObserver(NS_BINDING_ABORTED);
++        mImageRequest = nullptr;
++    }
++
++    mOwner = nullptr;
++}
++
++static int
++CalculateTextWidth(const nsAString& aText)
++{
++    if (!gPangoLayout) {
++        PangoFontMap *fontmap = pango_cairo_font_map_get_default();
++        PangoContext *ctx = pango_font_map_create_context(fontmap);
++        gPangoLayout = pango_layout_new(ctx);
++        g_object_unref(ctx);
++    }
++
++    pango_layout_set_text(gPangoLayout, NS_ConvertUTF16toUTF8(aText).get(), -1);
++
++    int width, dummy;
++    pango_layout_get_size(gPangoLayout, &width, &dummy);
++
++    return width;
++}
++
++static const nsDependentString
++GetEllipsis()
++{
++    static char16_t sBuf[4] = { 0, 0, 0, 0 };
++    if (!sBuf[0]) {
++        nsString ellipsis;
++        Preferences::GetLocalizedString("intl.ellipsis", ellipsis);
++        if (!ellipsis.IsEmpty()) {
++            uint32_t l = ellipsis.Length();
++            const nsString::char_type *c = ellipsis.BeginReading();
++            uint32_t i = 0;
++            while (i < 3 && i < l) {
++                sBuf[i++] = *(c++);
++            }
++        } else {
++            sBuf[0] = '.';
++            sBuf[1] = '.';
++            sBuf[2] = '.';
++        }
++    }
++
++    return nsDependentString(sBuf);
++}
++
++static int
++GetEllipsisWidth()
++{
++    static int sEllipsisWidth = -1;
++
++    if (sEllipsisWidth == -1) {
++        sEllipsisWidth = CalculateTextWidth(GetEllipsis());
++    }
++
++    return sEllipsisWidth;
++}
++
++nsMenuObject::nsMenuObject(nsMenuContainer *aParent, nsIContent *aContent) :
++    mContent(aContent),
++    mListener(aParent->DocListener()),
++    mParent(aParent),
++    mNativeData(nullptr)
++{
++    MOZ_ASSERT(mContent);
++    MOZ_ASSERT(mListener);
++    MOZ_ASSERT(mParent);
++}
++
++nsMenuObject::nsMenuObject(nsNativeMenuDocListener *aListener,
++                           nsIContent *aContent) :
++    mContent(aContent),
++    mListener(aListener),
++    mParent(nullptr),
++    mNativeData(nullptr)
++{
++    MOZ_ASSERT(mContent);
++    MOZ_ASSERT(mListener);
++}
++
++void
++nsMenuObject::UpdateLabel()
++{
++    // Gecko stores the label and access key in separate attributes
++    // so we need to convert label="Foo_Bar"/accesskey="F" in to
++    // label="_Foo__Bar" for dbusmenu
++
++    nsAutoString label;
++    mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::label, label);
++
++    nsAutoString accesskey;
++    mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey,
++                                   accesskey);
++
++    const nsAutoString::char_type *akey = accesskey.BeginReading();
++    char16_t keyLower = ToLowerCase(*akey);
++    char16_t keyUpper = ToUpperCase(*akey);
++
++    const nsAutoString::char_type *iter = label.BeginReading();
++    const nsAutoString::char_type *end = label.EndReading();
++    uint32_t length = label.Length();
++    uint32_t pos = 0;
++    bool foundAccessKey = false;
++
++    while (iter != end) {
++        if (*iter != char16_t('_')) {
++            if ((*iter != keyLower && *iter != keyUpper) || foundAccessKey) {
++                ++iter;
++                ++pos;
++                continue;
++            }
++            foundAccessKey = true;
++        }
++
++        label.SetLength(++length);
++
++        iter = label.BeginReading() + pos;
++        end = label.EndReading();
++        nsAutoString::char_type *cur = label.BeginWriting() + pos;
++
++        memmove(cur + 1, cur, (length - 1 - pos) * sizeof(nsAutoString::char_type));
++        *cur = nsAutoString::char_type('_');
++
++        iter += 2;
++        pos += 2;
++    }
++
++    if (CalculateTextWidth(label) <= MAX_WIDTH) {
++        dbusmenu_menuitem_property_set(mNativeData,
++                                       DBUSMENU_MENUITEM_PROP_LABEL,
++                                       NS_ConvertUTF16toUTF8(label).get());
++        return;
++    }
++
++    // This sucks.
++    // This should be done at the point where the menu is drawn (hello Unity),
++    // but unfortunately it doesn't do that and will happily fill your entire
++    // screen width with a menu if you have a bookmark with a really long title.
++    // This leaves us with no other option but to ellipsize here, with no proper
++    // knowledge of Unity's render path, font size etc. This is better than nothing
++    nsAutoString truncated;
++    int target = MAX_WIDTH - GetEllipsisWidth();
++    length = label.Length();
++
++    static mozilla::dom::Element::AttrValuesArray strings[] = {
++        &nsGkAtoms::left, &nsGkAtoms::start,
++        &nsGkAtoms::center, &nsGkAtoms::right,
++        &nsGkAtoms::end, nullptr
++    };
++
++    int32_t type = mContent->AsElement()->FindAttrValueIn(kNameSpaceID_None,
++                                                          nsGkAtoms::crop,
++                                                          strings, eCaseMatters);
++
++    switch (type) {
++        case 0:
++        case 1:
++            // FIXME: Implement left cropping
++        case 2:
++            // FIXME: Implement center cropping
++        case 3:
++        case 4:
++        default:
++            for (uint32_t i = 0; i < length; i++) {
++                truncated.Append(label.CharAt(i));
++                if (CalculateTextWidth(truncated) > target) {
++                    break;
++                }
++            }
++
++            truncated.Append(GetEllipsis());
++    }
++
++    dbusmenu_menuitem_property_set(mNativeData,
++                                   DBUSMENU_MENUITEM_PROP_LABEL,
++                                   NS_ConvertUTF16toUTF8(truncated).get());
++}
++
++void
++nsMenuObject::UpdateVisibility(ComputedStyle *aComputedStyle)
++{
++    bool vis = true;
++
++    if (aComputedStyle &&
++        (aComputedStyle->StyleDisplay()->mDisplay == StyleDisplay::None ||
++         aComputedStyle->StyleVisibility()->mVisible ==
++            NS_STYLE_VISIBILITY_COLLAPSE)) {
++        vis = false;
++    }
++
++    dbusmenu_menuitem_property_set_bool(mNativeData,
++                                        DBUSMENU_MENUITEM_PROP_VISIBLE,
++                                        vis);
++}
++
++void
++nsMenuObject::UpdateSensitivity()
++{
++    bool disabled = mContent->AsElement()->AttrValueIs(kNameSpaceID_None,
++                                                       nsGkAtoms::disabled,
++                                                       nsGkAtoms::_true,
++                                                       eCaseMatters);
++
++    dbusmenu_menuitem_property_set_bool(mNativeData,
++                                        DBUSMENU_MENUITEM_PROP_ENABLED,
++                                        !disabled);
++
++}
++
++void
++nsMenuObject::UpdateIcon(ComputedStyle *aComputedStyle)
++{
++    if (ShouldShowIcon()) {
++        if (!mIconLoader) {
++            mIconLoader = new nsMenuObjectIconLoader(this);
++        }
++
++        mIconLoader->LoadIcon(aComputedStyle);
++    } else {
++        if (mIconLoader) {
++            mIconLoader->Destroy();
++            mIconLoader = nullptr;
++        }
++
++        ClearIcon();
++    }
++}
++
++already_AddRefed<ComputedStyle>
++nsMenuObject::GetComputedStyle()
++{
++    RefPtr<ComputedStyle> style =
++        nsComputedDOMStyle::GetComputedStyleNoFlush(
++            mContent->AsElement(), nullptr);
++
++    return style.forget();
++}
++
++void
++nsMenuObject::InitializeNativeData()
++{
++}
++
++nsMenuObject::PropertyFlags
++nsMenuObject::SupportedProperties() const
++{
++    return static_cast<nsMenuObject::PropertyFlags>(0);
++}
++
++bool
++nsMenuObject::IsCompatibleWithNativeData(DbusmenuMenuitem *aNativeData) const
++{
++    return true;
++}
++
++void
++nsMenuObject::UpdateContentAttributes()
++{
++}
++
++void
++nsMenuObject::Update(ComputedStyle *aComputedStyle)
++{
++}
++
++bool
++nsMenuObject::ShouldShowIcon() const
++{
++    // Ideally we want to know the visibility of the anonymous XUL image in
++    // our menuitem, but this isn't created because we don't have a frame.
++    // The following works by default (because xul.css hides images in menuitems
++    // that don't have the "menuitem-with-favicon" class). It's possible a third
++    // party theme could override this, but, oh well...
++    const nsAttrValue *classes = mContent->AsElement()->GetClasses();
++    if (!classes) {
++        return false;
++    }
++
++    for (uint32_t i = 0; i < classes->GetAtomCount(); ++i) {
++        if (classes->AtomAt(i) == nsNativeMenuAtoms::menuitem_with_favicon) {
++            return true;
++        }
++    }
++
++    return false;
++}
++
++void
++nsMenuObject::ClearIcon()
++{
++    dbusmenu_menuitem_property_remove(mNativeData,
++                                      DBUSMENU_MENUITEM_PROP_ICON_DATA);
++}
++
++nsMenuObject::~nsMenuObject()
++{
++    nsWeakMenuObject::NotifyDestroyed(this);
++
++    if (mIconLoader) {
++        mIconLoader->Destroy();
++    }
++
++    if (mListener) {
++        mListener->UnregisterForContentChanges(mContent);
++    }
++
++    if (mNativeData) {
++        g_object_unref(mNativeData);
++        mNativeData = nullptr;
++    }
++}
++
++void
++nsMenuObject::CreateNativeData()
++{
++    MOZ_ASSERT(mNativeData == nullptr, "This node already has a DbusmenuMenuitem. The old one will be leaked");
++
++    mNativeData = dbusmenu_menuitem_new();
++    InitializeNativeData();
++    if (mParent && mParent->IsBeingDisplayed()) {
++        ContainerIsOpening();
++    }
++
++    mListener->RegisterForContentChanges(mContent, this);
++}
++
++nsresult
++nsMenuObject::AdoptNativeData(DbusmenuMenuitem *aNativeData)
++{
++    MOZ_ASSERT(mNativeData == nullptr, "This node already has a DbusmenuMenuitem. The old one will be leaked");
++
++    if (!IsCompatibleWithNativeData(aNativeData)) {
++        return NS_ERROR_FAILURE;
++    }
++
++    mNativeData = aNativeData;
++    g_object_ref(mNativeData);
++
++    PropertyFlags supported = SupportedProperties();
++    PropertyFlags mask = static_cast<PropertyFlags>(1);
++
++    for (uint32_t i = 0; gPropertyStrings[i]; ++i) {
++        if (!(mask & supported)) {
++            dbusmenu_menuitem_property_remove(mNativeData, gPropertyStrings[i]);
++        }
++        mask = static_cast<PropertyFlags>(mask << 1);
++    }
++
++    InitializeNativeData();
++    if (mParent && mParent->IsBeingDisplayed()) {
++        ContainerIsOpening();
++    }
++
++    mListener->RegisterForContentChanges(mContent, this);
++
++    return NS_OK;
++}
++
++void
++nsMenuObject::ContainerIsOpening()
++{
++    MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
++
++    UpdateContentAttributes();
++
++    RefPtr<ComputedStyle> style = GetComputedStyle();
++    Update(style);
++}
++
++/* static */ void
++nsWeakMenuObject::AddWeakReference(nsWeakMenuObject *aWeak)
++{
++    aWeak->mPrev = sHead;
++    sHead = aWeak;
++}
++
++/* static */ void
++nsWeakMenuObject::RemoveWeakReference(nsWeakMenuObject *aWeak)
++{
++    if (aWeak == sHead) {
++        sHead = aWeak->mPrev;
++        return;
++    }
++
++    nsWeakMenuObject *weak = sHead;
++    while (weak && weak->mPrev != aWeak) {
++        weak = weak->mPrev;
++    }
++
++    if (weak) {
++        weak->mPrev = aWeak->mPrev;
++    }
++}
++
++/* static */ void
++nsWeakMenuObject::NotifyDestroyed(nsMenuObject *aMenuObject)
++{
++    nsWeakMenuObject *weak = sHead;
++    while (weak) {
++        if (weak->mMenuObject == aMenuObject) {
++            weak->mMenuObject = nullptr;
++        }
++
++        weak = weak->mPrev;
++    }
++}
+diff --git a/widget/gtk/nsMenuObject.h b/widget/gtk/nsMenuObject.h
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsMenuObject.h
+@@ -0,0 +1,172 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* This Source Code Form is subject to the terms of the Mozilla Public
++ * License, v. 2.0. If a copy of the MPL was not distributed with this
++ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++
++#ifndef __nsMenuObject_h__
++#define __nsMenuObject_h__
++
++#include "mozilla/Attributes.h"
++#include "nsCOMPtr.h"
++
++#include "nsDbusmenu.h"
++#include "nsNativeMenuDocListener.h"
++
++namespace mozilla {
++class ComputedStyle;
++}
++
++class nsIContent;
++class nsMenuContainer;
++class nsMenuObjectIconLoader;
++
++#define DBUSMENU_PROPERTIES \
++    DBUSMENU_PROPERTY(Label, DBUSMENU_MENUITEM_PROP_LABEL, 0) \
++    DBUSMENU_PROPERTY(Enabled, DBUSMENU_MENUITEM_PROP_ENABLED, 1) \
++    DBUSMENU_PROPERTY(Visible, DBUSMENU_MENUITEM_PROP_VISIBLE, 2) \
++    DBUSMENU_PROPERTY(IconData, DBUSMENU_MENUITEM_PROP_ICON_DATA, 3) \
++    DBUSMENU_PROPERTY(Type, DBUSMENU_MENUITEM_PROP_TYPE, 4) \
++    DBUSMENU_PROPERTY(Shortcut, DBUSMENU_MENUITEM_PROP_SHORTCUT, 5) \
++    DBUSMENU_PROPERTY(ToggleType, DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE, 6) \
++    DBUSMENU_PROPERTY(ToggleState, DBUSMENU_MENUITEM_PROP_TOGGLE_STATE, 7) \
++    DBUSMENU_PROPERTY(ChildDisplay, DBUSMENU_MENUITEM_PROP_CHILD_DISPLAY, 8)
++
++/*
++ * This is the base class for all menu nodes. Each instance represents
++ * a single node in the menu hierarchy. It wraps the corresponding DOM node and
++ * native menu node, keeps them in sync and transfers events between the two.
++ * It is not reference counted - each node is owned by its parent (the top
++ * level menubar is owned by the window) and keeps a weak pointer to its
++ * parent (which is guaranteed to always be valid because a node will never
++ * outlive its parent). It is not safe to keep a reference to nsMenuObject
++ * externally.
++ */
++class nsMenuObject : public nsNativeMenuChangeObserver
++{
++public:
++    enum EType {
++        eType_MenuBar,
++        eType_Menu,
++        eType_MenuItem
++    };
++
++    virtual ~nsMenuObject();
++
++    // Get the native menu item node
++    DbusmenuMenuitem* GetNativeData() const { return mNativeData; }
++
++    // Get the parent menu object
++    nsMenuContainer* Parent() const { return mParent; }
++
++    // Get the content node
++    nsIContent* ContentNode() const { return mContent; }
++
++    // Get the type of this node. Must be provided by subclasses
++    virtual EType Type() const = 0;
++
++    // Get the document listener
++    nsNativeMenuDocListener* DocListener() const { return mListener; }
++
++    // Create the native menu item node (called by containers)
++    void CreateNativeData();
++
++    // Adopt the specified native menu item node (called by containers)
++    nsresult AdoptNativeData(DbusmenuMenuitem *aNativeData);
++
++    // Called by the container to tell us that it's opening
++    void ContainerIsOpening();
++
++protected:
++    nsMenuObject(nsMenuContainer *aParent, nsIContent *aContent);
++    nsMenuObject(nsNativeMenuDocListener *aListener, nsIContent *aContent);
++
++    enum PropertyFlags {
++#define DBUSMENU_PROPERTY(e, s, b) eProp##e = (1 << b),
++        DBUSMENU_PROPERTIES
++#undef DBUSMENU_PROPERTY
++    };
++
++    void UpdateLabel();
++    void UpdateVisibility(mozilla::ComputedStyle *aComputedStyle);
++    void UpdateSensitivity();
++    void UpdateIcon(mozilla::ComputedStyle *aComputedStyle);
++
++    already_AddRefed<mozilla::ComputedStyle> GetComputedStyle();
++  
++private:
++    friend class nsMenuObjectIconLoader;
++
++    // Set up initial properties on the native data, connect to signals etc.
++    // This should be implemented by subclasses
++    virtual void InitializeNativeData();
++
++    // Return the properties that this menu object type supports
++    // This should be implemented by subclasses
++    virtual PropertyFlags SupportedProperties() const;
++
++    // Determine whether this menu object could use the specified
++    // native item. Returns true by default but can be overridden by subclasses
++    virtual bool
++    IsCompatibleWithNativeData(DbusmenuMenuitem *aNativeData) const;
++
++    // Update attributes on this objects content node when the container opens.
++    // This is called before style resolution, and should be implemented by
++    // subclasses who want to modify attributes that might affect style.
++    // This will not be called when there are script blockers
++    virtual void UpdateContentAttributes();
++
++    // Update properties that should be refreshed when the container opens.
++    // This should be implemented by subclasses that have properties which
++    // need refreshing
++    virtual void Update(mozilla::ComputedStyle *aComputedStyle);
++
++    bool ShouldShowIcon() const;
++    void ClearIcon();
++
++    nsCOMPtr<nsIContent> mContent;
++    // mListener is a strong ref for simplicity - someone in the tree needs to
++    // own it, and this only really needs to be the top-level object (as no
++    // children outlives their parent). However, we need to keep it alive until
++    // after running the nsMenuObject destructor for the top-level menu object,
++    // hence the strong ref
++    RefPtr<nsNativeMenuDocListener> mListener;
++    nsMenuContainer *mParent; // [weak]
++    DbusmenuMenuitem *mNativeData; // [strong]
++    RefPtr<nsMenuObjectIconLoader> mIconLoader;
++};
++
++// Keep a weak pointer to a menu object
++class nsWeakMenuObject
++{
++public:
++    nsWeakMenuObject() : mPrev(nullptr), mMenuObject(nullptr) {}
++
++    nsWeakMenuObject(nsMenuObject *aMenuObject) :
++        mPrev(nullptr), mMenuObject(aMenuObject)
++    {
++        AddWeakReference(this);
++    }
++
++    ~nsWeakMenuObject() { RemoveWeakReference(this); }
++
++    nsMenuObject* get() const { return mMenuObject; }
++
++    nsMenuObject* operator->() const { return mMenuObject; }
++
++    explicit operator bool() const { return !!mMenuObject; }
++
++    static void NotifyDestroyed(nsMenuObject *aMenuObject);
++
++private:
++    static void AddWeakReference(nsWeakMenuObject *aWeak);
++    static void RemoveWeakReference(nsWeakMenuObject *aWeak);
++
++    nsWeakMenuObject *mPrev;
++    static nsWeakMenuObject *sHead;
++
++    nsMenuObject *mMenuObject;
++};
++
++#endif /* __nsMenuObject_h__ */
+diff --git a/widget/gtk/nsMenuSeparator.cpp b/widget/gtk/nsMenuSeparator.cpp
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsMenuSeparator.cpp
+@@ -0,0 +1,85 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* 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 "mozilla/Assertions.h"
++#include "mozilla/ComputedStyle.h"
++#include "mozilla/Move.h"
++#include "nsAutoPtr.h"
++#include "nsCRT.h"
++#include "nsGkAtoms.h"
++
++#include "nsDbusmenu.h"
++
++#include "nsMenuContainer.h"
++#include "nsMenuSeparator.h"
++
++using namespace mozilla;
++
++void
++nsMenuSeparator::InitializeNativeData()
++{
++    dbusmenu_menuitem_property_set(GetNativeData(),
++                                   DBUSMENU_MENUITEM_PROP_TYPE,
++                                   "separator");
++}
++
++void
++nsMenuSeparator::Update(ComputedStyle *aComputedStyle)
++{
++    UpdateVisibility(aComputedStyle);
++}
++
++bool
++nsMenuSeparator::IsCompatibleWithNativeData(DbusmenuMenuitem *aNativeData) const
++{
++    return nsCRT::strcmp(dbusmenu_menuitem_property_get(aNativeData,
++                                                        DBUSMENU_MENUITEM_PROP_TYPE),
++                         "separator") == 0;
++}
++
++nsMenuObject::PropertyFlags
++nsMenuSeparator::SupportedProperties() const
++{
++    return static_cast<nsMenuObject::PropertyFlags>(
++        nsMenuObject::ePropVisible |
++        nsMenuObject::ePropType
++    );
++}
++
++void
++nsMenuSeparator::OnAttributeChanged(nsIContent *aContent, nsAtom *aAttribute)
++{
++    MOZ_ASSERT(aContent == ContentNode(), "Received an event that wasn't meant for us!");
++
++    if (!Parent()->IsBeingDisplayed()) {
++        return;
++    }
++
++    if (aAttribute == nsGkAtoms::hidden ||
++        aAttribute == nsGkAtoms::collapsed) {
++        RefPtr<ComputedStyle> style = GetComputedStyle();
++        UpdateVisibility(style);
++    }
++}
++
++nsMenuSeparator::nsMenuSeparator(nsMenuContainer *aParent,
++                                 nsIContent *aContent) :
++    nsMenuObject(aParent, aContent)
++{
++    MOZ_COUNT_CTOR(nsMenuSeparator);
++}
++
++nsMenuSeparator::~nsMenuSeparator()
++{
++    MOZ_COUNT_DTOR(nsMenuSeparator);
++}
++
++nsMenuObject::EType
++nsMenuSeparator::Type() const
++{
++    return eType_MenuItem;
++}
+diff --git a/widget/gtk/nsMenuSeparator.h b/widget/gtk/nsMenuSeparator.h
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsMenuSeparator.h
+@@ -0,0 +1,37 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* This Source Code Form is subject to the terms of the Mozilla Public
++ * License, v. 2.0. If a copy of the MPL was not distributed with this
++ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++
++#ifndef __nsMenuSeparator_h__
++#define __nsMenuSeparator_h__
++
++#include "mozilla/Attributes.h"
++
++#include "nsMenuObject.h"
++
++class nsIContent;
++class nsAtom;
++class nsMenuContainer;
++
++// Menu separator class
++class nsMenuSeparator final : public nsMenuObject
++{
++public:
++    nsMenuSeparator(nsMenuContainer *aParent, nsIContent *aContent);
++    ~nsMenuSeparator();
++
++    nsMenuObject::EType Type() const override;
++
++private:
++    void InitializeNativeData() override;
++    void Update(mozilla::ComputedStyle *aComputedStyle) override;
++    bool IsCompatibleWithNativeData(DbusmenuMenuitem *aNativeData) const override;
++    nsMenuObject::PropertyFlags SupportedProperties() const override;
++
++    void OnAttributeChanged(nsIContent *aContent, nsAtom *aAttribute) override;
++};
++
++#endif /* __nsMenuSeparator_h__ */
+diff --git a/widget/gtk/nsNativeMenuAtomList.h b/widget/gtk/nsNativeMenuAtomList.h
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsNativeMenuAtomList.h
+@@ -0,0 +1,12 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* 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/. */
++
++WIDGET_ATOM2(menuitem_with_favicon, "menuitem-with-favicon")
++WIDGET_ATOM2(_moz_menubarkeeplocal, "_moz-menubarkeeplocal")
++WIDGET_ATOM2(_moz_nativemenupopupstate, "_moz-nativemenupopupstate")
++WIDGET_ATOM(openedwithkey)
++WIDGET_ATOM(shellshowingmenubar)
+diff --git a/widget/gtk/nsNativeMenuAtoms.cpp b/widget/gtk/nsNativeMenuAtoms.cpp
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsNativeMenuAtoms.cpp
+@@ -0,0 +1,52 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* 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 "nsAtom.h"
++#include "nsStaticAtom.h"
++
++#include "nsNativeMenuAtoms.h"
++
++
++namespace mozilla {
++namespace widget {
++namespace detail {
++
++static constexpr NativeMenuAtoms gNativeMenuAtoms = {
++    #define WIDGET_ATOM(name_) NS_STATIC_ATOM_INIT_STRING(#name_)
++    #define WIDGET_ATOM2(name_, value_) NS_STATIC_ATOM_INIT_STRING(value_)
++    #include "nsNativeMenuAtomList.h"
++    #undef WIDGET_ATOM
++    #undef WIDGET_ATOM2
++    
++    {
++        #define WIDGET_ATOM(name_) NS_STATIC_ATOM_INIT_ATOM(nsStaticAtom, NativeMenuAtoms, name_, #name_)
++        #define WIDGET_ATOM2(name_, value_) NS_STATIC_ATOM_INIT_ATOM(nsStaticAtom, NativeMenuAtoms, name_, value_)
++        #include "nsNativeMenuAtomList.h"
++        #undef WIDGET_ATOM
++        #undef WIDGET_ATOM2
++    }
++};
++
++}
++}
++}
++
++using namespace mozilla;
++
++const nsStaticAtom* const nsNativeMenuAtoms::sAtoms = widget::detail::gNativeMenuAtoms.mAtoms;
++
++#define WIDGET_ATOM(name_) NS_STATIC_ATOM_DEFN_PTR(nsStaticAtom, widget::detail::NativeMenuAtoms, widget::detail::gNativeMenuAtoms, nsNativeMenuAtoms, name_)
++#define WIDGET_ATOM2(name_, value_) NS_STATIC_ATOM_DEFN_PTR(nsStaticAtom, widget::detail::NativeMenuAtoms, widget::detail::gNativeMenuAtoms, nsNativeMenuAtoms, name_)
++#include "nsNativeMenuAtomList.h"
++#undef WIDGET_ATOM
++#undef WIDGET_ATOM2
++
++/* static */ void
++nsNativeMenuAtoms::RegisterAtoms()
++{
++    NS_RegisterStaticAtoms(sAtoms, sAtomsLen);
++}
+diff --git a/widget/gtk/nsNativeMenuAtoms.h b/widget/gtk/nsNativeMenuAtoms.h
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsNativeMenuAtoms.h
+@@ -0,0 +1,61 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* This Source Code Form is subject to the terms of the Mozilla Public
++ * License, v. 2.0. If a copy of the MPL was not distributed with this
++ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++
++#ifndef __nsNativeMenuAtoms_h__
++#define __nsNativeMenuAtoms_h__
++
++class nsAtom;
++
++namespace mozilla {
++namespace widget {
++namespace detail {
++
++struct NativeMenuAtoms
++{
++    #define WIDGET_ATOM(name_) NS_STATIC_ATOM_DECL_STRING(name_, #name_)
++    #define WIDGET_ATOM2(name_, value_) NS_STATIC_ATOM_DECL_STRING(name_, value_)
++    #include "nsNativeMenuAtomList.h"
++    #undef WIDGET_ATOM
++    #undef WIDGET_ATOM2
++
++    enum class Atoms {
++        #define WIDGET_ATOM(name_) NS_STATIC_ATOM_ENUM(name_)
++        #define WIDGET_ATOM2(name_, value_) NS_STATIC_ATOM_ENUM(name_)
++        #include "nsNativeMenuAtomList.h"
++        #undef WIDGET_ATOM
++        #undef WIDGET_ATOM2
++        AtomsCount
++    };
++
++    const nsStaticAtom mAtoms[static_cast<size_t>(Atoms::AtomsCount)];
++};
++
++}
++}
++}
++
++class nsNativeMenuAtoms
++{
++private:
++    static const nsStaticAtom* const sAtoms;
++
++    static constexpr size_t sAtomsLen =
++      static_cast<size_t>(mozilla::widget::detail::NativeMenuAtoms::Atoms::AtomsCount);
++
++public:
++    nsNativeMenuAtoms() = delete;
++
++    static void RegisterAtoms();
++
++    #define WIDGET_ATOM(name_) NS_STATIC_ATOM_DECL_PTR(nsStaticAtom, name_)
++    #define WIDGET_ATOM2(name_, value_) NS_STATIC_ATOM_DECL_PTR(nsStaticAtom, name_)
++    #include "nsNativeMenuAtomList.h"
++    #undef WIDGET_ATOM
++    #undef WIDGET_ATOM2
++};
++
++#endif /* __nsNativeMenuAtoms_h__ */
+diff --git a/widget/gtk/nsNativeMenuDocListener.cpp b/widget/gtk/nsNativeMenuDocListener.cpp
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsNativeMenuDocListener.cpp
+@@ -0,0 +1,350 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* 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 "mozilla/Assertions.h"
++#include "mozilla/DebugOnly.h"
++#include "mozilla/dom/Element.h"
++#include "nsContentUtils.h"
++#include "nsAtom.h"
++#include "nsIContent.h"
++#include "nsIDocument.h"
++
++#include "nsMenuContainer.h"
++
++#include "nsNativeMenuDocListener.h"
++
++using namespace mozilla;
++
++uint32_t nsNativeMenuDocListener::sUpdateBlockersCount = 0;
++
++nsNativeMenuDocListenerTArray *gPendingListeners;
++
++/*
++ * Small helper which caches a single listener, so that consecutive
++ * events which go to the same node avoid multiple hash table lookups
++ */
++class MOZ_STACK_CLASS DispatchHelper
++{
++public:
++    DispatchHelper(nsNativeMenuDocListener *aListener,
++                   nsIContent *aContent
++                   MOZ_GUARD_OBJECT_NOTIFIER_PARAM) :
++                   mObserver(nullptr)
++    {
++        MOZ_GUARD_OBJECT_NOTIFIER_INIT;
++        if (aContent == aListener->mLastSource) {
++            mObserver = aListener->mLastTarget;
++        } else {
++            mObserver = aListener->mContentToObserverTable.Get(aContent);
++            if (mObserver) {
++                aListener->mLastSource = aContent;
++                aListener->mLastTarget = mObserver;
++            }
++        }
++    }
++
++    ~DispatchHelper() { };
++
++    nsNativeMenuChangeObserver* Observer() const { return mObserver; }
++
++    bool HasObserver() const { return !!mObserver; }
++
++private:
++    nsNativeMenuChangeObserver *mObserver;
++    MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
++};
++
++NS_IMPL_ISUPPORTS(nsNativeMenuDocListener, nsIMutationObserver)
++
++nsNativeMenuDocListener::~nsNativeMenuDocListener()
++{
++    MOZ_ASSERT(mContentToObserverTable.Count() == 0,
++               "Some nodes forgot to unregister listeners. This is bad! (and we're lucky we made it this far)");
++    MOZ_COUNT_DTOR(nsNativeMenuDocListener);
++}
++
++void
++nsNativeMenuDocListener::AttributeChanged(mozilla::dom::Element *aElement,
++                                          int32_t aNameSpaceID,
++                                          nsAtom *aAttribute,
++                                          int32_t aModType,
++                                          const nsAttrValue* aOldValue)
++{
++    if (sUpdateBlockersCount == 0) {
++        DoAttributeChanged(aElement, aAttribute);
++        return;
++    }
++
++    MutationRecord *m = *mPendingMutations.AppendElement(new MutationRecord);
++    m->mType = MutationRecord::eAttributeChanged;
++    m->mTarget = aElement;
++    m->mAttribute = aAttribute;
++
++    ScheduleFlush(this);
++}
++
++void
++nsNativeMenuDocListener::ContentAppended(nsIContent *aFirstNewContent)
++{
++    for (nsIContent *c = aFirstNewContent; c; c = c->GetNextSibling()) {
++        ContentInserted(c);
++    }
++}
++
++void
++nsNativeMenuDocListener::ContentInserted(nsIContent *aChild)
++{
++    nsIContent* container = aChild->GetParent();
++    if (!container) {
++      return;
++    }
++
++    nsIContent *prevSibling = nsMenuContainer::GetPreviousSupportedSibling(aChild);
++
++    if (sUpdateBlockersCount == 0) {
++        DoContentInserted(container, aChild, prevSibling);
++        return;
++    }
++
++    MutationRecord *m = *mPendingMutations.AppendElement(new MutationRecord);
++    m->mType = MutationRecord::eContentInserted;
++    m->mTarget = container;
++    m->mChild = aChild;
++    m->mPrevSibling = prevSibling;
++
++    ScheduleFlush(this);
++}
++
++void
++nsNativeMenuDocListener::ContentRemoved(nsIContent *aChild,
++                                        nsIContent *aPreviousSibling)
++{
++    nsIContent* container = aChild->GetParent();
++    if (!container) {
++      return;
++    }
++
++    if (sUpdateBlockersCount == 0) {
++        DoContentRemoved(container, aChild);
++        return;
++    }
++
++    MutationRecord *m = *mPendingMutations.AppendElement(new MutationRecord);
++    m->mType = MutationRecord::eContentRemoved;
++    m->mTarget = container;
++    m->mChild = aChild;
++
++    ScheduleFlush(this);
++}                                                           
++
++void
++nsNativeMenuDocListener::NodeWillBeDestroyed(const nsINode *aNode)
++{
++    mDocument = nullptr;
++}
++
++void
++nsNativeMenuDocListener::DoAttributeChanged(nsIContent *aContent,
++                                            nsAtom *aAttribute)
++{
++    DispatchHelper h(this, aContent);
++    if (h.HasObserver()) {
++        h.Observer()->OnAttributeChanged(aContent, aAttribute);
++    }
++}
++
++void
++nsNativeMenuDocListener::DoContentInserted(nsIContent *aContainer,
++                                           nsIContent *aChild,
++                                           nsIContent *aPrevSibling)
++{
++    DispatchHelper h(this, aContainer);
++    if (h.HasObserver()) {
++        h.Observer()->OnContentInserted(aContainer, aChild, aPrevSibling);
++    }
++}
++
++void
++nsNativeMenuDocListener::DoContentRemoved(nsIContent *aContainer,
++                                          nsIContent *aChild)
++{
++    DispatchHelper h(this, aContainer);
++    if (h.HasObserver()) {
++        h.Observer()->OnContentRemoved(aContainer, aChild);
++    }
++}
++
++void
++nsNativeMenuDocListener::DoBeginUpdates(nsIContent *aTarget)
++{
++    DispatchHelper h(this, aTarget);
++    if (h.HasObserver()) {
++        h.Observer()->OnBeginUpdates(aTarget);
++    }
++}
++
++void
++nsNativeMenuDocListener::DoEndUpdates(nsIContent *aTarget)
++{
++    DispatchHelper h(this, aTarget);
++    if (h.HasObserver()) {
++        h.Observer()->OnEndUpdates();
++    }
++}
++
++void
++nsNativeMenuDocListener::FlushPendingMutations()
++{
++    nsIContent *currentTarget = nullptr;
++    bool inUpdateSequence = false;
++
++    while (mPendingMutations.Length() > 0) {
++        MutationRecord *m = mPendingMutations[0];
++
++        if (m->mTarget != currentTarget) {
++            if (inUpdateSequence) {
++                DoEndUpdates(currentTarget);
++                inUpdateSequence = false;
++            }
++
++            currentTarget = m->mTarget;
++
++            if (mPendingMutations.Length() > 1 &&
++                mPendingMutations[1]->mTarget == currentTarget) {
++                DoBeginUpdates(currentTarget);
++                inUpdateSequence = true;
++            }
++        }
++
++        switch (m->mType) {
++            case MutationRecord::eAttributeChanged:
++                DoAttributeChanged(m->mTarget, m->mAttribute);
++                break;
++            case MutationRecord::eContentInserted:
++                DoContentInserted(m->mTarget, m->mChild, m->mPrevSibling);
++                break;
++            case MutationRecord::eContentRemoved:
++                DoContentRemoved(m->mTarget, m->mChild);
++                break;
++            default:
++                NS_NOTREACHED("Invalid type");
++        }
++
++        mPendingMutations.RemoveElementAt(0);
++    }
++
++    if (inUpdateSequence) {
++        DoEndUpdates(currentTarget);
++    }
++}
++
++/* static */ void
++nsNativeMenuDocListener::ScheduleFlush(nsNativeMenuDocListener *aListener)
++{
++    MOZ_ASSERT(sUpdateBlockersCount > 0, "Shouldn't be doing this now");
++
++    if (!gPendingListeners) {
++        gPendingListeners = new nsNativeMenuDocListenerTArray;
++    }
++
++    if (gPendingListeners->IndexOf(aListener) ==
++        nsNativeMenuDocListenerTArray::NoIndex) {
++        gPendingListeners->AppendElement(aListener);
++    }
++}
++
++/* static */ void
++nsNativeMenuDocListener::CancelFlush(nsNativeMenuDocListener *aListener)
++{
++    if (!gPendingListeners) {
++        return;
++    }
++
++    gPendingListeners->RemoveElement(aListener);
++}
++
++/* static */ void
++nsNativeMenuDocListener::RemoveUpdateBlocker()
++{
++    if (sUpdateBlockersCount == 1 && gPendingListeners) {
++        while (gPendingListeners->Length() > 0) {
++            (*gPendingListeners)[0]->FlushPendingMutations();
++            gPendingListeners->RemoveElementAt(0);
++        }
++    }
++ 
++    MOZ_ASSERT(sUpdateBlockersCount > 0, "Negative update blockers count!");
++    sUpdateBlockersCount--;
++}
++
++nsNativeMenuDocListener::nsNativeMenuDocListener(nsIContent *aRootNode) :
++    mRootNode(aRootNode),
++    mDocument(nullptr),
++    mLastSource(nullptr),
++    mLastTarget(nullptr)
++{
++    MOZ_COUNT_CTOR(nsNativeMenuDocListener);
++}
++
++void
++nsNativeMenuDocListener::RegisterForContentChanges(nsIContent *aContent,
++                                                   nsNativeMenuChangeObserver *aObserver)
++{
++    MOZ_ASSERT(aContent, "Need content parameter");
++    MOZ_ASSERT(aObserver, "Need observer parameter");
++    if (!aContent || !aObserver) {
++        return;
++    }
++
++    DebugOnly<nsNativeMenuChangeObserver *> old;
++    MOZ_ASSERT(!mContentToObserverTable.Get(aContent, &old) || old == aObserver,
++               "Multiple observers for the same content node are not supported");
++
++    mContentToObserverTable.Put(aContent, aObserver);
++}
++
++void
++nsNativeMenuDocListener::UnregisterForContentChanges(nsIContent *aContent)
++{
++    MOZ_ASSERT(aContent, "Need content parameter");
++    if (!aContent) {
++        return;
++    }
++
++    mContentToObserverTable.Remove(aContent);
++    if (aContent == mLastSource) {
++        mLastSource = nullptr;
++        mLastTarget = nullptr;
++    }
++}
++
++void
++nsNativeMenuDocListener::Start()
++{
++    if (mDocument) {
++        return;
++    }
++
++    mDocument = mRootNode->OwnerDoc();
++    if (!mDocument) {
++        return;
++    }
++
++    mDocument->AddMutationObserver(this);
++}
++
++void
++nsNativeMenuDocListener::Stop()
++{
++    if (mDocument) {
++        mDocument->RemoveMutationObserver(this);
++        mDocument = nullptr;
++    }
++
++    CancelFlush(this);
++    mPendingMutations.Clear();
++}
+diff --git a/widget/gtk/nsNativeMenuDocListener.h b/widget/gtk/nsNativeMenuDocListener.h
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsNativeMenuDocListener.h
+@@ -0,0 +1,152 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* This Source Code Form is subject to the terms of the Mozilla Public
++ * License, v. 2.0. If a copy of the MPL was not distributed with this
++ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++
++#ifndef __nsNativeMenuDocListener_h__
++#define __nsNativeMenuDocListener_h__
++
++#include "mozilla/Attributes.h"
++#include "mozilla/GuardObjects.h"
++#include "mozilla/RefPtr.h"
++#include "nsAutoPtr.h"
++#include "nsDataHashtable.h"
++#include "nsStubMutationObserver.h"
++#include "nsTArray.h"
++
++class nsAtom;
++class nsIContent;
++class nsIDocument;
++class nsNativeMenuChangeObserver;
++
++/*
++ * This class keeps a mapping of content nodes to observers and forwards DOM
++ * mutations to these. There is exactly one of these for every menubar.
++ */
++class nsNativeMenuDocListener final : nsStubMutationObserver
++{
++public:
++    NS_DECL_ISUPPORTS
++
++    nsNativeMenuDocListener(nsIContent *aRootNode);
++
++    // Register an observer to receive mutation events for the specified
++    // content node. The caller must keep the observer alive until
++    // UnregisterForContentChanges is called.
++    void RegisterForContentChanges(nsIContent *aContent,
++                                   nsNativeMenuChangeObserver *aObserver);
++
++    // Unregister the registered observer for the specified content node
++    void UnregisterForContentChanges(nsIContent *aContent);
++
++    // Start listening to the document and forwarding DOM mutations to
++    // registered observers.
++    void Start();
++
++    // Stop listening to the document. No DOM mutations will be forwarded
++    // to registered observers.
++    void Stop();
++
++    /*
++     * This class is intended to be used inside GObject signal handlers.
++     * It allows us to queue updates until we have finished delivering
++     * events to Gecko, and then we can batch updates to our view of the
++     * menu. This allows us to do menu updates without altering the structure
++     * seen by the OS.
++     */
++    class MOZ_STACK_CLASS BlockUpdatesScope
++    {
++    public:
++        BlockUpdatesScope(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM)
++        {
++            MOZ_GUARD_OBJECT_NOTIFIER_INIT;
++            nsNativeMenuDocListener::AddUpdateBlocker();
++        }
++
++        ~BlockUpdatesScope()
++        {
++            nsNativeMenuDocListener::RemoveUpdateBlocker();
++        }
++
++    private:
++        MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
++    };
++
++private:
++    friend class DispatchHelper;
++
++    struct MutationRecord {
++        enum RecordType {
++            eAttributeChanged,
++            eContentInserted,
++            eContentRemoved
++        } mType;
++
++        nsCOMPtr<nsIContent> mTarget;
++        nsCOMPtr<nsIContent> mChild;
++        nsCOMPtr<nsIContent> mPrevSibling;
++        RefPtr<nsAtom> mAttribute;
++    };
++
++    ~nsNativeMenuDocListener();
++
++    NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
++    NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
++    NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
++    NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
++    NS_DECL_NSIMUTATIONOBSERVER_NODEWILLBEDESTROYED
++
++    void DoAttributeChanged(nsIContent *aContent, nsAtom *aAttribute);
++    void DoContentInserted(nsIContent *aContainer,
++                           nsIContent *aChild,
++                           nsIContent *aPrevSibling);
++    void DoContentRemoved(nsIContent *aContainer, nsIContent *aChild);
++    void DoBeginUpdates(nsIContent *aTarget);
++    void DoEndUpdates(nsIContent *aTarget);
++
++    void FlushPendingMutations();
++    static void ScheduleFlush(nsNativeMenuDocListener *aListener);
++    static void CancelFlush(nsNativeMenuDocListener *aListener);
++
++    static void AddUpdateBlocker() { ++sUpdateBlockersCount; }
++    static void RemoveUpdateBlocker();
++
++    nsCOMPtr<nsIContent> mRootNode;
++    nsIDocument *mDocument;
++    nsIContent *mLastSource;
++    nsNativeMenuChangeObserver *mLastTarget;
++    nsTArray<nsAutoPtr<MutationRecord> > mPendingMutations;
++    nsDataHashtable<nsPtrHashKey<nsIContent>, nsNativeMenuChangeObserver *> mContentToObserverTable;
++
++    static uint32_t sUpdateBlockersCount;
++};
++
++typedef nsTArray<RefPtr<nsNativeMenuDocListener> > nsNativeMenuDocListenerTArray;
++
++/*
++ * Implemented by classes that want to listen to mutation events from content
++ * nodes.
++ */
++class nsNativeMenuChangeObserver
++{
++public:
++    virtual void OnAttributeChanged(nsIContent *aContent, nsAtom *aAttribute) {}
++
++    virtual void OnContentInserted(nsIContent *aContainer,
++                                   nsIContent *aChild,
++                                   nsIContent *aPrevSibling) {}
++
++    virtual void OnContentRemoved(nsIContent *aContainer, nsIContent *aChild) {}
++
++    // Signals the start of a sequence of more than 1 event for the specified
++    // node. This only happens when events are flushed as all BlockUpdatesScope
++    // instances go out of scope
++    virtual void OnBeginUpdates(nsIContent *aContent) {};
++
++    // Signals the end of a sequence of events
++    virtual void OnEndUpdates() {};
++};
++
++#endif /* __nsNativeMenuDocListener_h__ */
+diff --git a/widget/gtk/nsNativeMenuService.cpp b/widget/gtk/nsNativeMenuService.cpp
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsNativeMenuService.cpp
+@@ -0,0 +1,508 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* 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 "mozilla/Assertions.h"
++#include "mozilla/Move.h"
++#include "mozilla/Preferences.h"
++#include "mozilla/UniquePtr.h"
++#include "nsAutoPtr.h"
++#include "nsCOMPtr.h"
++#include "nsCRT.h"
++#include "nsGtkUtils.h"
++#include "nsIContent.h"
++#include "nsIWidget.h"
++#include "nsServiceManagerUtils.h"
++#include "nsWindow.h"
++#include "prlink.h"
++
++#include "nsDbusmenu.h"
++#include "nsMenuBar.h"
++#include "nsNativeMenuAtoms.h"
++#include "nsNativeMenuDocListener.h"
++
++#include <glib-object.h>
++#include <pango/pango.h>
++#include <stdlib.h>
++
++#include "nsNativeMenuService.h"
++
++using namespace mozilla;
++
++nsNativeMenuService* nsNativeMenuService::sService = nullptr;
++
++extern PangoLayout* gPangoLayout;
++extern nsNativeMenuDocListenerTArray* gPendingListeners;
++
++static const nsTArray<nsMenuBar *>::index_type NoIndex = nsTArray<nsMenuBar *>::NoIndex;
++
++#if not GLIB_CHECK_VERSION(2,26,0)
++enum GBusType {
++    G_BUS_TYPE_STARTER = -1,
++    G_BUS_TYPE_NONE = 0,
++    G_BUS_TYPE_SYSTEM = 1,
++    G_BUS_TYPE_SESSION = 2
++};
++
++enum GDBusProxyFlags {
++    G_DBUS_PROXY_FLAGS_NONE = 0,
++    G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES = 1 << 0,
++    G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS = 1 << 1,
++    G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START = 1 << 2,
++    G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES = 1 << 3
++};
++
++enum GDBusCallFlags {
++    G_DBUS_CALL_FLAGS_NONE = 0,
++    G_DBUS_CALL_FLAGS_NO_AUTO_START = 1 << 0
++};
++
++typedef _GDBusInterfaceInfo GDBusInterfaceInfo;
++typedef _GDBusProxy GDBusProxy;
++typedef _GVariant GVariant;
++#endif
++
++#undef g_dbus_proxy_new_for_bus
++#undef g_dbus_proxy_new_for_bus_finish
++#undef g_dbus_proxy_call
++#undef g_dbus_proxy_call_finish
++#undef g_dbus_proxy_get_name_owner
++
++typedef void (*_g_dbus_proxy_new_for_bus_fn)(GBusType, GDBusProxyFlags,
++                                             GDBusInterfaceInfo*,
++                                             const gchar*, const gchar*,
++                                             const gchar*, GCancellable*,
++                                             GAsyncReadyCallback, gpointer);
++
++typedef GDBusProxy* (*_g_dbus_proxy_new_for_bus_finish_fn)(GAsyncResult*,
++                                                           GError**);
++typedef void (*_g_dbus_proxy_call_fn)(GDBusProxy*, const gchar*, GVariant*,
++                                      GDBusCallFlags, gint, GCancellable*,
++                                      GAsyncReadyCallback, gpointer);
++typedef GVariant* (*_g_dbus_proxy_call_finish_fn)(GDBusProxy*, GAsyncResult*,
++                                                  GError**);
++typedef gchar* (*_g_dbus_proxy_get_name_owner_fn)(GDBusProxy*);
++
++static _g_dbus_proxy_new_for_bus_fn _g_dbus_proxy_new_for_bus;
++static _g_dbus_proxy_new_for_bus_finish_fn _g_dbus_proxy_new_for_bus_finish;
++static _g_dbus_proxy_call_fn _g_dbus_proxy_call;
++static _g_dbus_proxy_call_finish_fn _g_dbus_proxy_call_finish;
++static _g_dbus_proxy_get_name_owner_fn _g_dbus_proxy_get_name_owner;
++
++#define g_dbus_proxy_new_for_bus _g_dbus_proxy_new_for_bus
++#define g_dbus_proxy_new_for_bus_finish _g_dbus_proxy_new_for_bus_finish
++#define g_dbus_proxy_call _g_dbus_proxy_call
++#define g_dbus_proxy_call_finish _g_dbus_proxy_call_finish
++#define g_dbus_proxy_get_name_owner _g_dbus_proxy_get_name_owner
++
++static PRLibrary *gGIOLib = nullptr;
++
++static nsresult
++GDBusInit()
++{
++    gGIOLib = PR_LoadLibrary("libgio-2.0.so.0");
++    if (!gGIOLib) {
++        return NS_ERROR_FAILURE;
++    }
++
++    g_dbus_proxy_new_for_bus = (_g_dbus_proxy_new_for_bus_fn)PR_FindFunctionSymbol(gGIOLib, "g_dbus_proxy_new_for_bus");
++    g_dbus_proxy_new_for_bus_finish = (_g_dbus_proxy_new_for_bus_finish_fn)PR_FindFunctionSymbol(gGIOLib, "g_dbus_proxy_new_for_bus_finish");
++    g_dbus_proxy_call = (_g_dbus_proxy_call_fn)PR_FindFunctionSymbol(gGIOLib, "g_dbus_proxy_call");
++    g_dbus_proxy_call_finish = (_g_dbus_proxy_call_finish_fn)PR_FindFunctionSymbol(gGIOLib, "g_dbus_proxy_call_finish");
++    g_dbus_proxy_get_name_owner = (_g_dbus_proxy_get_name_owner_fn)PR_FindFunctionSymbol(gGIOLib, "g_dbus_proxy_get_name_owner");
++
++    if (!g_dbus_proxy_new_for_bus ||
++        !g_dbus_proxy_new_for_bus_finish ||
++        !g_dbus_proxy_call ||
++        !g_dbus_proxy_call_finish ||
++        !g_dbus_proxy_get_name_owner) {
++        return NS_ERROR_FAILURE;
++    }
++
++    return NS_OK;
++}
++
++NS_IMPL_ISUPPORTS(nsNativeMenuService, nsINativeMenuService)
++
++nsNativeMenuService::nsNativeMenuService() :
++    mCreateProxyCancellable(nullptr), mDbusProxy(nullptr), mOnline(false)
++{
++}
++
++nsNativeMenuService::~nsNativeMenuService()
++{
++    SetOnline(false);
++
++    if (mCreateProxyCancellable) {
++        g_cancellable_cancel(mCreateProxyCancellable);
++        g_object_unref(mCreateProxyCancellable);
++        mCreateProxyCancellable = nullptr;
++    }
++
++    // Make sure we disconnect map-event handlers
++    while (mMenuBars.Length() > 0) {
++        NotifyNativeMenuBarDestroyed(mMenuBars[0]);
++    }
++
++    Preferences::UnregisterCallback(PrefChangedCallback,
++                                    "ui.use_unity_menubar");
++
++    if (mDbusProxy) {
++        g_signal_handlers_disconnect_by_func(mDbusProxy,
++                                             FuncToGpointer(name_owner_changed_cb),
++                                             NULL);
++        g_object_unref(mDbusProxy);
++    }
++
++    if (gPendingListeners) {
++        delete gPendingListeners;
++        gPendingListeners = nullptr;
++    }
++    if (gPangoLayout) {
++        g_object_unref(gPangoLayout);
++        gPangoLayout = nullptr;
++    }
++
++    MOZ_ASSERT(sService == this);
++    sService = nullptr;
++}
++
++nsresult
++nsNativeMenuService::Init()
++{
++    nsresult rv = nsDbusmenuFunctions::Init();
++    if (NS_FAILED(rv)) {
++        return rv;
++    }
++
++    rv = GDBusInit();
++    if (NS_FAILED(rv)) {
++        return rv;
++    }
++
++    Preferences::RegisterCallback(PrefChangedCallback,
++                                  "ui.use_unity_menubar");
++
++    mCreateProxyCancellable = g_cancellable_new();
++
++    g_dbus_proxy_new_for_bus(G_BUS_TYPE_SESSION,
++                             static_cast<GDBusProxyFlags>(
++                                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |
++                                 G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS |
++                                 G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START),
++                             nullptr,
++                             "com.canonical.AppMenu.Registrar",
++                             "/com/canonical/AppMenu/Registrar",
++                             "com.canonical.AppMenu.Registrar",
++                             mCreateProxyCancellable, proxy_created_cb,
++                             nullptr);
++
++    /* We don't technically know that the shell will draw the menubar until
++     * we know whether anybody owns the name of the menubar service on the
++     * session bus. However, discovering this happens asynchronously so
++     * we optimize for the common case here by assuming that the shell will
++     * draw window menubars if we are running inside Unity. This should
++     * mean that we avoid temporarily displaying the window menubar ourselves
++     */
++    const char *desktop = getenv("XDG_CURRENT_DESKTOP");
++    if (nsCRT::strcmp(desktop, "Unity") == 0) {
++        SetOnline(true);
++    }
++
++    return NS_OK;
++}
++
++/* static */ void
++nsNativeMenuService::EnsureInitialized()
++{
++    if (sService) {
++        return;
++    }
++    nsCOMPtr<nsINativeMenuService> service =
++        do_GetService("@mozilla.org/widget/nativemenuservice;1");
++}
++
++void
++nsNativeMenuService::SetOnline(bool aOnline)
++{
++    if (!Preferences::GetBool("ui.use_unity_menubar", true)) {
++        aOnline = false;
++    }
++
++    mOnline = aOnline;
++    if (aOnline) {
++        for (uint32_t i = 0; i < mMenuBars.Length(); ++i) {
++            RegisterNativeMenuBar(mMenuBars[i]);
++        }
++    } else {
++        for (uint32_t i = 0; i < mMenuBars.Length(); ++i) {
++            mMenuBars[i]->Deactivate();
++        }
++    }
++}
++
++void
++nsNativeMenuService::RegisterNativeMenuBar(nsMenuBar *aMenuBar)
++{
++    if (!mOnline) {
++        return;
++    }
++
++    // This will effectively create the native menubar for
++    // exporting over the session bus, and hide the XUL menubar
++    aMenuBar->Activate();
++
++    if (!mDbusProxy ||
++        !gtk_widget_get_mapped(aMenuBar->TopLevelWindow()) ||
++        mMenuBarRegistrationCancellables.Get(aMenuBar, nullptr)) {
++        // Don't go further if we don't have a proxy for the shell menu
++        // service, the window isn't mapped or there is a request in progress.
++        return;
++    }
++
++    uint32_t xid = aMenuBar->WindowId();
++    nsCString path = aMenuBar->ObjectPath();
++    if (xid == 0 || path.IsEmpty()) {
++        NS_WARNING("Menubar has invalid XID or object path");
++        return;
++    }
++
++    GCancellable *cancellable = g_cancellable_new();
++    mMenuBarRegistrationCancellables.Put(aMenuBar, cancellable);
++
++    // We keep a weak ref because we can't assume that GDBus cancellation
++    // is reliable (see https://launchpad.net/bugs/953562)
++
++    g_dbus_proxy_call(mDbusProxy, "RegisterWindow",
++                      g_variant_new("(uo)", xid, path.get()),
++                      G_DBUS_CALL_FLAGS_NONE, -1,
++                      cancellable,
++                      register_native_menubar_cb, aMenuBar);
++}
++
++/* static */ void
++nsNativeMenuService::name_owner_changed_cb(GObject *gobject,
++                                           GParamSpec *pspec,
++                                           gpointer user_data)
++{
++    nsNativeMenuService::GetSingleton()->OnNameOwnerChanged();
++}
++
++/* static */ void
++nsNativeMenuService::proxy_created_cb(GObject *source_object,
++                                      GAsyncResult *res,
++                                      gpointer user_data)
++{
++    GError *error = nullptr;
++    GDBusProxy *proxy = g_dbus_proxy_new_for_bus_finish(res, &error);
++    if (error && g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
++        g_error_free(error);
++        return;
++    }
++
++    if (error) {
++        g_error_free(error);
++    }
++
++    // We need this check because we can't assume that GDBus cancellation
++    // is reliable (see https://launchpad.net/bugs/953562)
++    nsNativeMenuService *self = nsNativeMenuService::GetSingleton();
++    if (!self) {
++        if (proxy) {
++            g_object_unref(proxy);
++        }
++        return;
++    }
++
++    self->OnProxyCreated(proxy);
++}
++
++/* static */ void
++nsNativeMenuService::register_native_menubar_cb(GObject *source_object,
++                                                GAsyncResult *res,
++                                                gpointer user_data)
++{
++    nsMenuBar *menuBar = static_cast<nsMenuBar *>(user_data);
++
++    GError *error = nullptr;
++    GVariant *results = g_dbus_proxy_call_finish(G_DBUS_PROXY(source_object),
++                                                 res, &error);
++    if (results) {
++        // There's nothing useful in the response
++        g_variant_unref(results);
++    }
++
++    bool success = error ? false : true;
++    if (error && g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
++        g_error_free(error);
++        return;
++    }
++
++    if (error) {
++        g_error_free(error);
++    }
++
++    nsNativeMenuService *self = nsNativeMenuService::GetSingleton();
++    if (!self) {
++        return;
++    }
++
++    self->OnNativeMenuBarRegistered(menuBar, success);
++}
++
++/* static */ gboolean
++nsNativeMenuService::map_event_cb(GtkWidget *widget,
++                                  GdkEvent *event,
++                                  gpointer user_data)
++{
++    nsMenuBar *menubar = static_cast<nsMenuBar *>(user_data);
++    nsNativeMenuService::GetSingleton()->RegisterNativeMenuBar(menubar);
++
++    return FALSE;
++}
++
++void
++nsNativeMenuService::OnNameOwnerChanged()
++{
++    char *owner = g_dbus_proxy_get_name_owner(mDbusProxy);
++    SetOnline(owner ? true : false);
++    g_free(owner);
++}
++
++void
++nsNativeMenuService::OnProxyCreated(GDBusProxy *aProxy)
++{
++    mDbusProxy = aProxy;
++
++    g_object_unref(mCreateProxyCancellable);
++    mCreateProxyCancellable = nullptr;
++
++    if (!mDbusProxy) {
++        SetOnline(false);
++        return;
++    }
++
++    g_signal_connect(mDbusProxy, "notify::g-name-owner",
++                     G_CALLBACK(name_owner_changed_cb), nullptr);
++
++    OnNameOwnerChanged();
++}
++
++void
++nsNativeMenuService::OnNativeMenuBarRegistered(nsMenuBar *aMenuBar,
++                                               bool aSuccess)
++{
++    // Don't assume that GDBus cancellation is reliable (ie, |aMenuBar| might
++    // have already been deleted (see https://launchpad.net/bugs/953562)
++    GCancellable *cancellable = nullptr;
++    if (!mMenuBarRegistrationCancellables.Get(aMenuBar, &cancellable)) {
++        return;
++    }
++
++    g_object_unref(cancellable);
++    mMenuBarRegistrationCancellables.Remove(aMenuBar);
++
++    if (!aSuccess) {
++        aMenuBar->Deactivate();
++    }
++}
++
++/* static */ void
++nsNativeMenuService::PrefChangedCallback(const char *aPref,
++                                         void *aClosure)
++{
++    nsNativeMenuService::GetSingleton()->PrefChanged();
++}
++
++void
++nsNativeMenuService::PrefChanged()
++{
++    if (!mDbusProxy) {
++        SetOnline(false);
++        return;
++    }
++
++    OnNameOwnerChanged();
++}
++
++NS_IMETHODIMP
++nsNativeMenuService::CreateNativeMenuBar(nsIWidget *aParent,
++                                         mozilla::dom::Element *aMenuBarNode)
++{
++    NS_ENSURE_ARG(aParent);
++    NS_ENSURE_ARG(aMenuBarNode);
++
++    if (aMenuBarNode->AsElement()->AttrValueIs(kNameSpaceID_None,
++                                               nsNativeMenuAtoms::_moz_menubarkeeplocal,
++                                               nsGkAtoms::_true,
++                                               eCaseMatters)) {
++        return NS_OK;
++    }
++
++    UniquePtr<nsMenuBar> menubar(nsMenuBar::Create(aParent, aMenuBarNode));
++    if (!menubar) {
++        NS_WARNING("Failed to create menubar");
++        return NS_ERROR_FAILURE;
++    }
++
++    // Unity forgets our window if it is unmapped by the application, which
++    // happens with some extensions that add "minimize to tray" type
++    // functionality. We hook on to the MapNotify event to re-register our menu
++    // with Unity
++    g_signal_connect(G_OBJECT(menubar->TopLevelWindow()),
++                     "map-event", G_CALLBACK(map_event_cb),
++                     menubar.get());
++
++    mMenuBars.AppendElement(menubar.get());
++    RegisterNativeMenuBar(menubar.get());
++
++    static_cast<nsWindow *>(aParent)->SetMenuBar(Move(menubar));
++
++    return NS_OK;
++}
++
++/* static */ already_AddRefed<nsNativeMenuService>
++nsNativeMenuService::GetInstanceForServiceManager()
++{
++    RefPtr<nsNativeMenuService> service(sService);
++
++    if (service) {
++        return service.forget();
++    }
++
++    service = new nsNativeMenuService();
++
++    if (NS_FAILED(service->Init())) {
++        return nullptr;
++    }
++
++    sService = service.get();
++    return service.forget();
++}
++
++/* static */ nsNativeMenuService*
++nsNativeMenuService::GetSingleton()
++{
++    EnsureInitialized();
++    return sService;
++}
++
++void
++nsNativeMenuService::NotifyNativeMenuBarDestroyed(nsMenuBar *aMenuBar)
++{
++    g_signal_handlers_disconnect_by_func(aMenuBar->TopLevelWindow(),
++                                         FuncToGpointer(map_event_cb),
++                                         aMenuBar);
++
++    mMenuBars.RemoveElement(aMenuBar);
++
++    GCancellable *cancellable = nullptr;
++    if (mMenuBarRegistrationCancellables.Get(aMenuBar, &cancellable)) {
++        mMenuBarRegistrationCancellables.Remove(aMenuBar);
++        g_cancellable_cancel(cancellable);
++        g_object_unref(cancellable);
++    }
++}
+diff --git a/widget/gtk/nsNativeMenuService.h b/widget/gtk/nsNativeMenuService.h
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsNativeMenuService.h
+@@ -0,0 +1,84 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* This Source Code Form is subject to the terms of the Mozilla Public
++ * License, v. 2.0. If a copy of the MPL was not distributed with this
++ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++
++#ifndef __nsNativeMenuService_h__
++#define __nsNativeMenuService_h__
++
++#include "mozilla/Attributes.h"
++#include "nsCOMPtr.h"
++#include "nsDataHashtable.h"
++#include "nsINativeMenuService.h"
++#include "nsTArray.h"
++
++#include <gdk/gdk.h>
++#include <gio/gio.h>
++#include <gtk/gtk.h>
++
++class nsMenuBar;
++
++/*
++ * The main native menu service singleton. nsWebShellWindow calls in to this when
++ * a new top level window is created.
++ *
++ * Menubars are owned by their nsWindow. This service holds a weak reference to
++ * each menubar for the purpose of re-registering them with the shell if it
++ * needs to. The menubar is responsible for notifying the service when the last
++ * reference to it is dropped.
++ */
++class nsNativeMenuService final : public nsINativeMenuService
++{
++public:
++    NS_DECL_ISUPPORTS
++
++    NS_IMETHOD CreateNativeMenuBar(nsIWidget* aParent, mozilla::dom::Element* aMenuBarNode) override;
++
++    // Returns the singleton addref'd for the service manager
++    static already_AddRefed<nsNativeMenuService> GetInstanceForServiceManager();
++
++    // Returns the singleton without increasing the reference count
++    static nsNativeMenuService* GetSingleton();
++
++    // Called by a menubar when it is deleted
++    void NotifyNativeMenuBarDestroyed(nsMenuBar *aMenuBar);
++
++private:
++    nsNativeMenuService();
++    ~nsNativeMenuService();
++    nsresult Init();
++
++    static void EnsureInitialized();
++    void SetOnline(bool aOnline);
++    void RegisterNativeMenuBar(nsMenuBar *aMenuBar);
++    static void name_owner_changed_cb(GObject *gobject,
++                                      GParamSpec *pspec,
++                                      gpointer user_data);
++    static void proxy_created_cb(GObject *source_object,
++                                 GAsyncResult *res,
++                                 gpointer user_data);
++    static void register_native_menubar_cb(GObject *source_object,
++                                           GAsyncResult *res,
++                                           gpointer user_data);
++    static gboolean map_event_cb(GtkWidget *widget, GdkEvent *event,
++                                 gpointer user_data);
++    void OnNameOwnerChanged();
++    void OnProxyCreated(GDBusProxy *aProxy);
++    void OnNativeMenuBarRegistered(nsMenuBar *aMenuBar,
++                                   bool aSuccess);
++    static void PrefChangedCallback(const char *aPref, void *aClosure);
++    void PrefChanged();
++
++    GCancellable *mCreateProxyCancellable;
++    GDBusProxy *mDbusProxy;
++    bool mOnline;
++    nsTArray<nsMenuBar *> mMenuBars;
++    nsDataHashtable<nsPtrHashKey<nsMenuBar>, GCancellable*> mMenuBarRegistrationCancellables;
++
++    static bool sShutdown;
++    static nsNativeMenuService *sService;
++};
++
++#endif /* __nsNativeMenuService_h__ */
+diff --git a/widget/gtk/nsWidgetFactory.cpp b/widget/gtk/nsWidgetFactory.cpp
+--- a/widget/gtk/nsWidgetFactory.cpp
++++ b/widget/gtk/nsWidgetFactory.cpp
+@@ -43,16 +43,18 @@
+ #include "nsImageToPixbuf.h"
+ #include "nsPrintDialogGTK.h"
+ 
+ #if defined(MOZ_X11)
+ #include "nsIdleServiceGTK.h"
+ #include "GfxInfoX11.h"
+ #endif
+ 
++#include "nsNativeMenuService.h"
++
+ #include "nsNativeThemeGTK.h"
+ #include "HeadlessThemeGTK.h"
+ 
+ #include "nsIComponentRegistrar.h"
+ #include "nsComponentManagerUtils.h"
+ #include "mozilla/gfx/2D.h"
+ #include "mozilla/widget/ScreenManager.h"
+ #include <gtk/gtk.h>
+@@ -111,16 +113,19 @@ nsNativeThemeGTKConstructor(nsISupports 
+ namespace mozilla {
+ namespace widget {
+ // This constructor should really be shared with all platforms.
+ NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(GfxInfo, Init)
+ }
+ }
+ #endif
+ 
++NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsNativeMenuService,
++                                         nsNativeMenuService::GetInstanceForServiceManager)
++
+ #ifdef NS_PRINTING
+ NS_GENERIC_FACTORY_CONSTRUCTOR(nsDeviceContextSpecGTK)
+ NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsPrintSettingsServiceGTK, Init)
+ NS_GENERIC_FACTORY_CONSTRUCTOR(nsPrinterEnumeratorGTK)
+ NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsPrintSession, Init)
+ NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsPrintDialogServiceGTK, Init)
+ #endif
+ 
+@@ -224,16 +229,17 @@ NS_DEFINE_NAMED_CID(NS_PRINTSESSION_CID)
+ NS_DEFINE_NAMED_CID(NS_DEVICE_CONTEXT_SPEC_CID);
+ NS_DEFINE_NAMED_CID(NS_PRINTDIALOGSERVICE_CID);
+ #endif
+ NS_DEFINE_NAMED_CID(NS_IMAGE_TO_PIXBUF_CID);
+ #if defined(MOZ_X11)
+ NS_DEFINE_NAMED_CID(NS_IDLE_SERVICE_CID);
+ NS_DEFINE_NAMED_CID(NS_GFXINFO_CID);
+ #endif
++NS_DEFINE_NAMED_CID(NS_NATIVEMENUSERVICE_CID);
+ 
+ 
+ static const mozilla::Module::CIDEntry kWidgetCIDs[] = {
+     { &kNS_WINDOW_CID, false, nullptr, nsWindowConstructor },
+     { &kNS_CHILD_CID, false, nullptr, nsWindowConstructor },
+     { &kNS_APPSHELL_CID, false, nullptr, nsAppShellConstructor, Module::ALLOW_IN_GPU_PROCESS },
+     { &kNS_COLORPICKER_CID, false, nullptr, nsColorPickerConstructor, Module::MAIN_PROCESS_ONLY },
+     { &kNS_FILEPICKER_CID, false, nullptr, nsFilePickerConstructor, Module::MAIN_PROCESS_ONLY },
+@@ -260,16 +266,17 @@ static const mozilla::Module::CIDEntry k
+     { &kNS_DEVICE_CONTEXT_SPEC_CID, false, nullptr, nsDeviceContextSpecGTKConstructor },
+     { &kNS_PRINTDIALOGSERVICE_CID, false, nullptr, nsPrintDialogServiceGTKConstructor },
+ #endif
+     { &kNS_IMAGE_TO_PIXBUF_CID, false, nullptr, nsImageToPixbufConstructor },
+ #if defined(MOZ_X11)
+     { &kNS_IDLE_SERVICE_CID, false, nullptr, nsIdleServiceGTKConstructor },
+     { &kNS_GFXINFO_CID, false, nullptr, mozilla::widget::GfxInfoConstructor },
+ #endif
++    { &kNS_NATIVEMENUSERVICE_CID, true, NULL, nsNativeMenuServiceConstructor },
+     { nullptr }
+ };
+ 
+ static const mozilla::Module::ContractIDEntry kWidgetContracts[] = {
+     { "@mozilla.org/widget/window/gtk;1", &kNS_WINDOW_CID },
+     { "@mozilla.org/widgets/child_window/gtk;1", &kNS_CHILD_CID },
+     { "@mozilla.org/widget/appshell/gtk;1", &kNS_APPSHELL_CID, Module::ALLOW_IN_GPU_PROCESS },
+     { "@mozilla.org/colorpicker;1", &kNS_COLORPICKER_CID, Module::MAIN_PROCESS_ONLY },
+@@ -298,16 +305,17 @@ static const mozilla::Module::ContractID
+     { "@mozilla.org/gfx/devicecontextspec;1", &kNS_DEVICE_CONTEXT_SPEC_CID },
+     { NS_PRINTDIALOGSERVICE_CONTRACTID, &kNS_PRINTDIALOGSERVICE_CID },
+ #endif
+     { "@mozilla.org/widget/image-to-gdk-pixbuf;1", &kNS_IMAGE_TO_PIXBUF_CID },
+ #if defined(MOZ_X11)
+     { "@mozilla.org/widget/idleservice;1", &kNS_IDLE_SERVICE_CID },
+     { "@mozilla.org/gfx/info;1", &kNS_GFXINFO_CID },
+ #endif
++    { "@mozilla.org/widget/nativemenuservice;1", &kNS_NATIVEMENUSERVICE_CID },
+     { nullptr }
+ };
+ 
+ static void
+ nsWidgetGtk2ModuleDtor()
+ {
+   // Shutdown all XP level widget classes.
+   WidgetUtils::Shutdown();
+diff --git a/widget/gtk/nsWindow.cpp b/widget/gtk/nsWindow.cpp
+--- a/widget/gtk/nsWindow.cpp
++++ b/widget/gtk/nsWindow.cpp
+@@ -63,16 +63,17 @@
+ 
+ #ifdef MOZ_ENABLE_STARTUP_NOTIFICATION
+ #define SN_API_NOT_YET_FROZEN
+ #include <startup-notification-1.0/libsn/sn.h>
+ #endif
+ 
+ #include "mozilla/Assertions.h"
+ #include "mozilla/Likely.h"
++#include "mozilla/Move.h"
+ #include "mozilla/Preferences.h"
+ #include "nsIPrefService.h"
+ #include "nsIGConfService.h"
+ #include "nsIServiceManager.h"
+ #include "nsGfxCIID.h"
+ #include "nsGtkUtils.h"
+ #include "nsIObserverService.h"
+ #include "mozilla/layers/LayersTypes.h"
+@@ -5219,16 +5220,21 @@ nsWindow::SetWindowDecoration(nsBorderSt
+ }
+ 
+ void
+ nsWindow::HideWindowChrome(bool aShouldHide)
+ {
+     SetWindowDecoration(aShouldHide ? eBorderStyle_none : mBorderStyle);
+ }
+ 
++void
++nsWindow::SetMenuBar(UniquePtr<nsMenuBar> aMenuBar) {
++    mMenuBar = mozilla::Move(aMenuBar);
++}
++
+ bool
+ nsWindow::CheckForRollup(gdouble aMouseX, gdouble aMouseY,
+                          bool aIsWheel, bool aAlwaysRollup)
+ {
+     nsIRollupListener* rollupListener = GetActiveRollupListener();
+     nsCOMPtr<nsIWidget> rollupWidget;
+     if (rollupListener) {
+         rollupWidget = rollupListener->GetRollupWidget();
+diff --git a/widget/gtk/nsWindow.h b/widget/gtk/nsWindow.h
+--- a/widget/gtk/nsWindow.h
++++ b/widget/gtk/nsWindow.h
+@@ -35,16 +35,18 @@
+ #ifdef ACCESSIBILITY
+ #include "mozilla/a11y/Accessible.h"
+ #endif
+ #include "mozilla/EventForwards.h"
+ #include "mozilla/TouchEvents.h"
+ 
+ #include "IMContextWrapper.h"
+ 
++#include "nsMenuBar.h"
++
+ #undef LOG
+ #ifdef MOZ_LOGGING
+ 
+ #include "mozilla/Logging.h"
+ #include "nsTArray.h"
+ #include "Units.h"
+ 
+ extern mozilla::LazyLogModule gWidgetLog;
+@@ -159,16 +161,18 @@ public:
+                                              uint16_t aDuration,
+                                              nsISupports* aData,
+                                              nsIRunnable* aCallback) override;
+     virtual already_AddRefed<nsIScreen> GetWidgetScreen() override;
+     virtual nsresult   MakeFullScreen(bool aFullScreen,
+                                       nsIScreen* aTargetScreen = nullptr) override;
+     virtual void       HideWindowChrome(bool aShouldHide) override;
+ 
++    void               SetMenuBar(mozilla::UniquePtr<nsMenuBar> aMenuBar);
++
+     /**
+      * GetLastUserInputTime returns a timestamp for the most recent user input
+      * event.  This is intended for pointer grab requests (including drags).
+      */
+     static guint32     GetLastUserInputTime();
+ 
+     // utility method, -1 if no change should be made, otherwise returns a
+     // value that can be passed to gdk_window_set_decorations
+@@ -632,11 +636,13 @@ private:
+      * all windows in a hierarchy.  If the children are released after the top
+      * level window is released, the children still have a valid pointer,
+      * however, IME doesn't work at that time.
+      */
+     RefPtr<mozilla::widget::IMContextWrapper> mIMContext;
+ 
+     mozilla::UniquePtr<mozilla::CurrentX11TimeGetter> mCurrentTimeGetter;
+     static CSDSupportLevel sCSDSupportLevel;
++
++    mozilla::UniquePtr<nsMenuBar> mMenuBar;
+ };
+ 
+ #endif /* __nsWindow_h__ */
+diff --git a/widget/moz.build b/widget/moz.build
+--- a/widget/moz.build
++++ b/widget/moz.build
+@@ -60,19 +60,19 @@ elif toolkit == 'cocoa':
+     XPIDL_SOURCES += [
+         'nsIMacDockSupport.idl',
+         'nsIMacSharingService.idl',
+         'nsIMacWebAppUtils.idl',
+         'nsIStandaloneNativeMenu.idl',
+         'nsISystemStatusBar.idl',
+         'nsITaskbarProgress.idl',
+     ]
+-    EXPORTS += [
+-        'nsINativeMenuService.h',
+-    ]
++
++if toolkit in ('cocoa', 'gtk3'):
++    EXPORTS += ['nsINativeMenuService.h']
+ 
+ TEST_DIRS += ['tests']
+ 
+ DIRS += ['headless']
+ 
+ # Don't build the DSO under the 'build' directory as windows does.
+ #
+ # The DSOs get built in the toolkit dir itself.  Do this so that
+diff --git a/xpfe/appshell/nsWebShellWindow.cpp b/xpfe/appshell/nsWebShellWindow.cpp
+--- a/xpfe/appshell/nsWebShellWindow.cpp
++++ b/xpfe/appshell/nsWebShellWindow.cpp
+@@ -62,17 +62,17 @@
+ #include "mozilla/DebugOnly.h"
+ #include "mozilla/EventDispatcher.h"
+ #include "mozilla/MouseEvents.h"
+ 
+ #include "nsPIWindowRoot.h"
+ 
+ #include "gfxPlatform.h"
+ 
+-#ifdef XP_MACOSX
++#if defined(XP_MACOSX) || defined(MOZ_WIDGET_GTK)
+ #include "nsINativeMenuService.h"
+ #define USE_NATIVE_MENUS
+ #endif
+ 
+ using namespace mozilla;
+ using namespace mozilla::dom;
+ 
+ /* Define Class IDs */
diff --git a/unity-menubar.patch.tar.xz b/unity-menubar.patch.tar.xz
deleted file mode 100644
index a180b14ed0a3..000000000000
--- a/unity-menubar.patch.tar.xz
+++ /dev/null