Adding upstream version 110.0.1.upstream/110.0.1upstream

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

1 files changed, 958 insertions, 0 deletions

diff --git a/browser/components/migration/MigrationUtils.sys.mjs b/browser/components/migration/MigrationUtils.sys.mjs
new file mode 100644
index 0000000000..4193e6d840
--- /dev/null
+++ b/browser/components/migration/MigrationUtils.sys.mjs
@@ -0,0 +1,958 @@
+/* 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/. */
+
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs",
+  PlacesUIUtils: "resource:///modules/PlacesUIUtils.sys.mjs",
+  Sqlite: "resource://gre/modules/Sqlite.sys.mjs",
+  setTimeout: "resource://gre/modules/Timer.sys.mjs",
+  WindowsRegistry: "resource://gre/modules/WindowsRegistry.sys.mjs",
+});
+ChromeUtils.defineModuleGetter(
+  lazy,
+  "LoginHelper",
+  "resource://gre/modules/LoginHelper.jsm"
+);
+
+var gMigrators = null;
+var gProfileStartup = null;
+var gL10n = null;
+var gPreviousDefaultBrowserKey = "";
+
+let gForceExitSpinResolve = false;
+let gKeepUndoData = false;
+let gUndoData = null;
+
+function getL10n() {
+  if (!gL10n) {
+    gL10n = new Localization(["browser/migration.ftl"]);
+  }
+  return gL10n;
+}
+
+const MIGRATOR_MODULES = Object.freeze({
+  EdgeProfileMigrator: {
+    moduleURI: "resource:///modules/EdgeProfileMigrator.sys.mjs",
+    platforms: ["win"],
+  },
+  FirefoxProfileMigrator: {
+    moduleURI: "resource:///modules/FirefoxProfileMigrator.sys.mjs",
+    platforms: ["linux", "macosx", "win"],
+  },
+  IEProfileMigrator: {
+    moduleURI: "resource:///modules/IEProfileMigrator.sys.mjs",
+    platforms: ["win"],
+  },
+  SafariProfileMigrator: {
+    moduleURI: "resource:///modules/SafariProfileMigrator.sys.mjs",
+    platforms: ["macosx"],
+  },
+
+  // The following migrators are all variants of the ChromeProfileMigrator
+
+  BraveProfileMigrator: {
+    moduleURI: "resource:///modules/ChromeProfileMigrator.sys.mjs",
+    platforms: ["linux", "macosx", "win"],
+  },
+  CanaryProfileMigrator: {
+    moduleURI: "resource:///modules/ChromeProfileMigrator.sys.mjs",
+    platforms: ["macosx", "win"],
+  },
+  ChromeProfileMigrator: {
+    moduleURI: "resource:///modules/ChromeProfileMigrator.sys.mjs",
+    platforms: ["linux", "macosx", "win"],
+  },
+  ChromeBetaMigrator: {
+    moduleURI: "resource:///modules/ChromeProfileMigrator.sys.mjs",
+    platforms: ["linux", "win"],
+  },
+  ChromeDevMigrator: {
+    moduleURI: "resource:///modules/ChromeProfileMigrator.sys.mjs",
+    platforms: ["linux"],
+  },
+  ChromiumProfileMigrator: {
+    moduleURI: "resource:///modules/ChromeProfileMigrator.sys.mjs",
+    platforms: ["linux", "macosx", "win"],
+  },
+  Chromium360seMigrator: {
+    moduleURI: "resource:///modules/ChromeProfileMigrator.sys.mjs",
+    platforms: ["win"],
+  },
+  ChromiumEdgeMigrator: {
+    moduleURI: "resource:///modules/ChromeProfileMigrator.sys.mjs",
+    platforms: ["macosx", "win"],
+  },
+  ChromiumEdgeBetaMigrator: {
+    moduleURI: "resource:///modules/ChromeProfileMigrator.sys.mjs",
+    platforms: ["macosx", "win"],
+  },
+  OperaProfileMigrator: {
+    moduleURI: "resource:///modules/ChromeProfileMigrator.sys.mjs",
+    platforms: ["linux", "macosx", "win"],
+  },
+  VivaldiProfileMigrator: {
+    moduleURI: "resource:///modules/ChromeProfileMigrator.sys.mjs",
+    platforms: ["linux", "macosx", "win"],
+  },
+  OperaGXProfileMigrator: {
+    moduleURI: "resource:///modules/ChromeProfileMigrator.sys.mjs",
+    platforms: ["macosx", "win"],
+  },
+});
+
+/**
+ * The singleton MigrationUtils service. This service is the primary mechanism
+ * by which migrations from other browsers to this browser occur. The singleton
+ * instance of this class is exported from this module as `MigrationUtils`.
+ */
+class MigrationUtils {
+  resourceTypes = Object.freeze({
+    ALL: 0x0000,
+    /* 0x01 used to be used for settings, but was removed. */
+    COOKIES: 0x0002,
+    HISTORY: 0x0004,
+    FORMDATA: 0x0008,
+    PASSWORDS: 0x0010,
+    BOOKMARKS: 0x0020,
+    OTHERDATA: 0x0040,
+    SESSION: 0x0080,
+  });
+
+  /**
+   * Helper for implementing simple asynchronous cases of migration resources'
+   * |migrate(aCallback)| (see MigratorBase).  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.
+   *
+   * @example
+   * // 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 {Function} 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 {Function} aCallback
+   *   the callback function passed to |migrate|.
+   * @returns {Function}
+   *   the wrapped function.
+   */
+  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 localized string corresponding to l10n-id
+   *
+   * @param {string} aKey
+   *   The key of the id of the localization to retrieve.
+   * @param {object} [aArgs=undefined]
+   *   An optional map of arguments to the id.
+   * @returns {Promise<string>}
+   *   A promise that resolves to the retrieved localization.
+   */
+  getLocalizedString(aKey, aArgs) {
+    let l10n = getL10n();
+    return l10n.formatValue(aKey, aArgs);
+  }
+
+  /**
+   * 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 {string} path
+   *   The file path to the database we want to open.
+   * @param {string} description
+   *   A developer-readable string identifying what kind of database we're
+   *   trying to open.
+   * @param {string} selectQuery
+   *   The SELECT query to use to fetch the rows.
+   *
+   * @returns {Promise<object[]|Error>}
+   *   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 (async 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 previousException = { message: null };
+        try {
+          db = await lazy.Sqlite.openConnection(dbOptions);
+          didOpen = true;
+          rows = await db.execute(selectQuery);
+        } catch (ex) {
+          if (previousException.message != ex.message) {
+            Cu.reportError(ex);
+          }
+          previousException = ex;
+        } finally {
+          try {
+            if (didOpen) {
+              await db.close();
+            }
+          } catch (ex) {}
+        }
+        if (previousException) {
+          await new Promise(resolve => lazy.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();
+      for (let [symbol, { moduleURI, platforms }] of Object.entries(
+        MIGRATOR_MODULES
+      )) {
+        if (platforms.includes(AppConstants.platform)) {
+          let { [symbol]: migratorClass } = ChromeUtils.importESModule(
+            moduleURI
+          );
+          if (gMigrators.has(migratorClass.key)) {
+            console.error(
+              "A pre-existing migrator exists with key " +
+                `${migratorClass.key}. Not registering.`
+            );
+            continue;
+          }
+          gMigrators.set(migratorClass.key, new migratorClass());
+        }
+      }
+    }
+    return gMigrators;
+  }
+
+  forceExitSpinResolve() {
+    gForceExitSpinResolve = true;
+  }
+
+  spinResolve(promise) {
+    if (!(promise instanceof Promise)) {
+      return promise;
+    }
+    let done = false;
+    let result = null;
+    let error = null;
+    gForceExitSpinResolve = false;
+    promise
+      .catch(e => {
+        error = e;
+      })
+      .then(r => {
+        result = r;
+        done = true;
+      });
+
+    Services.tm.spinEventLoopUntil(
+      "MigrationUtils.jsm:MU_spinResolve",
+      () => done || gForceExitSpinResolve
+    );
+    if (!done) {
+      throw new Error("Forcefully exited event loop.");
+    } else if (error) {
+      throw error;
+    } else {
+      return result;
+    }
+  }
+
+  /**
+   * Returns the migrator for the given source, if any data is available
+   * for this source, or null otherwise.
+   *
+   * 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).
+   *
+   * @param {string} aKey
+   *   Internal name of the migration source. See `availableMigratorKeys`
+   *   for supported values by OS.
+   *
+   * @returns {MigratorBase}
+   *   A profile migrator implementing nsIBrowserProfileMigrator, if it can
+   *   import any data, null otherwise.
+   */
+  async getMigrator(aKey) {
+    let migrator = this.#migrators.get(aKey);
+    if (!migrator) {
+      console.error(`Could not find a migrator class for key ${aKey}`);
+      return null;
+    }
+
+    try {
+      return migrator && (await migrator.isSourceAvailable()) ? migrator : null;
+    } catch (ex) {
+      Cu.reportError(ex);
+      return null;
+    }
+  }
+
+  /**
+   * Returns true if a migrator is registered with key aKey. No check is made
+   * to determine if a profile exists that the migrator can migrate from.
+   *
+   * @param {string} aKey
+   *   Internal name of the migration source. See `availableMigratorKeys`
+   *   for supported values by OS.
+   * @returns {boolean}
+   */
+  migratorExists(aKey) {
+    return this.#migrators.has(aKey);
+  }
+
+  /**
+   * 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.
+   *
+   * @returns {string}
+   */
+  getMigratorKeyForDefaultBrowser() {
+    // Canary uses the same description as Chrome so we can't distinguish them.
+    // Edge Beta on macOS uses "Microsoft Edge" with no "beta" indication.
+    const APP_DESC_TO_KEY = {
+      "Internet Explorer": "ie",
+      "Microsoft Edge": "edge",
+      Safari: "safari",
+      Firefox: "firefox",
+      Nightly: "firefox",
+      Opera: "opera",
+      Vivaldi: "vivaldi",
+      "Opera GX": "opera-gx",
+      "Brave Web Browser": "brave", // Windows, Linux
+      Brave: "brave", // OS X
+      "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": "chromium-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 = lazy.WindowsRegistry.readRegKey(
+          Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
+          kRegPath,
+          "OldDefaultBrowserCommand"
+        );
+        if (oldDefault) {
+          // Remove the key:
+          lazy.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;
+  }
+
+  /**
+   * True if we're in the process of a startup migration.
+   *
+   * @type {boolean}
+   */
+  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
+   * @type {nsIProfileStartup|null}
+   */
+  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 aOptions are ignored.
+   *
+   * NB: If you add new consumers, please add a migration entry point constant to
+   * MIGRATION_ENTRYPOINTS and supply that entrypoint with the entrypoint property
+   * in the aOptions argument.
+   *
+   * @param {Window} [aOpener=null]
+   *   optional; the window that asks to open the wizard.
+   * @param {object} [aOptions=null]
+   *   optional named arguments for the migration wizard.
+   * @param {number} [aOptions.entrypoint=undefined]
+   *   migration entry point constant. See MIGRATION_ENTRYPOINTS.
+   * @param {string} [aOptions.migratorKey=undefined]
+   *   The key for which migrator to use automatically. This is the key that is exposed
+   *   as a static getter on the migrator class.
+   * @param {MigratorBase} [aOptions.migrator=undefined]
+   *   A migrator instance to use automatically.
+   * @param {boolean} [aOptions.isStartupMigration=undefined]
+   *   True if this is a startup migration.
+   * @param {boolean} [aOptions.skipSourceSelection=undefined]
+   *   True if the source selection page of the wizard should be skipped.
+   * @param {string} [aOptions.profileId]
+   *   An identifier for the profile to use when migrating.
+   */
+  showMigrationWizard(aOpener, aOptions) {
+    const DIALOG_URL = "chrome://browser/content/migration/migration.xhtml";
+    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";
+    }
+
+    if (
+      Services.prefs.getBoolPref(
+        "browser.migrate.content-modal.enabled",
+        false
+      ) &&
+      aOpener &&
+      aOpener.gBrowser
+    ) {
+      const { gBrowser } = aOpener;
+      const { selectedBrowser } = gBrowser;
+      gBrowser.getTabDialogBox(selectedBrowser).open(DIALOG_URL, aOptions);
+    } else {
+      Services.ww.openWindow(aOpener, DIALOG_URL, "_blank", features, aOptions);
+    }
+  }
+
+  /**
+   * Show the migration wizard for startup-migration.  This should only be
+   * called by ProfileMigrator (see ProfileMigrator.js), which implements
+   * nsIProfileMigrator. This runs asynchronously if we are running an
+   * automigration.
+   *
+   * @param {nsIProfileStartup} aProfileStartup
+   *   the nsIProfileStartup instance provided to ProfileMigrator.migrate.
+   * @param {string|null} [aMigratorKey=null]
+   *   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.xhtml).
+   * @param {string|null} [aProfileToMigrate=null]
+   *   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(aProfileStartup, aMigratorKey, aProfileToMigrate) {
+    this.spinResolve(
+      this.asyncStartupMigration(
+        aProfileStartup,
+        aMigratorKey,
+        aProfileToMigrate
+      )
+    );
+  }
+
+  async asyncStartupMigration(
+    aProfileStartup,
+    aMigratorKey,
+    aProfileToMigrate
+  ) {
+    if (!aProfileStartup) {
+      throw new Error(
+        "an profile-startup instance is required for startup-migration"
+      );
+    }
+    gProfileStartup = aProfileStartup;
+
+    let skipSourceSelection = false,
+      migrator = null,
+      migratorKey = "";
+    if (aMigratorKey) {
+      migrator = await 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;
+      skipSourceSelection = true;
+    } else {
+      let defaultBrowserKey = this.getMigratorKeyForDefaultBrowser();
+      if (defaultBrowserKey) {
+        migrator = await this.getMigrator(defaultBrowserKey);
+        if (migrator) {
+          migratorKey = defaultBrowserKey;
+        }
+      }
+    }
+
+    if (!migrator) {
+      let migrators = await Promise.all(
+        this.availableMigratorKeys.map(key => this.getMigrator(key))
+      );
+      // 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 (!migrators.some(m => m)) {
+        // None of the keys produced a usable migrator, so finish up here:
+        this.finishMigration();
+        return;
+      }
+    }
+
+    let isRefresh =
+      migrator &&
+      skipSourceSelection &&
+      migratorKey == AppConstants.MOZ_APP_NAME;
+
+    let entrypoint = this.MIGRATION_ENTRYPOINTS.FIRSTRUN;
+    if (isRefresh) {
+      entrypoint = this.MIGRATION_ENTRYPOINTS.FXREFRESH;
+    }
+
+    this.showMigrationWizard(null, {
+      entrypoint,
+      migratorKey,
+      migrator,
+      isStartupMigration: !!aProfileStartup,
+      skipSourceSelection,
+      profileId: aProfileToMigrate,
+    });
+  }
+
+  /**
+   * This is only pseudo-private because some tests and helper functions
+   * still expect to be able to directly access it.
+   */
+  _importQuantities = {
+    bookmarks: 0,
+    logins: 0,
+    history: 0,
+  };
+
+  getImportedCount(type) {
+    if (!this._importQuantities.hasOwnProperty(type)) {
+      throw new Error(
+        `Unknown import data type "${type}" passed to getImportedCount`
+      );
+    }
+    return this._importQuantities[type];
+  }
+
+  insertBookmarkWrapper(bookmark) {
+    this._importQuantities.bookmarks++;
+    let insertionPromise = lazy.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;
+    });
+  }
+
+  insertManyBookmarksWrapper(bookmarks, parent) {
+    let insertionPromise = lazy.PlacesUtils.bookmarks.insertTree({
+      guid: parent,
+      children: bookmarks,
+    });
+    return insertionPromise.then(
+      insertedItems => {
+        this._importQuantities.bookmarks += insertedItems.length;
+        if (gKeepUndoData) {
+          let bmData = gUndoData.get("bookmarks");
+          for (let bm of insertedItems) {
+            let { parentGuid, guid, lastModified, type } = bm;
+            bmData.push({ parentGuid, guid, lastModified, type });
+          }
+        }
+        if (parent == lazy.PlacesUtils.bookmarks.toolbarGuid) {
+          lazy.PlacesUIUtils.maybeToggleBookmarkToolbarVisibility(
+            true /* aForceVisible */
+          );
+        }
+      },
+      ex => Cu.reportError(ex)
+    );
+  }
+
+  insertVisitsWrapper(pageInfos) {
+    let now = new Date();
+    // Ensure that none of the dates are in the future. If they are, rewrite
+    // them to be now. This means we don't loose history entries, but they will
+    // be valid for the history store.
+    for (let pageInfo of pageInfos) {
+      for (let visit of pageInfo.visits) {
+        if (visit.date && visit.date > now) {
+          visit.date = now;
+        }
+      }
+    }
+    this._importQuantities.history += pageInfos.length;
+    if (gKeepUndoData) {
+      this.#updateHistoryUndo(pageInfos);
+    }
+    return lazy.PlacesUtils.history.insertMany(pageInfos);
+  }
+
+  async insertLoginsWrapper(logins) {
+    this._importQuantities.logins += logins.length;
+    let inserted = await lazy.LoginHelper.maybeImportLogins(logins);
+    // 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 (gKeepUndoData) {
+      for (let { guid, timePasswordChanged } of inserted) {
+        gUndoData.get("logins").push({ guid, timePasswordChanged });
+      }
+    }
+  }
+
+  /**
+   * Iterates through the favicons, sniffs for a mime type,
+   * and uses the mime type to properly import the favicon.
+   *
+   * @param {object[]} favicons
+   *   An array of Objects with these properties:
+   *     {Uint8Array} faviconData: The binary data of a favicon
+   *     {nsIURI} uri: The URI of the associated page
+   */
+  insertManyFavicons(favicons) {
+    let sniffer = Cc["@mozilla.org/image/loader;1"].createInstance(
+      Ci.nsIContentSniffer
+    );
+    for (let faviconDataItem of favicons) {
+      let mimeType = sniffer.getMIMETypeFromContent(
+        null,
+        faviconDataItem.faviconData,
+        faviconDataItem.faviconData.length
+      );
+      let fakeFaviconURI = Services.io.newURI(
+        "fake-favicon-uri:" + faviconDataItem.uri.spec
+      );
+      lazy.PlacesUtils.favicons.replaceFaviconData(
+        fakeFaviconURI,
+        faviconDataItem.faviconData,
+        mimeType
+      );
+      lazy.PlacesUtils.favicons.setAndFetchFaviconForPage(
+        faviconDataItem.uri,
+        fakeFaviconURI,
+        true,
+        lazy.PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+        null,
+        Services.scriptSecurityManager.getSystemPrincipal()
+      );
+    }
+  }
+
+  initializeUndoData() {
+    gKeepUndoData = true;
+    gUndoData = new Map([
+      ["bookmarks", []],
+      ["visits", []],
+      ["logins", []],
+    ]);
+  }
+
+  async #postProcessUndoData(state) {
+    if (!state) {
+      return state;
+    }
+    let bookmarkFolders = state
+      .get("bookmarks")
+      .filter(b => b.type == lazy.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 lazy.PlacesUtils.bookmarks.fetch(guid).then(
+        bm => bm && bookmarkFolderData.push(bm),
+        () => {}
+      );
+    });
+
+    await 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(pageInfos) {
+    let visits = gUndoData.get("visits");
+    let visitMap = new Map(visits.map(v => [v.url, v]));
+    for (let pageInfo of pageInfos) {
+      let visitCount = pageInfo.visits.length;
+      let first, last;
+      if (visitCount > 1) {
+        let dates = pageInfo.visits.map(v => v.date);
+        first = Math.min.apply(Math, dates);
+        last = Math.max.apply(Math, dates);
+      } else {
+        first = last = pageInfo.visits[0].date;
+      }
+      let url = pageInfo.url;
+      if (url instanceof Ci.nsIURI) {
+        url = pageInfo.url.spec;
+      } else if (typeof url != "string") {
+        pageInfo.url.href;
+      }
+
+      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() {
+    gMigrators = null;
+    gProfileStartup = null;
+    gL10n = null;
+  }
+
+  get availableMigratorKeys() {
+    return [...this.#migrators.keys()];
+  }
+
+  /**
+   * Enum for the entrypoint that is being used to start migration.
+   * Callers can use the MIGRATION_ENTRYPOINTS getter to use these.
+   *
+   * These values are what's written into the FX_MIGRATION_ENTRY_POINT
+   * histogram after a migration.
+   *
+   * @see MIGRATION_ENTRYPOINTS
+   * @readonly
+   * @enum {number}
+   */
+  #MIGRATION_ENTRYPOINTS_ENUM = Object.freeze({
+    /** The entrypoint was not supplied */
+    UNKNOWN: 0,
+
+    /** Migration is occurring at startup */
+    FIRSTRUN: 1,
+
+    /** Migration is occurring at after a profile refresh */
+    FXREFRESH: 2,
+
+    /** Migration is being started from the Library window */
+    PLACES: 3,
+
+    /** Migration is being started from our password management UI */
+    PASSWORDS: 4,
+
+    /** Migration is being started from the default about:home/about:newtab */
+    NEWTAB: 5,
+
+    /** Migration is being started from the File menu */
+    FILE_MENU: 6,
+
+    /** Migration is being started from the Help menu */
+    HELP_MENU: 7,
+
+    /** Migration is being started from the Bookmarks Toolbar */
+    BOOKMARKS_TOOLBAR: 8,
+  });
+
+  /**
+   * Returns an enum that should be used to record the entrypoint for
+   * starting a migration.
+   *
+   * @returns {number}
+   */
+  get MIGRATION_ENTRYPOINTS() {
+    return this.#MIGRATION_ENTRYPOINTS_ENUM;
+  }
+
+  /**
+   * Enum for the numeric value written to the FX_MIGRATION_SOURCE_BROWSER,
+   * and FX_STARTUP_MIGRATION_EXISTING_DEFAULT_BROWSER histograms.
+   *
+   * @see getSourceIdForTelemetry
+   * @readonly
+   * @enum {number}
+   */
+  #SOURCE_NAME_TO_ID_MAPPING_ENUM = Object.freeze({
+    nothing: 1,
+    firefox: 2,
+    edge: 3,
+    ie: 4,
+    chrome: 5,
+    "chrome-beta": 5,
+    "chrome-dev": 5,
+    chromium: 6,
+    canary: 7,
+    safari: 8,
+    "chromium-360se": 9,
+    "chromium-edge": 10,
+    "chromium-edge-beta": 10,
+    brave: 11,
+    opera: 12,
+    "opera-gx": 14,
+    vivaldi: 13,
+  });
+
+  getSourceIdForTelemetry(sourceName) {
+    return this.#SOURCE_NAME_TO_ID_MAPPING_ENUM[sourceName] || 0;
+  }
+}
+
+const MigrationUtilsSingleton = new MigrationUtils();
+
+export { MigrationUtilsSingleton as MigrationUtils };