Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

1 files changed, 1918 insertions, 0 deletions

diff --git a/browser/base/content/browser-addons.js b/browser/base/content/browser-addons.js
new file mode 100644
index 0000000000..708f3af68f
--- /dev/null
+++ b/browser/base/content/browser-addons.js
@@ -0,0 +1,1918 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// This file is loaded into the browser window scope.
+/* eslint-env mozilla/browser-window */
+
+var { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ExtensionParent: "resource://gre/modules/ExtensionParent.sys.mjs",
+  ExtensionPermissions: "resource://gre/modules/ExtensionPermissions.sys.mjs",
+  OriginControls: "resource://gre/modules/ExtensionPermissions.sys.mjs",
+  SITEPERMS_ADDON_TYPE:
+    "resource://gre/modules/addons/siteperms-addon-utils.sys.mjs",
+});
+XPCOMUtils.defineLazyGetter(lazy, "l10n", function () {
+  return new Localization(
+    ["browser/addonNotifications.ftl", "branding/brand.ftl"],
+    true
+  );
+});
+
+/**
+ * Mapping of error code -> [error-id, local-error-id]
+ *
+ * error-id is used for errors in DownloadedAddonInstall,
+ * local-error-id for errors in LocalAddonInstall.
+ *
+ * The error codes are defined in AddonManager's _errors Map.
+ * Not all error codes listed there are translated,
+ * since errors that are only triggered during updates
+ * will never reach this code.
+ */
+const ERROR_L10N_IDS = new Map([
+  [
+    -1,
+    [
+      "addon-install-error-network-failure",
+      "addon-local-install-error-network-failure",
+    ],
+  ],
+  [
+    -2,
+    [
+      "addon-install-error-incorrect-hash",
+      "addon-local-install-error-incorrect-hash",
+    ],
+  ],
+  [
+    -3,
+    [
+      "addon-install-error-corrupt-file",
+      "addon-local-install-error-corrupt-file",
+    ],
+  ],
+  [
+    -4,
+    [
+      "addon-install-error-file-access",
+      "addon-local-install-error-file-access",
+    ],
+  ],
+  [
+    -5,
+    ["addon-install-error-not-signed", "addon-local-install-error-not-signed"],
+  ],
+  [-8, ["addon-install-error-invalid-domain"]],
+]);
+
+customElements.define(
+  "addon-progress-notification",
+  class MozAddonProgressNotification extends customElements.get(
+    "popupnotification"
+  ) {
+    show() {
+      super.show();
+      this.progressmeter = document.getElementById(
+        "addon-progress-notification-progressmeter"
+      );
+
+      this.progresstext = document.getElementById(
+        "addon-progress-notification-progresstext"
+      );
+
+      if (!this.notification) {
+        return;
+      }
+
+      this.notification.options.installs.forEach(function (aInstall) {
+        aInstall.addListener(this);
+      }, this);
+
+      // Calling updateProgress can sometimes cause this notification to be
+      // removed in the middle of refreshing the notification panel which
+      // makes the panel get refreshed again. Just initialise to the
+      // undetermined state and then schedule a proper check at the next
+      // opportunity
+      this.setProgress(0, -1);
+      this._updateProgressTimeout = setTimeout(
+        this.updateProgress.bind(this),
+        0
+      );
+    }
+
+    disconnectedCallback() {
+      this.destroy();
+    }
+
+    destroy() {
+      if (!this.notification) {
+        return;
+      }
+      this.notification.options.installs.forEach(function (aInstall) {
+        aInstall.removeListener(this);
+      }, this);
+
+      clearTimeout(this._updateProgressTimeout);
+    }
+
+    setProgress(aProgress, aMaxProgress) {
+      if (aMaxProgress == -1) {
+        this.progressmeter.removeAttribute("value");
+      } else {
+        this.progressmeter.setAttribute(
+          "value",
+          (aProgress * 100) / aMaxProgress
+        );
+      }
+
+      let now = Date.now();
+
+      if (!this.notification.lastUpdate) {
+        this.notification.lastUpdate = now;
+        this.notification.lastProgress = aProgress;
+        return;
+      }
+
+      let delta = now - this.notification.lastUpdate;
+      if (delta < 400 && aProgress < aMaxProgress) {
+        return;
+      }
+
+      // Set min. time delta to avoid division by zero in the upcoming speed calculation
+      delta = Math.max(delta, 400);
+      delta /= 1000;
+
+      // This algorithm is the same used by the downloads code.
+      let speed = (aProgress - this.notification.lastProgress) / delta;
+      if (this.notification.speed) {
+        speed = speed * 0.9 + this.notification.speed * 0.1;
+      }
+
+      this.notification.lastUpdate = now;
+      this.notification.lastProgress = aProgress;
+      this.notification.speed = speed;
+
+      let status = null;
+      [status, this.notification.last] = DownloadUtils.getDownloadStatus(
+        aProgress,
+        aMaxProgress,
+        speed,
+        this.notification.last
+      );
+      this.progresstext.setAttribute("value", status);
+      this.progresstext.setAttribute("tooltiptext", status);
+    }
+
+    cancel() {
+      let installs = this.notification.options.installs;
+      installs.forEach(function (aInstall) {
+        try {
+          aInstall.cancel();
+        } catch (e) {
+          // Cancel will throw if the download has already failed
+        }
+      }, this);
+
+      PopupNotifications.remove(this.notification);
+    }
+
+    updateProgress() {
+      if (!this.notification) {
+        return;
+      }
+
+      let downloadingCount = 0;
+      let progress = 0;
+      let maxProgress = 0;
+
+      this.notification.options.installs.forEach(function (aInstall) {
+        if (aInstall.maxProgress == -1) {
+          maxProgress = -1;
+        }
+        progress += aInstall.progress;
+        if (maxProgress >= 0) {
+          maxProgress += aInstall.maxProgress;
+        }
+        if (aInstall.state < AddonManager.STATE_DOWNLOADED) {
+          downloadingCount++;
+        }
+      });
+
+      if (downloadingCount == 0) {
+        this.destroy();
+        this.progressmeter.removeAttribute("value");
+        const status = lazy.l10n.formatValueSync("addon-download-verifying");
+        this.progresstext.setAttribute("value", status);
+        this.progresstext.setAttribute("tooltiptext", status);
+      } else {
+        this.setProgress(progress, maxProgress);
+      }
+    }
+
+    onDownloadProgress() {
+      this.updateProgress();
+    }
+
+    onDownloadFailed() {
+      this.updateProgress();
+    }
+
+    onDownloadCancelled() {
+      this.updateProgress();
+    }
+
+    onDownloadEnded() {
+      this.updateProgress();
+    }
+  }
+);
+
+// Removes a doorhanger notification if all of the installs it was notifying
+// about have ended in some way.
+function removeNotificationOnEnd(notification, installs) {
+  let count = installs.length;
+
+  function maybeRemove(install) {
+    install.removeListener(this);
+
+    if (--count == 0) {
+      // Check that the notification is still showing
+      let current = PopupNotifications.getNotification(
+        notification.id,
+        notification.browser
+      );
+      if (current === notification) {
+        notification.remove();
+      }
+    }
+  }
+
+  for (let install of installs) {
+    install.addListener({
+      onDownloadCancelled: maybeRemove,
+      onDownloadFailed: maybeRemove,
+      onInstallFailed: maybeRemove,
+      onInstallEnded: maybeRemove,
+    });
+  }
+}
+
+function buildNotificationAction(msg, callback) {
+  let label = "";
+  let accessKey = "";
+  for (let { name, value } of msg.attributes) {
+    switch (name) {
+      case "label":
+        label = value;
+        break;
+      case "accesskey":
+        accessKey = value;
+        break;
+    }
+  }
+  return { label, accessKey, callback };
+}
+
+var gXPInstallObserver = {
+  _findChildShell(aDocShell, aSoughtShell) {
+    if (aDocShell == aSoughtShell) {
+      return aDocShell;
+    }
+
+    var node = aDocShell.QueryInterface(Ci.nsIDocShellTreeItem);
+    for (var i = 0; i < node.childCount; ++i) {
+      var docShell = node.getChildAt(i);
+      docShell = this._findChildShell(docShell, aSoughtShell);
+      if (docShell == aSoughtShell) {
+        return docShell;
+      }
+    }
+    return null;
+  },
+
+  _getBrowser(aDocShell) {
+    for (let browser of gBrowser.browsers) {
+      if (this._findChildShell(browser.docShell, aDocShell)) {
+        return browser;
+      }
+    }
+    return null;
+  },
+
+  pendingInstalls: new WeakMap(),
+
+  showInstallConfirmation(browser, installInfo, height = undefined) {
+    // If the confirmation notification is already open cache the installInfo
+    // and the new confirmation will be shown later
+    if (
+      PopupNotifications.getNotification("addon-install-confirmation", browser)
+    ) {
+      let pending = this.pendingInstalls.get(browser);
+      if (pending) {
+        pending.push(installInfo);
+      } else {
+        this.pendingInstalls.set(browser, [installInfo]);
+      }
+      return;
+    }
+
+    let showNextConfirmation = () => {
+      // Make sure the browser is still alive.
+      if (!gBrowser.browsers.includes(browser)) {
+        return;
+      }
+
+      let pending = this.pendingInstalls.get(browser);
+      if (pending && pending.length) {
+        this.showInstallConfirmation(browser, pending.shift());
+      }
+    };
+
+    // If all installs have already been cancelled in some way then just show
+    // the next confirmation
+    if (
+      installInfo.installs.every(i => i.state != AddonManager.STATE_DOWNLOADED)
+    ) {
+      showNextConfirmation();
+      return;
+    }
+
+    // Make notifications persistent
+    var options = {
+      displayURI: installInfo.originatingURI,
+      persistent: true,
+      hideClose: true,
+      popupOptions: {
+        position: "bottomright topright",
+      },
+    };
+
+    let acceptInstallation = () => {
+      for (let install of installInfo.installs) {
+        install.install();
+      }
+      installInfo = null;
+
+      Services.telemetry
+        .getHistogramById("SECURITY_UI")
+        .add(
+          Ci.nsISecurityUITelemetry.WARNING_CONFIRM_ADDON_INSTALL_CLICK_THROUGH
+        );
+    };
+
+    let cancelInstallation = () => {
+      if (installInfo) {
+        for (let install of installInfo.installs) {
+          // The notification may have been closed because the add-ons got
+          // cancelled elsewhere, only try to cancel those that are still
+          // pending install.
+          if (install.state != AddonManager.STATE_CANCELLED) {
+            install.cancel();
+          }
+        }
+      }
+
+      showNextConfirmation();
+    };
+
+    let unsigned = installInfo.installs.filter(
+      i => i.addon.signedState <= AddonManager.SIGNEDSTATE_MISSING
+    );
+    let someUnsigned =
+      !!unsigned.length && unsigned.length < installInfo.installs.length;
+
+    options.eventCallback = aEvent => {
+      switch (aEvent) {
+        case "removed":
+          cancelInstallation();
+          break;
+        case "shown":
+          let addonList = document.getElementById(
+            "addon-install-confirmation-content"
+          );
+          while (addonList.firstChild) {
+            addonList.firstChild.remove();
+          }
+
+          for (let install of installInfo.installs) {
+            let container = document.createXULElement("hbox");
+
+            let name = document.createXULElement("label");
+            name.setAttribute("value", install.addon.name);
+            name.setAttribute("class", "addon-install-confirmation-name");
+            container.appendChild(name);
+
+            if (
+              someUnsigned &&
+              install.addon.signedState <= AddonManager.SIGNEDSTATE_MISSING
+            ) {
+              let unsignedLabel = document.createXULElement("label");
+              document.l10n.setAttributes(
+                unsignedLabel,
+                "popup-notification-addon-install-unsigned"
+              );
+              unsignedLabel.setAttribute(
+                "class",
+                "addon-install-confirmation-unsigned"
+              );
+              container.appendChild(unsignedLabel);
+            }
+
+            addonList.appendChild(container);
+          }
+          break;
+      }
+    };
+
+    options.learnMoreURL = Services.urlFormatter.formatURLPref(
+      "app.support.baseURL"
+    );
+
+    let msgId;
+    let notification = document.getElementById(
+      "addon-install-confirmation-notification"
+    );
+    if (unsigned.length == installInfo.installs.length) {
+      // None of the add-ons are verified
+      msgId = "addon-confirm-install-unsigned-message";
+      notification.setAttribute("warning", "true");
+      options.learnMoreURL += "unsigned-addons";
+    } else if (!unsigned.length) {
+      // All add-ons are verified or don't need to be verified
+      msgId = "addon-confirm-install-message";
+      notification.removeAttribute("warning");
+      options.learnMoreURL += "find-and-install-add-ons";
+    } else {
+      // Some of the add-ons are unverified, the list of names will indicate
+      // which
+      msgId = "addon-confirm-install-some-unsigned-message";
+      notification.setAttribute("warning", "true");
+      options.learnMoreURL += "unsigned-addons";
+    }
+    const addonCount = installInfo.installs.length;
+    const messageString = lazy.l10n.formatValueSync(msgId, { addonCount });
+
+    const [acceptMsg, cancelMsg] = lazy.l10n.formatMessagesSync([
+      "addon-install-accept-button",
+      "addon-install-cancel-button",
+    ]);
+    const action = buildNotificationAction(acceptMsg, acceptInstallation);
+    const secondaryAction = buildNotificationAction(cancelMsg, () => {});
+
+    if (height) {
+      notification.style.minHeight = height + "px";
+    }
+
+    let tab = gBrowser.getTabForBrowser(browser);
+    if (tab) {
+      gBrowser.selectedTab = tab;
+    }
+
+    let popup = PopupNotifications.show(
+      browser,
+      "addon-install-confirmation",
+      messageString,
+      gUnifiedExtensions.getPopupAnchorID(browser, window),
+      action,
+      [secondaryAction],
+      options
+    );
+
+    removeNotificationOnEnd(popup, installInfo.installs);
+
+    Services.telemetry
+      .getHistogramById("SECURITY_UI")
+      .add(Ci.nsISecurityUITelemetry.WARNING_CONFIRM_ADDON_INSTALL);
+  },
+
+  // IDs of addon install related notifications
+  NOTIFICATION_IDS: [
+    "addon-install-blocked",
+    "addon-install-confirmation",
+    "addon-install-failed",
+    "addon-install-origin-blocked",
+    "addon-install-webapi-blocked",
+    "addon-install-policy-blocked",
+    "addon-progress",
+    "addon-webext-permissions",
+    "xpinstall-disabled",
+  ],
+
+  /**
+   * Remove all opened addon installation notifications
+   *
+   * @param {*} browser - Browser to remove notifications for
+   * @returns {boolean} - true if notifications have been removed.
+   */
+  removeAllNotifications(browser) {
+    let notifications = this.NOTIFICATION_IDS.map(id =>
+      PopupNotifications.getNotification(id, browser)
+    ).filter(notification => notification != null);
+
+    PopupNotifications.remove(notifications, true);
+
+    return !!notifications.length;
+  },
+
+  logWarningFullScreenInstallBlocked() {
+    // If notifications have been removed, log a warning to the website console
+    let consoleMsg = Cc["@mozilla.org/scripterror;1"].createInstance(
+      Ci.nsIScriptError
+    );
+    const message = lazy.l10n.formatValueSync(
+      "addon-install-full-screen-blocked"
+    );
+    consoleMsg.initWithWindowID(
+      message,
+      gBrowser.currentURI.spec,
+      null,
+      0,
+      0,
+      Ci.nsIScriptError.warningFlag,
+      "FullScreen",
+      gBrowser.selectedBrowser.innerWindowID
+    );
+    Services.console.logMessage(consoleMsg);
+  },
+
+  async observe(aSubject, aTopic, aData) {
+    var installInfo = aSubject.wrappedJSObject;
+    var browser = installInfo.browser;
+
+    // Make sure the browser is still alive.
+    if (!browser || !gBrowser.browsers.includes(browser)) {
+      return;
+    }
+
+    // Make notifications persistent
+    var options = {
+      displayURI: installInfo.originatingURI,
+      persistent: true,
+      hideClose: true,
+      timeout: Date.now() + 30000,
+      popupOptions: {
+        position: "bottomright topright",
+      },
+    };
+
+    switch (aTopic) {
+      case "addon-install-disabled": {
+        let msgId, action, secondaryActions;
+        if (Services.prefs.prefIsLocked("xpinstall.enabled")) {
+          msgId = "xpinstall-disabled-locked";
+          action = null;
+          secondaryActions = null;
+        } else {
+          msgId = "xpinstall-disabled";
+          const [disabledMsg, cancelMsg] = await lazy.l10n.formatMessages([
+            "xpinstall-disabled-button",
+            "addon-install-cancel-button",
+          ]);
+          action = buildNotificationAction(disabledMsg, () => {
+            Services.prefs.setBoolPref("xpinstall.enabled", true);
+          });
+          secondaryActions = [buildNotificationAction(cancelMsg, () => {})];
+        }
+
+        PopupNotifications.show(
+          browser,
+          "xpinstall-disabled",
+          await lazy.l10n.formatValue(msgId),
+          gUnifiedExtensions.getPopupAnchorID(browser, window),
+          action,
+          secondaryActions,
+          options
+        );
+        break;
+      }
+      case "addon-install-fullscreen-blocked": {
+        // AddonManager denied installation because we are in DOM fullscreen
+        this.logWarningFullScreenInstallBlocked();
+        break;
+      }
+      case "addon-install-webapi-blocked":
+      case "addon-install-policy-blocked":
+      case "addon-install-origin-blocked": {
+        const msgId =
+          aTopic == "addon-install-policy-blocked"
+            ? "addon-domain-blocked-by-policy"
+            : "xpinstall-prompt";
+        let messageString = await lazy.l10n.formatValue(msgId);
+        if (Services.policies) {
+          let extensionSettings = Services.policies.getExtensionSettings("*");
+          if (
+            extensionSettings &&
+            "blocked_install_message" in extensionSettings
+          ) {
+            messageString += " " + extensionSettings.blocked_install_message;
+          }
+        }
+
+        options.removeOnDismissal = true;
+        options.persistent = false;
+
+        let secHistogram = Services.telemetry.getHistogramById("SECURITY_UI");
+        secHistogram.add(
+          Ci.nsISecurityUITelemetry.WARNING_ADDON_ASKING_PREVENTED
+        );
+        let popup = PopupNotifications.show(
+          browser,
+          aTopic,
+          messageString,
+          gUnifiedExtensions.getPopupAnchorID(browser, window),
+          null,
+          null,
+          options
+        );
+        removeNotificationOnEnd(popup, installInfo.installs);
+        break;
+      }
+      case "addon-install-blocked": {
+        await window.ensureCustomElements("moz-support-link");
+        // Dismiss the progress notification.  Note that this is bad if
+        // there are multiple simultaneous installs happening, see
+        // bug 1329884 for a longer explanation.
+        let progressNotification = PopupNotifications.getNotification(
+          "addon-progress",
+          browser
+        );
+        if (progressNotification) {
+          progressNotification.remove();
+        }
+
+        // The informational content differs somewhat for site permission
+        // add-ons. AOM no longer supports installing multiple addons,
+        // so the array handling here is vestigial.
+        let isSitePermissionAddon = installInfo.installs.every(
+          ({ addon }) => addon?.type === lazy.SITEPERMS_ADDON_TYPE
+        );
+        let hasHost = false;
+        let headerId, msgId;
+        if (isSitePermissionAddon) {
+          // At present, WebMIDI is the only consumer of the site permission
+          // add-on infrastructure, and so we can hard-code a midi string here.
+          // If and when we use it for other things, we'll need to plumb that
+          // information through. See bug 1826747.
+          headerId = "site-permission-install-first-prompt-midi-header";
+          msgId = "site-permission-install-first-prompt-midi-message";
+        } else if (options.displayURI) {
+          // PopupNotifications.show replaces <> with options.name.
+          headerId = { id: "xpinstall-prompt-header", args: { host: "<>" } };
+          // BrowserUIUtils.getLocalizedFragment replaces %1$S with options.name.
+          msgId = { id: "xpinstall-prompt-message", args: { host: "%1$S" } };
+          options.name = options.displayURI.displayHost;
+          hasHost = true;
+        } else {
+          headerId = "xpinstall-prompt-header-unknown";
+          msgId = "xpinstall-prompt-message-unknown";
+        }
+        const [headerString, msgString] = await lazy.l10n.formatValues([
+          headerId,
+          msgId,
+        ]);
+
+        // displayURI becomes it's own label, so we unset it for this panel. It will become part of the
+        // messageString above.
+        let displayURI = options.displayURI;
+        options.displayURI = undefined;
+
+        options.eventCallback = topic => {
+          if (topic !== "showing") {
+            return;
+          }
+          let doc = browser.ownerDocument;
+          let message = doc.getElementById("addon-install-blocked-message");
+          // We must remove any prior use of this panel message in this window.
+          while (message.firstChild) {
+            message.firstChild.remove();
+          }
+
+          if (!hasHost) {
+            message.textContent = msgString;
+          } else {
+            let b = doc.createElementNS("http://www.w3.org/1999/xhtml", "b");
+            b.textContent = options.name;
+            let fragment = BrowserUIUtils.getLocalizedFragment(
+              doc,
+              msgString,
+              b
+            );
+            message.appendChild(fragment);
+          }
+
+          let article = isSitePermissionAddon
+            ? "site-permission-addons"
+            : "unlisted-extensions-risks";
+          let learnMore = doc.getElementById("addon-install-blocked-info");
+          learnMore.setAttribute("support-page", article);
+        };
+
+        let secHistogram = Services.telemetry.getHistogramById("SECURITY_UI");
+        secHistogram.add(
+          Ci.nsISecurityUITelemetry.WARNING_ADDON_ASKING_PREVENTED
+        );
+
+        const [
+          installMsg,
+          dontAllowMsg,
+          neverAllowMsg,
+          neverAllowAndReportMsg,
+        ] = await lazy.l10n.formatMessages([
+          "xpinstall-prompt-install",
+          "xpinstall-prompt-dont-allow",
+          "xpinstall-prompt-never-allow",
+          "xpinstall-prompt-never-allow-and-report",
+        ]);
+
+        const action = buildNotificationAction(installMsg, () => {
+          secHistogram.add(
+            Ci.nsISecurityUITelemetry
+              .WARNING_ADDON_ASKING_PREVENTED_CLICK_THROUGH
+          );
+          installInfo.install();
+        });
+
+        const neverAllowCallback = () => {
+          SitePermissions.setForPrincipal(
+            browser.contentPrincipal,
+            "install",
+            SitePermissions.BLOCK
+          );
+          for (let install of installInfo.installs) {
+            if (install.state != AddonManager.STATE_CANCELLED) {
+              install.cancel();
+            }
+          }
+          if (installInfo.cancel) {
+            installInfo.cancel();
+          }
+        };
+
+        const declineActions = [
+          buildNotificationAction(dontAllowMsg, () => {
+            for (let install of installInfo.installs) {
+              if (install.state != AddonManager.STATE_CANCELLED) {
+                install.cancel();
+              }
+            }
+            if (installInfo.cancel) {
+              installInfo.cancel();
+            }
+          }),
+          buildNotificationAction(neverAllowMsg, neverAllowCallback),
+        ];
+
+        if (isSitePermissionAddon) {
+          // Restrict this to site permission add-ons for now pending a decision
+          // from product about how to approach this for extensions.
+          declineActions.push(
+            buildNotificationAction(neverAllowAndReportMsg, () => {
+              AMTelemetry.recordEvent({
+                method: "reportSuspiciousSite",
+                object: "suspiciousSite",
+                value: displayURI?.displayHost ?? "(unknown)",
+                extra: {},
+              });
+              neverAllowCallback();
+            })
+          );
+        }
+
+        let popup = PopupNotifications.show(
+          browser,
+          aTopic,
+          headerString,
+          gUnifiedExtensions.getPopupAnchorID(browser, window),
+          action,
+          declineActions,
+          options
+        );
+        removeNotificationOnEnd(popup, installInfo.installs);
+        break;
+      }
+      case "addon-install-started": {
+        // If all installs have already been downloaded then there is no need to
+        // show the download progress
+        if (
+          installInfo.installs.every(
+            aInstall => aInstall.state == AddonManager.STATE_DOWNLOADED
+          )
+        ) {
+          return;
+        }
+
+        const messageString = lazy.l10n.formatValueSync(
+          "addon-downloading-and-verifying",
+          { addonCount: installInfo.installs.length }
+        );
+        options.installs = installInfo.installs;
+        options.contentWindow = browser.contentWindow;
+        options.sourceURI = browser.currentURI;
+        options.eventCallback = function (aEvent) {
+          switch (aEvent) {
+            case "removed":
+              options.contentWindow = null;
+              options.sourceURI = null;
+              break;
+          }
+        };
+
+        const [acceptMsg, cancelMsg] = lazy.l10n.formatMessagesSync([
+          "addon-install-accept-button",
+          "addon-install-cancel-button",
+        ]);
+
+        const action = buildNotificationAction(acceptMsg, () => {});
+        action.disabled = true;
+
+        const secondaryAction = buildNotificationAction(cancelMsg, () => {
+          for (let install of installInfo.installs) {
+            if (install.state != AddonManager.STATE_CANCELLED) {
+              install.cancel();
+            }
+          }
+        });
+
+        let notification = PopupNotifications.show(
+          browser,
+          "addon-progress",
+          messageString,
+          gUnifiedExtensions.getPopupAnchorID(browser, window),
+          action,
+          [secondaryAction],
+          options
+        );
+        notification._startTime = Date.now();
+
+        break;
+      }
+      case "addon-install-failed": {
+        options.removeOnDismissal = true;
+        options.persistent = false;
+
+        // TODO This isn't terribly ideal for the multiple failure case
+        for (let install of installInfo.installs) {
+          let host;
+          try {
+            host = options.displayURI.host;
+          } catch (e) {
+            // displayURI might be missing or 'host' might throw for non-nsStandardURL nsIURIs.
+          }
+
+          if (!host) {
+            host =
+              install.sourceURI instanceof Ci.nsIStandardURL &&
+              install.sourceURI.host;
+          }
+
+          let messageString;
+          if (
+            install.addon &&
+            !Services.policies.mayInstallAddon(install.addon)
+          ) {
+            messageString = lazy.l10n.formatValueSync(
+              "addon-install-blocked-by-policy",
+              { addonName: install.name, addonId: install.addon.id }
+            );
+            let extensionSettings = Services.policies.getExtensionSettings(
+              install.addon.id
+            );
+            if (
+              extensionSettings &&
+              "blocked_install_message" in extensionSettings
+            ) {
+              messageString += " " + extensionSettings.blocked_install_message;
+            }
+          } else {
+            // TODO bug 1834484: simplify computation of isLocal.
+            const isLocal = !host;
+            let errorId = ERROR_L10N_IDS.get(install.error)?.[isLocal ? 1 : 0];
+            const args = { addonName: install.name };
+            if (!errorId) {
+              if (
+                install.addon.blocklistState ==
+                Ci.nsIBlocklistService.STATE_BLOCKED
+              ) {
+                errorId = "addon-install-error-blocklisted";
+              } else {
+                errorId = "addon-install-error-incompatible";
+                args.appVersion = Services.appinfo.version;
+              }
+            }
+            messageString = lazy.l10n.formatValueSync(errorId, args);
+          }
+
+          // Add Learn More link when refusing to install an unsigned add-on
+          if (install.error == AddonManager.ERROR_SIGNEDSTATE_REQUIRED) {
+            options.learnMoreURL =
+              Services.urlFormatter.formatURLPref("app.support.baseURL") +
+              "unsigned-addons";
+          }
+
+          PopupNotifications.show(
+            browser,
+            aTopic,
+            messageString,
+            gUnifiedExtensions.getPopupAnchorID(browser, window),
+            null,
+            null,
+            options
+          );
+
+          // Can't have multiple notifications with the same ID, so stop here.
+          break;
+        }
+        this._removeProgressNotification(browser);
+        break;
+      }
+      case "addon-install-confirmation": {
+        let showNotification = () => {
+          let height = undefined;
+
+          if (PopupNotifications.isPanelOpen) {
+            let rect = document
+              .getElementById("addon-progress-notification")
+              .getBoundingClientRect();
+            height = rect.height;
+          }
+
+          this._removeProgressNotification(browser);
+          this.showInstallConfirmation(browser, installInfo, height);
+        };
+
+        let progressNotification = PopupNotifications.getNotification(
+          "addon-progress",
+          browser
+        );
+        if (progressNotification) {
+          let downloadDuration = Date.now() - progressNotification._startTime;
+          let securityDelay =
+            Services.prefs.getIntPref("security.dialog_enable_delay") -
+            downloadDuration;
+          if (securityDelay > 0) {
+            setTimeout(() => {
+              // The download may have been cancelled during the security delay
+              if (
+                PopupNotifications.getNotification("addon-progress", browser)
+              ) {
+                showNotification();
+              }
+            }, securityDelay);
+            break;
+          }
+        }
+        showNotification();
+        break;
+      }
+    }
+  },
+  _removeProgressNotification(aBrowser) {
+    let notification = PopupNotifications.getNotification(
+      "addon-progress",
+      aBrowser
+    );
+    if (notification) {
+      notification.remove();
+    }
+  },
+};
+
+var gExtensionsNotifications = {
+  initialized: false,
+  init() {
+    this.updateAlerts();
+    this.boundUpdate = this.updateAlerts.bind(this);
+    ExtensionsUI.on("change", this.boundUpdate);
+    this.initialized = true;
+  },
+
+  uninit() {
+    // uninit() can race ahead of init() in some cases, if that happens,
+    // we have no handler to remove.
+    if (!this.initialized) {
+      return;
+    }
+    ExtensionsUI.off("change", this.boundUpdate);
+  },
+
+  _createAddonButton(l10nId, addon, callback) {
+    let text = lazy.l10n.formatValueSync(l10nId, { addonName: addon.name });
+    let button = document.createXULElement("toolbarbutton");
+    button.setAttribute("wrap", "true");
+    button.setAttribute("label", text);
+    button.setAttribute("tooltiptext", text);
+    const DEFAULT_EXTENSION_ICON =
+      "chrome://mozapps/skin/extensions/extensionGeneric.svg";
+    button.setAttribute("image", addon.iconURL || DEFAULT_EXTENSION_ICON);
+    button.className = "addon-banner-item subviewbutton";
+
+    button.addEventListener("command", callback);
+    PanelUI.addonNotificationContainer.appendChild(button);
+  },
+
+  updateAlerts() {
+    let sideloaded = ExtensionsUI.sideloaded;
+    let updates = ExtensionsUI.updates;
+
+    let container = PanelUI.addonNotificationContainer;
+
+    while (container.firstChild) {
+      container.firstChild.remove();
+    }
+
+    let items = 0;
+    for (let update of updates) {
+      if (++items > 4) {
+        break;
+      }
+      this._createAddonButton(
+        "webext-perms-update-menu-item",
+        update.addon,
+        evt => {
+          ExtensionsUI.showUpdate(gBrowser, update);
+        }
+      );
+    }
+
+    for (let addon of sideloaded) {
+      if (++items > 4) {
+        break;
+      }
+      this._createAddonButton("webext-perms-sideload-menu-item", addon, evt => {
+        // We need to hide the main menu manually because the toolbarbutton is
+        // removed immediately while processing this event, and PanelUI is
+        // unable to identify which panel should be closed automatically.
+        PanelUI.hide();
+        ExtensionsUI.showSideloaded(gBrowser, addon);
+      });
+    }
+  },
+};
+
+var BrowserAddonUI = {
+  async promptRemoveExtension(addon) {
+    let { name } = addon;
+    let [title, btnTitle, message] = await lazy.l10n.formatValues([
+      { id: "addon-removal-title", args: { name } },
+      { id: "addon-removal-button" },
+      { id: "addon-removal-message", args: { name } },
+    ]);
+
+    if (Services.prefs.getBoolPref("prompts.windowPromptSubDialog", false)) {
+      message = null;
+    }
+
+    let {
+      BUTTON_TITLE_IS_STRING: titleString,
+      BUTTON_TITLE_CANCEL: titleCancel,
+      BUTTON_POS_0,
+      BUTTON_POS_1,
+      confirmEx,
+    } = Services.prompt;
+    let btnFlags = BUTTON_POS_0 * titleString + BUTTON_POS_1 * titleCancel;
+
+    // Enable abuse report checkbox in the remove extension dialog,
+    // if enabled by the about:config prefs and the addon type
+    // is currently supported.
+    let checkboxMessage = null;
+    if (
+      gAddonAbuseReportEnabled &&
+      ["extension", "theme"].includes(addon.type)
+    ) {
+      checkboxMessage = await lazy.l10n.formatValue(
+        "addon-removal-abuse-report-checkbox"
+      );
+    }
+
+    let checkboxState = { value: false };
+    let result = confirmEx(
+      window,
+      title,
+      message,
+      btnFlags,
+      btnTitle,
+      /* button1 */ null,
+      /* button2 */ null,
+      checkboxMessage,
+      checkboxState
+    );
+
+    return { remove: result === 0, report: checkboxState.value };
+  },
+
+  async reportAddon(addonId, reportEntryPoint) {
+    let addon = addonId && (await AddonManager.getAddonByID(addonId));
+    if (!addon) {
+      return;
+    }
+
+    const win = await BrowserOpenAddonsMgr("addons://list/extension");
+
+    win.openAbuseReport({ addonId, reportEntryPoint });
+  },
+
+  async removeAddon(addonId, eventObject) {
+    let addon = addonId && (await AddonManager.getAddonByID(addonId));
+    if (!addon || !(addon.permissions & AddonManager.PERM_CAN_UNINSTALL)) {
+      return;
+    }
+
+    let { remove, report } = await this.promptRemoveExtension(addon);
+
+    if (remove) {
+      // Leave the extension in pending uninstall if we are also reporting the
+      // add-on.
+      await addon.uninstall(report);
+
+      if (report) {
+        await this.reportAddon(addon.id, "uninstall");
+      }
+    }
+  },
+
+  async manageAddon(addonId, eventObject) {
+    let addon = addonId && (await AddonManager.getAddonByID(addonId));
+    if (!addon) {
+      return;
+    }
+
+    BrowserOpenAddonsMgr("addons://detail/" + encodeURIComponent(addon.id));
+  },
+};
+
+// We must declare `gUnifiedExtensions` using `var` below to avoid a
+// "redeclaration" syntax error.
+var gUnifiedExtensions = {
+  _initialized: false,
+
+  // We use a `<deck>` in the extension items to show/hide messages below each
+  // extension name. We have a default message for origin controls, and
+  // optionally a second message shown on hover, which describes the action
+  // (when clicking on the action button). We have another message shown when
+  // the menu button is hovered/focused. The constants below define the indexes
+  // of each message in the `<deck>`.
+  MESSAGE_DECK_INDEX_DEFAULT: 0,
+  MESSAGE_DECK_INDEX_HOVER: 1,
+  MESSAGE_DECK_INDEX_MENU_HOVER: 2,
+
+  init() {
+    if (this._initialized) {
+      return;
+    }
+
+    this._button = document.getElementById("unified-extensions-button");
+    // TODO: Bug 1778684 - Auto-hide button when there is no active extension.
+    this._button.hidden = false;
+
+    document
+      .getElementById("nav-bar")
+      .setAttribute("unifiedextensionsbuttonshown", true);
+
+    gBrowser.addTabsProgressListener(this);
+    window.addEventListener("TabSelect", () => this.updateAttention());
+    window.addEventListener("toolbarvisibilitychange", this);
+
+    this.permListener = () => this.updateAttention();
+    lazy.ExtensionPermissions.addListener(this.permListener);
+
+    gNavToolbox.addEventListener("customizationstarting", this);
+    CustomizableUI.addListener(this);
+
+    this._initialized = true;
+  },
+
+  uninit() {
+    if (!this._initialized) {
+      return;
+    }
+
+    window.removeEventListener("toolbarvisibilitychange", this);
+
+    lazy.ExtensionPermissions.removeListener(this.permListener);
+    this.permListener = null;
+
+    gNavToolbox.removeEventListener("customizationstarting", this);
+    CustomizableUI.removeListener(this);
+  },
+
+  onLocationChange(browser, webProgress, _request, _uri, flags) {
+    // Only update on top-level cross-document navigations in the selected tab.
+    if (
+      webProgress.isTopLevel &&
+      browser === gBrowser.selectedBrowser &&
+      !(flags & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT)
+    ) {
+      this.updateAttention();
+    }
+  },
+
+  // Update the attention indicator for the whole unified extensions button.
+  updateAttention() {
+    let attention = false;
+    for (let policy of this.getActivePolicies()) {
+      let widget = this.browserActionFor(policy)?.widget;
+
+      // Only show for extensions which are not already visible in the toolbar.
+      if (!widget || widget.areaType !== CustomizableUI.TYPE_TOOLBAR) {
+        if (lazy.OriginControls.getAttention(policy, window)) {
+          attention = true;
+          break;
+        }
+      }
+    }
+    this.button.toggleAttribute("attention", attention);
+    this.button.ownerDocument.l10n.setAttributes(
+      this.button,
+      attention
+        ? "unified-extensions-button-permissions-needed"
+        : "unified-extensions-button"
+    );
+  },
+
+  getPopupAnchorID(aBrowser, aWindow) {
+    const anchorID = "unified-extensions-button";
+    const attr = anchorID + "popupnotificationanchor";
+
+    if (!aBrowser[attr]) {
+      // A hacky way of setting the popup anchor outside the usual url bar
+      // icon box, similar to how it was done for CFR.
+      // See: https://searchfox.org/mozilla-central/rev/c5c002f81f08a73e04868e0c2bf0eb113f200b03/toolkit/modules/PopupNotifications.sys.mjs#40
+      aBrowser[attr] = aWindow.document.getElementById(
+        anchorID
+        // Anchor on the toolbar icon to position the popup right below the
+        // button.
+      ).firstElementChild;
+    }
+
+    return anchorID;
+  },
+
+  get button() {
+    return this._button;
+  },
+
+  /**
+   * Gets a list of active WebExtensionPolicy instances of type "extension",
+   * sorted alphabetically based on add-on's names. Optionally, filter out
+   * extensions with browser action.
+   *
+   * @param {bool} all When set to true (the default), return the list of all
+   *                   active policies, including the ones that have a
+   *                   browser action. Otherwise, extensions with browser
+   *                   action are filtered out.
+   * @returns {Array<WebExtensionPolicy>} An array of active policies.
+   */
+  getActivePolicies(all = true) {
+    let policies = WebExtensionPolicy.getActiveExtensions();
+    policies = policies.filter(policy => {
+      let { extension } = policy;
+      if (!policy.active || extension?.type !== "extension") {
+        return false;
+      }
+
+      // Ignore hidden and extensions that cannot access the current window
+      // (because of PB mode when we are in a private window), since users
+      // cannot do anything with those extensions anyway.
+      if (extension.isHidden || !policy.canAccessWindow(window)) {
+        return false;
+      }
+
+      return all || !extension.hasBrowserActionUI;
+    });
+
+    policies.sort((a, b) => a.name.localeCompare(b.name));
+    return policies;
+  },
+
+  /**
+   * Returns true when there are active extensions listed/shown in the unified
+   * extensions panel, and false otherwise (e.g. when extensions are pinned in
+   * the toolbar OR there are 0 active extensions).
+   *
+   * @returns {boolean} Whether there are extensions listed in the panel.
+   */
+  hasExtensionsInPanel() {
+    const policies = this.getActivePolicies();
+
+    return !!policies
+      .map(policy => this.browserActionFor(policy)?.widget)
+      .filter(widget => {
+        return (
+          !widget ||
+          widget?.areaType !== CustomizableUI.TYPE_TOOLBAR ||
+          widget?.forWindow(window).overflowed
+        );
+      }).length;
+  },
+
+  handleEvent(event) {
+    switch (event.type) {
+      case "ViewShowing":
+        this.onPanelViewShowing(event.target);
+        break;
+
+      case "ViewHiding":
+        this.onPanelViewHiding(event.target);
+        break;
+
+      case "customizationstarting":
+        this.panel.hidePopup();
+        break;
+
+      case "toolbarvisibilitychange":
+        this.onToolbarVisibilityChange(event.target.id, event.detail.visible);
+        break;
+    }
+  },
+
+  onPanelViewShowing(panelview) {
+    const list = panelview.querySelector(".unified-extensions-list");
+    // Only add extensions that do not have a browser action in this list since
+    // the extensions with browser action have CUI widgets and will appear in
+    // the panel (or toolbar) via the CUI mechanism.
+    for (const policy of this.getActivePolicies(/* all */ false)) {
+      const item = document.createElement("unified-extensions-item");
+      item.setExtension(policy.extension);
+      list.appendChild(item);
+    }
+
+    const isQuarantinedDomain = this.getActivePolicies().some(
+      policy =>
+        lazy.OriginControls.getState(policy, window.gBrowser.selectedTab)
+          .quarantined
+    );
+    const container = panelview.querySelector(
+      "#unified-extensions-messages-container"
+    );
+
+    if (isQuarantinedDomain) {
+      if (!this._messageBarQuarantinedDomain) {
+        this._messageBarQuarantinedDomain = this._makeMessageBar({
+          titleFluentId: "unified-extensions-mb-quarantined-domain-title",
+          messageFluentId: "unified-extensions-mb-quarantined-domain-message",
+          supportPage: "quarantined-domains",
+          dismissable: false,
+        });
+        this._messageBarQuarantinedDomain
+          .querySelector("a")
+          .addEventListener("click", () => {
+            this.togglePanel();
+          });
+      }
+
+      container.appendChild(this._messageBarQuarantinedDomain);
+    } else if (
+      !isQuarantinedDomain &&
+      this._messageBarQuarantinedDomain &&
+      container.contains(this._messageBarQuarantinedDomain)
+    ) {
+      container.removeChild(this._messageBarQuarantinedDomain);
+    }
+  },
+
+  onPanelViewHiding(panelview) {
+    if (window.closed) {
+      return;
+    }
+    const list = panelview.querySelector(".unified-extensions-list");
+    while (list.lastChild) {
+      list.lastChild.remove();
+    }
+    // If temporary access was granted, (maybe) clear attention indicator.
+    requestAnimationFrame(() => this.updateAttention());
+  },
+
+  onToolbarVisibilityChange(toolbarId, isVisible) {
+    // A list of extension widget IDs (possibly empty).
+    let widgetIDs;
+
+    try {
+      widgetIDs = CustomizableUI.getWidgetIdsInArea(toolbarId).filter(
+        CustomizableUI.isWebExtensionWidget
+      );
+    } catch {
+      // Do nothing if the area does not exist for some reason.
+      return;
+    }
+
+    // The list of overflowed extensions in the extensions panel.
+    const overflowedExtensionsList = this.panel.querySelector(
+      "#overflowed-extensions-list"
+    );
+
+    // We are going to move all the extension widgets via DOM manipulation
+    // *only* so that it looks like these widgets have moved (and users will
+    // see that) but CUI still thinks the widgets haven't been moved.
+    //
+    // We can move the extension widgets either from the toolbar to the
+    // extensions panel OR the other way around (when the toolbar becomes
+    // visible again).
+    for (const widgetID of widgetIDs) {
+      const widget = CustomizableUI.getWidget(widgetID);
+      if (!widget) {
+        continue;
+      }
+
+      if (isVisible) {
+        this._maybeMoveWidgetNodeBack(widget.id);
+      } else {
+        const { node } = widget.forWindow(window);
+        // Artificially overflow the extension widget in the extensions panel
+        // when the toolbar is hidden.
+        node.setAttribute("overflowedItem", true);
+        node.setAttribute("artificallyOverflowed", true);
+        // This attribute forces browser action popups to be anchored to the
+        // extensions button.
+        node.setAttribute("cui-anchorid", "unified-extensions-button");
+        overflowedExtensionsList.appendChild(node);
+
+        this._updateWidgetClassName(widgetID, /* inPanel */ true);
+      }
+    }
+  },
+
+  _maybeMoveWidgetNodeBack(widgetID) {
+    const widget = CustomizableUI.getWidget(widgetID);
+    if (!widget) {
+      return;
+    }
+
+    // We only want to move back widget nodes that have been manually moved
+    // previously via `onToolbarVisibilityChange()`.
+    const { node } = widget.forWindow(window);
+    if (!node.hasAttribute("artificallyOverflowed")) {
+      return;
+    }
+
+    const { area, position } = CustomizableUI.getPlacementOfWidget(widgetID);
+
+    // This is where we are going to re-insert the extension widgets (DOM
+    // nodes) but we need to account for some hidden DOM nodes already present
+    // in this container when determining where to put the nodes back.
+    const container = document.getElementById(area);
+
+    let moved = false;
+    let currentPosition = 0;
+
+    for (const child of container.childNodes) {
+      const isSkipToolbarset = child.getAttribute("skipintoolbarset") == "true";
+      if (isSkipToolbarset && child !== container.lastChild) {
+        continue;
+      }
+
+      if (currentPosition === position) {
+        child.before(node);
+        moved = true;
+        break;
+      }
+
+      if (child === container.lastChild) {
+        child.after(node);
+        moved = true;
+        break;
+      }
+
+      currentPosition++;
+    }
+
+    if (moved) {
+      // Remove the attribute set when we artificially overflow the widget.
+      node.removeAttribute("overflowedItem");
+      node.removeAttribute("artificallyOverflowed");
+      node.removeAttribute("cui-anchorid");
+
+      this._updateWidgetClassName(widgetID, /* inPanel */ false);
+    }
+  },
+
+  _panel: null,
+  get panel() {
+    // Lazy load the unified-extensions-panel panel the first time we need to
+    // display it.
+    if (!this._panel) {
+      let template = document.getElementById(
+        "unified-extensions-panel-template"
+      );
+      template.replaceWith(template.content);
+      this._panel = document.getElementById("unified-extensions-panel");
+      let customizationArea = this._panel.querySelector(
+        "#unified-extensions-area"
+      );
+      CustomizableUI.registerPanelNode(
+        customizationArea,
+        CustomizableUI.AREA_ADDONS
+      );
+      CustomizableUI.addPanelCloseListeners(this._panel);
+
+      // Lazy-load the l10n strings. Those strings are used for the CUI and
+      // non-CUI extensions in the unified extensions panel.
+      document
+        .getElementById("unified-extensions-context-menu")
+        .querySelectorAll("[data-lazy-l10n-id]")
+        .forEach(el => {
+          el.setAttribute("data-l10n-id", el.getAttribute("data-lazy-l10n-id"));
+          el.removeAttribute("data-lazy-l10n-id");
+        });
+    }
+    return this._panel;
+  },
+
+  async togglePanel(aEvent) {
+    if (!CustomizationHandler.isCustomizing()) {
+      if (aEvent) {
+        if (
+          // On MacOS, ctrl-click will send a context menu event from the
+          // widget, so we don't want to bring up the panel when ctrl key is
+          // pressed.
+          (aEvent.type == "mousedown" &&
+            (aEvent.button !== 0 ||
+              (AppConstants.platform === "macosx" && aEvent.ctrlKey))) ||
+          (aEvent.type === "keypress" &&
+            aEvent.charCode !== KeyEvent.DOM_VK_SPACE &&
+            aEvent.keyCode !== KeyEvent.DOM_VK_RETURN)
+        ) {
+          return;
+        }
+
+        // The button should directly open `about:addons` when the user does not
+        // have any active extensions listed in the unified extensions panel.
+        if (!this.hasExtensionsInPanel()) {
+          let viewID;
+          if (
+            Services.prefs.getBoolPref("extensions.getAddons.showPane", true)
+          ) {
+            viewID = "addons://discover/";
+          } else {
+            viewID = "addons://list/extension";
+          }
+          await BrowserOpenAddonsMgr(viewID);
+          return;
+        }
+      }
+
+      let panel = this.panel;
+
+      if (!this._listView) {
+        this._listView = PanelMultiView.getViewNode(
+          document,
+          "unified-extensions-view"
+        );
+        this._listView.addEventListener("ViewShowing", this);
+        this._listView.addEventListener("ViewHiding", this);
+      }
+
+      if (this._button.open) {
+        PanelMultiView.hidePopup(panel);
+        this._button.open = false;
+      } else {
+        // Overflow extensions placed in collapsed toolbars, if any.
+        for (const toolbarId of CustomizableUI.getCollapsedToolbarIds(window)) {
+          // We pass `false` because all these toolbars are collapsed.
+          this.onToolbarVisibilityChange(toolbarId, /* isVisible */ false);
+        }
+
+        panel.hidden = false;
+        PanelMultiView.openPopup(panel, this._button, {
+          position: "bottomright topright",
+          triggerEvent: aEvent,
+        });
+      }
+    }
+
+    // We always dispatch an event (useful for testing purposes).
+    window.dispatchEvent(new CustomEvent("UnifiedExtensionsTogglePanel"));
+  },
+
+  updateContextMenu(menu, event) {
+    // When the context menu is open, `onpopupshowing` is called when menu
+    // items open sub-menus. We don't want to update the context menu in this
+    // case.
+    if (event.target.id !== "unified-extensions-context-menu") {
+      return;
+    }
+
+    const id = this._getExtensionId(menu);
+    const widgetId = this._getWidgetId(menu);
+    const forBrowserAction = !!widgetId;
+
+    const pinButton = menu.querySelector(
+      ".unified-extensions-context-menu-pin-to-toolbar"
+    );
+    const removeButton = menu.querySelector(
+      ".unified-extensions-context-menu-remove-extension"
+    );
+    const reportButton = menu.querySelector(
+      ".unified-extensions-context-menu-report-extension"
+    );
+    const menuSeparator = menu.querySelector(
+      ".unified-extensions-context-menu-management-separator"
+    );
+    const moveUp = menu.querySelector(
+      ".unified-extensions-context-menu-move-widget-up"
+    );
+    const moveDown = menu.querySelector(
+      ".unified-extensions-context-menu-move-widget-down"
+    );
+
+    for (const element of [menuSeparator, pinButton, moveUp, moveDown]) {
+      element.hidden = !forBrowserAction;
+    }
+
+    reportButton.hidden = !gAddonAbuseReportEnabled;
+    // We use this syntax instead of async/await to not block this method that
+    // updates the context menu. This avoids the context menu to be out of sync
+    // on macOS.
+    AddonManager.getAddonByID(id).then(addon => {
+      removeButton.disabled = !(
+        addon.permissions & AddonManager.PERM_CAN_UNINSTALL
+      );
+    });
+
+    if (forBrowserAction) {
+      let area = CustomizableUI.getPlacementOfWidget(widgetId).area;
+      let inToolbar = area != CustomizableUI.AREA_ADDONS;
+      pinButton.setAttribute("checked", inToolbar);
+
+      const placement = CustomizableUI.getPlacementOfWidget(widgetId);
+      const notInPanel = placement?.area !== CustomizableUI.AREA_ADDONS;
+      // We rely on the DOM nodes because CUI widgets will always exist but
+      // not necessarily with DOM nodes created depending on the window. For
+      // example, in PB mode, not all extensions will be listed in the panel
+      // but the CUI widgets may be all created.
+      if (
+        notInPanel ||
+        document.querySelector("#unified-extensions-area > :first-child")
+          ?.id === widgetId
+      ) {
+        moveUp.hidden = true;
+      }
+
+      if (
+        notInPanel ||
+        document.querySelector("#unified-extensions-area > :last-child")?.id ===
+          widgetId
+      ) {
+        moveDown.hidden = true;
+      }
+    }
+
+    ExtensionsUI.originControlsMenu(menu, id);
+
+    const browserAction = this.browserActionFor(WebExtensionPolicy.getByID(id));
+    if (browserAction) {
+      browserAction.updateContextMenu(menu);
+    }
+  },
+
+  // This is registered on the top-level unified extensions context menu.
+  onContextMenuCommand(menu, event) {
+    // Do not close the extensions panel automatically when we move extension
+    // widgets.
+    const { classList } = event.target;
+    if (
+      classList.contains("unified-extensions-context-menu-move-widget-up") ||
+      classList.contains("unified-extensions-context-menu-move-widget-down")
+    ) {
+      return;
+    }
+
+    this.togglePanel();
+  },
+
+  browserActionFor(policy) {
+    // Ideally, we wouldn't do that because `browserActionFor()` will only be
+    // defined in `global` when at least one extension has required loading the
+    // `ext-browserAction` code.
+    let method = lazy.ExtensionParent.apiManager.global.browserActionFor;
+    return method?.(policy?.extension);
+  },
+
+  async manageExtension(menu) {
+    const id = this._getExtensionId(menu);
+
+    await BrowserAddonUI.manageAddon(id, "unifiedExtensions");
+  },
+
+  async removeExtension(menu) {
+    const id = this._getExtensionId(menu);
+
+    await BrowserAddonUI.removeAddon(id, "unifiedExtensions");
+  },
+
+  async reportExtension(menu) {
+    const id = this._getExtensionId(menu);
+
+    await BrowserAddonUI.reportAddon(id, "unified_context_menu");
+  },
+
+  _getExtensionId(menu) {
+    const { triggerNode } = menu;
+    return triggerNode.dataset.extensionid;
+  },
+
+  _getWidgetId(menu) {
+    const { triggerNode } = menu;
+    return triggerNode.closest(".unified-extensions-item")?.id;
+  },
+
+  async onPinToToolbarChange(menu, event) {
+    let shouldPinToToolbar = event.target.getAttribute("checked") == "true";
+    // Revert the checkbox back to its original state. This is because the
+    // addon context menu handlers are asynchronous, and there seems to be
+    // a race where the checkbox state won't get set in time to show the
+    // right state. So we err on the side of caution, and presume that future
+    // attempts to open this context menu on an extension button will show
+    // the same checked state that we started in.
+    event.target.setAttribute("checked", !shouldPinToToolbar);
+
+    let widgetId = this._getWidgetId(menu);
+    if (!widgetId) {
+      return;
+    }
+
+    // We artificially overflow extension widgets that are placed in collapsed
+    // toolbars and CUI does not know about it. For end users, these widgets
+    // appear in the list of overflowed extensions in the panel. When we unpin
+    // and then pin one of these extensions to the toolbar, we need to first
+    // move the DOM node back to where it was (i.e.  in the collapsed toolbar)
+    // so that CUI can retrieve the DOM node and do the pinning correctly.
+    if (shouldPinToToolbar) {
+      this._maybeMoveWidgetNodeBack(widgetId);
+    }
+
+    this.pinToToolbar(widgetId, shouldPinToToolbar);
+  },
+
+  pinToToolbar(widgetId, shouldPinToToolbar) {
+    let newArea = shouldPinToToolbar
+      ? CustomizableUI.AREA_NAVBAR
+      : CustomizableUI.AREA_ADDONS;
+    let newPosition = shouldPinToToolbar ? undefined : 0;
+
+    CustomizableUI.addWidgetToArea(widgetId, newArea, newPosition);
+
+    this.updateAttention();
+  },
+
+  async moveWidget(menu, direction) {
+    // We'll move the widgets based on the DOM node positions. This is because
+    // in PB mode (for example), we might not have the same extensions listed
+    // in the panel but CUI does not know that. As far as CUI is concerned, all
+    // extensions will likely have widgets.
+    const node = menu.triggerNode.closest(".unified-extensions-item");
+
+    // Find the element that is before or after the current widget/node to
+    // move. `element` might be `null`, e.g. if the current node is the first
+    // one listed in the panel (though it shouldn't be possible to call this
+    // method in this case).
+    let element;
+    if (direction === "up" && node.previousElementSibling) {
+      element = node.previousElementSibling;
+    } else if (direction === "down" && node.nextElementSibling) {
+      element = node.nextElementSibling;
+    }
+
+    // Now we need to retrieve the position of the CUI placement.
+    const placement = CustomizableUI.getPlacementOfWidget(element?.id);
+    if (placement) {
+      let newPosition = placement.position;
+      // That, I am not sure why this is required but it looks like we need to
+      // always add one to the current position if we want to move a widget
+      // down in the list.
+      if (direction === "down") {
+        newPosition += 1;
+      }
+
+      CustomizableUI.moveWidgetWithinArea(node.id, newPosition);
+    }
+  },
+
+  onWidgetAdded(aWidgetId, aArea, aPosition) {
+    // When we pin a widget to the toolbar from a narrow window, the widget
+    // will be overflowed directly. In this case, we do not want to change the
+    // class name since it is going to be changed by `onWidgetOverflow()`
+    // below.
+    if (CustomizableUI.getWidget(aWidgetId)?.forWindow(window)?.overflowed) {
+      return;
+    }
+
+    const inPanel =
+      CustomizableUI.getAreaType(aArea) !== CustomizableUI.TYPE_TOOLBAR;
+
+    this._updateWidgetClassName(aWidgetId, inPanel);
+  },
+
+  onWidgetOverflow(aNode, aContainer) {
+    // We register a CUI listener for each window so we make sure that we
+    // handle the event for the right window here.
+    if (window !== aNode.ownerGlobal) {
+      return;
+    }
+
+    this._updateWidgetClassName(aNode.getAttribute("widget-id"), true);
+  },
+
+  onWidgetUnderflow(aNode, aContainer) {
+    // We register a CUI listener for each window so we make sure that we
+    // handle the event for the right window here.
+    if (window !== aNode.ownerGlobal) {
+      return;
+    }
+
+    this._updateWidgetClassName(aNode.getAttribute("widget-id"), false);
+  },
+
+  onAreaNodeRegistered(aArea, aContainer) {
+    // We register a CUI listener for each window so we make sure that we
+    // handle the event for the right window here.
+    if (window !== aContainer.ownerGlobal) {
+      return;
+    }
+
+    const inPanel =
+      CustomizableUI.getAreaType(aArea) !== CustomizableUI.TYPE_TOOLBAR;
+
+    for (const widgetId of CustomizableUI.getWidgetIdsInArea(aArea)) {
+      this._updateWidgetClassName(widgetId, inPanel);
+    }
+  },
+
+  // This internal method is used to change some CSS classnames on the action
+  // and menu buttons of an extension (CUI) widget. When the widget is placed
+  // in the panel, the action and menu buttons should have the `.subviewbutton`
+  // class and not the `.toolbarbutton-1` one. When NOT placed in the panel,
+  // it is the other way around.
+  _updateWidgetClassName(aWidgetId, inPanel) {
+    if (!CustomizableUI.isWebExtensionWidget(aWidgetId)) {
+      return;
+    }
+
+    const node = CustomizableUI.getWidget(aWidgetId)?.forWindow(window)?.node;
+    const actionButton = node?.querySelector(
+      ".unified-extensions-item-action-button"
+    );
+    if (actionButton) {
+      actionButton.classList.toggle("subviewbutton", inPanel);
+      actionButton.classList.toggle("subviewbutton-iconic", inPanel);
+      actionButton.classList.toggle("toolbarbutton-1", !inPanel);
+    }
+    const menuButton = node?.querySelector(
+      ".unified-extensions-item-menu-button"
+    );
+    if (menuButton) {
+      menuButton.classList.toggle("subviewbutton", inPanel);
+      menuButton.classList.toggle("subviewbutton-iconic", inPanel);
+      menuButton.classList.toggle("toolbarbutton-1", !inPanel);
+    }
+  },
+
+  _makeMessageBar({
+    messageFluentId,
+    titleFluentId = null,
+    supportPage = null,
+    type = "warning",
+  }) {
+    const messageBar = document.createElement("message-bar");
+    messageBar.setAttribute("type", type);
+    messageBar.classList.add("unified-extensions-message-bar");
+
+    if (titleFluentId) {
+      const titleEl = document.createElement("strong");
+      titleEl.setAttribute("id", titleFluentId);
+      document.l10n.setAttributes(titleEl, titleFluentId);
+      messageBar.append(titleEl);
+    }
+
+    const messageEl = document.createElement("span");
+    messageEl.setAttribute("id", messageFluentId);
+    document.l10n.setAttributes(messageEl, messageFluentId);
+    messageBar.append(messageEl);
+
+    if (supportPage) {
+      window.ensureCustomElements("moz-support-link");
+
+      const supportUrl = document.createElement("a", {
+        is: "moz-support-link",
+      });
+      supportUrl.setAttribute("support-page", supportPage);
+      if (titleFluentId) {
+        supportUrl.setAttribute("aria-labelledby", titleFluentId);
+        supportUrl.setAttribute("aria-describedby", messageFluentId);
+      } else {
+        supportUrl.setAttribute("aria-labelledby", messageFluentId);
+      }
+
+      messageBar.append(supportUrl);
+    }
+
+    return messageBar;
+  },
+};