Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 667 insertions, 0 deletions

diff --git a/toolkit/components/extensions/ExtensionActions.sys.mjs b/toolkit/components/extensions/ExtensionActions.sys.mjs
new file mode 100644
index 0000000000..8e8cf3abd2
--- /dev/null
+++ b/toolkit/components/extensions/ExtensionActions.sys.mjs
@@ -0,0 +1,667 @@
+/* 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 { ExtensionUtils } from "resource://gre/modules/ExtensionUtils.sys.mjs";
+
+const { ExtensionError } = ExtensionUtils;
+
+import { ExtensionParent } from "resource://gre/modules/ExtensionParent.sys.mjs";
+
+const { IconDetails, StartupCache } = ExtensionParent;
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "MV2_ACTION_POPURL_RESTRICTED",
+  "extensions.manifestV2.actionsPopupURLRestricted",
+  false
+);
+
+function parseColor(color, kind) {
+  if (typeof color == "string") {
+    let rgba = InspectorUtils.colorToRGBA(color);
+    if (!rgba) {
+      throw new ExtensionError(`Invalid badge ${kind} color: "${color}"`);
+    }
+    color = [rgba.r, rgba.g, rgba.b, Math.round(rgba.a * 255)];
+  }
+  return color;
+}
+
+/** Common base class for Page and Browser actions. */
+class PanelActionBase {
+  constructor(options, tabContext, extension) {
+    this.tabContext = tabContext;
+    this.extension = extension;
+
+    // These are always defined on the action
+    this.defaults = {
+      enabled: true,
+      title: options.default_title || extension.name,
+      popup: options.default_popup || "",
+      icon: null,
+    };
+    this.globals = Object.create(this.defaults);
+
+    // eslint-disable-next-line mozilla/balanced-listeners
+    this.tabContext.on("location-change", this.handleLocationChange.bind(this));
+
+    // eslint-disable-next-line mozilla/balanced-listeners
+    this.tabContext.on("tab-select", (evt, tab) => {
+      this.updateOnChange(tab);
+    });
+
+    // eslint-disable-next-line mozilla/balanced-listeners
+    extension.on("add-permissions", () => this.updateOnChange());
+    // eslint-disable-next-line mozilla/balanced-listeners
+    extension.on("remove-permissions", () => this.updateOnChange());
+    // eslint-disable-next-line mozilla/balanced-listeners
+    extension.on("update-ignore-quarantine", () => this.updateOnChange());
+
+    // When preloading a popup we temporarily grant active tab permissions to
+    // the preloaded popup. If we don't end up opening we need to clear this
+    // permission when clearing the popup.
+    this.activeTabForPreload = null;
+  }
+
+  onShutdown() {
+    this.tabContext.shutdown();
+  }
+
+  setPropertyFromDetails(details, prop, value) {
+    return this.setProperty(this.getTargetFromDetails(details), prop, value);
+  }
+
+  /**
+   * Set a global, window specific or tab specific property.
+   *
+   * @param {XULElement|ChromeWindow|null} target
+   *        A XULElement tab, a ChromeWindow, or null for the global data.
+   * @param {string} prop
+   *        String property to set. Should should be one of "icon", "title", "badgeText",
+   *        "popup", "badgeBackgroundColor", "badgeTextColor" or "enabled".
+   * @param {string} value
+   *        Value for prop.
+   * @returns {object}
+   *        The object to which the property has been set.
+   */
+  setProperty(target, prop, value) {
+    let values = this.getContextData(target);
+    if (value === null) {
+      delete values[prop];
+    } else {
+      values[prop] = value;
+    }
+
+    this.updateOnChange(target);
+    return values;
+  }
+
+  /**
+   * Gets the data associated with a tab, window, or the global one.
+   *
+   * @param {XULElement|ChromeWindow|null} target
+   *        A XULElement tab, a ChromeWindow, or null for the global data.
+   * @returns {object}
+   *        The icon, title, badge, etc. associated with the target.
+   */
+  getContextData(target) {
+    if (target) {
+      return this.tabContext.get(target);
+    }
+    return this.globals;
+  }
+
+  /**
+   * Retrieve the value of a global, window specific or tab specific property.
+   *
+   * @param {XULElement|ChromeWindow|null} target
+   *        A XULElement tab, a ChromeWindow, or null for the global data.
+   * @param {string} prop
+   *        Name of property to retrieve. Should should be one of "icon",
+   *        "title", "badgeText", "popup", "badgeBackgroundColor" or "enabled".
+   * @returns {any} value
+   *          Value of prop.
+   */
+  getProperty(target, prop) {
+    return this.getContextData(target)[prop];
+  }
+
+  getPropertyFromDetails(details, prop) {
+    return this.getProperty(this.getTargetFromDetails(details), prop);
+  }
+
+  enable(tabId) {
+    this.setPropertyFromDetails({ tabId }, "enabled", true);
+  }
+
+  disable(tabId) {
+    this.setPropertyFromDetails({ tabId }, "enabled", false);
+  }
+
+  getIcon(details = {}) {
+    return this.getPropertyFromDetails(details, "icon");
+  }
+
+  normalizeIcon(details, extension, context) {
+    let icon = IconDetails.normalize(details, extension, context);
+    if (!Object.keys(icon).length) {
+      return null;
+    }
+    return icon;
+  }
+
+  /**
+   * Updates the `tabData` for any location change, however it only updates the button
+   * when the selected tab has a location change, or the selected tab has changed.
+   *
+   * @param {string} eventType
+   *        The type of the event, should be "location-change".
+   * @param {XULElement} tab
+   *        The tab whose location changed, or which has become selected.
+   * @param {boolean} [fromBrowse]
+   *        - `true` if navigation occurred in `tab`.
+   *        - `false` if the location changed but no navigation occurred, e.g. due to
+               a hash change or `history.pushState`.
+   *        - Omitted if TabSelect has occurred, tabData does not need to be updated.
+   */
+  handleLocationChange(eventType, tab, fromBrowse) {
+    if (fromBrowse) {
+      this.tabContext.clear(tab);
+    }
+  }
+
+  /**
+   * Gets the popup url for a given tab.
+   *
+   * @param {XULElement} tab
+   *        The tab the popup refers to.
+   * @param {boolean} strict
+   *        If errors should be thrown if a URL is not available.
+   * @returns {string}
+   *        The popup URL if a popup is present, undefined otherwise.
+   */
+  getPopupUrl(tab, strict = false) {
+    if (!this.isShownForTab(tab)) {
+      if (strict) {
+        throw new ExtensionError("Popup is disabled");
+      }
+
+      return undefined;
+    }
+    let popupUrl = this.getProperty(tab, "popup");
+
+    if (strict && !popupUrl) {
+      throw new ExtensionError("No popup URL is set");
+    }
+
+    return popupUrl;
+  }
+
+  /**
+   * Grants activeTab permission for a tab when preloading the popup.
+   *
+   * Will clear any existing activeTab permissions previously granted for any
+   * other tab.
+   *
+   * @param {XULElement} tab
+   *        The tab that should be granted activeTab permission for. Set to
+   *        null to clear previously granted activeTab permission.
+   */
+  setActiveTabForPreload(tab = null) {
+    let oldTab = this.activeTabForPreload;
+    if (oldTab === tab) {
+      return;
+    }
+    this.activeTabForPreload = tab;
+    if (tab) {
+      this.extension.tabManager.addActiveTabPermission(tab);
+    }
+    if (oldTab) {
+      this.extension.tabManager.revokeActiveTabPermission(oldTab);
+    }
+  }
+
+  /**
+   * Triggers this action and sends the appropriate event if needed.
+   *
+   * @param {XULElement} tab
+   *        The tab on which the action was fired.
+   * @param {object} clickInfo
+   *        Extra data passed to the second parameter to the action API's
+   *        onClicked event.
+   * @returns {string}
+   *        the popup URL if a popup should be open, undefined otherwise.
+   */
+  triggerClickOrPopup(tab, clickInfo = undefined) {
+    if (!this.isShownForTab(tab)) {
+      return null;
+    }
+
+    // Now that the action is actually being triggered we can clear any
+    // existing preloaded activeTab permission.
+    this.setActiveTabForPreload(null);
+    this.extension.tabManager.addActiveTabPermission(tab);
+    this.extension.tabManager.activateScripts(tab);
+
+    let popupUrl = this.getProperty(tab, "popup");
+    // The "click" event is only dispatched when the popup is not shown. This
+    // is done for compatibility with the Google Chrome onClicked extension
+    // API.
+    if (!popupUrl) {
+      this.dispatchClick(tab, clickInfo);
+    }
+    this.updateOnChange(tab);
+    return popupUrl;
+  }
+
+  api(context) {
+    let { extension } = context;
+    return {
+      setTitle: details => {
+        this.setPropertyFromDetails(details, "title", details.title);
+      },
+      getTitle: details => {
+        return this.getPropertyFromDetails(details, "title");
+      },
+      setIcon: details => {
+        details.iconType = "browserAction";
+        this.setPropertyFromDetails(
+          details,
+          "icon",
+          this.normalizeIcon(details, extension, context)
+        );
+      },
+      setPopup: details => {
+        // Note: Chrome resolves arguments to setIcon relative to the calling
+        // context, but resolves arguments to setPopup relative to the extension
+        // root.
+        // For internal consistency, we currently resolve both relative to the
+        // calling context.
+        let url = details.popup && context.uri.resolve(details.popup);
+
+        if (url && !context.checkLoadURL(url)) {
+          return Promise.reject({ message: `Access denied for URL ${url}` });
+        }
+
+        // On manifest_version 3 is mandatory for the resolved URI to belong to the
+        // current extension (see Bug 1760608).
+        //
+        // The same restriction is extended  extend to MV2 extensions if the
+        // "extensions.manifestV2.actionsPopupURLRestricted" preference is set to true.
+        //
+        // (Currently set to true by default on GeckoView builds, where the set of
+        // extensions supported is limited to a small set and so less risks of
+        // unexpected regressions for the existing extensions).
+        if (
+          url &&
+          !url.startsWith(extension.baseURI.spec) &&
+          (context.extension.manifestVersion >= 3 ||
+            lazy.MV2_ACTION_POPURL_RESTRICTED)
+        ) {
+          return Promise.reject({ message: `Access denied for URL ${url}` });
+        }
+
+        this.setPropertyFromDetails(details, "popup", url);
+      },
+      getPopup: details => {
+        return this.getPropertyFromDetails(details, "popup");
+      },
+    };
+  }
+
+  // Override these
+
+  /**
+   * Update the toolbar button when the extension changes the icon, title, url, etc.
+   * If it only changes a parameter for a single tab, `target` will be that tab.
+   * If it only changes a parameter for a single window, `target` will be that window.
+   * Otherwise `target` will be null.
+   *
+   * @param {XULElement|ChromeWindow|null} target
+   *        Browser tab or browser chrome window, may be null.
+   */
+  updateOnChange(target) {}
+
+  /**
+   * Get tab object from tabId.
+   *
+   * @param {string} tabId
+   *        Internal id of the tab to get.
+   */
+  getTab(tabId) {}
+
+  /**
+   * Get window object from windowId
+   *
+   * @param {string} windowId
+   *        Internal id of the window to get.
+   */
+  getWindow(windowId) {}
+
+  /**
+   * Gets the target object corresponding to the `details` parameter of the various
+   * get* and set* API methods.
+   *
+   * @param {object} details
+   *        An object with optional `tabId` or `windowId` properties.
+   * @param {number} [details.tabId]
+   * @param {number} [details.windowId]
+   * @throws if both `tabId` and `windowId` are specified, or if they are invalid.
+   * @returns {XULElement|ChromeWindow|null}
+   *        If a `tabId` was specified, the corresponding XULElement tab.
+   *        If a `windowId` was specified, the corresponding ChromeWindow.
+   *        Otherwise, `null`.
+   */
+  getTargetFromDetails({ tabId, windowId }) {
+    return null;
+  }
+
+  /**
+   * Triggers a click event.
+   *
+   * @param {XULElement} tab
+   *        The tab where this event should be fired.
+   * @param {object} clickInfo
+   *        Extra data passed to the second parameter to the action API's
+   *        onClicked event.
+   */
+  dispatchClick(tab, clickInfo) {}
+
+  /**
+   * Checks whether this action is shown.
+   *
+   * @param {XULElement} tab
+   *        The tab to be checked
+   * @returns {boolean}
+   */
+  isShownForTab(tab) {
+    return false;
+  }
+}
+
+export class PageActionBase extends PanelActionBase {
+  constructor(tabContext, extension) {
+    const options = extension.manifest.page_action;
+    super(options, tabContext, extension);
+
+    // `enabled` can have three different values:
+    // - `false`. This means the page action is not shown.
+    //   It's set as default if show_matches is empty. Can also be set in a tab via
+    //   `pageAction.hide(tabId)`, e.g. in order to override show_matches.
+    // - `true`. This means the page action is shown.
+    //   It's never set as default because <all_urls> doesn't really match all URLs
+    //   (e.g. "about:" URLs). But can be set in a tab via `pageAction.show(tabId)`.
+    // - `undefined`.
+    //   This is the default value when there are some patterns in show_matches.
+    //   Can't be set as a tab-specific value.
+    let enabled, showMatches, hideMatches;
+    let show_matches = options.show_matches || [];
+    let hide_matches = options.hide_matches || [];
+    if (!show_matches.length) {
+      // Always hide by default. No need to do any pattern matching.
+      enabled = false;
+    } else {
+      // Might show or hide depending on the URL. Enable pattern matching.
+      const { restrictSchemes } = extension;
+      showMatches = new MatchPatternSet(show_matches, { restrictSchemes });
+      hideMatches = new MatchPatternSet(hide_matches, { restrictSchemes });
+    }
+
+    this.defaults = {
+      ...this.defaults,
+      enabled,
+      showMatches,
+      hideMatches,
+      pinned: options.pinned,
+    };
+    this.globals = Object.create(this.defaults);
+  }
+
+  handleLocationChange(eventType, tab, fromBrowse) {
+    super.handleLocationChange(eventType, tab, fromBrowse);
+    if (fromBrowse === false) {
+      // Clear pattern matching cache when URL changes.
+      let tabData = this.tabContext.get(tab);
+      if (tabData.patternMatching !== undefined) {
+        tabData.patternMatching = undefined;
+      }
+    }
+
+    if (tab.selected) {
+      // isShownForTab will do pattern matching (if necessary) and store the result
+      // so that updateButton knows whether the page action should be shown.
+      this.isShownForTab(tab);
+      this.updateOnChange(tab);
+    }
+  }
+
+  // Checks whether the tab action is shown when the specified tab becomes active.
+  // Does pattern matching if necessary, and caches the result as a tab-specific value.
+  // @param {XULElement} tab
+  //        The tab to be checked
+  // @return boolean
+  isShownForTab(tab) {
+    let tabData = this.getContextData(tab);
+
+    // If there is a "show" value, return it. Can be due to show(), hide() or empty show_matches.
+    if (tabData.enabled !== undefined) {
+      return tabData.enabled;
+    }
+
+    // Otherwise pattern matching must have been configured. Do it, caching the result.
+    if (tabData.patternMatching === undefined) {
+      let uri = tab.linkedBrowser.currentURI;
+      tabData.patternMatching =
+        tabData.showMatches.matches(uri) && !tabData.hideMatches.matches(uri);
+    }
+    return tabData.patternMatching;
+  }
+
+  async loadIconData() {
+    const { extension } = this;
+    const options = extension.manifest.page_action;
+    this.defaults.icon = await StartupCache.get(
+      extension,
+      ["pageAction", "default_icon"],
+      () =>
+        this.normalizeIcon(
+          { path: options.default_icon || "" },
+          extension,
+          null
+        )
+    );
+  }
+
+  getPinned() {
+    return this.globals.pinned;
+  }
+
+  getTargetFromDetails({ tabId, windowId }) {
+    // PageActionBase doesn't support |windowId|
+    if (tabId != null) {
+      return this.getTab(tabId);
+    }
+    return null;
+  }
+
+  api(context) {
+    return {
+      ...super.api(context),
+      show: (...args) => this.enable(...args),
+      hide: (...args) => this.disable(...args),
+      isShown: ({ tabId }) => {
+        let tab = this.getTab(tabId);
+        return this.isShownForTab(tab);
+      },
+    };
+  }
+}
+
+export class BrowserActionBase extends PanelActionBase {
+  constructor(tabContext, extension) {
+    const options =
+      extension.manifest.browser_action || extension.manifest.action;
+    super(options, tabContext, extension);
+
+    let default_area =
+      Services.policies?.getExtensionSettings(extension.id)?.default_area ||
+      options.default_area ||
+      "menupanel";
+
+    this.defaults = {
+      ...this.defaults,
+      badgeText: "",
+      badgeBackgroundColor: [0xd9, 0, 0, 255],
+      badgeDefaultColor: [255, 255, 255, 255],
+      badgeTextColor: null,
+      default_area,
+    };
+    this.globals = Object.create(this.defaults);
+  }
+
+  async loadIconData() {
+    const { extension } = this;
+    const options =
+      extension.manifest.browser_action || extension.manifest.action;
+    this.defaults.icon = await StartupCache.get(
+      extension,
+      ["browserAction", "default_icon"],
+      () =>
+        IconDetails.normalize(
+          {
+            path: options.default_icon || extension.manifest.icons,
+            iconType: "browserAction",
+            themeIcons: options.theme_icons,
+          },
+          extension
+        )
+    );
+  }
+
+  handleLocationChange(eventType, tab, fromBrowse) {
+    super.handleLocationChange(eventType, tab, fromBrowse);
+    if (fromBrowse) {
+      this.updateOnChange(tab);
+    }
+  }
+
+  getTargetFromDetails({ tabId, windowId }) {
+    if (tabId != null && windowId != null) {
+      throw new ExtensionError(
+        "Only one of tabId and windowId can be specified."
+      );
+    }
+    if (tabId != null) {
+      return this.getTab(tabId);
+    } else if (windowId != null) {
+      return this.getWindow(windowId);
+    }
+    return null;
+  }
+
+  getDefaultArea() {
+    return this.globals.default_area;
+  }
+
+  /**
+   * Determines the text badge color to be used in a tab, window, or globally.
+   *
+   * @param {object} values
+   *        The values associated with the tab or window, or global values.
+   * @returns {ColorArray}
+   */
+  getTextColor(values) {
+    // If a text color has been explicitly provided, use it.
+    let { badgeTextColor } = values;
+    if (badgeTextColor) {
+      return badgeTextColor;
+    }
+
+    // Otherwise, check if the default color to be used has been cached previously.
+    let { badgeDefaultColor } = values;
+    if (badgeDefaultColor) {
+      return badgeDefaultColor;
+    }
+
+    // Choose a color among white and black, maximizing contrast with background
+    // according to https://www.w3.org/TR/WCAG20-TECHS/G18.html#G18-procedure
+    let [r, g, b] = values.badgeBackgroundColor
+      .slice(0, 3)
+      .map(function (channel) {
+        channel /= 255;
+        if (channel <= 0.03928) {
+          return channel / 12.92;
+        }
+        return ((channel + 0.055) / 1.055) ** 2.4;
+      });
+    let lum = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+
+    // The luminance is 0 for black, 1 for white, and `lum` for the background color.
+    // Since `0 <= lum`, the contrast ratio for black is `c0 = (lum + 0.05) / 0.05`.
+    // Since `lum <= 1`, the contrast ratio for white is `c1 = 1.05 / (lum + 0.05)`.
+    // We want to maximize contrast, so black is chosen if `c1 < c0`, that is, if
+    // `1.05 * 0.05 < (L + 0.05) ** 2`. Otherwise white is chosen.
+    let channel = 1.05 * 0.05 < (lum + 0.05) ** 2 ? 0 : 255;
+    let result = [channel, channel, channel, 255];
+
+    // Cache the result as high as possible in the prototype chain
+    while (!Object.getOwnPropertyDescriptor(values, "badgeDefaultColor")) {
+      values = Object.getPrototypeOf(values);
+    }
+    values.badgeDefaultColor = result;
+    return result;
+  }
+
+  isShownForTab(tab) {
+    return this.getProperty(tab, "enabled");
+  }
+
+  api(context) {
+    return {
+      ...super.api(context),
+      enable: (...args) => this.enable(...args),
+      disable: (...args) => this.disable(...args),
+      isEnabled: details => {
+        return this.getPropertyFromDetails(details, "enabled");
+      },
+      setBadgeText: details => {
+        this.setPropertyFromDetails(details, "badgeText", details.text);
+      },
+      getBadgeText: details => {
+        return this.getPropertyFromDetails(details, "badgeText");
+      },
+      setBadgeBackgroundColor: details => {
+        let color = parseColor(details.color, "background");
+        let values = this.setPropertyFromDetails(
+          details,
+          "badgeBackgroundColor",
+          color
+        );
+        if (color === null) {
+          // Let the default text color inherit after removing background color
+          delete values.badgeDefaultColor;
+        } else {
+          // Invalidate a cached default color calculated with the old background
+          values.badgeDefaultColor = null;
+        }
+      },
+      getBadgeBackgroundColor: details => {
+        return this.getPropertyFromDetails(details, "badgeBackgroundColor");
+      },
+      setBadgeTextColor: details => {
+        let color = parseColor(details.color, "text");
+        this.setPropertyFromDetails(details, "badgeTextColor", color);
+      },
+      getBadgeTextColor: details => {
+        let target = this.getTargetFromDetails(details);
+        let values = this.getContextData(target);
+        return this.getTextColor(values);
+      },
+    };
+  }
+}