summaryrefslogtreecommitdiffstats
path: root/toolkit/modules/PopupNotifications.sys.mjs
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 01:47:29 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 01:47:29 +0000
commit0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d (patch)
treea31f07c9bcca9d56ce61e9a1ffd30ef350d513aa /toolkit/modules/PopupNotifications.sys.mjs
parentInitial commit. (diff)
downloadfirefox-esr-0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d.tar.xz
firefox-esr-0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d.zip
Adding upstream version 115.8.0esr.upstream/115.8.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'toolkit/modules/PopupNotifications.sys.mjs')
-rw-r--r--toolkit/modules/PopupNotifications.sys.mjs2021
1 files changed, 2021 insertions, 0 deletions
diff --git a/toolkit/modules/PopupNotifications.sys.mjs b/toolkit/modules/PopupNotifications.sys.mjs
new file mode 100644
index 0000000000..ca51346625
--- /dev/null
+++ b/toolkit/modules/PopupNotifications.sys.mjs
@@ -0,0 +1,2021 @@
+/* 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/. */
+
+import { PrivateBrowsingUtils } from "resource://gre/modules/PrivateBrowsingUtils.sys.mjs";
+
+import { PromiseUtils } from "resource://gre/modules/PromiseUtils.sys.mjs";
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const NOTIFICATION_EVENT_DISMISSED = "dismissed";
+const NOTIFICATION_EVENT_REMOVED = "removed";
+const NOTIFICATION_EVENT_SHOWING = "showing";
+const NOTIFICATION_EVENT_SHOWN = "shown";
+const NOTIFICATION_EVENT_SWAPPING = "swapping";
+
+const ICON_SELECTOR = ".notification-anchor-icon";
+const ICON_ATTRIBUTE_SHOWING = "showing";
+const ICON_ANCHOR_ATTRIBUTE = "popupnotificationanchor";
+
+const PREF_SECURITY_DELAY = "security.notification_enable_delay";
+const FULLSCREEN_TRANSITION_TIME_SHOWN_OFFSET_MS = 2000;
+
+// Enumerated values for the POPUP_NOTIFICATION_STATS telemetry histogram.
+const TELEMETRY_STAT_OFFERED = 0;
+const TELEMETRY_STAT_ACTION_1 = 1;
+const TELEMETRY_STAT_ACTION_2 = 2;
+// const TELEMETRY_STAT_ACTION_3 = 3;
+const TELEMETRY_STAT_ACTION_LAST = 4;
+// const TELEMETRY_STAT_DISMISSAL_CLICK_ELSEWHERE = 5;
+const TELEMETRY_STAT_REMOVAL_LEAVE_PAGE = 6;
+// const TELEMETRY_STAT_DISMISSAL_CLOSE_BUTTON = 7;
+const TELEMETRY_STAT_OPEN_SUBMENU = 10;
+const TELEMETRY_STAT_LEARN_MORE = 11;
+
+const TELEMETRY_STAT_REOPENED_OFFSET = 20;
+const lazy = {};
+
+XPCOMUtils.defineLazyPreferenceGetter(lazy, "buttonDelay", PREF_SECURITY_DELAY);
+
+var popupNotificationsMap = new WeakMap();
+var gNotificationParents = new WeakMap();
+
+function getAnchorFromBrowser(aBrowser, aAnchorID) {
+ let attrPrefix = aAnchorID ? aAnchorID.replace("notification-icon", "") : "";
+ let anchor =
+ aBrowser.getAttribute(attrPrefix + ICON_ANCHOR_ATTRIBUTE) ||
+ aBrowser[attrPrefix + ICON_ANCHOR_ATTRIBUTE] ||
+ aBrowser.getAttribute(ICON_ANCHOR_ATTRIBUTE) ||
+ aBrowser[ICON_ANCHOR_ATTRIBUTE];
+ if (anchor) {
+ if (ChromeUtils.getClassName(anchor) == "XULElement") {
+ return anchor;
+ }
+ return aBrowser.ownerDocument.getElementById(anchor);
+ }
+ return null;
+}
+
+/**
+ * Given a DOM node inside a <popupnotification>, return the parent <popupnotification>.
+ */
+function getNotificationFromElement(aElement) {
+ return aElement.closest("popupnotification");
+}
+
+/**
+ * Notification object describes a single popup notification.
+ *
+ * @see PopupNotifications.show()
+ */
+function Notification(
+ id,
+ message,
+ anchorID,
+ mainAction,
+ secondaryActions,
+ browser,
+ owner,
+ options
+) {
+ this.id = id;
+ this.message = message;
+ this.anchorID = anchorID;
+ this.mainAction = mainAction;
+ this.secondaryActions = secondaryActions || [];
+ this.browser = browser;
+ this.owner = owner;
+ this.options = options || {};
+
+ this._dismissed = false;
+ // Will become a boolean when manually toggled by the user.
+ this._checkboxChecked = null;
+ this.wasDismissed = false;
+ this.recordedTelemetryStats = new Set();
+ this.isPrivate = PrivateBrowsingUtils.isWindowPrivate(
+ this.browser.ownerGlobal
+ );
+ this.timeCreated = this.owner.window.performance.now();
+}
+
+Notification.prototype = {
+ id: null,
+ message: null,
+ anchorID: null,
+ mainAction: null,
+ secondaryActions: null,
+ browser: null,
+ owner: null,
+ options: null,
+ timeShown: null,
+
+ /**
+ * Indicates whether the notification is currently dismissed.
+ */
+ set dismissed(value) {
+ this._dismissed = value;
+ if (value) {
+ // Keep the dismissal into account when recording telemetry.
+ this.wasDismissed = true;
+ }
+ },
+ get dismissed() {
+ return this._dismissed;
+ },
+
+ /**
+ * Removes the notification and updates the popup accordingly if needed.
+ */
+ remove: function Notification_remove() {
+ this.owner.remove(this);
+ },
+
+ get anchorElement() {
+ let iconBox = this.owner.iconBox;
+
+ let anchorElement = getAnchorFromBrowser(this.browser, this.anchorID);
+ if (!iconBox) {
+ return anchorElement;
+ }
+
+ if (!anchorElement && this.anchorID) {
+ anchorElement = iconBox.querySelector("#" + this.anchorID);
+ }
+
+ // Use a default anchor icon if it's available
+ if (!anchorElement) {
+ anchorElement =
+ iconBox.querySelector("#default-notification-icon") || iconBox;
+ }
+
+ return anchorElement;
+ },
+
+ reshow() {
+ this.owner._reshowNotifications(this.anchorElement, this.browser);
+ },
+
+ /**
+ * Adds a value to the specified histogram, that must be keyed by ID.
+ */
+ _recordTelemetry(histogramId, value) {
+ if (this.isPrivate && !this.options.recordTelemetryInPrivateBrowsing) {
+ // The reason why we don't record telemetry in private windows is because
+ // the available actions can be different from regular mode. The main
+ // difference is that all of the persistent permission options like
+ // "Always remember" aren't there, so they really need to be handled
+ // separately to avoid skewing results. For notifications with the same
+ // choices, there would be no reason not to record in private windows as
+ // well, but it's just simpler to use the same check for everything.
+ return;
+ }
+ let histogram = Services.telemetry.getKeyedHistogramById(histogramId);
+ histogram.add("(all)", value);
+ histogram.add(this.id, value);
+ },
+
+ /**
+ * Adds an enumerated value to the POPUP_NOTIFICATION_STATS histogram,
+ * ensuring that it is recorded at most once for each distinct Notification.
+ *
+ * Statistics for reopened notifications are recorded in separate buckets.
+ *
+ * @param value
+ * One of the TELEMETRY_STAT_ constants.
+ */
+ _recordTelemetryStat(value) {
+ if (this.wasDismissed) {
+ value += TELEMETRY_STAT_REOPENED_OFFSET;
+ }
+ if (!this.recordedTelemetryStats.has(value)) {
+ this.recordedTelemetryStats.add(value);
+ this._recordTelemetry("POPUP_NOTIFICATION_STATS", value);
+ }
+ },
+};
+
+/**
+ * The PopupNotifications object manages popup notifications for a given browser
+ * window.
+ * @param tabbrowser
+ * window's TabBrowser. Used to observe tab switching events and
+ * for determining the active browser element.
+ * @param panel
+ * The <xul:panel/> element to use for notifications. The panel is
+ * populated with <popupnotification> children and displayed it as
+ * needed.
+ * @param iconBox
+ * Reference to a container element that should be hidden or
+ * unhidden when notifications are hidden or shown. It should be the
+ * parent of anchor elements whose IDs are passed to show().
+ * It is used as a fallback popup anchor if notifications specify
+ * invalid or non-existent anchor IDs.
+ * @param options
+ * An optional object with the following optional properties:
+ * {
+ * shouldSuppress:
+ * If this function returns true, then all notifications are
+ * suppressed for this window. This state is checked on construction
+ * and when the "anchorVisibilityChange" method is called.
+ * getVisibleAnchorElement(anchorElement):
+ * A function which takes an anchor element as input and should return
+ * either the anchor if it's visible, a fallback anchor element, or if
+ * no fallback exists, a null element.
+ * }
+ */
+export function PopupNotifications(tabbrowser, panel, iconBox, options = {}) {
+ if (!tabbrowser) {
+ throw new Error("Invalid tabbrowser");
+ }
+ if (iconBox && ChromeUtils.getClassName(iconBox) != "XULElement") {
+ throw new Error("Invalid iconBox");
+ }
+ if (ChromeUtils.getClassName(panel) != "XULPopupElement") {
+ throw new Error("Invalid panel");
+ }
+
+ this._shouldSuppress = options.shouldSuppress || (() => false);
+ this._suppress = this._shouldSuppress();
+
+ this._getVisibleAnchorElement = options.getVisibleAnchorElement;
+
+ this.window = tabbrowser.ownerGlobal;
+ this.panel = panel;
+ this.tabbrowser = tabbrowser;
+ this.iconBox = iconBox;
+
+ this.panel.addEventListener("popuphidden", this, true);
+ this.panel.addEventListener("popuppositioned", this);
+ this.panel.classList.add("popup-notification-panel", "panel-no-padding");
+
+ // This listener will be attached to the chrome window whenever a notification
+ // is showing, to allow the user to dismiss notifications using the escape key.
+ this._handleWindowKeyPress = aEvent => {
+ if (aEvent.keyCode != aEvent.DOM_VK_ESCAPE) {
+ return;
+ }
+
+ // Esc key cancels the topmost notification, if there is one.
+ let notification = this.panel.firstElementChild;
+ if (!notification) {
+ return;
+ }
+
+ let doc = this.window.document;
+ let focusedElement = Services.focus.focusedElement;
+
+ // If the chrome window has a focused element, let it handle the ESC key instead.
+ if (
+ !focusedElement ||
+ focusedElement == doc.body ||
+ focusedElement == this.tabbrowser.selectedBrowser ||
+ // Ignore focused elements inside the notification.
+ notification.contains(focusedElement)
+ ) {
+ let escAction = notification.notification.options.escAction;
+ this._onButtonEvent(aEvent, escAction, "esc-press", notification);
+ // Without this preventDefault call, the event will be sent to the content page
+ // and our event listener might be called again after receiving a reply from
+ // the content process, which could accidentally dismiss another notification.
+ aEvent.preventDefault();
+ }
+ };
+
+ let documentElement = this.window.document.documentElement;
+ let locationBarHidden = documentElement
+ .getAttribute("chromehidden")
+ .includes("location");
+ let isFullscreen = !!this.window.document.fullscreenElement;
+
+ this.panel.setAttribute("followanchor", !locationBarHidden && !isFullscreen);
+
+ // There are no anchor icons in DOM fullscreen mode, but we would
+ // still like to show the popup notification. To avoid an infinite
+ // loop of showing and hiding, we have to disable followanchor
+ // (which hides the element without an anchor) in fullscreen.
+ this.window.addEventListener(
+ "MozDOMFullscreen:Entered",
+ () => {
+ this.panel.setAttribute("followanchor", "false");
+ },
+ true
+ );
+ this.window.addEventListener(
+ "MozDOMFullscreen:Exited",
+ () => {
+ this.panel.setAttribute("followanchor", !locationBarHidden);
+ },
+ true
+ );
+
+ Services.obs.addObserver(this, "fullscreen-transition-start");
+
+ this.window.addEventListener("unload", () => {
+ Services.obs.removeObserver(this, "fullscreen-transition-start");
+ });
+
+ this.window.addEventListener("activate", this, true);
+ if (this.tabbrowser.tabContainer) {
+ this.tabbrowser.tabContainer.addEventListener("TabSelect", this, true);
+
+ this.tabbrowser.tabContainer.addEventListener("TabClose", aEvent => {
+ // If the tab was just closed and we have notifications associated with it,
+ // then the notifications were closed because of the tab removal. We need to
+ // record this event in telemetry and fire the removal callback.
+ this.nextRemovalReason = TELEMETRY_STAT_REMOVAL_LEAVE_PAGE;
+ let notifications = this._getNotificationsForBrowser(
+ aEvent.target.linkedBrowser
+ );
+ for (let notification of notifications) {
+ this._fireCallback(
+ notification,
+ NOTIFICATION_EVENT_REMOVED,
+ this.nextRemovalReason
+ );
+ notification._recordTelemetryStat(this.nextRemovalReason);
+ }
+ });
+ }
+}
+
+PopupNotifications.prototype = {
+ window: null,
+ panel: null,
+ tabbrowser: null,
+
+ _iconBox: null,
+ set iconBox(iconBox) {
+ // Remove the listeners on the old iconBox, if needed
+ if (this._iconBox) {
+ this._iconBox.removeEventListener("click", this);
+ this._iconBox.removeEventListener("keypress", this);
+ }
+ this._iconBox = iconBox;
+ if (iconBox) {
+ iconBox.addEventListener("click", this);
+ iconBox.addEventListener("keypress", this);
+ }
+ },
+ get iconBox() {
+ return this._iconBox;
+ },
+
+ observe(subject, topic) {
+ if (topic == "fullscreen-transition-start") {
+ // Extend security delay if the panel is open.
+ if (this.isPanelOpen) {
+ let notification = this.panel.firstChild?.notification;
+ if (notification) {
+ this._extendSecurityDelay([notification]);
+ }
+ }
+ }
+ },
+
+ /**
+ * Retrieve one or many Notification object/s associated with the browser/ID pair.
+ * @param {string|string[]} id
+ * The Notification ID or an array of IDs to search for.
+ * @param [browser]
+ * The browser whose notifications should be searched. If null, the
+ * currently selected browser's notifications will be searched.
+ *
+ * @returns {Notification|Notification[]|null} If passed a single id, returns the corresponding Notification object, or null if no such
+ * notification exists.
+ * If passed an id array, returns an array of Notification objects which match the ids.
+ */
+ getNotification: function PopupNotifications_getNotification(id, browser) {
+ let notifications = this._getNotificationsForBrowser(
+ browser || this.tabbrowser.selectedBrowser
+ );
+ if (Array.isArray(id)) {
+ return notifications.filter(x => id.includes(x.id));
+ }
+ return notifications.find(x => x.id == id) || null;
+ },
+
+ /**
+ * Adds a new popup notification.
+ * @param browser
+ * The <xul:browser> element associated with the notification. Must not
+ * be null.
+ * @param id
+ * A unique ID that identifies the type of notification (e.g.
+ * "geolocation"). Only one notification with a given ID can be visible
+ * at a time. If a notification already exists with the given ID, it
+ * will be replaced.
+ * @param message
+ * A string containing the text to be displayed as the notification
+ * header. The string may optionally contain one or two "<>" as a
+ * placeholder which is later replaced by a host name or an addon name
+ * that is formatted to look bold, in which case the options.name
+ * property (as well as options.secondName if passing a "<>" and a "{}"
+ * placeholder) needs to be specified. "<>" will be considered as the
+ * first and "{}" as the second placeholder.
+ * @param anchorID
+ * The ID of the element that should be used as this notification
+ * popup's anchor. May be null, in which case the notification will be
+ * anchored to the iconBox.
+ * @param mainAction
+ * A JavaScript object literal describing the notification button's
+ * action. If present, it must have the following properties:
+ * - label (string): the button's label.
+ * - accessKey (string): the button's accessKey.
+ * - callback (function): a callback to be invoked when the button is
+ * pressed, is passed an object that contains the following fields:
+ * - checkboxChecked: (boolean) If the optional checkbox is checked.
+ * - source: (string): the source of the action that initiated the
+ * callback, either:
+ * - "button" if popup buttons were directly activated, or
+ * - "esc-press" if the user pressed the escape key, or
+ * - "menucommand" if a menu was activated.
+ * - [optional] dismiss (boolean): If this is true, the notification
+ * will be dismissed instead of removed after running the callback.
+ * - [optional] disabled (boolean): If this is true, the button
+ * will be disabled.
+ * If null, the notification will have a default "OK" action button
+ * that can be used to dismiss the popup and secondaryActions will be ignored.
+ * @param secondaryActions
+ * An optional JavaScript array describing the notification's alternate
+ * actions. The array should contain objects with the same properties
+ * as mainAction. These are used to populate the notification button's
+ * dropdown menu.
+ * @param options
+ * An options JavaScript object holding additional properties for the
+ * notification. The following properties are currently supported:
+ * persistence: An integer. The notification will not automatically
+ * dismiss for this many page loads.
+ * timeout: A time in milliseconds. The notification will not
+ * automatically dismiss before this time.
+ * persistWhileVisible:
+ * A boolean. If true, a visible notification will always
+ * persist across location changes.
+ * persistent: A boolean. If true, the notification will always
+ * persist even across tab and app changes (but not across
+ * location changes), until the user accepts or rejects
+ * the request. The notification will never be implicitly
+ * dismissed.
+ * dismissed: Whether the notification should be added as a dismissed
+ * notification. Dismissed notifications can be activated
+ * by clicking on their anchorElement.
+ * autofocus: Whether the notification should be autofocused on
+ * showing, stealing focus from any other focused element.
+ * eventCallback:
+ * Callback to be invoked when the notification changes
+ * state. The callback's first argument is a string
+ * identifying the state change:
+ * "dismissed": notification has been dismissed by the
+ * user (e.g. by clicking away or switching
+ * tabs)
+ * "removed": notification has been removed (due to
+ * location change or user action)
+ * "showing": notification is about to be shown
+ * (this can be fired multiple times as
+ * notifications are dismissed and re-shown)
+ * If the callback returns true, the notification
+ * will be dismissed.
+ * "shown": notification has been shown (this can be fired
+ * multiple times as notifications are dismissed
+ * and re-shown)
+ * "swapping": the docshell of the browser that created
+ * the notification is about to be swapped to
+ * another browser. A second parameter contains
+ * the browser that is receiving the docshell,
+ * so that the event callback can transfer stuff
+ * specific to this notification.
+ * If the callback returns true, the notification
+ * will be moved to the new browser.
+ * If the callback isn't implemented, returns false,
+ * or doesn't return any value, the notification
+ * will be removed.
+ * neverShow: Indicate that no popup should be shown for this
+ * notification. Useful for just showing the anchor icon.
+ * removeOnDismissal:
+ * Notifications with this parameter set to true will be
+ * removed when they would have otherwise been dismissed
+ * (i.e. any time the popup is closed due to user
+ * interaction).
+ * hideClose: Indicate that the little close button in the corner of
+ * the panel should be hidden.
+ * checkbox: An object that allows you to add a checkbox and
+ * control its behavior with these fields:
+ * label:
+ * (required) Label to be shown next to the checkbox.
+ * checked:
+ * (optional) Whether the checkbox should be checked
+ * by default. Defaults to false.
+ * checkedState:
+ * (optional) An object that allows you to customize
+ * the notification state when the checkbox is checked.
+ * disableMainAction:
+ * (optional) Whether the mainAction is disabled.
+ * Defaults to false.
+ * warningLabel:
+ * (optional) A (warning) text that is shown below the
+ * checkbox. Pass null to hide.
+ * uncheckedState:
+ * (optional) An object that allows you to customize
+ * the notification state when the checkbox is not checked.
+ * Has the same attributes as checkedState.
+ * popupIconClass:
+ * A string. A class (or space separated list of classes)
+ * that will be applied to the icon in the popup so that
+ * several notifications using the same panel can use
+ * different icons.
+ * popupIconURL:
+ * A string. URL of the image to be displayed in the popup.
+ * learnMoreURL:
+ * A string URL. Setting this property will make the
+ * prompt display a "Learn More" link that, when clicked,
+ * opens the URL in a new tab.
+ * displayURI:
+ * The nsIURI of the page the notification came
+ * from. If present, this will be displayed above the message.
+ * If the nsIURI represents a file, the path will be displayed,
+ * otherwise the hostPort will be displayed.
+ * name:
+ * An optional string formatted to look bold and used in the
+ * notifiation description header text. Usually a host name or
+ * addon name.
+ * secondName:
+ * An optional string formatted to look bold and used in the
+ * notification description header text. Usually a host name or
+ * addon name. This is similar to name, and only used in case
+ * where message contains a "<>" and a "{}" placeholder. "<>"
+ * is considered the first and "{}" is considered the second
+ * placeholder.
+ * escAction:
+ * An optional string indicating the action to take when the
+ * Esc key is pressed. This should be set to the name of the
+ * command to run. If not provided, "secondarybuttoncommand"
+ * will be used.
+ * extraAttr:
+ * An optional string value which will be given to the
+ * extraAttr attribute on the notification's anchorElement
+ * popupOptions:
+ * An optional object containing popup options passed to
+ * `openPopup()` when defined.
+ * recordTelemetryInPrivateBrowsing:
+ * An optional boolean indicating whether popup telemetry
+ * should be recorded in private browsing windows. By default,
+ * telemetry is NOT recorded in PBM, because the available
+ * options for persistent permission notifications are
+ * different between normal and PBM windows, potentially
+ * skewing the data. But for notifications that do not differ
+ * in PBM, this option can be used to ensure that popups in
+ * both PBM and normal windows record the same interactions.
+ * @returns the Notification object corresponding to the added notification.
+ */
+ show: function PopupNotifications_show(
+ browser,
+ id,
+ message,
+ anchorID,
+ mainAction,
+ secondaryActions,
+ options
+ ) {
+ function isInvalidAction(a) {
+ return (
+ !a || !(typeof a.callback == "function") || !a.label || !a.accessKey
+ );
+ }
+
+ if (!browser) {
+ throw new Error("PopupNotifications_show: invalid browser");
+ }
+ if (!id) {
+ throw new Error("PopupNotifications_show: invalid ID");
+ }
+ if (mainAction && isInvalidAction(mainAction)) {
+ throw new Error("PopupNotifications_show: invalid mainAction");
+ }
+ if (secondaryActions && secondaryActions.some(isInvalidAction)) {
+ throw new Error("PopupNotifications_show: invalid secondaryActions");
+ }
+
+ let notification = new Notification(
+ id,
+ message,
+ anchorID,
+ mainAction,
+ secondaryActions,
+ browser,
+ this,
+ options
+ );
+
+ if (options) {
+ let escAction = options.escAction;
+ if (
+ escAction != "buttoncommand" &&
+ escAction != "secondarybuttoncommand"
+ ) {
+ escAction = "secondarybuttoncommand";
+ }
+ notification.options.escAction = escAction;
+ }
+
+ if (options && options.dismissed) {
+ notification.dismissed = true;
+ }
+
+ let existingNotification = this.getNotification(id, browser);
+ if (existingNotification) {
+ this._remove(existingNotification);
+ }
+
+ let notifications = this._getNotificationsForBrowser(browser);
+ notifications.push(notification);
+
+ let isActiveBrowser = this._isActiveBrowser(browser);
+ let isActiveWindow = Services.focus.activeWindow == this.window;
+
+ if (isActiveBrowser) {
+ if (isActiveWindow) {
+ // Autofocus if the notification requests focus.
+ if (options && !options.dismissed && options.autofocus) {
+ this.panel.removeAttribute("noautofocus");
+ } else {
+ this.panel.setAttribute("noautofocus", "true");
+ }
+
+ // show panel now
+ this._update(
+ notifications,
+ new Set([notification.anchorElement]),
+ true
+ );
+ } else {
+ // indicate attention and update the icon if necessary
+ if (!notification.dismissed) {
+ this.window.getAttention();
+ }
+ this._updateAnchorIcons(
+ notifications,
+ this._getAnchorsForNotifications(
+ notifications,
+ notification.anchorElement
+ )
+ );
+ this._notify("backgroundShow");
+ }
+ } else {
+ // Notify observers that we're not showing the popup (useful for testing)
+ this._notify("backgroundShow");
+ }
+
+ return notification;
+ },
+
+ /**
+ * Returns true if the notification popup is currently being displayed.
+ */
+ get isPanelOpen() {
+ let panelState = this.panel.state;
+
+ return panelState == "showing" || panelState == "open";
+ },
+
+ /**
+ * Called by the consumer to indicate that the open panel should
+ * temporarily be hidden while the given panel is showing.
+ */
+ suppressWhileOpen(panel) {
+ this._hidePanel().catch(console.error);
+ panel.addEventListener("popuphidden", aEvent => {
+ this._update();
+ });
+ },
+
+ /**
+ * Called by the consumer to indicate that a browser's location has changed,
+ * so that we can update the active notifications accordingly.
+ */
+ locationChange: function PopupNotifications_locationChange(aBrowser) {
+ if (!aBrowser) {
+ throw new Error("PopupNotifications_locationChange: invalid browser");
+ }
+
+ let notifications = this._getNotificationsForBrowser(aBrowser);
+
+ this.nextRemovalReason = TELEMETRY_STAT_REMOVAL_LEAVE_PAGE;
+
+ notifications = notifications.filter(function (notification) {
+ // The persistWhileVisible option allows an open notification to persist
+ // across location changes
+ if (notification.options.persistWhileVisible && this.isPanelOpen) {
+ if (
+ "persistence" in notification.options &&
+ notification.options.persistence
+ ) {
+ notification.options.persistence--;
+ }
+ return true;
+ }
+
+ // The persistence option allows a notification to persist across multiple
+ // page loads
+ if (
+ "persistence" in notification.options &&
+ notification.options.persistence
+ ) {
+ notification.options.persistence--;
+ return true;
+ }
+
+ // The timeout option allows a notification to persist until a certain time
+ if (
+ "timeout" in notification.options &&
+ Date.now() <= notification.options.timeout
+ ) {
+ return true;
+ }
+
+ notification._recordTelemetryStat(this.nextRemovalReason);
+ this._fireCallback(
+ notification,
+ NOTIFICATION_EVENT_REMOVED,
+ this.nextRemovalReason
+ );
+ return false;
+ }, this);
+
+ this._setNotificationsForBrowser(aBrowser, notifications);
+
+ if (this._isActiveBrowser(aBrowser)) {
+ this.anchorVisibilityChange();
+ }
+ },
+
+ /**
+ * Called by the consumer to indicate that the visibility of the notification
+ * anchors may have changed, but the location has not changed. This also
+ * checks whether all notifications are suppressed for this window.
+ *
+ * Calling this method may result in the "showing" and "shown" events for
+ * visible notifications to be invoked even if the anchor has not changed.
+ */
+ anchorVisibilityChange() {
+ let suppress = this._shouldSuppress();
+ if (!suppress) {
+ // If notifications are not suppressed, always update the visibility.
+ this._suppress = false;
+ let notifications = this._getNotificationsForBrowser(
+ this.tabbrowser.selectedBrowser
+ );
+ this._update(
+ notifications,
+ this._getAnchorsForNotifications(
+ notifications,
+ getAnchorFromBrowser(this.tabbrowser.selectedBrowser)
+ )
+ );
+ return;
+ }
+
+ // Notifications are suppressed, ensure that the panel is hidden.
+ if (!this._suppress) {
+ this._suppress = true;
+ this._hidePanel().catch(console.error);
+ }
+ },
+
+ /**
+ * Removes one or many Notifications.
+ * @param {Notification|Notification[]} notification - The Notification object/s to remove.
+ * @param {Boolean} [isCancel] - Whether to signal, in the notification event, that removal
+ * should be treated as cancel. This is currently used to cancel permission requests
+ * when their Notifications are removed.
+ */
+ remove: function PopupNotifications_remove(notification, isCancel = false) {
+ let notificationArray = Array.isArray(notification)
+ ? notification
+ : [notification];
+ let activeBrowser;
+
+ notificationArray.forEach(n => {
+ this._remove(n, isCancel);
+ if (!activeBrowser && this._isActiveBrowser(n.browser)) {
+ activeBrowser = n.browser;
+ }
+ });
+
+ if (activeBrowser) {
+ let browserNotifications =
+ this._getNotificationsForBrowser(activeBrowser);
+ this._update(browserNotifications);
+ }
+ },
+
+ handleEvent(aEvent) {
+ switch (aEvent.type) {
+ case "popuphidden":
+ this._onPopupHidden(aEvent);
+ break;
+ case "activate":
+ case "popuppositioned":
+ if (this.isPanelOpen) {
+ for (let elt of this.panel.children) {
+ elt.notification.timeShown = Math.max(
+ this.window.performance.now(),
+ elt.notification.timeShown ?? 0
+ );
+ }
+ break;
+ }
+ // fall through
+ case "TabSelect":
+ // setTimeout(..., 0) needed, otherwise openPopup from "activate" event
+ // handler results in the popup being hidden again for some reason...
+ this.window.setTimeout(() => {
+ this._suppress = this._shouldSuppress();
+ this._update();
+ }, 0);
+ break;
+ case "click":
+ case "keypress":
+ this._onIconBoxCommand(aEvent);
+ break;
+ }
+ },
+
+ // Utility methods
+
+ _ignoreDismissal: null,
+ _currentAnchorElement: null,
+
+ /**
+ * Gets notifications for the currently selected browser.
+ */
+ get _currentNotifications() {
+ return this.tabbrowser.selectedBrowser
+ ? this._getNotificationsForBrowser(this.tabbrowser.selectedBrowser)
+ : [];
+ },
+
+ _remove: function PopupNotifications_removeHelper(
+ notification,
+ isCancel = false
+ ) {
+ // This notification may already be removed, in which case let's just fail
+ // silently.
+ let notifications = this._getNotificationsForBrowser(notification.browser);
+ if (!notifications) {
+ return;
+ }
+
+ var index = notifications.indexOf(notification);
+ if (index == -1) {
+ return;
+ }
+
+ if (this._isActiveBrowser(notification.browser)) {
+ notification.anchorElement.removeAttribute(ICON_ATTRIBUTE_SHOWING);
+ }
+
+ // remove the notification
+ notifications.splice(index, 1);
+ this._fireCallback(
+ notification,
+ NOTIFICATION_EVENT_REMOVED,
+ this.nextRemovalReason,
+ isCancel
+ );
+ },
+
+ /**
+ * Dismisses the notification without removing it.
+ *
+ * @param {Event} the event associated with the user interaction that
+ * caused the dismissal
+ * @param {boolean} whether to disable persistent status. Normally,
+ * persistent prompts can not be dismissed. You can
+ * use this argument to force dismissal.
+ */
+ _dismiss: function PopupNotifications_dismiss(
+ event,
+ disablePersistent = false
+ ) {
+ if (disablePersistent) {
+ let notificationEl = getNotificationFromElement(event.target);
+ if (notificationEl) {
+ notificationEl.notification.options.persistent = false;
+ }
+ }
+
+ let browser =
+ this.panel.firstElementChild &&
+ this.panel.firstElementChild.notification.browser;
+ this.panel.hidePopup();
+ if (browser) {
+ browser.focus();
+ }
+ },
+
+ /**
+ * Hides the notification popup.
+ */
+ _hidePanel: function PopupNotifications_hide() {
+ if (this.panel.state == "closed") {
+ return Promise.resolve();
+ }
+ if (this._ignoreDismissal) {
+ return this._ignoreDismissal.promise;
+ }
+ let deferred = PromiseUtils.defer();
+ this._ignoreDismissal = deferred;
+ this.panel.hidePopup();
+ return deferred.promise;
+ },
+
+ /**
+ * Removes all notifications from the notification popup.
+ */
+ _clearPanel() {
+ let popupnotification;
+ while ((popupnotification = this.panel.lastElementChild)) {
+ this.panel.removeChild(popupnotification);
+
+ // If this notification was provided by the chrome document rather than
+ // created ad hoc, move it back to where we got it from.
+ let originalParent = gNotificationParents.get(popupnotification);
+ if (originalParent) {
+ popupnotification.notification = null;
+
+ // Re-hide the notification such that it isn't rendered in the chrome
+ // document. _refreshPanel will unhide it again when needed.
+ popupnotification.hidden = true;
+
+ originalParent.appendChild(popupnotification);
+ }
+ }
+ },
+
+ /**
+ * Formats the notification description message before we display it
+ * and splits it into three parts if the message contains "<>" as
+ * placeholder.
+ *
+ * param notification
+ * The Notification object which contains the message to format.
+ *
+ * @returns a Javascript object that has the following properties:
+ * start: A start label string containing the first part of the message.
+ * It may contain the whole string if the description message
+ * does not have "<>" as a placeholder. For example, local
+ * file URIs with description messages that don't display hostnames.
+ * name: A string that is formatted to look bold. It replaces the
+ * placeholder with the options.name property from the notification
+ * object which is usually an addon name or a host name.
+ * end: The last part of the description message.
+ */
+ _formatDescriptionMessage(n) {
+ let text = {};
+ let array = n.message.split(/<>|{}/);
+ text.start = array[0] || "";
+ text.name = n.options.name || "";
+ text.end = array[1] || "";
+ if (array.length == 3) {
+ text.secondName = n.options.secondName || "";
+ text.secondEnd = array[2] || "";
+
+ // name and secondName should be in logical positions. Swap them in case
+ // the second placeholder came before the first one in the original string.
+ if (n.message.indexOf("{}") < n.message.indexOf("<>")) {
+ let tmp = text.name;
+ text.name = text.secondName;
+ text.secondName = tmp;
+ }
+ } else if (array.length > 3) {
+ console.error(
+ "Unexpected array length encountered in " +
+ "_formatDescriptionMessage: ",
+ array.length
+ );
+ }
+ return text;
+ },
+
+ _refreshPanel: function PopupNotifications_refreshPanel(notificationsToShow) {
+ this._clearPanel();
+
+ notificationsToShow.forEach(function (n) {
+ let doc = this.window.document;
+
+ // Append "-notification" to the ID to try to avoid ID conflicts with other stuff
+ // in the document.
+ let popupnotificationID = n.id + "-notification";
+
+ // If the chrome document provides a popupnotification with this id, use
+ // that. Otherwise create it ad-hoc.
+ let popupnotification = doc.getElementById(popupnotificationID);
+ if (popupnotification) {
+ gNotificationParents.set(
+ popupnotification,
+ popupnotification.parentNode
+ );
+ } else {
+ popupnotification = doc.createXULElement("popupnotification");
+ }
+
+ // Create the notification description element.
+ let desc = this._formatDescriptionMessage(n);
+ popupnotification.setAttribute("label", desc.start);
+ popupnotification.setAttribute("name", desc.name);
+ popupnotification.setAttribute("endlabel", desc.end);
+ if ("secondName" in desc && "secondEnd" in desc) {
+ popupnotification.setAttribute("secondname", desc.secondName);
+ popupnotification.setAttribute("secondendlabel", desc.secondEnd);
+ } else {
+ popupnotification.removeAttribute("secondname");
+ popupnotification.removeAttribute("secondendlabel");
+ }
+
+ if (n.options.hintText) {
+ popupnotification.setAttribute("hinttext", n.options.hintText);
+ } else {
+ popupnotification.removeAttribute("hinttext");
+ }
+
+ popupnotification.setAttribute("id", popupnotificationID);
+ popupnotification.setAttribute("popupid", n.id);
+ popupnotification.setAttribute(
+ "oncommand",
+ "PopupNotifications._onCommand(event);"
+ );
+ popupnotification.setAttribute(
+ "closebuttoncommand",
+ `PopupNotifications._dismiss(event, true);`
+ );
+
+ popupnotification.toggleAttribute(
+ "hasicon",
+ !!(n.options.popupIconURL || n.options.popupIconClass)
+ );
+
+ if (n.mainAction) {
+ popupnotification.setAttribute("buttonlabel", n.mainAction.label);
+ popupnotification.setAttribute(
+ "buttonaccesskey",
+ n.mainAction.accessKey
+ );
+ popupnotification.setAttribute(
+ "buttoncommand",
+ "PopupNotifications._onButtonEvent(event, 'buttoncommand');"
+ );
+ popupnotification.setAttribute(
+ "dropmarkerpopupshown",
+ "PopupNotifications._onButtonEvent(event, 'dropmarkerpopupshown');"
+ );
+ popupnotification.setAttribute(
+ "learnmoreclick",
+ "PopupNotifications._onButtonEvent(event, 'learnmoreclick');"
+ );
+ popupnotification.setAttribute(
+ "menucommand",
+ "PopupNotifications._onMenuCommand(event);"
+ );
+ } else {
+ // Enable the default button to let the user close the popup if the close button is hidden
+ popupnotification.setAttribute(
+ "buttoncommand",
+ "PopupNotifications._onButtonEvent(event, 'buttoncommand');"
+ );
+ popupnotification.toggleAttribute("buttonhighlight", true);
+ popupnotification.removeAttribute("buttonlabel");
+ popupnotification.removeAttribute("buttonaccesskey");
+ popupnotification.removeAttribute("dropmarkerpopupshown");
+ popupnotification.removeAttribute("learnmoreclick");
+ popupnotification.removeAttribute("menucommand");
+ }
+
+ let classes = "popup-notification-icon";
+ if (n.options.popupIconClass) {
+ classes += " " + n.options.popupIconClass;
+ }
+ popupnotification.setAttribute("iconclass", classes);
+
+ if (n.options.popupIconURL) {
+ popupnotification.setAttribute("icon", n.options.popupIconURL);
+ } else {
+ popupnotification.removeAttribute("icon");
+ }
+
+ if (n.options.learnMoreURL) {
+ popupnotification.setAttribute("learnmoreurl", n.options.learnMoreURL);
+ } else {
+ popupnotification.removeAttribute("learnmoreurl");
+ }
+
+ if (n.options.displayURI) {
+ let uri;
+ try {
+ if (n.options.displayURI instanceof Ci.nsIFileURL) {
+ uri = n.options.displayURI.pathQueryRef;
+ } else {
+ try {
+ uri = n.options.displayURI.hostPort;
+ } catch (e) {
+ uri = n.options.displayURI.spec;
+ }
+ }
+ popupnotification.setAttribute("origin", uri);
+ } catch (e) {
+ console.error(e);
+ popupnotification.removeAttribute("origin");
+ }
+ } else {
+ popupnotification.removeAttribute("origin");
+ }
+
+ if (n.options.hideClose) {
+ popupnotification.setAttribute("closebuttonhidden", "true");
+ }
+
+ popupnotification.notification = n;
+ let menuitems = [];
+
+ if (n.mainAction && n.secondaryActions && n.secondaryActions.length) {
+ let telemetryStatId = TELEMETRY_STAT_ACTION_2;
+
+ let secondaryAction = n.secondaryActions[0];
+ popupnotification.setAttribute(
+ "secondarybuttonlabel",
+ secondaryAction.label
+ );
+ popupnotification.setAttribute(
+ "secondarybuttonaccesskey",
+ secondaryAction.accessKey
+ );
+ popupnotification.setAttribute(
+ "secondarybuttoncommand",
+ "PopupNotifications._onButtonEvent(event, 'secondarybuttoncommand');"
+ );
+
+ for (let i = 1; i < n.secondaryActions.length; i++) {
+ let action = n.secondaryActions[i];
+ let item = doc.createXULElement("menuitem");
+ item.setAttribute("label", action.label);
+ item.setAttribute("accesskey", action.accessKey);
+ item.notification = n;
+ item.action = action;
+
+ menuitems.push(item);
+
+ // We can only record a limited number of actions in telemetry. If
+ // there are more, the latest are all recorded in the last bucket.
+ item.action.telemetryStatId = telemetryStatId;
+ if (telemetryStatId < TELEMETRY_STAT_ACTION_LAST) {
+ telemetryStatId++;
+ }
+ }
+ popupnotification.setAttribute("secondarybuttonhidden", "false");
+ } else {
+ popupnotification.setAttribute("secondarybuttonhidden", "true");
+ }
+ popupnotification.setAttribute(
+ "dropmarkerhidden",
+ n.secondaryActions.length < 2 ? "true" : "false"
+ );
+
+ let checkbox = n.options.checkbox;
+ if (checkbox && checkbox.label) {
+ let checked =
+ n._checkboxChecked != null ? n._checkboxChecked : !!checkbox.checked;
+ popupnotification.checkboxState = {
+ checked,
+ label: checkbox.label,
+ };
+
+ if (checked) {
+ this._setNotificationUIState(
+ popupnotification,
+ checkbox.checkedState
+ );
+ } else {
+ this._setNotificationUIState(
+ popupnotification,
+ checkbox.uncheckedState
+ );
+ }
+ } else {
+ popupnotification.checkboxState = null;
+ // Reset the UI state to avoid previous state bleeding into this prompt.
+ this._setNotificationUIState(popupnotification);
+ }
+
+ this.panel.appendChild(popupnotification);
+
+ // The popupnotification may be hidden if we got it from the chrome
+ // document rather than creating it ad hoc.
+ popupnotification.show();
+
+ popupnotification.menupopup.textContent = "";
+ popupnotification.menupopup.append(...menuitems);
+ }, this);
+ },
+
+ _setNotificationUIState(notification, state = {}) {
+ let mainAction = notification.notification.mainAction;
+ if (
+ (mainAction && mainAction.disabled) ||
+ state.disableMainAction ||
+ notification.hasAttribute("invalidselection")
+ ) {
+ notification.setAttribute("mainactiondisabled", "true");
+ } else {
+ notification.removeAttribute("mainactiondisabled");
+ }
+ if (state.warningLabel) {
+ notification.setAttribute("warninglabel", state.warningLabel);
+ notification.removeAttribute("warninghidden");
+ } else {
+ notification.setAttribute("warninghidden", "true");
+ }
+ },
+
+ _extendSecurityDelay(notifications) {
+ let now = this.window.performance.now();
+ notifications.forEach(n => {
+ n.timeShown = now + FULLSCREEN_TRANSITION_TIME_SHOWN_OFFSET_MS;
+ });
+ },
+
+ _showPanel: function PopupNotifications_showPanel(
+ notificationsToShow,
+ anchorElement
+ ) {
+ this.panel.hidden = false;
+
+ notificationsToShow = notificationsToShow.filter(n => {
+ if (anchorElement != n.anchorElement) {
+ return false;
+ }
+
+ let dismiss = this._fireCallback(n, NOTIFICATION_EVENT_SHOWING);
+ if (dismiss) {
+ n.dismissed = true;
+ }
+ return !dismiss;
+ });
+ if (!notificationsToShow.length) {
+ return;
+ }
+
+ let notificationIds = notificationsToShow.map(n => n.id);
+
+ this._refreshPanel(notificationsToShow);
+
+ // The element the PopupNotification should anchor to might not be visible.
+ // Check its visibility using a callback that returns the same anchor
+ // element if its visible, or a fallback option that is visible.
+ // If no fallbacks are visible, it should return null.
+ if (this._getVisibleAnchorElement) {
+ anchorElement = this._getVisibleAnchorElement(anchorElement);
+ }
+ // In case _getVisibleAnchorElement provided a non-visible element.
+ if (!anchorElement?.checkVisibility()) {
+ // We only ever show notifications for the current browser,
+ // so we can just use the current tab.
+ anchorElement = this.tabbrowser.selectedTab;
+ if (!anchorElement?.checkVisibility()) {
+ // If we're in an entirely chromeless environment, set the anchorElement
+ // to null and let openPopup show the notification at (0,0) later.
+ anchorElement = null;
+ }
+ }
+
+ // Remember the time the notification was shown for the security delay.
+ notificationsToShow.forEach(
+ n =>
+ (n.timeShown = Math.max(
+ this.window.performance.now(),
+ n.timeShown ?? 0
+ ))
+ );
+
+ if (this.isPanelOpen && this._currentAnchorElement == anchorElement) {
+ notificationsToShow.forEach(function (n) {
+ this._fireCallback(n, NOTIFICATION_EVENT_SHOWN);
+ }, this);
+
+ // Make sure we update the noautohide attribute on the panel, in case it changed.
+ if (notificationsToShow.some(n => n.options.persistent)) {
+ this.panel.setAttribute("noautohide", "true");
+ } else {
+ this.panel.removeAttribute("noautohide");
+ }
+
+ // Let tests know that the panel was updated and what notifications it was
+ // updated with so that tests can wait for the correct notifications to be
+ // added.
+ let event = new this.window.CustomEvent("PanelUpdated", {
+ detail: notificationIds,
+ });
+ this.panel.dispatchEvent(event);
+ return;
+ }
+
+ // If the panel is already open but we're changing anchors, we need to hide
+ // it first. Otherwise it can appear in the wrong spot. (_hidePanel is
+ // safe to call even if the panel is already hidden.)
+ this._hidePanel().then(() => {
+ this._currentAnchorElement = anchorElement;
+
+ if (notificationsToShow.some(n => n.options.persistent)) {
+ this.panel.setAttribute("noautohide", "true");
+ } else {
+ this.panel.removeAttribute("noautohide");
+ }
+
+ notificationsToShow.forEach(function (n) {
+ // Record that the notification was actually displayed on screen.
+ // Notifications that were opened a second time or that were originally
+ // shown with "options.dismissed" will be recorded in a separate bucket.
+ n._recordTelemetryStat(TELEMETRY_STAT_OFFERED);
+ }, this);
+
+ // We're about to open the panel while in a full screen transition. Extend
+ // the security delay.
+ if (this.window.isInFullScreenTransition) {
+ this._extendSecurityDelay(notificationsToShow);
+ }
+
+ let target = this.panel;
+ if (target.parentNode) {
+ // NOTIFICATION_EVENT_SHOWN should be fired for the panel before
+ // anyone listening for popupshown on the panel gets run. Otherwise,
+ // the panel will not be initialized when the popupshown event
+ // listeners run.
+ // 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;
+ }
+ if (this._popupshownListener) {
+ target.removeEventListener(
+ "popupshown",
+ this._popupshownListener,
+ true
+ );
+ }
+ this._popupshownListener = function (e) {
+ target.removeEventListener(
+ "popupshown",
+ this._popupshownListener,
+ true
+ );
+ this._popupshownListener = null;
+
+ notificationsToShow.forEach(function (n) {
+ this._fireCallback(n, NOTIFICATION_EVENT_SHOWN);
+ }, this);
+ // These notifications are used by tests to know when all the processing
+ // required to display the panel has happened.
+ this.panel.dispatchEvent(new this.window.CustomEvent("Shown"));
+ let event = new this.window.CustomEvent("PanelUpdated", {
+ detail: notificationIds,
+ });
+ this.panel.dispatchEvent(event);
+ };
+ this._popupshownListener = this._popupshownListener.bind(this);
+ target.addEventListener("popupshown", this._popupshownListener, true);
+
+ let popupOptions = notificationsToShow.findLast(
+ n => n.options?.popupOptions
+ )?.options?.popupOptions;
+ if (popupOptions) {
+ this.panel.openPopup(anchorElement, popupOptions);
+ } else {
+ this.panel.openPopup(anchorElement, "bottomleft topleft", 0, 0);
+ }
+ });
+ },
+
+ /**
+ * Updates the notification state in response to window activation or tab
+ * selection changes.
+ *
+ * @param notifications an array of Notification instances. if null,
+ * notifications will be retrieved off the current
+ * browser tab
+ * @param anchors is a XUL element or a Set of XUL elements that the
+ * notifications panel(s) will be anchored to.
+ * @param dismissShowing if true, dismiss any currently visible notifications
+ * if there are no notifications to show. Otherwise,
+ * currently displayed notifications will be left alone.
+ */
+ _update: function PopupNotifications_update(
+ notifications,
+ anchors = new Set(),
+ dismissShowing = false
+ ) {
+ if (ChromeUtils.getClassName(anchors) == "XULElement") {
+ anchors = new Set([anchors]);
+ }
+
+ if (!notifications) {
+ notifications = this._currentNotifications;
+ }
+
+ let haveNotifications = !!notifications.length;
+ if (!anchors.size && haveNotifications) {
+ anchors = this._getAnchorsForNotifications(notifications);
+ }
+
+ let useIconBox = !!this.iconBox;
+ if (useIconBox && anchors.size) {
+ for (let anchor of anchors) {
+ if (anchor.parentNode == this.iconBox) {
+ continue;
+ }
+ useIconBox = false;
+ break;
+ }
+ }
+
+ // Filter out notifications that have been dismissed, unless they are
+ // persistent. Also check if we should not show any notification.
+ let notificationsToShow = [];
+ if (!this._suppress) {
+ notificationsToShow = notifications.filter(
+ n => (!n.dismissed || n.options.persistent) && !n.options.neverShow
+ );
+ }
+
+ if (useIconBox) {
+ // Hide icons of the previous tab.
+ this._hideIcons();
+ }
+
+ if (haveNotifications) {
+ // Also filter out notifications that are for a different anchor.
+ notificationsToShow = notificationsToShow.filter(function (n) {
+ return anchors.has(n.anchorElement);
+ });
+
+ if (useIconBox) {
+ this._showIcons(notifications);
+ this.iconBox.hidden = false;
+ // Make sure that panels can only be attached to anchors of shown
+ // notifications inside an iconBox.
+ anchors = this._getAnchorsForNotifications(notificationsToShow);
+ } else if (anchors.size) {
+ this._updateAnchorIcons(notifications, anchors);
+ }
+ }
+
+ if (notificationsToShow.length) {
+ let anchorElement = anchors.values().next().value;
+ if (anchorElement) {
+ this._showPanel(notificationsToShow, anchorElement);
+ }
+
+ // Setup a capturing event listener on the whole window to catch the
+ // escape key while persistent notifications are visible.
+ this.window.addEventListener(
+ "keypress",
+ this._handleWindowKeyPress,
+ true
+ );
+ } else {
+ // Notify observers that we're not showing the popup (useful for testing)
+ this._notify("updateNotShowing");
+
+ // Close the panel if there are no notifications to show.
+ // When called from PopupNotifications.show() we should never close the
+ // panel, however. It may just be adding a dismissed notification, in
+ // which case we want to continue showing any existing notifications.
+ if (!dismissShowing) {
+ this._dismiss();
+ }
+
+ // Only hide the iconBox if we actually have no notifications (as opposed
+ // to not having any showable notifications)
+ if (!haveNotifications) {
+ if (useIconBox) {
+ this.iconBox.hidden = true;
+ } else if (anchors.size) {
+ for (let anchorElement of anchors) {
+ anchorElement.removeAttribute(ICON_ATTRIBUTE_SHOWING);
+ }
+ }
+ }
+
+ // Stop listening to keyboard events for notifications.
+ this.window.removeEventListener(
+ "keypress",
+ this._handleWindowKeyPress,
+ true
+ );
+ }
+ },
+
+ _updateAnchorIcons: function PopupNotifications_updateAnchorIcons(
+ notifications,
+ anchorElements
+ ) {
+ for (let anchorElement of anchorElements) {
+ anchorElement.setAttribute(ICON_ATTRIBUTE_SHOWING, "true");
+ }
+ },
+
+ _showIcons: function PopupNotifications_showIcons(aCurrentNotifications) {
+ for (let notification of aCurrentNotifications) {
+ let anchorElm = notification.anchorElement;
+ if (anchorElm) {
+ anchorElm.setAttribute(ICON_ATTRIBUTE_SHOWING, "true");
+
+ if (notification.options.extraAttr) {
+ anchorElm.setAttribute("extraAttr", notification.options.extraAttr);
+ } else {
+ anchorElm.removeAttribute("extraAttr");
+ }
+ }
+ }
+ },
+
+ _hideIcons: function PopupNotifications_hideIcons() {
+ let icons = this.iconBox.querySelectorAll(ICON_SELECTOR);
+ for (let icon of icons) {
+ icon.removeAttribute(ICON_ATTRIBUTE_SHOWING);
+ }
+ },
+
+ /**
+ * Gets and sets notifications for the browser.
+ */
+ _getNotificationsForBrowser: function PopupNotifications_getNotifications(
+ browser
+ ) {
+ let notifications = popupNotificationsMap.get(browser);
+ if (!notifications) {
+ // Initialize the WeakMap for the browser so callers can reference/manipulate the array.
+ notifications = [];
+ popupNotificationsMap.set(browser, notifications);
+ }
+ return notifications;
+ },
+ _setNotificationsForBrowser: function PopupNotifications_setNotifications(
+ browser,
+ notifications
+ ) {
+ popupNotificationsMap.set(browser, notifications);
+ return notifications;
+ },
+
+ _getAnchorsForNotifications:
+ function PopupNotifications_getAnchorsForNotifications(
+ notifications,
+ defaultAnchor
+ ) {
+ let anchors = new Set();
+ for (let notification of notifications) {
+ if (notification.anchorElement) {
+ anchors.add(notification.anchorElement);
+ }
+ }
+ if (defaultAnchor && !anchors.size) {
+ anchors.add(defaultAnchor);
+ }
+ return anchors;
+ },
+
+ _isActiveBrowser(browser) {
+ // We compare on frameLoader instead of just comparing the
+ // selectedBrowser and browser directly because browser tabs in
+ // Responsive Design Mode put the actual web content into a
+ // mozbrowser iframe and proxy property read/write and method
+ // calls from the tab to that iframe. This is so that attempts
+ // to reload the tab end up reloading the content in
+ // Responsive Design Mode, and not the Responsive Design Mode
+ // viewer itself.
+ //
+ // This means that PopupNotifications can come up from a browser
+ // in Responsive Design Mode, but the selectedBrowser will not match
+ // the browser being passed into this function, despite the browser
+ // actually being within the selected tab. We workaround this by
+ // comparing frameLoader instead, which is proxied from the outer
+ // <xul:browser> to the inner mozbrowser <iframe>.
+ return this.tabbrowser.selectedBrowser.frameLoader == browser.frameLoader;
+ },
+
+ _onIconBoxCommand: function PopupNotifications_onIconBoxCommand(event) {
+ // Left click, space or enter only
+ let type = event.type;
+ if (type == "click" && event.button != 0) {
+ return;
+ }
+
+ if (
+ type == "keypress" &&
+ !(
+ event.charCode == event.DOM_VK_SPACE ||
+ event.keyCode == event.DOM_VK_RETURN
+ )
+ ) {
+ return;
+ }
+
+ if (!this._currentNotifications.length) {
+ return;
+ }
+
+ event.stopPropagation();
+
+ // Get the anchor that is the immediate child of the icon box
+ let anchor = event.target;
+ while (anchor && anchor.parentNode != this.iconBox) {
+ anchor = anchor.parentNode;
+ }
+
+ if (!anchor) {
+ return;
+ }
+
+ // If the panel is not closed, and the anchor is different, immediately mark all
+ // active notifications for the previous anchor as dismissed
+ if (this.panel.state != "closed" && anchor != this._currentAnchorElement) {
+ this._dismissOrRemoveCurrentNotifications();
+ }
+
+ // Avoid reshowing notifications that are already shown and have not been dismissed.
+ if (this.panel.state == "closed" || anchor != this._currentAnchorElement) {
+ // As soon as the panel is shown, focus the first element in the selected notification.
+ this.panel.addEventListener(
+ "popupshown",
+ () =>
+ this.window.document.commandDispatcher.advanceFocusIntoSubtree(
+ this.panel
+ ),
+ { once: true }
+ );
+
+ this._reshowNotifications(anchor);
+ } else {
+ // Focus the first element in the selected notification.
+ this.window.document.commandDispatcher.advanceFocusIntoSubtree(
+ this.panel
+ );
+ }
+ },
+
+ _reshowNotifications: function PopupNotifications_reshowNotifications(
+ anchor,
+ browser
+ ) {
+ // Mark notifications anchored to this anchor as un-dismissed
+ browser = browser || this.tabbrowser.selectedBrowser;
+ let notifications = this._getNotificationsForBrowser(browser);
+ notifications.forEach(function (n) {
+ if (n.anchorElement == anchor) {
+ n.dismissed = false;
+ }
+ });
+
+ if (this._isActiveBrowser(browser)) {
+ // ...and then show them.
+ this._update(notifications, anchor);
+ }
+ },
+
+ _swapBrowserNotifications:
+ function PopupNotifications_swapBrowserNoficications(
+ ourBrowser,
+ otherBrowser
+ ) {
+ // When swaping browser docshells (e.g. dragging tab to new window) we need
+ // to update our notification map.
+
+ let ourNotifications = this._getNotificationsForBrowser(ourBrowser);
+ let other = otherBrowser.ownerGlobal.PopupNotifications;
+ if (!other) {
+ if (ourNotifications.length) {
+ console.error(
+ "unable to swap notifications: otherBrowser doesn't support notifications"
+ );
+ }
+ return;
+ }
+ let otherNotifications = other._getNotificationsForBrowser(otherBrowser);
+ if (ourNotifications.length < 1 && otherNotifications.length < 1) {
+ // No notification to swap.
+ return;
+ }
+
+ otherNotifications = otherNotifications.filter(n => {
+ if (this._fireCallback(n, NOTIFICATION_EVENT_SWAPPING, ourBrowser)) {
+ n.browser = ourBrowser;
+ n.owner = this;
+ return true;
+ }
+ other._fireCallback(
+ n,
+ NOTIFICATION_EVENT_REMOVED,
+ this.nextRemovalReason
+ );
+ return false;
+ });
+
+ ourNotifications = ourNotifications.filter(n => {
+ if (this._fireCallback(n, NOTIFICATION_EVENT_SWAPPING, otherBrowser)) {
+ n.browser = otherBrowser;
+ n.owner = other;
+ return true;
+ }
+ this._fireCallback(
+ n,
+ NOTIFICATION_EVENT_REMOVED,
+ this.nextRemovalReason
+ );
+ return false;
+ });
+
+ this._setNotificationsForBrowser(otherBrowser, ourNotifications);
+ other._setNotificationsForBrowser(ourBrowser, otherNotifications);
+
+ if (otherNotifications.length) {
+ this._update(otherNotifications);
+ }
+ if (ourNotifications.length) {
+ other._update(ourNotifications);
+ }
+ },
+
+ _fireCallback: function PopupNotifications_fireCallback(n, event, ...args) {
+ try {
+ if (n.options.eventCallback) {
+ return n.options.eventCallback.call(n, event, ...args);
+ }
+ } catch (error) {
+ console.error(error);
+ }
+ return undefined;
+ },
+
+ _onPopupHidden: function PopupNotifications_onPopupHidden(event) {
+ if (event.target != this.panel) {
+ return;
+ }
+
+ // It's possible that a popupnotification set `aria-describedby` on the
+ // panel element in its eventCallback function. If so, we'll clear that out
+ // before showing the next notification.
+ this.panel.removeAttribute("aria-describedby");
+
+ // We may have removed the "noautofocus" attribute before showing the panel
+ // if the notification specified it wants to autofocus on first show.
+ // When the panel is closed, we have to restore the attribute to its default
+ // value, so we don't autofocus it if it's subsequently opened from a different code path.
+ this.panel.setAttribute("noautofocus", "true");
+
+ // Handle the case where the panel was closed programmatically.
+ if (this._ignoreDismissal) {
+ this._ignoreDismissal.resolve();
+ this._ignoreDismissal = null;
+ return;
+ }
+
+ this._dismissOrRemoveCurrentNotifications();
+
+ this._clearPanel();
+
+ this._update();
+ },
+
+ _dismissOrRemoveCurrentNotifications() {
+ let browser =
+ this.panel.firstElementChild &&
+ this.panel.firstElementChild.notification.browser;
+ if (!browser) {
+ return;
+ }
+
+ let notifications = this._getNotificationsForBrowser(browser);
+ // Mark notifications as dismissed and call dismissal callbacks
+ for (let nEl of this.panel.children) {
+ let notificationObj = nEl.notification;
+ // Never call a dismissal handler on a notification that's been removed.
+ if (!notifications.includes(notificationObj)) {
+ return;
+ }
+
+ // Record the time of the first notification dismissal if the main action
+ // was not triggered in the meantime.
+ let timeSinceShown =
+ this.window.performance.now() - notificationObj.timeShown;
+ if (
+ !notificationObj.wasDismissed &&
+ !notificationObj.recordedTelemetryMainAction
+ ) {
+ notificationObj._recordTelemetry(
+ "POPUP_NOTIFICATION_DISMISSAL_MS",
+ timeSinceShown
+ );
+ }
+
+ // Do not mark the notification as dismissed or fire NOTIFICATION_EVENT_DISMISSED
+ // if the notification is removed.
+ if (notificationObj.options.removeOnDismissal) {
+ notificationObj._recordTelemetryStat(this.nextRemovalReason);
+ this._remove(notificationObj);
+ } else {
+ notificationObj.dismissed = true;
+ this._fireCallback(notificationObj, NOTIFICATION_EVENT_DISMISSED);
+ }
+ }
+ },
+
+ _onCheckboxCommand(event) {
+ let notificationEl = getNotificationFromElement(event.originalTarget);
+ let checked = notificationEl.checkbox.checked;
+ let notification = notificationEl.notification;
+
+ // Save checkbox state to be able to persist it when re-opening the doorhanger.
+ notification._checkboxChecked = checked;
+
+ if (checked) {
+ this._setNotificationUIState(
+ notificationEl,
+ notification.options.checkbox.checkedState
+ );
+ } else {
+ this._setNotificationUIState(
+ notificationEl,
+ notification.options.checkbox.uncheckedState
+ );
+ }
+ event.stopPropagation();
+ },
+
+ _onCommand(event) {
+ // Ignore events from buttons as they are submitting and so don't need checks
+ if (event.originalTarget.localName == "button") {
+ return;
+ }
+ let notificationEl = getNotificationFromElement(event.target);
+
+ let notification = notificationEl.notification;
+ if (!notification.options.checkbox) {
+ this._setNotificationUIState(notificationEl);
+ return;
+ }
+
+ if (notificationEl.checkbox.checked) {
+ this._setNotificationUIState(
+ notificationEl,
+ notification.options.checkbox.checkedState
+ );
+ } else {
+ this._setNotificationUIState(
+ notificationEl,
+ notification.options.checkbox.uncheckedState
+ );
+ }
+ },
+
+ _onButtonEvent(event, type, source = "button", notificationEl = null) {
+ if (!notificationEl) {
+ notificationEl = getNotificationFromElement(event.originalTarget);
+ }
+
+ if (!notificationEl) {
+ throw new Error(
+ "PopupNotifications._onButtonEvent: couldn't find notification element"
+ );
+ }
+
+ if (!notificationEl.notification) {
+ throw new Error(
+ "PopupNotifications._onButtonEvent: couldn't find notification"
+ );
+ }
+
+ let notification = notificationEl.notification;
+
+ // Receiving a button event means the notification should have been shown.
+ // Make sure that timeShown is always set to ensure we don't break the
+ // security delay calculation below.
+ if (!notification.timeShown) {
+ console.warn(
+ "_onButtonEvent: notification.timeShown is unset. Setting to now.",
+ notification
+ );
+ notification.timeShown = this.window.performance.now();
+ }
+
+ if (type == "dropmarkerpopupshown") {
+ notification._recordTelemetryStat(TELEMETRY_STAT_OPEN_SUBMENU);
+ return;
+ }
+
+ if (type == "learnmoreclick") {
+ notification._recordTelemetryStat(TELEMETRY_STAT_LEARN_MORE);
+ return;
+ }
+
+ if (type == "buttoncommand") {
+ // Record the total timing of the main action since the notification was
+ // created, even if the notification was dismissed in the meantime.
+ let timeSinceCreated =
+ this.window.performance.now() - notification.timeCreated;
+ if (!notification.recordedTelemetryMainAction) {
+ notification.recordedTelemetryMainAction = true;
+ notification._recordTelemetry(
+ "POPUP_NOTIFICATION_MAIN_ACTION_MS",
+ timeSinceCreated
+ );
+ }
+ }
+
+ if (type == "buttoncommand" || type == "secondarybuttoncommand") {
+ if (Services.focus.activeWindow != this.window) {
+ Services.console.logStringMessage(
+ "PopupNotifications._onButtonEvent: " +
+ "Button click happened before the window was focused"
+ );
+ this.window.focus();
+ return;
+ }
+
+ let now = this.window.performance.now();
+ let timeSinceShown = now - notification.timeShown;
+ if (timeSinceShown < lazy.buttonDelay) {
+ Services.console.logStringMessage(
+ "PopupNotifications._onButtonEvent: " +
+ "Button click happened before the security delay: " +
+ timeSinceShown +
+ "ms"
+ );
+ notification.timeShown = Math.max(now, notification.timeShown);
+ return;
+ }
+ }
+
+ let action = notification.mainAction;
+ let telemetryStatId = TELEMETRY_STAT_ACTION_1;
+
+ if (type == "secondarybuttoncommand") {
+ action = notification.secondaryActions[0];
+ telemetryStatId = TELEMETRY_STAT_ACTION_2;
+ }
+
+ notification._recordTelemetryStat(telemetryStatId);
+
+ if (action) {
+ try {
+ action.callback.call(undefined, {
+ checkboxChecked: notificationEl.checkbox.checked,
+ source,
+ event,
+ });
+ } catch (error) {
+ console.error(error);
+ }
+
+ if (action.dismiss) {
+ this._dismiss();
+ return;
+ }
+ }
+
+ this._remove(notification);
+ this._update();
+ },
+
+ _onMenuCommand: function PopupNotifications_onMenuCommand(event) {
+ let target = event.originalTarget;
+ if (!target.action || !target.notification) {
+ throw new Error(
+ "menucommand target has no associated action/notification"
+ );
+ }
+
+ let notificationEl = getNotificationFromElement(target);
+ event.stopPropagation();
+
+ target.notification._recordTelemetryStat(target.action.telemetryStatId);
+
+ try {
+ target.action.callback.call(undefined, {
+ checkboxChecked: notificationEl.checkbox.checked,
+ source: "menucommand",
+ });
+ } catch (error) {
+ console.error(error);
+ }
+
+ if (target.action.dismiss) {
+ this._dismiss();
+ return;
+ }
+
+ this._remove(target.notification);
+ this._update();
+ },
+
+ _notify: function PopupNotifications_notify(topic) {
+ Services.obs.notifyObservers(null, "PopupNotifications-" + topic);
+ },
+};