Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 791 insertions, 0 deletions

diff --git a/browser/components/ion/content/ion.js b/browser/components/ion/content/ion.js
new file mode 100644
index 0000000000..3c34328d58
--- /dev/null
+++ b/browser/components/ion/content/ion.js
@@ -0,0 +1,791 @@
+/* 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/. */
+
+/**
+ * Control panel for the Ion project, formerly known as Pioneer.
+ * This lives in `about:ion` and provides a UI for users to un/enroll in the
+ * overall program, and to un/enroll from individual studies.
+ *
+ * NOTE - prefs and Telemetry both still mention Pioneer for backwards-compatibility,
+ *        this may change in the future.
+ */
+
+const { AddonManager } = ChromeUtils.importESModule(
+  "resource://gre/modules/AddonManager.sys.mjs"
+);
+
+const { RemoteSettings } = ChromeUtils.importESModule(
+  "resource://services-settings/remote-settings.sys.mjs"
+);
+
+const { TelemetryController } = ChromeUtils.importESModule(
+  "resource://gre/modules/TelemetryController.sys.mjs"
+);
+
+let parserUtils = Cc["@mozilla.org/parserutils;1"].getService(
+  Ci.nsIParserUtils
+);
+
+const PREF_ION_ID = "toolkit.telemetry.pioneerId";
+const PREF_ION_NEW_STUDIES_AVAILABLE =
+  "toolkit.telemetry.pioneer-new-studies-available";
+const PREF_ION_COMPLETED_STUDIES =
+  "toolkit.telemetry.pioneer-completed-studies";
+
+/**
+ * Remote Settings keys for general content, and available studies.
+ */
+const CONTENT_COLLECTION_KEY = "pioneer-content-v2";
+const STUDY_ADDON_COLLECTION_KEY = "pioneer-study-addons-v2";
+
+const STUDY_LEAVE_REASONS = {
+  USER_ABANDONED: "user-abandoned",
+  STUDY_ENDED: "study-ended",
+};
+
+const PREF_TEST_CACHED_CONTENT = "toolkit.pioneer.testCachedContent";
+const PREF_TEST_CACHED_ADDONS = "toolkit.pioneer.testCachedAddons";
+const PREF_TEST_ADDONS = "toolkit.pioneer.testAddons";
+
+/**
+ * Use the in-tree HTML Sanitizer to ensure that HTML from remote-settings is safe to use.
+ * Note that RS does use content-signing, we're doing this extra step as an in-depth security measure.
+ *
+ * @param {string} htmlString - unsanitized HTML (content-signed by remote-settings)
+ * @returns {DocumentFragment} - sanitized DocumentFragment
+ */
+function sanitizeHtml(htmlString) {
+  const content = document.createElement("div");
+  const contentFragment = parserUtils.parseFragment(
+    htmlString,
+    Ci.nsIParserUtils.SanitizerDropForms |
+      Ci.nsIParserUtils.SanitizerAllowStyle |
+      Ci.nsIParserUtils.SanitizerLogRemovals,
+    false,
+    Services.io.newURI("about:ion"),
+    content
+  );
+
+  return contentFragment;
+}
+
+function showEnrollmentStatus() {
+  const ionId = Services.prefs.getStringPref(PREF_ION_ID, null);
+
+  const enrollmentButton = document.getElementById("enrollment-button");
+
+  document.l10n.setAttributes(
+    enrollmentButton,
+    `ion-${ionId ? "un" : ""}enrollment-button`
+  );
+  enrollmentButton.classList.toggle("primary", !ionId);
+
+  // collapse content above the fold if enrolled, otherwise open it.
+  for (const section of ["details", "data"]) {
+    const details = document.getElementById(section);
+    if (ionId) {
+      details.removeAttribute("open");
+    } else {
+      details.setAttribute("open", true);
+    }
+  }
+}
+
+function toggleContentBasedOnLocale() {
+  const requestedLocale = Services.locale.requestedLocale;
+  if (requestedLocale !== "en-US") {
+    const localeNotificationBar = document.getElementById(
+      "locale-notification"
+    );
+    localeNotificationBar.style.display = "block";
+
+    const reportContent = document.getElementById("report-content");
+    reportContent.style.display = "none";
+  }
+}
+
+async function toggleEnrolled(studyAddonId, cachedAddons) {
+  let addon;
+  let install;
+
+  const cachedAddon = cachedAddons.find(a => a.addon_id == studyAddonId);
+
+  if (Cu.isInAutomation) {
+    install = {
+      install: async () => {
+        let testAddons = Services.prefs.getStringPref(PREF_TEST_ADDONS, "[]");
+        testAddons = JSON.parse(testAddons);
+
+        testAddons.push(studyAddonId);
+        Services.prefs.setStringPref(
+          PREF_TEST_ADDONS,
+          JSON.stringify(testAddons)
+        );
+      },
+    };
+
+    let testAddons = Services.prefs.getStringPref(PREF_TEST_ADDONS, "[]");
+    testAddons = JSON.parse(testAddons);
+
+    for (const testAddon of testAddons) {
+      if (testAddon == studyAddonId) {
+        addon = {};
+        addon.uninstall = () => {
+          Services.prefs.setStringPref(
+            PREF_TEST_ADDONS,
+            JSON.stringify(testAddons.filter(a => a.id != testAddon.id))
+          );
+        };
+      }
+    }
+  } else {
+    addon = await AddonManager.getAddonByID(studyAddonId);
+    install = await AddonManager.getInstallForURL(cachedAddon.sourceURI.spec);
+  }
+
+  const completedStudies = Services.prefs.getStringPref(
+    PREF_ION_COMPLETED_STUDIES,
+    "{}"
+  );
+
+  const study = document.querySelector(`.card[id="${cachedAddon.addon_id}"`);
+  const joinBtn = study.querySelector(".join-button");
+
+  if (addon) {
+    joinBtn.disabled = true;
+    await addon.uninstall();
+    await sendDeletionPing(studyAddonId);
+
+    document.l10n.setAttributes(joinBtn, "ion-join-study");
+    joinBtn.disabled = false;
+
+    // Record that the user abandoned this study, since it may not be re-join-able.
+    if (completedStudies) {
+      const studies = JSON.parse(completedStudies);
+      studies[studyAddonId] = STUDY_LEAVE_REASONS.USER_ABANDONED;
+      Services.prefs.setStringPref(
+        PREF_ION_COMPLETED_STUDIES,
+        JSON.stringify(studies)
+      );
+    }
+  } else {
+    // Check if this study is re-join-able before enrollment.
+    const studies = JSON.parse(completedStudies);
+    if (studyAddonId in studies) {
+      if (
+        "canRejoin" in cachedAddons[studyAddonId] &&
+        cachedAddons[studyAddonId].canRejoin === false
+      ) {
+        console.error(
+          `Cannot rejoin ended study ${studyAddonId}, reason: ${studies[studyAddonId]}`
+        );
+        return;
+      }
+    }
+    joinBtn.disabled = true;
+    await install.install();
+    document.l10n.setAttributes(joinBtn, "ion-leave-study");
+    joinBtn.disabled = false;
+
+    // Send an enrollment ping for this study. Note that this could be sent again
+    // if we are re-joining.
+    await sendEnrollmentPing(studyAddonId);
+  }
+
+  await updateStudy(cachedAddon.addon_id);
+}
+
+async function showAvailableStudies(cachedAddons) {
+  const ionId = Services.prefs.getStringPref(PREF_ION_ID, null);
+  const defaultAddons = cachedAddons.filter(a => a.isDefault);
+  if (ionId) {
+    for (const defaultAddon of defaultAddons) {
+      let addon;
+      let install;
+      if (Cu.isInAutomation) {
+        install = {
+          install: async () => {
+            if (
+              defaultAddon.addon_id == "ion-v2-bad-default-example@mozilla.org"
+            ) {
+              throw new Error("Bad test default add-on");
+            }
+          },
+        };
+      } else {
+        addon = await AddonManager.getAddonByID(defaultAddon.addon_id);
+        install = await AddonManager.getInstallForURL(
+          defaultAddon.sourceURI.spec
+        );
+      }
+
+      if (!addon) {
+        // Any default add-ons are required, try to reinstall.
+        await install.install();
+      }
+    }
+  }
+
+  const studyAddons = cachedAddons.filter(a => !a.isDefault);
+  for (const cachedAddon of studyAddons) {
+    if (!cachedAddon) {
+      console.error(
+        `about:ion - Study addon ID not found in cache: ${studyAddonId}`
+      );
+      return;
+    }
+
+    const studyAddonId = cachedAddon.addon_id;
+
+    const study = document.createElement("div");
+    study.setAttribute("id", studyAddonId);
+    study.setAttribute("class", "card card-no-hover");
+
+    if (cachedAddon.icons && 32 in cachedAddon.icons) {
+      const iconName = document.createElement("img");
+      iconName.setAttribute("class", "card-icon");
+      iconName.setAttribute("src", cachedAddon.icons[32]);
+      study.appendChild(iconName);
+    }
+
+    const studyBody = document.createElement("div");
+    studyBody.classList.add("card-body");
+    study.appendChild(studyBody);
+
+    const studyName = document.createElement("h3");
+    studyName.setAttribute("class", "card-name");
+    studyName.textContent = cachedAddon.name;
+    studyBody.appendChild(studyName);
+
+    const studyAuthor = document.createElement("span");
+    studyAuthor.setAttribute("class", "card-author");
+    studyAuthor.textContent = cachedAddon.authors.name;
+    studyBody.appendChild(studyAuthor);
+
+    const actions = document.createElement("div");
+    actions.classList.add("card-actions");
+    study.appendChild(actions);
+
+    const joinBtn = document.createElement("button");
+    joinBtn.setAttribute("id", `${studyAddonId}-join-button`);
+    joinBtn.classList.add("primary");
+    joinBtn.classList.add("join-button");
+    document.l10n.setAttributes(joinBtn, "ion-join-study");
+
+    joinBtn.addEventListener("click", async () => {
+      let addon;
+      if (Cu.isInAutomation) {
+        const testAddons = Services.prefs.getStringPref(PREF_TEST_ADDONS, "[]");
+        for (const testAddon of JSON.parse(testAddons)) {
+          if (testAddon == studyAddonId) {
+            addon = {};
+            addon.uninstall = () => {
+              Services.prefs.setStringPref(PREF_TEST_ADDONS, "[]");
+            };
+          }
+        }
+      } else {
+        addon = await AddonManager.getAddonByID(studyAddonId);
+      }
+      let joinOrLeave = addon ? "leave" : "join";
+      let dialog = document.getElementById(
+        `${joinOrLeave}-study-consent-dialog`
+      );
+      dialog.setAttribute("addon-id", cachedAddon.addon_id);
+      const consentText = dialog.querySelector(
+        `[id=${joinOrLeave}-study-consent]`
+      );
+
+      // Clears out any existing children with a single #text node
+      consentText.textContent = "";
+
+      const contentFragment = sanitizeHtml(
+        cachedAddon[`${joinOrLeave}StudyConsent`]
+      );
+      consentText.appendChild(contentFragment);
+
+      dialog.showModal();
+      dialog.scrollTop = 0;
+
+      const openEvent = new Event("open");
+      dialog.dispatchEvent(openEvent);
+    });
+    actions.appendChild(joinBtn);
+
+    const studyDesc = document.createElement("div");
+    studyDesc.setAttribute("class", "card-description");
+
+    const contentFragment = sanitizeHtml(cachedAddon.description);
+    studyDesc.appendChild(contentFragment);
+
+    study.appendChild(studyDesc);
+
+    const studyDataCollected = document.createElement("div");
+    studyDataCollected.setAttribute("class", "card-data-collected");
+    study.appendChild(studyDataCollected);
+
+    const dataCollectionDetailsHeader = document.createElement("p");
+    dataCollectionDetailsHeader.textContent = "This study will collect:";
+    studyDataCollected.appendChild(dataCollectionDetailsHeader);
+
+    const dataCollectionDetails = document.createElement("ul");
+    for (const dataCollectionDetail of cachedAddon.dataCollectionDetails) {
+      const detailsBullet = document.createElement("li");
+      detailsBullet.textContent = dataCollectionDetail;
+      dataCollectionDetails.append(detailsBullet);
+    }
+    studyDataCollected.appendChild(dataCollectionDetails);
+
+    const availableStudies = document.getElementById("available-studies");
+    availableStudies.appendChild(study);
+
+    await updateStudy(studyAddonId);
+  }
+
+  const availableStudies = document.getElementById("header-available-studies");
+  document.l10n.setAttributes(availableStudies, "ion-current-studies");
+}
+
+async function updateStudy(studyAddonId) {
+  let addon;
+  if (Cu.isInAutomation) {
+    const testAddons = Services.prefs.getStringPref(PREF_TEST_ADDONS, "[]");
+    for (const testAddon of JSON.parse(testAddons)) {
+      if (testAddon == studyAddonId) {
+        addon = {
+          uninstall() {},
+        };
+      }
+    }
+  } else {
+    addon = await AddonManager.getAddonByID(studyAddonId);
+  }
+
+  const study = document.querySelector(`.card[id="${studyAddonId}"`);
+
+  const joinBtn = study.querySelector(".join-button");
+
+  const ionId = Services.prefs.getStringPref(PREF_ION_ID, null);
+
+  const completedStudies = Services.prefs.getStringPref(
+    PREF_ION_COMPLETED_STUDIES,
+    "{}"
+  );
+
+  const studies = JSON.parse(completedStudies);
+  if (studyAddonId in studies) {
+    study.style.opacity = 0.5;
+    joinBtn.disabled = true;
+    document.l10n.setAttributes(joinBtn, "ion-ended-study");
+    return;
+  }
+
+  if (ionId) {
+    study.style.opacity = 1;
+    joinBtn.disabled = false;
+
+    if (addon) {
+      document.l10n.setAttributes(joinBtn, "ion-leave-study");
+    } else {
+      document.l10n.setAttributes(joinBtn, "ion-join-study");
+    }
+  } else {
+    document.l10n.setAttributes(joinBtn, "ion-study-prompt");
+    study.style.opacity = 0.5;
+    joinBtn.disabled = true;
+  }
+}
+
+// equivalent to what we use for Telemetry IDs
+// https://searchfox.org/mozilla-central/rev/9193635dca8cfdcb68f114306194ffc860456044/toolkit/components/telemetry/app/TelemetryUtils.jsm#222
+function generateUUID() {
+  let str = Services.uuid.generateUUID().toString();
+  return str.substring(1, str.length - 1);
+}
+
+async function setup(cachedAddons) {
+  document
+    .getElementById("enrollment-button")
+    .addEventListener("click", async () => {
+      const ionId = Services.prefs.getStringPref(PREF_ION_ID, null);
+
+      if (ionId) {
+        let dialog = document.getElementById("leave-ion-consent-dialog");
+        dialog.showModal();
+        dialog.scrollTop = 0;
+      } else {
+        let dialog = document.getElementById("join-ion-consent-dialog");
+        dialog.showModal();
+        dialog.scrollTop = 0;
+      }
+    });
+
+  document
+    .getElementById("join-ion-cancel-dialog-button")
+    .addEventListener("click", () =>
+      document.getElementById("join-ion-consent-dialog").close()
+    );
+  document
+    .getElementById("leave-ion-cancel-dialog-button")
+    .addEventListener("click", () =>
+      document.getElementById("leave-ion-consent-dialog").close()
+    );
+  document
+    .getElementById("join-study-cancel-dialog-button")
+    .addEventListener("click", () =>
+      document.getElementById("join-study-consent-dialog").close()
+    );
+  document
+    .getElementById("leave-study-cancel-dialog-button")
+    .addEventListener("click", () =>
+      document.getElementById("leave-study-consent-dialog").close()
+    );
+
+  document
+    .getElementById("join-ion-accept-dialog-button")
+    .addEventListener("click", async event => {
+      const ionId = Services.prefs.getStringPref(PREF_ION_ID, null);
+
+      if (!ionId) {
+        let uuid = generateUUID();
+        Services.prefs.setStringPref(PREF_ION_ID, uuid);
+        for (const cachedAddon of cachedAddons) {
+          if (cachedAddon.isDefault) {
+            let install;
+            if (Cu.isInAutomation) {
+              install = {
+                install: async () => {
+                  if (
+                    cachedAddon.addon_id ==
+                    "ion-v2-bad-default-example@mozilla.org"
+                  ) {
+                    throw new Error("Bad test default add-on");
+                  }
+                },
+              };
+            } else {
+              install = await AddonManager.getInstallForURL(
+                cachedAddon.sourceURI.spec
+              );
+            }
+
+            try {
+              await install.install();
+            } catch (ex) {
+              // No need to throw here, we'll try again before letting users enroll in any studies.
+              console.error(
+                `Could not install default add-on ${cachedAddon.addon_id}`
+              );
+              const availableStudies =
+                document.getElementById("available-studies");
+              document.l10n.setAttributes(
+                availableStudies,
+                "ion-no-current-studies"
+              );
+            }
+          }
+          const study = document.getElementById(cachedAddon.addon_id);
+          if (study) {
+            await updateStudy(cachedAddon.addon_id);
+          }
+        }
+        document.querySelector("dialog").close();
+      }
+      // A this point we should have a valid ion id, so we should be able to send
+      // the enrollment ping.
+      await sendEnrollmentPing();
+
+      showEnrollmentStatus();
+    });
+
+  document
+    .getElementById("leave-ion-accept-dialog-button")
+    .addEventListener("click", async event => {
+      const completedStudies = Services.prefs.getStringPref(
+        PREF_ION_COMPLETED_STUDIES,
+        "{}"
+      );
+      const studies = JSON.parse(completedStudies);
+
+      // Send a deletion ping for all completed studies the user has been a part of.
+      for (const studyAddonId in studies) {
+        await sendDeletionPing(studyAddonId);
+      }
+
+      Services.prefs.clearUserPref(PREF_ION_COMPLETED_STUDIES);
+
+      for (const cachedAddon of cachedAddons) {
+        // Record any studies that have been marked as concluded on the server, in case they re-enroll.
+        if ("studyEnded" in cachedAddon && cachedAddon.studyEnded === true) {
+          studies[cachedAddon.addon_id] = STUDY_LEAVE_REASONS.STUDY_ENDED;
+
+          Services.prefs.setStringPref(
+            PREF_ION_COMPLETED_STUDIES,
+            JSON.stringify(studies)
+          );
+        }
+
+        let addon;
+        if (Cu.isInAutomation) {
+          addon = {};
+          addon.id = cachedAddon.addon_id;
+          addon.uninstall = () => {
+            let testAddons = Services.prefs.getStringPref(
+              PREF_TEST_ADDONS,
+              "[]"
+            );
+            testAddons = JSON.parse(testAddons);
+
+            Services.prefs.setStringPref(
+              PREF_TEST_ADDONS,
+              JSON.stringify(
+                testAddons.filter(a => a.id != cachedAddon.addon_id)
+              )
+            );
+          };
+        } else {
+          addon = await AddonManager.getAddonByID(cachedAddon.addon_id);
+        }
+        if (addon) {
+          await sendDeletionPing(addon.id);
+          await addon.uninstall();
+        }
+      }
+
+      Services.prefs.clearUserPref(PREF_ION_ID);
+      for (const cachedAddon of cachedAddons) {
+        const study = document.getElementById(cachedAddon.addon_id);
+        if (study) {
+          await updateStudy(cachedAddon.addon_id);
+        }
+      }
+
+      document.getElementById("leave-ion-consent-dialog").close();
+      showEnrollmentStatus();
+    });
+
+  document
+    .getElementById("join-study-accept-dialog-button")
+    .addEventListener("click", async event => {
+      const dialog = document.getElementById("join-study-consent-dialog");
+      const studyAddonId = dialog.getAttribute("addon-id");
+      toggleEnrolled(studyAddonId, cachedAddons).then(dialog.close());
+    });
+
+  document
+    .getElementById("leave-study-accept-dialog-button")
+    .addEventListener("click", async event => {
+      const dialog = document.getElementById("leave-study-consent-dialog");
+      const studyAddonId = dialog.getAttribute("addon-id");
+      await toggleEnrolled(studyAddonId, cachedAddons).then(dialog.close());
+    });
+
+  const onAddonEvent = async addon => {
+    for (const cachedAddon of cachedAddons) {
+      if (cachedAddon.addon_id == addon.id) {
+        await updateStudy(addon.id);
+      }
+    }
+  };
+
+  const addonsListener = {
+    onEnabled: onAddonEvent,
+    onDisabled: onAddonEvent,
+    onInstalled: onAddonEvent,
+    onUninstalled: onAddonEvent,
+  };
+  AddonManager.addAddonListener(addonsListener);
+
+  window.addEventListener("unload", event => {
+    AddonManager.removeAddonListener(addonsListener);
+  });
+}
+
+function removeBadge() {
+  Services.prefs.setBoolPref(PREF_ION_NEW_STUDIES_AVAILABLE, false);
+
+  for (let win of Services.wm.getEnumerator("navigator:browser")) {
+    const badge = win.document
+      .getElementById("ion-button")
+      .querySelector(".toolbarbutton-badge");
+    badge.classList.remove("feature-callout");
+  }
+}
+
+// Updates Ion HTML page contents from RemoteSettings.
+function updateContents(contents) {
+  for (const section of [
+    "title",
+    "summary",
+    "details",
+    "data",
+    "joinIonConsent",
+    "leaveIonConsent",
+  ]) {
+    if (contents && section in contents) {
+      // Generate a corresponding dom-id style ID for a camel-case domId style JS attribute.
+      // Dynamically set the tag type based on which section is getting updated.
+      const domId = section
+        .split(/(?=[A-Z])/)
+        .join("-")
+        .toLowerCase();
+      // Clears out any existing children with a single #text node.
+      document.getElementById(domId).textContent = "";
+
+      const contentFragment = sanitizeHtml(contents[section]);
+      document.getElementById(domId).appendChild(contentFragment);
+    }
+  }
+}
+
+document.addEventListener("DOMContentLoaded", async domEvent => {
+  toggleContentBasedOnLocale();
+
+  showEnrollmentStatus();
+
+  document.addEventListener("focus", removeBadge);
+  removeBadge();
+
+  const privacyPolicyLinks = document.querySelectorAll(
+    ".privacy-policy,.privacy-notice"
+  );
+  for (const privacyPolicyLink of privacyPolicyLinks) {
+    const privacyPolicyFormattedLink = Services.urlFormatter.formatURL(
+      privacyPolicyLink.href
+    );
+    privacyPolicyLink.href = privacyPolicyFormattedLink;
+  }
+
+  let cachedContent;
+  let cachedAddons;
+  if (Cu.isInAutomation) {
+    let testCachedAddons = Services.prefs.getStringPref(
+      PREF_TEST_CACHED_ADDONS,
+      null
+    );
+    if (testCachedAddons) {
+      cachedAddons = JSON.parse(testCachedAddons);
+    }
+
+    let testCachedContent = Services.prefs.getStringPref(
+      PREF_TEST_CACHED_CONTENT,
+      null
+    );
+    if (testCachedContent) {
+      cachedContent = JSON.parse(testCachedContent);
+    }
+  } else {
+    cachedContent = await RemoteSettings(CONTENT_COLLECTION_KEY).get();
+    cachedAddons = await RemoteSettings(STUDY_ADDON_COLLECTION_KEY).get();
+  }
+
+  // Replace existing contents immediately on page load.
+  for (const contents of cachedContent) {
+    updateContents(contents);
+  }
+
+  for (const cachedAddon of cachedAddons) {
+    // Record any studies that have been marked as concluded on the server.
+    if ("studyEnded" in cachedAddon && cachedAddon.studyEnded === true) {
+      const completedStudies = Services.prefs.getStringPref(
+        PREF_ION_COMPLETED_STUDIES,
+        "{}"
+      );
+      const studies = JSON.parse(completedStudies);
+      studies[cachedAddon.addon_id] = STUDY_LEAVE_REASONS.STUDY_ENDED;
+
+      Services.prefs.setStringPref(
+        PREF_ION_COMPLETED_STUDIES,
+        JSON.stringify(studies)
+      );
+    }
+  }
+
+  await setup(cachedAddons);
+
+  try {
+    await showAvailableStudies(cachedAddons);
+  } catch (ex) {
+    // No need to throw here, we'll try again before letting users enroll in any studies.
+    console.error(`Could not show available studies`, ex);
+  }
+});
+
+async function sendDeletionPing(studyAddonId) {
+  const type = "pioneer-study";
+
+  const options = {
+    studyName: studyAddonId,
+    addPioneerId: true,
+    useEncryption: true,
+    // NOTE - while we're not actually sending useful data in this payload, the current Pioneer v2 Telemetry
+    // pipeline requires that pings are shaped this way so they are routed to the correct environment.
+    //
+    // At the moment, the public key used here isn't important but we do need to use *something*.
+    encryptionKeyId: "discarded",
+    publicKey: {
+      crv: "P-256",
+      kty: "EC",
+      x: "XLkI3NaY3-AF2nRMspC63BT1u0Y3moXYSfss7VuQ0mk",
+      y: "SB0KnIW-pqk85OIEYZenoNkEyOOp5GeWQhS1KeRtEUE",
+    },
+    schemaName: "deletion-request",
+    schemaVersion: 1,
+    // The schema namespace needs to be the study addon id, as we
+    // want to route the ping to the specific study table.
+    schemaNamespace: studyAddonId,
+  };
+
+  const payload = {
+    encryptedData: "",
+  };
+
+  await TelemetryController.submitExternalPing(type, payload, options);
+}
+
+/**
+ * Sends a Pioneer enrollment ping.
+ *
+ * The `creationDate` provided by the telemetry APIs will be used as the timestamp for
+ * considering the user enrolled in pioneer and/or the study.
+ *
+ * @param {string} [studyAddonId] - optional study id. It's sent in the ping, if present,
+ * to signal that user enroled in the study.
+ */
+async function sendEnrollmentPing(studyAddonId) {
+  let options = {
+    studyName: "pioneer-meta",
+    addPioneerId: true,
+    useEncryption: true,
+    // NOTE - while we're not actually sending useful data in this payload, the current Pioneer v2 Telemetry
+    // pipeline requires that pings are shaped this way so they are routed to the correct environment.
+    //
+    // At the moment, the public key used here isn't important but we do need to use *something*.
+    encryptionKeyId: "discarded",
+    publicKey: {
+      crv: "P-256",
+      kty: "EC",
+      x: "XLkI3NaY3-AF2nRMspC63BT1u0Y3moXYSfss7VuQ0mk",
+      y: "SB0KnIW-pqk85OIEYZenoNkEyOOp5GeWQhS1KeRtEUE",
+    },
+    schemaName: "pioneer-enrollment",
+    schemaVersion: 1,
+    // Note that the schema namespace directly informs how data is segregated after ingestion.
+    // If this is an enrollment ping for the pioneer program (in contrast to the enrollment to
+    // a specific study), use a meta namespace.
+    schemaNamespace: "pioneer-meta",
+  };
+
+  // If we were provided with a study id, then this is an enrollment to a study.
+  // Send the id alongside with the data and change the schema namespace to simplify
+  // the work on the ingestion pipeline.
+  if (typeof studyAddonId != "undefined") {
+    options.studyName = studyAddonId;
+    // The schema namespace needs to be the study addon id, as we
+    // want to route the ping to the specific study table.
+    options.schemaNamespace = studyAddonId;
+  }
+
+  await TelemetryController.submitExternalPing("pioneer-study", {}, options);
+}