corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1894239: Enable MOZ_SELECTABLE_PROFILES by default. r=jhirsch,omc-reviewers,niklas,emcminn,mconley

Browse Source 
This also removes some tests of `MOZ_SELECTABLE_PROFILES` from `browser/components/profiles` files
where the test is pointless because that test is excluded from the build if `MOZ_SELECTABLE_PROFILES`
is unset.

Differential Revision: https://phabricator.services.mozilla.com/D227372
This commit is contained in:
Dave Townsend
2024-11-01 17:08:27 +00:00
parent 60d975e6b2
commit 0085ce80d2
20 changed files with 293 additions and 329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
browser/base/content/browser-profiles.js
View File

@@ -21,7 +21,8 @@ var gProfiles = {
"PROFILES_ENABLED", "PROFILES_ENABLED",
"browser.profiles.enabled", "browser.profiles.enabled",
false, false,
this.toggleProfileButtonVisibility.bind(this) this.toggleProfileButtonVisibility.bind(this),
() => SelectableProfileService?.isEnabled
); );
if (!this.PROFILES_ENABLED) { if (!this.PROFILES_ENABLED) {

4
browser/base/content/test/performance/browser_appmenu.js
View File

@@ -73,7 +73,9 @@ add_task(async function () {
async function openSubViewsRecursively(currentView) { async function openSubViewsRecursively(currentView) {
let navButtons = Array.from( let navButtons = Array.from(
// Ensure that only enabled buttons are tested // Ensure that only enabled buttons are tested
currentView.querySelectorAll(".subviewbutton-nav:not([disabled])") currentView.querySelectorAll(
".subviewbutton-nav:not([disabled]):not([hidden])"
)
); );
if (!navButtons) { if (!navButtons) {
return; return;

5
browser/components/BrowserGlue.sys.mjs
View File

@@ -1957,10 +1957,7 @@ BrowserGlue.prototype = {
lazy.DoHController.init(); lazy.DoHController.init();
if ( if (AppConstants.MOZ_SELECTABLE_PROFILES) {
AppConstants.MOZ_SELECTABLE_PROFILES &&
Services.prefs.getBoolPref("browser.profiles.enabled", false)
) {
lazy.SelectableProfileService.init().catch(console.error); lazy.SelectableProfileService.init().catch(console.error);
} }

4
browser/components/asrouter/modules/ASRouterTargeting.sys.mjs
View File

@@ -588,9 +588,9 @@ const TargetingGetters = {
}, },
get canCreateSelectableProfiles() { get canCreateSelectableProfiles() {
if (!AppConstants.MOZ_SELECTABLE_PROFILES) { if (!AppConstants.MOZ_SELECTABLE_PROFILES) {
return null; return false;
} }
return !!lazy.SelectableProfileService?.groupToolkitProfile; return lazy.SelectableProfileService?.isEnabled ?? false;
}, },
get hasSelectableProfiles() { get hasSelectableProfiles() {
return !!lazy.profileStoreID; return !!lazy.profileStoreID;

12
browser/components/asrouter/tests/browser/browser_asrouter_targeting.js
View File

@@ -219,6 +219,16 @@ add_task(async function check_canCreateSelectableProfiles() {
return; return;
} }
is(
await ASRouterTargeting.Environment.canCreateSelectableProfiles,
false,
"The new profiles feature doesn't support standalone profiles which are used in automation."
);
// We have to fake there being a real profile available and enable the profiles feature
await pushPrefs(["browser.profiles.enabled", "someValue"]);
await SelectableProfileService.resetProfileService({ currentProfile: {} });
is( is(
await ASRouterTargeting.Environment.canCreateSelectableProfiles, await ASRouterTargeting.Environment.canCreateSelectableProfiles,
true, true,
@@ -231,6 +241,8 @@ add_task(async function check_canCreateSelectableProfiles() {
message, message,
"should select correct item by canCreateSelectableProfiles" "should select correct item by canCreateSelectableProfiles"
); );
await SelectableProfileService.resetProfileService(null);
}); });
add_task(async function check_hasSelectableProfiles() { add_task(async function check_hasSelectableProfiles() {

11
browser/components/profiles/SelectableProfileService.sys.mjs
View File

@@ -118,6 +118,13 @@ class SelectableProfileServiceClass {
this.#asyncShutdownBlocker = () => this.uninit(); this.#asyncShutdownBlocker = () => this.uninit();
} }
get isEnabled() {
return (
Services.prefs.getBoolPref("browser.profiles.enabled", false) &&
!!(this.#storeID || this.#groupToolkitProfile)
);
}
/** /**
* For use in testing only, override the profile service with a mock version * For use in testing only, override the profile service with a mock version
* and reset state accordingly. * and reset state accordingly.
@@ -258,6 +265,10 @@ class SelectableProfileServiceClass {
); );
} }
if (!this.isEnabled) {
return;
}
// If the storeID doesn't exist, we don't want to create the db until we // If the storeID doesn't exist, we don't want to create the db until we
// need to so we early return. // need to so we early return.
if (!this.storeID) { if (!this.storeID) {

7
browser/components/profiles/tests/browser/browser_create_profile_page_test.js
View File

@@ -6,13 +6,6 @@
const NEW_PROFILE_NAME = "This is a new profile name"; const NEW_PROFILE_NAME = "This is a new profile name";
add_task(async function test_create_profile_name() { add_task(async function test_create_profile_name() {
if (!AppConstants.MOZ_SELECTABLE_PROFILES) {
// `mochitest-browser` suite `add_task` does not yet support
// `properties.skip_if`.
ok(true, "Skipping because !AppConstants.MOZ_SELECTABLE_PROFILES");
return;
}
await SpecialPowers.pushPrefEnv({ await SpecialPowers.pushPrefEnv({
set: [["browser.profiles.profile-name.updated", false]], set: [["browser.profiles.profile-name.updated", false]],
}); });

7
browser/components/profiles/tests/browser/browser_edit_profile_test.js
View File

@@ -6,13 +6,6 @@
const NEW_PROFILE_NAME = "This is a new profile name"; const NEW_PROFILE_NAME = "This is a new profile name";
add_task(async function test_edit_profile_name() { add_task(async function test_edit_profile_name() {
if (!AppConstants.MOZ_SELECTABLE_PROFILES) {
// `mochitest-browser` suite `add_task` does not yet support
// `properties.skip_if`.
ok(true, "Skipping because !AppConstants.MOZ_SELECTABLE_PROFILES");
return;
}
await initGroupDatabase(); await initGroupDatabase();
let profile = SelectableProfileService.currentProfile; let profile = SelectableProfileService.currentProfile;
Assert.ok(profile, "Should have a profile now"); Assert.ok(profile, "Should have a profile now");

7
browser/components/profiles/tests/browser/browser_test_db_lazily_created.js
View File

@@ -4,13 +4,6 @@
"use strict"; "use strict";
add_task(async function test_dbLazilyCreated() { add_task(async function test_dbLazilyCreated() {
if (!AppConstants.MOZ_SELECTABLE_PROFILES) {
// `mochitest-browser` suite `add_task` does not yet support
// `properties.skip_if`.
ok(true, "Skipping because !AppConstants.MOZ_SELECTABLE_PROFILES");
return;
}
Assert.ok( Assert.ok(
!SelectableProfileService.initialized, !SelectableProfileService.initialized,
`Selectable Profile Service should not be initialized because the default profile has no storeID` `Selectable Profile Service should not be initialized because the default profile has no storeID`

7
browser/components/profiles/tests/browser/browser_test_profile_selector.js
View File

@@ -4,13 +4,6 @@
"use strict"; "use strict";
add_task(async function test_selector_window() { add_task(async function test_selector_window() {
if (!AppConstants.MOZ_SELECTABLE_PROFILES) {
// `mochitest-browser` suite `add_task` does not yet support
// `properties.skip_if`.
ok(true, "Skipping because !AppConstants.MOZ_SELECTABLE_PROFILES");
return;
}
await initGroupDatabase(); await initGroupDatabase();
let profile = SelectableProfileService.currentProfile; let profile = SelectableProfileService.currentProfile;

7
browser/components/profiles/tests/browser/browser_update_profile_on_window_switch.js
View File

@@ -8,13 +8,6 @@ const { SelectableProfile } = ChromeUtils.importESModule(
); );
add_task(async function test_updateDefaultProfileOnWindowSwitch() { add_task(async function test_updateDefaultProfileOnWindowSwitch() {
if (!AppConstants.MOZ_SELECTABLE_PROFILES) {
// `mochitest-browser` suite `add_task` does not yet support
// `properties.skip_if`.
ok(true, "Skipping because !AppConstants.MOZ_SELECTABLE_PROFILES");
return;
}
await initGroupDatabase(); await initGroupDatabase();
let currentProfile = SelectableProfileService.currentProfile; let currentProfile = SelectableProfileService.currentProfile;
let profileRootDir = await currentProfile.rootDir; let profileRootDir = await currentProfile.rootDir;

47
browser/components/profiles/tests/unit/test_fail_recover_storeID.js
View File

@@ -3,32 +3,27 @@ https://creativecommons.org/publicdomain/zero/1.0/ */
"use strict"; "use strict";
add_task( add_task(async function test_recover_storeID() {
{ startProfileService();
skip_if: () => !AppConstants.MOZ_SELECTABLE_PROFILES, Services.prefs.setCharPref("toolkit.profiles.storeID", "foobar");
},
async function test_recover_storeID() {
startProfileService();
Services.prefs.setCharPref("toolkit.profiles.storeID", "foobar");
const SelectableProfileService = getSelectableProfileService(); const SelectableProfileService = getSelectableProfileService();
await SelectableProfileService.init(); await SelectableProfileService.init();
Assert.ok( Assert.ok(
!SelectableProfileService.initialized, !SelectableProfileService.initialized,
"Didn't initialize the service" "Didn't initialize the service"
); );
let profile = SelectableProfileService.currentProfile; let profile = SelectableProfileService.currentProfile;
Assert.ok(!profile, "Should not have a current profile"); Assert.ok(!profile, "Should not have a current profile");
Assert.equal( Assert.equal(
getProfileService().currentProfile.storeID, getProfileService().currentProfile.storeID,
null, null,
"Should not have updated the store ID on the profile" "Should not have updated the store ID on the profile"
); );
Assert.ok( Assert.ok(
!Services.prefs.prefHasUserValue("toolkit.profiles.storeID"), !Services.prefs.prefHasUserValue("toolkit.profiles.storeID"),
"Should have cleared the storeID pref" "Should have cleared the storeID pref"
); );
} });
);

92
browser/components/profiles/tests/unit/test_recover_storeID.js
View File

@@ -7,33 +7,27 @@ const { Sqlite } = ChromeUtils.importESModule(
"resource://gre/modules/Sqlite.sys.mjs" "resource://gre/modules/Sqlite.sys.mjs"
); );
add_task( add_task(async function test_recover_storeID() {
{ startProfileService();
skip_if: () => !AppConstants.MOZ_SELECTABLE_PROFILES, Services.prefs.setCharPref("toolkit.profiles.storeID", "foobar");
},
async function test_recover_storeID() {
startProfileService();
Services.prefs.setCharPref("toolkit.profiles.storeID", "foobar");
// The database needs to exist already // The database needs to exist already
let groupsPath = PathUtils.join( let groupsPath = PathUtils.join(
Services.dirsvc.get("UAppData", Ci.nsIFile).path, Services.dirsvc.get("UAppData", Ci.nsIFile).path,
"Profile Groups" "Profile Groups"
); );
await IOUtils.makeDirectory(groupsPath); await IOUtils.makeDirectory(groupsPath);
let dbFile = PathUtils.join(groupsPath, "foobar.sqlite"); let dbFile = PathUtils.join(groupsPath, "foobar.sqlite");
let db = await Sqlite.openConnection({ let db = await Sqlite.openConnection({
path: dbFile, path: dbFile,
openNotExclusive: true, openNotExclusive: true,
}); });
let path = getRelativeProfilePath( let path = getRelativeProfilePath(getProfileService().currentProfile.rootDir);
getProfileService().currentProfile.rootDir
);
// Slightly annoying we have to replicate this... // Slightly annoying we have to replicate this...
await db.execute(`CREATE TABLE IF NOT EXISTS "Profiles" ( await db.execute(`CREATE TABLE IF NOT EXISTS "Profiles" (
id INTEGER NOT NULL, id INTEGER NOT NULL,
path TEXT NOT NULL UNIQUE, path TEXT NOT NULL UNIQUE,
name TEXT NOT NULL, name TEXT NOT NULL,
@@ -43,34 +37,30 @@ add_task(
themeBg TEXT NOT NULL, themeBg TEXT NOT NULL,
PRIMARY KEY(id) PRIMARY KEY(id)
);`); );`);
await db.execute( await db.execute(
`INSERT INTO Profiles VALUES (NULL, :path, :name, :avatar, :themeL10nId, :themeFg, :themeBg);`, `INSERT INTO Profiles VALUES (NULL, :path, :name, :avatar, :themeL10nId, :themeFg, :themeBg);`,
{ {
path, path,
name: "Fake Profile", name: "Fake Profile",
avatar: "book", avatar: "book",
themeL10nId: "default", themeL10nId: "default",
themeFg: "", themeFg: "",
themeBg: "", themeBg: "",
} }
); );
await db.close(); await db.close();
const SelectableProfileService = getSelectableProfileService(); const SelectableProfileService = getSelectableProfileService();
await SelectableProfileService.init(); await SelectableProfileService.init();
Assert.ok( Assert.ok(SelectableProfileService.initialized, "Did initialize the service");
SelectableProfileService.initialized,
"Did initialize the service"
);
let profile = SelectableProfileService.currentProfile; let profile = SelectableProfileService.currentProfile;
Assert.ok(profile, "Should have a current profile"); Assert.ok(profile, "Should have a current profile");
Assert.equal(profile.name, "Fake Profile"); Assert.equal(profile.name, "Fake Profile");
Assert.equal( Assert.equal(
getProfileService().currentProfile.storeID, getProfileService().currentProfile.storeID,
"foobar", "foobar",
"Should have updated the store ID on the profile" "Should have updated the store ID on the profile"
); );
} });
);

49
browser/components/profiles/tests/unit/test_selectable_profile_launch.js
View File

@@ -5,35 +5,30 @@ https://creativecommons.org/publicdomain/zero/1.0/ */
add_setup(initSelectableProfileService); add_setup(initSelectableProfileService);
add_task( add_task(async function test_launcher() {
{ // mock() returns an object with a fake `runw` method that, when
skip_if: () => !AppConstants.MOZ_SELECTABLE_PROFILES, // called, records its arguments.
}, let input = [];
async function test_launcher() { let mock = () => {
// mock() returns an object with a fake `runw` method that, when return {
// called, records its arguments. runw: (...args) => {
let input = []; input = args;
let mock = () => { },
return {
runw: (...args) => {
input = args;
},
};
}; };
};
let profile = await createTestProfile(); let profile = await createTestProfile();
const SelectableProfileService = getSelectableProfileService(); const SelectableProfileService = getSelectableProfileService();
SelectableProfileService.getExecutableProcess = mock; SelectableProfileService.getExecutableProcess = mock;
SelectableProfileService.launchInstance(profile); SelectableProfileService.launchInstance(profile);
let expected; let expected;
if (Services.appinfo.OS == "Darwin") { if (Services.appinfo.OS == "Darwin") {
expected = ["-foreground", "--profile", profile.path]; expected = ["-foreground", "--profile", profile.path];
} else { } else {
expected = ["--profile", profile.path]; expected = ["--profile", profile.path];
}
Assert.deepEqual(expected, input[1], "Expected runw arguments");
} }
);
Assert.deepEqual(expected, input[1], "Expected runw arguments");
});

25
browser/components/profiles/tests/unit/test_selectable_profile_service_exists.js
View File

@@ -3,19 +3,14 @@ https://creativecommons.org/publicdomain/zero/1.0/ */
"use strict"; "use strict";
add_task( add_task(async function test_SelectableProfileAndServiceExist() {
{ const { SelectableProfile } = ChromeUtils.importESModule(
skip_if: () => !AppConstants.MOZ_SELECTABLE_PROFILES, "resource:///modules/profiles/SelectableProfile.sys.mjs"
}, );
async function test_SelectableProfileAndServiceExist() { const { SelectableProfileService } = ChromeUtils.importESModule(
const { SelectableProfile } = ChromeUtils.importESModule( "resource:///modules/profiles/SelectableProfileService.sys.mjs"
"resource:///modules/profiles/SelectableProfile.sys.mjs" );
);
const { SelectableProfileService } = ChromeUtils.importESModule(
"resource:///modules/profiles/SelectableProfileService.sys.mjs"
);
ok(SelectableProfile, "SelectableProfile exists"); ok(SelectableProfile, "SelectableProfile exists");
ok(SelectableProfileService, "SelectableProfileService exists"); ok(SelectableProfileService, "SelectableProfileService exists");
} });
);

200
browser/components/profiles/tests/unit/test_selectable_profiles_lifecycle.js
View File

@@ -3,110 +3,116 @@ https://creativecommons.org/publicdomain/zero/1.0/ */
"use strict"; "use strict";
add_task( add_task(async function test_SelectableProfileLifecycle() {
{ startProfileService();
skip_if: () => !AppConstants.MOZ_SELECTABLE_PROFILES, const SelectableProfileService = getSelectableProfileService();
},
async function test_SelectableProfileLifecycle() {
startProfileService();
const SelectableProfileService = getSelectableProfileService();
await SelectableProfileService.init();
let profiles = await SelectableProfileService.getAllProfiles(); Services.prefs.setBoolPref("browser.profiles.enabled", false);
await SelectableProfileService.init();
Assert.ok(
!SelectableProfileService.isEnabled,
"Service should not be enabled"
);
Assert.ok(!profiles.length, "No selectable profiles exist yet"); Services.prefs.setBoolPref("browser.profiles.enabled", true);
await SelectableProfileService.init();
Assert.ok(
SelectableProfileService.isEnabled,
"Service should now be enabled"
);
await SelectableProfileService.maybeSetupDataStore(); let profiles = await SelectableProfileService.getAllProfiles();
let currentProfile = SelectableProfileService.currentProfile;
const leafName = (await currentProfile.rootDir).leafName; Assert.ok(!profiles.length, "No selectable profiles exist yet");
const profilePath = PathUtils.join( await SelectableProfileService.maybeSetupDataStore();
Services.dirsvc.get("DefProfRt", Ci.nsIFile).path, let currentProfile = SelectableProfileService.currentProfile;
leafName
const leafName = (await currentProfile.rootDir).leafName;
const profilePath = PathUtils.join(
Services.dirsvc.get("DefProfRt", Ci.nsIFile).path,
leafName
);
let profileDirExists = await IOUtils.exists(profilePath);
const profileLocalPath = PathUtils.join(
Services.dirsvc.get("DefProfLRt", Ci.nsIFile).path,
leafName
);
let profileLocalDirExists = await IOUtils.exists(profileLocalPath);
Assert.ok(
profileDirExists,
`Profile dir was successfully created at ${profilePath}`
);
Assert.ok(
profileLocalDirExists,
`Profile local dir was successfully created at ${profileLocalPath}`
);
profiles = await SelectableProfileService.getAllProfiles();
Assert.equal(profiles.length, 1, "One selectable profile exists");
let selectableProfile = profiles[0];
let profile = await SelectableProfileService.getProfile(selectableProfile.id);
for (let attr of ["id", "name", "path"]) {
Assert.equal(
profile[attr],
currentProfile[attr],
`We got the correct profile ${attr}`
); );
let profileDirExists = await IOUtils.exists(profilePath);
const profileLocalPath = PathUtils.join(
Services.dirsvc.get("DefProfLRt", Ci.nsIFile).path,
leafName
);
let profileLocalDirExists = await IOUtils.exists(profileLocalPath);
Assert.ok(
profileDirExists,
`Profile dir was successfully created at ${profilePath}`
);
Assert.ok(
profileLocalDirExists,
`Profile local dir was successfully created at ${profileLocalPath}`
);
profiles = await SelectableProfileService.getAllProfiles();
Assert.equal(profiles.length, 1, "One selectable profile exists");
let selectableProfile = profiles[0];
let profile = await SelectableProfileService.getProfile(
selectableProfile.id
);
for (let attr of ["id", "name", "path"]) {
Assert.equal(
profile[attr],
currentProfile[attr],
`We got the correct profile ${attr}`
);
Assert.equal(
selectableProfile[attr],
currentProfile[attr],
`We got the correct profile ${attr}`
);
}
selectableProfile.name = "updatedTestProfile";
await SelectableProfileService.updateProfile(selectableProfile);
profile = await SelectableProfileService.getProfile(selectableProfile.id);
Assert.equal( Assert.equal(
profile.name, selectableProfile[attr],
"updatedTestProfile", currentProfile[attr],
"We got the correct profile name: updatedTestProfile" `We got the correct profile ${attr}`
);
let newProfile = await createTestProfile({ name: "New profile" });
let rootDir = await newProfile.rootDir;
let localDir = PathUtils.join(
Services.dirsvc.get("DefProfLRt", Ci.nsIFile).path,
rootDir.leafName
);
profileDirExists = await IOUtils.exists(rootDir.path);
profileLocalDirExists = await IOUtils.exists(localDir);
Assert.ok(profileDirExists, "Profile dir was successfully created");
Assert.ok(
profileLocalDirExists,
"Profile local dir was successfully created"
);
profiles = await SelectableProfileService.getAllProfiles();
Assert.equal(profiles.length, 2, "Should now be two profiles.");
await SelectableProfileService.deleteProfile(newProfile);
profiles = await SelectableProfileService.getAllProfiles();
Assert.equal(profiles.length, 1, "Should now be one profiles.");
profileDirExists = await IOUtils.exists(rootDir.path);
profileLocalDirExists = await IOUtils.exists(localDir);
Assert.ok(!profileDirExists, "Profile dir was successfully removed");
Assert.ok(
!profileLocalDirExists,
"Profile local dir was successfully removed"
); );
} }
);
selectableProfile.name = "updatedTestProfile";
await SelectableProfileService.updateProfile(selectableProfile);
profile = await SelectableProfileService.getProfile(selectableProfile.id);
Assert.equal(
profile.name,
"updatedTestProfile",
"We got the correct profile name: updatedTestProfile"
);
let newProfile = await createTestProfile({ name: "New profile" });
let rootDir = await newProfile.rootDir;
let localDir = PathUtils.join(
Services.dirsvc.get("DefProfLRt", Ci.nsIFile).path,
rootDir.leafName
);
profileDirExists = await IOUtils.exists(rootDir.path);
profileLocalDirExists = await IOUtils.exists(localDir);
Assert.ok(profileDirExists, "Profile dir was successfully created");
Assert.ok(
profileLocalDirExists,
"Profile local dir was successfully created"
);
profiles = await SelectableProfileService.getAllProfiles();
Assert.equal(profiles.length, 2, "Should now be two profiles.");
await SelectableProfileService.deleteProfile(newProfile);
profiles = await SelectableProfileService.getAllProfiles();
Assert.equal(profiles.length, 1, "Should now be one profiles.");
profileDirExists = await IOUtils.exists(rootDir.path);
profileLocalDirExists = await IOUtils.exists(localDir);
Assert.ok(!profileDirExists, "Profile dir was successfully removed");
Assert.ok(
!profileLocalDirExists,
"Profile local dir was successfully removed"
);
});

111
browser/components/profiles/tests/unit/test_shared_prefs_lifecycles_methods.js
View File

@@ -5,69 +5,64 @@ https://creativecommons.org/publicdomain/zero/1.0/ */
add_setup(initSelectableProfileService); add_setup(initSelectableProfileService);
add_task( add_task(async function test_SharedPrefsLifecycle() {
{ const SelectableProfileService = getSelectableProfileService();
skip_if: () => !AppConstants.MOZ_SELECTABLE_PROFILES, let prefs = await SelectableProfileService.getAllPrefs();
},
async function test_SharedPrefsLifecycle() {
const SelectableProfileService = getSelectableProfileService();
let prefs = await SelectableProfileService.getAllPrefs();
Assert.equal(prefs.length, 3, "The default shared prefs exist"); Assert.equal(prefs.length, 3, "The default shared prefs exist");
await SelectableProfileService.setIntPref("testPrefInt0", 0); await SelectableProfileService.setIntPref("testPrefInt0", 0);
await SelectableProfileService.setIntPref("testPrefInt1", 1); await SelectableProfileService.setIntPref("testPrefInt1", 1);
await SelectableProfileService.setPref("testPrefInt2", 2); await SelectableProfileService.setPref("testPrefInt2", 2);
await SelectableProfileService.setStringPref( await SelectableProfileService.setStringPref(
"testPrefString0", "testPrefString0",
"Hello world!" "Hello world!"
); );
await SelectableProfileService.setPref("testPrefString1", "Hello world 2!"); await SelectableProfileService.setPref("testPrefString1", "Hello world 2!");
await SelectableProfileService.setBoolPref("testPrefBoolTrue", true); await SelectableProfileService.setBoolPref("testPrefBoolTrue", true);
await SelectableProfileService.setPref("testPrefBoolFalse", false); await SelectableProfileService.setPref("testPrefBoolFalse", false);
prefs = await SelectableProfileService.getAllPrefs(); prefs = await SelectableProfileService.getAllPrefs();
Assert.equal(prefs.length, 10, "10 shared prefs exist"); Assert.equal(prefs.length, 10, "10 shared prefs exist");
Assert.equal( Assert.equal(
await SelectableProfileService.getIntPref("testPrefInt0"), await SelectableProfileService.getIntPref("testPrefInt0"),
0, 0,
"testPrefInt0 value is 0" "testPrefInt0 value is 0"
); );
Assert.equal( Assert.equal(
await SelectableProfileService.getIntPref("testPrefInt1"), await SelectableProfileService.getIntPref("testPrefInt1"),
1, 1,
"testPrefInt1 value is 1" "testPrefInt1 value is 1"
); );
Assert.equal( Assert.equal(
await SelectableProfileService.getPref("testPrefInt2"), await SelectableProfileService.getPref("testPrefInt2"),
2, 2,
"testPrefInt2 value is 2" "testPrefInt2 value is 2"
); );
Assert.equal( Assert.equal(
await SelectableProfileService.getStringPref("testPrefString0"), await SelectableProfileService.getStringPref("testPrefString0"),
"Hello world!", "Hello world!",
'testPrefString0 value is "Hello world!"' 'testPrefString0 value is "Hello world!"'
); );
Assert.equal( Assert.equal(
await SelectableProfileService.getPref("testPrefString1"), await SelectableProfileService.getPref("testPrefString1"),
"Hello world 2!", "Hello world 2!",
'testPrefString1 value is "Hello world 2!"' 'testPrefString1 value is "Hello world 2!"'
); );
Assert.equal( Assert.equal(
await SelectableProfileService.getBoolPref("testPrefBoolTrue"), await SelectableProfileService.getBoolPref("testPrefBoolTrue"),
true, true,
"testPrefBoolTrue value is true" "testPrefBoolTrue value is true"
); );
Assert.equal( Assert.equal(
await SelectableProfileService.getPref("testPrefBoolFalse"), await SelectableProfileService.getPref("testPrefBoolFalse"),
false, false,
"testPrefBoolFalse value is false" "testPrefBoolFalse value is false"
); );
await SelectableProfileService.deleteProfileGroup(); await SelectableProfileService.deleteProfileGroup();
} });
);

4
browser/components/profiles/tests/unit/xpcshell.toml
View File

@@ -2,6 +2,10 @@
head = "../../../../../toolkit/profile/test/xpcshell/head.js head.js" head = "../../../../../toolkit/profile/test/xpcshell/head.js head.js"
firefox-appdir = "browser" firefox-appdir = "browser"
prefs = [
"browser.profiles.enabled=true",
]
["test_fail_recover_storeID.js"] ["test_fail_recover_storeID.js"]
["test_recover_storeID.js"] ["test_recover_storeID.js"]

12
toolkit/moz.configure
View File

@@ -1092,16 +1092,10 @@ with only_when(target_is_osx):
# Profile Management # Profile Management
# ============================================================== # ==============================================================
# Selectable profiles are temporarily gated behind a build flag # Selectable profiles are enabled by default.
# while we build and stabilize the backend (bug 1893315).
option( set_define("MOZ_SELECTABLE_PROFILES", True)
env="MOZ_SELECTABLE_PROFILES", set_config("MOZ_SELECTABLE_PROFILES", True)
help="Enable experimental and unstable profile groups",
)
set_define("MOZ_SELECTABLE_PROFILES", True, when="MOZ_SELECTABLE_PROFILES")
set_config("MOZ_SELECTABLE_PROFILES", True, when="MOZ_SELECTABLE_PROFILES")
project_flag( project_flag(
"MOZ_DEDICATED_PROFILES", "MOZ_DEDICATED_PROFILES",

8
toolkit/profile/test/xpcshell/head.js
View File

@@ -33,10 +33,12 @@ xreDirProvider.setUserDataDirectory(gDataHome, false);
xreDirProvider.setUserDataDirectory(gDataHomeLocal, true); xreDirProvider.setUserDataDirectory(gDataHomeLocal, true);
Services.dirsvc.set("UAppData", gDataHome); Services.dirsvc.set("UAppData", gDataHome);
let gProfilesRoot = gDataHome.clone(); let gProfilesRoot = gDataHome.clone();
gProfilesRoot.append("profiles");
Services.dirsvc.set("DefProfRt", gProfilesRoot);
let gProfilesTemp = gDataHomeLocal.clone(); let gProfilesTemp = gDataHomeLocal.clone();
gProfilesTemp.append("profiles"); if (!AppConstants.XP_UNIX || AppConstants.platform == "macosx") {
gProfilesRoot.append("Profiles");
gProfilesTemp.append("Profiles");
}
Services.dirsvc.set("DefProfRt", gProfilesRoot);
Services.dirsvc.set("DefProfLRt", gProfilesTemp); Services.dirsvc.set("DefProfLRt", gProfilesTemp);
let gIsDefaultApp = false; let gIsDefaultApp = false;