summaryrefslogtreecommitdiffstats
path: root/browser/components/migration/FirefoxProfileMigrator.sys.mjs
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /browser/components/migration/FirefoxProfileMigrator.sys.mjs
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'browser/components/migration/FirefoxProfileMigrator.sys.mjs')
-rw-r--r--browser/components/migration/FirefoxProfileMigrator.sys.mjs400
1 files changed, 400 insertions, 0 deletions
diff --git a/browser/components/migration/FirefoxProfileMigrator.sys.mjs b/browser/components/migration/FirefoxProfileMigrator.sys.mjs
new file mode 100644
index 0000000000..27a15b65fb
--- /dev/null
+++ b/browser/components/migration/FirefoxProfileMigrator.sys.mjs
@@ -0,0 +1,400 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sw=2 ts=2 sts=2 et */
+/* 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/. */
+
+/*
+ * Migrates from a Firefox profile in a lossy manner in order to clean up a
+ * user's profile. Data is only migrated where the benefits outweigh the
+ * potential problems caused by importing undesired/invalid configurations
+ * from the source profile.
+ */
+
+import { MigrationUtils } from "resource:///modules/MigrationUtils.sys.mjs";
+
+import { MigratorBase } from "resource:///modules/MigratorBase.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ FileUtils: "resource://gre/modules/FileUtils.sys.mjs",
+ PlacesBackups: "resource://gre/modules/PlacesBackups.sys.mjs",
+ ProfileAge: "resource://gre/modules/ProfileAge.sys.mjs",
+ SessionMigration: "resource:///modules/sessionstore/SessionMigration.sys.mjs",
+});
+
+/**
+ * Firefox profile migrator. Currently, this class only does "pave over"
+ * migrations, where various parts of an old profile overwrite a new
+ * profile. This is distinct from other migrators which attempt to import
+ * old profile data into the existing profile.
+ *
+ * This migrator is what powers the "Profile Refresh" mechanism.
+ */
+export class FirefoxProfileMigrator extends MigratorBase {
+ static get key() {
+ return "firefox";
+ }
+
+ static get displayNameL10nID() {
+ return "migration-wizard-migrator-display-name-firefox";
+ }
+
+ static get brandImage() {
+ return "chrome://branding/content/icon128.png";
+ }
+
+ _getAllProfiles() {
+ let allProfiles = new Map();
+ let profileService = Cc[
+ "@mozilla.org/toolkit/profile-service;1"
+ ].getService(Ci.nsIToolkitProfileService);
+ for (let profile of profileService.profiles) {
+ let rootDir = profile.rootDir;
+
+ if (
+ rootDir.exists() &&
+ rootDir.isReadable() &&
+ !rootDir.equals(MigrationUtils.profileStartup.directory)
+ ) {
+ allProfiles.set(profile.name, rootDir);
+ }
+ }
+ return allProfiles;
+ }
+
+ getSourceProfiles() {
+ let sorter = (a, b) => {
+ return a.id.toLocaleLowerCase().localeCompare(b.id.toLocaleLowerCase());
+ };
+
+ return [...this._getAllProfiles().keys()]
+ .map(x => ({ id: x, name: x }))
+ .sort(sorter);
+ }
+
+ _getFileObject(dir, fileName) {
+ let file = dir.clone();
+ file.append(fileName);
+
+ // File resources are monolithic. We don't make partial copies since
+ // they are not expected to work alone. Return null to avoid trying to
+ // copy non-existing files.
+ return file.exists() ? file : null;
+ }
+
+ getResources(aProfile) {
+ let sourceProfileDir = aProfile
+ ? this._getAllProfiles().get(aProfile.id)
+ : Cc["@mozilla.org/toolkit/profile-service;1"].getService(
+ Ci.nsIToolkitProfileService
+ ).defaultProfile.rootDir;
+ if (
+ !sourceProfileDir ||
+ !sourceProfileDir.exists() ||
+ !sourceProfileDir.isReadable()
+ ) {
+ return null;
+ }
+
+ // Being a startup-only migrator, we can rely on
+ // MigrationUtils.profileStartup being set.
+ let currentProfileDir = MigrationUtils.profileStartup.directory;
+
+ // Surely data cannot be imported from the current profile.
+ if (sourceProfileDir.equals(currentProfileDir)) {
+ return null;
+ }
+
+ return this._getResourcesInternal(sourceProfileDir, currentProfileDir);
+ }
+
+ getLastUsedDate() {
+ // We always pretend we're really old, so that we don't mess
+ // up the determination of which browser is the most 'recent'
+ // to import from.
+ return Promise.resolve(new Date(0));
+ }
+
+ _getResourcesInternal(sourceProfileDir, currentProfileDir) {
+ let getFileResource = (aMigrationType, aFileNames) => {
+ let files = [];
+ for (let fileName of aFileNames) {
+ let file = this._getFileObject(sourceProfileDir, fileName);
+ if (file) {
+ files.push(file);
+ }
+ }
+ if (!files.length) {
+ return null;
+ }
+ return {
+ type: aMigrationType,
+ migrate(aCallback) {
+ for (let file of files) {
+ file.copyTo(currentProfileDir, "");
+ }
+ aCallback(true);
+ },
+ };
+ };
+
+ let _oldRawPrefsMemoized = null;
+ async function readOldPrefs() {
+ if (!_oldRawPrefsMemoized) {
+ let prefsPath = PathUtils.join(sourceProfileDir.path, "prefs.js");
+ if (await IOUtils.exists(prefsPath)) {
+ _oldRawPrefsMemoized = await IOUtils.readUTF8(prefsPath, {
+ encoding: "utf-8",
+ });
+ }
+ }
+
+ return _oldRawPrefsMemoized;
+ }
+
+ function savePrefs() {
+ // If we've used the pref service to write prefs for the new profile, it's too
+ // early in startup for the service to have a profile directory, so we have to
+ // manually tell it where to save the prefs file.
+ let newPrefsFile = currentProfileDir.clone();
+ newPrefsFile.append("prefs.js");
+ Services.prefs.savePrefFile(newPrefsFile);
+ }
+
+ let types = MigrationUtils.resourceTypes;
+ let places = getFileResource(types.HISTORY, [
+ "places.sqlite",
+ "places.sqlite-wal",
+ ]);
+ let favicons = getFileResource(types.HISTORY, [
+ "favicons.sqlite",
+ "favicons.sqlite-wal",
+ ]);
+ let cookies = getFileResource(types.COOKIES, [
+ "cookies.sqlite",
+ "cookies.sqlite-wal",
+ ]);
+ let passwords = getFileResource(types.PASSWORDS, [
+ "logins.json",
+ "key3.db",
+ "key4.db",
+ ]);
+ let formData = getFileResource(types.FORMDATA, [
+ "formhistory.sqlite",
+ "autofill-profiles.json",
+ ]);
+ let bookmarksBackups = getFileResource(types.OTHERDATA, [
+ lazy.PlacesBackups.profileRelativeFolderPath,
+ ]);
+ let dictionary = getFileResource(types.OTHERDATA, ["persdict.dat"]);
+
+ let session;
+ if (Services.env.get("MOZ_RESET_PROFILE_MIGRATE_SESSION")) {
+ // We only want to restore the previous firefox session if the profile refresh was
+ // triggered by user. The MOZ_RESET_PROFILE_MIGRATE_SESSION would be set when a user-triggered
+ // profile refresh happened in nsAppRunner.cpp. Hence, we detect the MOZ_RESET_PROFILE_MIGRATE_SESSION
+ // to see if session data migration is required.
+ Services.env.set("MOZ_RESET_PROFILE_MIGRATE_SESSION", "");
+ let sessionCheckpoints = this._getFileObject(
+ sourceProfileDir,
+ "sessionCheckpoints.json"
+ );
+ let sessionFile = this._getFileObject(
+ sourceProfileDir,
+ "sessionstore.jsonlz4"
+ );
+ if (sessionFile) {
+ session = {
+ type: types.SESSION,
+ migrate(aCallback) {
+ sessionCheckpoints.copyTo(
+ currentProfileDir,
+ "sessionCheckpoints.json"
+ );
+ let newSessionFile = currentProfileDir.clone();
+ newSessionFile.append("sessionstore.jsonlz4");
+ let migrationPromise = lazy.SessionMigration.migrate(
+ sessionFile.path,
+ newSessionFile.path
+ );
+ migrationPromise.then(
+ function () {
+ let buildID = Services.appinfo.platformBuildID;
+ let mstone = Services.appinfo.platformVersion;
+ // Force the browser to one-off resume the session that we give it:
+ Services.prefs.setBoolPref(
+ "browser.sessionstore.resume_session_once",
+ true
+ );
+ // Reset the homepage_override prefs so that the browser doesn't override our
+ // session with the "what's new" page:
+ Services.prefs.setCharPref(
+ "browser.startup.homepage_override.mstone",
+ mstone
+ );
+ Services.prefs.setCharPref(
+ "browser.startup.homepage_override.buildID",
+ buildID
+ );
+ savePrefs();
+ aCallback(true);
+ },
+ function () {
+ aCallback(false);
+ }
+ );
+ },
+ };
+ }
+ }
+
+ // Sync/FxA related data
+ let sync = {
+ name: "sync", // name is used only by tests.
+ type: types.OTHERDATA,
+ migrate: async aCallback => {
+ // Try and parse a signedInUser.json file from the source directory and
+ // if we can, copy it to the new profile and set sync's username pref
+ // (which acts as a de-facto flag to indicate if sync is configured)
+ try {
+ let oldPath = PathUtils.join(
+ sourceProfileDir.path,
+ "signedInUser.json"
+ );
+ let exists = await IOUtils.exists(oldPath);
+ if (exists) {
+ let data = await IOUtils.readJSON(oldPath);
+ if (data && data.accountData && data.accountData.email) {
+ let username = data.accountData.email;
+ // copy the file itself.
+ await IOUtils.copy(
+ oldPath,
+ PathUtils.join(currentProfileDir.path, "signedInUser.json")
+ );
+ // Now we need to know whether Sync is actually configured for this
+ // user. The only way we know is by looking at the prefs file from
+ // the old profile. We avoid trying to do a full parse of the prefs
+ // file and even avoid parsing the single string value we care
+ // about.
+ let oldRawPrefs = await readOldPrefs();
+ if (/^user_pref\("services\.sync\.username"/m.test(oldRawPrefs)) {
+ // sync's configured in the source profile - ensure it is in the
+ // new profile too.
+ // Write it to prefs.js and flush the file.
+ Services.prefs.setStringPref(
+ "services.sync.username",
+ username
+ );
+ savePrefs();
+ }
+ }
+ }
+ } catch (ex) {
+ aCallback(false);
+ return;
+ }
+ aCallback(true);
+ },
+ };
+
+ // Telemetry related migrations.
+ let times = {
+ name: "times", // name is used only by tests.
+ type: types.OTHERDATA,
+ migrate: aCallback => {
+ let file = this._getFileObject(sourceProfileDir, "times.json");
+ if (file) {
+ file.copyTo(currentProfileDir, "");
+ }
+ // And record the fact a migration (ie, a reset) happened.
+ let recordMigration = async () => {
+ try {
+ let profileTimes = await lazy.ProfileAge(currentProfileDir.path);
+ await profileTimes.recordProfileReset();
+ aCallback(true);
+ } catch (e) {
+ aCallback(false);
+ }
+ };
+
+ recordMigration();
+ },
+ };
+ let telemetry = {
+ name: "telemetry", // name is used only by tests...
+ type: types.OTHERDATA,
+ migrate: async aCallback => {
+ let createSubDir = name => {
+ let dir = currentProfileDir.clone();
+ dir.append(name);
+ dir.create(Ci.nsIFile.DIRECTORY_TYPE, lazy.FileUtils.PERMS_DIRECTORY);
+ return dir;
+ };
+
+ // If the 'datareporting' directory exists we migrate files from it.
+ let dataReportingDir = this._getFileObject(
+ sourceProfileDir,
+ "datareporting"
+ );
+ if (dataReportingDir && dataReportingDir.isDirectory()) {
+ // Copy only specific files.
+ let toCopy = ["state.json", "session-state.json"];
+
+ let dest = createSubDir("datareporting");
+ let enumerator = dataReportingDir.directoryEntries;
+ while (enumerator.hasMoreElements()) {
+ let file = enumerator.nextFile;
+ if (file.isDirectory() || !toCopy.includes(file.leafName)) {
+ continue;
+ }
+ file.copyTo(dest, "");
+ }
+ }
+
+ try {
+ let oldRawPrefs = await readOldPrefs();
+ let writePrefs = false;
+ const PREFS = ["bookmarks", "csvpasswords", "history", "passwords"];
+
+ for (let pref of PREFS) {
+ let fullPref = `browser\.migrate\.interactions\.${pref}`;
+ let regex = new RegExp('^user_pref\\("' + fullPref, "m");
+ if (regex.test(oldRawPrefs)) {
+ Services.prefs.setBoolPref(fullPref, true);
+ writePrefs = true;
+ }
+ }
+
+ if (writePrefs) {
+ savePrefs();
+ }
+ } catch (e) {
+ aCallback(false);
+ return;
+ }
+
+ aCallback(true);
+ },
+ };
+
+ return [
+ places,
+ cookies,
+ passwords,
+ formData,
+ dictionary,
+ bookmarksBackups,
+ session,
+ sync,
+ times,
+ telemetry,
+ favicons,
+ ].filter(r => r);
+ }
+
+ get startupOnlyMigrator() {
+ return true;
+ }
+}