/* 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/. */ "use strict"; this.EXPORTED_SYMBOLS = ["MigrationUtils", "MigratorPrototype"]; const { classes: Cc, interfaces: Ci, results: Cr, utils: Cu } = Components; const TOPIC_WILL_IMPORT_BOOKMARKS = "initial-migration-will-import-default-bookmarks"; const TOPIC_DID_IMPORT_BOOKMARKS = "initial-migration-did-import-default-bookmarks"; const TOPIC_PLACES_DEFAULTS_FINISHED = "places-browser-init-complete"; Cu.import("resource://gre/modules/AppConstants.jsm"); Cu.import("resource://gre/modules/Services.jsm"); Cu.import("resource://gre/modules/Task.jsm"); Cu.import("resource://gre/modules/XPCOMUtils.jsm"); Cu.importGlobalProperties(["URL"]); XPCOMUtils.defineLazyModuleGetter(this, "AutoMigrate", "resource:///modules/AutoMigrate.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "BookmarkHTMLUtils", "resource://gre/modules/BookmarkHTMLUtils.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "LoginHelper", "resource://gre/modules/LoginHelper.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils", "resource://gre/modules/PlacesUtils.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "PromiseUtils", "resource://gre/modules/PromiseUtils.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "ResponsivenessMonitor", "resource://gre/modules/ResponsivenessMonitor.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "Sqlite", "resource://gre/modules/Sqlite.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "TelemetryStopwatch", "resource://gre/modules/TelemetryStopwatch.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "WindowsRegistry", "resource://gre/modules/WindowsRegistry.jsm"); var gMigrators = null; var gProfileStartup = null; var gMigrationBundle = null; var gPreviousDefaultBrowserKey = ""; let gKeepUndoData = false; let gUndoData = null; XPCOMUtils.defineLazyGetter(this, "gAvailableMigratorKeys", function() { if (AppConstants.platform == "win") { return [ "firefox", "edge", "ie", "chrome", "chromium", "360se", "canary" ]; } if (AppConstants.platform == "macosx") { return ["firefox", "safari", "chrome", "chromium", "canary"]; } if (AppConstants.XP_UNIX) { return ["firefox", "chrome", "chromium"]; } return []; }); function getMigrationBundle() { if (!gMigrationBundle) { gMigrationBundle = Services.strings.createBundle( "chrome://browser/locale/migration/migration.properties"); } return gMigrationBundle; } /** * Shared prototype for migrators, implementing nsIBrowserProfileMigrator. * * To implement a migrator: * 1. Import this module. * 2. Create the prototype for the migrator, extending MigratorPrototype. * Namely: MosaicMigrator.prototype = Object.create(MigratorPrototype); * 3. Set classDescription, contractID and classID for your migrator, and set * NSGetFactory appropriately. * 4. If the migrator supports multiple profiles, override the sourceProfiles * Here we default for single-profile migrator. * 5. Implement getResources(aProfile) (see below). * 6. If the migrator supports reading the home page of the source browser, * override |sourceHomePageURL| getter. * 7. For startup-only migrators, override |startupOnlyMigrator|. */ this.MigratorPrototype = { QueryInterface: XPCOMUtils.generateQI([Ci.nsIBrowserProfileMigrator]), /** * OVERRIDE IF AND ONLY IF the source supports multiple profiles. * * Returns array of profile objects from which data may be imported. The object * should have the following keys: * id - a unique string identifier for the profile * name - a pretty name to display to the user in the UI * * Only profiles from which data can be imported should be listed. Otherwise * the behavior of the migration wizard isn't well-defined. * * For a single-profile source (e.g. safari, ie), this returns null, * and not an empty array. That is the default implementation. */ get sourceProfiles() { return null; }, /** * MUST BE OVERRIDDEN. * * Returns an array of "migration resources" objects for the given profile, * or for the "default" profile, if the migrator does not support multiple * profiles. * * Each migration resource should provide: * - a |type| getter, returning any of the migration types (see * nsIBrowserProfileMigrator). * * - a |migrate| method, taking a single argument, aCallback(bool success), * for migrating the data for this resource. It may do its job * synchronously or asynchronously. Either way, it must call * aCallback(bool aSuccess) when it's done. In the case of an exception * thrown from |migrate|, it's taken as if aCallback(false) is called. * * Note: In the case of a simple asynchronous implementation, you may find * MigrationUtils.wrapMigrateFunction handy for handling aCallback easily. * * For each migration type listed in nsIBrowserProfileMigrator, multiple * migration resources may be provided. This practice is useful when the * data for a certain migration type is independently stored in few * locations. For example, the mac version of Safari stores its "reading list" * bookmarks in a separate property list. * * Note that the importation of a particular migration type is reported as * successful if _any_ of its resources succeeded to import (that is, called, * |aCallback(true)|). However, completion-status for a particular migration * type is reported to the UI only once all of its migrators have called * aCallback. * * @note The returned array should only include resources from which data * can be imported. So, for example, before adding a resource for the * BOOKMARKS migration type, you should check if you should check that the * bookmarks file exists. * * @param aProfile * The profile from which data may be imported, or an empty string * in the case of a single-profile migrator. * In the case of multiple-profiles migrator, it is guaranteed that * aProfile is a value returned by the sourceProfiles getter (see * above). */ getResources: function MP_getResources(/* aProfile */) { throw new Error("getResources must be overridden"); }, /** * OVERRIDE in order to provide an estimate of when the last time was * that somebody used the browser. It is OK that this is somewhat fuzzy - * history may not be available (or be wiped or not present due to e.g. * incognito mode). * * @return a Promise that resolves to the last used date. * * @note If not overridden, the promise will resolve to the unix epoch. */ getLastUsedDate() { return Promise.resolve(new Date(0)); }, /** * OVERRIDE IF AND ONLY IF the migrator is a startup-only migrator (For now, * that is just the Firefox migrator, see bug 737381). Default: false. * * Startup-only migrators are different in two ways: * - they may only be used during startup. * - the user-profile is half baked during migration. The folder exists, * but it's only accessible through MigrationUtils.profileStartup. * The migrator can call MigrationUtils.profileStartup.doStartup * at any point in order to initialize the profile. */ get startupOnlyMigrator() { return false; }, /** * OVERRIDE IF AND ONLY IF your migrator supports importing the homepage. * @see nsIBrowserProfileMigrator */ get sourceHomePageURL() { return ""; }, /** * Override if the data to migrate is locked/in-use and the user should * probably shutdown the source browser. */ get sourceLocked() { return false; }, /** * DO NOT OVERRIDE - After deCOMing migration, the UI will just call * getResources. * * @see nsIBrowserProfileMigrator */ getMigrateData: function MP_getMigrateData(aProfile) { let resources = this._getMaybeCachedResources(aProfile); if (!resources) { return []; } let types = resources.map(r => r.type); return types.reduce((a, b) => { a |= b; return a }, 0); }, getBrowserKey: function MP_getBrowserKey() { return this.contractID.match(/\=([^\=]+)$/)[1]; }, /** * DO NOT OVERRIDE - After deCOMing migration, the UI will just call * migrate for each resource. * * @see nsIBrowserProfileMigrator */ migrate: function MP_migrate(aItems, aStartup, aProfile) { let resources = this._getMaybeCachedResources(aProfile); if (resources.length == 0) throw new Error("migrate called for a non-existent source"); if (aItems != Ci.nsIBrowserProfileMigrator.ALL) resources = resources.filter(r => aItems & r.type); // Used to periodically give back control to the main-thread loop. let unblockMainThread = function() { return new Promise(resolve => { Services.tm.mainThread.dispatch(resolve, Ci.nsIThread.DISPATCH_NORMAL); }); }; let getHistogramIdForResourceType = (resourceType, template) => { if (resourceType == MigrationUtils.resourceTypes.HISTORY) { return template.replace("*", "HISTORY"); } if (resourceType == MigrationUtils.resourceTypes.BOOKMARKS) { return template.replace("*", "BOOKMARKS"); } if (resourceType == MigrationUtils.resourceTypes.PASSWORDS) { return template.replace("*", "LOGINS"); } return null; }; let browserKey = this.getBrowserKey(); let maybeStartTelemetryStopwatch = resourceType => { let histogramId = getHistogramIdForResourceType(resourceType, "FX_MIGRATION_*_IMPORT_MS"); if (histogramId) { TelemetryStopwatch.startKeyed(histogramId, browserKey); } return histogramId; }; let maybeStartResponsivenessMonitor = resourceType => { let responsivenessMonitor; let responsivenessHistogramId = getHistogramIdForResourceType(resourceType, "FX_MIGRATION_*_JANK_MS"); if (responsivenessHistogramId) { responsivenessMonitor = new ResponsivenessMonitor(); } return {responsivenessMonitor, responsivenessHistogramId}; }; let maybeFinishResponsivenessMonitor = (responsivenessMonitor, histogramId) => { if (responsivenessMonitor) { let accumulatedDelay = responsivenessMonitor.finish(); if (histogramId) { try { Services.telemetry.getKeyedHistogramById(histogramId) .add(browserKey, accumulatedDelay); } catch (ex) { Cu.reportError(histogramId + ": " + ex); } } } }; let collectQuantityTelemetry = () => { for (let resourceType of Object.keys(MigrationUtils._importQuantities)) { let histogramId = "FX_MIGRATION_" + resourceType.toUpperCase() + "_QUANTITY"; try { Services.telemetry.getKeyedHistogramById(histogramId) .add(browserKey, MigrationUtils._importQuantities[resourceType]); } catch (ex) { Cu.reportError(histogramId + ": " + ex); } } }; // Called either directly or through the bookmarks import callback. let doMigrate = Task.async(function*() { let resourcesGroupedByItems = new Map(); resources.forEach(function(resource) { if (!resourcesGroupedByItems.has(resource.type)) { resourcesGroupedByItems.set(resource.type, new Set()); } resourcesGroupedByItems.get(resource.type).add(resource); }); if (resourcesGroupedByItems.size == 0) throw new Error("No items to import"); let notify = function(aMsg, aItemType) { Services.obs.notifyObservers(null, aMsg, aItemType); }; for (let resourceType of Object.keys(MigrationUtils._importQuantities)) { MigrationUtils._importQuantities[resourceType] = 0; } notify("Migration:Started"); for (let [migrationType, itemResources] of resourcesGroupedByItems) { notify("Migration:ItemBeforeMigrate", migrationType); let stopwatchHistogramId = maybeStartTelemetryStopwatch(migrationType); let {responsivenessMonitor, responsivenessHistogramId} = maybeStartResponsivenessMonitor(migrationType); let itemSuccess = false; for (let res of itemResources) { let completeDeferred = PromiseUtils.defer(); let resourceDone = function(aSuccess) { itemResources.delete(res); itemSuccess |= aSuccess; if (itemResources.size == 0) { notify(itemSuccess ? "Migration:ItemAfterMigrate" : "Migration:ItemError", migrationType); resourcesGroupedByItems.delete(migrationType); if (stopwatchHistogramId) { TelemetryStopwatch.finishKeyed(stopwatchHistogramId, browserKey); } maybeFinishResponsivenessMonitor(responsivenessMonitor, responsivenessHistogramId); if (resourcesGroupedByItems.size == 0) { collectQuantityTelemetry(); notify("Migration:Ended"); } } completeDeferred.resolve(); }; // If migrate throws, an error occurred, and the callback // (itemMayBeDone) might haven't been called. try { res.migrate(resourceDone); } catch (ex) { Cu.reportError(ex); resourceDone(false); } // Certain resources must be ran sequentially or they could fail, // for example bookmarks and history (See bug 1272652). if (migrationType == MigrationUtils.resourceTypes.BOOKMARKS || migrationType == MigrationUtils.resourceTypes.HISTORY) { yield completeDeferred.promise; } yield unblockMainThread(); } } }); if (MigrationUtils.isStartupMigration && !this.startupOnlyMigrator) { MigrationUtils.profileStartup.doStartup(); // First import the default bookmarks. // Note: We do not need to do so for the Firefox migrator // (=startupOnlyMigrator), as it just copies over the places database // from another profile. Task.spawn(function* () { // Tell nsBrowserGlue we're importing default bookmarks. let browserGlue = Cc["@mozilla.org/browser/browserglue;1"]. getService(Ci.nsIObserver); browserGlue.observe(null, TOPIC_WILL_IMPORT_BOOKMARKS, ""); // Import the default bookmarks. We ignore whether or not we succeed. yield BookmarkHTMLUtils.importFromURL( "chrome://browser/locale/bookmarks.html", true).catch(r => r); // We'll tell nsBrowserGlue we've imported bookmarks, but before that // we need to make sure we're going to know when it's finished // initializing places: let placesInitedPromise = new Promise(resolve => { let onPlacesInited = function() { Services.obs.removeObserver(onPlacesInited, TOPIC_PLACES_DEFAULTS_FINISHED); resolve(); }; Services.obs.addObserver(onPlacesInited, TOPIC_PLACES_DEFAULTS_FINISHED, false); }); browserGlue.observe(null, TOPIC_DID_IMPORT_BOOKMARKS, ""); yield placesInitedPromise; doMigrate(); }); return; } doMigrate(); }, /** * DO NOT OVERRIDE - After deCOMing migration, this code * won't be part of the migrator itself. * * @see nsIBrowserProfileMigrator */ get sourceExists() { if (this.startupOnlyMigrator && !MigrationUtils.isStartupMigration) return false; // For a single-profile source, check if any data is available. // For multiple-profiles source, make sure that at least one // profile is available. let exists = false; try { let profiles = this.sourceProfiles; if (!profiles) { let resources = this._getMaybeCachedResources(""); if (resources && resources.length > 0) exists = true; } else { exists = profiles.length > 0; } } catch (ex) { Cu.reportError(ex); } return exists; }, /** * PRIVATE STUFF - DO NOT OVERRIDE ***/ _getMaybeCachedResources: function PMB__getMaybeCachedResources(aProfile) { let profileKey = aProfile ? aProfile.id : ""; if (this._resourcesByProfile) { if (profileKey in this._resourcesByProfile) return this._resourcesByProfile[profileKey]; } else { this._resourcesByProfile = { }; } this._resourcesByProfile[profileKey] = this.getResources(aProfile); return this._resourcesByProfile[profileKey]; } }; this.MigrationUtils = Object.freeze({ resourceTypes: { SETTINGS: Ci.nsIBrowserProfileMigrator.SETTINGS, COOKIES: Ci.nsIBrowserProfileMigrator.COOKIES, HISTORY: Ci.nsIBrowserProfileMigrator.HISTORY, FORMDATA: Ci.nsIBrowserProfileMigrator.FORMDATA, PASSWORDS: Ci.nsIBrowserProfileMigrator.PASSWORDS, BOOKMARKS: Ci.nsIBrowserProfileMigrator.BOOKMARKS, OTHERDATA: Ci.nsIBrowserProfileMigrator.OTHERDATA, SESSION: Ci.nsIBrowserProfileMigrator.SESSION, }, /** * Helper for implementing simple asynchronous cases of migration resources' * |migrate(aCallback)| (see MigratorPrototype). If your |migrate| method * just waits for some file to be read, for example, and then migrates * everything right away, you can wrap the async-function with this helper * and not worry about notifying the callback. * * For example, instead of writing: * setTimeout(function() { * try { * .... * aCallback(true); * } * catch() { * aCallback(false); * } * }, 0); * * You may write: * setTimeout(MigrationUtils.wrapMigrateFunction(function() { * if (importingFromMosaic) * throw Cr.NS_ERROR_UNEXPECTED; * }, aCallback), 0); * * ... and aCallback will be called with aSuccess=false when importing * from Mosaic, or with aSuccess=true otherwise. * * @param aFunction * the function that will be called sometime later. If aFunction * throws when it's called, aCallback(false) is called, otherwise * aCallback(true) is called. * @param aCallback * the callback function passed to |migrate|. * @return the wrapped function. */ wrapMigrateFunction: function MU_wrapMigrateFunction(aFunction, aCallback) { return function() { let success = false; try { aFunction.apply(null, arguments); success = true; } catch (ex) { Cu.reportError(ex); } // Do not change this to call aCallback directly in try try & catch // blocks, because if aCallback throws, we may end up calling aCallback // twice. aCallback(success); }; }, /** * Gets a string from the migration bundle. Shorthand for * nsIStringBundle.GetStringFromName, if aReplacements isn't passed, or for * nsIStringBundle.formatStringFromName if it is. * * This method also takes care of "bumped" keys (See bug 737381 comment 8 for * details). * * @param aKey * The key of the string to retrieve. * @param aReplacements * [optioanl] Array of replacements to run on the retrieved string. * @return the retrieved string. * * @see nsIStringBundle */ getLocalizedString: function MU_getLocalizedString(aKey, aReplacements) { aKey = aKey.replace(/_(canary|chromium)$/, "_chrome"); const OVERRIDES = { "4_firefox": "4_firefox_history_and_bookmarks", "64_firefox": "64_firefox_other" }; aKey = OVERRIDES[aKey] || aKey; if (aReplacements === undefined) return getMigrationBundle().GetStringFromName(aKey); return getMigrationBundle().formatStringFromName( aKey, aReplacements, aReplacements.length); }, _getLocalePropertyForBrowser(browserId) { switch (browserId) { case "edge": return "sourceNameEdge"; case "ie": return "sourceNameIE"; case "safari": return "sourceNameSafari"; case "canary": return "sourceNameCanary"; case "chrome": return "sourceNameChrome"; case "chromium": return "sourceNameChromium"; case "firefox": return "sourceNameFirefox"; case "360se": return "sourceName360se"; } return null; }, getBrowserName(browserId) { let prop = this._getLocalePropertyForBrowser(browserId); if (prop) { return this.getLocalizedString(prop); } return null; }, /** * Helper for creating a folder for imported bookmarks from a particular * migration source. The folder is created at the end of the given folder. * * @param sourceNameStr * the source name (first letter capitalized). This is used * for reading the localized source name from the migration * bundle (e.g. if aSourceNameStr is Mosaic, this will try to read * sourceNameMosaic from the migration bundle). * @param parentGuid * the GUID of the folder in which the new folder should be created. * @return the GUID of the new folder. */ createImportedBookmarksFolder: Task.async(function* (sourceNameStr, parentGuid) { let source = this.getLocalizedString("sourceName" + sourceNameStr); let title = this.getLocalizedString("importedBookmarksFolder", [source]); return (yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER, parentGuid, title })).guid; }), /** * Get all the rows corresponding to a select query from a database, without * requiring a lock on the database. If fetching data fails (because someone * else tried to write to the DB at the same time, for example), we will * retry the fetch after a 100ms timeout, up to 10 times. * * @param path * the file path to the database we want to open. * @param description * a developer-readable string identifying what kind of database we're * trying to open. * @param selectQuery * the SELECT query to use to fetch the rows. * * @return a promise that resolves to an array of rows. The promise will be * rejected if the read/fetch failed even after retrying. */ getRowsFromDBWithoutLocks(path, description, selectQuery) { let dbOptions = { readOnly: true, ignoreLockingMode: true, path, }; const RETRYLIMIT = 10; const RETRYINTERVAL = 100; return Task.spawn(function* innerGetRows() { let rows = null; for (let retryCount = RETRYLIMIT; retryCount && !rows; retryCount--) { // Attempt to get the rows. If this succeeds, we will bail out of the loop, // close the database in a failsafe way, and pass the rows back. // If fetching the rows throws, we will wait RETRYINTERVAL ms // and try again. This will repeat a maximum of RETRYLIMIT times. let db; let didOpen = false; let exceptionSeen; try { db = yield Sqlite.openConnection(dbOptions); didOpen = true; rows = yield db.execute(selectQuery); } catch (ex) { if (!exceptionSeen) { Cu.reportError(ex); } exceptionSeen = ex; } finally { try { if (didOpen) { yield db.close(); } } catch (ex) {} } if (exceptionSeen) { yield new Promise(resolve => setTimeout(resolve, RETRYINTERVAL)); } } if (!rows) { throw new Error("Couldn't get rows from the " + description + " database."); } return rows; }); }, get _migrators() { if (!gMigrators) { gMigrators = new Map(); } return gMigrators; }, /* * Returns the migrator for the given source, if any data is available * for this source, or null otherwise. * * @param aKey internal name of the migration source. * Supported values: ie (windows), * edge (windows), * safari (mac), * canary (mac/windows), * chrome (mac/windows/linux), * chromium (mac/windows/linux), * 360se (windows), * firefox. * * If null is returned, either no data can be imported * for the given migrator, or aMigratorKey is invalid (e.g. ie on mac, * or mosaic everywhere). This method should be used rather than direct * getService for future compatibility (see bug 718280). * * @return profile migrator implementing nsIBrowserProfileMigrator, if it can * import any data, null otherwise. */ getMigrator: function MU_getMigrator(aKey) { let migrator = null; if (this._migrators.has(aKey)) { migrator = this._migrators.get(aKey); } else { try { migrator = Cc["@mozilla.org/profile/migrator;1?app=browser&type=" + aKey].createInstance(Ci.nsIBrowserProfileMigrator); } catch (ex) { Cu.reportError(ex) } this._migrators.set(aKey, migrator); } try { return migrator && migrator.sourceExists ? migrator : null; } catch (ex) { Cu.reportError(ex); return null } }, /** * Figure out what is the default browser, and if there is a migrator * for it, return that migrator's internal name. * For the time being, the "internal name" of a migrator is its contract-id * trailer (e.g. ie for @mozilla.org/profile/migrator;1?app=browser&type=ie), * but it will soon be exposed properly. */ getMigratorKeyForDefaultBrowser() { // Canary uses the same description as Chrome so we can't distinguish them. const APP_DESC_TO_KEY = { "Internet Explorer": "ie", "Microsoft Edge": "edge", "Safari": "safari", "Firefox": "firefox", "Nightly": "firefox", "Google Chrome": "chrome", // Windows, Linux "Chrome": "chrome", // OS X "Chromium": "chromium", // Windows, OS X "Chromium Web Browser": "chromium", // Linux "360\u5b89\u5168\u6d4f\u89c8\u5668": "360se", }; let key = ""; try { let browserDesc = Cc["@mozilla.org/uriloader/external-protocol-service;1"] .getService(Ci.nsIExternalProtocolService) .getApplicationDescription("http"); key = APP_DESC_TO_KEY[browserDesc] || ""; // Handle devedition, as well as "FirefoxNightly" on OS X. if (!key && browserDesc.startsWith("Firefox")) { key = "firefox"; } } catch (ex) { Cu.reportError("Could not detect default browser: " + ex); } // "firefox" is the least useful entry here, and might just be because we've set // ourselves as the default (on Windows 7 and below). In that case, check if we // have a registry key that tells us where to go: if (key == "firefox" && AppConstants.isPlatformAndVersionAtMost("win", "6.2")) { // Because we remove the registry key, reading the registry key only works once. // We save the value for subsequent calls to avoid hard-to-trace bugs when multiple // consumers ask for this key. if (gPreviousDefaultBrowserKey) { key = gPreviousDefaultBrowserKey; } else { // We didn't have a saved value, so check the registry. const kRegPath = "Software\\Mozilla\\Firefox"; let oldDefault = WindowsRegistry.readRegKey( Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER, kRegPath, "OldDefaultBrowserCommand"); if (oldDefault) { // Remove the key: WindowsRegistry.removeRegKey( Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER, kRegPath, "OldDefaultBrowserCommand"); try { let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsILocalFileWin); file.initWithCommandLine(oldDefault); key = APP_DESC_TO_KEY[file.getVersionInfoField("FileDescription")] || key; // Save the value for future callers. gPreviousDefaultBrowserKey = key; } catch (ex) { Cu.reportError("Could not convert old default browser value to description."); } } } } return key; }, // Whether or not we're in the process of startup migration get isStartupMigration() { return gProfileStartup != null; }, /** * In the case of startup migration, this is set to the nsIProfileStartup * instance passed to ProfileMigrator's migrate. * * @see showMigrationWizard */ get profileStartup() { return gProfileStartup; }, /** * Show the migration wizard. On mac, this may just focus the wizard if it's * already running, in which case aOpener and aParams are ignored. * * @param {Window} [aOpener] * optional; the window that asks to open the wizard. * @param {Array} [aParams] * optional arguments for the migration wizard, in the form of an array * This is passed as-is for the params argument of * nsIWindowWatcher.openWindow. The array elements we expect are, in * order: * - {Number} migration entry point constant (see below) * - {String} source browser identifier * - {nsIBrowserProfileMigrator} actual migrator object * - {Boolean} whether this is a startup migration * - {Boolean} whether to skip the 'source' page * - {String} an identifier for the profile to use when migrating * NB: If you add new consumers, please add a migration entry point * constant below, and specify at least the first element of the array * (the migration entry point for purposes of telemetry). */ showMigrationWizard: function MU_showMigrationWizard(aOpener, aParams) { let features = "chrome,dialog,modal,centerscreen,titlebar,resizable=no"; if (AppConstants.platform == "macosx" && !this.isStartupMigration) { let win = Services.wm.getMostRecentWindow("Browser:MigrationWizard"); if (win) { win.focus(); return; } // On mac, the migration wiazrd should only be modal in the case of // startup-migration. features = "centerscreen,chrome,resizable=no"; } // nsIWindowWatcher doesn't deal with raw arrays, so we convert the input let params; if (Array.isArray(aParams)) { params = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray); for (let item of aParams) { let comtaminatedVal; if (item && item instanceof Ci.nsISupports) { comtaminatedVal = item; } else { switch (typeof item) { case "boolean": comtaminatedVal = Cc["@mozilla.org/supports-PRBool;1"]. createInstance(Ci.nsISupportsPRBool); comtaminatedVal.data = item; break; case "number": comtaminatedVal = Cc["@mozilla.org/supports-PRUint32;1"]. createInstance(Ci.nsISupportsPRUint32); comtaminatedVal.data = item; break; case "string": comtaminatedVal = Cc["@mozilla.org/supports-cstring;1"]. createInstance(Ci.nsISupportsCString); comtaminatedVal.data = item; break; case "undefined": case "object": if (!item) { comtaminatedVal = null; break; } /* intentionally falling through to error out here for non-null/undefined things: */ default: throw new Error("Unexpected parameter type " + (typeof item) + ": " + item); } } params.appendElement(comtaminatedVal, false); } } else { params = aParams; } Services.ww.openWindow(aOpener, "chrome://browser/content/migration/migration.xul", "_blank", features, params); }, /** * Show the migration wizard for startup-migration. This should only be * called by ProfileMigrator (see ProfileMigrator.js), which implements * nsIProfileMigrator. * * @param aProfileStartup * the nsIProfileStartup instance provided to ProfileMigrator.migrate. * @param [optional] aMigratorKey * If set, the migration wizard will import from the corresponding * migrator, bypassing the source-selection page. Otherwise, the * source-selection page will be displayed, either with the default * browser selected, if it could be detected and if there is a * migrator for it, or with the first option selected as a fallback * (The first option is hardcoded to be the most common browser for * the OS we run on. See migration.xul). * @param [optional] aProfileToMigrate * If set, the migration wizard will import from the profile indicated. * @throws if aMigratorKey is invalid or if it points to a non-existent * source. */ startupMigration: function MU_startupMigrator(aProfileStartup, aMigratorKey, aProfileToMigrate) { if (!aProfileStartup) { throw new Error("an profile-startup instance is required for startup-migration"); } gProfileStartup = aProfileStartup; let skipSourcePage = false, migrator = null, migratorKey = ""; if (aMigratorKey) { migrator = this.getMigrator(aMigratorKey); if (!migrator) { // aMigratorKey must point to a valid source, so, if it doesn't // cleanup and throw. this.finishMigration(); throw new Error("startMigration was asked to open auto-migrate from " + "a non-existent source: " + aMigratorKey); } migratorKey = aMigratorKey; skipSourcePage = true; } else { let defaultBrowserKey = this.getMigratorKeyForDefaultBrowser(); if (defaultBrowserKey) { migrator = this.getMigrator(defaultBrowserKey); if (migrator) migratorKey = defaultBrowserKey; } } if (!migrator) { // If there's no migrator set so far, ensure that there is at least one // migrator available before opening the wizard. // Note that we don't need to check the default browser first, because // if that one existed we would have used it in the block above this one. if (!gAvailableMigratorKeys.some(key => !!this.getMigrator(key))) { // None of the keys produced a usable migrator, so finish up here: this.finishMigration(); return; } } let isRefresh = migrator && skipSourcePage && migratorKey == AppConstants.MOZ_APP_NAME; if (!isRefresh && AutoMigrate.enabled) { try { AutoMigrate.migrate(aProfileStartup, migratorKey, aProfileToMigrate); return; } catch (ex) { // If automigration failed, continue and show the dialog. Cu.reportError(ex); } } let migrationEntryPoint = this.MIGRATION_ENTRYPOINT_FIRSTRUN; if (isRefresh) { migrationEntryPoint = this.MIGRATION_ENTRYPOINT_FXREFRESH; } let params = [ migrationEntryPoint, migratorKey, migrator, aProfileStartup, skipSourcePage, aProfileToMigrate, ]; this.showMigrationWizard(null, params); }, _importQuantities: { bookmarks: 0, logins: 0, history: 0, }, insertBookmarkWrapper(bookmark) { this._importQuantities.bookmarks++; let insertionPromise = PlacesUtils.bookmarks.insert(bookmark); if (!gKeepUndoData) { return insertionPromise; } // If we keep undo data, add a promise handler that stores the undo data once // the bookmark has been inserted in the DB, and then returns the bookmark. let {parentGuid} = bookmark; return insertionPromise.then(bm => { let {guid, lastModified, type} = bm; gUndoData.get("bookmarks").push({ parentGuid, guid, lastModified, type }); return bm; }); }, insertVisitsWrapper(places, options) { this._importQuantities.history += places.length; if (gKeepUndoData) { this._updateHistoryUndo(places); } return PlacesUtils.asyncHistory.updatePlaces(places, options); }, insertLoginWrapper(login) { this._importQuantities.logins++; let insertedLogin = LoginHelper.maybeImportLogin(login); // Note that this means that if we import a login that has a newer password // than we know about, we will update the login, and an undo of the import // will not revert this. This seems preferable over removing the login // outright or storing the old password in the undo file. if (insertedLogin && gKeepUndoData) { let {guid, timePasswordChanged} = insertedLogin; gUndoData.get("logins").push({guid, timePasswordChanged}); } }, initializeUndoData() { gKeepUndoData = true; gUndoData = new Map([["bookmarks", []], ["visits", []], ["logins", []]]); }, _postProcessUndoData: Task.async(function*(state) { if (!state) { return state; } let bookmarkFolders = state.get("bookmarks").filter(b => b.type == PlacesUtils.bookmarks.TYPE_FOLDER); let bookmarkFolderData = []; let bmPromises = bookmarkFolders.map(({guid}) => { // Ignore bookmarks where the promise doesn't resolve (ie that are missing) // Also check that the bookmark fetch returns isn't null before adding it. return PlacesUtils.bookmarks.fetch(guid).then(bm => bm && bookmarkFolderData.push(bm), () => {}); }); yield Promise.all(bmPromises); let folderLMMap = new Map(bookmarkFolderData.map(b => [b.guid, b.lastModified])); for (let bookmark of bookmarkFolders) { let lastModified = folderLMMap.get(bookmark.guid); // If the bookmark was deleted, the map will be returning null, so check: if (lastModified) { bookmark.lastModified = lastModified; } } return state; }), stopAndRetrieveUndoData() { let undoData = gUndoData; gUndoData = null; gKeepUndoData = false; return this._postProcessUndoData(undoData); }, _updateHistoryUndo(places) { let visits = gUndoData.get("visits"); let visitMap = new Map(visits.map(v => [v.url, v])); for (let place of places) { let visitCount = place.visits.length; let first = Math.min.apply(Math, place.visits.map(v => v.visitDate)); let last = Math.max.apply(Math, place.visits.map(v => v.visitDate)); let url = place.uri.spec; try { new URL(url); } catch (ex) { // This won't save and we won't need to 'undo' it, so ignore this URL. continue; } if (!visitMap.has(url)) { visitMap.set(url, {url, visitCount, first, last}); } else { let currentData = visitMap.get(url); currentData.visitCount += visitCount; currentData.first = Math.min(currentData.first, first); currentData.last = Math.max(currentData.last, last); } } gUndoData.set("visits", Array.from(visitMap.values())); }, /** * Cleans up references to migrators and nsIProfileInstance instances. */ finishMigration: function MU_finishMigration() { gMigrators = null; gProfileStartup = null; gMigrationBundle = null; }, gAvailableMigratorKeys, MIGRATION_ENTRYPOINT_UNKNOWN: 0, MIGRATION_ENTRYPOINT_FIRSTRUN: 1, MIGRATION_ENTRYPOINT_FXREFRESH: 2, MIGRATION_ENTRYPOINT_PLACES: 3, MIGRATION_ENTRYPOINT_PASSWORDS: 4, _sourceNameToIdMapping: { "nothing": 1, "firefox": 2, "edge": 3, "ie": 4, "chrome": 5, "chromium": 6, "canary": 7, "safari": 8, "360se": 9, }, getSourceIdForTelemetry(sourceName) { return this._sourceNameToIdMapping[sourceName] || 0; }, });