Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 719 insertions, 0 deletions

diff --git a/browser/modules/ExtensionsUI.sys.mjs b/browser/modules/ExtensionsUI.sys.mjs
new file mode 100644
index 0000000000..0b113f87ce
--- /dev/null
+++ b/browser/modules/ExtensionsUI.sys.mjs
@@ -0,0 +1,719 @@
+/* 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 { EventEmitter } from "resource://gre/modules/EventEmitter.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  AMBrowserExtensionsImport: "resource://gre/modules/AddonManager.sys.mjs",
+  AMTelemetry: "resource://gre/modules/AddonManager.sys.mjs",
+  AddonManager: "resource://gre/modules/AddonManager.sys.mjs",
+  AddonManagerPrivate: "resource://gre/modules/AddonManager.sys.mjs",
+  AppMenuNotifications: "resource://gre/modules/AppMenuNotifications.sys.mjs",
+  ExtensionData: "resource://gre/modules/Extension.sys.mjs",
+  ExtensionPermissions: "resource://gre/modules/ExtensionPermissions.sys.mjs",
+  OriginControls: "resource://gre/modules/ExtensionPermissions.sys.mjs",
+  QuarantinedDomains: "resource://gre/modules/ExtensionPermissions.sys.mjs",
+});
+
+ChromeUtils.defineLazyGetter(
+  lazy,
+  "l10n",
+  () =>
+    new Localization(["browser/extensionsUI.ftl", "branding/brand.ftl"], true)
+);
+
+const DEFAULT_EXTENSION_ICON =
+  "chrome://mozapps/skin/extensions/extensionGeneric.svg";
+
+const HTML_NS = "http://www.w3.org/1999/xhtml";
+
+function getTabBrowser(browser) {
+  while (browser.ownerGlobal.docShell.itemType !== Ci.nsIDocShell.typeChrome) {
+    browser = browser.ownerGlobal.docShell.chromeEventHandler;
+  }
+  let window = browser.ownerGlobal;
+  let viewType = browser.getAttribute("webextension-view-type");
+  if (viewType == "sidebar") {
+    window = window.browsingContext.topChromeWindow;
+  }
+  if (viewType == "popup" || viewType == "sidebar") {
+    browser = window.gBrowser.selectedBrowser;
+  }
+  return { browser, window };
+}
+
+export var ExtensionsUI = {
+  sideloaded: new Set(),
+  updates: new Set(),
+  sideloadListener: null,
+
+  pendingNotifications: new WeakMap(),
+
+  async init() {
+    Services.obs.addObserver(this, "webextension-permission-prompt");
+    Services.obs.addObserver(this, "webextension-update-permissions");
+    Services.obs.addObserver(this, "webextension-install-notify");
+    Services.obs.addObserver(this, "webextension-optional-permission-prompt");
+    Services.obs.addObserver(this, "webextension-defaultsearch-prompt");
+    Services.obs.addObserver(this, "webextension-imported-addons-cancelled");
+    Services.obs.addObserver(this, "webextension-imported-addons-complete");
+    Services.obs.addObserver(this, "webextension-imported-addons-pending");
+
+    await Services.wm.getMostRecentWindow("navigator:browser")
+      .delayedStartupPromise;
+
+    this._checkForSideloaded();
+  },
+
+  async _checkForSideloaded() {
+    let sideloaded = await lazy.AddonManagerPrivate.getNewSideloads();
+
+    if (!sideloaded.length) {
+      // No new side-loads. We're done.
+      return;
+    }
+
+    // The ordering shouldn't matter, but tests depend on notifications
+    // happening in a specific order.
+    sideloaded.sort((a, b) => a.id.localeCompare(b.id));
+
+    if (!this.sideloadListener) {
+      this.sideloadListener = {
+        onEnabled: addon => {
+          if (!this.sideloaded.has(addon)) {
+            return;
+          }
+
+          this.sideloaded.delete(addon);
+          this._updateNotifications();
+
+          if (this.sideloaded.size == 0) {
+            lazy.AddonManager.removeAddonListener(this.sideloadListener);
+            this.sideloadListener = null;
+          }
+        },
+      };
+      lazy.AddonManager.addAddonListener(this.sideloadListener);
+    }
+
+    for (let addon of sideloaded) {
+      this.sideloaded.add(addon);
+    }
+    this._updateNotifications();
+  },
+
+  _updateNotifications() {
+    const { sideloaded, updates } = this;
+    const { importedAddonIDs } = lazy.AMBrowserExtensionsImport;
+
+    if (importedAddonIDs.length + sideloaded.size + updates.size == 0) {
+      lazy.AppMenuNotifications.removeNotification("addon-alert");
+    } else {
+      lazy.AppMenuNotifications.showBadgeOnlyNotification("addon-alert");
+    }
+    this.emit("change");
+  },
+
+  showAddonsManager(tabbrowser, strings, icon) {
+    let global = tabbrowser.selectedBrowser.ownerGlobal;
+    return global
+      .BrowserOpenAddonsMgr("addons://list/extension")
+      .then(aomWin => {
+        let aomBrowser = aomWin.docShell.chromeEventHandler;
+        return this.showPermissionsPrompt(aomBrowser, strings, icon);
+      });
+  },
+
+  showSideloaded(tabbrowser, addon) {
+    addon.markAsSeen();
+    this.sideloaded.delete(addon);
+    this._updateNotifications();
+
+    let strings = this._buildStrings({
+      addon,
+      permissions: addon.userPermissions,
+      type: "sideload",
+    });
+
+    lazy.AMTelemetry.recordManageEvent(addon, "sideload_prompt", {
+      num_strings: strings.msgs.length,
+    });
+
+    this.showAddonsManager(tabbrowser, strings, addon.iconURL).then(
+      async answer => {
+        if (answer) {
+          await addon.enable();
+
+          this._updateNotifications();
+
+          // The user has just enabled a sideloaded extension, if the permission
+          // can be changed for the extension, show the post-install panel to
+          // give the user that opportunity.
+          if (
+            addon.permissions &
+            lazy.AddonManager.PERM_CAN_CHANGE_PRIVATEBROWSING_ACCESS
+          ) {
+            this.showInstallNotification(tabbrowser.selectedBrowser, addon);
+          }
+        }
+        this.emit("sideload-response");
+      }
+    );
+  },
+
+  showUpdate(browser, info) {
+    lazy.AMTelemetry.recordInstallEvent(info.install, {
+      step: "permissions_prompt",
+      num_strings: info.strings.msgs.length,
+    });
+
+    this.showAddonsManager(browser, info.strings, info.addon.iconURL).then(
+      answer => {
+        if (answer) {
+          info.resolve();
+        } else {
+          info.reject();
+        }
+        // At the moment, this prompt will re-appear next time we do an update
+        // check.  See bug 1332360 for proposal to avoid this.
+        this.updates.delete(info);
+        this._updateNotifications();
+      }
+    );
+  },
+
+  observe(subject, topic, data) {
+    if (topic == "webextension-permission-prompt") {
+      let { target, info } = subject.wrappedJSObject;
+
+      let { browser, window } = getTabBrowser(target);
+
+      // 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 = window.PopupNotifications.getNotification(
+        "addon-progress",
+        browser
+      );
+      if (progressNotification) {
+        progressNotification.remove();
+      }
+
+      info.unsigned =
+        info.addon.signedState <= lazy.AddonManager.SIGNEDSTATE_MISSING;
+      if (
+        info.unsigned &&
+        Cu.isInAutomation &&
+        Services.prefs.getBoolPref("extensions.ui.ignoreUnsigned", false)
+      ) {
+        info.unsigned = false;
+      }
+
+      let strings = this._buildStrings(info);
+
+      // If this is an update with no promptable permissions, just apply it
+      if (info.type == "update" && !strings.msgs.length) {
+        info.resolve();
+        return;
+      }
+
+      let icon = info.unsigned
+        ? "chrome://global/skin/icons/warning.svg"
+        : info.icon;
+
+      if (info.type == "sideload") {
+        lazy.AMTelemetry.recordManageEvent(info.addon, "sideload_prompt", {
+          num_strings: strings.msgs.length,
+        });
+      } else {
+        lazy.AMTelemetry.recordInstallEvent(info.install, {
+          step: "permissions_prompt",
+          num_strings: strings.msgs.length,
+        });
+      }
+
+      this.showPermissionsPrompt(browser, strings, icon).then(answer => {
+        if (answer) {
+          info.resolve();
+        } else {
+          info.reject();
+        }
+      });
+    } else if (topic == "webextension-update-permissions") {
+      let info = subject.wrappedJSObject;
+      info.type = "update";
+      let strings = this._buildStrings(info);
+
+      // If we don't prompt for any new permissions, just apply it
+      if (!strings.msgs.length) {
+        info.resolve();
+        return;
+      }
+
+      let update = {
+        strings,
+        permissions: info.permissions,
+        install: info.install,
+        addon: info.addon,
+        resolve: info.resolve,
+        reject: info.reject,
+      };
+
+      this.updates.add(update);
+      this._updateNotifications();
+    } else if (topic == "webextension-install-notify") {
+      let { target, addon, callback } = subject.wrappedJSObject;
+      this.showInstallNotification(target, addon).then(() => {
+        if (callback) {
+          callback();
+        }
+      });
+    } else if (topic == "webextension-optional-permission-prompt") {
+      let { browser, name, icon, permissions, resolve } =
+        subject.wrappedJSObject;
+      let strings = this._buildStrings({
+        type: "optional",
+        addon: { name },
+        permissions,
+      });
+
+      // If we don't have any promptable permissions, just proceed
+      if (!strings.msgs.length) {
+        resolve(true);
+        return;
+      }
+      resolve(this.showPermissionsPrompt(browser, strings, icon));
+    } else if (topic == "webextension-defaultsearch-prompt") {
+      let { browser, name, icon, respond, currentEngine, newEngine } =
+        subject.wrappedJSObject;
+
+      const [searchDesc, searchYes, searchNo] = lazy.l10n.formatMessagesSync([
+        {
+          id: "webext-default-search-description",
+          args: { addonName: "<>", currentEngine, newEngine },
+        },
+        "webext-default-search-yes",
+        "webext-default-search-no",
+      ]);
+
+      const strings = { addonName: name, text: searchDesc.value };
+      for (let attr of searchYes.attributes) {
+        if (attr.name === "label") {
+          strings.acceptText = attr.value;
+        } else if (attr.name === "accesskey") {
+          strings.acceptKey = attr.value;
+        }
+      }
+      for (let attr of searchNo.attributes) {
+        if (attr.name === "label") {
+          strings.cancelText = attr.value;
+        } else if (attr.name === "accesskey") {
+          strings.cancelKey = attr.value;
+        }
+      }
+
+      this.showDefaultSearchPrompt(browser, strings, icon).then(respond);
+    } else if (
+      [
+        "webextension-imported-addons-cancelled",
+        "webextension-imported-addons-complete",
+        "webextension-imported-addons-pending",
+      ].includes(topic)
+    ) {
+      this._updateNotifications();
+    }
+  },
+
+  // Create a set of formatted strings for a permission prompt
+  _buildStrings(info) {
+    const strings = lazy.ExtensionData.formatPermissionStrings(info, {
+      collapseOrigins: true,
+    });
+    strings.addonName = info.addon.name;
+    return strings;
+  },
+
+  async showPermissionsPrompt(target, strings, icon) {
+    let { browser, window } = getTabBrowser(target);
+
+    await window.ensureCustomElements("moz-support-link");
+
+    // Wait for any pending prompts to complete before showing the next one.
+    let pending;
+    while ((pending = this.pendingNotifications.get(browser))) {
+      await pending;
+    }
+
+    let promise = new Promise(resolve => {
+      function eventCallback(topic) {
+        let doc = this.browser.ownerDocument;
+        if (topic == "showing") {
+          let textEl = doc.getElementById("addon-webext-perm-text");
+          textEl.textContent = strings.text;
+          textEl.hidden = !strings.text;
+
+          // By default, multiline strings don't get formatted properly. These
+          // are presently only used in site permission add-ons, so we treat it
+          // as a special case to avoid unintended effects on other things.
+          let isMultiline = strings.text.includes("\n\n");
+          textEl.classList.toggle(
+            "addon-webext-perm-text-multiline",
+            isMultiline
+          );
+
+          let listIntroEl = doc.getElementById("addon-webext-perm-intro");
+          listIntroEl.textContent = strings.listIntro;
+          listIntroEl.hidden = !strings.msgs.length || !strings.listIntro;
+
+          let listInfoEl = doc.getElementById("addon-webext-perm-info");
+          listInfoEl.hidden = !strings.msgs.length;
+
+          let list = doc.getElementById("addon-webext-perm-list");
+          while (list.firstChild) {
+            list.firstChild.remove();
+          }
+          let singleEntryEl = doc.getElementById(
+            "addon-webext-perm-single-entry"
+          );
+          singleEntryEl.textContent = "";
+          singleEntryEl.hidden = true;
+          list.hidden = true;
+
+          if (strings.msgs.length === 1) {
+            singleEntryEl.textContent = strings.msgs[0];
+            singleEntryEl.hidden = false;
+          } else if (strings.msgs.length) {
+            for (let msg of strings.msgs) {
+              let item = doc.createElementNS(HTML_NS, "li");
+              item.textContent = msg;
+              list.appendChild(item);
+            }
+            list.hidden = false;
+          }
+        } else if (topic == "swapping") {
+          return true;
+        }
+        if (topic == "removed") {
+          Services.tm.dispatchToMainThread(() => {
+            resolve(false);
+          });
+        }
+        return false;
+      }
+
+      let options = {
+        hideClose: true,
+        popupIconURL: icon || DEFAULT_EXTENSION_ICON,
+        popupIconClass: icon ? "" : "addon-warning-icon",
+        persistent: true,
+        eventCallback,
+        removeOnDismissal: true,
+        popupOptions: {
+          position: "bottomright topright",
+        },
+      };
+      // The prompt/notification machinery has a special affordance wherein
+      // certain subsets of the header string can be designated "names", and
+      // referenced symbolically as "<>" and "{}" to receive special formatting.
+      // That code assumes that the existence of |name| and |secondName| in the
+      // options object imply the presence of "<>" and "{}" (respectively) in
+      // in the string.
+      //
+      // At present, WebExtensions use this affordance while SitePermission
+      // add-ons don't, so we need to conditionally set the |name| field.
+      //
+      // NB: This could potentially be cleaned up, see bug 1799710.
+      if (strings.header.includes("<>")) {
+        options.name = strings.addonName;
+      }
+
+      let action = {
+        label: strings.acceptText,
+        accessKey: strings.acceptKey,
+        callback: () => {
+          resolve(true);
+        },
+      };
+      let secondaryActions = [
+        {
+          label: strings.cancelText,
+          accessKey: strings.cancelKey,
+          callback: () => {
+            resolve(false);
+          },
+        },
+      ];
+
+      window.PopupNotifications.show(
+        browser,
+        "addon-webext-permissions",
+        strings.header,
+        browser.ownerGlobal.gUnifiedExtensions.getPopupAnchorID(
+          browser,
+          window
+        ),
+        action,
+        secondaryActions,
+        options
+      );
+    });
+
+    this.pendingNotifications.set(browser, promise);
+    promise.finally(() => this.pendingNotifications.delete(browser));
+    return promise;
+  },
+
+  showDefaultSearchPrompt(target, strings, icon) {
+    return new Promise(resolve => {
+      let options = {
+        hideClose: true,
+        popupIconURL: icon || DEFAULT_EXTENSION_ICON,
+        persistent: true,
+        removeOnDismissal: true,
+        eventCallback(topic) {
+          if (topic == "removed") {
+            resolve(false);
+          }
+        },
+        name: strings.addonName,
+      };
+
+      let action = {
+        label: strings.acceptText,
+        accessKey: strings.acceptKey,
+        callback: () => {
+          resolve(true);
+        },
+      };
+      let secondaryActions = [
+        {
+          label: strings.cancelText,
+          accessKey: strings.cancelKey,
+          callback: () => {
+            resolve(false);
+          },
+        },
+      ];
+
+      let { browser, window } = getTabBrowser(target);
+
+      window.PopupNotifications.show(
+        browser,
+        "addon-webext-defaultsearch",
+        strings.text,
+        "addons-notification-icon",
+        action,
+        secondaryActions,
+        options
+      );
+    });
+  },
+
+  async showInstallNotification(target, addon) {
+    let { window } = getTabBrowser(target);
+
+    const message = await lazy.l10n.formatValue("addon-post-install-message", {
+      addonName: "<>",
+    });
+    const permissionName = "internal:privateBrowsingAllowed";
+    const { permissions } = await lazy.ExtensionPermissions.get(addon.id);
+    const hasIncognito = permissions.includes(permissionName);
+
+    return new Promise(resolve => {
+      // Show or hide private permission ui based on the pref.
+      function setCheckbox(win) {
+        let checkbox = win.document.getElementById("addon-incognito-checkbox");
+        checkbox.checked = hasIncognito;
+        checkbox.hidden = !(
+          addon.permissions &
+          lazy.AddonManager.PERM_CAN_CHANGE_PRIVATEBROWSING_ACCESS
+        );
+      }
+
+      async function actionResolve(win) {
+        let checkbox = win.document.getElementById("addon-incognito-checkbox");
+
+        if (checkbox.checked == hasIncognito) {
+          resolve();
+          return;
+        }
+
+        let incognitoPermission = {
+          permissions: [permissionName],
+          origins: [],
+        };
+
+        // The checkbox has been changed at this point, otherwise we would
+        // have exited early above.
+        if (checkbox.checked) {
+          await lazy.ExtensionPermissions.add(addon.id, incognitoPermission);
+        } else if (hasIncognito) {
+          await lazy.ExtensionPermissions.remove(addon.id, incognitoPermission);
+        }
+        // Reload the extension if it is already enabled.  This ensures any change
+        // on the private browsing permission is properly handled.
+        if (addon.isActive) {
+          await addon.reload();
+        }
+
+        resolve();
+      }
+
+      let action = {
+        callback: actionResolve,
+      };
+
+      let icon = addon.isWebExtension
+        ? lazy.AddonManager.getPreferredIconURL(addon, 32, window) ||
+          DEFAULT_EXTENSION_ICON
+        : "chrome://browser/skin/addons/addon-install-installed.svg";
+      let options = {
+        name: addon.name,
+        message,
+        popupIconURL: icon,
+        onRefresh: setCheckbox,
+        onDismissed: win => {
+          lazy.AppMenuNotifications.removeNotification("addon-installed");
+          actionResolve(win);
+        },
+      };
+      lazy.AppMenuNotifications.showNotification(
+        "addon-installed",
+        action,
+        null,
+        options
+      );
+    });
+  },
+
+  async showQuarantineConfirmation(browser, policy) {
+    let [title, line1, line2, allow, deny] = await lazy.l10n.formatMessages([
+      {
+        id: "webext-quarantine-confirmation-title",
+        args: { addonName: "<>" },
+      },
+      "webext-quarantine-confirmation-line-1",
+      "webext-quarantine-confirmation-line-2",
+      "webext-quarantine-confirmation-allow",
+      "webext-quarantine-confirmation-deny",
+    ]);
+
+    let attr = (msg, name) => msg.attributes.find(a => a.name === name)?.value;
+
+    let strings = {
+      addonName: policy.name,
+      header: title.value,
+      text: line1.value + "\n\n" + line2.value,
+      msgs: [],
+      acceptText: attr(allow, "label"),
+      acceptKey: attr(allow, "accesskey"),
+      cancelText: attr(deny, "label"),
+      cancelKey: attr(deny, "accesskey"),
+    };
+
+    let icon = policy.extension?.getPreferredIcon(32);
+
+    if (await ExtensionsUI.showPermissionsPrompt(browser, strings, icon)) {
+      lazy.QuarantinedDomains.setUserAllowedAddonIdPref(policy.id, true);
+    }
+  },
+
+  // Populate extension toolbar popup menu with origin controls.
+  originControlsMenu(popup, extensionId) {
+    let policy = WebExtensionPolicy.getByID(extensionId);
+
+    let win = popup.ownerGlobal;
+    let doc = popup.ownerDocument;
+    let tab = win.gBrowser.selectedTab;
+    let uri = tab.linkedBrowser?.currentURI;
+    let state = lazy.OriginControls.getState(policy, tab);
+
+    let headerItem = doc.createXULElement("menuitem");
+    headerItem.setAttribute("disabled", true);
+    let items = [headerItem];
+
+    // MV2 normally don't have controls, but we show the quarantined state.
+    if (!policy?.extension.originControls && !state.quarantined) {
+      return;
+    }
+
+    if (state.noAccess) {
+      doc.l10n.setAttributes(headerItem, "origin-controls-no-access");
+    } else {
+      doc.l10n.setAttributes(headerItem, "origin-controls-options");
+    }
+
+    if (state.quarantined) {
+      doc.l10n.setAttributes(headerItem, "origin-controls-quarantined-status");
+
+      let allowQuarantined = doc.createXULElement("menuitem");
+      doc.l10n.setAttributes(
+        allowQuarantined,
+        "origin-controls-quarantined-allow"
+      );
+      allowQuarantined.addEventListener("command", () => {
+        this.showQuarantineConfirmation(tab.linkedBrowser, policy);
+      });
+      items.push(allowQuarantined);
+    }
+
+    if (state.allDomains) {
+      let allDomains = doc.createXULElement("menuitem");
+      allDomains.setAttribute("type", "radio");
+      allDomains.setAttribute("checked", state.hasAccess);
+      doc.l10n.setAttributes(allDomains, "origin-controls-option-all-domains");
+      items.push(allDomains);
+    }
+
+    if (state.whenClicked) {
+      let whenClicked = doc.createXULElement("menuitem");
+      whenClicked.setAttribute("type", "radio");
+      whenClicked.setAttribute("checked", !state.hasAccess);
+      doc.l10n.setAttributes(
+        whenClicked,
+        "origin-controls-option-when-clicked"
+      );
+      whenClicked.addEventListener("command", async () => {
+        await lazy.OriginControls.setWhenClicked(policy, uri);
+        win.gUnifiedExtensions.updateAttention();
+      });
+      items.push(whenClicked);
+    }
+
+    if (state.alwaysOn) {
+      let alwaysOn = doc.createXULElement("menuitem");
+      alwaysOn.setAttribute("type", "radio");
+      alwaysOn.setAttribute("checked", state.hasAccess);
+      doc.l10n.setAttributes(alwaysOn, "origin-controls-option-always-on", {
+        domain: uri.host,
+      });
+      alwaysOn.addEventListener("command", async () => {
+        await lazy.OriginControls.setAlwaysOn(policy, uri);
+        win.gUnifiedExtensions.updateAttention();
+      });
+      items.push(alwaysOn);
+    }
+
+    items.push(doc.createXULElement("menuseparator"));
+
+    // Insert all items before Pin to toolbar OR Manage Extension, but after
+    // any extension's menu items.
+    let manageItem =
+      popup.querySelector(".customize-context-manageExtension") ||
+      popup.querySelector(".unified-extensions-context-menu-pin-to-toolbar");
+    items.forEach(item => item && popup.insertBefore(item, manageItem));
+
+    let cleanup = e => {
+      if (e.target === popup) {
+        items.forEach(item => item?.remove());
+        popup.removeEventListener("popuphidden", cleanup);
+      }
+    };
+    popup.addEventListener("popuphidden", cleanup);
+  },
+};
+
+EventEmitter.decorate(ExtensionsUI);