Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 834 insertions, 0 deletions

diff --git a/browser/components/migration/MigrationWizardParent.sys.mjs b/browser/components/migration/MigrationWizardParent.sys.mjs
new file mode 100644
index 0000000000..deb0e89007
--- /dev/null
+++ b/browser/components/migration/MigrationWizardParent.sys.mjs
@@ -0,0 +1,834 @@
+/* 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";
+import { MigrationUtils } from "resource:///modules/MigrationUtils.sys.mjs";
+import { E10SUtils } from "resource://gre/modules/E10SUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineLazyGetter(lazy, "gFluentStrings", function () {
+  return new Localization([
+    "branding/brand.ftl",
+    "browser/migrationWizard.ftl",
+  ]);
+});
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  FirefoxProfileMigrator: "resource:///modules/FirefoxProfileMigrator.sys.mjs",
+  InternalTestingProfileMigrator:
+    "resource:///modules/InternalTestingProfileMigrator.sys.mjs",
+  LoginCSVImport: "resource://gre/modules/LoginCSVImport.sys.mjs",
+  MigrationWizardConstants:
+    "chrome://browser/content/migration/migration-wizard-constants.mjs",
+  PasswordFileMigrator: "resource:///modules/FileMigrators.sys.mjs",
+});
+
+if (AppConstants.platform == "macosx") {
+  ChromeUtils.defineESModuleGetters(lazy, {
+    SafariProfileMigrator: "resource:///modules/SafariProfileMigrator.sys.mjs",
+  });
+}
+
+/**
+ * Set to true once the first instance of MigrationWizardParent has received
+ * a "GetAvailableMigrators" message.
+ */
+let gHasOpenedBefore = false;
+
+/**
+ * This class is responsible for communicating with MigrationUtils to do the
+ * actual heavy-lifting of any kinds of migration work, based on messages from
+ * the associated MigrationWizardChild.
+ */
+export class MigrationWizardParent extends JSWindowActorParent {
+  constructor() {
+    super();
+    Services.telemetry.setEventRecordingEnabled("browser.migration", true);
+  }
+
+  didDestroy() {
+    Services.obs.notifyObservers(this, "MigrationWizard:Destroyed");
+    MigrationUtils.finishMigration();
+  }
+
+  /**
+   * General message handler function for messages received from the
+   * associated MigrationWizardChild JSWindowActor.
+   *
+   * @param {ReceiveMessageArgument} message
+   *   The message received from the MigrationWizardChild.
+   * @returns {Promise}
+   */
+  async receiveMessage(message) {
+    // Some belt-and-suspenders here, mainly because the migration-wizard
+    // component can be embedded in less privileged content pages, so let's
+    // make sure that any messages from content are coming from the privileged
+    // about content process type.
+    if (
+      !this.browsingContext.currentWindowGlobal.isInProcess &&
+      this.browsingContext.currentRemoteType !=
+        E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE
+    ) {
+      throw new Error(
+        "MigrationWizardParent: received message from the wrong content process type."
+      );
+    }
+
+    switch (message.name) {
+      case "GetAvailableMigrators": {
+        let start = Cu.now();
+
+        let availableMigrators = [];
+        for (const key of MigrationUtils.availableMigratorKeys) {
+          availableMigrators.push(this.#getMigratorAndProfiles(key));
+        }
+
+        // Wait for all getMigrator calls to resolve in parallel
+        let results = await Promise.all(availableMigrators);
+
+        for (const migrator of MigrationUtils.availableFileMigrators.values()) {
+          results.push(await this.#serializeFileMigrator(migrator));
+        }
+
+        // Each migrator might give us a single MigratorProfileInstance,
+        // or an Array of them, so we flatten them out and filter out
+        // any that ended up going wrong and returning null from the
+        // #getMigratorAndProfiles call.
+        let filteredResults = results
+          .flat()
+          .filter(result => result)
+          .sort((a, b) => {
+            return b.lastModifiedDate - a.lastModifiedDate;
+          });
+
+        let elapsed = Cu.now() - start;
+        if (!gHasOpenedBefore) {
+          gHasOpenedBefore = true;
+          Services.telemetry.scalarSet(
+            "migration.time_to_produce_migrator_list",
+            elapsed
+          );
+        }
+
+        return filteredResults;
+      }
+
+      case "Migrate": {
+        let { migrationDetails, extraArgs } = message.data;
+        if (
+          migrationDetails.type ==
+          lazy.MigrationWizardConstants.MIGRATOR_TYPES.BROWSER
+        ) {
+          return this.#doBrowserMigration(migrationDetails, extraArgs);
+        } else if (
+          migrationDetails.type ==
+          lazy.MigrationWizardConstants.MIGRATOR_TYPES.FILE
+        ) {
+          let window = this.browsingContext.topChromeWindow;
+          await this.#doFileMigration(window, migrationDetails.key);
+          return extraArgs;
+        }
+        break;
+      }
+
+      case "CheckPermissions": {
+        if (
+          message.data.type ==
+          lazy.MigrationWizardConstants.MIGRATOR_TYPES.BROWSER
+        ) {
+          let migrator = await MigrationUtils.getMigrator(message.data.key);
+          return migrator.hasPermissions();
+        }
+        return true;
+      }
+
+      case "RequestSafariPermissions": {
+        let safariMigrator = await MigrationUtils.getMigrator("safari");
+        return safariMigrator.getPermissions(
+          this.browsingContext.topChromeWindow
+        );
+      }
+
+      case "SelectSafariPasswordFile": {
+        return this.#selectSafariPasswordFile(
+          this.browsingContext.topChromeWindow
+        );
+      }
+
+      case "RecordEvent": {
+        this.#recordEvent(message.data.type, message.data.args);
+        break;
+      }
+
+      case "OpenAboutAddons": {
+        let browser = this.browsingContext.top.embedderElement;
+        this.#openAboutAddons(browser);
+        break;
+      }
+
+      case "GetPermissions": {
+        let migrator = await MigrationUtils.getMigrator(message.data.key);
+        return migrator.getPermissions(this.browsingContext.topChromeWindow);
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Used for recording telemetry in the migration wizard.
+   *
+   * @param {string} type
+   *   The type of event being recorded.
+   * @param {object} args
+   *   The data to pass to telemetry when the event is recorded.
+   */
+  #recordEvent(type, args = null) {
+    Services.telemetry.recordEvent(
+      "browser.migration",
+      type,
+      "wizard",
+      null,
+      args
+    );
+  }
+
+  /**
+   * Gets the FileMigrator associated with the passed in key, and then opens
+   * a native file picker configured for that migrator. Once the user selects
+   * a file from the native file picker, this is then passed to the
+   * FileMigrator.migrate method.
+   *
+   * As the migration occurs, this will send UpdateProgress messages to the
+   * MigrationWizardChild to show the beginning and then the ending state of
+   * the migration.
+   *
+   * @param {DOMWindow} window
+   *   The window that the native file picker should be associated with. This
+   *   cannot be null. See nsIFilePicker.init for more details.
+   * @param {string} key
+   *   The unique identification key for a file migrator.
+   * @returns {Promise<undefined>}
+   *   Resolves once the file migrator's migrate method has resolved.
+   */
+  async #doFileMigration(window, key) {
+    let fileMigrator = MigrationUtils.getFileMigrator(key);
+    let filePickerConfig = await fileMigrator.getFilePickerConfig();
+
+    let { result, path } = await new Promise(resolve => {
+      let fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);
+      fp.init(window, filePickerConfig.title, Ci.nsIFilePicker.modeOpen);
+
+      for (let filter of filePickerConfig.filters) {
+        fp.appendFilter(filter.title, filter.extensionPattern);
+      }
+      fp.appendFilters(Ci.nsIFilePicker.filterAll);
+      fp.open(async fileOpenResult => {
+        resolve({ result: fileOpenResult, path: fp.file.path });
+      });
+    });
+
+    if (result == Ci.nsIFilePicker.returnCancel) {
+      // If the user cancels out of the file picker, the migration wizard should
+      // still be in the state that lets the user re-open the file picker if
+      // they closed it by accident, so we don't have to do anything else here.
+      return;
+    }
+
+    let progress = {};
+    for (let resourceType of fileMigrator.displayedResourceTypes) {
+      progress[resourceType] = {
+        value: lazy.MigrationWizardConstants.PROGRESS_VALUE.LOADING,
+        message: "",
+      };
+    }
+
+    let [progressHeaderString, successHeaderString] =
+      await lazy.gFluentStrings.formatValues([
+        fileMigrator.progressHeaderL10nID,
+        fileMigrator.successHeaderL10nID,
+      ]);
+
+    this.sendAsyncMessage("UpdateFileImportProgress", {
+      title: progressHeaderString,
+      progress,
+    });
+
+    let migrationResult;
+    try {
+      migrationResult = await fileMigrator.migrate(path);
+    } catch (e) {
+      this.sendAsyncMessage("FileImportProgressError", {
+        migratorKey: key,
+        fileImportErrorMessage: e.message,
+      });
+      return;
+    }
+
+    let successProgress = {};
+    for (let resourceType in migrationResult) {
+      successProgress[resourceType] = {
+        value: lazy.MigrationWizardConstants.PROGRESS_VALUE.SUCCESS,
+        message: migrationResult[resourceType],
+      };
+    }
+    this.sendAsyncMessage("UpdateFileImportProgress", {
+      title: successHeaderString,
+      progress: successProgress,
+    });
+  }
+
+  /**
+   * Handles a request to open a native file picker to get the path to a
+   * CSV file that contains passwords exported from Safari. The returned
+   * path is in the form of a string, or `null` if the user cancelled the
+   * native picker.
+   *
+   * @param {DOMWindow} window
+   *   The window that the native file picker should be associated with. This
+   *   cannot be null. See nsIFilePicker.init for more details.
+   * @returns {Promise<string|null>}
+   */
+  async #selectSafariPasswordFile(window) {
+    let fileMigrator = MigrationUtils.getFileMigrator(
+      lazy.PasswordFileMigrator.key
+    );
+    let filePickerConfig = await fileMigrator.getFilePickerConfig();
+
+    let { result, path } = await new Promise(resolve => {
+      let fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);
+      fp.init(window, filePickerConfig.title, Ci.nsIFilePicker.modeOpen);
+
+      for (let filter of filePickerConfig.filters) {
+        fp.appendFilter(filter.title, filter.extensionPattern);
+      }
+      fp.appendFilters(Ci.nsIFilePicker.filterAll);
+      fp.open(async fileOpenResult => {
+        resolve({ result: fileOpenResult, path: fp.file.path });
+      });
+    });
+
+    if (result == Ci.nsIFilePicker.returnCancel) {
+      // If the user cancels out of the file picker, the migration wizard should
+      // still be in the state that lets the user re-open the file picker if
+      // they closed it by accident, so we don't have to do anything else here.
+      return null;
+    }
+
+    return path;
+  }
+
+  /**
+   * Calls into MigrationUtils to perform a migration given the parameters
+   * sent via the wizard.
+   *
+   * @param {MigrationDetails} migrationDetails
+   *   See migration-wizard.mjs for a definition of MigrationDetails.
+   * @param {object} extraArgs
+   *   Extra argument object that will be passed to the Event Telemetry for
+   *   finishing the migration. This was initialized in the child actor, and
+   *   will be sent back down to it to write to Telemetry once migration
+   *   completes.
+   *
+   * @returns {Promise<object>}
+   *   Resolves once the Migration:Ended observer notification has fired,
+   *   passing the extraArgs for Telemetry back with any relevant properties
+   *   updated.
+   */
+  async #doBrowserMigration(migrationDetails, extraArgs) {
+    Services.telemetry
+      .getHistogramById("FX_MIGRATION_SOURCE_BROWSER")
+      .add(MigrationUtils.getSourceIdForTelemetry(migrationDetails.key));
+
+    let migrator = await MigrationUtils.getMigrator(migrationDetails.key);
+    let availableResourceTypes = await migrator.getMigrateData(
+      migrationDetails.profile
+    );
+    let resourceTypesToMigrate = 0;
+    let progress = {};
+    let migrationUsageHist =
+      Services.telemetry.getKeyedHistogramById("FX_MIGRATION_USAGE");
+
+    for (let resourceTypeName of migrationDetails.resourceTypes) {
+      let resourceType = MigrationUtils.resourceTypes[resourceTypeName];
+      if (availableResourceTypes & resourceType) {
+        resourceTypesToMigrate |= resourceType;
+        progress[resourceTypeName] = {
+          value: lazy.MigrationWizardConstants.PROGRESS_VALUE.LOADING,
+          message: "",
+        };
+
+        if (!migrationDetails.autoMigration) {
+          migrationUsageHist.add(migrationDetails.key, Math.log2(resourceType));
+        }
+      }
+    }
+
+    if (
+      migrationDetails.key == lazy.SafariProfileMigrator?.key &&
+      migrationDetails.safariPasswordFilePath
+    ) {
+      // The caller supplied a password export file for Safari. We're going to
+      // pretend that there was a PASSWORDS resource for Safari to represent
+      // the state of importing from that file.
+      progress[
+        lazy.MigrationWizardConstants.DISPLAYED_RESOURCE_TYPES.PASSWORDS
+      ] = {
+        value: lazy.MigrationWizardConstants.PROGRESS_VALUE.LOADING,
+        message: "",
+      };
+
+      this.sendAsyncMessage("UpdateProgress", {
+        key: migrationDetails.key,
+        progress,
+      });
+
+      try {
+        let summary = await lazy.LoginCSVImport.importFromCSV(
+          migrationDetails.safariPasswordFilePath
+        );
+        let quantity = summary.filter(entry => entry.result == "added").length;
+
+        progress[
+          lazy.MigrationWizardConstants.DISPLAYED_RESOURCE_TYPES.PASSWORDS
+        ] = {
+          value: lazy.MigrationWizardConstants.PROGRESS_VALUE.SUCCESS,
+          message: await lazy.gFluentStrings.formatValue(
+            "migration-wizard-progress-success-passwords",
+            {
+              quantity,
+            }
+          ),
+        };
+      } catch (e) {
+        progress[
+          lazy.MigrationWizardConstants.DISPLAYED_RESOURCE_TYPES.PASSWORDS
+        ] = {
+          value: lazy.MigrationWizardConstants.PROGRESS_VALUE.WARNING,
+          message: await lazy.gFluentStrings.formatValue(
+            "migration-passwords-from-file-no-valid-data"
+          ),
+        };
+      }
+    }
+
+    this.sendAsyncMessage("UpdateProgress", {
+      key: migrationDetails.key,
+      progress,
+    });
+
+    // It's possible that only a Safari password file path was sent up, and
+    // there's nothing left to migrate, in which case we're done here.
+    if (
+      migrationDetails.safariPasswordFilePath &&
+      !migrationDetails.resourceTypes.length
+    ) {
+      return extraArgs;
+    }
+
+    try {
+      await migrator.migrate(
+        resourceTypesToMigrate,
+        false,
+        migrationDetails.profile,
+        async (resourceTypeNum, success, details) => {
+          // Unfortunately, MigratorBase hands us the the numeric value of the
+          // MigrationUtils.resourceType for this callback. For now, we'll just
+          // do a look-up to map it to the right constant.
+          let foundResourceTypeName;
+          for (let resourceTypeName in MigrationUtils.resourceTypes) {
+            if (
+              MigrationUtils.resourceTypes[resourceTypeName] == resourceTypeNum
+            ) {
+              foundResourceTypeName = resourceTypeName;
+              break;
+            }
+          }
+
+          if (!foundResourceTypeName) {
+            console.error(
+              "Could not find a resource type for value: ",
+              resourceTypeNum
+            );
+          } else {
+            if (!success) {
+              Services.telemetry
+                .getKeyedHistogramById("FX_MIGRATION_ERRORS")
+                .add(migrationDetails.key, Math.log2(resourceTypeNum));
+            }
+            if (
+              foundResourceTypeName ==
+              lazy.MigrationWizardConstants.DISPLAYED_RESOURCE_TYPES.EXTENSIONS
+            ) {
+              if (!success) {
+                // did not match any extensions
+                extraArgs.extensions =
+                  lazy.MigrationWizardConstants.EXTENSIONS_IMPORT_RESULT.NONE_MATCHED;
+                progress[foundResourceTypeName] = {
+                  value: lazy.MigrationWizardConstants.PROGRESS_VALUE.WARNING,
+                  message: await lazy.gFluentStrings.formatValue(
+                    "migration-wizard-progress-no-matched-extensions"
+                  ),
+                  linkURL: Services.urlFormatter.formatURLPref(
+                    "extensions.getAddons.link.url"
+                  ),
+                  linkText: await lazy.gFluentStrings.formatValue(
+                    "migration-wizard-progress-extensions-addons-link"
+                  ),
+                };
+              } else if (
+                details?.progressValue ==
+                lazy.MigrationWizardConstants.PROGRESS_VALUE.SUCCESS
+              ) {
+                // did match all extensions
+                extraArgs.extensions =
+                  lazy.MigrationWizardConstants.EXTENSIONS_IMPORT_RESULT.ALL_MATCHED;
+                progress[foundResourceTypeName] = {
+                  value: lazy.MigrationWizardConstants.PROGRESS_VALUE.SUCCESS,
+                  message: await lazy.gFluentStrings.formatValue(
+                    "migration-wizard-progress-success-extensions",
+                    {
+                      quantity: details.totalExtensions.length,
+                    }
+                  ),
+                };
+              } else if (
+                details?.progressValue ==
+                lazy.MigrationWizardConstants.PROGRESS_VALUE.INFO
+              ) {
+                // did match some extensions
+                extraArgs.extensions =
+                  lazy.MigrationWizardConstants.EXTENSIONS_IMPORT_RESULT.PARTIAL_MATCH;
+                progress[foundResourceTypeName] = {
+                  value: lazy.MigrationWizardConstants.PROGRESS_VALUE.INFO,
+                  message: await lazy.gFluentStrings.formatValue(
+                    "migration-wizard-progress-partial-success-extensions",
+                    {
+                      matched: details.importedExtensions.length,
+                      quantity: details.totalExtensions.length,
+                    }
+                  ),
+                  linkURL:
+                    Services.urlFormatter.formatURLPref("app.support.baseURL") +
+                    "import-data-another-browser",
+                  linkText: await lazy.gFluentStrings.formatValue(
+                    "migration-wizard-progress-extensions-support-link"
+                  ),
+                };
+              }
+            } else {
+              progress[foundResourceTypeName] = {
+                value: success
+                  ? lazy.MigrationWizardConstants.PROGRESS_VALUE.SUCCESS
+                  : lazy.MigrationWizardConstants.PROGRESS_VALUE.WARNING,
+                message: await this.#getStringForImportQuantity(
+                  migrationDetails.key,
+                  foundResourceTypeName
+                ),
+              };
+            }
+            this.sendAsyncMessage("UpdateProgress", {
+              key: migrationDetails.key,
+              progress,
+            });
+          }
+        }
+      );
+    } catch (e) {
+      console.error(e);
+    }
+
+    return extraArgs;
+  }
+
+  /**
+   * @typedef {object} MigratorProfileInstance
+   *   An object that describes a single user profile (or the default
+   *   user profile) for a particular migrator.
+   * @property {string} key
+   *   The unique identification key for a migrator.
+   * @property {string} displayName
+   *   The display name for the migrator that will be shown to the user
+   *   in the wizard.
+   * @property {string[]} resourceTypes
+   *   An array of strings, where each string represents a resource type
+   *   that can be imported for this migrator and profile. The strings
+   *   should be one of the key values of
+   *   MigrationWizardConstants.DISPLAYED_RESOURCE_TYPES.
+   *
+   *   Example: ["HISTORY", "FORMDATA", "PASSWORDS", "BOOKMARKS"]
+   * @property {object|null} profile
+   *   A description of the user profile that the migrator can import.
+   * @property {string} profile.id
+   *   A unique ID for the user profile.
+   * @property {string} profile.name
+   *   The display name for the user profile.
+   */
+
+  /**
+   * Asynchronously fetches a migrator for a particular key, and then
+   * also gets any user profiles that exist on for that migrator. Resolves
+   * to null if something goes wrong getting information about the migrator
+   * or any of the user profiles.
+   *
+   * @param {string} key
+   *   The unique identification key for a migrator.
+   * @returns {Promise<MigratorProfileInstance[]|null>}
+   */
+  async #getMigratorAndProfiles(key) {
+    try {
+      let migrator = await MigrationUtils.getMigrator(key);
+      if (!migrator?.enabled) {
+        return null;
+      }
+
+      if (!(await migrator.hasPermissions())) {
+        // If we're unable to get permissions for this migrator, then we
+        // just don't bother showing it.
+        let permissionsPath = await migrator.canGetPermissions();
+        if (!permissionsPath) {
+          return null;
+        }
+        return this.#serializeMigratorAndProfile(
+          migrator,
+          null,
+          false /* hasPermissions */,
+          permissionsPath
+        );
+      }
+
+      let sourceProfiles = await migrator.getSourceProfiles();
+      if (Array.isArray(sourceProfiles)) {
+        if (!sourceProfiles.length) {
+          return null;
+        }
+
+        Services.telemetry.keyedScalarAdd(
+          "migration.discovered_migrators",
+          key,
+          sourceProfiles.length
+        );
+
+        let result = [];
+        for (let profile of sourceProfiles) {
+          result.push(
+            await this.#serializeMigratorAndProfile(migrator, profile)
+          );
+        }
+        return result;
+      }
+
+      Services.telemetry.keyedScalarAdd(
+        "migration.discovered_migrators",
+        key,
+        1
+      );
+      return this.#serializeMigratorAndProfile(migrator, sourceProfiles);
+    } catch (e) {
+      console.error(`Could not get migrator with key ${key}`, e);
+    }
+    return null;
+  }
+
+  /**
+   * Asynchronously fetches information about what resource types can be
+   * migrated for a particular migrator and user profile, and then packages
+   * the migrator, user profile data, and resource type data into an object
+   * that can be sent down to the MigrationWizardChild.
+   *
+   * @param {MigratorBase} migrator
+   *   A migrator subclass of MigratorBase.
+   * @param {object|null} profileObj
+   *   The user profile object representing the profile to get information
+   *   about. This object is usually gotten by calling getSourceProfiles on
+   *   the migrator.
+   * @param {boolean} [hasPermissions=true]
+   *   Whether or not the migrator has permission to read the data for the
+   *   other browser. It is expected that the caller will have already
+   *   computed this by calling hasPermissions() on the migrator, and
+   *   passing the result into this method. This is true by default.
+   * @param {string} [permissionsPath=undefined]
+   *   The path that the selected migrator needs read access to in order to
+   *   do a migration, in the event that hasPermissions is false. This is
+   *   undefined if hasPermissions is true.
+   * @returns {Promise<MigratorProfileInstance>}
+   */
+  async #serializeMigratorAndProfile(
+    migrator,
+    profileObj,
+    hasPermissions = true,
+    permissionsPath
+  ) {
+    let [profileMigrationData, lastModifiedDate] = await Promise.all([
+      migrator.getMigrateData(profileObj),
+      migrator.getLastUsedDate(),
+    ]);
+
+    let availableResourceTypes = [];
+
+    // Even if we don't have permissions, we'll show the resources available
+    // for Safari. For Safari, the workflow is to request permissions only
+    // after the resources have been selected.
+    if (
+      hasPermissions ||
+      migrator.constructor.key == lazy.SafariProfileMigrator?.key
+    ) {
+      for (let resourceType in MigrationUtils.resourceTypes) {
+        // Normally, we check each possible resourceType to see if we have one or
+        // more corresponding resourceTypes in profileMigrationData. The exception
+        // is for Safari, where the migrator does not expose a PASSWORDS resource
+        // type, but we allow the user to express that they'd like to import
+        // passwords from it anyways. This is because the Safari migration flow is
+        // special, and allows the user to import passwords from a file exported
+        // from Safari.
+        if (
+          profileMigrationData & MigrationUtils.resourceTypes[resourceType] ||
+          (migrator.constructor.key == lazy.SafariProfileMigrator?.key &&
+            MigrationUtils.resourceTypes[resourceType] ==
+              MigrationUtils.resourceTypes.PASSWORDS &&
+            Services.prefs.getBoolPref(
+              "signon.management.page.fileImport.enabled",
+              false
+            ))
+        ) {
+          availableResourceTypes.push(resourceType);
+        }
+      }
+    }
+
+    let displayName;
+
+    if (migrator.constructor.key == lazy.InternalTestingProfileMigrator.key) {
+      // In the case of the InternalTestingProfileMigrator, which is never seen
+      // by users outside of testing, we don't make our localization community
+      // localize it's display name, and just display the ID instead.
+      displayName = migrator.constructor.displayNameL10nID;
+    } else {
+      displayName = await lazy.gFluentStrings.formatValue(
+        migrator.constructor.displayNameL10nID
+      );
+    }
+
+    return {
+      type: lazy.MigrationWizardConstants.MIGRATOR_TYPES.BROWSER,
+      key: migrator.constructor.key,
+      displayName,
+      brandImage: migrator.constructor.brandImage,
+      resourceTypes: availableResourceTypes,
+      profile: profileObj,
+      lastModifiedDate,
+      hasPermissions,
+      permissionsPath,
+    };
+  }
+
+  /**
+   * Returns the "success" string for a particular resource type after
+   * migration has completed.
+   *
+   * @param {string} migratorKey
+   *   The key for the migrator being used.
+   * @param {string} resourceTypeStr
+   *   A string mapping to one of the key values of
+   *   MigrationWizardConstants.DISPLAYED_RESOURCE_TYPES.
+   * @returns {Promise<string>}
+   *   The success string for the resource type after migration has completed.
+   */
+  #getStringForImportQuantity(migratorKey, resourceTypeStr) {
+    if (migratorKey == lazy.FirefoxProfileMigrator.key) {
+      return "";
+    }
+
+    switch (resourceTypeStr) {
+      case lazy.MigrationWizardConstants.DISPLAYED_RESOURCE_TYPES.BOOKMARKS: {
+        let quantity = MigrationUtils.getImportedCount("bookmarks");
+        let stringID = "migration-wizard-progress-success-bookmarks";
+
+        if (
+          lazy.MigrationWizardConstants.USES_FAVORITES.includes(migratorKey)
+        ) {
+          stringID = "migration-wizard-progress-success-favorites";
+        }
+
+        return lazy.gFluentStrings.formatValue(stringID, {
+          quantity,
+        });
+      }
+      case lazy.MigrationWizardConstants.DISPLAYED_RESOURCE_TYPES.HISTORY: {
+        return lazy.gFluentStrings.formatValue(
+          "migration-wizard-progress-success-history",
+          {
+            maxAgeInDays: MigrationUtils.HISTORY_MAX_AGE_IN_DAYS,
+          }
+        );
+      }
+      case lazy.MigrationWizardConstants.DISPLAYED_RESOURCE_TYPES.PASSWORDS: {
+        let quantity = MigrationUtils.getImportedCount("logins");
+        return lazy.gFluentStrings.formatValue(
+          "migration-wizard-progress-success-passwords",
+          {
+            quantity,
+          }
+        );
+      }
+      case lazy.MigrationWizardConstants.DISPLAYED_RESOURCE_TYPES.FORMDATA: {
+        return lazy.gFluentStrings.formatValue(
+          "migration-wizard-progress-success-formdata"
+        );
+      }
+      case lazy.MigrationWizardConstants.DISPLAYED_RESOURCE_TYPES
+        .PAYMENT_METHODS: {
+        let quantity = MigrationUtils.getImportedCount("cards");
+        return lazy.gFluentStrings.formatValue(
+          "migration-wizard-progress-success-payment-methods",
+          {
+            quantity,
+          }
+        );
+      }
+      default: {
+        return "";
+      }
+    }
+  }
+
+  /**
+   * Returns a Promise that resolves to a serializable representation of a
+   * FileMigrator for sending down to the MigrationWizard.
+   *
+   * @param {FileMigrator} fileMigrator
+   *   The FileMigrator to serialize.
+   * @returns {Promise<object|null>}
+   *   The serializable representation of the FileMigrator, or null if the
+   *   migrator is disabled.
+   */
+  async #serializeFileMigrator(fileMigrator) {
+    if (!fileMigrator.enabled) {
+      return null;
+    }
+
+    return {
+      type: lazy.MigrationWizardConstants.MIGRATOR_TYPES.FILE,
+      key: fileMigrator.constructor.key,
+      displayName: await lazy.gFluentStrings.formatValue(
+        fileMigrator.constructor.displayNameL10nID
+      ),
+      brandImage: fileMigrator.constructor.brandImage,
+      resourceTypes: [],
+    };
+  }
+
+  /**
+   * Opens the about:addons page in a new background tab in the same window
+   * as the passed browser.
+   *
+   * @param {Element} browser
+   *   The browser element requesting that about:addons opens.
+   */
+  #openAboutAddons(browser) {
+    let window = browser.ownerGlobal;
+    window.openTrustedLinkIn("about:addons", "tab", { inBackground: true });
+  }
+}