summaryrefslogtreecommitdiffstats
path: root/toolkit/profile/xpcshell/head.js
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /toolkit/profile/xpcshell/head.js
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'toolkit/profile/xpcshell/head.js')
-rw-r--r--toolkit/profile/xpcshell/head.js616
1 files changed, 616 insertions, 0 deletions
diff --git a/toolkit/profile/xpcshell/head.js b/toolkit/profile/xpcshell/head.js
new file mode 100644
index 0000000000..9c41a36078
--- /dev/null
+++ b/toolkit/profile/xpcshell/head.js
@@ -0,0 +1,616 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
+const { FileUtils } = ChromeUtils.importESModule(
+ "resource://gre/modules/FileUtils.sys.mjs"
+);
+const { AppConstants } = ChromeUtils.importESModule(
+ "resource://gre/modules/AppConstants.sys.mjs"
+);
+const { TelemetryTestUtils } = ChromeUtils.importESModule(
+ "resource://testing-common/TelemetryTestUtils.sys.mjs"
+);
+
+const NS_ERROR_START_PROFILE_MANAGER = 0x805800c9;
+
+const UPDATE_CHANNEL = AppConstants.MOZ_UPDATE_CHANNEL;
+
+let gProfD = do_get_profile();
+let gDataHome = gProfD.clone();
+gDataHome.append("data");
+gDataHome.createUnique(Ci.nsIFile.DIRECTORY_TYPE, 0o755);
+let gDataHomeLocal = gProfD.clone();
+gDataHomeLocal.append("local");
+gDataHomeLocal.createUnique(Ci.nsIFile.DIRECTORY_TYPE, 0o755);
+
+let xreDirProvider = Cc["@mozilla.org/xre/directory-provider;1"].getService(
+ Ci.nsIXREDirProvider
+);
+xreDirProvider.setUserDataDirectory(gDataHome, false);
+xreDirProvider.setUserDataDirectory(gDataHomeLocal, true);
+
+let gIsDefaultApp = false;
+
+const ShellService = {
+ register() {
+ let registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
+
+ let factory = {
+ createInstance(iid) {
+ return ShellService.QueryInterface(iid);
+ },
+ };
+
+ registrar.registerFactory(
+ this.ID,
+ "ToolkitShellService",
+ this.CONTRACT,
+ factory
+ );
+ },
+
+ isDefaultApplication() {
+ return gIsDefaultApp;
+ },
+
+ QueryInterface: ChromeUtils.generateQI(["nsIToolkitShellService"]),
+ ID: Components.ID("{ce724e0c-ed70-41c9-ab31-1033b0b591be}"),
+ CONTRACT: "@mozilla.org/toolkit/shell-service;1",
+};
+
+ShellService.register();
+
+let gIsLegacy = false;
+
+function enableLegacyProfiles() {
+ Services.env.set("MOZ_LEGACY_PROFILES", "1");
+
+ gIsLegacy = true;
+}
+
+function getProfileService() {
+ return Cc["@mozilla.org/toolkit/profile-service;1"].getService(
+ Ci.nsIToolkitProfileService
+ );
+}
+
+let PROFILE_DEFAULT = "default";
+let DEDICATED_NAME = `default-${UPDATE_CHANNEL}`;
+if (AppConstants.MOZ_DEV_EDITION) {
+ DEDICATED_NAME = PROFILE_DEFAULT = "dev-edition-default";
+}
+
+// Shared data for backgroundtasks tests.
+const BACKGROUNDTASKS_PROFILE_DATA = (() => {
+ let hash = xreDirProvider.getInstallHash();
+ let profileData = {
+ options: {
+ startWithLastProfile: true,
+ },
+ profiles: [
+ {
+ name: "Profile1",
+ path: "Path1",
+ default: false,
+ },
+ {
+ name: "Profile3",
+ path: "Path3",
+ default: false,
+ },
+ ],
+ installs: {
+ [hash]: {
+ default: "Path1",
+ },
+ },
+ backgroundTasksProfiles: [
+ {
+ name: `MozillaBackgroundTask-${hash}-unrelated_task`,
+ path: `saltsalt.MozillaBackgroundTask-${hash}-unrelated_task`,
+ },
+ ],
+ };
+ return profileData;
+})();
+
+/**
+ * Creates a random profile path for use.
+ */
+function makeRandomProfileDir(name) {
+ let file = gDataHome.clone();
+ file.append(name);
+ file.createUnique(Ci.nsIFile.DIRECTORY_TYPE, 0o755);
+ return file;
+}
+
+/**
+ * A wrapper around nsIToolkitProfileService.selectStartupProfile to make it
+ * a bit nicer to use from JS.
+ */
+function selectStartupProfile(args = [], isResetting = false, legacyHash = "") {
+ let service = getProfileService();
+ let rootDir = {};
+ let localDir = {};
+ let profile = {};
+ let didCreate = service.selectStartupProfile(
+ ["xpcshell", ...args],
+ isResetting,
+ UPDATE_CHANNEL,
+ legacyHash,
+ rootDir,
+ localDir,
+ profile
+ );
+
+ if (profile.value) {
+ Assert.ok(
+ rootDir.value.equals(profile.value.rootDir),
+ "Should have matched the root dir."
+ );
+ Assert.ok(
+ localDir.value.equals(profile.value.localDir),
+ "Should have matched the local dir."
+ );
+ Assert.ok(
+ service.currentProfile === profile.value,
+ "Should have marked the profile as the current profile."
+ );
+ } else {
+ Assert.ok(!service.currentProfile, "Should be no current profile.");
+ }
+
+ return {
+ rootDir: rootDir.value,
+ localDir: localDir.value,
+ profile: profile.value,
+ didCreate,
+ };
+}
+
+function testStartsProfileManager(args = [], isResetting = false) {
+ try {
+ selectStartupProfile(args, isResetting);
+ Assert.ok(false, "Should have started the profile manager");
+ checkStartupReason();
+ } catch (e) {
+ Assert.equal(
+ e.result,
+ NS_ERROR_START_PROFILE_MANAGER,
+ "Should have started the profile manager"
+ );
+ }
+}
+
+function safeGet(ini, section, key) {
+ try {
+ return ini.getString(section, key);
+ } catch (e) {
+ return null;
+ }
+}
+
+/**
+ * Writes a compatibility.ini file that marks the give profile directory as last
+ * used by the given install path.
+ */
+function writeCompatibilityIni(
+ dir,
+ appDir = FileUtils.getDir("CurProcD", []),
+ greDir = FileUtils.getDir("GreD", [])
+) {
+ let target = dir.clone();
+ target.append("compatibility.ini");
+
+ let factory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"].getService(
+ Ci.nsIINIParserFactory
+ );
+ let ini = factory.createINIParser().QueryInterface(Ci.nsIINIParserWriter);
+
+ // The profile service doesn't care about these so just use fixed values
+ ini.setString(
+ "Compatibility",
+ "LastVersion",
+ "64.0a1_20180919123806/20180919123806"
+ );
+ ini.setString("Compatibility", "LastOSABI", "Darwin_x86_64-gcc3");
+
+ ini.setString(
+ "Compatibility",
+ "LastPlatformDir",
+ greDir.persistentDescriptor
+ );
+ ini.setString("Compatibility", "LastAppDir", appDir.persistentDescriptor);
+
+ ini.writeFile(target);
+}
+
+/**
+ * Writes a profiles.ini based on the passed profile data.
+ * profileData should contain two properties, options and profiles.
+ * options contains a single property, startWithLastProfile.
+ * profiles is an array of profiles each containing name, path and default
+ * properties.
+ */
+function writeProfilesIni(profileData) {
+ let target = gDataHome.clone();
+ target.append("profiles.ini");
+
+ let factory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"].getService(
+ Ci.nsIINIParserFactory
+ );
+ let ini = factory.createINIParser().QueryInterface(Ci.nsIINIParserWriter);
+
+ const {
+ options = {},
+ profiles = [],
+ installs = null,
+ backgroundTasksProfiles = null,
+ } = profileData;
+
+ let { startWithLastProfile = true } = options;
+ ini.setString(
+ "General",
+ "StartWithLastProfile",
+ startWithLastProfile ? "1" : "0"
+ );
+
+ for (let i = 0; i < profiles.length; i++) {
+ let profile = profiles[i];
+ let section = `Profile${i}`;
+
+ ini.setString(section, "Name", profile.name);
+ ini.setString(section, "IsRelative", 1);
+ ini.setString(section, "Path", profile.path);
+
+ if (profile.default) {
+ ini.setString(section, "Default", "1");
+ }
+ }
+
+ if (backgroundTasksProfiles) {
+ let section = "BackgroundTasksProfiles";
+ for (let backgroundTasksProfile of backgroundTasksProfiles) {
+ ini.setString(
+ section,
+ backgroundTasksProfile.name,
+ backgroundTasksProfile.path
+ );
+ }
+ }
+
+ if (installs) {
+ ini.setString("General", "Version", "2");
+
+ for (let hash of Object.keys(installs)) {
+ ini.setString(`Install${hash}`, "Default", installs[hash].default);
+ if ("locked" in installs[hash]) {
+ ini.setString(
+ `Install${hash}`,
+ "Locked",
+ installs[hash].locked ? "1" : "0"
+ );
+ }
+ }
+
+ writeInstallsIni({ installs });
+ } else {
+ writeInstallsIni(null);
+ }
+
+ ini.writeFile(target);
+}
+
+/**
+ * Reads the existing profiles.ini into the same structure as that accepted by
+ * writeProfilesIni above. The profiles property is sorted according to name
+ * because the order is irrelevant and it makes testing easier if we can make
+ * that assumption.
+ */
+function readProfilesIni() {
+ let target = gDataHome.clone();
+ target.append("profiles.ini");
+
+ let profileData = {
+ options: {
+ startWithLastProfile: true,
+ },
+ profiles: [],
+ installs: null,
+ };
+
+ if (!target.exists()) {
+ return profileData;
+ }
+
+ let factory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"].getService(
+ Ci.nsIINIParserFactory
+ );
+ let ini = factory.createINIParser(target);
+
+ profileData.options.startWithLastProfile =
+ safeGet(ini, "General", "StartWithLastProfile") == "1";
+ if (safeGet(ini, "General", "Version") == "2") {
+ profileData.installs = {};
+ }
+
+ let sections = ini.getSections();
+ while (sections.hasMore()) {
+ let section = sections.getNext();
+
+ if (section == "General") {
+ continue;
+ }
+
+ if (section.startsWith("Profile")) {
+ let isRelative = safeGet(ini, section, "IsRelative");
+ if (isRelative === null) {
+ break;
+ }
+ Assert.equal(
+ isRelative,
+ "1",
+ "Paths should always be relative in these tests."
+ );
+
+ let profile = {
+ name: safeGet(ini, section, "Name"),
+ path: safeGet(ini, section, "Path"),
+ };
+
+ try {
+ profile.default = ini.getString(section, "Default") == "1";
+ Assert.ok(
+ profile.default,
+ "The Default value is only written when true."
+ );
+ } catch (e) {
+ profile.default = false;
+ }
+
+ profileData.profiles.push(profile);
+ }
+
+ if (section.startsWith("Install")) {
+ Assert.ok(
+ profileData.installs,
+ "Should only see an install section if the ini version was correct."
+ );
+
+ profileData.installs[section.substring(7)] = {
+ default: safeGet(ini, section, "Default"),
+ };
+
+ let locked = safeGet(ini, section, "Locked");
+ if (locked !== null) {
+ profileData.installs[section.substring(7)].locked = locked;
+ }
+ }
+
+ if (section == "BackgroundTasksProfiles") {
+ profileData.backgroundTasksProfiles = [];
+ let backgroundTasksProfiles = ini.getKeys(section);
+ while (backgroundTasksProfiles.hasMore()) {
+ let name = backgroundTasksProfiles.getNext();
+ let path = ini.getString(section, name);
+ profileData.backgroundTasksProfiles.push({ name, path });
+ }
+ profileData.backgroundTasksProfiles.sort((a, b) =>
+ a.name.localeCompare(b.name)
+ );
+ }
+ }
+
+ profileData.profiles.sort((a, b) => a.name.localeCompare(b.name));
+
+ return profileData;
+}
+
+/**
+ * Writes an installs.ini based on the supplied data. Should be an object with
+ * keys for every installation hash each mapping to an object. Each object
+ * should have a default property for the relative path to the profile.
+ */
+function writeInstallsIni(installData) {
+ let target = gDataHome.clone();
+ target.append("installs.ini");
+
+ if (!installData) {
+ try {
+ target.remove(false);
+ } catch (e) {}
+ return;
+ }
+
+ const { installs = {} } = installData;
+
+ let factory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"].getService(
+ Ci.nsIINIParserFactory
+ );
+ let ini = factory.createINIParser(null).QueryInterface(Ci.nsIINIParserWriter);
+
+ for (let hash of Object.keys(installs)) {
+ ini.setString(hash, "Default", installs[hash].default);
+ if ("locked" in installs[hash]) {
+ ini.setString(hash, "Locked", installs[hash].locked ? "1" : "0");
+ }
+ }
+
+ ini.writeFile(target);
+}
+
+/**
+ * Reads installs.ini into a structure like that used in the above function.
+ */
+function readInstallsIni() {
+ let target = gDataHome.clone();
+ target.append("installs.ini");
+
+ let installData = {
+ installs: {},
+ };
+
+ if (!target.exists()) {
+ return installData;
+ }
+
+ let factory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"].getService(
+ Ci.nsIINIParserFactory
+ );
+ let ini = factory.createINIParser(target);
+
+ let sections = ini.getSections();
+ while (sections.hasMore()) {
+ let hash = sections.getNext();
+ if (hash != "General") {
+ installData.installs[hash] = {
+ default: safeGet(ini, hash, "Default"),
+ };
+
+ let locked = safeGet(ini, hash, "Locked");
+ if (locked !== null) {
+ installData.installs[hash].locked = locked;
+ }
+ }
+ }
+
+ return installData;
+}
+
+/**
+ * Check that the backup data in installs.ini matches the install data in
+ * profiles.ini.
+ */
+function checkBackup(
+ profileData = readProfilesIni(),
+ installData = readInstallsIni()
+) {
+ if (!profileData.installs) {
+ // If the profiles db isn't of the right version we wouldn't expect the
+ // backup to be accurate.
+ return;
+ }
+
+ Assert.deepEqual(
+ profileData.installs,
+ installData.installs,
+ "Backup installs.ini should match installs in profiles.ini"
+ );
+}
+
+/**
+ * Checks that the profile service seems to have the right data in it compared
+ * to profile and install data structured as in the above functions.
+ */
+function checkProfileService(
+ profileData = readProfilesIni(),
+ verifyBackup = true
+) {
+ let service = getProfileService();
+
+ let expectedStartWithLast = true;
+ if ("options" in profileData) {
+ expectedStartWithLast = profileData.options.startWithLastProfile;
+ }
+
+ Assert.equal(
+ service.startWithLastProfile,
+ expectedStartWithLast,
+ "Start with last profile should match."
+ );
+
+ let serviceProfiles = Array.from(service.profiles);
+
+ Assert.equal(
+ serviceProfiles.length,
+ profileData.profiles.length,
+ "Should be the same number of profiles."
+ );
+
+ // Sort to make matching easy.
+ serviceProfiles.sort((a, b) => a.name.localeCompare(b.name));
+ profileData.profiles.sort((a, b) => a.name.localeCompare(b.name));
+
+ let hash = xreDirProvider.getInstallHash();
+ let defaultPath =
+ profileData.installs && hash in profileData.installs
+ ? profileData.installs[hash].default
+ : null;
+ let dedicatedProfile = null;
+ let legacyProfile = null;
+
+ for (let i = 0; i < serviceProfiles.length; i++) {
+ let serviceProfile = serviceProfiles[i];
+ let expectedProfile = profileData.profiles[i];
+
+ Assert.equal(
+ serviceProfile.name,
+ expectedProfile.name,
+ "Should have the same name."
+ );
+
+ let expectedPath = Cc["@mozilla.org/file/local;1"].createInstance(
+ Ci.nsIFile
+ );
+ expectedPath.setRelativeDescriptor(gDataHome, expectedProfile.path);
+ Assert.equal(
+ serviceProfile.rootDir.path,
+ expectedPath.path,
+ "Should have the same path."
+ );
+
+ if (expectedProfile.path == defaultPath) {
+ dedicatedProfile = serviceProfile;
+ }
+
+ if (AppConstants.MOZ_DEV_EDITION) {
+ if (expectedProfile.name == PROFILE_DEFAULT) {
+ legacyProfile = serviceProfile;
+ }
+ } else if (expectedProfile.default) {
+ legacyProfile = serviceProfile;
+ }
+ }
+
+ if (gIsLegacy || Services.env.get("SNAP_NAME")) {
+ Assert.equal(
+ service.defaultProfile,
+ legacyProfile,
+ "Should have seen the right profile selected."
+ );
+ } else {
+ Assert.equal(
+ service.defaultProfile,
+ dedicatedProfile,
+ "Should have seen the right profile selected."
+ );
+ }
+
+ if (verifyBackup) {
+ checkBackup(profileData);
+ }
+}
+
+function checkStartupReason(expected = undefined) {
+ const tId = "startup.profile_selection_reason";
+ let scalars = TelemetryTestUtils.getProcessScalars("parent");
+
+ if (expected === undefined) {
+ Assert.ok(
+ !(tId in scalars),
+ "Startup telemetry should not have been recorded."
+ );
+ return;
+ }
+
+ if (tId in scalars) {
+ Assert.equal(
+ scalars[tId],
+ expected,
+ "Should have seen the right startup reason."
+ );
+ } else {
+ Assert.ok(false, "Startup telemetry should have been recorded.");
+ }
+}