Adding upstream version 115.7.0esr.upstream/115.7.0esr

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

1 files changed, 268 insertions, 0 deletions

diff --git a/toolkit/actors/PopupBlockingParent.sys.mjs b/toolkit/actors/PopupBlockingParent.sys.mjs
new file mode 100644
index 0000000000..adb49a1ba2
--- /dev/null
+++ b/toolkit/actors/PopupBlockingParent.sys.mjs
@@ -0,0 +1,268 @@
+/* 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 class manages all popup blocking operations on a <xul:browser>, including
+ * notifying the UI about updates to the blocked popups, and allowing popups to
+ * be unblocked.
+ */
+export class PopupBlocker {
+  constructor(browser) {
+    this._browser = browser;
+    this._allBlockedPopupCounts = new WeakMap();
+    this._shouldShowNotification = false;
+  }
+
+  /**
+   * Returns whether or not there are new blocked popups for the associated
+   * <xul:browser> that the user might need to be notified about.
+   */
+  get shouldShowNotification() {
+    return this._shouldShowNotification;
+  }
+
+  /**
+   * Should be called by the UI when the user has been notified about blocked
+   * popups for the associated <xul:browser>.
+   */
+  didShowNotification() {
+    this._shouldShowNotification = false;
+  }
+
+  /**
+   * Synchronously returns the most recent count of blocked popups for
+   * the associated <xul:browser>.
+   *
+   * @return {Number}
+   *   The total number of blocked popups for this <xul:browser>.
+   */
+  getBlockedPopupCount() {
+    let totalBlockedPopups = 0;
+
+    let contextsToVisit = [this._browser.browsingContext];
+    while (contextsToVisit.length) {
+      let currentBC = contextsToVisit.pop();
+      let windowGlobal = currentBC.currentWindowGlobal;
+
+      if (!windowGlobal) {
+        continue;
+      }
+
+      let popupCountForGlobal =
+        this._allBlockedPopupCounts.get(windowGlobal) || 0;
+      totalBlockedPopups += popupCountForGlobal;
+      contextsToVisit.push(...currentBC.children);
+    }
+
+    return totalBlockedPopups;
+  }
+
+  /**
+   * Asynchronously retrieve information about the popups that have
+   * been blocked for the associated <xul:browser>. This information
+   * can be used to unblock those popups.
+   *
+   * @return {Promise}
+   * @resolves {Array}
+   *   When the blocked popup information has been gathered,
+   *   resolves with an Array of Objects with the following properties:
+   *
+   *   browsingContext {BrowsingContext}
+   *     The BrowsingContext that the popup was blocked for.
+   *
+   *   innerWindowId {Number}
+   *     The inner window ID for the blocked popup. This is used to differentiate
+   *     popups that were blocked from one page load to the next.
+   *
+   *   popupWindowURISpec {String}
+   *     A string representing part or all of the URI that tried to be opened in a
+   *     popup.
+   */
+  async getBlockedPopups() {
+    let contextsToVisit = [this._browser.browsingContext];
+    let result = [];
+    while (contextsToVisit.length) {
+      let currentBC = contextsToVisit.pop();
+      let windowGlobal = currentBC.currentWindowGlobal;
+
+      if (!windowGlobal) {
+        continue;
+      }
+
+      let popupCountForGlobal =
+        this._allBlockedPopupCounts.get(windowGlobal) || 0;
+      if (popupCountForGlobal) {
+        let actor = windowGlobal.getActor("PopupBlocking");
+        let popups = await actor.sendQuery("GetBlockedPopupList");
+
+        for (let popup of popups) {
+          if (!popup.popupWindowURISpec) {
+            continue;
+          }
+
+          result.push({
+            browsingContext: currentBC,
+            innerWindowId: windowGlobal.innerWindowId,
+            popupWindowURISpec: popup.popupWindowURISpec,
+          });
+        }
+      }
+
+      contextsToVisit.push(...currentBC.children);
+    }
+
+    return result;
+  }
+
+  /**
+   * Unblocks a popup that had been blocked. The information passed should
+   * come from the list of blocked popups returned via getBlockedPopups().
+   *
+   * Unblocking a popup causes that popup to open.
+   *
+   * @param browsingContext {BrowsingContext}
+   *   The BrowsingContext that the popup was blocked for.
+   *
+   * @param innerWindowId {Number}
+   *   The inner window ID for the blocked popup. This is used to differentiate popups
+   *   that were blocked from one page load to the next.
+   *
+   * @param popupIndex {Number}
+   *   The index of the entry in the Array returned by getBlockedPopups().
+   */
+  unblockPopup(browsingContext, innerWindowId, popupIndex) {
+    let popupFrame = browsingContext.top.embedderElement;
+    let popupBrowser = popupFrame.outerBrowser
+      ? popupFrame.outerBrowser
+      : popupFrame;
+
+    if (this._browser != popupBrowser) {
+      throw new Error(
+        "Attempting to unblock popup in a BrowsingContext no longer hosted in this browser."
+      );
+    }
+
+    let windowGlobal = browsingContext.currentWindowGlobal;
+
+    if (!windowGlobal || windowGlobal.innerWindowId != innerWindowId) {
+      // The inner window has moved on since the user clicked on
+      // the blocked popups dropdown, so we'll just exit silently.
+      return;
+    }
+
+    let actor = browsingContext.currentWindowGlobal.getActor("PopupBlocking");
+    actor.sendAsyncMessage("UnblockPopup", { index: popupIndex });
+  }
+
+  /**
+   * Goes through the most recent list of blocked popups for the associated
+   * <xul:browser> and unblocks all of them. Unblocking a popup causes the popup
+   * to open.
+   */
+  async unblockAllPopups() {
+    let popups = await this.getBlockedPopups();
+    for (let i = 0; i < popups.length; ++i) {
+      let popup = popups[i];
+      this.unblockPopup(popup.browsingContext, popup.innerWindowId, i);
+    }
+  }
+
+  /**
+   * Fires a DOMUpdateBlockedPopups chrome-only event so that the UI can
+   * update itself to represent the current state of popup blocking for
+   * the associated <xul:browser>.
+   */
+  updateBlockedPopupsUI() {
+    let event = this._browser.ownerDocument.createEvent("Events");
+    event.initEvent("DOMUpdateBlockedPopups", true, true);
+    this._browser.dispatchEvent(event);
+  }
+
+  /** Private methods **/
+
+  /**
+   * Updates the current popup count for a particular BrowsingContext based
+   * on messages from the underlying process.
+   *
+   * This should only be called by a PopupBlockingParent instance.
+   *
+   * @param browsingContext {BrowsingContext}
+   *   The BrowsingContext to update the internal blocked popup count for.
+   *
+   * @param blockedPopupData {Object}
+   *   An Object representing information about how many popups are blocked
+   *   for the BrowsingContext. The Object has the following properties:
+   *
+   *   count {Number}
+   *     The total number of blocked popups for the BrowsingContext.
+   *
+   *   shouldNotify {Boolean}
+   *     Whether or not the list of blocked popups has changed in such a way that
+   *     the UI should be updated about it.
+   */
+  _updateBlockedPopupEntries(browsingContext, blockedPopupData) {
+    let windowGlobal = browsingContext.currentWindowGlobal;
+    let { count, shouldNotify } = blockedPopupData;
+
+    if (!this.shouldShowNotification && shouldNotify) {
+      this._shouldShowNotification = true;
+    }
+
+    if (windowGlobal) {
+      this._allBlockedPopupCounts.set(windowGlobal, count);
+    }
+
+    this.updateBlockedPopupsUI();
+  }
+}
+
+/**
+ * To keep things properly encapsulated, these should only be instantiated via
+ * the PopupBlocker class for a particular <xul:browser>.
+ *
+ * Instantiated for a WindowGlobalParent for a BrowsingContext in one of two cases:
+ *
+ *   1. One or more popups have been blocked for the underlying frame represented
+ *      by the WindowGlobalParent.
+ *
+ *   2. Something in the parent process is querying a frame for information about
+ *      any popups that may have been blocked inside of it.
+ */
+export class PopupBlockingParent extends JSWindowActorParent {
+  didDestroy() {
+    this.updatePopupCountForBrowser({ count: 0, shouldNotify: false });
+  }
+
+  receiveMessage(message) {
+    if (message.name == "UpdateBlockedPopups") {
+      this.updatePopupCountForBrowser({
+        count: message.data.count,
+        shouldNotify: message.data.shouldNotify,
+      });
+    }
+  }
+
+  /**
+   * Updates the PopupBlocker for the <xul:browser> associated with this
+   * PopupBlockingParent with the most recent count of blocked popups.
+   *
+   * @param data {Object}
+   *   An Object with the following properties:
+   *
+   *     count {Number}:
+   *       The number of blocked popups for the underlying document.
+   *
+   *     shouldNotify {Boolean}:
+   *       Whether or not the list of blocked popups has changed in such a way that
+   *       the UI should be updated about it.
+   */
+  updatePopupCountForBrowser(data) {
+    let browser = this.browsingContext.top.embedderElement;
+    if (!browser) {
+      return;
+    }
+
+    browser.popupBlocker._updateBlockedPopupEntries(this.browsingContext, data);
+  }
+}