Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2268 insertions, 0 deletions

diff --git a/browser/base/content/browser-places.js b/browser/base/content/browser-places.js
new file mode 100644
index 0000000000..1b9cfb9b76
--- /dev/null
+++ b/browser/base/content/browser-places.js
@@ -0,0 +1,2268 @@
+/* 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/. */
+
+// This file is loaded into the browser window scope.
+/* eslint-env mozilla/browser-window */
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  this,
+  "NEWTAB_ENABLED",
+  "browser.newtabpage.enabled",
+  false
+);
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  this,
+  "SHOW_OTHER_BOOKMARKS",
+  "browser.toolbars.bookmarks.showOtherBookmarks",
+  true,
+  (aPref, aPrevVal, aNewVal) => {
+    BookmarkingUI.maybeShowOtherBookmarksFolder().then(() => {
+      document
+        .getElementById("PlacesToolbar")
+        ?._placesView?.updateNodesVisibility();
+    }, console.error);
+  }
+);
+ChromeUtils.defineESModuleGetters(this, {
+  PanelMultiView: "resource:///modules/PanelMultiView.sys.mjs",
+  RecentlyClosedTabsAndWindowsMenuUtils:
+    "resource:///modules/sessionstore/RecentlyClosedTabsAndWindowsMenuUtils.sys.mjs",
+});
+
+var StarUI = {
+  _itemGuids: null,
+  _isNewBookmark: false,
+  _isComposing: false,
+  _autoCloseTimer: 0,
+  // The autoclose timer is diasbled if the user interacts with the
+  // popup, such as making a change through typing or clicking on
+  // the popup.
+  _autoCloseTimerEnabled: true,
+  // The autoclose timeout length. 3500ms matches the timeout that Pocket uses
+  // in browser/components/pocket/content/panels/js/saved.js.
+  _autoCloseTimeout: 3500,
+  _removeBookmarksOnPopupHidden: false,
+
+  _element(aID) {
+    return document.getElementById(aID);
+  },
+
+  // Edit-bookmark panel
+  get panel() {
+    delete this.panel;
+    this._createPanelIfNeeded();
+    var element = this._element("editBookmarkPanel");
+    // initially the panel is hidden
+    // to avoid impacting startup / new window performance
+    element.hidden = false;
+    element.addEventListener("keypress", this, { mozSystemGroup: true });
+    element.addEventListener("mousedown", this);
+    element.addEventListener("mouseout", this);
+    element.addEventListener("mousemove", this);
+    element.addEventListener("compositionstart", this);
+    element.addEventListener("compositionend", this);
+    element.addEventListener("input", this);
+    element.addEventListener("popuphidden", this);
+    element.addEventListener("popupshown", this);
+    return (this.panel = element);
+  },
+
+  // nsIDOMEventListener
+  handleEvent(aEvent) {
+    switch (aEvent.type) {
+      case "mousemove":
+        clearTimeout(this._autoCloseTimer);
+        // The autoclose timer is not disabled on generic mouseout
+        // because the user may not have actually interacted with the popup.
+        break;
+      case "popuphidden": {
+        clearTimeout(this._autoCloseTimer);
+        if (aEvent.originalTarget == this.panel) {
+          this._handlePopupHiddenEvent().catch(console.error);
+        }
+        break;
+      }
+      case "keypress":
+        clearTimeout(this._autoCloseTimer);
+        this._autoCloseTimerEnabled = false;
+
+        if (aEvent.defaultPrevented) {
+          // The event has already been consumed inside of the panel.
+          break;
+        }
+
+        switch (aEvent.keyCode) {
+          case KeyEvent.DOM_VK_ESCAPE:
+            if (this._isNewBookmark) {
+              this._removeBookmarksOnPopupHidden = true;
+            }
+            this.panel.hidePopup();
+            break;
+          case KeyEvent.DOM_VK_RETURN:
+            if (
+              aEvent.target.classList.contains("expander-up") ||
+              aEvent.target.classList.contains("expander-down") ||
+              aEvent.target.id == "editBMPanel_newFolderButton" ||
+              aEvent.target.id == "editBookmarkPanelRemoveButton"
+            ) {
+              // XXX Why is this necessary? The defaultPrevented check should
+              //    be enough.
+              break;
+            }
+            this.panel.hidePopup();
+            break;
+          // This case is for catching character-generating keypresses
+          case 0:
+            let accessKey = document.getElementById("key_close");
+            if (eventMatchesKey(aEvent, accessKey)) {
+              this.panel.hidePopup();
+            }
+            break;
+        }
+        break;
+      case "compositionend":
+        // After composition is committed, "mouseout" or something can set
+        // auto close timer.
+        this._isComposing = false;
+        break;
+      case "compositionstart":
+        if (aEvent.defaultPrevented) {
+          // If the composition was canceled, nothing to do here.
+          break;
+        }
+        this._isComposing = true;
+      // Explicit fall-through, during composition, panel shouldn't be hidden automatically.
+      case "input":
+      // Might have edited some text without keyboard events nor composition
+      // events. Fall-through to cancel auto close in such case.
+      case "mousedown":
+        clearTimeout(this._autoCloseTimer);
+        this._autoCloseTimerEnabled = false;
+        break;
+      case "mouseout":
+        if (!this._autoCloseTimerEnabled) {
+          // Don't autoclose the popup if the user has made a selection
+          // or keypress and then subsequently mouseout.
+          break;
+        }
+      // Explicit fall-through
+      case "popupshown":
+        // Don't handle events for descendent elements.
+        if (aEvent.target != aEvent.currentTarget) {
+          break;
+        }
+        // auto-close if new and not interacted with
+        if (this._isNewBookmark && !this._isComposing) {
+          let delay = this._autoCloseTimeout;
+          if (this._closePanelQuickForTesting) {
+            delay /= 10;
+          }
+          clearTimeout(this._autoCloseTimer);
+          this._autoCloseTimer = setTimeout(() => {
+            if (!this.panel.matches(":hover")) {
+              this.panel.hidePopup(true);
+            }
+          }, delay);
+          this._autoCloseTimerEnabled = true;
+        }
+        break;
+    }
+  },
+
+  /**
+   * Handle popup hidden event.
+   */
+  async _handlePopupHiddenEvent() {
+    const { bookmarkState, didChangeFolder, selectedFolderGuid } =
+      gEditItemOverlay;
+    gEditItemOverlay.uninitPanel(true);
+
+    // Capture _removeBookmarksOnPopupHidden and _itemGuids values. Reset them
+    // before we handle the next popup.
+    const removeBookmarksOnPopupHidden = this._removeBookmarksOnPopupHidden;
+    this._removeBookmarksOnPopupHidden = false;
+    const guidsForRemoval = this._itemGuids;
+    this._itemGuids = null;
+
+    if (removeBookmarksOnPopupHidden && guidsForRemoval) {
+      if (!this._isNewBookmark) {
+        // Remove all bookmarks for the bookmark's url, this also removes
+        // the tags for the url.
+        await PlacesTransactions.Remove(guidsForRemoval).transact();
+      } else {
+        BookmarkingUI.star.removeAttribute("starred");
+      }
+      return;
+    }
+
+    await this._storeRecentlyUsedFolder(selectedFolderGuid, didChangeFolder);
+    await bookmarkState.save();
+    if (this._isNewBookmark) {
+      this.showConfirmation();
+    }
+  },
+
+  async showEditBookmarkPopup(aNode, aIsNewBookmark, aUrl) {
+    // Slow double-clicks (not true double-clicks) shouldn't
+    // cause the panel to flicker.
+    if (this.panel.state != "closed") {
+      return;
+    }
+
+    this._isNewBookmark = aIsNewBookmark;
+    this._itemGuids = null;
+
+    let titleL10nID = this._isNewBookmark
+      ? "bookmarks-add-bookmark"
+      : "bookmarks-edit-bookmark";
+    document.l10n.setAttributes(
+      this._element("editBookmarkPanelTitle"),
+      titleL10nID
+    );
+
+    this._element("editBookmarkPanel_showForNewBookmarks").checked =
+      this.showForNewBookmarks;
+
+    this._itemGuids = [];
+    await PlacesUtils.bookmarks.fetch({ url: aUrl }, bookmark =>
+      this._itemGuids.push(bookmark.guid)
+    );
+
+    let removeButton = this._element("editBookmarkPanelRemoveButton");
+    if (this._isNewBookmark) {
+      document.l10n.setAttributes(removeButton, "bookmark-panel-cancel");
+    } else {
+      // The label of the remove button differs if the URI is bookmarked
+      // multiple times.
+      document.l10n.setAttributes(removeButton, "bookmark-panel-remove", {
+        count: this._itemGuids.length,
+      });
+    }
+
+    this._setIconAndPreviewImage();
+
+    let onPanelReady = fn => {
+      let target = this.panel;
+      if (target.parentNode) {
+        // By targeting the panel's parent and using a capturing listener, we
+        // can have our listener called before others waiting for the panel to
+        // be shown (which probably expect the panel to be fully initialized)
+        target = target.parentNode;
+      }
+      target.addEventListener(
+        "popupshown",
+        function (event) {
+          fn();
+        },
+        { capture: true, once: true }
+      );
+    };
+    await gEditItemOverlay.initPanel({
+      node: aNode,
+      onPanelReady,
+      hiddenRows: ["location", "keyword"],
+      focusedElement: "preferred",
+      isNewBookmark: this._isNewBookmark,
+    });
+
+    this.panel.openPopup(BookmarkingUI.anchor, "bottomright topright");
+  },
+
+  _createPanelIfNeeded() {
+    // Lazy load the editBookmarkPanel the first time we need to display it.
+    if (!this._element("editBookmarkPanel")) {
+      MozXULElement.insertFTLIfNeeded("browser/editBookmarkOverlay.ftl");
+      let template = this._element("editBookmarkPanelTemplate");
+      let clone = template.content.cloneNode(true);
+      template.replaceWith(clone);
+    }
+  },
+
+  _setIconAndPreviewImage() {
+    let faviconImage = this._element("editBookmarkPanelFavicon");
+    faviconImage.removeAttribute("iconloadingprincipal");
+    faviconImage.removeAttribute("src");
+
+    let tab = gBrowser.selectedTab;
+    if (tab.hasAttribute("image") && !tab.hasAttribute("busy")) {
+      faviconImage.setAttribute(
+        "iconloadingprincipal",
+        tab.getAttribute("iconloadingprincipal")
+      );
+      faviconImage.setAttribute("src", tab.getAttribute("image"));
+    }
+
+    let canvas = PageThumbs.createCanvas(window);
+    PageThumbs.captureToCanvas(gBrowser.selectedBrowser, canvas).catch(e =>
+      console.error(e)
+    );
+    document.mozSetImageElement("editBookmarkPanelImageCanvas", canvas);
+  },
+
+  removeBookmarkButtonCommand: function SU_removeBookmarkButtonCommand() {
+    this._removeBookmarksOnPopupHidden = true;
+    this.panel.hidePopup();
+  },
+
+  async _storeRecentlyUsedFolder(selectedFolderGuid, didChangeFolder) {
+    if (!selectedFolderGuid) {
+      return;
+    }
+
+    // If we're changing where a bookmark gets saved, persist that location.
+    if (didChangeFolder) {
+      Services.prefs.setCharPref(
+        "browser.bookmarks.defaultLocation",
+        selectedFolderGuid
+      );
+    }
+
+    // Don't store folders that are always displayed in "Recent Folders".
+    if (PlacesUtils.bookmarks.userContentRoots.includes(selectedFolderGuid)) {
+      return;
+    }
+
+    // List of recently used folders:
+    let lastUsedFolderGuids = await PlacesUtils.metadata.get(
+      PlacesUIUtils.LAST_USED_FOLDERS_META_KEY,
+      []
+    );
+
+    let index = lastUsedFolderGuids.indexOf(selectedFolderGuid);
+    if (index > 1) {
+      // The guid is in the array but not the most recent.
+      lastUsedFolderGuids.splice(index, 1);
+      lastUsedFolderGuids.unshift(selectedFolderGuid);
+    } else if (index == -1) {
+      lastUsedFolderGuids.unshift(selectedFolderGuid);
+    }
+    while (lastUsedFolderGuids.length > PlacesUIUtils.maxRecentFolders) {
+      lastUsedFolderGuids.pop();
+    }
+
+    await PlacesUtils.metadata.set(
+      PlacesUIUtils.LAST_USED_FOLDERS_META_KEY,
+      lastUsedFolderGuids
+    );
+  },
+
+  onShowForNewBookmarksCheckboxCommand() {
+    Services.prefs.setBoolPref(
+      "browser.bookmarks.editDialog.showForNewBookmarks",
+      this._element("editBookmarkPanel_showForNewBookmarks").checked
+    );
+  },
+
+  showConfirmation() {
+    // Show the "Saved to bookmarks" hint for the first three times
+    const HINT_COUNT_PREF =
+      "browser.bookmarks.editDialog.confirmationHintShowCount";
+    const HINT_COUNT = Services.prefs.getIntPref(HINT_COUNT_PREF, 0);
+
+    if (HINT_COUNT >= 3) {
+      return;
+    }
+    Services.prefs.setIntPref(HINT_COUNT_PREF, HINT_COUNT + 1);
+
+    let anchor;
+    if (window.toolbar.visible) {
+      for (let id of ["library-button", "bookmarks-menu-button"]) {
+        let element = document.getElementById(id);
+        if (
+          element &&
+          element.getAttribute("cui-areatype") != "panel" &&
+          element.getAttribute("overflowedItem") != "true"
+        ) {
+          anchor = element;
+          break;
+        }
+      }
+    }
+    if (!anchor) {
+      anchor = document.getElementById("PanelUI-menu-button");
+    }
+    ConfirmationHint.show(anchor, "confirmation-hint-page-bookmarked");
+  },
+};
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  StarUI,
+  "showForNewBookmarks",
+  "browser.bookmarks.editDialog.showForNewBookmarks"
+);
+
+var PlacesCommandHook = {
+  /**
+   * Adds a bookmark to the page loaded in the current browser.
+   */
+  async bookmarkPage() {
+    let browser = gBrowser.selectedBrowser;
+    let url = URL.fromURI(browser.currentURI);
+    let info = await PlacesUtils.bookmarks.fetch({ url });
+    let isNewBookmark = !info;
+    let showEditUI = !isNewBookmark || StarUI.showForNewBookmarks;
+    if (isNewBookmark) {
+      // This is async because we have to validate the guid
+      // coming from prefs.
+      let parentGuid = await PlacesUIUtils.defaultParentGuid;
+      info = { url, parentGuid };
+      // Bug 1148838 - Make this code work for full page plugins.
+      let charset = null;
+
+      let isErrorPage = false;
+      if (browser.documentURI) {
+        isErrorPage = /^about:(neterror|certerror|blocked)/.test(
+          browser.documentURI.spec
+        );
+      }
+
+      try {
+        if (isErrorPage) {
+          let entry = await PlacesUtils.history.fetch(browser.currentURI);
+          if (entry) {
+            info.title = entry.title;
+          }
+        } else {
+          info.title = browser.contentTitle;
+        }
+        info.title = info.title || url.href;
+        charset = browser.characterSet;
+      } catch (e) {
+        console.error(e);
+      }
+
+      if (!StarUI.showForNewBookmarks) {
+        info.guid = await PlacesTransactions.NewBookmark(info).transact();
+      } else {
+        info.guid = PlacesUtils.bookmarks.unsavedGuid;
+        BookmarkingUI.star.setAttribute("starred", "true");
+      }
+
+      if (charset) {
+        PlacesUIUtils.setCharsetForPage(url, charset, window).catch(
+          console.error
+        );
+      }
+    }
+
+    // Revert the contents of the location bar
+    gURLBar.handleRevert();
+
+    // If it was not requested to open directly in "edit" mode, we are done.
+    if (!showEditUI) {
+      StarUI.showConfirmation();
+      return;
+    }
+
+    let node = await PlacesUIUtils.promiseNodeLikeFromFetchInfo(info);
+
+    await StarUI.showEditBookmarkPopup(node, isNewBookmark, url);
+  },
+
+  /**
+   * Adds a bookmark to the page targeted by a link.
+   * @param url (string)
+   *        the address of the link target
+   * @param title
+   *        The link text
+   */
+  async bookmarkLink(url, title) {
+    let bm = await PlacesUtils.bookmarks.fetch({ url });
+    if (bm) {
+      let node = await PlacesUIUtils.promiseNodeLikeFromFetchInfo(bm);
+      await PlacesUIUtils.showBookmarkDialog(
+        { action: "edit", node },
+        window.top
+      );
+      return;
+    }
+
+    let parentGuid = await PlacesUIUtils.defaultParentGuid;
+    let defaultInsertionPoint = new PlacesInsertionPoint({
+      parentGuid,
+    });
+    await PlacesUIUtils.showBookmarkDialog(
+      {
+        action: "add",
+        type: "bookmark",
+        uri: Services.io.newURI(url),
+        title,
+        defaultInsertionPoint,
+        hiddenRows: ["location", "keyword"],
+      },
+      window.top
+    );
+  },
+
+  /**
+   * List of nsIURI objects characterizing tabs given in param.
+   * Duplicates are discarded.
+   */
+  getUniquePages(tabs) {
+    let uniquePages = {};
+    let URIs = [];
+
+    tabs.forEach(tab => {
+      let browser = tab.linkedBrowser;
+      let uri = browser.currentURI;
+      let title = browser.contentTitle || tab.label;
+      let spec = uri.spec;
+      if (!(spec in uniquePages)) {
+        uniquePages[spec] = null;
+        URIs.push({ uri, title });
+      }
+    });
+    return URIs;
+  },
+
+  /**
+   * List of nsIURI objects characterizing the tabs currently open in the
+   * browser, modulo pinned tabs. The URIs will be in the order in which their
+   * corresponding tabs appeared and duplicates are discarded.
+   */
+  get uniqueCurrentPages() {
+    let visibleUnpinnedTabs = gBrowser.visibleTabs.filter(tab => !tab.pinned);
+    return this.getUniquePages(visibleUnpinnedTabs);
+  },
+
+  /**
+   * List of nsIURI objects characterizing the tabs currently
+   * selected in the window. Duplicates are discarded.
+   */
+  get uniqueSelectedPages() {
+    return this.getUniquePages(gBrowser.selectedTabs);
+  },
+
+  /**
+   * Opens the Places Organizer.
+   * @param {String} item The item to select in the organizer window,
+   *                      options are (case sensitive):
+   *                      BookmarksMenu, BookmarksToolbar, UnfiledBookmarks,
+   *                      AllBookmarks, History, Downloads.
+   */
+  showPlacesOrganizer(item) {
+    var organizer = Services.wm.getMostRecentWindow("Places:Organizer");
+    // Due to bug 528706, getMostRecentWindow can return closed windows.
+    if (!organizer || organizer.closed) {
+      // No currently open places window, so open one with the specified mode.
+      openDialog(
+        "chrome://browser/content/places/places.xhtml",
+        "",
+        "chrome,toolbar=yes,dialog=no,resizable",
+        item
+      );
+    } else {
+      organizer.PlacesOrganizer.selectLeftPaneContainerByHierarchy(item);
+      organizer.focus();
+    }
+  },
+
+  searchBookmarks() {
+    gURLBar.search(UrlbarTokenizer.RESTRICT.BOOKMARK, {
+      searchModeEntry: "bookmarkmenu",
+    });
+  },
+
+  searchHistory() {
+    gURLBar.search(UrlbarTokenizer.RESTRICT.HISTORY, {
+      searchModeEntry: "historymenu",
+    });
+  },
+};
+
+// View for the history menu.
+class HistoryMenu extends PlacesMenu {
+  constructor(aPopupShowingEvent) {
+    super(aPopupShowingEvent, "place:sort=4&maxResults=15");
+  }
+
+  // Called by the base class (PlacesViewBase) so we can initialize some
+  // element references before the several superclass constructors call our
+  // methods which depend on these.
+  _init() {
+    super._init();
+    let elements = {
+      undoTabMenu: "historyUndoMenu",
+      hiddenTabsMenu: "hiddenTabsMenu",
+      undoWindowMenu: "historyUndoWindowMenu",
+      syncTabsMenuitem: "sync-tabs-menuitem",
+    };
+    for (let [key, elemId] of Object.entries(elements)) {
+      this[key] = document.getElementById(elemId);
+    }
+  }
+
+  _getClosedTabCount() {
+    try {
+      return SessionStore.getClosedTabCountForWindow(window);
+    } catch (ex) {
+      // SessionStore doesn't track the hidden window, so just return zero then.
+      return 0;
+    }
+  }
+
+  toggleHiddenTabs() {
+    const isShown =
+      window.gBrowser && gBrowser.visibleTabs.length < gBrowser.tabs.length;
+    this.hiddenTabsMenu.hidden = !isShown;
+  }
+
+  toggleRecentlyClosedTabs() {
+    // enable/disable the Recently Closed Tabs sub menu
+    // no restorable tabs, so disable menu
+    if (this._getClosedTabCount() == 0) {
+      this.undoTabMenu.setAttribute("disabled", true);
+    } else {
+      this.undoTabMenu.removeAttribute("disabled");
+    }
+  }
+
+  /**
+   * Populate when the history menu is opened
+   */
+  populateUndoSubmenu() {
+    var undoPopup = this.undoTabMenu.menupopup;
+
+    // remove existing menu items
+    while (undoPopup.hasChildNodes()) {
+      undoPopup.firstChild.remove();
+    }
+
+    // no restorable tabs, so make sure menu is disabled, and return
+    if (this._getClosedTabCount() == 0) {
+      this.undoTabMenu.setAttribute("disabled", true);
+      return;
+    }
+
+    // enable menu
+    this.undoTabMenu.removeAttribute("disabled");
+
+    // populate menu
+    let tabsFragment = RecentlyClosedTabsAndWindowsMenuUtils.getTabsFragment(
+      window,
+      "menuitem",
+      /* aPrefixRestoreAll = */ false
+    );
+    undoPopup.appendChild(tabsFragment);
+  }
+
+  toggleRecentlyClosedWindows() {
+    // enable/disable the Recently Closed Windows sub menu
+    // no restorable windows, so disable menu
+    if (SessionStore.getClosedWindowCount() == 0) {
+      this.undoWindowMenu.setAttribute("disabled", true);
+    } else {
+      this.undoWindowMenu.removeAttribute("disabled");
+    }
+  }
+
+  /**
+   * Populate when the history menu is opened
+   */
+  populateUndoWindowSubmenu() {
+    let undoPopup = this.undoWindowMenu.menupopup;
+
+    // remove existing menu items
+    while (undoPopup.hasChildNodes()) {
+      undoPopup.firstChild.remove();
+    }
+
+    // no restorable windows, so make sure menu is disabled, and return
+    if (SessionStore.getClosedWindowCount() == 0) {
+      this.undoWindowMenu.setAttribute("disabled", true);
+      return;
+    }
+
+    // enable menu
+    this.undoWindowMenu.removeAttribute("disabled");
+
+    // populate menu
+    let windowsFragment =
+      RecentlyClosedTabsAndWindowsMenuUtils.getWindowsFragment(
+        window,
+        "menuitem",
+        /* aPrefixRestoreAll = */ false
+      );
+    undoPopup.appendChild(windowsFragment);
+  }
+
+  toggleTabsFromOtherComputers() {
+    // Enable/disable the Tabs From Other Computers menu. Some of the menus handled
+    // by HistoryMenu do not have this menuitem.
+    if (!this.syncTabsMenuitem) {
+      return;
+    }
+
+    if (!PlacesUIUtils.shouldShowTabsFromOtherComputersMenuitem()) {
+      this.syncTabsMenuitem.hidden = true;
+      return;
+    }
+
+    this.syncTabsMenuitem.hidden = false;
+  }
+
+  _onPopupShowing(aEvent) {
+    super._onPopupShowing(aEvent);
+
+    // Don't handle events for submenus.
+    if (aEvent.target != aEvent.currentTarget) {
+      return;
+    }
+
+    this.toggleHiddenTabs();
+    this.toggleRecentlyClosedTabs();
+    this.toggleRecentlyClosedWindows();
+    this.toggleTabsFromOtherComputers();
+  }
+
+  _onCommand(aEvent) {
+    aEvent = getRootEvent(aEvent);
+    let placesNode = aEvent.target._placesNode;
+    if (placesNode) {
+      if (!PrivateBrowsingUtils.isWindowPrivate(window)) {
+        PlacesUIUtils.markPageAsTyped(placesNode.uri);
+      }
+      openUILink(placesNode.uri, aEvent, {
+        ignoreAlt: true,
+        triggeringPrincipal:
+          Services.scriptSecurityManager.getSystemPrincipal(),
+      });
+    }
+  }
+}
+
+/**
+ * Functions for handling events in the Bookmarks Toolbar and menu.
+ */
+var BookmarksEventHandler = {
+  /**
+   * Handler for click event for an item in the bookmarks toolbar or menu.
+   * Menus and submenus from the folder buttons bubble up to this handler.
+   * Left-click is handled in the onCommand function.
+   * When items are middle-clicked (or clicked with modifier), open in tabs.
+   * If the click came through a menu, close the menu.
+   * @param aEvent
+   *        DOMEvent for the click
+   * @param aView
+   *        The places view which aEvent should be associated with.
+   */
+
+  onMouseUp(aEvent) {
+    // Handles middle-click or left-click with modifier if not browser.bookmarks.openInTabClosesMenu.
+    if (aEvent.button == 2 || PlacesUIUtils.openInTabClosesMenu) {
+      return;
+    }
+    let target = aEvent.originalTarget;
+    if (target.tagName != "menuitem") {
+      return;
+    }
+    let modifKey =
+      AppConstants.platform === "macosx" ? aEvent.metaKey : aEvent.ctrlKey;
+    if (modifKey || aEvent.button == 1) {
+      target.setAttribute("closemenu", "none");
+      var menupopup = target.parentNode;
+      menupopup.addEventListener(
+        "popuphidden",
+        () => {
+          target.removeAttribute("closemenu");
+        },
+        { once: true }
+      );
+    } else {
+      // Handles edge case where same menuitem was opened previously
+      // while menu was kept open, but now menu should close.
+      target.removeAttribute("closemenu");
+    }
+  },
+
+  onClick: function BEH_onClick(aEvent, aView) {
+    // Only handle middle-click or left-click with modifiers.
+    let modifKey;
+    if (AppConstants.platform == "macosx") {
+      modifKey = aEvent.metaKey || aEvent.shiftKey;
+    } else {
+      modifKey = aEvent.ctrlKey || aEvent.shiftKey;
+    }
+
+    if (aEvent.button == 2 || (aEvent.button == 0 && !modifKey)) {
+      return;
+    }
+
+    var target = aEvent.originalTarget;
+    // If this event bubbled up from a menu or menuitem,
+    // close the menus if browser.bookmarks.openInTabClosesMenu.
+    var tag = target.tagName;
+    if (
+      PlacesUIUtils.openInTabClosesMenu &&
+      (tag == "menuitem" || tag == "menu")
+    ) {
+      closeMenus(aEvent.target);
+    }
+
+    if (target._placesNode && PlacesUtils.nodeIsContainer(target._placesNode)) {
+      // Don't open the root folder in tabs when the empty area on the toolbar
+      // is middle-clicked or when a non-bookmark item (except for Open in Tabs)
+      // in a bookmarks menupopup is middle-clicked.
+      if (target.localName == "menu" || target.localName == "toolbarbutton") {
+        PlacesUIUtils.openMultipleLinksInTabs(
+          target._placesNode,
+          aEvent,
+          aView
+        );
+      }
+    } else if (aEvent.button == 1 && !(tag == "menuitem" || tag == "menu")) {
+      // Call onCommand in the cases where it's not called automatically:
+      // Middle-clicks outside of menus.
+      this.onCommand(aEvent);
+    }
+  },
+
+  /**
+   * Handler for command event for an item in the bookmarks toolbar.
+   * Menus and submenus from the folder buttons bubble up to this handler.
+   * Opens the item.
+   * @param aEvent
+   *        DOMEvent for the command
+   */
+  onCommand: function BEH_onCommand(aEvent) {
+    var target = aEvent.originalTarget;
+    if (target._placesNode) {
+      PlacesUIUtils.openNodeWithEvent(target._placesNode, aEvent);
+      // Only record interactions through the Bookmarks Toolbar
+      if (target.closest("#PersonalToolbar")) {
+        Services.telemetry.scalarAdd(
+          "browser.engagement.bookmarks_toolbar_bookmark_opened",
+          1
+        );
+      }
+    }
+  },
+
+  fillInBHTooltip: function BEH_fillInBHTooltip(aTooltip, aEvent) {
+    var node;
+    var cropped = false;
+    var targetURI;
+
+    if (aTooltip.triggerNode.localName == "treechildren") {
+      var tree = aTooltip.triggerNode.parentNode;
+      var cell = tree.getCellAt(aEvent.clientX, aEvent.clientY);
+      if (cell.row == -1) {
+        return false;
+      }
+      node = tree.view.nodeForTreeIndex(cell.row);
+      cropped = tree.isCellCropped(cell.row, cell.col);
+    } else {
+      // Check whether the tooltipNode is a Places node.
+      // In such a case use it, otherwise check for targetURI attribute.
+      var tooltipNode = aTooltip.triggerNode;
+      if (tooltipNode._placesNode) {
+        node = tooltipNode._placesNode;
+      } else {
+        // This is a static non-Places node.
+        targetURI = tooltipNode.getAttribute("targetURI");
+      }
+    }
+
+    if (!node && !targetURI) {
+      return false;
+    }
+
+    // Show node.label as tooltip's title for non-Places nodes.
+    var title = node ? node.title : tooltipNode.label;
+
+    // Show URL only for Places URI-nodes or nodes with a targetURI attribute.
+    var url;
+    if (targetURI || PlacesUtils.nodeIsURI(node)) {
+      url = targetURI || node.uri;
+    }
+
+    // Show tooltip for containers only if their title is cropped.
+    if (!cropped && !url) {
+      return false;
+    }
+
+    let tooltipTitle = aEvent.target.querySelector(".places-tooltip-title");
+    tooltipTitle.hidden = !title || title == url;
+    if (!tooltipTitle.hidden) {
+      tooltipTitle.textContent = title;
+    }
+
+    let tooltipUrl = aEvent.target.querySelector(".places-tooltip-uri");
+    tooltipUrl.hidden = !url;
+    if (!tooltipUrl.hidden) {
+      // Use `value` instead of `textContent` so cropping will apply
+      tooltipUrl.value = url;
+    }
+
+    // Show tooltip.
+    return true;
+  },
+};
+
+// Handles special drag and drop functionality for Places menus that are not
+// part of a Places view (e.g. the bookmarks menu in the menubar).
+var PlacesMenuDNDHandler = {
+  _springLoadDelayMs: 350,
+  _closeDelayMs: 500,
+  _loadTimer: null,
+  _closeTimer: null,
+  _closingTimerNode: null,
+
+  /**
+   * Called when the user enters the <menu> element during a drag.
+   * @param   event
+   *          The DragEnter event that spawned the opening.
+   */
+  onDragEnter: function PMDH_onDragEnter(event) {
+    // Opening menus in a Places popup is handled by the view itself.
+    if (!this._isStaticContainer(event.target)) {
+      return;
+    }
+
+    // If we re-enter the same menu or anchor before the close timer runs out,
+    // we should ensure that we do not close:
+    if (this._closeTimer && this._closingTimerNode === event.currentTarget) {
+      this._closeTimer.cancel();
+      this._closingTimerNode = null;
+      this._closeTimer = null;
+    }
+
+    PlacesControllerDragHelper.currentDropTarget = event.target;
+    let popup = event.target.menupopup;
+    if (
+      this._loadTimer ||
+      popup.state === "showing" ||
+      popup.state === "open"
+    ) {
+      return;
+    }
+
+    this._loadTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+    this._loadTimer.initWithCallback(
+      () => {
+        this._loadTimer = null;
+        popup.setAttribute("autoopened", "true");
+        popup.openPopup();
+      },
+      this._springLoadDelayMs,
+      Ci.nsITimer.TYPE_ONE_SHOT
+    );
+    event.preventDefault();
+    event.stopPropagation();
+  },
+
+  /**
+   * Handles dragleave on the <menu> element.
+   */
+  onDragLeave: function PMDH_onDragLeave(event) {
+    // Handle menu-button separate targets.
+    if (
+      event.relatedTarget === event.currentTarget ||
+      (event.relatedTarget &&
+        event.relatedTarget.parentNode === event.currentTarget)
+    ) {
+      return;
+    }
+
+    // Closing menus in a Places popup is handled by the view itself.
+    if (!this._isStaticContainer(event.target)) {
+      return;
+    }
+
+    PlacesControllerDragHelper.currentDropTarget = null;
+    let popup = event.target.menupopup;
+
+    if (this._loadTimer) {
+      this._loadTimer.cancel();
+      this._loadTimer = null;
+    }
+    this._closeTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+    this._closingTimerNode = event.currentTarget;
+    this._closeTimer.initWithCallback(
+      function () {
+        this._closeTimer = null;
+        this._closingTimerNode = null;
+        let node = PlacesControllerDragHelper.currentDropTarget;
+        let inHierarchy = false;
+        while (node && !inHierarchy) {
+          inHierarchy = node == event.target;
+          node = node.parentNode;
+        }
+        if (!inHierarchy && popup && popup.hasAttribute("autoopened")) {
+          popup.removeAttribute("autoopened");
+          popup.hidePopup();
+        }
+      },
+      this._closeDelayMs,
+      Ci.nsITimer.TYPE_ONE_SHOT
+    );
+  },
+
+  /**
+   * Determines if a XUL element represents a static container.
+   * @returns true if the element is a container element (menu or
+   *`         menu-toolbarbutton), false otherwise.
+   */
+  _isStaticContainer: function PMDH__isContainer(node) {
+    let isMenu =
+      node.localName == "menu" ||
+      (node.localName == "toolbarbutton" &&
+        node.getAttribute("type") == "menu");
+    let isStatic =
+      !("_placesNode" in node) &&
+      node.menupopup &&
+      node.menupopup.hasAttribute("placespopup") &&
+      !node.parentNode.hasAttribute("placespopup");
+    return isMenu && isStatic;
+  },
+
+  /**
+   * Called when the user drags over the <menu> element.
+   * @param   event
+   *          The DragOver event.
+   */
+  onDragOver: function PMDH_onDragOver(event) {
+    PlacesControllerDragHelper.currentDropTarget = event.target;
+    let ip = new PlacesInsertionPoint({
+      parentGuid: PlacesUtils.bookmarks.menuGuid,
+    });
+    if (ip && PlacesControllerDragHelper.canDrop(ip, event.dataTransfer)) {
+      event.preventDefault();
+    }
+
+    event.stopPropagation();
+  },
+
+  /**
+   * Called when the user drops on the <menu> element.
+   * @param   event
+   *          The Drop event.
+   */
+  onDrop: function PMDH_onDrop(event) {
+    // Put the item at the end of bookmark menu.
+    let ip = new PlacesInsertionPoint({
+      parentGuid: PlacesUtils.bookmarks.menuGuid,
+    });
+    PlacesControllerDragHelper.onDrop(ip, event.dataTransfer);
+    PlacesControllerDragHelper.currentDropTarget = null;
+    event.stopPropagation();
+  },
+};
+
+/**
+ * This object handles the initialization and uninitialization of the bookmarks
+ * toolbar. It also has helper functions for the managed bookmarks button.
+ */
+var PlacesToolbarHelper = {
+  get _viewElt() {
+    return document.getElementById("PlacesToolbar");
+  },
+
+  /**
+   * Initialize. This will check whether we've finished startup and can
+   * show toolbars.
+   */
+  async init() {
+    await PlacesUIUtils.canLoadToolbarContentPromise;
+    this._realInit();
+  },
+
+  /**
+   * Actually initialize the places view (if needed; we might still no-op).
+   */
+  _realInit() {
+    let viewElt = this._viewElt;
+    if (!viewElt || viewElt._placesView || window.closed) {
+      return;
+    }
+
+    // CustomizableUI.addListener is idempotent, so we can safely
+    // call this multiple times.
+    CustomizableUI.addListener(this);
+
+    if (!this._isObservingToolbars) {
+      this._isObservingToolbars = true;
+      window.addEventListener("toolbarvisibilitychange", this);
+    }
+
+    // If the bookmarks toolbar item is:
+    // - not in a toolbar, or;
+    // - the toolbar is collapsed, or;
+    // - the toolbar is hidden some other way:
+    // don't initialize.  Also, there is no need to initialize the toolbar if
+    // customizing, because that will happen when the customization is done.
+    let toolbar = this._getParentToolbar(viewElt);
+    if (
+      !toolbar ||
+      toolbar.collapsed ||
+      this._isCustomizing ||
+      getComputedStyle(toolbar, "").display == "none"
+    ) {
+      return;
+    }
+
+    new PlacesToolbar(
+      `place:parent=${PlacesUtils.bookmarks.toolbarGuid}`,
+      document.getElementById("PlacesToolbarItems"),
+      viewElt
+    );
+
+    if (
+      toolbar.id == "PersonalToolbar" &&
+      !toolbar.hasAttribute("initialized")
+    ) {
+      toolbar.setAttribute("initialized", "true");
+      BookmarkingUI.updateEmptyToolbarMessage().catch(console.error);
+    }
+  },
+
+  async getIsEmpty() {
+    if (!this._viewElt._placesView) {
+      return true;
+    }
+    await this._viewElt._placesView.promiseRebuilt();
+    return !document.getElementById("PlacesToolbarItems").hasChildNodes();
+  },
+
+  handleEvent(event) {
+    switch (event.type) {
+      case "toolbarvisibilitychange":
+        if (event.target == this._getParentToolbar(this._viewElt)) {
+          this._resetView();
+        }
+        break;
+    }
+  },
+
+  /**
+   * This is a no-op if we haven't been initialized.
+   */
+  uninit: function PTH_uninit() {
+    if (this._isObservingToolbars) {
+      delete this._isObservingToolbars;
+      window.removeEventListener("toolbarvisibilitychange", this);
+    }
+    CustomizableUI.removeListener(this);
+  },
+
+  customizeStart: function PTH_customizeStart() {
+    try {
+      let viewElt = this._viewElt;
+      if (viewElt && viewElt._placesView) {
+        viewElt._placesView.uninit();
+      }
+    } finally {
+      this._isCustomizing = true;
+    }
+  },
+
+  customizeDone: function PTH_customizeDone() {
+    this._isCustomizing = false;
+    this.init();
+  },
+
+  onPlaceholderCommand() {
+    let widgetGroup = CustomizableUI.getWidget("personal-bookmarks");
+    let widget = widgetGroup.forWindow(window);
+    if (
+      widget.overflowed ||
+      widgetGroup.areaType == CustomizableUI.TYPE_PANEL
+    ) {
+      PlacesCommandHook.showPlacesOrganizer("BookmarksToolbar");
+    }
+  },
+
+  _getParentToolbar(element) {
+    while (element) {
+      if (element.localName == "toolbar") {
+        return element;
+      }
+      element = element.parentNode;
+    }
+    return null;
+  },
+
+  onWidgetUnderflow(aNode, aContainer) {
+    // The view gets broken by being removed and reinserted by the overflowable
+    // toolbar, so we have to force an uninit and reinit.
+    let win = aNode.ownerGlobal;
+    if (aNode.id == "personal-bookmarks" && win == window) {
+      this._resetView();
+    }
+  },
+
+  onWidgetAdded(aWidgetId, aArea, aPosition) {
+    if (aWidgetId == "personal-bookmarks" && !this._isCustomizing) {
+      // It's possible (with the "Add to Menu", "Add to Toolbar" context
+      // options) that the Places Toolbar Items have been moved without
+      // letting us prepare and handle it with with customizeStart and
+      // customizeDone. If that's the case, we need to reset the views
+      // since they're probably broken from the DOM reparenting.
+      this._resetView();
+    }
+  },
+
+  _resetView() {
+    if (this._viewElt) {
+      // It's possible that the placesView might not exist, and we need to
+      // do a full init. This could happen if the Bookmarks Toolbar Items are
+      // moved to the Menu Panel, and then to the toolbar with the "Add to Toolbar"
+      // context menu option, outside of customize mode.
+      if (this._viewElt._placesView) {
+        this._viewElt._placesView.uninit();
+      }
+      this.init();
+    }
+  },
+
+  async populateManagedBookmarks(popup) {
+    if (popup.hasChildNodes()) {
+      return;
+    }
+    // Show item's uri in the status bar when hovering, and clear on exit
+    popup.addEventListener("DOMMenuItemActive", function (event) {
+      XULBrowserWindow.setOverLink(event.target.link);
+    });
+    popup.addEventListener("DOMMenuItemInactive", function () {
+      XULBrowserWindow.setOverLink("");
+    });
+    let fragment = document.createDocumentFragment();
+    await this.addManagedBookmarks(
+      fragment,
+      Services.policies.getActivePolicies().ManagedBookmarks
+    );
+    popup.appendChild(fragment);
+  },
+
+  async addManagedBookmarks(menu, children) {
+    for (let i = 0; i < children.length; i++) {
+      let entry = children[i];
+      if (entry.children) {
+        // It's a folder.
+        let submenu = document.createXULElement("menu");
+        if (entry.name) {
+          submenu.setAttribute("label", entry.name);
+        } else {
+          submenu.setAttribute("data-l10n-id", "managed-bookmarks-subfolder");
+        }
+        submenu.setAttribute("container", "true");
+        submenu.setAttribute(
+          "class",
+          "menu-iconic bookmark-item subviewbutton"
+        );
+        let submenupopup = document.createXULElement("menupopup");
+        submenupopup.setAttribute("placespopup", "true");
+        submenu.appendChild(submenupopup);
+        menu.appendChild(submenu);
+        this.addManagedBookmarks(submenupopup, entry.children);
+      } else if (entry.name && entry.url) {
+        // It's bookmark.
+        let { preferredURI } = Services.uriFixup.getFixupURIInfo(entry.url);
+        let menuitem = document.createXULElement("menuitem");
+        menuitem.setAttribute("label", entry.name);
+        menuitem.setAttribute("image", "page-icon:" + preferredURI.spec);
+        menuitem.setAttribute(
+          "class",
+          "menuitem-iconic bookmark-item menuitem-with-favicon subviewbutton"
+        );
+        menuitem.link = preferredURI.spec;
+        menu.appendChild(menuitem);
+      }
+    }
+  },
+
+  openManagedBookmark(event) {
+    openUILink(event.target.link, event, {
+      triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
+    });
+  },
+
+  onDragStartManaged(event) {
+    if (!event.target.link) {
+      return;
+    }
+
+    let dt = event.dataTransfer;
+
+    let node = {};
+    node.type = 0;
+    node.title = event.target.label;
+    node.uri = event.target.link;
+
+    function addData(type, index) {
+      let wrapNode = PlacesUtils.wrapNode(node, type);
+      dt.mozSetDataAt(type, wrapNode, index);
+    }
+
+    addData(PlacesUtils.TYPE_X_MOZ_URL, 0);
+    addData(PlacesUtils.TYPE_PLAINTEXT, 0);
+    addData(PlacesUtils.TYPE_HTML, 0);
+  },
+};
+
+/**
+ * Handles the bookmarks menu-button in the toolbar.
+ */
+
+var BookmarkingUI = {
+  STAR_ID: "star-button",
+  STAR_BOX_ID: "star-button-box",
+  BOOKMARK_BUTTON_ID: "bookmarks-menu-button",
+  BOOKMARK_BUTTON_SHORTCUT: "addBookmarkAsKb",
+  get button() {
+    delete this.button;
+    let widgetGroup = CustomizableUI.getWidget(this.BOOKMARK_BUTTON_ID);
+    return (this.button = widgetGroup.forWindow(window).node);
+  },
+
+  get star() {
+    delete this.star;
+    return (this.star = document.getElementById(this.STAR_ID));
+  },
+
+  get starBox() {
+    delete this.starBox;
+    return (this.starBox = document.getElementById(this.STAR_BOX_ID));
+  },
+
+  get anchor() {
+    let action = PageActions.actionForID(PageActions.ACTION_ID_BOOKMARK);
+    return BrowserPageActions.panelAnchorNodeForAction(action);
+  },
+
+  get stringbundleset() {
+    delete this.stringbundleset;
+    return (this.stringbundleset = document.getElementById("stringbundleset"));
+  },
+
+  get toolbar() {
+    delete this.toolbar;
+    return (this.toolbar = document.getElementById("PersonalToolbar"));
+  },
+
+  STATUS_UPDATING: -1,
+  STATUS_UNSTARRED: 0,
+  STATUS_STARRED: 1,
+  get status() {
+    if (this._pendingUpdate) {
+      return this.STATUS_UPDATING;
+    }
+    return this.star.hasAttribute("starred")
+      ? this.STATUS_STARRED
+      : this.STATUS_UNSTARRED;
+  },
+
+  onPopupShowing: function BUI_onPopupShowing(event) {
+    // Don't handle events for submenus.
+    if (event.target != event.currentTarget) {
+      return;
+    }
+
+    // On non-photon, this code should never be reached. However, if you click
+    // the outer button's border, some cpp code for the menu button's XBL
+    // binding decides to open the popup even though the dropmarker is invisible.
+    //
+    // Separately, in Photon, if the button is in the dynamic portion of the
+    // overflow panel, we want to show a subview instead.
+    if (
+      this.button.getAttribute("cui-areatype") == CustomizableUI.TYPE_PANEL ||
+      this.button.hasAttribute("overflowedItem")
+    ) {
+      this._showSubView();
+      event.preventDefault();
+      event.stopPropagation();
+      return;
+    }
+
+    let widget = CustomizableUI.getWidget(this.BOOKMARK_BUTTON_ID).forWindow(
+      window
+    );
+    if (widget.overflowed) {
+      // Don't open a popup in the overflow popup, rather just open the Library.
+      event.preventDefault();
+      widget.node.removeAttribute("closemenu");
+      PlacesCommandHook.showPlacesOrganizer("BookmarksMenu");
+      return;
+    }
+
+    this._initMobileBookmarks(document.getElementById("BMB_mobileBookmarks"));
+
+    this.updateLabel(
+      "BMB_viewBookmarksSidebar",
+      SidebarUI.currentID == "viewBookmarksSidebar"
+    );
+    this.updateLabel("BMB_viewBookmarksToolbar", !this.toolbar.collapsed);
+  },
+
+  updateLabel(elementId, visible) {
+    let element = PanelMultiView.getViewNode(document, elementId);
+    let l10nID = element.getAttribute("data-l10n-id");
+    document.l10n.setAttributes(element, l10nID, { isVisible: !!visible });
+  },
+
+  toggleBookmarksToolbar(reason) {
+    let newState = this.toolbar.collapsed ? "always" : "never";
+    Services.prefs.setCharPref(
+      "browser.toolbars.bookmarks.visibility",
+      // See firefox.js for possible values
+      newState
+    );
+
+    CustomizableUI.setToolbarVisibility(this.toolbar.id, newState, false);
+    BrowserUsageTelemetry.recordToolbarVisibility(
+      this.toolbar.id,
+      newState,
+      reason
+    );
+  },
+
+  isOnNewTabPage({ currentURI }) {
+    // Prevent loading AboutNewTab.jsm during startup path if it
+    // is only the newTabURL getter we are interested in.
+    let newTabURL = Cu.isModuleLoaded("resource:///modules/AboutNewTab.jsm")
+      ? AboutNewTab.newTabURL
+      : "about:newtab";
+    // Don't treat a custom "about:blank" new tab URL as the "New Tab Page"
+    // due to about:blank being used in different contexts and the
+    // difficulty in determining if the eventual page load is
+    // about:blank or if the about:blank load is just temporary.
+    if (newTabURL == "about:blank") {
+      newTabURL = "about:newtab";
+    }
+    let newTabURLs = [newTabURL, "about:home"];
+    if (PrivateBrowsingUtils.isWindowPrivate(window)) {
+      newTabURLs.push("about:privatebrowsing");
+    }
+    return newTabURLs.some(uri => currentURI?.spec.startsWith(uri));
+  },
+
+  buildBookmarksToolbarSubmenu(toolbar) {
+    let alwaysShowMenuItem = document.createXULElement("menuitem");
+    let alwaysHideMenuItem = document.createXULElement("menuitem");
+    let showOnNewTabMenuItem = document.createXULElement("menuitem");
+    let menuPopup = document.createXULElement("menupopup");
+    menuPopup.append(
+      alwaysShowMenuItem,
+      showOnNewTabMenuItem,
+      alwaysHideMenuItem
+    );
+    let menu = document.createXULElement("menu");
+    menu.appendChild(menuPopup);
+
+    menu.setAttribute("label", toolbar.getAttribute("toolbarname"));
+    menu.setAttribute("id", "toggle_" + toolbar.id);
+    menu.setAttribute("accesskey", toolbar.getAttribute("accesskey"));
+    menu.setAttribute("toolbarId", toolbar.id);
+
+    // Used by the Places context menu in the Bookmarks Toolbar
+    // when nothing is selected
+    menu.setAttribute("selection-type", "none|single");
+
+    MozXULElement.insertFTLIfNeeded("browser/toolbarContextMenu.ftl");
+    let menuItems = [
+      [
+        showOnNewTabMenuItem,
+        "toolbar-context-menu-bookmarks-toolbar-on-new-tab-2",
+        "newtab",
+      ],
+      [
+        alwaysShowMenuItem,
+        "toolbar-context-menu-bookmarks-toolbar-always-show-2",
+        "always",
+      ],
+      [
+        alwaysHideMenuItem,
+        "toolbar-context-menu-bookmarks-toolbar-never-show-2",
+        "never",
+      ],
+    ];
+    menuItems.map(([menuItem, l10nId, visibilityEnum]) => {
+      document.l10n.setAttributes(menuItem, l10nId);
+      menuItem.setAttribute("type", "radio");
+      // The persisted state of the PersonalToolbar is stored in
+      // "browser.toolbars.bookmarks.visibility".
+      menuItem.setAttribute(
+        "checked",
+        gBookmarksToolbarVisibility == visibilityEnum
+      );
+      // Identify these items for "onViewToolbarCommand" so
+      // we know to check the visibilityEnum value.
+      menuItem.dataset.bookmarksToolbarVisibility = true;
+      menuItem.dataset.visibilityEnum = visibilityEnum;
+      menuItem.addEventListener("command", onViewToolbarCommand);
+    });
+    let menuItemForNextStateFromKbShortcut =
+      gBookmarksToolbarVisibility == "never"
+        ? alwaysShowMenuItem
+        : alwaysHideMenuItem;
+    menuItemForNextStateFromKbShortcut.setAttribute(
+      "key",
+      "viewBookmarksToolbarKb"
+    );
+
+    return menu;
+  },
+
+  /**
+   * Check if we need to make the empty toolbar message `hidden`.
+   * We'll have it unhidden during startup, to make sure the toolbar
+   * has height, and we'll unhide it if there is nothing else on the toolbar.
+   * We hide it in customize mode, unless there's nothing on the toolbar.
+   */
+  async updateEmptyToolbarMessage() {
+    let checkNumBookmarksOnToolbar = false;
+    let hasVisibleChildren = (() => {
+      // Do we have visible kids?
+      if (
+        this.toolbar.querySelector(
+          `:scope > toolbarpaletteitem > toolbarbutton:not([hidden]),
+           :scope > toolbarpaletteitem > toolbaritem:not([hidden], #personal-bookmarks),
+           :scope > toolbarbutton:not([hidden]),
+           :scope > toolbaritem:not([hidden], #personal-bookmarks)`
+        )
+      ) {
+        return true;
+      }
+      if (!this.toolbar.hasAttribute("initialized") && !this._isCustomizing) {
+        // If the bookmarks are here but it's early in startup, show the
+        // message. It'll get made visibility: hidden early in startup anyway -
+        // it's just to ensure the toolbar has height.
+        return false;
+      }
+      // Hmm, apparently not. Check for bookmarks or customize mode:
+      let bookmarksToolbarItemsPlacement =
+        CustomizableUI.getPlacementOfWidget("personal-bookmarks");
+      let bookmarksItemInToolbar =
+        bookmarksToolbarItemsPlacement?.area == CustomizableUI.AREA_BOOKMARKS;
+      if (!bookmarksItemInToolbar) {
+        return false;
+      }
+      if (this._isCustomizing) {
+        return true;
+      }
+      // Check visible bookmark nodes.
+      if (
+        this.toolbar.querySelector(
+          `#PlacesToolbarItems > toolbarseparator,
+           #PlacesToolbarItems > toolbarbutton`
+        )
+      ) {
+        return true;
+      }
+      checkNumBookmarksOnToolbar = true;
+      return false;
+    })();
+
+    if (checkNumBookmarksOnToolbar) {
+      hasVisibleChildren = !(await PlacesToolbarHelper.getIsEmpty());
+    }
+
+    let emptyMsg = document.getElementById("personal-toolbar-empty");
+    emptyMsg.hidden = hasVisibleChildren;
+    emptyMsg.toggleAttribute("nowidth", !hasVisibleChildren);
+  },
+
+  openLibraryIfLinkClicked(event) {
+    if (
+      ((event.type == "click" && event.button == 0) ||
+        (event.type == "keydown" && event.keyCode == KeyEvent.DOM_VK_RETURN)) &&
+      event.target.localName == "a"
+    ) {
+      PlacesCommandHook.showPlacesOrganizer("BookmarksToolbar");
+    }
+  },
+
+  // Set by sync after syncing bookmarks successfully once.
+  MOBILE_BOOKMARKS_PREF: "browser.bookmarks.showMobileBookmarks",
+
+  _shouldShowMobileBookmarks() {
+    return Services.prefs.getBoolPref(this.MOBILE_BOOKMARKS_PREF, false);
+  },
+
+  _initMobileBookmarks(mobileMenuItem) {
+    mobileMenuItem.hidden = !this._shouldShowMobileBookmarks();
+  },
+
+  _uninitView: function BUI__uninitView() {
+    // When an element with a placesView attached is removed and re-inserted,
+    // XBL reapplies the binding causing any kind of issues and possible leaks,
+    // so kill current view and let popupshowing generate a new one.
+    if (this.button._placesView) {
+      this.button._placesView.uninit();
+    }
+    // Also uninit the main menubar placesView, since it would have the same
+    // issues.
+    let menubar = document.getElementById("bookmarksMenu");
+    if (menubar && menubar._placesView) {
+      menubar._placesView.uninit();
+    }
+
+    // We have to do the same thing for the "special" views underneath the
+    // the bookmarks menu.
+    const kSpecialViewNodeIDs = [
+      "BMB_bookmarksToolbar",
+      "BMB_unsortedBookmarks",
+    ];
+    for (let viewNodeID of kSpecialViewNodeIDs) {
+      let elem = document.getElementById(viewNodeID);
+      if (elem && elem._placesView) {
+        elem._placesView.uninit();
+      }
+    }
+  },
+
+  onCustomizeStart: function BUI_customizeStart(aWindow) {
+    if (aWindow == window) {
+      this._uninitView();
+      this._isCustomizing = true;
+
+      this.updateEmptyToolbarMessage().catch(console.error);
+
+      let isVisible =
+        Services.prefs.getCharPref(
+          "browser.toolbars.bookmarks.visibility",
+          "newtab"
+        ) != "never";
+      // Temporarily show the bookmarks toolbar in Customize mode if
+      // the toolbar isn't set to Never. We don't have to worry about
+      // hiding when leaving customize mode since the toolbar will
+      // hide itself on location change.
+      setToolbarVisibility(this.toolbar, isVisible, false);
+    }
+  },
+
+  onWidgetAdded: function BUI_widgetAdded(aWidgetId, aArea) {
+    if (aWidgetId == this.BOOKMARK_BUTTON_ID) {
+      this._onWidgetWasMoved();
+    }
+    if (aArea == CustomizableUI.AREA_BOOKMARKS) {
+      this.updateEmptyToolbarMessage().catch(console.error);
+    }
+  },
+
+  onWidgetRemoved: function BUI_widgetRemoved(aWidgetId, aOldArea) {
+    if (aWidgetId == this.BOOKMARK_BUTTON_ID) {
+      this._onWidgetWasMoved();
+    }
+    if (aOldArea == CustomizableUI.AREA_BOOKMARKS) {
+      this.updateEmptyToolbarMessage().catch(console.error);
+    }
+  },
+
+  onWidgetReset: function BUI_widgetReset(aNode, aContainer) {
+    if (aNode == this.button) {
+      this._onWidgetWasMoved();
+    }
+  },
+
+  onWidgetUndoMove: function BUI_undoWidgetUndoMove(aNode, aContainer) {
+    if (aNode == this.button) {
+      this._onWidgetWasMoved();
+    }
+  },
+
+  onWidgetBeforeDOMChange: function BUI_onWidgetBeforeDOMChange(
+    aNode,
+    aNextNode,
+    aContainer,
+    aIsRemoval
+  ) {
+    if (aNode.id == "import-button") {
+      this._updateImportButton(aNode, aIsRemoval ? null : aContainer);
+    }
+  },
+
+  _updateImportButton: function BUI_updateImportButton(aNode, aContainer) {
+    // The import button behaves like a bookmark item when in the bookmarks
+    // toolbar, otherwise like a regular toolbar button.
+    let isBookmarkItem = aContainer == this.toolbar;
+    aNode.classList.toggle("toolbarbutton-1", !isBookmarkItem);
+    aNode.classList.toggle("bookmark-item", isBookmarkItem);
+  },
+
+  _onWidgetWasMoved: function BUI_widgetWasMoved() {
+    // If we're moved outside of customize mode, we need to uninit
+    // our view so it gets reconstructed.
+    if (!this._isCustomizing) {
+      this._uninitView();
+    }
+  },
+
+  onCustomizeEnd: function BUI_customizeEnd(aWindow) {
+    if (aWindow == window) {
+      this._isCustomizing = false;
+      this.updateEmptyToolbarMessage().catch(console.error);
+    }
+  },
+
+  init() {
+    CustomizableUI.addListener(this);
+    let importButton = document.getElementById("import-button");
+    if (importButton) {
+      this._updateImportButton(importButton, importButton.parentNode);
+    }
+    this.updateEmptyToolbarMessage().catch(console.error);
+  },
+
+  _hasBookmarksObserver: false,
+  _itemGuids: new Set(),
+  uninit: function BUI_uninit() {
+    this.updateBookmarkPageMenuItem(true);
+    CustomizableUI.removeListener(this);
+
+    this._uninitView();
+
+    if (this._hasBookmarksObserver) {
+      PlacesUtils.observers.removeListener(
+        [
+          "bookmark-added",
+          "bookmark-removed",
+          "bookmark-moved",
+          "bookmark-url-changed",
+        ],
+        this.handlePlacesEvents
+      );
+    }
+
+    if (this._pendingUpdate) {
+      delete this._pendingUpdate;
+    }
+  },
+
+  onLocationChange: function BUI_onLocationChange() {
+    if (this._uri && gBrowser.currentURI.equals(this._uri)) {
+      return;
+    }
+    this.updateStarState();
+  },
+
+  updateStarState: function BUI_updateStarState() {
+    this._uri = gBrowser.currentURI;
+    this._itemGuids.clear();
+    let guids = new Set();
+
+    // those objects are use to check if we are in the current iteration before
+    // returning any result.
+    let pendingUpdate = (this._pendingUpdate = {});
+
+    PlacesUtils.bookmarks
+      .fetch({ url: this._uri }, b => guids.add(b.guid), { concurrent: true })
+      .catch(console.error)
+      .then(() => {
+        if (pendingUpdate != this._pendingUpdate) {
+          return;
+        }
+
+        // It's possible that "bookmark-added" gets called before the async statement
+        // calls back.  For such an edge case, retain all unique entries from the
+        // array.
+        if (this._itemGuids.size > 0) {
+          this._itemGuids = new Set(...this._itemGuids, ...guids);
+        } else {
+          this._itemGuids = guids;
+        }
+
+        this._updateStar();
+
+        // Start observing bookmarks if needed.
+        if (!this._hasBookmarksObserver) {
+          try {
+            this.handlePlacesEvents = this.handlePlacesEvents.bind(this);
+            PlacesUtils.observers.addListener(
+              [
+                "bookmark-added",
+                "bookmark-removed",
+                "bookmark-moved",
+                "bookmark-url-changed",
+              ],
+              this.handlePlacesEvents
+            );
+            this._hasBookmarksObserver = true;
+          } catch (ex) {
+            console.error(
+              "BookmarkingUI failed adding a bookmarks observer: ",
+              ex
+            );
+          }
+        }
+
+        delete this._pendingUpdate;
+      });
+  },
+
+  _updateStar: function BUI__updateStar() {
+    let starred = this._itemGuids.size > 0;
+
+    // Update the image for all elements.
+    for (let element of [
+      this.star,
+      document.getElementById("context-bookmarkpage"),
+      PanelMultiView.getViewNode(document, "panelMenuBookmarkThisPage"),
+      document.getElementById("pageAction-panel-bookmark"),
+    ]) {
+      if (!element) {
+        // The page action panel element may not have been created yet.
+        continue;
+      }
+      if (starred) {
+        element.setAttribute("starred", "true");
+      } else {
+        element.removeAttribute("starred");
+      }
+    }
+
+    if (!this.starBox) {
+      // The BOOKMARK_BUTTON_SHORTCUT exists only in browser.xhtml.
+      // Return early if we're not in this context, but still reset the
+      // Bookmark Page items.
+      this.updateBookmarkPageMenuItem(true);
+      return;
+    }
+
+    // Update the tooltip for elements that require it.
+    let shortcut = document.getElementById(this.BOOKMARK_BUTTON_SHORTCUT);
+    let l10nArgs = {
+      shortcut: ShortcutUtils.prettifyShortcut(shortcut),
+    };
+    document.l10n.setAttributes(
+      this.starBox,
+      starred ? "urlbar-star-edit-bookmark" : "urlbar-star-add-bookmark",
+      l10nArgs
+    );
+
+    // Update the Bookmark Page menuitem when bookmarked state changes.
+    this.updateBookmarkPageMenuItem();
+
+    Services.obs.notifyObservers(
+      null,
+      "bookmark-icon-updated",
+      starred ? "starred" : "unstarred"
+    );
+  },
+
+  /**
+   * Update the "Bookmark Page…" menuitems on the menubar, panels, context
+   * menu and page actions.
+   * @param {boolean} [forceReset] passed when we're destroyed and the label
+   * should go back to the default (Bookmark Page), for MacOS.
+   */
+  updateBookmarkPageMenuItem(forceReset = false) {
+    let isStarred = !forceReset && this._itemGuids.size > 0;
+    // Define the l10n id which will be used to localize elements
+    // that only require a label using the menubar.ftl messages.
+    let menuItemL10nId = isStarred ? "menu-edit-bookmark" : "menu-bookmark-tab";
+    let menuItem = document.getElementById("menu_bookmarkThisPage");
+    if (menuItem) {
+      // Localize the menubar item.
+      document.l10n.setAttributes(menuItem, menuItemL10nId);
+    }
+
+    let panelMenuItemL10nId = isStarred
+      ? "bookmarks-subview-edit-bookmark"
+      : "bookmarks-subview-bookmark-tab";
+    let panelMenuToolbarButton = PanelMultiView.getViewNode(
+      document,
+      "panelMenuBookmarkThisPage"
+    );
+    if (panelMenuToolbarButton) {
+      document.l10n.setAttributes(panelMenuToolbarButton, panelMenuItemL10nId);
+    }
+
+    // Localize the context menu item element.
+    let contextItem = document.getElementById("context-bookmarkpage");
+    // On macOS regular menuitems are used and the shortcut isn't added
+    if (contextItem) {
+      if (AppConstants.platform == "macosx") {
+        let contextItemL10nId = isStarred
+          ? "main-context-menu-edit-bookmark-mac"
+          : "main-context-menu-bookmark-page-mac";
+        document.l10n.setAttributes(contextItem, contextItemL10nId);
+      } else {
+        let shortcutElem = document.getElementById(
+          this.BOOKMARK_BUTTON_SHORTCUT
+        );
+        if (shortcutElem) {
+          let shortcut = ShortcutUtils.prettifyShortcut(shortcutElem);
+          let contextItemL10nId = isStarred
+            ? "main-context-menu-edit-bookmark-with-shortcut"
+            : "main-context-menu-bookmark-page-with-shortcut";
+          let l10nArgs = { shortcut };
+          document.l10n.setAttributes(contextItem, contextItemL10nId, l10nArgs);
+        } else {
+          let contextItemL10nId = isStarred
+            ? "main-context-menu-edit-bookmark"
+            : "main-context-menu-bookmark-page";
+          document.l10n.setAttributes(contextItem, contextItemL10nId);
+        }
+      }
+    }
+
+    // Update Page Actions.
+    if (document.getElementById("page-action-buttons")) {
+      // Fetch the label attribute value of the message and
+      // apply it on the star title.
+      //
+      // Note: This should be updated once bug 1608198 is fixed.
+      this._latestMenuItemL10nId = menuItemL10nId;
+      document.l10n.formatMessages([{ id: menuItemL10nId }]).then(l10n => {
+        // It's possible for this promise to be scheduled multiple times.
+        // In such a case, we'd like to avoid setting the title if there's
+        // a newer l10n id pending to be set.
+        if (this._latestMenuItemL10nId != menuItemL10nId) {
+          return;
+        }
+
+        // We assume that menuItemL10nId has a single attribute.
+        let label = l10n[0].attributes[0].value;
+
+        // Update the label for the page action panel.
+        let panelButton = BrowserPageActions.panelButtonNodeForActionID(
+          PageActions.ACTION_ID_BOOKMARK
+        );
+        if (panelButton) {
+          panelButton.setAttribute("label", label);
+        }
+      });
+    }
+  },
+
+  onMainMenuPopupShowing: function BUI_onMainMenuPopupShowing(event) {
+    // Don't handle events for submenus.
+    if (event.target != event.currentTarget) {
+      return;
+    }
+
+    this._initMobileBookmarks(document.getElementById("menu_mobileBookmarks"));
+  },
+
+  showSubView(anchor) {
+    this._showSubView(null, anchor);
+  },
+
+  _showSubView(
+    event,
+    anchor = document.getElementById(this.BOOKMARK_BUTTON_ID)
+  ) {
+    let view = PanelMultiView.getViewNode(document, "PanelUI-bookmarks");
+    view.addEventListener("ViewShowing", this);
+    view.addEventListener("ViewHiding", this);
+    anchor.setAttribute("closemenu", "none");
+    this.updateLabel("panelMenu_viewBookmarksToolbar", !this.toolbar.collapsed);
+    PanelUI.showSubView("PanelUI-bookmarks", anchor, event);
+  },
+
+  onCommand: function BUI_onCommand(aEvent) {
+    if (aEvent.target != aEvent.currentTarget) {
+      return;
+    }
+
+    // Handle special case when the button is in the panel.
+    if (this.button.getAttribute("cui-areatype") == CustomizableUI.TYPE_PANEL) {
+      this._showSubView(aEvent);
+      return;
+    }
+    let widget = CustomizableUI.getWidget(this.BOOKMARK_BUTTON_ID).forWindow(
+      window
+    );
+    if (widget.overflowed) {
+      // Close the overflow panel because the Edit Bookmark panel will appear.
+      widget.node.removeAttribute("closemenu");
+    }
+    this.onStarCommand(aEvent);
+  },
+
+  onStarCommand(aEvent) {
+    // Ignore non-left clicks on the star, or if we are updating its state.
+    if (
+      !this._pendingUpdate &&
+      (aEvent.type != "click" || aEvent.button == 0)
+    ) {
+      PlacesCommandHook.bookmarkPage();
+    }
+  },
+
+  handleEvent: function BUI_handleEvent(aEvent) {
+    switch (aEvent.type) {
+      case "ViewShowing":
+        this.onPanelMenuViewShowing(aEvent);
+        break;
+      case "ViewHiding":
+        this.onPanelMenuViewHiding(aEvent);
+        break;
+    }
+  },
+
+  onPanelMenuViewShowing: function BUI_onViewShowing(aEvent) {
+    let panelview = aEvent.target;
+
+    // Get all statically placed buttons to supply them with keyboard shortcuts.
+    let staticButtons = panelview.getElementsByTagName("toolbarbutton");
+    for (let i = 0, l = staticButtons.length; i < l; ++i) {
+      CustomizableUI.addShortcut(staticButtons[i]);
+    }
+
+    // Setup the Places view.
+    // We restrict the amount of results to 42. Not 50, but 42. Why? Because 42.
+    let query =
+      "place:queryType=" +
+      Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS +
+      "&sort=" +
+      Ci.nsINavHistoryQueryOptions.SORT_BY_DATEADDED_DESCENDING +
+      "&maxResults=42&excludeQueries=1";
+
+    this._panelMenuView = new PlacesPanelview(
+      query,
+      document.getElementById("panelMenu_bookmarksMenu"),
+      panelview
+    );
+    panelview.removeEventListener("ViewShowing", this);
+  },
+
+  onPanelMenuViewHiding: function BUI_onViewHiding(aEvent) {
+    this._panelMenuView.uninit();
+    delete this._panelMenuView;
+    aEvent.target.removeEventListener("ViewHiding", this);
+  },
+
+  handlePlacesEvents(aEvents) {
+    let isStarUpdateNeeded = false;
+    let affectsOtherBookmarksFolder = false;
+    let affectsBookmarksToolbarFolder = false;
+
+    for (let ev of aEvents) {
+      switch (ev.type) {
+        case "bookmark-added":
+          // Only need to update the UI if it wasn't marked as starred before:
+          if (this._itemGuids.size == 0) {
+            if (ev.url && ev.url == this._uri.spec) {
+              // If a new bookmark has been added to the tracked uri, register it.
+              if (!this._itemGuids.has(ev.guid)) {
+                this._itemGuids.add(ev.guid);
+                isStarUpdateNeeded = true;
+              }
+            }
+          }
+
+          if (ev.parentGuid === PlacesUtils.bookmarks.toolbarGuid) {
+            Services.telemetry.scalarAdd(
+              "browser.engagement.bookmarks_toolbar_bookmark_added",
+              1
+            );
+          }
+          break;
+        case "bookmark-removed":
+          // If one of the tracked bookmarks has been removed, unregister it.
+          if (this._itemGuids.has(ev.guid)) {
+            this._itemGuids.delete(ev.guid);
+            // Only need to update the UI if the page is no longer starred
+            if (this._itemGuids.size == 0) {
+              isStarUpdateNeeded = true;
+            }
+          }
+
+          // Reset the default location if it is equal to the folder
+          // being deleted. Just check the preference directly since we
+          // do not want to do a asynchronous db lookup.
+          PlacesUIUtils.defaultParentGuid.then(parentGuid => {
+            if (
+              ev.itemType == PlacesUtils.bookmarks.TYPE_FOLDER &&
+              ev.guid == parentGuid
+            ) {
+              Services.prefs.setCharPref(
+                "browser.bookmarks.defaultLocation",
+                PlacesUtils.bookmarks.toolbarGuid
+              );
+            }
+          });
+          break;
+        case "bookmark-moved":
+          if (
+            ev.parentGuid === PlacesUtils.bookmarks.unfiledGuid ||
+            ev.oldParentGuid === PlacesUtils.bookmarks.unfiledGuid
+          ) {
+            affectsOtherBookmarksFolder = true;
+          }
+
+          if (
+            ev.parentGuid == PlacesUtils.bookmarks.toolbarGuid ||
+            ev.oldParentGuid == PlacesUtils.bookmarks.toolbarGuid
+          ) {
+            affectsBookmarksToolbarFolder = true;
+            if (ev.oldParentGuid != PlacesUtils.bookmarks.toolbarGuid) {
+              Services.telemetry.scalarAdd(
+                "browser.engagement.bookmarks_toolbar_bookmark_added",
+                1
+              );
+            }
+          }
+          break;
+        case "bookmark-url-changed":
+          // If the changed bookmark was tracked, check if it is now pointing to
+          // a different uri and unregister it.
+          if (this._itemGuids.has(ev.guid) && ev.url != this._uri.spec) {
+            this._itemGuids.delete(ev.guid);
+            // Only need to update the UI if the page is no longer starred
+            if (this._itemGuids.size == 0) {
+              this._updateStar();
+            }
+          } else if (
+            !this._itemGuids.has(ev.guid) &&
+            ev.url == this._uri.spec
+          ) {
+            // If another bookmark is now pointing to the tracked uri, register it.
+            this._itemGuids.add(ev.guid);
+            // Only need to update the UI if it wasn't marked as starred before:
+            if (this._itemGuids.size == 1) {
+              this._updateStar();
+            }
+          }
+
+          break;
+      }
+
+      if (ev.parentGuid == PlacesUtils.bookmarks.unfiledGuid) {
+        affectsOtherBookmarksFolder = true;
+      } else if (ev.parentGuid == PlacesUtils.bookmarks.toolbarGuid) {
+        affectsBookmarksToolbarFolder = true;
+      }
+    }
+
+    if (isStarUpdateNeeded) {
+      this._updateStar();
+    }
+
+    // Run after the notification has been handled by the views.
+    Services.tm.dispatchToMainThread(() => {
+      if (affectsOtherBookmarksFolder) {
+        this.maybeShowOtherBookmarksFolder().catch(console.error);
+      }
+      if (affectsBookmarksToolbarFolder) {
+        this.updateEmptyToolbarMessage().catch(console.error);
+      }
+    });
+  },
+
+  onWidgetUnderflow(aNode, aContainer) {
+    let win = aNode.ownerGlobal;
+    if (aNode.id != this.BOOKMARK_BUTTON_ID || win != window) {
+      return;
+    }
+
+    // The view gets broken by being removed and reinserted. Uninit
+    // here so popupshowing will generate a new one:
+    this._uninitView();
+  },
+
+  async maybeShowOtherBookmarksFolder() {
+    // PlacesToolbar._placesView can be undefined if the toolbar isn't initialized,
+    // collapsed, or hidden in some other way.
+    let toolbar = document.getElementById("PlacesToolbar");
+    if (!toolbar?._placesView) {
+      return;
+    }
+
+    let placement = CustomizableUI.getPlacementOfWidget("personal-bookmarks");
+    let otherBookmarks = document.getElementById("OtherBookmarks");
+    if (
+      !SHOW_OTHER_BOOKMARKS ||
+      placement?.area != CustomizableUI.AREA_BOOKMARKS
+    ) {
+      if (otherBookmarks) {
+        otherBookmarks.hidden = true;
+      }
+      return;
+    }
+
+    let instance = (this._showOtherBookmarksInstance = {});
+    let unfiledGuid = PlacesUtils.bookmarks.unfiledGuid;
+    let numberOfBookmarks = (await PlacesUtils.bookmarks.fetch(unfiledGuid))
+      .childCount;
+    if (instance != this._showOtherBookmarksInstance) {
+      return;
+    }
+
+    if (numberOfBookmarks > 0) {
+      // Build the "Other Bookmarks" button if it doesn't exist.
+      if (!otherBookmarks) {
+        const node = PlacesUtils.getFolderContents(unfiledGuid).root;
+        otherBookmarks = this.buildOtherBookmarksFolder(node);
+      }
+      otherBookmarks.hidden = false;
+    } else if (otherBookmarks) {
+      otherBookmarks.hidden = true;
+    }
+  },
+
+  buildShowOtherBookmarksMenuItem() {
+    // Building this only if there's bookmarks in unfiled would cause
+    // synchronous IO, thus we just add it as disabled and enable it once the
+    // information is available.
+    let menuItem = document.createXULElement("menuitem");
+
+    menuItem.setAttribute("id", "show-other-bookmarks_PersonalToolbar");
+    menuItem.setAttribute("toolbarId", "PersonalToolbar");
+    menuItem.setAttribute("type", "checkbox");
+    menuItem.setAttribute("checked", SHOW_OTHER_BOOKMARKS);
+    menuItem.setAttribute("selection-type", "none|single");
+    menuItem.setAttribute("start-disabled", "true");
+
+    MozXULElement.insertFTLIfNeeded("browser/toolbarContextMenu.ftl");
+    document.l10n.setAttributes(
+      menuItem,
+      "toolbar-context-menu-bookmarks-show-other-bookmarks"
+    );
+    menuItem.addEventListener("command", () => {
+      Services.prefs.setBoolPref(
+        "browser.toolbars.bookmarks.showOtherBookmarks",
+        !SHOW_OTHER_BOOKMARKS
+      );
+    });
+    // Enable the menuItem if there's unfiled bookmarks
+    PlacesUtils.bookmarks.fetch(PlacesUtils.bookmarks.unfiledGuid).then(bm => {
+      if (bm.childCount) {
+        menuItem.disabled = false;
+      }
+    });
+
+    return menuItem;
+  },
+
+  buildOtherBookmarksFolder(node) {
+    let otherBookmarksButton = document.createXULElement("toolbarbutton");
+    otherBookmarksButton.setAttribute("type", "menu");
+    otherBookmarksButton.setAttribute("container", "true");
+    otherBookmarksButton.setAttribute(
+      "onpopupshowing",
+      "document.getElementById('PlacesToolbar')._placesView._onOtherBookmarksPopupShowing(event);"
+    );
+    otherBookmarksButton.id = "OtherBookmarks";
+    otherBookmarksButton.className = "bookmark-item";
+    otherBookmarksButton.hidden = "true";
+
+    MozXULElement.insertFTLIfNeeded("browser/places.ftl");
+    document.l10n.setAttributes(otherBookmarksButton, "other-bookmarks-folder");
+
+    let otherBookmarksPopup = document.createXULElement("menupopup", {
+      is: "places-popup",
+    });
+    otherBookmarksPopup.setAttribute("placespopup", "true");
+    otherBookmarksPopup.setAttribute("type", "arrow");
+    otherBookmarksPopup.setAttribute("context", "placesContext");
+    otherBookmarksPopup.id = "OtherBookmarksPopup";
+
+    otherBookmarksPopup._placesNode = PlacesUtils.asContainer(node);
+    otherBookmarksButton._placesNode = PlacesUtils.asContainer(node);
+
+    otherBookmarksButton.appendChild(otherBookmarksPopup);
+
+    let chevronButton = document.getElementById("PlacesChevron");
+    chevronButton.parentNode.append(otherBookmarksButton);
+
+    let placesToolbar = document.getElementById("PlacesToolbar");
+    placesToolbar._placesView._otherBookmarks = otherBookmarksButton;
+    placesToolbar._placesView._otherBookmarksPopup = otherBookmarksPopup;
+    return otherBookmarksButton;
+  },
+};