Adding upstream version 110.0.1.upstream/110.0.1upstream

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

72 files changed, 8696 insertions, 0 deletions

diff --git a/toolkit/profile/ProfileUnlockerAndroid.cpp b/toolkit/profile/ProfileUnlockerAndroid.cpp
new file mode 100644
index 0000000000..58836c7b8e
--- /dev/null
+++ b/toolkit/profile/ProfileUnlockerAndroid.cpp
@@ -0,0 +1,37 @@
+/* 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/. */
+
+#include "ProfileUnlockerAndroid.h"
+#include "nsPrintfCString.h"
+#include <unistd.h>
+
+namespace mozilla {
+
+ProfileUnlockerAndroid::ProfileUnlockerAndroid(const pid_t aPid) : mPid(aPid) {}
+
+ProfileUnlockerAndroid::~ProfileUnlockerAndroid() {}
+
+NS_IMPL_ISUPPORTS(ProfileUnlockerAndroid, nsIProfileUnlocker)
+
+NS_IMETHODIMP
+ProfileUnlockerAndroid::Unlock(uint32_t aSeverity) {
+  if (aSeverity != FORCE_QUIT) {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+
+  NS_WARNING(nsPrintfCString("Process %d has the profile "
+                             "lock, will try to kill it.",
+                             mPid)
+                 .get());
+  if (mPid == getpid()) {
+    NS_ERROR("Lock held by current process !?");
+    return NS_ERROR_FAILURE;
+  }
+  if (kill(mPid, SIGKILL) != 0) {
+    NS_WARNING("Could not kill process.");
+  }
+  return NS_OK;
+}
+
+}  // namespace mozilla
diff --git a/toolkit/profile/ProfileUnlockerAndroid.h b/toolkit/profile/ProfileUnlockerAndroid.h
new file mode 100644
index 0000000000..a8dc33bcb5
--- /dev/null
+++ b/toolkit/profile/ProfileUnlockerAndroid.h
@@ -0,0 +1,26 @@
+/* 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/. */
+
+#ifndef ProfileUnlockerAndroid_h
+#define ProfileUnlockerAndroid_h
+
+#include "nsIProfileUnlocker.h"
+
+namespace mozilla {
+
+class ProfileUnlockerAndroid final : public nsIProfileUnlocker {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPROFILEUNLOCKER
+
+  explicit ProfileUnlockerAndroid(const pid_t aPid);
+
+ private:
+  ~ProfileUnlockerAndroid();
+  pid_t mPid;
+};
+
+}  // namespace mozilla
+
+#endif  // ProfileUnlockerAndroid_h
diff --git a/toolkit/profile/ProfileUnlockerWin.cpp b/toolkit/profile/ProfileUnlockerWin.cpp
new file mode 100644
index 0000000000..d7ab5e0a30
--- /dev/null
+++ b/toolkit/profile/ProfileUnlockerWin.cpp
@@ -0,0 +1,245 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "ProfileUnlockerWin.h"
+#include "nsCOMPtr.h"
+#include "nsIFile.h"
+#include "nsTArray.h"
+#include "nsXPCOM.h"
+
+namespace mozilla {
+
+/**
+ * RAII class to obtain and manage a handle to a Restart Manager session.
+ * It opens a new handle upon construction and releases it upon destruction.
+ */
+class MOZ_STACK_CLASS ScopedRestartManagerSession {
+ public:
+  explicit ScopedRestartManagerSession(ProfileUnlockerWin& aUnlocker)
+      : mError(ERROR_INVALID_HANDLE),
+        mHandle((DWORD)-1)  // 0 is a valid restart manager handle
+        ,
+        mUnlocker(aUnlocker) {
+    mError = mUnlocker.StartSession(mHandle);
+  }
+
+  ~ScopedRestartManagerSession() {
+    if (mError == ERROR_SUCCESS) {
+      mUnlocker.EndSession(mHandle);
+    }
+  }
+
+  /**
+   * @return true if the handle is a valid Restart Ranager handle.
+   */
+  inline bool ok() { return mError == ERROR_SUCCESS; }
+
+  /**
+   * @return the Restart Manager handle to pass to other Restart Manager APIs.
+   */
+  inline DWORD handle() { return mHandle; }
+
+ private:
+  DWORD mError;
+  DWORD mHandle;
+  ProfileUnlockerWin& mUnlocker;
+};
+
+ProfileUnlockerWin::ProfileUnlockerWin(const nsAString& aFileName)
+    : mRmStartSession(nullptr),
+      mRmRegisterResources(nullptr),
+      mRmGetList(nullptr),
+      mRmEndSession(nullptr),
+      mFileName(aFileName) {}
+
+ProfileUnlockerWin::~ProfileUnlockerWin() {}
+
+NS_IMPL_ISUPPORTS(ProfileUnlockerWin, nsIProfileUnlocker)
+
+nsresult ProfileUnlockerWin::Init() {
+  MOZ_ASSERT(!mRestartMgrModule);
+  if (mFileName.IsEmpty()) {
+    return NS_ERROR_ILLEGAL_VALUE;
+  }
+
+  nsModuleHandle module(::LoadLibraryW(L"Rstrtmgr.dll"));
+  if (!module) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  mRmStartSession = reinterpret_cast<RMSTARTSESSION>(
+      ::GetProcAddress(module, "RmStartSession"));
+  if (!mRmStartSession) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  mRmRegisterResources = reinterpret_cast<RMREGISTERRESOURCES>(
+      ::GetProcAddress(module, "RmRegisterResources"));
+  if (!mRmRegisterResources) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  mRmGetList =
+      reinterpret_cast<RMGETLIST>(::GetProcAddress(module, "RmGetList"));
+  if (!mRmGetList) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  mRmEndSession =
+      reinterpret_cast<RMENDSESSION>(::GetProcAddress(module, "RmEndSession"));
+  if (!mRmEndSession) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  mRestartMgrModule.steal(module);
+  return NS_OK;
+}
+
+DWORD
+ProfileUnlockerWin::StartSession(DWORD& aHandle) {
+  WCHAR sessionKey[CCH_RM_SESSION_KEY + 1] = {0};
+  return mRmStartSession(&aHandle, 0, sessionKey);
+}
+
+void ProfileUnlockerWin::EndSession(DWORD aHandle) { mRmEndSession(aHandle); }
+
+NS_IMETHODIMP
+ProfileUnlockerWin::Unlock(uint32_t aSeverity) {
+  if (!mRestartMgrModule) {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  if (aSeverity != FORCE_QUIT) {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+
+  ScopedRestartManagerSession session(*this);
+  if (!session.ok()) {
+    return NS_ERROR_FAILURE;
+  }
+
+  LPCWSTR resources[] = {mFileName.get()};
+  DWORD error = mRmRegisterResources(session.handle(), 1, resources, 0, nullptr,
+                                     0, nullptr);
+  if (error != ERROR_SUCCESS) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Using a AutoTArray here because we expect the required size to be 1.
+  AutoTArray<RM_PROCESS_INFO, 1> info;
+  UINT numEntries;
+  UINT numEntriesNeeded = 1;
+  error = ERROR_MORE_DATA;
+  DWORD reason = RmRebootReasonNone;
+  while (error == ERROR_MORE_DATA) {
+    info.SetLength(numEntriesNeeded);
+    numEntries = numEntriesNeeded;
+    error = mRmGetList(session.handle(), &numEntriesNeeded, &numEntries,
+                       &info[0], &reason);
+  }
+  if (error != ERROR_SUCCESS) {
+    return NS_ERROR_FAILURE;
+  }
+  if (numEntries == 0) {
+    // Nobody else is locking the file; the other process must have terminated
+    return NS_OK;
+  }
+
+  nsresult rv = NS_ERROR_FAILURE;
+  for (UINT i = 0; i < numEntries; ++i) {
+    rv = TryToTerminate(info[i].Process);
+    if (NS_SUCCEEDED(rv)) {
+      return NS_OK;
+    }
+  }
+
+  // If nothing could be unlocked then we return the error code of the last
+  // failure that was returned.
+  return rv;
+}
+
+nsresult ProfileUnlockerWin::TryToTerminate(RM_UNIQUE_PROCESS& aProcess) {
+  // Subtle: If the target process terminated before this call to OpenProcess,
+  // this call will still succeed. This is because the restart manager session
+  // internally retains a handle to the target process. The rules for Windows
+  // PIDs state that the PID of a terminated process remains valid as long as
+  // at least one handle to that process remains open, so when we reach this
+  // point the PID is still valid and the process will open successfully.
+  DWORD accessRights = PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_TERMINATE;
+  nsAutoHandle otherProcess(
+      ::OpenProcess(accessRights, FALSE, aProcess.dwProcessId));
+  if (!otherProcess) {
+    return NS_ERROR_FAILURE;
+  }
+
+  FILETIME creationTime, exitTime, kernelTime, userTime;
+  if (!::GetProcessTimes(otherProcess, &creationTime, &exitTime, &kernelTime,
+                         &userTime)) {
+    return NS_ERROR_FAILURE;
+  }
+  if (::CompareFileTime(&aProcess.ProcessStartTime, &creationTime)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  WCHAR imageName[MAX_PATH];
+  DWORD imageNameLen = MAX_PATH;
+  if (!::QueryFullProcessImageNameW(otherProcess, 0, imageName,
+                                    &imageNameLen)) {
+    // The error codes for this function are not very descriptive. There are
+    // actually two failure cases here: Either the call failed because the
+    // process is no longer running, or it failed for some other reason. We
+    // need to know which case that is.
+    DWORD otherProcessExitCode;
+    if (!::GetExitCodeProcess(otherProcess, &otherProcessExitCode) ||
+        otherProcessExitCode == STILL_ACTIVE) {
+      // The other process is still running.
+      return NS_ERROR_FAILURE;
+    }
+    // The other process must have terminated. We should return NS_OK so that
+    // this process may proceed with startup.
+    return NS_OK;
+  }
+  nsCOMPtr<nsIFile> otherProcessImageName;
+  if (NS_FAILED(NS_NewLocalFile(nsDependentString(imageName, imageNameLen),
+                                false,
+                                getter_AddRefs(otherProcessImageName)))) {
+    return NS_ERROR_FAILURE;
+  }
+  nsAutoString otherProcessLeafName;
+  if (NS_FAILED(otherProcessImageName->GetLeafName(otherProcessLeafName))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  imageNameLen = MAX_PATH;
+  if (!::QueryFullProcessImageNameW(::GetCurrentProcess(), 0, imageName,
+                                    &imageNameLen)) {
+    return NS_ERROR_FAILURE;
+  }
+  nsCOMPtr<nsIFile> thisProcessImageName;
+  if (NS_FAILED(NS_NewLocalFile(nsDependentString(imageName, imageNameLen),
+                                false, getter_AddRefs(thisProcessImageName)))) {
+    return NS_ERROR_FAILURE;
+  }
+  nsAutoString thisProcessLeafName;
+  if (NS_FAILED(thisProcessImageName->GetLeafName(thisProcessLeafName))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Make sure the image leaf names match
+  if (_wcsicmp(otherProcessLeafName.get(), thisProcessLeafName.get())) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  // We know that another process holds the lock and that it shares the same
+  // image name as our process. Let's kill it.
+  // Subtle: TerminateProcess returning ERROR_ACCESS_DENIED is actually an
+  // indicator that the target process managed to shut down on its own. In that
+  // case we should return NS_OK since we may proceed with startup.
+  if (!::TerminateProcess(otherProcess, 1) &&
+      ::GetLastError() != ERROR_ACCESS_DENIED) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+}  // namespace mozilla
diff --git a/toolkit/profile/ProfileUnlockerWin.h b/toolkit/profile/ProfileUnlockerWin.h
new file mode 100644
index 0000000000..6429301394
--- /dev/null
+++ b/toolkit/profile/ProfileUnlockerWin.h
@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef ProfileUnlockerWin_h
+#define ProfileUnlockerWin_h
+
+#include <windows.h>
+#include <restartmanager.h>
+
+#include "nsIProfileUnlocker.h"
+#include "nsString.h"
+#include "nsWindowsHelpers.h"
+
+namespace mozilla {
+
+class ProfileUnlockerWin final : public nsIProfileUnlocker {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPROFILEUNLOCKER
+
+  explicit ProfileUnlockerWin(const nsAString& aFileName);
+
+  nsresult Init();
+
+  DWORD StartSession(DWORD& aHandle);
+  void EndSession(DWORD aHandle);
+
+ private:
+  ~ProfileUnlockerWin();
+  nsresult TryToTerminate(RM_UNIQUE_PROCESS& aProcess);
+
+ private:
+  typedef DWORD(WINAPI* RMSTARTSESSION)(DWORD*, DWORD, WCHAR[]);
+  typedef DWORD(WINAPI* RMREGISTERRESOURCES)(DWORD, UINT, LPCWSTR[], UINT,
+                                             RM_UNIQUE_PROCESS[], UINT,
+                                             LPCWSTR[]);
+  typedef DWORD(WINAPI* RMGETLIST)(DWORD, UINT*, UINT*, RM_PROCESS_INFO[],
+                                   LPDWORD);
+  typedef DWORD(WINAPI* RMENDSESSION)(DWORD);
+
+ private:
+  nsModuleHandle mRestartMgrModule;
+  RMSTARTSESSION mRmStartSession;
+  RMREGISTERRESOURCES mRmRegisterResources;
+  RMGETLIST mRmGetList;
+  RMENDSESSION mRmEndSession;
+
+  nsString mFileName;
+};
+
+}  // namespace mozilla
+
+#endif  // ProfileUnlockerWin_h
diff --git a/toolkit/profile/content/createProfileWizard.js b/toolkit/profile/content/createProfileWizard.js
new file mode 100644
index 0000000000..2315e33b22
--- /dev/null
+++ b/toolkit/profile/content/createProfileWizard.js
@@ -0,0 +1,268 @@
+/* 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/. */
+
+const C = Cc;
+const I = Ci;
+
+const { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+
+const ToolkitProfileService = "@mozilla.org/toolkit/profile-service;1";
+
+var gProfileService;
+var gProfileManagerBundle;
+
+var gDefaultProfileParent;
+
+// The directory where the profile will be created.
+var gProfileRoot;
+
+// Text node to display the location and name of the profile to create.
+var gProfileDisplay;
+
+// Called once when the wizard is opened.
+function initWizard() {
+  try {
+    gProfileService = C[ToolkitProfileService].getService(
+      I.nsIToolkitProfileService
+    );
+    gProfileManagerBundle = document.getElementById("bundle_profileManager");
+
+    gDefaultProfileParent = Services.dirsvc.get("DefProfRt", I.nsIFile);
+
+    // Initialize the profile location display.
+    gProfileDisplay = document.getElementById("profileDisplay").firstChild;
+    document.addEventListener("wizardfinish", onFinish);
+    document
+      .getElementById("explanation")
+      .addEventListener("pageshow", enableNextButton);
+    document
+      .getElementById("createProfile")
+      .addEventListener("pageshow", initSecondWizardPage);
+    setDisplayToDefaultFolder();
+  } catch (e) {
+    window.close();
+    throw e;
+  }
+}
+
+// Called every time the second wizard page is displayed.
+function initSecondWizardPage() {
+  var profileName = document.getElementById("profileName");
+  profileName.select();
+  profileName.focus();
+
+  // Initialize profile name validation.
+  checkCurrentInput(profileName.value);
+}
+
+const kSaltTable = [
+  "a",
+  "b",
+  "c",
+  "d",
+  "e",
+  "f",
+  "g",
+  "h",
+  "i",
+  "j",
+  "k",
+  "l",
+  "m",
+  "n",
+  "o",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "u",
+  "v",
+  "w",
+  "x",
+  "y",
+  "z",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "0",
+];
+
+var kSaltString = "";
+for (var i = 0; i < 8; ++i) {
+  kSaltString += kSaltTable[Math.floor(Math.random() * kSaltTable.length)];
+}
+
+function saltName(aName) {
+  return kSaltString + "." + aName;
+}
+
+function setDisplayToDefaultFolder() {
+  var defaultProfileDir = gDefaultProfileParent.clone();
+  defaultProfileDir.append(
+    saltName(document.getElementById("profileName").value)
+  );
+  gProfileRoot = defaultProfileDir;
+  document.getElementById("useDefault").disabled = true;
+}
+
+function updateProfileDisplay() {
+  gProfileDisplay.data = gProfileRoot.path;
+}
+
+// Invoke a folder selection dialog for choosing the directory of profile storage.
+function chooseProfileFolder() {
+  var newProfileRoot;
+
+  var dirChooser = C["@mozilla.org/filepicker;1"].createInstance(
+    I.nsIFilePicker
+  );
+  dirChooser.init(
+    window,
+    gProfileManagerBundle.getString("chooseFolder"),
+    I.nsIFilePicker.modeGetFolder
+  );
+  dirChooser.appendFilters(I.nsIFilePicker.filterAll);
+
+  // default to the Profiles folder
+  dirChooser.displayDirectory = gDefaultProfileParent;
+
+  dirChooser.open(() => {
+    newProfileRoot = dirChooser.file;
+
+    // Disable the "Default Folder..." button when the default profile folder
+    // was selected manually in the File Picker.
+    document.getElementById(
+      "useDefault"
+    ).disabled = newProfileRoot.parent.equals(gDefaultProfileParent);
+
+    gProfileRoot = newProfileRoot;
+    updateProfileDisplay();
+  });
+}
+
+// Checks the current user input for validity and triggers an error message accordingly.
+function checkCurrentInput(currentInput) {
+  let wizard = document.querySelector("wizard");
+  var finishButton = wizard.getButton("finish");
+  var finishText = document.getElementById("finishText");
+  var canAdvance;
+
+  var errorMessage = checkProfileName(currentInput);
+
+  if (!errorMessage) {
+    finishText.className = "";
+    if (AppConstants.platform == "macosx") {
+      finishText.firstChild.data = gProfileManagerBundle.getString(
+        "profileFinishTextMac"
+      );
+    } else {
+      finishText.firstChild.data = gProfileManagerBundle.getString(
+        "profileFinishText"
+      );
+    }
+    canAdvance = true;
+  } else {
+    finishText.className = "error";
+    finishText.firstChild.data = errorMessage;
+    canAdvance = false;
+  }
+
+  wizard.canAdvance = canAdvance;
+  finishButton.disabled = !canAdvance;
+
+  updateProfileDisplay();
+
+  return canAdvance;
+}
+
+function updateProfileName(aNewName) {
+  if (checkCurrentInput(aNewName)) {
+    gProfileRoot.leafName = saltName(aNewName);
+    updateProfileDisplay();
+  }
+}
+
+// Checks whether the given string is a valid profile name.
+// Returns an error message describing the error in the name or "" when it's valid.
+function checkProfileName(profileNameToCheck) {
+  // Check for emtpy profile name.
+  if (!/\S/.test(profileNameToCheck)) {
+    return gProfileManagerBundle.getString("profileNameEmpty");
+  }
+
+  // Check whether all characters in the profile name are allowed.
+  if (/([\\*:?<>|\/\"])/.test(profileNameToCheck)) {
+    return gProfileManagerBundle.getFormattedString("invalidChar", [RegExp.$1]);
+  }
+
+  // Check whether a profile with the same name already exists.
+  if (profileExists(profileNameToCheck)) {
+    return gProfileManagerBundle.getString("profileExists");
+  }
+
+  // profileNameToCheck is valid.
+  return "";
+}
+
+function profileExists(aName) {
+  for (let profile of gProfileService.profiles) {
+    if (profile.name.toLowerCase() == aName.toLowerCase()) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Called when the first wizard page is shown.
+function enableNextButton() {
+  document.querySelector("wizard").canAdvance = true;
+}
+
+function onFinish(event) {
+  var profileName = document.getElementById("profileName").value;
+  var profile;
+
+  // Create profile named profileName in profileRoot.
+  try {
+    profile = gProfileService.createProfile(gProfileRoot, profileName);
+  } catch (e) {
+    var profileCreationFailed = gProfileManagerBundle.getString(
+      "profileCreationFailed"
+    );
+    var profileCreationFailedTitle = gProfileManagerBundle.getString(
+      "profileCreationFailedTitle"
+    );
+    Services.prompt.alert(
+      window,
+      profileCreationFailedTitle,
+      profileCreationFailed + "\n" + e
+    );
+
+    event.preventDefault();
+    return;
+  }
+
+  if (window.arguments && window.arguments[1]) {
+    // Add new profile to the list in the Profile Manager.
+    window.arguments[1].CreateProfile(profile);
+  } else {
+    // Use the newly created Profile.
+    var profileLock = profile.lock(null);
+
+    var dialogParams = window.arguments[0].QueryInterface(
+      I.nsIDialogParamBlock
+    );
+    dialogParams.objects.insertElementAt(profileLock, 0);
+  }
+}
diff --git a/toolkit/profile/content/createProfileWizard.xhtml b/toolkit/profile/content/createProfileWizard.xhtml
new file mode 100644
index 0000000000..48d0b9f2da
--- /dev/null
+++ b/toolkit/profile/content/createProfileWizard.xhtml
@@ -0,0 +1,70 @@
+<?xml version="1.0"?>
+<!-- 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/. -->
+
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+
+<!DOCTYPE wizard>
+
+<window id="createProfileWizard"
+        data-l10n-id="create-profile-window2"
+        xmlns:html="http://www.w3.org/1999/xhtml"
+        xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+        onload="initWizard();"
+        data-l10n-attrs="style"
+        >
+
+<linkset>
+  <html:link rel="localization" href="branding/brand.ftl"/>
+  <html:link rel="localization" href="toolkit/global/createProfileWizard.ftl"/>
+</linkset>
+
+<script src="chrome://global/content/customElements.js"/>
+<script src="chrome://global/content/globalOverlay.js"/>
+<script src="chrome://global/content/editMenuOverlay.js"/>
+<script src="chrome://mozapps/content/profile/createProfileWizard.js"/>
+
+<wizard>
+  <stringbundle id="bundle_profileManager"
+                src="chrome://mozapps/locale/profile/profileSelection.properties"/>
+
+  <wizardpage id="explanation" data-header-label-id="create-profile-first-page-header2">
+    <description data-l10n-id="profile-creation-explanation-1"></description>
+    <description data-l10n-id="profile-creation-explanation-2"></description>
+    <description data-l10n-id="profile-creation-explanation-3"></description>
+    <spacer flex="1"/>
+    <description data-l10n-id="profile-creation-explanation-4"></description>
+  </wizardpage>
+
+  <wizardpage id="createProfile" data-header-label-id="create-profile-last-page-header2">
+    <description data-l10n-id="profile-creation-intro"></description>
+
+    <label data-l10n-id="profile-prompt" control="ProfileName"></label>
+    <html:input id="profileName" data-l10n-id="profile-default-name"
+                data-l10n-attrs="value" oninput="updateProfileName(this.value);"/>
+
+    <separator/>
+
+    <description data-l10n-id="profile-directory-explanation"></description>
+
+    <vbox class="indent" flex="1" style="overflow: auto;">
+      <description id="profileDisplay">*</description>
+    </vbox>
+
+    <hbox>
+      <button data-l10n-id="create-profile-choose-folder" oncommand="chooseProfileFolder();"/>
+
+      <button id="useDefault" data-l10n-id="create-profile-use-default"
+              oncommand="setDisplayToDefaultFolder(); updateProfileDisplay();"
+              disabled="true"/>
+    </hbox>
+
+    <separator/>
+
+    <description id="finishText">*</description>
+  </wizardpage>
+
+</wizard>
+</window>
diff --git a/toolkit/profile/content/profileDowngrade.js b/toolkit/profile/content/profileDowngrade.js
new file mode 100644
index 0000000000..ba1f723ec2
--- /dev/null
+++ b/toolkit/profile/content/profileDowngrade.js
@@ -0,0 +1,39 @@
+/* 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/. */
+
+let gParams;
+
+const { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+
+function init() {
+  /*
+   * The C++ code passes a dialog param block using its integers as in and out
+   * arguments for this UI. The following are the uses of the integers:
+   *
+   *  0: A set of flags from nsIToolkitProfileService.downgradeUIFlags.
+   *  1: A return argument, one of nsIToolkitProfileService.downgradeUIChoice.
+   */
+  gParams = window.arguments[0].QueryInterface(Ci.nsIDialogParamBlock);
+  if (AppConstants.MOZ_SERVICES_SYNC) {
+    let hasSync = gParams.GetInt(0) & Ci.nsIToolkitProfileService.hasSync;
+
+    document.getElementById("sync").hidden = !hasSync;
+    document.getElementById("nosync").hidden = hasSync;
+  }
+
+  document.addEventListener("dialogextra1", createProfile);
+  document.addEventListener("dialogaccept", quit);
+  document.addEventListener("dialogcancel", quit);
+}
+
+function quit() {
+  gParams.SetInt(1, Ci.nsIToolkitProfileService.quit);
+}
+
+function createProfile() {
+  gParams.SetInt(1, Ci.nsIToolkitProfileService.createNewProfile);
+  window.close();
+}
diff --git a/toolkit/profile/content/profileDowngrade.xhtml b/toolkit/profile/content/profileDowngrade.xhtml
new file mode 100644
index 0000000000..15755d7210
--- /dev/null
+++ b/toolkit/profile/content/profileDowngrade.xhtml
@@ -0,0 +1,40 @@
+<?xml version="1.0"?>
+<!-- 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/. -->
+
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+<?xml-stylesheet href="chrome://mozapps/skin/profileDowngrade.css" type="text/css"?>
+
+<!DOCTYPE window>
+
+<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+        xmlns:html="http://www.w3.org/1999/xhtml"
+        prefwidth="min-width"
+        data-l10n-id="profiledowngrade-window2"
+        data-l10n-attrs="title,style"
+        onload="init()">
+<linkset>
+  <html:link rel="localization" href="branding/brand.ftl"/>
+  <html:link rel="localization" href="browser/branding/sync-brand.ftl"/>
+  <html:link rel="localization" href="toolkit/global/profileDowngrade.ftl"/>
+</linkset>
+<dialog buttons="accept,extra1" buttonpack="end"
+        buttonidextra1="profiledowngrade-window-create"
+        buttonidaccept="profiledowngrade-quit">
+
+  <script src="profileDowngrade.js"/>
+  <script src="chrome://global/content/customElements.js"/>
+
+  <hbox flex="1" align="start">
+    <image id="info" role="presentation"/>
+    <vbox flex="1">
+      <description data-l10n-id="profiledowngrade-nosync"></description>
+#ifdef MOZ_SERVICES_SYNC
+      <description data-l10n-id="profiledowngrade-sync"></description>
+#endif
+    </vbox>
+  </hbox>
+
+</dialog>
+</window>
diff --git a/toolkit/profile/content/profileSelection.js b/toolkit/profile/content/profileSelection.js
new file mode 100644
index 0000000000..5f581f8dc5
--- /dev/null
+++ b/toolkit/profile/content/profileSelection.js
@@ -0,0 +1,356 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ *
+ * 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/. */
+
+const { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+
+const C = Cc;
+const I = Ci;
+
+const ToolkitProfileService = "@mozilla.org/toolkit/profile-service;1";
+
+const fluentStrings = new Localization([
+  "branding/brand.ftl",
+  "toolkit/global/profileSelection.ftl",
+]);
+
+var gDialogParams;
+var gProfileManagerBundle;
+var gBrandBundle;
+var gProfileService;
+var gNeedsFlush = false;
+
+function getFluentString(str) {
+  return fluentStrings.formatValue(str);
+}
+
+function startup() {
+  try {
+    gDialogParams = window.arguments[0].QueryInterface(I.nsIDialogParamBlock);
+
+    gProfileService = C[ToolkitProfileService].getService(
+      I.nsIToolkitProfileService
+    );
+
+    gProfileManagerBundle = document.getElementById("bundle_profileManager");
+    gBrandBundle = document.getElementById("bundle_brand");
+
+    document.getElementById("profileWindow").centerWindowOnScreen();
+
+    var profilesElement = document.getElementById("profiles");
+
+    for (let profile of gProfileService.profiles.entries(I.nsIToolkitProfile)) {
+      var listitem = profilesElement.appendItem(profile.name, "");
+
+      var tooltiptext = gProfileManagerBundle.getFormattedString(
+        "profileTooltip",
+        [profile.name, profile.rootDir.path]
+      );
+      listitem.setAttribute("tooltiptext", tooltiptext);
+      listitem.profile = profile;
+      try {
+        if (profile === gProfileService.defaultProfile) {
+          setTimeout(
+            function(a) {
+              profilesElement.ensureElementIsVisible(a);
+              profilesElement.selectItem(a);
+            },
+            0,
+            listitem
+          );
+        }
+      } catch (e) {}
+    }
+
+    var autoSelectLastProfile = document.getElementById(
+      "autoSelectLastProfile"
+    );
+    autoSelectLastProfile.checked = gProfileService.startWithLastProfile;
+    profilesElement.focus();
+  } catch (e) {
+    window.close();
+    throw e;
+  }
+  document.addEventListener("dialogaccept", acceptDialog);
+  document.addEventListener("dialogcancel", exitDialog);
+}
+
+async function flush(cancelled) {
+  updateStartupPrefs();
+
+  gDialogParams.SetInt(
+    1,
+    document.getElementById("offlineState").checked ? 1 : 0
+  );
+
+  if (gNeedsFlush) {
+    try {
+      gProfileService.flush();
+    } catch (e) {
+      let appName = gBrandBundle.getString("brandShortName");
+
+      let title = gProfileManagerBundle.getString("flushFailTitle");
+      let restartButton = gProfileManagerBundle.getFormattedString(
+        "flushFailRestartButton",
+        [appName]
+      );
+      let exitButton = gProfileManagerBundle.getString("flushFailExitButton");
+
+      let message;
+      if (e.result == undefined) {
+        message = await getFluentString("profile-selection-conflict-message");
+      } else {
+        message = gProfileManagerBundle.getString("flushFailMessage");
+      }
+
+      const PS = Ci.nsIPromptService;
+      let result = Services.prompt.confirmEx(
+        window,
+        title,
+        message,
+        PS.BUTTON_POS_0 * PS.BUTTON_TITLE_IS_STRING +
+          PS.BUTTON_POS_1 * PS.BUTTON_TITLE_IS_STRING,
+        restartButton,
+        exitButton,
+        null,
+        null,
+        {}
+      );
+
+      gDialogParams.SetInt(
+        0,
+        result == 0
+          ? Ci.nsIToolkitProfileService.restart
+          : Ci.nsIToolkitProfileService.exit
+      );
+      return;
+    }
+    gNeedsFlush = false;
+  }
+
+  gDialogParams.SetInt(
+    0,
+    cancelled
+      ? Ci.nsIToolkitProfileService.exit
+      : Ci.nsIToolkitProfileService.launchWithProfile
+  );
+}
+
+function acceptDialog(event) {
+  var appName = gBrandBundle.getString("brandShortName");
+
+  var profilesElement = document.getElementById("profiles");
+  var selectedProfile = profilesElement.selectedItem;
+  if (!selectedProfile) {
+    var pleaseSelectTitle = gProfileManagerBundle.getString(
+      "pleaseSelectTitle"
+    );
+    var pleaseSelect = gProfileManagerBundle.getFormattedString(
+      "pleaseSelect",
+      [appName]
+    );
+    Services.prompt.alert(window, pleaseSelectTitle, pleaseSelect);
+    event.preventDefault();
+    return;
+  }
+
+  gDialogParams.objects.insertElementAt(selectedProfile.profile.rootDir, 0);
+  gDialogParams.objects.insertElementAt(selectedProfile.profile.localDir, 1);
+
+  if (gProfileService.defaultProfile != selectedProfile.profile) {
+    try {
+      gProfileService.defaultProfile = selectedProfile.profile;
+      gNeedsFlush = true;
+    } catch (e) {
+      // This can happen on dev-edition. We'll still restart with the selected
+      // profile based on the lock's directories.
+    }
+  }
+  flush(false);
+}
+
+function exitDialog() {
+  flush(true);
+}
+
+function updateStartupPrefs() {
+  var autoSelectLastProfile = document.getElementById("autoSelectLastProfile");
+  if (gProfileService.startWithLastProfile != autoSelectLastProfile.checked) {
+    gProfileService.startWithLastProfile = autoSelectLastProfile.checked;
+    gNeedsFlush = true;
+  }
+}
+
+// handle key event on listboxes
+function onProfilesKey(aEvent) {
+  switch (aEvent.keyCode) {
+    case KeyEvent.DOM_VK_BACK_SPACE:
+      if (AppConstants.platform != "macosx") {
+        break;
+      }
+    // fall through
+    case KeyEvent.DOM_VK_DELETE:
+      ConfirmDelete();
+      break;
+    case KeyEvent.DOM_VK_F2:
+      RenameProfile();
+      break;
+  }
+}
+
+function onProfilesDblClick(aEvent) {
+  if (aEvent.target.closest("richlistitem")) {
+    document.getElementById("profileWindow").acceptDialog();
+  }
+}
+
+// invoke the createProfile Wizard
+function CreateProfileWizard() {
+  window.openDialog(
+    "chrome://mozapps/content/profile/createProfileWizard.xhtml",
+    "",
+    "centerscreen,chrome,modal,titlebar",
+    gProfileService,
+    { CreateProfile }
+  );
+}
+
+/**
+ * Called from createProfileWizard to update the display.
+ */
+function CreateProfile(aProfile) {
+  var profilesElement = document.getElementById("profiles");
+
+  var listitem = profilesElement.appendItem(aProfile.name, "");
+
+  var tooltiptext = gProfileManagerBundle.getFormattedString("profileTooltip", [
+    aProfile.name,
+    aProfile.rootDir.path,
+  ]);
+  listitem.setAttribute("tooltiptext", tooltiptext);
+  listitem.profile = aProfile;
+
+  profilesElement.ensureElementIsVisible(listitem);
+  profilesElement.selectItem(listitem);
+
+  gNeedsFlush = true;
+}
+
+// rename the selected profile
+function RenameProfile() {
+  var profilesElement = document.getElementById("profiles");
+  var selectedItem = profilesElement.selectedItem;
+  if (!selectedItem) {
+    return false;
+  }
+
+  var selectedProfile = selectedItem.profile;
+
+  var oldName = selectedProfile.name;
+  var newName = { value: oldName };
+
+  var dialogTitle = gProfileManagerBundle.getString("renameProfileTitle");
+  var msg = gProfileManagerBundle.getFormattedString("renameProfilePrompt", [
+    oldName,
+  ]);
+
+  if (
+    Services.prompt.prompt(window, dialogTitle, msg, newName, null, {
+      value: 0,
+    })
+  ) {
+    newName = newName.value;
+
+    // User hasn't changed the profile name. Treat as if cancel was pressed.
+    if (newName == oldName) {
+      return false;
+    }
+
+    try {
+      selectedProfile.name = newName;
+      gNeedsFlush = true;
+    } catch (e) {
+      var alTitle = gProfileManagerBundle.getString("profileNameInvalidTitle");
+      var alMsg = gProfileManagerBundle.getFormattedString(
+        "profileNameInvalid",
+        [newName]
+      );
+      Services.prompt.alert(window, alTitle, alMsg);
+      return false;
+    }
+
+    selectedItem.firstChild.setAttribute("value", newName);
+    var tiptext = gProfileManagerBundle.getFormattedString("profileTooltip", [
+      newName,
+      selectedProfile.rootDir.path,
+    ]);
+    selectedItem.setAttribute("tooltiptext", tiptext);
+
+    return true;
+  }
+
+  return false;
+}
+
+function ConfirmDelete() {
+  var profileList = document.getElementById("profiles");
+
+  var selectedItem = profileList.selectedItem;
+  if (!selectedItem) {
+    return false;
+  }
+
+  var selectedProfile = selectedItem.profile;
+  var deleteFiles = false;
+
+  if (selectedProfile.rootDir.exists()) {
+    var dialogTitle = gProfileManagerBundle.getString("deleteTitle");
+    var dialogText = gProfileManagerBundle.getFormattedString(
+      "deleteProfileConfirm",
+      [selectedProfile.rootDir.path]
+    );
+
+    var buttonPressed = Services.prompt.confirmEx(
+      window,
+      dialogTitle,
+      dialogText,
+      Services.prompt.BUTTON_TITLE_IS_STRING * Services.prompt.BUTTON_POS_0 +
+        Services.prompt.BUTTON_TITLE_CANCEL * Services.prompt.BUTTON_POS_1 +
+        Services.prompt.BUTTON_TITLE_IS_STRING * Services.prompt.BUTTON_POS_2,
+      gProfileManagerBundle.getString("dontDeleteFiles"),
+      null,
+      gProfileManagerBundle.getString("deleteFiles"),
+      null,
+      { value: 0 }
+    );
+    if (buttonPressed == 1) {
+      return false;
+    }
+
+    if (buttonPressed == 2) {
+      deleteFiles = true;
+    }
+  }
+
+  try {
+    selectedProfile.remove(deleteFiles);
+    gNeedsFlush = true;
+  } catch (e) {
+    let title = gProfileManagerBundle.getString("profileDeletionFailedTitle");
+    let msg = gProfileManagerBundle.getString("profileDeletionFailed");
+    Services.prompt.alert(window, title, msg);
+
+    return true;
+  }
+
+  profileList.removeChild(selectedItem);
+  if (profileList.firstChild != undefined) {
+    profileList.selectItem(profileList.firstChild);
+  }
+
+  return true;
+}
diff --git a/toolkit/profile/content/profileSelection.xhtml b/toolkit/profile/content/profileSelection.xhtml
new file mode 100644
index 0000000000..3dd1c864f7
--- /dev/null
+++ b/toolkit/profile/content/profileSelection.xhtml
@@ -0,0 +1,72 @@
+<?xml version="1.0"?>
+<!-- -*- Mode: SGML; indent-tabs-mode: nil; -*- -->
+<!--
+
+ 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/. -->
+
+<?xml-stylesheet href="chrome://mozapps/skin/profileSelection.css" type="text/css"?>
+
+<!DOCTYPE window>
+
+<window
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+  xmlns:html="http://www.w3.org/1999/xhtml"
+  class="non-resizable"
+  data-l10n-id="profile-selection-window"
+  orient="vertical"
+  prefwidth="min-width"
+  style="min-width: 30em;"
+  onload="startup();">
+<dialog id="profileWindow"
+  buttons="accept,cancel"
+  buttonidaccept="profile-selection-button-accept"
+  buttonidcancel="profile-selection-button-cancel">
+
+  <linkset>
+    <html:link rel="localization" href="branding/brand.ftl"/>
+    <html:link rel="localization" href="toolkit/global/profileSelection.ftl"/>
+  </linkset>
+
+  <script src="chrome://global/content/customElements.js"/>
+
+  <stringbundle id="bundle_profileManager"
+                src="chrome://mozapps/locale/profile/profileSelection.properties"/>
+  <stringbundle id="bundle_brand"
+                src="chrome://branding/locale/brand.properties"/>
+
+  <script src="chrome://mozapps/content/profile/profileSelection.js"/>
+
+  <description class="label" data-l10n-id="profile-manager-description"></description>
+
+  <separator class="thin"/>
+
+  <hbox class="profile-box indent" flex="1">
+
+    <vbox id="managebuttons">
+      <button id="newbutton" data-l10n-id="profile-selection-new-button"
+              oncommand="CreateProfileWizard();"/>
+      <button id="renbutton" data-l10n-id="profile-selection-rename-button"
+              oncommand="RenameProfile();"/>
+      <button id="delbutton" data-l10n-id="profile-selection-delete-button"
+              oncommand="ConfirmDelete();"/>
+    </vbox>
+
+    <separator flex="1"/>
+
+    <vbox flex="1">
+      <richlistbox id="profiles" class="theme-listbox" seltype="single"
+                   ondblclick="onProfilesDblClick(event)"
+                   onkeypress="onProfilesKey(event);">
+      </richlistbox>
+
+      <!-- Bug 257777 -->
+      <checkbox id="offlineState" data-l10n-id="profile-manager-work-offline" native="true"/>
+
+      <checkbox id="autoSelectLastProfile" data-l10n-id="profile-manager-use-selected" native="true"/>
+    </vbox>
+
+  </hbox>
+</dialog>
+</window>
diff --git a/toolkit/profile/gtest/TestProfileLock.cpp b/toolkit/profile/gtest/TestProfileLock.cpp
new file mode 100644
index 0000000000..918a41bf7d
--- /dev/null
+++ b/toolkit/profile/gtest/TestProfileLock.cpp
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "gtest/gtest.h"
+
+#include "nsCOMPtr.h"
+#include "nsIFile.h"
+#include "nsProfileLock.h"
+#include "nsString.h"
+#include "nsDirectoryServiceDefs.h"
+
+TEST(ProfileLock, BasicLock)
+{
+  char tmpExt[] = "profilebasiclocktest";
+
+  nsProfileLock myLock;
+  nsresult rv;
+
+  nsCOMPtr<nsIFile> tmpDir;
+  rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(tmpDir));
+  ASSERT_EQ(NS_SUCCEEDED(rv), true);
+
+  rv = tmpDir->AppendNative(nsCString(tmpExt));
+  ASSERT_EQ(NS_SUCCEEDED(rv), true);
+
+  rv = tmpDir->CreateUnique(nsIFile::DIRECTORY_TYPE, 0700);
+  ASSERT_EQ(NS_SUCCEEDED(rv), true);
+
+  rv = myLock.Lock(tmpDir, nullptr);
+  EXPECT_EQ(NS_SUCCEEDED(rv), true);
+
+  myLock.Cleanup();
+}
diff --git a/toolkit/profile/gtest/TestProfileLockRetry.cpp b/toolkit/profile/gtest/TestProfileLockRetry.cpp
new file mode 100644
index 0000000000..8301103493
--- /dev/null
+++ b/toolkit/profile/gtest/TestProfileLockRetry.cpp
@@ -0,0 +1,74 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "gtest/gtest.h"
+
+#include <sys/eventfd.h>
+#include <sched.h>
+
+#include "nsComponentManagerUtils.h"
+#include "nsCOMPtr.h"
+#include "nsIFile.h"
+#include "nsProfileLock.h"
+#include "nsString.h"
+
+TEST(ProfileLock, RetryLock)
+{
+  char templ[] = "/tmp/profilelocktest.XXXXXX";
+  char* tmpdir = mkdtemp(templ);
+  ASSERT_NE(tmpdir, nullptr);
+
+  nsProfileLock myLock;
+  nsProfileLock myLock2;
+  nsresult rv;
+  nsCOMPtr<nsIFile> dir(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv));
+  ASSERT_EQ(NS_SUCCEEDED(rv), true);
+
+  rv = dir->InitWithNativePath(nsCString(tmpdir));
+  ASSERT_EQ(NS_SUCCEEDED(rv), true);
+
+  int eventfd_fd = eventfd(0, 0);
+  ASSERT_GE(eventfd_fd, 0);
+
+  // fcntl advisory locks are per process, so it's hard
+  // to avoid using fork here.
+  pid_t childpid = fork();
+
+  if (childpid) {
+    // parent
+
+    // blocking read causing us to lose the race
+    eventfd_t value;
+    EXPECT_EQ(0, eventfd_read(eventfd_fd, &value));
+
+    rv = myLock2.Lock(dir, nullptr);
+    EXPECT_EQ(NS_ERROR_FILE_ACCESS_DENIED, rv);
+
+    // kill the child
+    EXPECT_EQ(0, kill(childpid, SIGTERM));
+
+    // reap zombie (required to collect the lock)
+    int status;
+    EXPECT_EQ(childpid, waitpid(childpid, &status, 0));
+
+    rv = myLock2.Lock(dir, nullptr);
+    EXPECT_EQ(NS_SUCCEEDED(rv), true);
+  } else {
+    // child
+    rv = myLock.Lock(dir, nullptr);
+    ASSERT_EQ(NS_SUCCEEDED(rv), true);
+
+    // unblock parent
+    EXPECT_EQ(0, eventfd_write(eventfd_fd, 1));
+
+    // parent will kill us
+    for (;;) sleep(1);
+  }
+
+  close(eventfd_fd);
+
+  myLock.Cleanup();
+  myLock2.Cleanup();
+}
diff --git a/toolkit/profile/gtest/moz.build b/toolkit/profile/gtest/moz.build
new file mode 100644
index 0000000000..d9219b4113
--- /dev/null
+++ b/toolkit/profile/gtest/moz.build
@@ -0,0 +1,20 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+LOCAL_INCLUDES += [
+    "..",
+]
+
+UNIFIED_SOURCES += [
+    "TestProfileLock.cpp",
+]
+
+if CONFIG["OS_ARCH"] == "Linux" and CONFIG["OS_TARGET"] != "Android":
+    UNIFIED_SOURCES += [
+        "TestProfileLockRetry.cpp",
+    ]
+
+FINAL_LIBRARY = "xul-gtest"
diff --git a/toolkit/profile/jar.mn b/toolkit/profile/jar.mn
new file mode 100644
index 0000000000..4ddead64cb
--- /dev/null
+++ b/toolkit/profile/jar.mn
@@ -0,0 +1,13 @@
+# 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/.
+
+toolkit.jar:
+  content/mozapps/profile/createProfileWizard.js  (content/createProfileWizard.js)
+  content/mozapps/profile/createProfileWizard.xhtml (content/createProfileWizard.xhtml)
+  content/mozapps/profile/profileSelection.js     (content/profileSelection.js)
+  content/mozapps/profile/profileSelection.xhtml  (content/profileSelection.xhtml)
+#ifdef MOZ_BLOCK_PROFILE_DOWNGRADE
+  content/mozapps/profile/profileDowngrade.js     (content/profileDowngrade.js)
+* content/mozapps/profile/profileDowngrade.xhtml  (content/profileDowngrade.xhtml)
+#endif
diff --git a/toolkit/profile/moz.build b/toolkit/profile/moz.build
new file mode 100644
index 0000000000..5eb7a3053d
--- /dev/null
+++ b/toolkit/profile/moz.build
@@ -0,0 +1,45 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+MOCHITEST_CHROME_MANIFESTS += ["test/chrome.ini"]
+
+XPCSHELL_TESTS_MANIFESTS += ["xpcshell/xpcshell.ini"]
+
+if CONFIG["ENABLE_TESTS"]:
+    DIRS += ["gtest"]
+
+XPIDL_SOURCES += [
+    "nsIProfileMigrator.idl",
+    "nsIProfileUnlocker.idl",
+    "nsIToolkitProfile.idl",
+    "nsIToolkitProfileService.idl",
+]
+
+XPIDL_MODULE = "toolkitprofile"
+
+UNIFIED_SOURCES += ["nsProfileLock.cpp"]
+
+if CONFIG["OS_ARCH"] == "WINNT":
+    UNIFIED_SOURCES += ["ProfileUnlockerWin.cpp"]
+
+if CONFIG["OS_TARGET"] == "Android":
+    UNIFIED_SOURCES += ["ProfileUnlockerAndroid.cpp"]
+
+UNIFIED_SOURCES += ["nsToolkitProfileService.cpp"]
+
+LOCAL_INCLUDES += [
+    "../xre",
+]
+
+FINAL_LIBRARY = "xul"
+
+for var in ("MOZ_APP_NAME", "MOZ_APP_BASENAME"):
+    DEFINES[var] = '"%s"' % CONFIG[var]
+
+JAR_MANIFESTS += ["jar.mn"]
+
+with Files("**"):
+    BUG_COMPONENT = ("Toolkit", "Startup and Profile System")
diff --git a/toolkit/profile/notifications.txt b/toolkit/profile/notifications.txt
new file mode 100644
index 0000000000..e6703b274c
--- /dev/null
+++ b/toolkit/profile/notifications.txt
@@ -0,0 +1,52 @@
+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/.
+
+nsIObserver topics for profile changing. Profile changing happens in phases
+in the order given below. An observer may register separately for each phase
+of the process depending on its needs.
+
+"profile-change-teardown"
+  All async activity must be stopped in this phase. Typically,
+  the application level observer will close all open windows.
+  This is the last phase in which the subject's vetoChange()
+  method may still be called.
+  The next notification will be either
+  profile-change-teardown-veto or profile-before-change.
+
+"profile-before-change"
+  Called before the profile has changed. Use this notification
+  to prepare for the profile going away. If a component is
+  holding any state which needs to be flushed to a profile-relative
+  location, it should be done here.
+
+"profile-do-change"
+  Called after the profile has changed. Do the work to
+  respond to having a new profile. Any change which
+  affects others must be done in this phase.
+
+"profile-after-change"
+  Called after the profile has changed. Use this notification
+  to make changes that are dependent on what some other listener
+  did during its profile-do-change. For example, to respond to
+  new preferences.
+
+"profile-initial-state"
+  Called after all phases of a change have completed. Typically
+  in this phase, an application level observer will open a new window.
+
+Contexts for profile changes. These are passed as the someData param to the
+observer's Observe() method.
+
+"startup"
+  Going from no profile to a profile.
+  The following topics happen in this context:
+      profile-do-change
+      profile-after-change
+
+See https://wiki.mozilla.org/XPCOM_Shutdown for more details about the shutdown
+process.
+
+NOTE: Long ago there was be a "shutdown-cleanse" version of shutdown which was
+intended to clear profile data. This is no longer sent and observer code should
+remove support for it.
diff --git a/toolkit/profile/nsIProfileMigrator.idl b/toolkit/profile/nsIProfileMigrator.idl
new file mode 100644
index 0000000000..6936ce4242
--- /dev/null
+++ b/toolkit/profile/nsIProfileMigrator.idl
@@ -0,0 +1,69 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "nsISupports.idl"
+interface nsIFile;
+
+/**
+ * Helper interface for nsIProfileMigrator.
+ *
+ * @provider Toolkit (Startup code)
+ * @client   Application (Profile-migration code)
+ * @obtainable nsIProfileMigrator.migrate
+ */
+[scriptable, uuid(048e5ca1-0eb7-4bb1-a9a2-a36f7d4e0e3c)]
+interface nsIProfileStartup : nsISupports
+{
+  /**
+   * The root directory of the semi-current profile, during profile migration.
+   * After nsIProfileMigrator.migrate has returned, this object will not be
+   * useful.
+   */
+  readonly attribute nsIFile directory;
+
+  /**
+   * Do profile-startup by setting NS_APP_USER_PROFILE_50_DIR in the directory
+   * service and notifying the profile-startup observer topics.
+   */
+  void doStartup();
+};
+
+/**
+ * Migrate application settings from an outside source.
+ *
+ * @provider Application (Profile-migration code)
+ * @client   Toolkit (Startup code)
+ * @obtainable service, contractid("@mozilla.org/toolkit/profile-migrator;1")
+ */
+[scriptable, uuid(3df284a5-2258-4d46-a664-761ecdc04c22)]
+interface nsIProfileMigrator : nsISupports
+{
+  /**
+   * Migrate data from an outside source, if possible.  Does nothing
+   * otherwise.
+   *
+   * When this method is called, a default profile has been created;
+   * XPCOM has been initialized such that compreg.dat is in the
+   * profile; the directory service does *not* return a key for
+   * NS_APP_USER_PROFILE_50_DIR or any of the keys depending on an active
+   * profile. To figure out the directory of the "current" profile, use
+   * aStartup.directory.
+   *
+   * If your migrator needs to access services that use the profile (to
+   * set profile prefs or bookmarks, for example), use aStartup.doStartup.
+   *
+   * @param  aStartup nsIProfileStartup object to use during migration.
+   * @param  aKey     optional key of a migrator to use to skip source selection.
+   * @param  aProfileName optional name of the profile to use for migration.
+   *
+   * @note The startup code ignores COM exceptions thrown from this method.
+   */
+  void migrate(in nsIProfileStartup aStartup, in ACString aKey,
+               [optional] in AUTF8String aProfileName);
+};
+
+%{C++
+#define NS_PROFILEMIGRATOR_CONTRACTID "@mozilla.org/toolkit/profile-migrator;1"
+%}
diff --git a/toolkit/profile/nsIProfileUnlocker.idl b/toolkit/profile/nsIProfileUnlocker.idl
new file mode 100644
index 0000000000..cd1a71051f
--- /dev/null
+++ b/toolkit/profile/nsIProfileUnlocker.idl
@@ -0,0 +1,21 @@
+/* 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/. */
+
+#include "nsISupports.idl"
+
+[scriptable, uuid(08923af1-e7a3-4fae-ba02-128502193994)]
+interface nsIProfileUnlocker : nsISupports
+{
+  const unsigned long ATTEMPT_QUIT = 0;
+  const unsigned long FORCE_QUIT   = 1;
+
+  /**
+   * Try to unlock the specified profile by attempting or forcing the
+   * process that currently holds the lock to quit.
+   *
+   * @param aSeverity either ATTEMPT_QUIT or FORCE_QUIT
+   * @throws NS_ERROR_FAILURE if unlocking failed.
+   */
+  void unlock(in unsigned long aSeverity);
+};
diff --git a/toolkit/profile/nsIToolkitProfile.idl b/toolkit/profile/nsIToolkitProfile.idl
new file mode 100644
index 0000000000..b194cd9563
--- /dev/null
+++ b/toolkit/profile/nsIToolkitProfile.idl
@@ -0,0 +1,99 @@
+/* -*- Mode: IDL; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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/. */
+
+#include "nsISupports.idl"
+
+interface nsIFile;
+interface nsIProfileUnlocker;
+
+/**
+ * Hold on to a profile lock. Once you release the last reference to this
+ * interface, the profile lock is released.
+ */
+[scriptable, uuid(7c58c703-d245-4864-8d75-9648ca4a6139)]
+interface nsIProfileLock : nsISupports
+{
+    /**
+     * The main profile directory.
+     */
+    readonly attribute nsIFile directory;
+
+    /**
+     * A directory corresponding to the main profile directory that exists for
+     * the purpose of storing data on the local filesystem, including cache
+     * files or other data files that may not represent critical user data.
+     * (e.g., this directory may not be included as part of a backup scheme.)
+     *
+     * In some cases, this directory may just be the main profile directory.
+     */
+    readonly attribute nsIFile localDirectory;
+
+    /**
+     * The timestamp of an existing profile lock at lock time.
+     */
+    readonly attribute PRTime replacedLockTime;
+
+    /**
+     * Unlock the profile.
+     */
+    void unlock();
+};
+
+/**
+ * A interface representing a profile.
+ * @note THIS INTERFACE SHOULD BE IMPLEMENTED BY THE TOOLKIT CODE ONLY! DON'T
+ *       EVEN THINK ABOUT IMPLEMENTING THIS IN JAVASCRIPT!
+ */
+[scriptable, builtinclass, uuid(7422b090-4a86-4407-972e-75468a625388)]
+interface nsIToolkitProfile : nsISupports
+{
+    /**
+     * The location of the profile directory.
+     */
+    readonly attribute nsIFile rootDir;
+
+    /**
+     * The location of the profile local directory, which may be the same as
+     * the root directory.  See nsIProfileLock::localDirectory.
+     */
+    readonly attribute nsIFile localDir;
+
+    /**
+     * The name of the profile.
+     */
+    attribute AUTF8String name;
+
+    /**
+     * Removes the profile from the registry of profiles.
+     *
+     * @param removeFiles
+     *        Indicates whether or not the profile directory should be
+     *        removed in addition.
+     */
+    void remove(in boolean removeFiles);
+
+    /**
+     * Removes the profile from the registry of profiles.
+     * The profile directory is removed in the stream transport thread.
+     *
+     * @param removeFiles
+     *        Indicates whether or not the profile directory should be
+     *        removed in addition.
+     */
+    void removeInBackground(in boolean removeFiles);
+
+    /**
+     * Lock this profile using platform-specific locking methods.
+     *
+     * @param lockFile If locking fails, this may return a lockFile object
+     *                 which can be used in platform-specific ways to
+     *                 determine which process has the file locked. Null
+     *                 may be passed.
+     * @return An interface which holds a profile lock as long as you reference
+     *         it.
+     * @throws NS_ERROR_FILE_ACCESS_DENIED if the profile was already locked.
+     */
+    nsIProfileLock lock(out nsIProfileUnlocker aUnlocker);
+};
diff --git a/toolkit/profile/nsIToolkitProfileService.idl b/toolkit/profile/nsIToolkitProfileService.idl
new file mode 100644
index 0000000000..f8519f1101
--- /dev/null
+++ b/toolkit/profile/nsIToolkitProfileService.idl
@@ -0,0 +1,147 @@
+/* -*- Mode: IDL; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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/. */
+
+#include "nsISupports.idl"
+
+interface nsISimpleEnumerator;
+interface nsIFile;
+interface nsIToolkitProfile;
+interface nsIProfileLock;
+
+[scriptable, builtinclass, uuid(1947899b-f369-48fa-89da-f7c37bb1e6bc)]
+interface nsIToolkitProfileService : nsISupports
+{
+    /**
+     * Tests whether the profile lists on disk have changed since they were
+     * loaded. When this is true attempts to flush changes to disk will fail.
+     */
+    [infallible] readonly attribute boolean isListOutdated;
+
+    /**
+     * When a downgrade is detected UI is presented to the user to ask how to
+     * proceed. These flags are used to pass some information to the UI.
+     */
+    cenum downgradeUIFlags: 8 {
+        hasSync = 1,
+    };
+
+    /**
+     * When a downgrade is detected UI is presented to the user to ask how to
+     * proceed. These are the possible options the user can choose.
+     */
+    cenum downgradeUIChoice: 8 {
+        quit = 0,
+        createNewProfile = 1,
+    };
+
+    cenum profileManagerResult: 8 {
+        exit = 0,
+        launchWithProfile = 1,
+        restart = 2,
+    };
+
+    attribute boolean startWithLastProfile;
+
+    readonly attribute nsISimpleEnumerator /*nsIToolkitProfile*/ profiles;
+
+    /**
+     * The profile currently in use if it is a named profile. This will return
+     * null if the current profile path doesn't match a profile in the database.
+     */
+    readonly attribute nsIToolkitProfile currentProfile;
+
+    /**
+     * The default profile for this build.
+     * On startup this is the profile selected unless overridden by command line
+     * arguments or environment variables. Setting this will change the profile
+     * used by default the next time the application is started.
+     * Attempting to change the default may throw an exception on builds that do
+     * not support changing the default profile, such as developer edition.
+     */
+    attribute nsIToolkitProfile defaultProfile;
+
+    /**
+     * Selects or creates a profile to use based on the profiles database, any
+     * environment variables and any command line arguments. Will not create
+     * a profile if aIsResetting is true. The profile is selected based on this
+     * order of preference:
+     * * Environment variables (set when restarting the application).
+     * * --profile command line argument.
+     * * --createprofile command line argument (this also causes the app to exit).
+     * * -p command line argument.
+     * * A new profile created if this is the first run of the application.
+     * * The default profile.
+     * aRootDir and aLocalDir are set to the data and local directories for the
+     * profile data. If a profile from the database was selected it will be
+     * returned in aProfile.
+     * This returns true if a new profile was created.
+     * This method is primarily for testing. It can be called only once.
+     */
+    bool selectStartupProfile(in Array<ACString> aArgv,
+                              in boolean aIsResetting, in AUTF8String aUpdateChannel,
+                              in AUTF8String aLegacyInstallHash,
+                              out nsIFile aRootDir, out nsIFile aLocalDir,
+                              out nsIToolkitProfile aProfile);
+
+    /**
+     * Get a profile by name. This is mainly for use by the -P
+     * commandline flag.
+     *
+     * @param aName The profile name to find.
+     */
+    nsIToolkitProfile getProfileByName(in AUTF8String aName);
+
+    /**
+     * Create a new profile.
+     *
+     * The profile temporary directory will be chosen based on where the
+     * profile directory is located.
+     *
+     * If a profile with the given name already exists it will be returned
+     * instead of creating a new profile.
+     *
+     * @param aRootDir
+     *        The profile directory. May be null, in which case a suitable
+     *        default will be chosen based on the profile name.
+     * @param aName
+     *        The profile name.
+     */
+    nsIToolkitProfile createProfile(in nsIFile aRootDir,
+                                    in AUTF8String aName);
+
+    /**
+     * Create a new profile with a unique name.
+     *
+     * As above however the name given will be altered to make it a unique
+     * profile name.
+     *
+     * @param aRootDir
+     *        The profile directory. May be null, in which case a suitable
+     *        default will be chosen based on the profile name.
+     * @param aNamePrefix
+     *        The prefix to use for the profile name. If unused this will be
+     *        used as the profile name otherwise additional characters will be
+     *        added to make the name unique.
+     */
+    nsIToolkitProfile createUniqueProfile(in nsIFile aRootDir,
+                                          in AUTF8String aNamePrefix);
+
+    /**
+     * Returns the number of profiles.
+     * @return the number of profiles.
+     */
+    readonly attribute unsigned long profileCount;
+
+    /**
+     * Flush the profiles list file. This will fail with
+     * NS_ERROR_DATABASE_CHANGED if the files on disk have changed since the
+     * profiles were loaded.
+     */
+    void flush();
+};
+
+%{C++
+#define NS_PROFILESERVICE_CONTRACTID "@mozilla.org/toolkit/profile-service;1"
+%}
diff --git a/toolkit/profile/nsProfileLock.cpp b/toolkit/profile/nsProfileLock.cpp
new file mode 100644
index 0000000000..0a809642aa
--- /dev/null
+++ b/toolkit/profile/nsProfileLock.cpp
@@ -0,0 +1,578 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "nsProfileLock.h"
+#include "nsCOMPtr.h"
+#include "nsQueryObject.h"
+#include "nsString.h"
+#include "nsPrintfCString.h"
+#include "nsDebug.h"
+
+#if defined(XP_WIN)
+#  include "ProfileUnlockerWin.h"
+#endif
+
+#if defined(XP_MACOSX)
+#  include <Carbon/Carbon.h>
+#  include <CoreFoundation/CoreFoundation.h>
+#endif
+
+#if defined(MOZ_WIDGET_ANDROID)
+#  include "ProfileUnlockerAndroid.h"
+#endif
+
+#ifdef XP_UNIX
+#  include <unistd.h>
+#  include <fcntl.h>
+#  include <errno.h>
+#  include <signal.h>
+#  include <stdlib.h>
+#  include "prnetdb.h"
+#  include "prsystem.h"
+#  include "prenv.h"
+#  include "mozilla/Printf.h"
+#endif
+
+// **********************************************************************
+// class nsProfileLock
+//
+// This code was moved from profile/src/nsProfileAccess.
+// **********************************************************************
+
+#if defined(XP_UNIX)
+static bool sDisableSignalHandling = false;
+#endif
+
+nsProfileLock::nsProfileLock()
+    : mHaveLock(false),
+      mReplacedLockTime(0)
+#if defined(XP_WIN)
+      ,
+      mLockFileHandle(INVALID_HANDLE_VALUE)
+#elif defined(XP_UNIX)
+      ,
+      mPidLockFileName(nullptr),
+      mLockFileDesc(-1)
+#endif
+{
+#if defined(XP_UNIX)
+  next = prev = this;
+  sDisableSignalHandling = PR_GetEnv("MOZ_DISABLE_SIG_HANDLER") ? true : false;
+#endif
+}
+
+nsProfileLock::nsProfileLock(nsProfileLock& src) { *this = src; }
+
+nsProfileLock& nsProfileLock::operator=(nsProfileLock& rhs) {
+  Unlock();
+
+  mHaveLock = rhs.mHaveLock;
+  rhs.mHaveLock = false;
+
+#if defined(XP_WIN)
+  mLockFileHandle = rhs.mLockFileHandle;
+  rhs.mLockFileHandle = INVALID_HANDLE_VALUE;
+#elif defined(XP_UNIX)
+  mLockFileDesc = rhs.mLockFileDesc;
+  rhs.mLockFileDesc = -1;
+  mPidLockFileName = rhs.mPidLockFileName;
+  rhs.mPidLockFileName = nullptr;
+  if (mPidLockFileName) {
+    // rhs had a symlink lock, therefore it was on the list.
+    PR_REMOVE_LINK(&rhs);
+    PR_APPEND_LINK(this, &mPidLockList);
+  }
+#endif
+
+  return *this;
+}
+
+nsProfileLock::~nsProfileLock() {
+  Unlock();
+  // Note that we don't clean up by default here so on next startup we know when
+  // the profile was last used based on the modification time of the lock file.
+}
+
+#if defined(XP_UNIX)
+
+static int setupPidLockCleanup;
+
+PRCList nsProfileLock::mPidLockList =
+    PR_INIT_STATIC_CLIST(&nsProfileLock::mPidLockList);
+
+void nsProfileLock::RemovePidLockFiles(bool aFatalSignal) {
+  while (!PR_CLIST_IS_EMPTY(&mPidLockList)) {
+    nsProfileLock* lock = static_cast<nsProfileLock*>(mPidLockList.next);
+    lock->Unlock(aFatalSignal);
+  }
+}
+
+static struct sigaction SIGHUP_oldact;
+static struct sigaction SIGINT_oldact;
+static struct sigaction SIGQUIT_oldact;
+static struct sigaction SIGILL_oldact;
+static struct sigaction SIGABRT_oldact;
+static struct sigaction SIGSEGV_oldact;
+static struct sigaction SIGTERM_oldact;
+
+void nsProfileLock::FatalSignalHandler(int signo
+#  ifdef SA_SIGINFO
+                                       ,
+                                       siginfo_t* info, void* context
+#  endif
+) {
+  // Remove any locks still held.
+  RemovePidLockFiles(true);
+
+  // Chain to the old handler, which may exit.
+  struct sigaction* oldact = nullptr;
+
+  switch (signo) {
+    case SIGHUP:
+      oldact = &SIGHUP_oldact;
+      break;
+    case SIGINT:
+      oldact = &SIGINT_oldact;
+      break;
+    case SIGQUIT:
+      oldact = &SIGQUIT_oldact;
+      break;
+    case SIGILL:
+      oldact = &SIGILL_oldact;
+      break;
+    case SIGABRT:
+      oldact = &SIGABRT_oldact;
+      break;
+    case SIGSEGV:
+      oldact = &SIGSEGV_oldact;
+      break;
+    case SIGTERM:
+      oldact = &SIGTERM_oldact;
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("bad signo");
+      break;
+  }
+
+  if (oldact) {
+    if (oldact->sa_handler == SIG_DFL) {
+      // Make sure the default sig handler is executed
+      // We need it to get Mozilla to dump core.
+      sigaction(signo, oldact, nullptr);
+
+      // Now that we've restored the default handler, unmask the
+      // signal and invoke it.
+
+      sigset_t unblock_sigs;
+      sigemptyset(&unblock_sigs);
+      sigaddset(&unblock_sigs, signo);
+
+      sigprocmask(SIG_UNBLOCK, &unblock_sigs, nullptr);
+
+      raise(signo);
+    }
+#  ifdef SA_SIGINFO
+    else if (oldact->sa_sigaction &&
+             (oldact->sa_flags & SA_SIGINFO) == SA_SIGINFO) {
+      oldact->sa_sigaction(signo, info, context);
+    }
+#  endif
+    else if (oldact->sa_handler && oldact->sa_handler != SIG_IGN) {
+      oldact->sa_handler(signo);
+    }
+  }
+
+  // Backstop exit call, just in case.
+  _exit(signo);
+}
+
+nsresult nsProfileLock::LockWithFcntl(nsIFile* aLockFile,
+                                      nsIProfileUnlocker** aUnlocker) {
+  nsresult rv = NS_OK;
+
+  nsAutoCString lockFilePath;
+  rv = aLockFile->GetNativePath(lockFilePath);
+  if (NS_FAILED(rv)) {
+    NS_ERROR("Could not get native path");
+    return rv;
+  }
+
+  aLockFile->GetLastModifiedTime(&mReplacedLockTime);
+
+  mLockFileDesc = open(lockFilePath.get(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
+  if (mLockFileDesc != -1) {
+    struct flock lock;
+    lock.l_start = 0;
+    lock.l_len = 0;  // len = 0 means entire file
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+
+    // If fcntl(F_GETLK) fails then the server does not support/allow fcntl(),
+    // return failure rather than access denied in this case so we fallback
+    // to using a symlink lock, bug 303633.
+    struct flock testlock = lock;
+    if (fcntl(mLockFileDesc, F_GETLK, &testlock) == -1) {
+      close(mLockFileDesc);
+      mLockFileDesc = -1;
+      rv = NS_ERROR_FAILURE;
+    } else if (fcntl(mLockFileDesc, F_SETLK, &lock) == -1) {
+#  ifdef MOZ_WIDGET_ANDROID
+      MOZ_ASSERT(aUnlocker);
+      RefPtr<mozilla::ProfileUnlockerAndroid> unlocker(
+          new mozilla::ProfileUnlockerAndroid(testlock.l_pid));
+      nsCOMPtr<nsIProfileUnlocker> unlockerInterface(do_QueryObject(unlocker));
+      unlockerInterface.forget(aUnlocker);
+#  endif
+
+      close(mLockFileDesc);
+      mLockFileDesc = -1;
+
+      // With OS X, on NFS, errno == ENOTSUP
+      // XXX Check for that and return specific rv for it?
+#  ifdef DEBUG
+      printf("fcntl(F_SETLK) failed. errno = %d\n", errno);
+#  endif
+      if (errno == EAGAIN || errno == EACCES)
+        rv = NS_ERROR_FILE_ACCESS_DENIED;
+      else
+        rv = NS_ERROR_FAILURE;
+    }
+  } else {
+    NS_ERROR("Failed to open lock file.");
+    rv = NS_ERROR_FAILURE;
+  }
+  return rv;
+}
+
+static bool IsSymlinkStaleLock(struct in_addr* aAddr, const char* aFileName,
+                               bool aHaveFcntlLock) {
+  // the link exists; see if it's from this machine, and if
+  // so if the process is still active
+  char buf[1024];
+  int len = readlink(aFileName, buf, sizeof buf - 1);
+  if (len > 0) {
+    buf[len] = '\0';
+    char* colon = strchr(buf, ':');
+    if (colon) {
+      *colon++ = '\0';
+      unsigned long addr = inet_addr(buf);
+      if (addr != (unsigned long)-1) {
+        if (colon[0] == '+' && aHaveFcntlLock) {
+          // This lock was placed by a Firefox build which would have
+          // taken the fnctl lock, and we've already taken the fcntl lock,
+          // so the process that created this obsolete lock must be gone
+          return true;
+        }
+
+        char* after = nullptr;
+        pid_t pid = strtol(colon, &after, 0);
+        if (pid != 0 && *after == '\0') {
+          if (addr != aAddr->s_addr) {
+            // Remote lock: give up even if stuck.
+            return false;
+          }
+
+          // kill(pid,0) is a neat trick to check if a
+          // process exists
+          if (kill(pid, 0) == 0 || errno != ESRCH) {
+            // Local process appears to be alive, ass-u-me it
+            // is another Mozilla instance, or a compatible
+            // derivative, that's currently using the profile.
+            // XXX need an "are you Mozilla?" protocol
+            return false;
+          }
+        }
+      }
+    }
+  }
+  return true;
+}
+
+nsresult nsProfileLock::LockWithSymlink(nsIFile* aLockFile,
+                                        bool aHaveFcntlLock) {
+  nsresult rv;
+  nsAutoCString lockFilePath;
+  rv = aLockFile->GetNativePath(lockFilePath);
+  if (NS_FAILED(rv)) {
+    NS_ERROR("Could not get native path");
+    return rv;
+  }
+
+  // don't replace an existing lock time if fcntl already got one
+  if (!mReplacedLockTime)
+    aLockFile->GetLastModifiedTimeOfLink(&mReplacedLockTime);
+
+  struct in_addr inaddr;
+  inaddr.s_addr = htonl(INADDR_LOOPBACK);
+
+  // We still have not loaded the profile, so we may not have proxy information.
+  // Avoiding a DNS lookup in this stage makes sure any proxy is not bypassed.
+  // By default, the lookup is enabled, but when it is not, we use 127.0.0.1
+  // for the IP address portion of the lock signature.
+  // However, this may cause the browser to refuse to start in the rare case
+  // that all of the following conditions are met:
+  //   1. The browser profile is on a network file system.
+  //   2. The file system does not support fcntl() locking.
+  //   3. The browser is run from two different computers at the same time.
+#  ifndef MOZ_PROXY_BYPASS_PROTECTION
+  char hostname[256];
+  PRStatus status = PR_GetSystemInfo(PR_SI_HOSTNAME, hostname, sizeof hostname);
+  if (status == PR_SUCCESS) {
+    char netdbbuf[PR_NETDB_BUF_SIZE];
+    PRHostEnt hostent;
+    status = PR_GetHostByName(hostname, netdbbuf, sizeof netdbbuf, &hostent);
+    if (status == PR_SUCCESS) memcpy(&inaddr, hostent.h_addr, sizeof inaddr);
+  }
+#  endif
+
+  mozilla::SmprintfPointer signature =
+      mozilla::Smprintf("%s:%s%lu", inet_ntoa(inaddr),
+                        aHaveFcntlLock ? "+" : "", (unsigned long)getpid());
+  const char* fileName = lockFilePath.get();
+  int symlink_rv, symlink_errno = 0, tries = 0;
+
+  // use ns4.x-compatible symlinks if the FS supports them
+  while ((symlink_rv = symlink(signature.get(), fileName)) < 0) {
+    symlink_errno = errno;
+    if (symlink_errno != EEXIST) break;
+
+    if (!IsSymlinkStaleLock(&inaddr, fileName, aHaveFcntlLock)) break;
+
+    // Lock seems to be bogus: try to claim it.  Give up after a large
+    // number of attempts (100 comes from the 4.x codebase).
+    (void)unlink(fileName);
+    if (++tries > 100) break;
+  }
+
+  if (symlink_rv == 0) {
+    // We exclusively created the symlink: record its name for eventual
+    // unlock-via-unlink.
+    rv = NS_OK;
+    mPidLockFileName = strdup(fileName);
+    if (mPidLockFileName) {
+      PR_APPEND_LINK(this, &mPidLockList);
+      if (!setupPidLockCleanup++) {
+        // Clean up on normal termination.
+        // This instanciates a dummy class, and will trigger the class
+        // destructor when libxul is unloaded. This is equivalent to atexit(),
+        // but gracefully handles dlclose().
+        static RemovePidLockFilesExiting r;
+
+        // Clean up on abnormal termination, using POSIX sigaction.
+        // Don't arm a handler if the signal is being ignored, e.g.,
+        // because mozilla is run via nohup.
+        if (!sDisableSignalHandling) {
+          struct sigaction act, oldact;
+#  ifdef SA_SIGINFO
+          act.sa_sigaction = FatalSignalHandler;
+          act.sa_flags = SA_SIGINFO | SA_ONSTACK;
+#  else
+          act.sa_handler = FatalSignalHandler;
+#  endif
+          sigfillset(&act.sa_mask);
+
+#  define CATCH_SIGNAL(signame)                      \
+    PR_BEGIN_MACRO                                   \
+    if (sigaction(signame, nullptr, &oldact) == 0 && \
+        oldact.sa_handler != SIG_IGN) {              \
+      sigaction(signame, &act, &signame##_oldact);   \
+    }                                                \
+    PR_END_MACRO
+
+          CATCH_SIGNAL(SIGHUP);
+          CATCH_SIGNAL(SIGINT);
+          CATCH_SIGNAL(SIGQUIT);
+          CATCH_SIGNAL(SIGILL);
+          CATCH_SIGNAL(SIGABRT);
+          CATCH_SIGNAL(SIGSEGV);
+          CATCH_SIGNAL(SIGTERM);
+
+#  undef CATCH_SIGNAL
+        }
+      }
+    }
+  } else if (symlink_errno == EEXIST)
+    rv = NS_ERROR_FILE_ACCESS_DENIED;
+  else {
+#  ifdef DEBUG
+    printf("symlink() failed. errno = %d\n", errno);
+#  endif
+    rv = NS_ERROR_FAILURE;
+  }
+  return rv;
+}
+#endif /* XP_UNIX */
+
+nsresult nsProfileLock::GetReplacedLockTime(PRTime* aResult) {
+  *aResult = mReplacedLockTime;
+  return NS_OK;
+}
+
+#if defined(XP_MACOSX)
+constexpr auto LOCKFILE_NAME = u".parentlock"_ns;
+constexpr auto OLD_LOCKFILE_NAME = u"parent.lock"_ns;
+#elif defined(XP_UNIX)
+constexpr auto OLD_LOCKFILE_NAME = u"lock"_ns;
+constexpr auto LOCKFILE_NAME = u".parentlock"_ns;
+#else
+constexpr auto LOCKFILE_NAME = u"parent.lock"_ns;
+#endif
+
+bool nsProfileLock::IsMaybeLockFile(nsIFile* aFile) {
+  nsAutoString tmp;
+  if (NS_SUCCEEDED(aFile->GetLeafName(tmp))) {
+    if (tmp.Equals(LOCKFILE_NAME)) return true;
+#if (defined(XP_MACOSX) || defined(XP_UNIX))
+    if (tmp.Equals(OLD_LOCKFILE_NAME)) return true;
+#endif
+  }
+  return false;
+}
+
+nsresult nsProfileLock::Lock(nsIFile* aProfileDir,
+                             nsIProfileUnlocker** aUnlocker) {
+  nsresult rv;
+  if (aUnlocker) *aUnlocker = nullptr;
+
+  NS_ENSURE_STATE(!mHaveLock);
+
+  bool isDir;
+  rv = aProfileDir->IsDirectory(&isDir);
+  if (NS_FAILED(rv)) return rv;
+  if (!isDir) return NS_ERROR_FILE_NOT_DIRECTORY;
+
+  nsCOMPtr<nsIFile> lockFile;
+  rv = aProfileDir->Clone(getter_AddRefs(lockFile));
+  if (NS_FAILED(rv)) return rv;
+
+  rv = lockFile->Append(LOCKFILE_NAME);
+  if (NS_FAILED(rv)) return rv;
+
+  // Remember the name we're using so we can clean up
+  rv = lockFile->Clone(getter_AddRefs(mLockFile));
+  if (NS_FAILED(rv)) return rv;
+
+#if defined(XP_MACOSX)
+  // First, try locking using fcntl. It is more reliable on
+  // a local machine, but may not be supported by an NFS server.
+
+  rv = LockWithFcntl(lockFile);
+  if (NS_FAILED(rv) && (rv != NS_ERROR_FILE_ACCESS_DENIED)) {
+    // If that failed for any reason other than NS_ERROR_FILE_ACCESS_DENIED,
+    // assume we tried an NFS that does not support it. Now, try with symlink.
+    rv = LockWithSymlink(lockFile, false);
+  }
+#elif defined(XP_UNIX)
+  // Get the old lockfile name
+  nsCOMPtr<nsIFile> oldLockFile;
+  rv = aProfileDir->Clone(getter_AddRefs(oldLockFile));
+  if (NS_FAILED(rv)) return rv;
+  rv = oldLockFile->Append(OLD_LOCKFILE_NAME);
+  if (NS_FAILED(rv)) return rv;
+
+  // First, try locking using fcntl. It is more reliable on
+  // a local machine, but may not be supported by an NFS server.
+  rv = LockWithFcntl(lockFile, aUnlocker);
+  if (NS_SUCCEEDED(rv)) {
+    // Check to see whether there is a symlink lock held by an older
+    // Firefox build, and also place our own symlink lock --- but
+    // mark it "obsolete" so that other newer builds can break the lock
+    // if they obtain the fcntl lock
+    rv = LockWithSymlink(oldLockFile, true);
+
+    // If the symlink failed for some reason other than it already
+    // exists, then something went wrong e.g. the file system
+    // doesn't support symlinks, or we don't have permission to
+    // create a symlink there.  In such cases we should just
+    // continue because it's unlikely there is an old build
+    // running with a symlink there and we've already successfully
+    // placed a fcntl lock.
+    if (rv != NS_ERROR_FILE_ACCESS_DENIED) rv = NS_OK;
+  } else if (rv != NS_ERROR_FILE_ACCESS_DENIED) {
+    // If that failed for any reason other than NS_ERROR_FILE_ACCESS_DENIED,
+    // assume we tried an NFS that does not support it. Now, try with symlink
+    // using the old symlink path
+    rv = LockWithSymlink(oldLockFile, false);
+  }
+
+#elif defined(XP_WIN)
+  nsAutoString filePath;
+  rv = lockFile->GetPath(filePath);
+  if (NS_FAILED(rv)) return rv;
+
+  lockFile->GetLastModifiedTime(&mReplacedLockTime);
+
+  // always create the profile lock and never delete it so we can use its
+  // modification timestamp to detect startup crashes
+  mLockFileHandle = CreateFileW(filePath.get(), GENERIC_READ | GENERIC_WRITE,
+                                0,  // no sharing - of course
+                                nullptr, CREATE_ALWAYS, 0, nullptr);
+  if (mLockFileHandle == INVALID_HANDLE_VALUE) {
+    if (aUnlocker) {
+      RefPtr<mozilla::ProfileUnlockerWin> unlocker(
+          new mozilla::ProfileUnlockerWin(filePath));
+      if (NS_SUCCEEDED(unlocker->Init())) {
+        nsCOMPtr<nsIProfileUnlocker> unlockerInterface(
+            do_QueryObject(unlocker));
+        unlockerInterface.forget(aUnlocker);
+      }
+    }
+    return NS_ERROR_FILE_ACCESS_DENIED;
+  }
+#endif
+
+  if (NS_SUCCEEDED(rv)) mHaveLock = true;
+
+  return rv;
+}
+
+nsresult nsProfileLock::Unlock(bool aFatalSignal) {
+  nsresult rv = NS_OK;
+
+  if (mHaveLock) {
+#if defined(XP_WIN)
+    if (mLockFileHandle != INVALID_HANDLE_VALUE) {
+      CloseHandle(mLockFileHandle);
+      mLockFileHandle = INVALID_HANDLE_VALUE;
+    }
+#elif defined(XP_UNIX)
+    if (mPidLockFileName) {
+      PR_REMOVE_LINK(this);
+      (void)unlink(mPidLockFileName);
+
+      // Only free mPidLockFileName if we're not in the fatal signal
+      // handler.  The problem is that a call to free() might be the
+      // cause of this fatal signal.  If so, calling free() might cause
+      // us to wait on the malloc implementation's lock.  We're already
+      // holding this lock, so we'll deadlock. See bug 522332.
+      if (!aFatalSignal) free(mPidLockFileName);
+      mPidLockFileName = nullptr;
+    }
+    if (mLockFileDesc != -1) {
+      close(mLockFileDesc);
+      mLockFileDesc = -1;
+      // Don't remove it
+    }
+#endif
+
+    mHaveLock = false;
+  }
+
+  return rv;
+}
+
+nsresult nsProfileLock::Cleanup() {
+  if (mHaveLock) {
+    return NS_ERROR_FILE_IS_LOCKED;
+  }
+
+  if (mLockFile) {
+    nsresult rv = mLockFile->Remove(false);
+    NS_ENSURE_SUCCESS(rv, rv);
+    mLockFile = nullptr;
+  }
+
+  return NS_OK;
+}
diff --git a/toolkit/profile/nsProfileLock.h b/toolkit/profile/nsProfileLock.h
new file mode 100644
index 0000000000..932ce567bf
--- /dev/null
+++ b/toolkit/profile/nsProfileLock.h
@@ -0,0 +1,106 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef __nsProfileLock_h___
+#define __nsProfileLock_h___
+
+#include "nsIFile.h"
+
+class nsIProfileUnlocker;
+
+#if defined(XP_WIN)
+#  include <windows.h>
+#endif
+
+#if defined(XP_UNIX)
+#  include <signal.h>
+#  include "prclist.h"
+#endif
+
+class nsProfileLock
+#if defined(XP_UNIX)
+    : public PRCList
+#endif
+{
+ public:
+  nsProfileLock();
+  nsProfileLock(nsProfileLock& src);
+
+  ~nsProfileLock();
+
+  nsProfileLock& operator=(nsProfileLock& rhs);
+
+  /**
+   * Attempt to lock a profile directory.
+   *
+   * @param aProfileDir  [in] The profile directory to lock.
+   * @param aUnlocker    [out] Optional. This is only returned when locking
+   *                     fails with NS_ERROR_FILE_ACCESS_DENIED, and may not
+   *                     be returned at all.
+   * @throws NS_ERROR_FILE_ACCESS_DENIED if the profile is locked.
+   */
+  nsresult Lock(nsIFile* aProfileDir, nsIProfileUnlocker** aUnlocker);
+
+  /**
+   * Unlock a profile directory.  If you're unlocking the directory because
+   * the application is in the process of shutting down because of a fatal
+   * signal, set aFatalSignal to true.
+   */
+  nsresult Unlock(bool aFatalSignal = false);
+
+  /**
+   * Checks, if the given file has a name that matches potential lock file
+   * names. It does not check, if it actually is the currently active lock.
+   */
+  static bool IsMaybeLockFile(nsIFile* aFile);
+
+  /**
+   * Clean up any left over files in the directory.
+   */
+  nsresult Cleanup();
+
+  /**
+   * Get the modification time of a replaced profile lock, otherwise 0.
+   */
+  nsresult GetReplacedLockTime(PRTime* aResult);
+
+ private:
+  bool mHaveLock;
+  PRTime mReplacedLockTime;
+  nsCOMPtr<nsIFile> mLockFile;
+
+#if defined(XP_WIN)
+  HANDLE mLockFileHandle;
+#elif defined(XP_UNIX)
+
+  struct RemovePidLockFilesExiting {
+    RemovePidLockFilesExiting() = default;
+    ~RemovePidLockFilesExiting() { RemovePidLockFiles(false); }
+  };
+
+  static void RemovePidLockFiles(bool aFatalSignal);
+  static void FatalSignalHandler(int signo
+#  ifdef SA_SIGINFO
+                                 ,
+                                 siginfo_t* info, void* context
+#  endif
+  );
+  static PRCList mPidLockList;
+
+  nsresult LockWithFcntl(nsIFile* aLockFile,
+                         nsIProfileUnlocker** aUnlocker = nullptr);
+
+  /**
+   * @param aHaveFcntlLock if true, we've already acquired an fcntl lock so this
+   * lock is merely an "obsolete" lock to keep out old Firefoxes
+   */
+  nsresult LockWithSymlink(nsIFile* aLockFile, bool aHaveFcntlLock);
+
+  char* mPidLockFileName;
+  int mLockFileDesc;
+#endif
+};
+
+#endif /* __nsProfileLock_h___ */
diff --git a/toolkit/profile/nsToolkitProfileService.cpp b/toolkit/profile/nsToolkitProfileService.cpp
new file mode 100644
index 0000000000..df5292dc99
--- /dev/null
+++ b/toolkit/profile/nsToolkitProfileService.cpp
@@ -0,0 +1,2231 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/UniquePtrExtensions.h"
+#include "mozilla/WidgetUtils.h"
+#include "nsProfileLock.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <prprf.h>
+#include <prtime.h>
+
+#ifdef XP_WIN
+#  include <windows.h>
+#  include <shlobj.h>
+#  include "mozilla/PolicyChecks.h"
+#endif
+#ifdef XP_UNIX
+#  include <unistd.h>
+#endif
+
+#include "nsToolkitProfileService.h"
+#include "CmdLineAndEnvUtils.h"
+#include "nsIFile.h"
+
+#ifdef XP_MACOSX
+#  include <CoreFoundation/CoreFoundation.h>
+#  include "nsILocalFileMac.h"
+#endif
+
+#ifdef MOZ_WIDGET_GTK
+#  include "mozilla/WidgetUtilsGtk.h"
+#endif
+
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsNetCID.h"
+#include "nsXULAppAPI.h"
+#include "nsThreadUtils.h"
+
+#include "nsIRunnable.h"
+#include "nsXREDirProvider.h"
+#include "nsAppRunner.h"
+#include "nsString.h"
+#include "nsReadableUtils.h"
+#include "nsNativeCharsetUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Sprintf.h"
+#include "nsPrintfCString.h"
+#include "mozilla/UniquePtr.h"
+#include "nsIToolkitShellService.h"
+#include "mozilla/Telemetry.h"
+#include "nsProxyRelease.h"
+#include "prinrval.h"
+#include "prthread.h"
+#ifdef MOZ_BACKGROUNDTASKS
+#  include "mozilla/BackgroundTasks.h"
+#  include "SpecialSystemDirectory.h"
+#endif
+
+using namespace mozilla;
+
+#define DEV_EDITION_NAME "dev-edition-default"
+#define DEFAULT_NAME "default"
+#define COMPAT_FILE u"compatibility.ini"_ns
+#define PROFILE_DB_VERSION "2"
+#define INSTALL_PREFIX "Install"
+#define INSTALL_PREFIX_LENGTH 7
+
+struct KeyValue {
+  KeyValue(const char* aKey, const char* aValue) : key(aKey), value(aValue) {}
+
+  nsCString key;
+  nsCString value;
+};
+
+static bool GetStrings(const char* aString, const char* aValue,
+                       void* aClosure) {
+  nsTArray<UniquePtr<KeyValue>>* array =
+      static_cast<nsTArray<UniquePtr<KeyValue>>*>(aClosure);
+  array->AppendElement(MakeUnique<KeyValue>(aString, aValue));
+
+  return true;
+}
+
+/**
+ * Returns an array of the strings inside a section of an ini file.
+ */
+nsTArray<UniquePtr<KeyValue>> GetSectionStrings(nsINIParser* aParser,
+                                                const char* aSection) {
+  nsTArray<UniquePtr<KeyValue>> result;
+  aParser->GetStrings(aSection, &GetStrings, &result);
+  return result;
+}
+
+void RemoveProfileRecursion(const nsCOMPtr<nsIFile>& aDirectoryOrFile,
+                            bool aIsIgnoreRoot, bool aIsIgnoreLockfile,
+                            nsTArray<nsCOMPtr<nsIFile>>& aOutUndeletedFiles) {
+  auto guardDeletion = MakeScopeExit(
+      [&] { aOutUndeletedFiles.AppendElement(aDirectoryOrFile); });
+
+  // We actually would not expect to see links in our profiles, but still.
+  bool isLink = false;
+  NS_ENSURE_SUCCESS_VOID(aDirectoryOrFile->IsSymlink(&isLink));
+
+  // Only check to see if we have a directory if it isn't a link.
+  bool isDir = false;
+  if (!isLink) {
+    NS_ENSURE_SUCCESS_VOID(aDirectoryOrFile->IsDirectory(&isDir));
+  }
+
+  if (isDir) {
+    nsCOMPtr<nsIDirectoryEnumerator> dirEnum;
+    NS_ENSURE_SUCCESS_VOID(
+        aDirectoryOrFile->GetDirectoryEntries(getter_AddRefs(dirEnum)));
+
+    bool more = false;
+    while (NS_SUCCEEDED(dirEnum->HasMoreElements(&more)) && more) {
+      nsCOMPtr<nsISupports> item;
+      dirEnum->GetNext(getter_AddRefs(item));
+      nsCOMPtr<nsIFile> file = do_QueryInterface(item);
+      if (file) {
+        // Do not delete the profile lock.
+        if (aIsIgnoreLockfile && nsProfileLock::IsMaybeLockFile(file)) continue;
+        // If some children's remove fails, we still continue the loop.
+        RemoveProfileRecursion(file, false, false, aOutUndeletedFiles);
+      }
+    }
+  }
+  // Do not delete the root directory (yet).
+  if (!aIsIgnoreRoot) {
+    NS_ENSURE_SUCCESS_VOID(aDirectoryOrFile->Remove(false));
+  }
+  guardDeletion.release();
+}
+
+void RemoveProfileFiles(nsIToolkitProfile* aProfile, bool aInBackground) {
+  nsCOMPtr<nsIFile> rootDir;
+  aProfile->GetRootDir(getter_AddRefs(rootDir));
+  nsCOMPtr<nsIFile> localDir;
+  aProfile->GetLocalDir(getter_AddRefs(localDir));
+
+  // XXX If we get here with an active quota manager,
+  // something went very wrong. We want to assert this.
+
+  // Just lock the directories, don't mark the profile as locked or the lock
+  // will attempt to release its reference to the profile on the background
+  // thread which will assert.
+  nsCOMPtr<nsIProfileLock> lock;
+  NS_ENSURE_SUCCESS_VOID(
+      NS_LockProfilePath(rootDir, localDir, nullptr, getter_AddRefs(lock)));
+
+  nsCOMPtr<nsIRunnable> runnable = NS_NewRunnableFunction(
+      "nsToolkitProfile::RemoveProfileFiles",
+      [rootDir, localDir, lock]() mutable {
+        // We try to remove every single file and directory and collect
+        // those whose removal failed.
+        nsTArray<nsCOMPtr<nsIFile>> undeletedFiles;
+        // The root dir might contain the temp dir, so remove the temp dir
+        // first.
+        bool equals;
+        nsresult rv = rootDir->Equals(localDir, &equals);
+        if (NS_SUCCEEDED(rv) && !equals) {
+          RemoveProfileRecursion(localDir,
+                                 /* aIsIgnoreRoot  */ false,
+                                 /* aIsIgnoreLockfile */ false, undeletedFiles);
+        }
+        // Now remove the content of the profile dir (except lockfile)
+        RemoveProfileRecursion(rootDir,
+                               /* aIsIgnoreRoot  */ true,
+                               /* aIsIgnoreLockfile */ true, undeletedFiles);
+
+        // Retry loop if something was not deleted
+        if (undeletedFiles.Length() > 0) {
+          uint32_t retries = 1;
+          // XXX: Until bug 1716291 is fixed we just make one retry
+          while (undeletedFiles.Length() > 0 && retries <= 1) {
+            Unused << PR_Sleep(PR_MillisecondsToInterval(10 * retries));
+            for (auto&& file :
+                 std::exchange(undeletedFiles, nsTArray<nsCOMPtr<nsIFile>>{})) {
+              RemoveProfileRecursion(file,
+                                     /* aIsIgnoreRoot */ false,
+                                     /* aIsIgnoreLockfile */ true,
+                                     undeletedFiles);
+            }
+            retries++;
+          }
+        }
+
+#ifdef DEBUG
+        // XXX: Until bug 1716291 is fixed, we do not want to spam release
+        if (undeletedFiles.Length() > 0) {
+          NS_WARNING("Unable to remove all files from the profile directory:");
+          // Log the file names of those we could not remove
+          for (auto&& file : undeletedFiles) {
+            nsAutoString leafName;
+            if (NS_SUCCEEDED(file->GetLeafName(leafName))) {
+              NS_WARNING(NS_LossyConvertUTF16toASCII(leafName).get());
+            }
+          }
+        }
+#endif
+        // XXX: Activate this assert once bug 1716291 is fixed
+        // MOZ_ASSERT(undeletedFiles.Length() == 0);
+
+        // Now we can unlock the profile safely.
+        lock->Unlock();
+        // nsIProfileLock is not threadsafe so release our reference to it on
+        // the main thread.
+        NS_ReleaseOnMainThread("nsToolkitProfile::RemoveProfileFiles::Unlock",
+                               lock.forget());
+
+        if (undeletedFiles.Length() == 0) {
+          // We can safely remove the (empty) remaining profile directory
+          // and lockfile, no other files are here.
+          // As we do this only if we had no other blockers, this is as safe
+          // as deleting the lockfile explicitely after unlocking.
+          Unused << rootDir->Remove(true);
+        }
+      });
+
+  if (aInBackground) {
+    nsCOMPtr<nsIEventTarget> target =
+        do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
+    target->Dispatch(runnable, NS_DISPATCH_NORMAL);
+  } else {
+    runnable->Run();
+  }
+}
+
+nsToolkitProfile::nsToolkitProfile(const nsACString& aName, nsIFile* aRootDir,
+                                   nsIFile* aLocalDir, bool aFromDB)
+    : mName(aName),
+      mRootDir(aRootDir),
+      mLocalDir(aLocalDir),
+      mLock(nullptr),
+      mIndex(0),
+      mSection("Profile") {
+  NS_ASSERTION(aRootDir, "No file!");
+
+  RefPtr<nsToolkitProfile> prev =
+      nsToolkitProfileService::gService->mProfiles.getLast();
+  if (prev) {
+    mIndex = prev->mIndex + 1;
+  }
+  mSection.AppendInt(mIndex);
+
+  nsToolkitProfileService::gService->mProfiles.insertBack(this);
+
+  // If this profile isn't in the database already add it.
+  if (!aFromDB) {
+    nsINIParser* db = &nsToolkitProfileService::gService->mProfileDB;
+    db->SetString(mSection.get(), "Name", mName.get());
+
+    bool isRelative = false;
+    nsCString descriptor;
+    nsToolkitProfileService::gService->GetProfileDescriptor(this, descriptor,
+                                                            &isRelative);
+
+    db->SetString(mSection.get(), "IsRelative", isRelative ? "1" : "0");
+    db->SetString(mSection.get(), "Path", descriptor.get());
+  }
+}
+
+NS_IMPL_ISUPPORTS(nsToolkitProfile, nsIToolkitProfile)
+
+NS_IMETHODIMP
+nsToolkitProfile::GetRootDir(nsIFile** aResult) {
+  NS_ADDREF(*aResult = mRootDir);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfile::GetLocalDir(nsIFile** aResult) {
+  NS_ADDREF(*aResult = mLocalDir);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfile::GetName(nsACString& aResult) {
+  aResult = mName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfile::SetName(const nsACString& aName) {
+  NS_ASSERTION(nsToolkitProfileService::gService, "Where did my service go?");
+
+  if (mName.Equals(aName)) {
+    return NS_OK;
+  }
+
+  // Changing the name from the dev-edition default profile name makes this
+  // profile no longer the dev-edition default.
+  if (mName.EqualsLiteral(DEV_EDITION_NAME) &&
+      nsToolkitProfileService::gService->mDevEditionDefault == this) {
+    nsToolkitProfileService::gService->mDevEditionDefault = nullptr;
+  }
+
+  mName = aName;
+
+  nsresult rv = nsToolkitProfileService::gService->mProfileDB.SetString(
+      mSection.get(), "Name", mName.get());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Setting the name to the dev-edition default profile name will cause this
+  // profile to become the dev-edition default.
+  if (aName.EqualsLiteral(DEV_EDITION_NAME) &&
+      !nsToolkitProfileService::gService->mDevEditionDefault) {
+    nsToolkitProfileService::gService->mDevEditionDefault = this;
+  }
+
+  return NS_OK;
+}
+
+nsresult nsToolkitProfile::RemoveInternal(bool aRemoveFiles,
+                                          bool aInBackground) {
+  NS_ASSERTION(nsToolkitProfileService::gService, "Whoa, my service is gone.");
+
+  if (mLock) return NS_ERROR_FILE_IS_LOCKED;
+
+  if (!isInList()) {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  if (aRemoveFiles) {
+    RemoveProfileFiles(this, aInBackground);
+  }
+
+  nsINIParser* db = &nsToolkitProfileService::gService->mProfileDB;
+  db->DeleteSection(mSection.get());
+
+  // We make some assumptions that the profile's index in the database is based
+  // on its position in the linked list. Removing a profile means we have to fix
+  // the index of later profiles in the list. The easiest way to do that is just
+  // to move the last profile into the profile's position and just update its
+  // index.
+  RefPtr<nsToolkitProfile> last =
+      nsToolkitProfileService::gService->mProfiles.getLast();
+  if (last != this) {
+    // Update the section in the db.
+    last->mIndex = mIndex;
+    db->RenameSection(last->mSection.get(), mSection.get());
+    last->mSection = mSection;
+
+    if (last != getNext()) {
+      last->remove();
+      setNext(last);
+    }
+  }
+
+  remove();
+
+  if (nsToolkitProfileService::gService->mNormalDefault == this) {
+    nsToolkitProfileService::gService->mNormalDefault = nullptr;
+  }
+  if (nsToolkitProfileService::gService->mDevEditionDefault == this) {
+    nsToolkitProfileService::gService->mDevEditionDefault = nullptr;
+  }
+  if (nsToolkitProfileService::gService->mDedicatedProfile == this) {
+    nsToolkitProfileService::gService->SetDefaultProfile(nullptr);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfile::Remove(bool removeFiles) {
+  return RemoveInternal(removeFiles, false /* in background */);
+}
+
+NS_IMETHODIMP
+nsToolkitProfile::RemoveInBackground(bool removeFiles) {
+  return RemoveInternal(removeFiles, true /* in background */);
+}
+
+NS_IMETHODIMP
+nsToolkitProfile::Lock(nsIProfileUnlocker** aUnlocker,
+                       nsIProfileLock** aResult) {
+  if (mLock) {
+    NS_ADDREF(*aResult = mLock);
+    return NS_OK;
+  }
+
+  RefPtr<nsToolkitProfileLock> lock = new nsToolkitProfileLock();
+
+  nsresult rv = lock->Init(this, aUnlocker);
+  if (NS_FAILED(rv)) return rv;
+
+  NS_ADDREF(*aResult = lock);
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(nsToolkitProfileLock, nsIProfileLock)
+
+nsresult nsToolkitProfileLock::Init(nsToolkitProfile* aProfile,
+                                    nsIProfileUnlocker** aUnlocker) {
+  nsresult rv;
+  rv = Init(aProfile->mRootDir, aProfile->mLocalDir, aUnlocker);
+  if (NS_SUCCEEDED(rv)) mProfile = aProfile;
+
+  return rv;
+}
+
+nsresult nsToolkitProfileLock::Init(nsIFile* aDirectory,
+                                    nsIFile* aLocalDirectory,
+                                    nsIProfileUnlocker** aUnlocker) {
+  nsresult rv;
+
+  rv = mLock.Lock(aDirectory, aUnlocker);
+
+  if (NS_SUCCEEDED(rv)) {
+    mDirectory = aDirectory;
+    mLocalDirectory = aLocalDirectory;
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileLock::GetDirectory(nsIFile** aResult) {
+  if (!mDirectory) {
+    NS_ERROR("Not initialized, or unlocked!");
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  NS_ADDREF(*aResult = mDirectory);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileLock::GetLocalDirectory(nsIFile** aResult) {
+  if (!mLocalDirectory) {
+    NS_ERROR("Not initialized, or unlocked!");
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  NS_ADDREF(*aResult = mLocalDirectory);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileLock::Unlock() {
+  if (!mDirectory) {
+    NS_ERROR("Unlocking a never-locked nsToolkitProfileLock!");
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  // XXX If we get here with an active quota manager,
+  // something went very wrong. We want to assert this.
+
+  mLock.Unlock();
+
+  if (mProfile) {
+    mProfile->mLock = nullptr;
+    mProfile = nullptr;
+  }
+  mDirectory = nullptr;
+  mLocalDirectory = nullptr;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileLock::GetReplacedLockTime(PRTime* aResult) {
+  mLock.GetReplacedLockTime(aResult);
+  return NS_OK;
+}
+
+nsToolkitProfileLock::~nsToolkitProfileLock() {
+  if (mDirectory) {
+    Unlock();
+  }
+}
+
+nsToolkitProfileService* nsToolkitProfileService::gService = nullptr;
+
+NS_IMPL_ISUPPORTS(nsToolkitProfileService, nsIToolkitProfileService)
+
+nsToolkitProfileService::nsToolkitProfileService()
+    : mStartupProfileSelected(false),
+      mStartWithLast(true),
+      mIsFirstRun(true),
+      mUseDevEditionProfile(false),
+#ifdef MOZ_DEDICATED_PROFILES
+      mUseDedicatedProfile(!IsSnapEnvironment() && !UseLegacyProfiles()),
+#else
+      mUseDedicatedProfile(false),
+#endif
+      mStartupReason(u"unknown"_ns),
+      mMaybeLockProfile(false),
+      mUpdateChannel(MOZ_STRINGIFY(MOZ_UPDATE_CHANNEL)),
+      mProfileDBExists(false),
+      mProfileDBFileSize(0),
+      mProfileDBModifiedTime(0) {
+#ifdef MOZ_DEV_EDITION
+  mUseDevEditionProfile = true;
+#endif
+}
+
+nsToolkitProfileService::~nsToolkitProfileService() {
+  gService = nullptr;
+  mProfiles.clear();
+}
+
+void nsToolkitProfileService::CompleteStartup() {
+  if (!mStartupProfileSelected) {
+    return;
+  }
+
+  ScalarSet(mozilla::Telemetry::ScalarID::STARTUP_PROFILE_SELECTION_REASON,
+            mStartupReason);
+
+  if (mMaybeLockProfile) {
+    nsCOMPtr<nsIToolkitShellService> shell =
+        do_GetService(NS_TOOLKITSHELLSERVICE_CONTRACTID);
+    if (!shell) {
+      return;
+    }
+
+    bool isDefaultApp;
+    nsresult rv = shell->IsDefaultApplication(&isDefaultApp);
+    NS_ENSURE_SUCCESS_VOID(rv);
+
+    if (isDefaultApp) {
+      mProfileDB.SetString(mInstallSection.get(), "Locked", "1");
+
+      // There is a very small chance that this could fail if something else
+      // overwrote the profiles database since we started up, probably less than
+      // a second ago. There isn't really a sane response here, all the other
+      // profile changes are already flushed so whether we fail to flush here or
+      // force quit the app makes no difference.
+      NS_ENSURE_SUCCESS_VOID(Flush());
+    }
+  }
+}
+
+// Tests whether the passed profile was last used by this install.
+bool nsToolkitProfileService::IsProfileForCurrentInstall(
+    nsIToolkitProfile* aProfile) {
+  nsCOMPtr<nsIFile> profileDir;
+  nsresult rv = aProfile->GetRootDir(getter_AddRefs(profileDir));
+  NS_ENSURE_SUCCESS(rv, false);
+
+  nsCOMPtr<nsIFile> compatFile;
+  rv = profileDir->Clone(getter_AddRefs(compatFile));
+  NS_ENSURE_SUCCESS(rv, false);
+
+  rv = compatFile->Append(COMPAT_FILE);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  nsINIParser compatData;
+  rv = compatData.Init(compatFile);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  /**
+   * In xpcshell gDirServiceProvider doesn't have all the correct directories
+   * set so using NS_GetSpecialDirectory works better there. But in a normal
+   * app launch the component registry isn't initialized so
+   * NS_GetSpecialDirectory doesn't work. So we have to use two different
+   * paths to support testing.
+   */
+  nsCOMPtr<nsIFile> currentGreDir;
+  rv = NS_GetSpecialDirectory(NS_GRE_DIR, getter_AddRefs(currentGreDir));
+  if (rv == NS_ERROR_NOT_INITIALIZED) {
+    currentGreDir = gDirServiceProvider->GetGREDir();
+    MOZ_ASSERT(currentGreDir, "No GRE dir found.");
+  } else if (NS_FAILED(rv)) {
+    return false;
+  }
+
+  nsCString lastGreDirStr;
+  rv = compatData.GetString("Compatibility", "LastPlatformDir", lastGreDirStr);
+  // If this string is missing then this profile is from an ancient version.
+  // We'll opt to use it in this case.
+  if (NS_FAILED(rv)) {
+    return true;
+  }
+
+  nsCOMPtr<nsIFile> lastGreDir;
+  rv = NS_NewNativeLocalFile(""_ns, false, getter_AddRefs(lastGreDir));
+  NS_ENSURE_SUCCESS(rv, false);
+
+  rv = lastGreDir->SetPersistentDescriptor(lastGreDirStr);
+  NS_ENSURE_SUCCESS(rv, false);
+
+#ifdef XP_WIN
+#  if defined(MOZ_THUNDERBIRD) || defined(MOZ_SUITE)
+  mozilla::PathString lastGreDirPath, currentGreDirPath;
+  lastGreDirPath = lastGreDir->NativePath();
+  currentGreDirPath = currentGreDir->NativePath();
+  if (lastGreDirPath.Equals(currentGreDirPath,
+                            nsCaseInsensitiveStringComparator)) {
+    return true;
+  }
+
+  // Convert a 64-bit install path to what would have been the 32-bit install
+  // path to allow users to migrate their profiles from one to the other.
+  PWSTR pathX86 = nullptr;
+  HRESULT hres =
+      SHGetKnownFolderPath(FOLDERID_ProgramFilesX86, 0, nullptr, &pathX86);
+  if (SUCCEEDED(hres)) {
+    nsDependentString strPathX86(pathX86);
+    if (!StringBeginsWith(currentGreDirPath, strPathX86,
+                          nsCaseInsensitiveStringComparator)) {
+      PWSTR path = nullptr;
+      hres = SHGetKnownFolderPath(FOLDERID_ProgramFiles, 0, nullptr, &path);
+      if (SUCCEEDED(hres)) {
+        if (StringBeginsWith(currentGreDirPath, nsDependentString(path),
+                             nsCaseInsensitiveStringComparator)) {
+          currentGreDirPath.Replace(0, wcslen(path), strPathX86);
+        }
+      }
+      CoTaskMemFree(path);
+    }
+  }
+  CoTaskMemFree(pathX86);
+
+  return lastGreDirPath.Equals(currentGreDirPath,
+                               nsCaseInsensitiveStringComparator);
+#  endif
+#endif
+
+  bool equal;
+  rv = lastGreDir->Equals(currentGreDir, &equal);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  return equal;
+}
+
+/**
+ * Used the first time an install with dedicated profile support runs. Decides
+ * whether to mark the passed profile as the default for this install.
+ *
+ * The goal is to reduce disruption but ideally end up with the OS default
+ * install using the old default profile.
+ *
+ * If the decision is to use the profile then it will be unassigned as the
+ * dedicated default for other installs.
+ *
+ * We won't attempt to use the profile if it was last used by a different
+ * install.
+ *
+ * If the profile is currently in use by an install that was either the OS
+ * default install or the profile has been explicitely chosen by some other
+ * means then we won't use it.
+ *
+ * aResult will be set to true if we chose to make the profile the new dedicated
+ * default.
+ */
+nsresult nsToolkitProfileService::MaybeMakeDefaultDedicatedProfile(
+    nsIToolkitProfile* aProfile, bool* aResult) {
+  nsresult rv;
+  *aResult = false;
+
+  // If the profile was last used by a different install then we won't use it.
+  if (!IsProfileForCurrentInstall(aProfile)) {
+    return NS_OK;
+  }
+
+  nsCString descriptor;
+  rv = GetProfileDescriptor(aProfile, descriptor, nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Get a list of all the installs.
+  nsTArray<nsCString> installs = GetKnownInstalls();
+
+  // Cache the installs that use the profile.
+  nsTArray<nsCString> inUseInstalls;
+
+  // See if the profile is already in use by an install that hasn't locked it.
+  for (uint32_t i = 0; i < installs.Length(); i++) {
+    const nsCString& install = installs[i];
+
+    nsCString path;
+    rv = mProfileDB.GetString(install.get(), "Default", path);
+    if (NS_FAILED(rv)) {
+      continue;
+    }
+
+    // Is this install using the profile we care about?
+    if (!descriptor.Equals(path)) {
+      continue;
+    }
+
+    // Is this profile locked to this other install?
+    nsCString isLocked;
+    rv = mProfileDB.GetString(install.get(), "Locked", isLocked);
+    if (NS_SUCCEEDED(rv) && isLocked.Equals("1")) {
+      return NS_OK;
+    }
+
+    inUseInstalls.AppendElement(install);
+  }
+
+  // At this point we've decided to take the profile. Strip it from other
+  // installs.
+  for (uint32_t i = 0; i < inUseInstalls.Length(); i++) {
+    // Removing the default setting entirely will make the install go through
+    // the first run process again at startup and create itself a new profile.
+    mProfileDB.DeleteString(inUseInstalls[i].get(), "Default");
+  }
+
+  // Set this as the default profile for this install.
+  SetDefaultProfile(aProfile);
+
+  // SetDefaultProfile will have locked this profile to this install so no
+  // other installs will steal it, but this was auto-selected so we want to
+  // unlock it so that other installs can potentially take it.
+  mProfileDB.DeleteString(mInstallSection.get(), "Locked");
+
+  // Persist the changes.
+  rv = Flush();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Once XPCOM is available check if this is the default application and if so
+  // lock the profile again.
+  mMaybeLockProfile = true;
+  *aResult = true;
+
+  return NS_OK;
+}
+
+bool IsFileOutdated(nsIFile* aFile, bool aExists, PRTime aLastModified,
+                    int64_t aLastSize) {
+  nsCOMPtr<nsIFile> file;
+  nsresult rv = aFile->Clone(getter_AddRefs(file));
+  if (NS_FAILED(rv)) {
+    return false;
+  }
+
+  bool exists;
+  rv = aFile->Exists(&exists);
+  if (NS_FAILED(rv) || exists != aExists) {
+    return true;
+  }
+
+  if (!exists) {
+    return false;
+  }
+
+  int64_t size;
+  rv = aFile->GetFileSize(&size);
+  if (NS_FAILED(rv) || size != aLastSize) {
+    return true;
+  }
+
+  PRTime time;
+  rv = aFile->GetLastModifiedTime(&time);
+  if (NS_FAILED(rv) || time != aLastModified) {
+    return true;
+  }
+
+  return false;
+}
+
+nsresult UpdateFileStats(nsIFile* aFile, bool* aExists, PRTime* aLastModified,
+                         int64_t* aLastSize) {
+  nsCOMPtr<nsIFile> file;
+  nsresult rv = aFile->Clone(getter_AddRefs(file));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = file->Exists(aExists);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!(*aExists)) {
+    *aLastModified = 0;
+    *aLastSize = 0;
+    return NS_OK;
+  }
+
+  rv = file->GetFileSize(aLastSize);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = file->GetLastModifiedTime(aLastModified);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::GetIsListOutdated(bool* aResult) {
+  if (IsFileOutdated(mProfileDBFile, mProfileDBExists, mProfileDBModifiedTime,
+                     mProfileDBFileSize)) {
+    *aResult = true;
+    return NS_OK;
+  }
+
+  *aResult = false;
+  return NS_OK;
+}
+
+struct ImportInstallsClosure {
+  nsINIParser* backupData;
+  nsINIParser* profileDB;
+};
+
+static bool ImportInstalls(const char* aSection, void* aClosure) {
+  ImportInstallsClosure* closure =
+      static_cast<ImportInstallsClosure*>(aClosure);
+
+  nsTArray<UniquePtr<KeyValue>> strings =
+      GetSectionStrings(closure->backupData, aSection);
+  if (strings.IsEmpty()) {
+    return true;
+  }
+
+  nsCString newSection(INSTALL_PREFIX);
+  newSection.Append(aSection);
+  nsCString buffer;
+
+  for (uint32_t i = 0; i < strings.Length(); i++) {
+    closure->profileDB->SetString(newSection.get(), strings[i]->key.get(),
+                                  strings[i]->value.get());
+  }
+
+  return true;
+}
+
+nsresult nsToolkitProfileService::Init() {
+  NS_ASSERTION(gDirServiceProvider, "No dirserviceprovider!");
+  nsresult rv;
+
+  rv = nsXREDirProvider::GetUserAppDataDirectory(getter_AddRefs(mAppData));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = nsXREDirProvider::GetUserLocalDataDirectory(getter_AddRefs(mTempData));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mAppData->Clone(getter_AddRefs(mProfileDBFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mProfileDBFile->AppendNative("profiles.ini"_ns);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mAppData->Clone(getter_AddRefs(mInstallDBFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mInstallDBFile->AppendNative("installs.ini"_ns);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString buffer;
+
+  rv = UpdateFileStats(mProfileDBFile, &mProfileDBExists,
+                       &mProfileDBModifiedTime, &mProfileDBFileSize);
+  if (NS_SUCCEEDED(rv) && mProfileDBExists) {
+    rv = mProfileDB.Init(mProfileDBFile);
+    // Init does not fail on parsing errors, only on OOM/really unexpected
+    // conditions.
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+
+    rv = mProfileDB.GetString("General", "StartWithLastProfile", buffer);
+    if (NS_SUCCEEDED(rv)) {
+      mStartWithLast = !buffer.EqualsLiteral("0");
+    }
+
+    rv = mProfileDB.GetString("General", "Version", buffer);
+    if (NS_FAILED(rv)) {
+      // This is a profiles.ini written by an older version. We must restore
+      // any install data from the backup.
+      nsINIParser installDB;
+
+      if (NS_SUCCEEDED(installDB.Init(mInstallDBFile))) {
+        // There is install data to import.
+        ImportInstallsClosure closure = {&installDB, &mProfileDB};
+        installDB.GetSections(&ImportInstalls, &closure);
+      }
+
+      rv = mProfileDB.SetString("General", "Version", PROFILE_DB_VERSION);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  } else {
+    rv = mProfileDB.SetString("General", "StartWithLastProfile",
+                              mStartWithLast ? "1" : "0");
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = mProfileDB.SetString("General", "Version", PROFILE_DB_VERSION);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCString installProfilePath;
+
+  if (mUseDedicatedProfile) {
+    nsString installHash;
+    rv = gDirServiceProvider->GetInstallHash(installHash);
+    NS_ENSURE_SUCCESS(rv, rv);
+    CopyUTF16toUTF8(installHash, mInstallSection);
+    mInstallSection.Insert(INSTALL_PREFIX, 0);
+
+    // Try to find the descriptor for the default profile for this install.
+    rv = mProfileDB.GetString(mInstallSection.get(), "Default",
+                              installProfilePath);
+
+    // Not having a value means this install doesn't appear in installs.ini so
+    // this is the first run for this install.
+    if (NS_FAILED(rv)) {
+      mIsFirstRun = true;
+
+      // Gets the install section that would have been created if the install
+      // path has incorrect casing (see bug 1555319). We use this later during
+      // profile selection.
+      rv = gDirServiceProvider->GetLegacyInstallHash(installHash);
+      NS_ENSURE_SUCCESS(rv, rv);
+      CopyUTF16toUTF8(installHash, mLegacyInstallSection);
+      mLegacyInstallSection.Insert(INSTALL_PREFIX, 0);
+    } else {
+      mIsFirstRun = false;
+    }
+  }
+
+  nsToolkitProfile* currentProfile = nullptr;
+
+#ifdef MOZ_DEV_EDITION
+  nsCOMPtr<nsIFile> ignoreDevEditionProfile;
+  rv = mAppData->Clone(getter_AddRefs(ignoreDevEditionProfile));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  rv = ignoreDevEditionProfile->AppendNative("ignore-dev-edition-profile"_ns);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  bool shouldIgnoreSeparateProfile;
+  rv = ignoreDevEditionProfile->Exists(&shouldIgnoreSeparateProfile);
+  if (NS_FAILED(rv)) return rv;
+
+  mUseDevEditionProfile = !shouldIgnoreSeparateProfile;
+#endif
+
+  nsCOMPtr<nsIToolkitProfile> autoSelectProfile;
+
+  unsigned int nonDevEditionProfiles = 0;
+  unsigned int c = 0;
+  for (c = 0; true; ++c) {
+    nsAutoCString profileID("Profile");
+    profileID.AppendInt(c);
+
+    rv = mProfileDB.GetString(profileID.get(), "IsRelative", buffer);
+    if (NS_FAILED(rv)) break;
+
+    bool isRelative = buffer.EqualsLiteral("1");
+
+    nsAutoCString filePath;
+
+    rv = mProfileDB.GetString(profileID.get(), "Path", filePath);
+    if (NS_FAILED(rv)) {
+      NS_ERROR("Malformed profiles.ini: Path= not found");
+      continue;
+    }
+
+    nsAutoCString name;
+
+    rv = mProfileDB.GetString(profileID.get(), "Name", name);
+    if (NS_FAILED(rv)) {
+      NS_ERROR("Malformed profiles.ini: Name= not found");
+      continue;
+    }
+
+    nsCOMPtr<nsIFile> rootDir;
+    rv = NS_NewNativeLocalFile(""_ns, true, getter_AddRefs(rootDir));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (isRelative) {
+      rv = rootDir->SetRelativeDescriptor(mAppData, filePath);
+    } else {
+      rv = rootDir->SetPersistentDescriptor(filePath);
+    }
+    if (NS_FAILED(rv)) continue;
+
+    nsCOMPtr<nsIFile> localDir;
+    if (isRelative) {
+      rv = NS_NewNativeLocalFile(""_ns, true, getter_AddRefs(localDir));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = localDir->SetRelativeDescriptor(mTempData, filePath);
+    } else {
+      localDir = rootDir;
+    }
+
+    currentProfile = new nsToolkitProfile(name, rootDir, localDir, true);
+
+    // If a user has modified the ini file path it may make for a valid profile
+    // path but not match what we would have serialised and so may not match
+    // the path in the install section. Re-serialise it to get it in the
+    // expected form again.
+    bool nowRelative;
+    nsCString descriptor;
+    GetProfileDescriptor(currentProfile, descriptor, &nowRelative);
+
+    if (isRelative != nowRelative || !descriptor.Equals(filePath)) {
+      mProfileDB.SetString(profileID.get(), "IsRelative",
+                           nowRelative ? "1" : "0");
+      mProfileDB.SetString(profileID.get(), "Path", descriptor.get());
+
+      // Should we flush now? It costs some startup time and we will fix it on
+      // the next startup anyway. If something else causes a flush then it will
+      // be fixed in the ini file then.
+    }
+
+    rv = mProfileDB.GetString(profileID.get(), "Default", buffer);
+    if (NS_SUCCEEDED(rv) && buffer.EqualsLiteral("1")) {
+      mNormalDefault = currentProfile;
+    }
+
+    // Is this the default profile for this install?
+    if (mUseDedicatedProfile && !mDedicatedProfile &&
+        installProfilePath.Equals(descriptor)) {
+      // Found a profile for this install.
+      mDedicatedProfile = currentProfile;
+    }
+
+    if (name.EqualsLiteral(DEV_EDITION_NAME)) {
+      mDevEditionDefault = currentProfile;
+    } else {
+      nonDevEditionProfiles++;
+      autoSelectProfile = currentProfile;
+    }
+  }
+
+  // If there is only one non-dev-edition profile then mark it as the default.
+  if (!mNormalDefault && nonDevEditionProfiles == 1) {
+    SetNormalDefault(autoSelectProfile);
+  }
+
+  if (!mUseDedicatedProfile) {
+    if (mUseDevEditionProfile) {
+      // When using the separate dev-edition profile not finding it means this
+      // is a first run.
+      mIsFirstRun = !mDevEditionDefault;
+    } else {
+      // If there are no normal profiles then this is a first run.
+      mIsFirstRun = nonDevEditionProfiles == 0;
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::SetStartWithLastProfile(bool aValue) {
+  if (mStartWithLast != aValue) {
+    // Note: the skeleton ui (see PreXULSkeletonUI.cpp) depends on this
+    // having this name and being under General. If that ever changes,
+    // the skeleton UI will just need to be updated. If it changes frequently,
+    // it's probably best we just mirror the value to the registry here.
+    nsresult rv = mProfileDB.SetString("General", "StartWithLastProfile",
+                                       aValue ? "1" : "0");
+    NS_ENSURE_SUCCESS(rv, rv);
+    mStartWithLast = aValue;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::GetStartWithLastProfile(bool* aResult) {
+  *aResult = mStartWithLast;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::GetProfiles(nsISimpleEnumerator** aResult) {
+  *aResult = new ProfileEnumerator(mProfiles.getFirst());
+
+  NS_ADDREF(*aResult);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::ProfileEnumerator::HasMoreElements(bool* aResult) {
+  *aResult = mCurrent ? true : false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::ProfileEnumerator::GetNext(nsISupports** aResult) {
+  if (!mCurrent) return NS_ERROR_FAILURE;
+
+  NS_ADDREF(*aResult = mCurrent);
+
+  mCurrent = mCurrent->getNext();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::GetCurrentProfile(nsIToolkitProfile** aResult) {
+  NS_IF_ADDREF(*aResult = mCurrent);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::GetDefaultProfile(nsIToolkitProfile** aResult) {
+  if (mUseDedicatedProfile) {
+    NS_IF_ADDREF(*aResult = mDedicatedProfile);
+    return NS_OK;
+  }
+
+  if (mUseDevEditionProfile) {
+    NS_IF_ADDREF(*aResult = mDevEditionDefault);
+    return NS_OK;
+  }
+
+  NS_IF_ADDREF(*aResult = mNormalDefault);
+  return NS_OK;
+}
+
+void nsToolkitProfileService::SetNormalDefault(nsIToolkitProfile* aProfile) {
+  if (mNormalDefault == aProfile) {
+    return;
+  }
+
+  if (mNormalDefault) {
+    nsToolkitProfile* profile =
+        static_cast<nsToolkitProfile*>(mNormalDefault.get());
+    mProfileDB.DeleteString(profile->mSection.get(), "Default");
+  }
+
+  mNormalDefault = aProfile;
+
+  if (mNormalDefault) {
+    nsToolkitProfile* profile =
+        static_cast<nsToolkitProfile*>(mNormalDefault.get());
+    mProfileDB.SetString(profile->mSection.get(), "Default", "1");
+  }
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::SetDefaultProfile(nsIToolkitProfile* aProfile) {
+  if (mUseDedicatedProfile) {
+    if (mDedicatedProfile != aProfile) {
+      if (!aProfile) {
+        // Setting this to the empty string means no profile will be found on
+        // startup but we'll recognise that this install has been used
+        // previously.
+        mProfileDB.SetString(mInstallSection.get(), "Default", "");
+      } else {
+        nsCString profilePath;
+        nsresult rv = GetProfileDescriptor(aProfile, profilePath, nullptr);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        mProfileDB.SetString(mInstallSection.get(), "Default",
+                             profilePath.get());
+      }
+      mDedicatedProfile = aProfile;
+
+      // Some kind of choice has happened here, lock this profile to this
+      // install.
+      mProfileDB.SetString(mInstallSection.get(), "Locked", "1");
+    }
+    return NS_OK;
+  }
+
+  if (mUseDevEditionProfile && aProfile != mDevEditionDefault) {
+    // The separate profile is hardcoded.
+    return NS_ERROR_FAILURE;
+  }
+
+  SetNormalDefault(aProfile);
+
+  return NS_OK;
+}
+
+// Gets the profile root directory descriptor for storing in profiles.ini or
+// installs.ini.
+nsresult nsToolkitProfileService::GetProfileDescriptor(
+    nsIToolkitProfile* aProfile, nsACString& aDescriptor, bool* aIsRelative) {
+  nsCOMPtr<nsIFile> profileDir;
+  nsresult rv = aProfile->GetRootDir(getter_AddRefs(profileDir));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // if the profile dir is relative to appdir...
+  bool isRelative;
+  rv = mAppData->Contains(profileDir, &isRelative);
+
+  nsCString profilePath;
+  if (NS_SUCCEEDED(rv) && isRelative) {
+    // we use a relative descriptor
+    rv = profileDir->GetRelativeDescriptor(mAppData, profilePath);
+  } else {
+    // otherwise, a persistent descriptor
+    rv = profileDir->GetPersistentDescriptor(profilePath);
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  aDescriptor.Assign(profilePath);
+  if (aIsRelative) {
+    *aIsRelative = isRelative;
+  }
+
+  return NS_OK;
+}
+
+nsresult nsToolkitProfileService::CreateDefaultProfile(
+    nsIToolkitProfile** aResult) {
+  // Create a new default profile
+  nsAutoCString name;
+  if (mUseDevEditionProfile) {
+    name.AssignLiteral(DEV_EDITION_NAME);
+  } else if (mUseDedicatedProfile) {
+    name.AppendPrintf("default-%s", mUpdateChannel.get());
+  } else {
+    name.AssignLiteral(DEFAULT_NAME);
+  }
+
+  nsresult rv = CreateUniqueProfile(nullptr, name, aResult);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (mUseDedicatedProfile) {
+    SetDefaultProfile(mCurrent);
+  } else if (mUseDevEditionProfile) {
+    mDevEditionDefault = mCurrent;
+  } else {
+    SetNormalDefault(mCurrent);
+  }
+
+  return NS_OK;
+}
+
+/**
+ * An implementation of SelectStartupProfile callable from JavaScript via XPCOM.
+ * See nsIToolkitProfileService.idl.
+ */
+NS_IMETHODIMP
+nsToolkitProfileService::SelectStartupProfile(
+    const nsTArray<nsCString>& aArgv, bool aIsResetting,
+    const nsACString& aUpdateChannel, const nsACString& aLegacyInstallHash,
+    nsIFile** aRootDir, nsIFile** aLocalDir, nsIToolkitProfile** aProfile,
+    bool* aDidCreate) {
+  int argc = aArgv.Length();
+  // Our command line handling expects argv to be null-terminated so construct
+  // an appropriate array.
+  auto argv = MakeUnique<char*[]>(argc + 1);
+  // Also, our command line handling removes things from the array without
+  // freeing them so keep track of what we've created separately.
+  auto allocated = MakeUnique<UniqueFreePtr<char>[]>(argc);
+
+  for (int i = 0; i < argc; i++) {
+    allocated[i].reset(ToNewCString(aArgv[i]));
+    argv[i] = allocated[i].get();
+  }
+  argv[argc] = nullptr;
+
+  mUpdateChannel = aUpdateChannel;
+  if (!aLegacyInstallHash.IsEmpty()) {
+    mLegacyInstallSection.Assign(aLegacyInstallHash);
+    mLegacyInstallSection.Insert(INSTALL_PREFIX, 0);
+  }
+
+  bool wasDefault;
+  nsresult rv =
+      SelectStartupProfile(&argc, argv.get(), aIsResetting, aRootDir, aLocalDir,
+                           aProfile, aDidCreate, &wasDefault);
+
+  // Since we were called outside of the normal startup path complete any
+  // startup tasks.
+  if (NS_SUCCEEDED(rv)) {
+    CompleteStartup();
+  }
+
+  return rv;
+}
+
+static void SaltProfileName(nsACString& aName);
+
+/**
+ * Selects or creates a profile to use based on the profiles database, any
+ * environment variables and any command line arguments. Will not create
+ * a profile if aIsResetting is true. The profile is selected based on this
+ * order of preference:
+ * * Environment variables (set when restarting the application).
+ * * --profile command line argument.
+ * * --createprofile command line argument (this also causes the app to exit).
+ * * -p command line argument.
+ * * A new profile created if this is the first run of the application.
+ * * The default profile.
+ * aRootDir and aLocalDir are set to the data and local directories for the
+ * profile data. If a profile from the database was selected it will be
+ * returned in aProfile.
+ * aDidCreate will be set to true if a new profile was created.
+ * This function should be called once at startup and will fail if called again.
+ * aArgv should be an array of aArgc + 1 strings, the last element being null.
+ * Both aArgv and aArgc will be mutated.
+ */
+nsresult nsToolkitProfileService::SelectStartupProfile(
+    int* aArgc, char* aArgv[], bool aIsResetting, nsIFile** aRootDir,
+    nsIFile** aLocalDir, nsIToolkitProfile** aProfile, bool* aDidCreate,
+    bool* aWasDefaultSelection) {
+  if (mStartupProfileSelected) {
+    return NS_ERROR_ALREADY_INITIALIZED;
+  }
+
+  mStartupProfileSelected = true;
+  *aDidCreate = false;
+  *aWasDefaultSelection = false;
+
+  nsresult rv;
+  const char* arg;
+
+  // Use the profile specified in the environment variables (generally from an
+  // app initiated restart).
+  nsCOMPtr<nsIFile> lf = GetFileFromEnv("XRE_PROFILE_PATH");
+  if (lf) {
+    nsCOMPtr<nsIFile> localDir = GetFileFromEnv("XRE_PROFILE_LOCAL_PATH");
+    if (!localDir) {
+      localDir = lf;
+    }
+
+    // Clear out flags that we handled (or should have handled!) last startup.
+    const char* dummy;
+    CheckArg(*aArgc, aArgv, "p", &dummy);
+    CheckArg(*aArgc, aArgv, "profile", &dummy);
+    CheckArg(*aArgc, aArgv, "profilemanager");
+
+    nsCOMPtr<nsIToolkitProfile> profile;
+    GetProfileByDir(lf, localDir, getter_AddRefs(profile));
+
+    if (profile && mIsFirstRun && mUseDedicatedProfile) {
+      if (profile ==
+          (mUseDevEditionProfile ? mDevEditionDefault : mNormalDefault)) {
+        // This is the first run of a dedicated profile build where the selected
+        // profile is the previous default so we should either make it the
+        // default profile for this install or push the user to a new profile.
+
+        bool result;
+        rv = MaybeMakeDefaultDedicatedProfile(profile, &result);
+        NS_ENSURE_SUCCESS(rv, rv);
+        if (result) {
+          mStartupReason = u"restart-claimed-default"_ns;
+
+          mCurrent = profile;
+        } else {
+          rv = CreateDefaultProfile(getter_AddRefs(mCurrent));
+          if (NS_FAILED(rv)) {
+            *aProfile = nullptr;
+            return rv;
+          }
+
+          rv = Flush();
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          mStartupReason = u"restart-skipped-default"_ns;
+          *aDidCreate = true;
+        }
+
+        NS_IF_ADDREF(*aProfile = mCurrent);
+        mCurrent->GetRootDir(aRootDir);
+        mCurrent->GetLocalDir(aLocalDir);
+
+        return NS_OK;
+      }
+    }
+
+    if (EnvHasValue("XRE_RESTARTED_BY_PROFILE_MANAGER")) {
+      mStartupReason = u"profile-manager"_ns;
+    } else if (aIsResetting) {
+      mStartupReason = u"profile-reset"_ns;
+    } else {
+      mStartupReason = u"restart"_ns;
+    }
+
+    mCurrent = profile;
+    lf.forget(aRootDir);
+    localDir.forget(aLocalDir);
+    NS_IF_ADDREF(*aProfile = profile);
+    return NS_OK;
+  }
+
+  // Check the -profile command line argument. It accepts a single argument that
+  // gives the path to use for the profile.
+  ArgResult ar = CheckArg(*aArgc, aArgv, "profile", &arg);
+  if (ar == ARG_BAD) {
+    PR_fprintf(PR_STDERR, "Error: argument --profile requires a path\n");
+    return NS_ERROR_FAILURE;
+  }
+  if (ar) {
+    nsCOMPtr<nsIFile> lf;
+    rv = XRE_GetFileFromPath(arg, getter_AddRefs(lf));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Make sure that the profile path exists and it's a directory.
+    bool exists;
+    rv = lf->Exists(&exists);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!exists) {
+      rv = lf->Create(nsIFile::DIRECTORY_TYPE, 0700);
+      NS_ENSURE_SUCCESS(rv, rv);
+    } else {
+      bool isDir;
+      rv = lf->IsDirectory(&isDir);
+      NS_ENSURE_SUCCESS(rv, rv);
+      if (!isDir) {
+        PR_fprintf(
+            PR_STDERR,
+            "Error: argument --profile requires a path to a directory\n");
+        return NS_ERROR_FAILURE;
+      }
+    }
+
+    mStartupReason = u"argument-profile"_ns;
+
+    GetProfileByDir(lf, nullptr, getter_AddRefs(mCurrent));
+    NS_ADDREF(*aRootDir = lf);
+    // If the root dir matched a profile then use its local dir, otherwise use
+    // the root dir as the local dir.
+    if (mCurrent) {
+      mCurrent->GetLocalDir(aLocalDir);
+    } else {
+      lf.forget(aLocalDir);
+    }
+
+    NS_IF_ADDREF(*aProfile = mCurrent);
+    return NS_OK;
+  }
+
+  // Check the -createprofile command line argument. It accepts a single
+  // argument that is either the name for the new profile or the name followed
+  // by the path to use.
+  ar = CheckArg(*aArgc, aArgv, "createprofile", &arg, CheckArgFlag::RemoveArg);
+  if (ar == ARG_BAD) {
+    PR_fprintf(PR_STDERR,
+               "Error: argument --createprofile requires a profile name\n");
+    return NS_ERROR_FAILURE;
+  }
+  if (ar) {
+    const char* delim = strchr(arg, ' ');
+    nsCOMPtr<nsIToolkitProfile> profile;
+    if (delim) {
+      nsCOMPtr<nsIFile> lf;
+      rv = NS_NewNativeLocalFile(nsDependentCString(delim + 1), true,
+                                 getter_AddRefs(lf));
+      if (NS_FAILED(rv)) {
+        PR_fprintf(PR_STDERR, "Error: profile path not valid.\n");
+        return rv;
+      }
+
+      // As with --profile, assume that the given path will be used for the
+      // main profile directory.
+      rv = CreateProfile(lf, nsDependentCSubstring(arg, delim),
+                         getter_AddRefs(profile));
+    } else {
+      rv = CreateProfile(nullptr, nsDependentCString(arg),
+                         getter_AddRefs(profile));
+    }
+    // Some pathological arguments can make it this far
+    if (NS_FAILED(rv) || NS_FAILED(Flush())) {
+      PR_fprintf(PR_STDERR, "Error creating profile.\n");
+    }
+    return NS_ERROR_ABORT;
+  }
+
+  // Check the -p command line argument. It either accepts a profile name and
+  // uses that named profile or without a name it opens the profile manager.
+  ar = CheckArg(*aArgc, aArgv, "p", &arg);
+  if (ar == ARG_BAD) {
+    return NS_ERROR_SHOW_PROFILE_MANAGER;
+  }
+  if (ar) {
+    rv = GetProfileByName(nsDependentCString(arg), getter_AddRefs(mCurrent));
+    if (NS_SUCCEEDED(rv)) {
+      mStartupReason = u"argument-p"_ns;
+
+      mCurrent->GetRootDir(aRootDir);
+      mCurrent->GetLocalDir(aLocalDir);
+
+      NS_ADDREF(*aProfile = mCurrent);
+      return NS_OK;
+    }
+
+    return NS_ERROR_SHOW_PROFILE_MANAGER;
+  }
+
+  ar = CheckArg(*aArgc, aArgv, "profilemanager");
+  if (ar == ARG_FOUND) {
+    return NS_ERROR_SHOW_PROFILE_MANAGER;
+  }
+
+#ifdef MOZ_BACKGROUNDTASKS
+  if (BackgroundTasks::IsBackgroundTaskMode()) {
+    // There are two cases:
+    // 1. ephemeral profile: create a new one in temporary directory.
+    // 2. non-ephemeral (persistent) profile:
+    //    a. if no salted profile is known, create a new one in
+    //       background task-specific directory.
+    //    b. if salted profile is know, use salted path.
+    nsString installHash;
+    rv = gDirServiceProvider->GetInstallHash(installHash);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCString profilePrefix(BackgroundTasks::GetProfilePrefix(
+        NS_LossyConvertUTF16toASCII(installHash)));
+
+    nsCString taskName(BackgroundTasks::GetBackgroundTasks().ref());
+
+    nsCOMPtr<nsIFile> file;
+
+    if (BackgroundTasks::IsEphemeralProfileTaskName(taskName)) {
+      // Background task mode does not enable legacy telemetry, so this is for
+      // completeness and testing only.
+      mStartupReason = u"backgroundtask-ephemeral"_ns;
+
+      nsCOMPtr<nsIFile> rootDir;
+      rv = GetSpecialSystemDirectory(OS_TemporaryDirectory,
+                                     getter_AddRefs(rootDir));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsresult rv = BackgroundTasks::CreateEphemeralProfileDirectory(
+          rootDir, profilePrefix, getter_AddRefs(file));
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        // In background task mode, NS_ERROR_UNEXPECTED is handled specially to
+        // exit with a non-zero exit code.
+        return NS_ERROR_UNEXPECTED;
+      }
+      *aDidCreate = true;
+    } else {
+      // Background task mode does not enable legacy telemetry, so this is for
+      // completeness and testing only.
+      mStartupReason = u"backgroundtask-not-ephemeral"_ns;
+
+      // A non-ephemeral profile is required.
+      nsCOMPtr<nsIFile> rootDir;
+      nsresult rv = gDirServiceProvider->GetBackgroundTasksProfilesRootDir(
+          getter_AddRefs(rootDir));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsAutoCString buffer;
+      rv = mProfileDB.GetString("BackgroundTasksProfiles", profilePrefix.get(),
+                                buffer);
+      if (NS_SUCCEEDED(rv)) {
+        // We have a record of one!  Use it.
+        rv = rootDir->Clone(getter_AddRefs(file));
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        rv = file->AppendNative(buffer);
+        NS_ENSURE_SUCCESS(rv, rv);
+      } else {
+        nsCString saltedProfilePrefix = profilePrefix;
+        SaltProfileName(saltedProfilePrefix);
+
+        nsresult rv = BackgroundTasks::CreateNonEphemeralProfileDirectory(
+            rootDir, saltedProfilePrefix, getter_AddRefs(file));
+        if (NS_WARN_IF(NS_FAILED(rv))) {
+          // In background task mode, NS_ERROR_UNEXPECTED is handled specially
+          // to exit with a non-zero exit code.
+          return NS_ERROR_UNEXPECTED;
+        }
+        *aDidCreate = true;
+
+        // Keep a record of the salted name.  It's okay if this doesn't succeed:
+        // not great, but it's better for tasks (particularly,
+        // `backgroundupdate`) to run and not persist state correctly than to
+        // not run at all.
+        rv =
+            mProfileDB.SetString("BackgroundTasksProfiles", profilePrefix.get(),
+                                 saltedProfilePrefix.get());
+        Unused << NS_WARN_IF(NS_FAILED(rv));
+
+        if (NS_SUCCEEDED(rv)) {
+          rv = Flush();
+          Unused << NS_WARN_IF(NS_FAILED(rv));
+        }
+      }
+    }
+
+    nsCOMPtr<nsIFile> localDir = file;
+    file.forget(aRootDir);
+    localDir.forget(aLocalDir);
+
+    // Background tasks never use profiles known to the profile service.
+    *aProfile = nullptr;
+
+    return NS_OK;
+  }
+#endif
+
+  if (mIsFirstRun && mUseDedicatedProfile &&
+      !mInstallSection.Equals(mLegacyInstallSection)) {
+    // The default profile could be assigned to a hash generated from an
+    // incorrectly cased version of the installation directory (see bug
+    // 1555319). Ideally we'd do all this while loading profiles.ini but we
+    // can't override the legacy section value before that for tests.
+    nsCString defaultDescriptor;
+    rv = mProfileDB.GetString(mLegacyInstallSection.get(), "Default",
+                              defaultDescriptor);
+
+    if (NS_SUCCEEDED(rv)) {
+      // There is a default here, need to see if it matches any profiles.
+      bool isRelative;
+      nsCString descriptor;
+
+      for (RefPtr<nsToolkitProfile> profile : mProfiles) {
+        GetProfileDescriptor(profile, descriptor, &isRelative);
+
+        if (descriptor.Equals(defaultDescriptor)) {
+          // Found the default profile. Copy the install section over to
+          // the correct location. We leave the old info in place for older
+          // versions of Firefox to use.
+          nsTArray<UniquePtr<KeyValue>> strings =
+              GetSectionStrings(&mProfileDB, mLegacyInstallSection.get());
+          for (const auto& kv : strings) {
+            mProfileDB.SetString(mInstallSection.get(), kv->key.get(),
+                                 kv->value.get());
+          }
+
+          // Flush now. This causes a small blip in startup but it should be
+          // one time only whereas not flushing means we have to do this search
+          // on every startup.
+          Flush();
+
+          // Now start up with the found profile.
+          mDedicatedProfile = profile;
+          mIsFirstRun = false;
+          break;
+        }
+      }
+    }
+  }
+
+  // If this is a first run then create a new profile.
+  if (mIsFirstRun) {
+    // If we're configured to always show the profile manager then don't create
+    // a new profile to use.
+    if (!mStartWithLast) {
+      return NS_ERROR_SHOW_PROFILE_MANAGER;
+    }
+
+    bool skippedDefaultProfile = false;
+
+    if (mUseDedicatedProfile) {
+      // This is the first run of a dedicated profile install. We have to decide
+      // whether to use the default profile used by non-dedicated-profile
+      // installs or to create a new profile.
+
+      // Find what would have been the default profile for old installs.
+      nsCOMPtr<nsIToolkitProfile> profile = mNormalDefault;
+      if (mUseDevEditionProfile) {
+        profile = mDevEditionDefault;
+      }
+
+      if (profile) {
+        nsCOMPtr<nsIFile> rootDir;
+        profile->GetRootDir(getter_AddRefs(rootDir));
+
+        nsCOMPtr<nsIFile> compat;
+        rootDir->Clone(getter_AddRefs(compat));
+        compat->Append(COMPAT_FILE);
+
+        bool exists;
+        rv = compat->Exists(&exists);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        // If the file is missing then either this is an empty profile (likely
+        // generated by bug 1518591) or it is from an ancient version. We'll opt
+        // to leave it for older versions in this case.
+        if (exists) {
+          bool result;
+          rv = MaybeMakeDefaultDedicatedProfile(profile, &result);
+          NS_ENSURE_SUCCESS(rv, rv);
+          if (result) {
+            mStartupReason = u"firstrun-claimed-default"_ns;
+
+            mCurrent = profile;
+            rootDir.forget(aRootDir);
+            profile->GetLocalDir(aLocalDir);
+            profile.forget(aProfile);
+            return NS_OK;
+          }
+
+          // We're going to create a new profile for this install even though
+          // another default exists.
+          skippedDefaultProfile = true;
+        }
+      }
+    }
+
+    rv = CreateDefaultProfile(getter_AddRefs(mCurrent));
+    if (NS_SUCCEEDED(rv)) {
+      // If there is only one profile and it isn't meant to be the profile that
+      // older versions of Firefox use then we must create a default profile
+      // for older versions of Firefox to avoid the existing profile being
+      // auto-selected.
+      if ((mUseDedicatedProfile || mUseDevEditionProfile) &&
+          mProfiles.getFirst() == mProfiles.getLast()) {
+        nsCOMPtr<nsIToolkitProfile> newProfile;
+        CreateProfile(nullptr, nsLiteralCString(DEFAULT_NAME),
+                      getter_AddRefs(newProfile));
+        SetNormalDefault(newProfile);
+      }
+
+      rv = Flush();
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      if (skippedDefaultProfile) {
+        mStartupReason = u"firstrun-skipped-default"_ns;
+      } else {
+        mStartupReason = u"firstrun-created-default"_ns;
+      }
+
+      // Use the new profile.
+      mCurrent->GetRootDir(aRootDir);
+      mCurrent->GetLocalDir(aLocalDir);
+      NS_ADDREF(*aProfile = mCurrent);
+
+      *aDidCreate = true;
+      return NS_OK;
+    }
+  }
+
+  GetDefaultProfile(getter_AddRefs(mCurrent));
+
+  // None of the profiles was marked as default (generally only happens if the
+  // user modifies profiles.ini manually). Let the user choose.
+  if (!mCurrent) {
+    return NS_ERROR_SHOW_PROFILE_MANAGER;
+  }
+
+  // Let the caller know that the profile was selected by default.
+  *aWasDefaultSelection = true;
+  mStartupReason = u"default"_ns;
+
+  // Use the selected profile.
+  mCurrent->GetRootDir(aRootDir);
+  mCurrent->GetLocalDir(aLocalDir);
+  NS_ADDREF(*aProfile = mCurrent);
+
+  return NS_OK;
+}
+
+/**
+ * Creates a new profile for reset and mark it as the current profile.
+ */
+nsresult nsToolkitProfileService::CreateResetProfile(
+    nsIToolkitProfile** aNewProfile) {
+  nsAutoCString oldProfileName;
+  mCurrent->GetName(oldProfileName);
+
+  nsCOMPtr<nsIToolkitProfile> newProfile;
+  // Make the new profile name the old profile (or "default-") + the time in
+  // seconds since epoch for uniqueness.
+  nsAutoCString newProfileName;
+  if (!oldProfileName.IsEmpty()) {
+    newProfileName.Assign(oldProfileName);
+    newProfileName.Append("-");
+  } else {
+    newProfileName.AssignLiteral("default-");
+  }
+  newProfileName.AppendPrintf("%" PRId64, PR_Now() / 1000);
+  nsresult rv = CreateProfile(nullptr,  // choose a default dir for us
+                              newProfileName, getter_AddRefs(newProfile));
+  if (NS_FAILED(rv)) return rv;
+
+  mCurrent = newProfile;
+  newProfile.forget(aNewProfile);
+
+  // Don't flush the changes yet. That will happen once the migration
+  // successfully completes.
+  return NS_OK;
+}
+
+/**
+ * This is responsible for deleting the old profile, copying its name to the
+ * current profile and if the old profile was default making the new profile
+ * default as well.
+ */
+nsresult nsToolkitProfileService::ApplyResetProfile(
+    nsIToolkitProfile* aOldProfile) {
+  // If the old profile would have been the default for old installs then mark
+  // the new profile as such.
+  if (mNormalDefault == aOldProfile) {
+    SetNormalDefault(mCurrent);
+  }
+
+  if (mUseDedicatedProfile && mDedicatedProfile == aOldProfile) {
+    bool wasLocked = false;
+    nsCString val;
+    if (NS_SUCCEEDED(
+            mProfileDB.GetString(mInstallSection.get(), "Locked", val))) {
+      wasLocked = val.Equals("1");
+    }
+
+    SetDefaultProfile(mCurrent);
+
+    // Make the locked state match if necessary.
+    if (!wasLocked) {
+      mProfileDB.DeleteString(mInstallSection.get(), "Locked");
+    }
+  }
+
+  nsCString name;
+  nsresult rv = aOldProfile->GetName(name);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Don't remove the old profile's files until after we've successfully flushed
+  // the profile changes to disk.
+  rv = aOldProfile->Remove(false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Switching the name will make this the default for dev-edition if
+  // appropriate.
+  rv = mCurrent->SetName(name);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = Flush();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Now that the profile changes are flushed, try to remove the old profile's
+  // files. If we fail the worst that will happen is that an orphan directory is
+  // left. Let this run in the background while we start up.
+  RemoveProfileFiles(aOldProfile, true);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::GetProfileByName(const nsACString& aName,
+                                          nsIToolkitProfile** aResult) {
+  for (RefPtr<nsToolkitProfile> profile : mProfiles) {
+    if (profile->mName.Equals(aName)) {
+      NS_ADDREF(*aResult = profile);
+      return NS_OK;
+    }
+  }
+
+  return NS_ERROR_FAILURE;
+}
+
+/**
+ * Finds a profile from the database that uses the given root and local
+ * directories.
+ */
+void nsToolkitProfileService::GetProfileByDir(nsIFile* aRootDir,
+                                              nsIFile* aLocalDir,
+                                              nsIToolkitProfile** aResult) {
+  for (RefPtr<nsToolkitProfile> profile : mProfiles) {
+    bool equal;
+    nsresult rv = profile->mRootDir->Equals(aRootDir, &equal);
+    if (NS_SUCCEEDED(rv) && equal) {
+      if (!aLocalDir) {
+        // If no local directory was given then we will just use the normal
+        // local directory for the profile.
+        profile.forget(aResult);
+        return;
+      }
+
+      rv = profile->mLocalDir->Equals(aLocalDir, &equal);
+      if (NS_SUCCEEDED(rv) && equal) {
+        profile.forget(aResult);
+        return;
+      }
+    }
+  }
+}
+
+nsresult NS_LockProfilePath(nsIFile* aPath, nsIFile* aTempPath,
+                            nsIProfileUnlocker** aUnlocker,
+                            nsIProfileLock** aResult) {
+  RefPtr<nsToolkitProfileLock> lock = new nsToolkitProfileLock();
+
+  nsresult rv = lock->Init(aPath, aTempPath, aUnlocker);
+  if (NS_FAILED(rv)) return rv;
+
+  lock.forget(aResult);
+  return NS_OK;
+}
+
+static void SaltProfileName(nsACString& aName) {
+  char salt[9];
+  NS_MakeRandomString(salt, 8);
+  salt[8] = '.';
+
+  aName.Insert(salt, 0, 9);
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::CreateUniqueProfile(nsIFile* aRootDir,
+                                             const nsACString& aNamePrefix,
+                                             nsIToolkitProfile** aResult) {
+  nsCOMPtr<nsIToolkitProfile> profile;
+  nsresult rv = GetProfileByName(aNamePrefix, getter_AddRefs(profile));
+  if (NS_FAILED(rv)) {
+    return CreateProfile(aRootDir, aNamePrefix, aResult);
+  }
+
+  uint32_t suffix = 1;
+  while (true) {
+    nsPrintfCString name("%s-%d", PromiseFlatCString(aNamePrefix).get(),
+                         suffix);
+    rv = GetProfileByName(name, getter_AddRefs(profile));
+    if (NS_FAILED(rv)) {
+      return CreateProfile(aRootDir, name, aResult);
+    }
+    suffix++;
+  }
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::CreateProfile(nsIFile* aRootDir,
+                                       const nsACString& aName,
+                                       nsIToolkitProfile** aResult) {
+  nsresult rv = GetProfileByName(aName, aResult);
+  if (NS_SUCCEEDED(rv)) {
+    return rv;
+  }
+
+  nsCOMPtr<nsIFile> rootDir(aRootDir);
+
+  nsAutoCString dirName;
+  if (!rootDir) {
+    rv = gDirServiceProvider->GetUserProfilesRootDir(getter_AddRefs(rootDir));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    dirName = aName;
+    SaltProfileName(dirName);
+
+    if (NS_IsNativeUTF8()) {
+      rootDir->AppendNative(dirName);
+    } else {
+      rootDir->Append(NS_ConvertUTF8toUTF16(dirName));
+    }
+  }
+
+  nsCOMPtr<nsIFile> localDir;
+
+  bool isRelative;
+  rv = mAppData->Contains(rootDir, &isRelative);
+  if (NS_SUCCEEDED(rv) && isRelative) {
+    nsAutoCString path;
+    rv = rootDir->GetRelativeDescriptor(mAppData, path);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = NS_NewNativeLocalFile(""_ns, true, getter_AddRefs(localDir));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = localDir->SetRelativeDescriptor(mTempData, path);
+  } else {
+    localDir = rootDir;
+  }
+
+  bool exists;
+  rv = rootDir->Exists(&exists);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (exists) {
+    rv = rootDir->IsDirectory(&exists);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (!exists) return NS_ERROR_FILE_NOT_DIRECTORY;
+  } else {
+    nsCOMPtr<nsIFile> profileDirParent;
+    nsAutoString profileDirName;
+
+    rv = rootDir->GetParent(getter_AddRefs(profileDirParent));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = rootDir->GetLeafName(profileDirName);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // let's ensure that the profile directory exists.
+    rv = rootDir->Create(nsIFile::DIRECTORY_TYPE, 0700);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = rootDir->SetPermissions(0700);
+#ifndef ANDROID
+    // If the profile is on the sdcard, this will fail but its non-fatal
+    NS_ENSURE_SUCCESS(rv, rv);
+#endif
+  }
+
+  rv = localDir->Exists(&exists);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!exists) {
+    rv = localDir->Create(nsIFile::DIRECTORY_TYPE, 0700);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // We created a new profile dir. Let's store a creation timestamp.
+  // Note that this code path does not apply if the profile dir was
+  // created prior to launching.
+  rv = CreateTimesInternal(rootDir);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIToolkitProfile> profile =
+      new nsToolkitProfile(aName, rootDir, localDir, false);
+
+  if (aName.Equals(DEV_EDITION_NAME)) {
+    mDevEditionDefault = profile;
+  }
+
+  profile.forget(aResult);
+  return NS_OK;
+}
+
+/**
+ * Snaps (https://snapcraft.io/) use a different installation directory for
+ * every version of an application. Since dedicated profiles uses the
+ * installation directory to determine which profile to use this would lead
+ * snap users getting a new profile on every application update.
+ *
+ * However the only way to have multiple installation of a snap is to install
+ * a new snap instance. Different snap instances have different user data
+ * directories and so already will not share profiles, in fact one instance
+ * will not even be able to see the other instance's profiles since
+ * profiles.ini will be stored in different places.
+ *
+ * So we can just disable dedicated profile support in this case and revert
+ * back to the old method of just having a single default profile and still
+ * get essentially the same benefits as dedicated profiles provides.
+ */
+bool nsToolkitProfileService::IsSnapEnvironment() {
+#ifdef MOZ_WIDGET_GTK
+  return widget::IsRunningUnderSnap();
+#else
+  return false;
+#endif
+}
+
+/**
+ * In some situations dedicated profile support does not work well. This
+ * includes a handful of linux distributions which always install different
+ * application versions to different locations, some application sandboxing
+ * systems as well as enterprise deployments. This environment variable provides
+ * a way to opt out of dedicated profiles for these cases.
+ *
+ * For Windows, we provide a policy to accomplish the same thing.
+ */
+bool nsToolkitProfileService::UseLegacyProfiles() {
+  bool legacyProfiles = !!PR_GetEnv("MOZ_LEGACY_PROFILES");
+#ifdef XP_WIN
+  legacyProfiles |= PolicyCheckBoolean(L"LegacyProfiles");
+#endif
+  return legacyProfiles;
+}
+
+struct FindInstallsClosure {
+  nsINIParser* installData;
+  nsTArray<nsCString>* installs;
+};
+
+static bool FindInstalls(const char* aSection, void* aClosure) {
+  FindInstallsClosure* closure = static_cast<FindInstallsClosure*>(aClosure);
+
+  // Check if the section starts with "Install"
+  if (strncmp(aSection, INSTALL_PREFIX, INSTALL_PREFIX_LENGTH) != 0) {
+    return true;
+  }
+
+  nsCString install(aSection);
+  closure->installs->AppendElement(install);
+
+  return true;
+}
+
+nsTArray<nsCString> nsToolkitProfileService::GetKnownInstalls() {
+  nsTArray<nsCString> result;
+  FindInstallsClosure closure = {&mProfileDB, &result};
+
+  mProfileDB.GetSections(&FindInstalls, &closure);
+
+  return result;
+}
+
+nsresult nsToolkitProfileService::CreateTimesInternal(nsIFile* aProfileDir) {
+  nsresult rv = NS_ERROR_FAILURE;
+  nsCOMPtr<nsIFile> creationLog;
+  rv = aProfileDir->Clone(getter_AddRefs(creationLog));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = creationLog->AppendNative("times.json"_ns);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool exists = false;
+  creationLog->Exists(&exists);
+  if (exists) {
+    return NS_OK;
+  }
+
+  rv = creationLog->Create(nsIFile::NORMAL_FILE_TYPE, 0700);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // We don't care about microsecond resolution.
+  int64_t msec = PR_Now() / PR_USEC_PER_MSEC;
+
+  // Write it out.
+  PRFileDesc* writeFile;
+  rv = creationLog->OpenNSPRFileDesc(PR_WRONLY, 0700, &writeFile);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  PR_fprintf(writeFile, "{\n\"created\": %lld,\n\"firstUse\": null\n}\n", msec);
+  PR_Close(writeFile);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::GetProfileCount(uint32_t* aResult) {
+  *aResult = 0;
+  for (nsToolkitProfile* profile : mProfiles) {
+    Unused << profile;
+    (*aResult)++;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsToolkitProfileService::Flush() {
+  if (GetIsListOutdated()) {
+    return NS_ERROR_DATABASE_CHANGED;
+  }
+
+  nsresult rv;
+
+  // If we aren't using dedicated profiles then nothing about the list of
+  // installs can have changed, so no need to update the backup.
+  if (mUseDedicatedProfile) {
+    // Export the installs to the backup.
+    nsTArray<nsCString> installs = GetKnownInstalls();
+
+    if (!installs.IsEmpty()) {
+      nsCString data;
+      nsCString buffer;
+
+      for (uint32_t i = 0; i < installs.Length(); i++) {
+        nsTArray<UniquePtr<KeyValue>> strings =
+            GetSectionStrings(&mProfileDB, installs[i].get());
+        if (strings.IsEmpty()) {
+          continue;
+        }
+
+        // Strip "Install" from the start.
+        const nsDependentCSubstring& install =
+            Substring(installs[i], INSTALL_PREFIX_LENGTH);
+        data.AppendPrintf("[%s]\n", PromiseFlatCString(install).get());
+
+        for (uint32_t j = 0; j < strings.Length(); j++) {
+          data.AppendPrintf("%s=%s\n", strings[j]->key.get(),
+                            strings[j]->value.get());
+        }
+
+        data.Append("\n");
+      }
+
+      FILE* writeFile;
+      rv = mInstallDBFile->OpenANSIFileDesc("w", &writeFile);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      uint32_t length = data.Length();
+      if (fwrite(data.get(), sizeof(char), length, writeFile) != length) {
+        fclose(writeFile);
+        return NS_ERROR_UNEXPECTED;
+      }
+
+      fclose(writeFile);
+    } else {
+      rv = mInstallDBFile->Remove(false);
+      if (NS_FAILED(rv) && rv != NS_ERROR_FILE_NOT_FOUND) {
+        return rv;
+      }
+    }
+  }
+
+  rv = mProfileDB.WriteToFile(mProfileDBFile);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = UpdateFileStats(mProfileDBFile, &mProfileDBExists,
+                       &mProfileDBModifiedTime, &mProfileDBFileSize);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+already_AddRefed<nsToolkitProfileService> NS_GetToolkitProfileService() {
+  if (!nsToolkitProfileService::gService) {
+    nsToolkitProfileService::gService = new nsToolkitProfileService();
+    nsresult rv = nsToolkitProfileService::gService->Init();
+    if (NS_FAILED(rv)) {
+      NS_ERROR("nsToolkitProfileService::Init failed!");
+      delete nsToolkitProfileService::gService;
+      return nullptr;
+    }
+  }
+
+  return do_AddRef(nsToolkitProfileService::gService);
+}
+
+nsresult XRE_GetFileFromPath(const char* aPath, nsIFile** aResult) {
+#if defined(XP_MACOSX)
+  int32_t pathLen = strlen(aPath);
+  if (pathLen > MAXPATHLEN) return NS_ERROR_INVALID_ARG;
+
+  CFURLRef fullPath = CFURLCreateFromFileSystemRepresentation(
+      nullptr, (const UInt8*)aPath, pathLen, true);
+  if (!fullPath) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIFile> lf;
+  nsresult rv = NS_NewNativeLocalFile(""_ns, true, getter_AddRefs(lf));
+  if (NS_SUCCEEDED(rv)) {
+    nsCOMPtr<nsILocalFileMac> lfMac = do_QueryInterface(lf, &rv);
+    if (NS_SUCCEEDED(rv)) {
+      rv = lfMac->InitWithCFURL(fullPath);
+      if (NS_SUCCEEDED(rv)) {
+        lf.forget(aResult);
+      }
+    }
+  }
+  CFRelease(fullPath);
+  return rv;
+
+#elif defined(XP_UNIX)
+  char fullPath[MAXPATHLEN];
+
+  if (!realpath(aPath, fullPath)) return NS_ERROR_FAILURE;
+
+  return NS_NewNativeLocalFile(nsDependentCString(fullPath), true, aResult);
+#elif defined(XP_WIN)
+  WCHAR fullPath[MAXPATHLEN];
+
+  if (!_wfullpath(fullPath, NS_ConvertUTF8toUTF16(aPath).get(), MAXPATHLEN))
+    return NS_ERROR_FAILURE;
+
+  return NS_NewLocalFile(nsDependentString(fullPath), true, aResult);
+
+#else
+#  error Platform-specific logic needed here.
+#endif
+}
diff --git a/toolkit/profile/nsToolkitProfileService.h b/toolkit/profile/nsToolkitProfileService.h
new file mode 100644
index 0000000000..dea1af0124
--- /dev/null
+++ b/toolkit/profile/nsToolkitProfileService.h
@@ -0,0 +1,177 @@
+
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef nsToolkitProfileService_h
+#define nsToolkitProfileService_h
+
+#include "mozilla/Components.h"
+#include "mozilla/LinkedList.h"
+#include "nsIToolkitProfileService.h"
+#include "nsIToolkitProfile.h"
+#include "nsIFactory.h"
+#include "nsSimpleEnumerator.h"
+#include "nsProfileLock.h"
+#include "nsINIParser.h"
+
+class nsToolkitProfile final
+    : public nsIToolkitProfile,
+      public mozilla::LinkedListElement<RefPtr<nsToolkitProfile>> {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSITOOLKITPROFILE
+
+  friend class nsToolkitProfileService;
+
+ private:
+  ~nsToolkitProfile() = default;
+
+  nsToolkitProfile(const nsACString& aName, nsIFile* aRootDir,
+                   nsIFile* aLocalDir, bool aFromDB);
+
+  nsresult RemoveInternal(bool aRemoveFiles, bool aInBackground);
+
+  friend class nsToolkitProfileLock;
+
+  nsCString mName;
+  nsCOMPtr<nsIFile> mRootDir;
+  nsCOMPtr<nsIFile> mLocalDir;
+  nsIProfileLock* mLock;
+  uint32_t mIndex;
+  nsCString mSection;
+};
+
+class nsToolkitProfileLock final : public nsIProfileLock {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPROFILELOCK
+
+  nsresult Init(nsToolkitProfile* aProfile, nsIProfileUnlocker** aUnlocker);
+  nsresult Init(nsIFile* aDirectory, nsIFile* aLocalDirectory,
+                nsIProfileUnlocker** aUnlocker);
+
+  nsToolkitProfileLock() = default;
+
+ private:
+  ~nsToolkitProfileLock();
+
+  RefPtr<nsToolkitProfile> mProfile;
+  nsCOMPtr<nsIFile> mDirectory;
+  nsCOMPtr<nsIFile> mLocalDirectory;
+
+  nsProfileLock mLock;
+};
+
+class nsToolkitProfileService final : public nsIToolkitProfileService {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSITOOLKITPROFILESERVICE
+
+  nsresult SelectStartupProfile(int* aArgc, char* aArgv[], bool aIsResetting,
+                                nsIFile** aRootDir, nsIFile** aLocalDir,
+                                nsIToolkitProfile** aProfile, bool* aDidCreate,
+                                bool* aWasDefaultSelection);
+  nsresult CreateResetProfile(nsIToolkitProfile** aNewProfile);
+  nsresult ApplyResetProfile(nsIToolkitProfile* aOldProfile);
+  void CompleteStartup();
+
+ private:
+  friend class nsToolkitProfile;
+  friend already_AddRefed<nsToolkitProfileService>
+  NS_GetToolkitProfileService();
+
+  nsToolkitProfileService();
+  ~nsToolkitProfileService();
+
+  nsresult Init();
+
+  nsresult CreateTimesInternal(nsIFile* profileDir);
+  void GetProfileByDir(nsIFile* aRootDir, nsIFile* aLocalDir,
+                       nsIToolkitProfile** aResult);
+
+  nsresult GetProfileDescriptor(nsIToolkitProfile* aProfile,
+                                nsACString& aDescriptor, bool* aIsRelative);
+  bool IsProfileForCurrentInstall(nsIToolkitProfile* aProfile);
+  void ClearProfileFromOtherInstalls(nsIToolkitProfile* aProfile);
+  nsresult MaybeMakeDefaultDedicatedProfile(nsIToolkitProfile* aProfile,
+                                            bool* aResult);
+  bool IsSnapEnvironment();
+  bool UseLegacyProfiles();
+  nsresult CreateDefaultProfile(nsIToolkitProfile** aResult);
+  void SetNormalDefault(nsIToolkitProfile* aProfile);
+
+  // Returns the known install hashes from the installs database. Modifying the
+  // installs database is safe while iterating the returned array.
+  nsTArray<nsCString> GetKnownInstalls();
+
+  // Tracks whether SelectStartupProfile has been called.
+  bool mStartupProfileSelected;
+  // The  profiles loaded from profiles.ini.
+  mozilla::LinkedList<RefPtr<nsToolkitProfile>> mProfiles;
+  // The profile selected for use at startup, if it exists in profiles.ini.
+  nsCOMPtr<nsIToolkitProfile> mCurrent;
+  // The profile selected for this install in installs.ini.
+  nsCOMPtr<nsIToolkitProfile> mDedicatedProfile;
+  // The default profile used by non-dev-edition builds.
+  nsCOMPtr<nsIToolkitProfile> mNormalDefault;
+  // The profile used if mUseDevEditionProfile is true (the default on
+  // dev-edition builds).
+  nsCOMPtr<nsIToolkitProfile> mDevEditionDefault;
+  // The directory that holds profiles.ini and profile directories.
+  nsCOMPtr<nsIFile> mAppData;
+  // The directory that holds the cache files for profiles.
+  nsCOMPtr<nsIFile> mTempData;
+  // The location of profiles.ini.
+  nsCOMPtr<nsIFile> mProfileDBFile;
+  // The location of installs.ini.
+  nsCOMPtr<nsIFile> mInstallDBFile;
+  // The data loaded from profiles.ini.
+  nsINIParser mProfileDB;
+  // The section in the profiles db for the current install.
+  nsCString mInstallSection;
+  // A legacy install section which may have been generated against an
+  // installation directory with an incorrect case (see bug 1555319). It is only
+  // really held here so that it can be overridden by tests.
+  nsCString mLegacyInstallSection;
+  // Whether to start with the selected profile by default.
+  bool mStartWithLast;
+  // True if during startup it appeared that this is the first run.
+  bool mIsFirstRun;
+  // True if the default profile is the separate dev-edition-profile.
+  bool mUseDevEditionProfile;
+  // True if this install should use a dedicated default profile.
+  const bool mUseDedicatedProfile;
+  nsString mStartupReason;
+  bool mMaybeLockProfile;
+  // Holds the current application update channel. This is only really held
+  // so it can be overriden in tests.
+  nsCString mUpdateChannel;
+  // Keep track of some attributes of the databases so we can tell if another
+  // process has changed them.
+  bool mProfileDBExists;
+  int64_t mProfileDBFileSize;
+  PRTime mProfileDBModifiedTime;
+
+  static nsToolkitProfileService* gService;
+
+  class ProfileEnumerator final : public nsSimpleEnumerator {
+   public:
+    NS_DECL_NSISIMPLEENUMERATOR
+
+    const nsID& DefaultInterface() override {
+      return NS_GET_IID(nsIToolkitProfile);
+    }
+
+    explicit ProfileEnumerator(nsToolkitProfile* first) { mCurrent = first; }
+
+   private:
+    RefPtr<nsToolkitProfile> mCurrent;
+  };
+};
+
+already_AddRefed<nsToolkitProfileService> NS_GetToolkitProfileService();
+
+#endif
diff --git a/toolkit/profile/test/chrome.ini b/toolkit/profile/test/chrome.ini
new file mode 100644
index 0000000000..9d27de238e
--- /dev/null
+++ b/toolkit/profile/test/chrome.ini
@@ -0,0 +1,3 @@
+[DEFAULT]
+
+[test_create_profile.xhtml]
diff --git a/toolkit/profile/test/test_create_profile.xhtml b/toolkit/profile/test/test_create_profile.xhtml
new file mode 100644
index 0000000000..5967580382
--- /dev/null
+++ b/toolkit/profile/test/test_create_profile.xhtml
@@ -0,0 +1,126 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/css" href="chrome://global/skin"?>
+<?xml-stylesheet type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"?>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=543854
+-->
+<window title="Mozilla Bug 543854"
+        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+
+    <!-- test results are displayed in the html:body -->
+  <body xmlns="http://www.w3.org/1999/xhtml">
+  <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=543854"
+     target="_blank">Mozilla Bug 543854</a>
+  </body>
+
+  <!-- test code goes here -->
+  <script type="application/javascript">
+  <![CDATA[
+
+  /** Test for Bug 543854 **/
+
+  SimpleTest.waitForExplicitFinish();
+
+  const ASCIIName = "myprofile";
+  const UnicodeName = "\u09A0\u09BE\u0995\u09C1\u09B0"; // A Bengali name
+
+  var gDirService = SpecialPowers.Services.dirsvc;
+  var gIOService = SpecialPowers.Services.io;
+  var gProfileService;
+  var gDefaultLocalProfileParent;
+
+  gProfileService = Cc["@mozilla.org/toolkit/profile-service;1"].
+    getService(Ci.nsIToolkitProfileService);
+
+  gDefaultLocalProfileParent = gDirService.get("DefProfLRt", Ci.nsIFile);
+
+  createProfile(ASCIIName);
+  createProfile(UnicodeName);
+  SimpleTest.finish();
+
+/**
+ * Read the contents of an nsIFile. Throws on error.
+
+ * @param file an nsIFile instance.
+ * @return string contents.
+ */
+function readFile(file) {
+  let fstream = Cc["@mozilla.org/network/file-input-stream;1"].
+    createInstance(Ci.nsIFileInputStream);
+  let sstream = Cc["@mozilla.org/scriptableinputstream;1"].
+    createInstance(Ci.nsIScriptableInputStream);
+
+  const RO = 0x01;
+  const READ_OTHERS = 4;
+
+  fstream.init(file, RO, READ_OTHERS, 0);
+  sstream.init(fstream);
+  let out = sstream.read(sstream.available());
+  sstream.close();
+  fstream.close();
+  return out;
+}
+
+function checkBounds(lowerBound, value, upperBound) {
+  ok(lowerBound <= value, "value " + value +
+                          " is above lower bound " + lowerBound);
+  ok(upperBound >= value, "value " + value +
+                          " is within upper bound " + upperBound);
+}
+
+function createProfile(profileName) {
+  // Filesystem precision is lower than Date precision.
+  let lowerBound = Date.now() - 1000;
+
+  let profile = gProfileService.createProfile(null, profileName);
+
+  // check that the directory was created
+  isnot(profile, null, "Profile " + profileName + " created");
+
+  let profileDir = profile.rootDir;
+
+  ok(profileDir.exists(), "Profile dir created");
+  ok(profileDir.isDirectory(), "Profile dir is a directory");
+
+  let profileDirPath = profileDir.path;
+
+  is(profileDirPath.substr(profileDirPath.length - profileName.length),
+     profileName, "Profile dir has expected name");
+
+  // Ensure that our timestamp file was created.
+  let jsonFile = profileDir.clone();
+  jsonFile.append("times.json");
+  ok(jsonFile.path, "Path is " + jsonFile.path);
+  ok(jsonFile.exists(), "Times file was created");
+  ok(jsonFile.isFile(), "Times file is a file");
+  let json = JSON.parse(readFile(jsonFile));
+
+  let upperBound = Date.now() + 1000;
+
+  let created = json.created;
+  ok(created, "created is set");
+
+  // Check against real clock time.
+  checkBounds(lowerBound, created, upperBound);
+
+  // Clean up the profile before local profile test.
+  profile.remove(true);
+  ok(!jsonFile.exists(), "Times file was removed");
+  ok(!profileDir.exists(), "Profile dir was removed");
+
+  // Create with non-null aRootDir
+  profile = gProfileService.createProfile(profileDir, profileName);
+
+  let localProfileDir = profile.localDir;
+  ok(gDefaultLocalProfileParent.contains(localProfileDir, false),
+    "Local profile dir created in DefProfLRt");
+
+  // Clean up the profile.
+  profile.remove(true);
+  ok(!profileDir.exists(), "Profile dir was removed");
+}
+
+  ]]>
+  </script>
+</window>
diff --git a/toolkit/profile/xpcshell/head.js b/toolkit/profile/xpcshell/head.js
new file mode 100644
index 0000000000..48cc712891
--- /dev/null
+++ b/toolkit/profile/xpcshell/head.js
@@ -0,0 +1,622 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
+const { FileUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/FileUtils.sys.mjs"
+);
+const { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+const { TelemetryTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/TelemetryTestUtils.sys.mjs"
+);
+
+const NS_ERROR_START_PROFILE_MANAGER = 0x805800c9;
+
+const UPDATE_CHANNEL = AppConstants.MOZ_UPDATE_CHANNEL;
+
+let gProfD = do_get_profile();
+let gDataHome = gProfD.clone();
+gDataHome.append("data");
+gDataHome.createUnique(Ci.nsIFile.DIRECTORY_TYPE, 0o755);
+let gDataHomeLocal = gProfD.clone();
+gDataHomeLocal.append("local");
+gDataHomeLocal.createUnique(Ci.nsIFile.DIRECTORY_TYPE, 0o755);
+
+let xreDirProvider = Cc["@mozilla.org/xre/directory-provider;1"].getService(
+  Ci.nsIXREDirProvider
+);
+xreDirProvider.setUserDataDirectory(gDataHome, false);
+xreDirProvider.setUserDataDirectory(gDataHomeLocal, true);
+
+let gIsDefaultApp = false;
+
+const ShellService = {
+  register() {
+    let registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
+
+    let factory = {
+      createInstance(iid) {
+        return ShellService.QueryInterface(iid);
+      },
+    };
+
+    registrar.registerFactory(
+      this.ID,
+      "ToolkitShellService",
+      this.CONTRACT,
+      factory
+    );
+  },
+
+  isDefaultApplication() {
+    return gIsDefaultApp;
+  },
+
+  QueryInterface: ChromeUtils.generateQI(["nsIToolkitShellService"]),
+  ID: Components.ID("{ce724e0c-ed70-41c9-ab31-1033b0b591be}"),
+  CONTRACT: "@mozilla.org/toolkit/shell-service;1",
+};
+
+ShellService.register();
+
+let gIsLegacy = false;
+
+function simulateSnapEnvironment() {
+  Services.env.set("SNAP_INSTANCE_NAME", AppConstants.MOZ_APP_NAME);
+
+  gIsLegacy = true;
+}
+
+function enableLegacyProfiles() {
+  Services.env.set("MOZ_LEGACY_PROFILES", "1");
+
+  gIsLegacy = true;
+}
+
+function getProfileService() {
+  return Cc["@mozilla.org/toolkit/profile-service;1"].getService(
+    Ci.nsIToolkitProfileService
+  );
+}
+
+let PROFILE_DEFAULT = "default";
+let DEDICATED_NAME = `default-${UPDATE_CHANNEL}`;
+if (AppConstants.MOZ_DEV_EDITION) {
+  DEDICATED_NAME = PROFILE_DEFAULT = "dev-edition-default";
+}
+
+// Shared data for backgroundtasks tests.
+const BACKGROUNDTASKS_PROFILE_DATA = (() => {
+  let hash = xreDirProvider.getInstallHash();
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: "Profile1",
+        path: "Path1",
+        default: false,
+      },
+      {
+        name: "Profile3",
+        path: "Path3",
+        default: false,
+      },
+    ],
+    installs: {
+      [hash]: {
+        default: "Path1",
+      },
+    },
+    backgroundTasksProfiles: [
+      {
+        name: `MozillaBackgroundTask-${hash}-unrelated_task`,
+        path: `saltsalt.MozillaBackgroundTask-${hash}-unrelated_task`,
+      },
+    ],
+  };
+  return profileData;
+})();
+
+/**
+ * Creates a random profile path for use.
+ */
+function makeRandomProfileDir(name) {
+  let file = gDataHome.clone();
+  file.append(name);
+  file.createUnique(Ci.nsIFile.DIRECTORY_TYPE, 0o755);
+  return file;
+}
+
+/**
+ * A wrapper around nsIToolkitProfileService.selectStartupProfile to make it
+ * a bit nicer to use from JS.
+ */
+function selectStartupProfile(args = [], isResetting = false, legacyHash = "") {
+  let service = getProfileService();
+  let rootDir = {};
+  let localDir = {};
+  let profile = {};
+  let didCreate = service.selectStartupProfile(
+    ["xpcshell", ...args],
+    isResetting,
+    UPDATE_CHANNEL,
+    legacyHash,
+    rootDir,
+    localDir,
+    profile
+  );
+
+  if (profile.value) {
+    Assert.ok(
+      rootDir.value.equals(profile.value.rootDir),
+      "Should have matched the root dir."
+    );
+    Assert.ok(
+      localDir.value.equals(profile.value.localDir),
+      "Should have matched the local dir."
+    );
+    Assert.ok(
+      service.currentProfile === profile.value,
+      "Should have marked the profile as the current profile."
+    );
+  } else {
+    Assert.ok(!service.currentProfile, "Should be no current profile.");
+  }
+
+  return {
+    rootDir: rootDir.value,
+    localDir: localDir.value,
+    profile: profile.value,
+    didCreate,
+  };
+}
+
+function testStartsProfileManager(args = [], isResetting = false) {
+  try {
+    selectStartupProfile(args, isResetting);
+    Assert.ok(false, "Should have started the profile manager");
+    checkStartupReason();
+  } catch (e) {
+    Assert.equal(
+      e.result,
+      NS_ERROR_START_PROFILE_MANAGER,
+      "Should have started the profile manager"
+    );
+  }
+}
+
+function safeGet(ini, section, key) {
+  try {
+    return ini.getString(section, key);
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Writes a compatibility.ini file that marks the give profile directory as last
+ * used by the given install path.
+ */
+function writeCompatibilityIni(
+  dir,
+  appDir = FileUtils.getDir("CurProcD", []),
+  greDir = FileUtils.getDir("GreD", [])
+) {
+  let target = dir.clone();
+  target.append("compatibility.ini");
+
+  let factory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"].getService(
+    Ci.nsIINIParserFactory
+  );
+  let ini = factory.createINIParser().QueryInterface(Ci.nsIINIParserWriter);
+
+  // The profile service doesn't care about these so just use fixed values
+  ini.setString(
+    "Compatibility",
+    "LastVersion",
+    "64.0a1_20180919123806/20180919123806"
+  );
+  ini.setString("Compatibility", "LastOSABI", "Darwin_x86_64-gcc3");
+
+  ini.setString(
+    "Compatibility",
+    "LastPlatformDir",
+    greDir.persistentDescriptor
+  );
+  ini.setString("Compatibility", "LastAppDir", appDir.persistentDescriptor);
+
+  ini.writeFile(target);
+}
+
+/**
+ * Writes a profiles.ini based on the passed profile data.
+ * profileData should contain two properties, options and profiles.
+ * options contains a single property, startWithLastProfile.
+ * profiles is an array of profiles each containing name, path and default
+ * properties.
+ */
+function writeProfilesIni(profileData) {
+  let target = gDataHome.clone();
+  target.append("profiles.ini");
+
+  let factory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"].getService(
+    Ci.nsIINIParserFactory
+  );
+  let ini = factory.createINIParser().QueryInterface(Ci.nsIINIParserWriter);
+
+  const {
+    options = {},
+    profiles = [],
+    installs = null,
+    backgroundTasksProfiles = null,
+  } = profileData;
+
+  let { startWithLastProfile = true } = options;
+  ini.setString(
+    "General",
+    "StartWithLastProfile",
+    startWithLastProfile ? "1" : "0"
+  );
+
+  for (let i = 0; i < profiles.length; i++) {
+    let profile = profiles[i];
+    let section = `Profile${i}`;
+
+    ini.setString(section, "Name", profile.name);
+    ini.setString(section, "IsRelative", 1);
+    ini.setString(section, "Path", profile.path);
+
+    if (profile.default) {
+      ini.setString(section, "Default", "1");
+    }
+  }
+
+  if (backgroundTasksProfiles) {
+    let section = "BackgroundTasksProfiles";
+    for (let backgroundTasksProfile of backgroundTasksProfiles) {
+      ini.setString(
+        section,
+        backgroundTasksProfile.name,
+        backgroundTasksProfile.path
+      );
+    }
+  }
+
+  if (installs) {
+    ini.setString("General", "Version", "2");
+
+    for (let hash of Object.keys(installs)) {
+      ini.setString(`Install${hash}`, "Default", installs[hash].default);
+      if ("locked" in installs[hash]) {
+        ini.setString(
+          `Install${hash}`,
+          "Locked",
+          installs[hash].locked ? "1" : "0"
+        );
+      }
+    }
+
+    writeInstallsIni({ installs });
+  } else {
+    writeInstallsIni(null);
+  }
+
+  ini.writeFile(target);
+}
+
+/**
+ * Reads the existing profiles.ini into the same structure as that accepted by
+ * writeProfilesIni above. The profiles property is sorted according to name
+ * because the order is irrelevant and it makes testing easier if we can make
+ * that assumption.
+ */
+function readProfilesIni() {
+  let target = gDataHome.clone();
+  target.append("profiles.ini");
+
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [],
+    installs: null,
+  };
+
+  if (!target.exists()) {
+    return profileData;
+  }
+
+  let factory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"].getService(
+    Ci.nsIINIParserFactory
+  );
+  let ini = factory.createINIParser(target);
+
+  profileData.options.startWithLastProfile =
+    safeGet(ini, "General", "StartWithLastProfile") == "1";
+  if (safeGet(ini, "General", "Version") == "2") {
+    profileData.installs = {};
+  }
+
+  let sections = ini.getSections();
+  while (sections.hasMore()) {
+    let section = sections.getNext();
+
+    if (section == "General") {
+      continue;
+    }
+
+    if (section.startsWith("Profile")) {
+      let isRelative = safeGet(ini, section, "IsRelative");
+      if (isRelative === null) {
+        break;
+      }
+      Assert.equal(
+        isRelative,
+        "1",
+        "Paths should always be relative in these tests."
+      );
+
+      let profile = {
+        name: safeGet(ini, section, "Name"),
+        path: safeGet(ini, section, "Path"),
+      };
+
+      try {
+        profile.default = ini.getString(section, "Default") == "1";
+        Assert.ok(
+          profile.default,
+          "The Default value is only written when true."
+        );
+      } catch (e) {
+        profile.default = false;
+      }
+
+      profileData.profiles.push(profile);
+    }
+
+    if (section.startsWith("Install")) {
+      Assert.ok(
+        profileData.installs,
+        "Should only see an install section if the ini version was correct."
+      );
+
+      profileData.installs[section.substring(7)] = {
+        default: safeGet(ini, section, "Default"),
+      };
+
+      let locked = safeGet(ini, section, "Locked");
+      if (locked !== null) {
+        profileData.installs[section.substring(7)].locked = locked;
+      }
+    }
+
+    if (section == "BackgroundTasksProfiles") {
+      profileData.backgroundTasksProfiles = [];
+      let backgroundTasksProfiles = ini.getKeys(section);
+      while (backgroundTasksProfiles.hasMore()) {
+        let name = backgroundTasksProfiles.getNext();
+        let path = ini.getString(section, name);
+        profileData.backgroundTasksProfiles.push({ name, path });
+      }
+      profileData.backgroundTasksProfiles.sort((a, b) =>
+        a.name.localeCompare(b.name)
+      );
+    }
+  }
+
+  profileData.profiles.sort((a, b) => a.name.localeCompare(b.name));
+
+  return profileData;
+}
+
+/**
+ * Writes an installs.ini based on the supplied data. Should be an object with
+ * keys for every installation hash each mapping to an object. Each object
+ * should have a default property for the relative path to the profile.
+ */
+function writeInstallsIni(installData) {
+  let target = gDataHome.clone();
+  target.append("installs.ini");
+
+  if (!installData) {
+    try {
+      target.remove(false);
+    } catch (e) {}
+    return;
+  }
+
+  const { installs = {} } = installData;
+
+  let factory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"].getService(
+    Ci.nsIINIParserFactory
+  );
+  let ini = factory.createINIParser(null).QueryInterface(Ci.nsIINIParserWriter);
+
+  for (let hash of Object.keys(installs)) {
+    ini.setString(hash, "Default", installs[hash].default);
+    if ("locked" in installs[hash]) {
+      ini.setString(hash, "Locked", installs[hash].locked ? "1" : "0");
+    }
+  }
+
+  ini.writeFile(target);
+}
+
+/**
+ * Reads installs.ini into a structure like that used in the above function.
+ */
+function readInstallsIni() {
+  let target = gDataHome.clone();
+  target.append("installs.ini");
+
+  let installData = {
+    installs: {},
+  };
+
+  if (!target.exists()) {
+    return installData;
+  }
+
+  let factory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"].getService(
+    Ci.nsIINIParserFactory
+  );
+  let ini = factory.createINIParser(target);
+
+  let sections = ini.getSections();
+  while (sections.hasMore()) {
+    let hash = sections.getNext();
+    if (hash != "General") {
+      installData.installs[hash] = {
+        default: safeGet(ini, hash, "Default"),
+      };
+
+      let locked = safeGet(ini, hash, "Locked");
+      if (locked !== null) {
+        installData.installs[hash].locked = locked;
+      }
+    }
+  }
+
+  return installData;
+}
+
+/**
+ * Check that the backup data in installs.ini matches the install data in
+ * profiles.ini.
+ */
+function checkBackup(
+  profileData = readProfilesIni(),
+  installData = readInstallsIni()
+) {
+  if (!profileData.installs) {
+    // If the profiles db isn't of the right version we wouldn't expect the
+    // backup to be accurate.
+    return;
+  }
+
+  Assert.deepEqual(
+    profileData.installs,
+    installData.installs,
+    "Backup installs.ini should match installs in profiles.ini"
+  );
+}
+
+/**
+ * Checks that the profile service seems to have the right data in it compared
+ * to profile and install data structured as in the above functions.
+ */
+function checkProfileService(
+  profileData = readProfilesIni(),
+  verifyBackup = true
+) {
+  let service = getProfileService();
+
+  let expectedStartWithLast = true;
+  if ("options" in profileData) {
+    expectedStartWithLast = profileData.options.startWithLastProfile;
+  }
+
+  Assert.equal(
+    service.startWithLastProfile,
+    expectedStartWithLast,
+    "Start with last profile should match."
+  );
+
+  let serviceProfiles = Array.from(service.profiles);
+
+  Assert.equal(
+    serviceProfiles.length,
+    profileData.profiles.length,
+    "Should be the same number of profiles."
+  );
+
+  // Sort to make matching easy.
+  serviceProfiles.sort((a, b) => a.name.localeCompare(b.name));
+  profileData.profiles.sort((a, b) => a.name.localeCompare(b.name));
+
+  let hash = xreDirProvider.getInstallHash();
+  let defaultPath =
+    profileData.installs && hash in profileData.installs
+      ? profileData.installs[hash].default
+      : null;
+  let dedicatedProfile = null;
+  let legacyProfile = null;
+
+  for (let i = 0; i < serviceProfiles.length; i++) {
+    let serviceProfile = serviceProfiles[i];
+    let expectedProfile = profileData.profiles[i];
+
+    Assert.equal(
+      serviceProfile.name,
+      expectedProfile.name,
+      "Should have the same name."
+    );
+
+    let expectedPath = Cc["@mozilla.org/file/local;1"].createInstance(
+      Ci.nsIFile
+    );
+    expectedPath.setRelativeDescriptor(gDataHome, expectedProfile.path);
+    Assert.equal(
+      serviceProfile.rootDir.path,
+      expectedPath.path,
+      "Should have the same path."
+    );
+
+    if (expectedProfile.path == defaultPath) {
+      dedicatedProfile = serviceProfile;
+    }
+
+    if (AppConstants.MOZ_DEV_EDITION) {
+      if (expectedProfile.name == PROFILE_DEFAULT) {
+        legacyProfile = serviceProfile;
+      }
+    } else if (expectedProfile.default) {
+      legacyProfile = serviceProfile;
+    }
+  }
+
+  if (gIsLegacy) {
+    Assert.equal(
+      service.defaultProfile,
+      legacyProfile,
+      "Should have seen the right profile selected."
+    );
+  } else {
+    Assert.equal(
+      service.defaultProfile,
+      dedicatedProfile,
+      "Should have seen the right profile selected."
+    );
+  }
+
+  if (verifyBackup) {
+    checkBackup(profileData);
+  }
+}
+
+function checkStartupReason(expected = undefined) {
+  const tId = "startup.profile_selection_reason";
+  let scalars = TelemetryTestUtils.getProcessScalars("parent");
+
+  if (expected === undefined) {
+    Assert.ok(
+      !(tId in scalars),
+      "Startup telemetry should not have been recorded."
+    );
+    return;
+  }
+
+  if (tId in scalars) {
+    Assert.equal(
+      scalars[tId],
+      expected,
+      "Should have seen the right startup reason."
+    );
+  } else {
+    Assert.ok(false, "Startup telemetry should have been recorded.");
+  }
+}
diff --git a/toolkit/profile/xpcshell/test_check_backup.js b/toolkit/profile/xpcshell/test_check_backup.js
new file mode 100644
index 0000000000..4ca91caa1d
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_check_backup.js
@@ -0,0 +1,49 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that when the profiles DB is missing the install data we reload it.
+ */
+
+add_task(async () => {
+  let hash = xreDirProvider.getInstallHash();
+
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: "Profile1",
+        path: "Path1",
+      },
+      {
+        name: "Profile2",
+        path: "Path2",
+      },
+    ],
+  };
+
+  let installs = {
+    [hash]: {
+      default: "Path2",
+    },
+  };
+
+  writeProfilesIni(profileData);
+  writeInstallsIni({ installs });
+
+  let { profile, didCreate } = selectStartupProfile();
+  checkStartupReason("default");
+
+  // Should have added the backup data to the service, check that is true.
+  profileData.installs = installs;
+  checkProfileService(profileData);
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.equal(
+    profile.name,
+    "Profile2",
+    "Should have selected the right profile"
+  );
+});
diff --git a/toolkit/profile/xpcshell/test_claim_locked.js b/toolkit/profile/xpcshell/test_claim_locked.js
new file mode 100644
index 0000000000..bffdea39dc
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_claim_locked.js
@@ -0,0 +1,68 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that an old-style default profile already locked to a different install
+ * isn't claimed by this install.
+ */
+
+add_task(async () => {
+  let defaultProfile = makeRandomProfileDir("default");
+
+  writeCompatibilityIni(defaultProfile);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: "Foo",
+        path: defaultProfile.leafName,
+        default: true,
+      },
+    ],
+    installs: {
+      other: {
+        default: defaultProfile.leafName,
+        locked: true,
+      },
+    },
+  });
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile();
+
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    2,
+    "Should have the right number of profiles."
+  );
+
+  let hash = xreDirProvider.getInstallHash();
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    2,
+    "Should be two known installs."
+  );
+  Assert.notEqual(
+    profileData.installs[hash].default,
+    defaultProfile.leafName,
+    "Should not have marked the original default profile as the default for this install."
+  );
+  Assert.ok(
+    profileData.installs[hash].locked,
+    "Should have locked as we created this profile for this install."
+  );
+
+  checkProfileService(profileData);
+
+  Assert.ok(didCreate, "Should have created a new profile.");
+  Assert.ok(
+    !selectedProfile.rootDir.equals(defaultProfile),
+    "Should be using a different directory."
+  );
+  Assert.equal(selectedProfile.name, DEDICATED_NAME);
+});
diff --git a/toolkit/profile/xpcshell/test_clean.js b/toolkit/profile/xpcshell/test_clean.js
new file mode 100644
index 0000000000..3132d5457d
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_clean.js
@@ -0,0 +1,165 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests from a clean state.
+ * Then does some testing that creating new profiles and marking them as
+ * selected works.
+ */
+
+add_task(async () => {
+  let service = getProfileService();
+
+  let target = gDataHome.clone();
+  target.append("profiles.ini");
+  Assert.ok(!target.exists(), "profiles.ini should not exist yet.");
+  target.leafName = "installs.ini";
+  Assert.ok(!target.exists(), "installs.ini should not exist yet.");
+
+  // Create a new profile to use.
+  let newProfile = service.createProfile(null, "dedicated");
+  service.flush();
+
+  let profileData = readProfilesIni();
+
+  Assert.equal(
+    profileData.profiles.length,
+    1,
+    "Should have the right number of profiles."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, "dedicated", "Should have the right name.");
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  // The new profile hasn't been marked as the default yet!
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    0,
+    "Should be no defaults for installs yet."
+  );
+
+  checkProfileService(profileData);
+
+  Assert.ok(
+    service.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  service.startWithLastProfile = false;
+  Assert.ok(
+    !service.startWithLastProfile,
+    "Should be set to not start with the last profile."
+  );
+
+  service.defaultProfile = newProfile;
+  service.flush();
+
+  profileData = readProfilesIni();
+
+  Assert.equal(
+    profileData.profiles.length,
+    1,
+    "Should have the right number of profiles."
+  );
+
+  profile = profileData.profiles[0];
+  Assert.equal(profile.name, "dedicated", "Should have the right name.");
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  let hash = xreDirProvider.getInstallHash();
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should be only one known install."
+  );
+  Assert.equal(
+    profileData.installs[hash].default,
+    profileData.profiles[0].path,
+    "Should have marked the new profile as the default for this install."
+  );
+
+  checkProfileService(profileData);
+
+  let otherProfile = service.createProfile(null, "another");
+  service.defaultProfile = otherProfile;
+
+  service.flush();
+
+  profileData = readProfilesIni();
+
+  Assert.equal(
+    profileData.profiles.length,
+    2,
+    "Should have the right number of profiles."
+  );
+
+  profile = profileData.profiles[0];
+  Assert.equal(profile.name, "another", "Should have the right name.");
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  profile = profileData.profiles[1];
+  Assert.equal(profile.name, "dedicated", "Should have the right name.");
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should be only one known install."
+  );
+  Assert.equal(
+    profileData.installs[hash].default,
+    profileData.profiles[0].path,
+    "Should have marked the new profile as the default for this install."
+  );
+
+  checkProfileService(profileData);
+
+  newProfile.remove(true);
+  service.flush();
+
+  profileData = readProfilesIni();
+
+  Assert.equal(
+    profileData.profiles.length,
+    1,
+    "Should have the right number of profiles."
+  );
+
+  profile = profileData.profiles[0];
+  Assert.equal(profile.name, "another", "Should have the right name.");
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should be only one known install."
+  );
+  Assert.equal(
+    profileData.installs[hash].default,
+    profileData.profiles[0].path,
+    "Should have marked the new profile as the default for this install."
+  );
+
+  checkProfileService(profileData);
+
+  otherProfile.remove(true);
+  service.flush();
+
+  profileData = readProfilesIni();
+
+  Assert.equal(
+    profileData.profiles.length,
+    0,
+    "Should have the right number of profiles."
+  );
+
+  // We leave a reference to the missing profile to stop us trying to steal the
+  // old-style default profile on next startup.
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should be only one known install."
+  );
+
+  checkProfileService(profileData);
+});
diff --git a/toolkit/profile/xpcshell/test_conflict_installs.js b/toolkit/profile/xpcshell/test_conflict_installs.js
new file mode 100644
index 0000000000..741e7ed70f
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_conflict_installs.js
@@ -0,0 +1,40 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that the profile service refuses to flush when the install.ini file
+ * has been modified.
+ */
+
+function check_unchanged(service) {
+  Assert.ok(
+    !service.isListOutdated,
+    "Should not have detected a modification."
+  );
+  try {
+    service.flush();
+    Assert.ok(true, "Should have flushed.");
+  } catch (e) {
+    Assert.ok(false, "Should have succeeded flushing.");
+  }
+}
+
+add_task(async () => {
+  let service = getProfileService();
+
+  Assert.ok(!service.isListOutdated, "Should not be modified yet.");
+
+  let installsini = gDataHome.clone();
+  installsini.append("installs.ini");
+
+  Assert.ok(!installsini.exists(), "File should not exist yet.");
+  installsini.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o644);
+
+  installsini.remove(false);
+  // We have to do profile selection to actually have any install data.
+  selectStartupProfile();
+  check_unchanged(service);
+
+  // We can't reset the modification time back to exactly what it was, so I
+  // guess we can't do much more here :(
+});
diff --git a/toolkit/profile/xpcshell/test_conflict_profiles.js b/toolkit/profile/xpcshell/test_conflict_profiles.js
new file mode 100644
index 0000000000..7028c1d5c2
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_conflict_profiles.js
@@ -0,0 +1,57 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that the profile service refuses to flush when the profiles.ini file
+ * has been modified.
+ */
+
+function check_unchanged(service) {
+  Assert.ok(
+    !service.isListOutdated,
+    "Should not have detected a modification."
+  );
+  try {
+    service.flush();
+    Assert.ok(true, "Should have flushed.");
+  } catch (e) {
+    Assert.ok(false, "Should have succeeded flushing.");
+  }
+}
+
+function check_outdated(service) {
+  Assert.ok(service.isListOutdated, "Should have detected a modification.");
+  try {
+    service.flush();
+    Assert.ok(false, "Should have failed to flush.");
+  } catch (e) {
+    Assert.equal(
+      e.result,
+      Cr.NS_ERROR_DATABASE_CHANGED,
+      "Should have refused to flush."
+    );
+  }
+}
+
+add_task(async () => {
+  let service = getProfileService();
+
+  Assert.ok(!service.isListOutdated, "Should not be modified yet.");
+
+  let profilesini = gDataHome.clone();
+  profilesini.append("profiles.ini");
+
+  Assert.ok(!profilesini.exists(), "File should not exist yet.");
+  profilesini.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o644);
+  check_outdated(service);
+
+  profilesini.remove(false);
+  check_unchanged(service);
+
+  let oldTime = profilesini.lastModifiedTime;
+  profilesini.lastModifiedTime = oldTime - 10000;
+  check_outdated(service);
+
+  // We can't reset the modification time back to exactly what it was, so I
+  // guess we can't do much more here :(
+});
diff --git a/toolkit/profile/xpcshell/test_create_default.js b/toolkit/profile/xpcshell/test_create_default.js
new file mode 100644
index 0000000000..cdac1832bf
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_create_default.js
@@ -0,0 +1,52 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that from an empty database a default profile is created.
+ */
+
+add_task(async () => {
+  let service = getProfileService();
+  let { profile, didCreate } = selectStartupProfile();
+
+  checkStartupReason("firstrun-created-default");
+
+  let profileData = readProfilesIni();
+  checkProfileService(profileData);
+
+  Assert.ok(didCreate, "Should have created a new profile.");
+  Assert.equal(
+    profile,
+    service.defaultProfile,
+    "Should now be the default profile."
+  );
+  Assert.equal(
+    profile.name,
+    DEDICATED_NAME,
+    "Should have created a new profile with the right name."
+  );
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    2,
+    "Should have the right number of profiles."
+  );
+
+  profile = profileData.profiles[0];
+  Assert.equal(profile.name, "default", "Should have the right name.");
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+
+  profile = profileData.profiles[1];
+  Assert.equal(profile.name, DEDICATED_NAME, "Should have the right name.");
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  let hash = xreDirProvider.getInstallHash();
+  Assert.ok(
+    profileData.installs[hash].locked,
+    "Should have locked the profile"
+  );
+});
diff --git a/toolkit/profile/xpcshell/test_fix_directory_case.js b/toolkit/profile/xpcshell/test_fix_directory_case.js
new file mode 100644
index 0000000000..60e3acbe4e
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_fix_directory_case.js
@@ -0,0 +1,113 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Tests the case where the user has an default profile set for the legacy
+ * install hash. This should be switched to the new hash and correctly used as
+ * the default.
+ */
+
+add_task(async () => {
+  let currentHash = xreDirProvider.getInstallHash();
+  let legacyHash = "F87E39E944FE466E";
+
+  let defaultProfile = makeRandomProfileDir("default");
+  let dedicatedProfile = makeRandomProfileDir("dedicated");
+  let devProfile = makeRandomProfileDir("devedition");
+
+  // Make sure we don't steal the old-style default.
+  writeCompatibilityIni(defaultProfile);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: "default",
+        path: defaultProfile.leafName,
+        default: true,
+      },
+      {
+        name: "dedicated",
+        path: dedicatedProfile.leafName,
+      },
+      {
+        name: "dev-edition-default",
+        path: devProfile.leafName,
+      },
+    ],
+    installs: {
+      [legacyHash]: {
+        default: dedicatedProfile.leafName,
+      },
+      otherhash: {
+        default: "foobar",
+      },
+    },
+  });
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile(
+    [],
+    false,
+    legacyHash
+  );
+  checkStartupReason("default");
+
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    3,
+    "Should have the right number of profiles."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, `dedicated`, "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    dedicatedProfile.leafName,
+    "Should be the expected dedicated profile."
+  );
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  profile = profileData.profiles[1];
+  Assert.equal(profile.name, "default", "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    3,
+    "Should be three known installs."
+  );
+  Assert.equal(
+    profileData.installs[currentHash].default,
+    dedicatedProfile.leafName,
+    "Should have switched to the new install hash."
+  );
+  Assert.equal(
+    profileData.installs[legacyHash].default,
+    dedicatedProfile.leafName,
+    "Should have kept the old install hash."
+  );
+  Assert.equal(
+    profileData.installs.otherhash.default,
+    "foobar",
+    "Should have kept the default for the other install."
+  );
+
+  checkProfileService(profileData);
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(
+    selectedProfile.rootDir.equals(dedicatedProfile),
+    "Should be using the right directory."
+  );
+  Assert.equal(selectedProfile.name, "dedicated");
+});
diff --git a/toolkit/profile/xpcshell/test_ignore_legacy_directory.js b/toolkit/profile/xpcshell/test_ignore_legacy_directory.js
new file mode 100644
index 0000000000..29b1601cc5
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_ignore_legacy_directory.js
@@ -0,0 +1,129 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Tests the case where the user has an default profile set for both the legacy
+ * and new install hash. This should just use the default for the new install
+ * hash.
+ */
+
+add_task(async () => {
+  let currentHash = xreDirProvider.getInstallHash();
+  let legacyHash = "F87E39E944FE466E";
+
+  let defaultProfile = makeRandomProfileDir("default");
+  let dedicatedProfile = makeRandomProfileDir("dedicated");
+  let devProfile = makeRandomProfileDir("devedition");
+
+  // Make sure we don't steal the old-style default.
+  writeCompatibilityIni(defaultProfile);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: "default",
+        path: defaultProfile.leafName,
+        default: true,
+      },
+      {
+        name: "dedicated",
+        path: dedicatedProfile.leafName,
+      },
+      {
+        name: "dev-edition-default",
+        path: devProfile.leafName,
+      },
+    ],
+    installs: {
+      [legacyHash]: {
+        default: defaultProfile.leafName,
+      },
+      [currentHash]: {
+        default: dedicatedProfile.leafName,
+      },
+      otherhash: {
+        default: "foobar",
+      },
+    },
+  });
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile(
+    [],
+    false,
+    legacyHash
+  );
+  checkStartupReason("default");
+
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    3,
+    "Should have the right number of profiles."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, `dedicated`, "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    dedicatedProfile.leafName,
+    "Should be the expected dedicated profile."
+  );
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  profile = profileData.profiles[1];
+  Assert.equal(profile.name, "default", "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+
+  profile = profileData.profiles[2];
+  Assert.equal(
+    profile.name,
+    "dev-edition-default",
+    "Should have the right name."
+  );
+  Assert.equal(
+    profile.path,
+    devProfile.leafName,
+    "Should not be the original default profile."
+  );
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    3,
+    "Should be three known installs."
+  );
+  Assert.equal(
+    profileData.installs[currentHash].default,
+    dedicatedProfile.leafName,
+    "Should have switched to the new install hash."
+  );
+  Assert.equal(
+    profileData.installs[legacyHash].default,
+    defaultProfile.leafName,
+    "Should have ignored old install hash."
+  );
+  Assert.equal(
+    profileData.installs.otherhash.default,
+    "foobar",
+    "Should have kept the default for the other install."
+  );
+
+  checkProfileService(profileData);
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(
+    selectedProfile.rootDir.equals(dedicatedProfile),
+    "Should be using the right directory."
+  );
+  Assert.equal(selectedProfile.name, "dedicated");
+});
diff --git a/toolkit/profile/xpcshell/test_invalid_descriptor.js b/toolkit/profile/xpcshell/test_invalid_descriptor.js
new file mode 100644
index 0000000000..87638d301d
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_invalid_descriptor.js
@@ -0,0 +1,55 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * If a user has modified a relative profile path then there may be issues where
+ * the profile default setting doesn't match.
+ */
+
+add_task(async () => {
+  let hash = xreDirProvider.getInstallHash();
+
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: "Profile1",
+        path: "../data/test",
+      },
+      {
+        name: "Profile2",
+        path: "Path2",
+      },
+    ],
+    installs: {
+      [hash]: {
+        default: "test",
+      },
+    },
+  };
+
+  writeProfilesIni(profileData);
+
+  let { profile, didCreate } = selectStartupProfile();
+  checkStartupReason("default");
+
+  let service = getProfileService();
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.equal(
+    profile.name,
+    "Profile1",
+    "Should have selected the expected profile"
+  );
+
+  Assert.equal(
+    profile.name,
+    service.defaultProfile.name,
+    "Should have selected the right default."
+  );
+
+  service.flush();
+  checkProfileService();
+});
diff --git a/toolkit/profile/xpcshell/test_legacy_empty.js b/toolkit/profile/xpcshell/test_legacy_empty.js
new file mode 100644
index 0000000000..7348006f8b
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_legacy_empty.js
@@ -0,0 +1,28 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that setting MOZ_LEGACY_PROFILES disables dedicated profiles.
+ */
+
+add_task(async () => {
+  enableLegacyProfiles();
+
+  let service = getProfileService();
+  let { profile, didCreate } = selectStartupProfile();
+  checkStartupReason("firstrun-created-default");
+
+  Assert.ok(didCreate, "Should have created a new profile.");
+  Assert.equal(
+    profile.name,
+    PROFILE_DEFAULT,
+    "Should have used the normal name."
+  );
+  if (AppConstants.MOZ_DEV_EDITION) {
+    Assert.equal(service.profileCount, 2, "Should be two profiles.");
+  } else {
+    Assert.equal(service.profileCount, 1, "Should be only one profile.");
+  }
+
+  checkProfileService();
+});
diff --git a/toolkit/profile/xpcshell/test_legacy_select.js b/toolkit/profile/xpcshell/test_legacy_select.js
new file mode 100644
index 0000000000..e919169d59
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_legacy_select.js
@@ -0,0 +1,67 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that an old-style default profile not previously used by this build
+ * gets selected when configured for legacy profiles.
+ */
+
+add_task(async () => {
+  let defaultProfile = makeRandomProfileDir("default");
+
+  // Just pretend this profile was last used by something in the profile dir.
+  let greDir = gProfD.clone();
+  greDir.append("app");
+  writeCompatibilityIni(defaultProfile, greDir, greDir);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: PROFILE_DEFAULT,
+        path: defaultProfile.leafName,
+        default: true,
+      },
+    ],
+  });
+
+  enableLegacyProfiles();
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile();
+  checkStartupReason("default");
+
+  let profileData = readProfilesIni();
+  let installsINI = gDataHome.clone();
+  installsINI.append("installs.ini");
+  Assert.ok(
+    !installsINI.exists(),
+    "Installs database should not have been created."
+  );
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    1,
+    "Should have the right number of profiles."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, PROFILE_DEFAULT, "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+
+  checkProfileService(profileData);
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(
+    selectedProfile.rootDir.equals(defaultProfile),
+    "Should be using the right directory."
+  );
+  Assert.equal(selectedProfile.name, PROFILE_DEFAULT);
+});
diff --git a/toolkit/profile/xpcshell/test_lock.js b/toolkit/profile/xpcshell/test_lock.js
new file mode 100644
index 0000000000..7283406e00
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_lock.js
@@ -0,0 +1,72 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that when the default application claims the old-style default profile
+ * it locks it to itself.
+ */
+
+add_task(async () => {
+  gIsDefaultApp = true;
+  let defaultProfile = makeRandomProfileDir("default");
+
+  writeCompatibilityIni(defaultProfile);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: PROFILE_DEFAULT,
+        path: defaultProfile.leafName,
+        default: true,
+      },
+    ],
+  });
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile();
+
+  let hash = xreDirProvider.getInstallHash();
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    1,
+    "Should have the right number of profiles."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, PROFILE_DEFAULT, "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should be only one known install."
+  );
+  Assert.equal(
+    profileData.installs[hash].default,
+    defaultProfile.leafName,
+    "Should have marked the original default profile as the default for this install."
+  );
+  Assert.ok(
+    profileData.installs[hash].locked,
+    "Should have locked as we're the default app."
+  );
+
+  checkProfileService(profileData);
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(
+    selectedProfile.rootDir.equals(defaultProfile),
+    "Should be using the right directory."
+  );
+  Assert.equal(selectedProfile.name, PROFILE_DEFAULT);
+});
diff --git a/toolkit/profile/xpcshell/test_missing_profilesini.js b/toolkit/profile/xpcshell/test_missing_profilesini.js
new file mode 100644
index 0000000000..c1602aeb06
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_missing_profilesini.js
@@ -0,0 +1,55 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * When profiles.ini is missing there isn't any point in restoring from any
+ * installs.ini, the profiles it refers to are gone anyway.
+ */
+
+add_task(async () => {
+  let hash = xreDirProvider.getInstallHash();
+
+  let installs = {
+    [hash]: {
+      default: "Path2",
+    },
+    otherhash: {
+      default: "foo",
+    },
+    anotherhash: {
+      default: "bar",
+    },
+  };
+
+  writeInstallsIni({ installs });
+
+  let { profile, didCreate } = selectStartupProfile();
+  checkStartupReason("firstrun-created-default");
+
+  Assert.ok(didCreate, "Should have created a new profile.");
+  Assert.equal(
+    profile.name,
+    DEDICATED_NAME,
+    "Should have created the right profile"
+  );
+
+  let profilesData = readProfilesIni();
+  Assert.equal(
+    Object.keys(profilesData.installs).length,
+    1,
+    "Should be only one known install"
+  );
+  Assert.ok(hash in profilesData.installs, "Should be the expected install.");
+  Assert.notEqual(
+    profilesData.installs[hash].default,
+    "Path2",
+    "Didn't import the previous data."
+  );
+  Assert.equal(
+    profilesData.profiles.length,
+    2,
+    "Should be two profiles (old-style default and dedicated default)."
+  );
+
+  checkProfileService(profilesData);
+});
diff --git a/toolkit/profile/xpcshell/test_new_default.js b/toolkit/profile/xpcshell/test_new_default.js
new file mode 100644
index 0000000000..71dfe252c3
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_new_default.js
@@ -0,0 +1,122 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that an old-style default profile previously used by this build gets
+ * updated to a dedicated profile for this build.
+ */
+
+add_task(async () => {
+  let mydefaultProfile = makeRandomProfileDir("mydefault");
+  let defaultProfile = makeRandomProfileDir("default");
+  let devDefaultProfile = makeRandomProfileDir("devedition");
+
+  writeCompatibilityIni(mydefaultProfile);
+  writeCompatibilityIni(devDefaultProfile);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: "mydefault",
+        path: mydefaultProfile.leafName,
+        default: true,
+      },
+      {
+        name: "default",
+        path: defaultProfile.leafName,
+      },
+      {
+        name: "dev-edition-default",
+        path: devDefaultProfile.leafName,
+      },
+    ],
+  });
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile();
+  checkStartupReason("firstrun-claimed-default");
+
+  let hash = xreDirProvider.getInstallHash();
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    3,
+    "Should have the right number of profiles."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, "default", "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original non-default profile."
+  );
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  profile = profileData.profiles[1];
+  Assert.equal(
+    profile.name,
+    "dev-edition-default",
+    "Should have the right name."
+  );
+  Assert.equal(
+    profile.path,
+    devDefaultProfile.leafName,
+    "Should be the original dev default profile."
+  );
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  profile = profileData.profiles[2];
+  Assert.equal(profile.name, "mydefault", "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    mydefaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should be only one known install."
+  );
+  if (AppConstants.MOZ_DEV_EDITION) {
+    Assert.equal(
+      profileData.installs[hash].default,
+      devDefaultProfile.leafName,
+      "Should have marked the original dev default profile as the default for this install."
+    );
+  } else {
+    Assert.equal(
+      profileData.installs[hash].default,
+      mydefaultProfile.leafName,
+      "Should have marked the original default profile as the default for this install."
+    );
+  }
+
+  Assert.ok(
+    !profileData.installs[hash].locked,
+    "Should not be locked as we're not the default app."
+  );
+
+  checkProfileService(profileData);
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  if (AppConstants.MOZ_DEV_EDITION) {
+    Assert.ok(
+      selectedProfile.rootDir.equals(devDefaultProfile),
+      "Should be using the right directory."
+    );
+    Assert.equal(selectedProfile.name, "dev-edition-default");
+  } else {
+    Assert.ok(
+      selectedProfile.rootDir.equals(mydefaultProfile),
+      "Should be using the right directory."
+    );
+    Assert.equal(selectedProfile.name, "mydefault");
+  }
+});
diff --git a/toolkit/profile/xpcshell/test_previous_dedicated.js b/toolkit/profile/xpcshell/test_previous_dedicated.js
new file mode 100644
index 0000000000..6dd80b4028
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_previous_dedicated.js
@@ -0,0 +1,62 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * If install.ini lists a default profile for this build but that profile no
+ * longer exists don't try to steal the old-style default even if it was used
+ * by this build. It means this install has previously used dedicated profiles.
+ */
+
+add_task(async () => {
+  let hash = xreDirProvider.getInstallHash();
+  let defaultProfile = makeRandomProfileDir("default");
+
+  writeCompatibilityIni(defaultProfile);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: "default",
+        path: defaultProfile.leafName,
+        default: true,
+      },
+    ],
+    installs: {
+      [hash]: {
+        default: "foobar",
+      },
+    },
+  });
+
+  testStartsProfileManager();
+
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    1,
+    "Should have the right number of profiles."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, "default", "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+
+  // We keep the data here so we don't steal on the next reboot...
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Still list the broken reference."
+  );
+
+  checkProfileService(profileData);
+});
diff --git a/toolkit/profile/xpcshell/test_profile_reset.js b/toolkit/profile/xpcshell/test_profile_reset.js
new file mode 100644
index 0000000000..7cfb5ed3d1
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_profile_reset.js
@@ -0,0 +1,59 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that from an empty database with profile reset requested a new profile
+ * is still created.
+ */
+
+add_task(async () => {
+  let { profile: selectedProfile, didCreate } = selectStartupProfile([], true);
+  // With no profile we're just create a new profile and skip resetting it.
+  checkStartupReason("firstrun-created-default");
+  checkProfileService();
+
+  let hash = xreDirProvider.getInstallHash();
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    2,
+    "Should have the right number of profiles, ours and the old-style default."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, "default", "Should have the right name.");
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+
+  profile = profileData.profiles[1];
+  Assert.equal(profile.name, DEDICATED_NAME, "Should have the right name.");
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should only be one known installs."
+  );
+  Assert.equal(
+    profileData.installs[hash].default,
+    profile.path,
+    "Should have taken the new profile as the default for the current install."
+  );
+  Assert.ok(
+    profileData.installs[hash].locked,
+    "Should have locked as we created this profile."
+  );
+
+  checkProfileService(profileData);
+
+  Assert.ok(didCreate, "Should have created a new profile.");
+  Assert.equal(
+    selectedProfile.name,
+    profile.name,
+    "Should be using the right profile."
+  );
+});
diff --git a/toolkit/profile/xpcshell/test_register_app_services_logger.js b/toolkit/profile/xpcshell/test_register_app_services_logger.js
new file mode 100644
index 0000000000..cf777c4c6c
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_register_app_services_logger.js
@@ -0,0 +1,26 @@
+let waitForDebugLog = target =>
+  new Promise(resolve => {
+    Cc["@mozilla.org/appservices/logger;1"]
+      .getService(Ci.mozIAppServicesLogger)
+      .register(target, {
+        maxLevel: Ci.mozIServicesLogSink.LEVEL_INFO,
+        info: resolve,
+      });
+  });
+
+let rustLog = (target, message) => {
+  Cc["@mozilla.org/xpcom/debug;1"]
+    .getService(Ci.nsIDebug2)
+    .rustLog(target, message);
+};
+
+add_task(async () => {
+  let target = "app-services:webext_storage:sync";
+  let expectedMessage = "info error: uh oh";
+  let promiseMessage = waitForDebugLog(target);
+
+  rustLog(target, expectedMessage);
+
+  let actualMessage = await promiseMessage;
+  Assert.ok(actualMessage.includes(expectedMessage));
+});
diff --git a/toolkit/profile/xpcshell/test_remove.js b/toolkit/profile/xpcshell/test_remove.js
new file mode 100644
index 0000000000..8b5025d612
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_remove.js
@@ -0,0 +1,103 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests adding and removing functions correctly.
+ */
+
+function compareLists(service, knownProfiles) {
+  Assert.equal(
+    service.profileCount,
+    knownProfiles.length,
+    "profileCount should be correct."
+  );
+  let serviceProfiles = Array.from(service.profiles);
+  Assert.equal(
+    serviceProfiles.length,
+    knownProfiles.length,
+    "Enumerator length should be correct."
+  );
+
+  for (let i = 0; i < knownProfiles.length; i++) {
+    // Cannot use strictEqual here, it attempts to print out a string
+    // representation of the profile objects and on some platforms that recurses
+    // infinitely.
+    Assert.ok(
+      serviceProfiles[i] === knownProfiles[i],
+      `Should have the right profile in position ${i}.`
+    );
+  }
+}
+
+function removeProfile(profiles, position) {
+  dump(`Removing profile in position ${position}.`);
+  Assert.greaterOrEqual(position, 0, "Should be removing a valid position.");
+  Assert.less(
+    position,
+    profiles.length,
+    "Should be removing a valid position."
+  );
+
+  let last = profiles.pop();
+
+  if (profiles.length == position) {
+    // We were asked to remove the last profile.
+    last.remove(false);
+    return;
+  }
+
+  profiles[position].remove(false);
+  profiles[position] = last;
+}
+
+add_task(async () => {
+  let service = getProfileService();
+  let profiles = [];
+  compareLists(service, profiles);
+
+  profiles.push(service.createProfile(null, "profile1"));
+  profiles.push(service.createProfile(null, "profile2"));
+  profiles.push(service.createProfile(null, "profile3"));
+  profiles.push(service.createProfile(null, "profile4"));
+  profiles.push(service.createProfile(null, "profile5"));
+  profiles.push(service.createProfile(null, "profile6"));
+  profiles.push(service.createProfile(null, "profile7"));
+  profiles.push(service.createProfile(null, "profile8"));
+  profiles.push(service.createProfile(null, "profile9"));
+  compareLists(service, profiles);
+
+  // Test removing the first profile.
+  removeProfile(profiles, 0);
+  compareLists(service, profiles);
+
+  // And the last profile.
+  removeProfile(profiles, profiles.length - 1);
+  compareLists(service, profiles);
+
+  // Last but one...
+  removeProfile(profiles, profiles.length - 2);
+  compareLists(service, profiles);
+
+  // Second one...
+  removeProfile(profiles, 1);
+  compareLists(service, profiles);
+
+  // Something in the middle.
+  removeProfile(profiles, 2);
+  compareLists(service, profiles);
+
+  let expectedNames = ["profile9", "profile7", "profile5", "profile4"];
+
+  let serviceProfiles = Array.from(service.profiles);
+  for (let i = 0; i < expectedNames.length; i++) {
+    Assert.equal(serviceProfiles[i].name, expectedNames[i]);
+  }
+
+  removeProfile(profiles, 0);
+  removeProfile(profiles, 0);
+  removeProfile(profiles, 0);
+  removeProfile(profiles, 0);
+
+  Assert.equal(Array.from(service.profiles).length, 0, "All profiles gone.");
+  Assert.equal(service.profileCount, 0, "All profiles gone.");
+});
diff --git a/toolkit/profile/xpcshell/test_remove_default.js b/toolkit/profile/xpcshell/test_remove_default.js
new file mode 100644
index 0000000000..f77f2d87d9
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_remove_default.js
@@ -0,0 +1,79 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Tests that calling nsIToolkitProfile.remove on the default profile correctly
+ * removes the profile.
+ */
+
+add_task(async () => {
+  let hash = xreDirProvider.getInstallHash();
+  let defaultProfile = makeRandomProfileDir("default");
+
+  let profilesIni = {
+    profiles: [
+      {
+        name: "default",
+        path: defaultProfile.leafName,
+        default: true,
+      },
+    ],
+    installs: {
+      [hash]: {
+        default: defaultProfile.leafName,
+      },
+    },
+  };
+  writeProfilesIni(profilesIni);
+
+  let service = getProfileService();
+  checkProfileService(profilesIni);
+
+  let { profile, didCreate } = selectStartupProfile();
+  Assert.ok(!didCreate, "Should have not created a new profile.");
+  Assert.equal(
+    profile.name,
+    "default",
+    "Should have selected the default profile."
+  );
+  Assert.equal(
+    profile,
+    service.defaultProfile,
+    "Should have selected the default profile."
+  );
+
+  checkProfileService(profilesIni);
+
+  // In an actual run of Firefox we wouldn't be able to delete the profile in
+  // use because it would be locked. But we don't actually lock the profile in
+  // tests.
+  profile.remove(false);
+
+  Assert.ok(!service.defaultProfile, "Should no longer be a default profile.");
+  Assert.equal(
+    profile,
+    service.currentProfile,
+    "Should still be the profile in use."
+  );
+
+  // These are the modifications that should have been made.
+  profilesIni.profiles.pop();
+  profilesIni.installs[hash].default = "";
+
+  // The data isn't flushed to disk so don't check the backup here.
+  checkProfileService(profilesIni, false);
+
+  service.flush();
+
+  // And that should have flushed to disk correctly.
+  checkProfileService();
+
+  // checkProfileService doesn't differentiate between a blank default profile
+  // for the install and a missing install.
+  profilesIni = readProfilesIni();
+  Assert.equal(
+    profilesIni.installs[hash].default,
+    "",
+    "Should be a blank default profile."
+  );
+});
diff --git a/toolkit/profile/xpcshell/test_select_backgroundtasks_ephemeral.js b/toolkit/profile/xpcshell/test_select_backgroundtasks_ephemeral.js
new file mode 100644
index 0000000000..982df276db
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_select_backgroundtasks_ephemeral.js
@@ -0,0 +1,30 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Verify that background tasks don't touch `profiles.ini` for ephemeral profile
+ * tasks.
+ */
+
+let condition = {
+  skip_if: () => !AppConstants.MOZ_BACKGROUNDTASKS,
+};
+
+add_task(condition, async () => {
+  writeProfilesIni(BACKGROUNDTASKS_PROFILE_DATA);
+
+  // Pretend that this is a background task.  For a task that uses an ephemeral
+  // profile, `profiles.ini` is untouched.
+  const bts = Cc["@mozilla.org/backgroundtasks;1"].getService(
+    Ci.nsIBackgroundTasks
+  );
+  bts.overrideBackgroundTaskNameForTesting("ephemeral_profile");
+
+  let { didCreate } = selectStartupProfile();
+  checkStartupReason("backgroundtask-ephemeral");
+
+  Assert.equal(didCreate, true, "Created new ephemeral profile");
+
+  let profileData = readProfilesIni();
+  Assert.deepEqual(BACKGROUNDTASKS_PROFILE_DATA, profileData);
+});
diff --git a/toolkit/profile/xpcshell/test_select_backgroundtasks_not_ephemeral_create.js b/toolkit/profile/xpcshell/test_select_backgroundtasks_not_ephemeral_create.js
new file mode 100644
index 0000000000..ebed889360
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_select_backgroundtasks_not_ephemeral_create.js
@@ -0,0 +1,78 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Verify that background tasks that create non-ephemeral profiles update
+ * `profiles.ini` with a salted profile location.
+ */
+
+let condition = {
+  skip_if: () => !AppConstants.MOZ_BACKGROUNDTASKS,
+};
+
+// MOZ_APP_VENDOR is empty on Thunderbird.
+let vendor = AppConstants.MOZ_APP_NAME == "thunderbird" ? "" : "Mozilla";
+
+add_task(condition, async () => {
+  let hash = xreDirProvider.getInstallHash();
+
+  writeProfilesIni(BACKGROUNDTASKS_PROFILE_DATA);
+
+  // Pretend that this is a background task.  For a task that does *not* use an
+  // ephemeral profile, i.e., that uses a persistent profile, `profiles.ini` is
+  // updated with a new entry in section `BackgroundTaskProfiles`.
+  const bts = Cc["@mozilla.org/backgroundtasks;1"].getService(
+    Ci.nsIBackgroundTasks
+  );
+  // "not_ephemeral_profile" is a special name recognized by the
+  // background task system.
+  bts.overrideBackgroundTaskNameForTesting("not_ephemeral_profile");
+
+  let { didCreate, rootDir } = selectStartupProfile();
+  checkStartupReason("backgroundtask-not-ephemeral");
+
+  Assert.equal(didCreate, true, "Created new non-ephemeral profile");
+
+  let profileData = readProfilesIni();
+
+  // Profile names are lexicographically ordered, and `not_ephemeral_profile`
+  // sorts before `unrelated_task`.
+  Assert.equal(profileData.backgroundTasksProfiles.length, 2);
+  Assert.deepEqual(
+    [profileData.backgroundTasksProfiles[1]],
+    BACKGROUNDTASKS_PROFILE_DATA.backgroundTasksProfiles
+  );
+
+  let saltedPath = profileData.backgroundTasksProfiles[0].path;
+  Assert.ok(
+    saltedPath.endsWith(
+      `.${vendor}BackgroundTask-${hash}-not_ephemeral_profile`
+    ),
+    `${saltedPath} ends with ".${vendor}BackgroundTask-${hash}-not_ephemeral_profile"`
+  );
+  Assert.ok(
+    !saltedPath.startsWith(
+      `.${vendor}BackgroundTask-${hash}-not_ephemeral_profile`
+    ),
+    `${saltedPath} is really salted`
+  );
+  Assert.deepEqual(profileData.backgroundTasksProfiles[0], {
+    name: `${vendor}BackgroundTask-${hash}-not_ephemeral_profile`,
+    path: saltedPath,
+  });
+
+  Assert.ok(
+    rootDir.path.endsWith(saltedPath),
+    `rootDir "${rootDir.path}" ends with salted path "${saltedPath}"`
+  );
+
+  // Really, "UAppData", but this is xpcshell.
+  let backgroundTasksProfilesPath = gDataHome;
+  if (!AppConstants.XP_UNIX || AppConstants.platform === "macosx") {
+    backgroundTasksProfilesPath.append("Background Tasks Profiles");
+  }
+  Assert.ok(
+    rootDir.path.startsWith(backgroundTasksProfilesPath.path),
+    `rootDir "${rootDir.path}" is sibling to user profiles directory ${backgroundTasksProfilesPath}`
+  );
+});
diff --git a/toolkit/profile/xpcshell/test_select_backgroundtasks_not_ephemeral_exists.js b/toolkit/profile/xpcshell/test_select_backgroundtasks_not_ephemeral_exists.js
new file mode 100644
index 0000000000..6fa3ec5882
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_select_backgroundtasks_not_ephemeral_exists.js
@@ -0,0 +1,66 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Verify that background tasks that use non-ephemeral profiles re-use existing
+ * salted profile locations from `profiles.ini`.
+ */
+
+let condition = {
+  skip_if: () => !AppConstants.MOZ_BACKGROUNDTASKS,
+};
+
+// MOZ_APP_VENDOR is empty on Thunderbird.
+let vendor = AppConstants.MOZ_APP_NAME == "thunderbird" ? "" : "Mozilla";
+
+add_task(condition, async () => {
+  let hash = xreDirProvider.getInstallHash();
+
+  let saltedPath = `saltSALT.${vendor}BackgroundTask-${hash}-not_ephemeral_profile`;
+
+  // See note about ordering below.
+  BACKGROUNDTASKS_PROFILE_DATA.backgroundTasksProfiles.splice(0, 0, {
+    name: `${vendor}BackgroundTask-${hash}-not_ephemeral_profile`,
+    path: saltedPath,
+  });
+
+  writeProfilesIni(BACKGROUNDTASKS_PROFILE_DATA);
+
+  // Pretend that this is a background task.  For a task that does *not* use an
+  // ephemeral profile, i.e., that uses a persistent profile, when
+  // `profiles.ini` section `BackgroundTasksProfiles` contains the relevant
+  // entry, that profile path is re-used.
+  const bts = Cc["@mozilla.org/backgroundtasks;1"].getService(
+    Ci.nsIBackgroundTasks
+  );
+  // "not_ephemeral_profile" is a special name recognized by the
+  // background task system.
+  bts.overrideBackgroundTaskNameForTesting("not_ephemeral_profile");
+
+  let { didCreate, rootDir } = selectStartupProfile();
+  checkStartupReason("backgroundtask-not-ephemeral");
+
+  Assert.equal(didCreate, false, "Re-used existing non-ephemeral profile");
+
+  let profileData = readProfilesIni();
+
+  // Profile names are lexicographically ordered, and `not_ephemeral_profile`
+  // sorts before `unrelated_task`.
+  Assert.equal(profileData.backgroundTasksProfiles.length, 2);
+  Assert.deepEqual(profileData, BACKGROUNDTASKS_PROFILE_DATA);
+
+  Assert.ok(
+    rootDir.path.endsWith(saltedPath),
+    `rootDir "${rootDir.path}" ends with salted path "${saltedPath}"`
+  );
+
+  // Really, "UAppData", but this is xpcshell.
+  let backgroundTasksProfilesPath = gDataHome;
+  if (!AppConstants.XP_UNIX || AppConstants.platform === "macosx") {
+    backgroundTasksProfilesPath.append("Background Tasks Profiles");
+  }
+  Assert.ok(
+    rootDir.path.startsWith(backgroundTasksProfilesPath.path),
+    `rootDir "${rootDir.path}" is sibling to user profiles directory ${backgroundTasksProfilesPath}`
+  );
+});
diff --git a/toolkit/profile/xpcshell/test_select_default.js b/toolkit/profile/xpcshell/test_select_default.js
new file mode 100644
index 0000000000..df4b27df7e
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_select_default.js
@@ -0,0 +1,71 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that from a database of profiles the default profile is selected.
+ */
+
+add_task(async () => {
+  let hash = xreDirProvider.getInstallHash();
+
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: "Profile1",
+        path: "Path1",
+      },
+      {
+        name: "Profile3",
+        path: "Path3",
+      },
+    ],
+    installs: {
+      [hash]: {
+        default: "Path2",
+      },
+    },
+  };
+
+  if (AppConstants.MOZ_DEV_EDITION) {
+    profileData.profiles.push(
+      {
+        name: "default",
+        path: "Path2",
+        default: true,
+      },
+      {
+        name: PROFILE_DEFAULT,
+        path: "Path4",
+      }
+    );
+  } else {
+    profileData.profiles.push({
+      name: PROFILE_DEFAULT,
+      path: "Path2",
+      default: true,
+    });
+  }
+
+  writeProfilesIni(profileData);
+
+  let { profile, didCreate } = selectStartupProfile();
+  checkStartupReason("default");
+
+  let service = getProfileService();
+  checkProfileService(profileData);
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.equal(
+    profile,
+    service.defaultProfile,
+    "Should have returned the default profile."
+  );
+  Assert.equal(
+    profile.name,
+    "default",
+    "Should have selected the right profile"
+  );
+});
diff --git a/toolkit/profile/xpcshell/test_select_environment.js b/toolkit/profile/xpcshell/test_select_environment.js
new file mode 100644
index 0000000000..f7e3138191
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_select_environment.js
@@ -0,0 +1,45 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that the environment variables are used to select a profile.
+ */
+
+add_task(async () => {
+  let dir = makeRandomProfileDir("foo");
+
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: "Profile1",
+        path: dir.leafName,
+      },
+      {
+        name: "Profile2",
+        path: "Path2",
+        default: true,
+      },
+      {
+        name: "Profile3",
+        path: "Path3",
+      },
+    ],
+  };
+
+  writeProfilesIni(profileData);
+  checkProfileService(profileData);
+
+  Services.env.set("XRE_PROFILE_PATH", dir.path);
+  Services.env.set("XRE_PROFILE_LOCAL_PATH", dir.path);
+
+  let { rootDir, localDir, profile, didCreate } = selectStartupProfile();
+  checkStartupReason("restart");
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(rootDir.equals(dir), "Should have selected the right root dir.");
+  Assert.ok(localDir.equals(dir), "Should have selected the right local dir.");
+  Assert.ok(!profile, "No named profile matches this.");
+});
diff --git a/toolkit/profile/xpcshell/test_select_environment_named.js b/toolkit/profile/xpcshell/test_select_environment_named.js
new file mode 100644
index 0000000000..348ce0ff0a
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_select_environment_named.js
@@ -0,0 +1,61 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that the environment variables are used to select a profile.
+ */
+
+add_task(async () => {
+  let root = makeRandomProfileDir("foo");
+  let local = gDataHomeLocal.clone();
+  local.append("foo");
+
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: "Profile1",
+        path: root.leafName,
+      },
+      {
+        name: "Profile2",
+        path: "Path2",
+        default: true,
+      },
+      {
+        name: "Profile3",
+        path: "Path3",
+      },
+    ],
+  };
+
+  writeProfilesIni(profileData);
+  checkProfileService(profileData);
+
+  Services.env.set("XRE_PROFILE_PATH", root.path);
+  Services.env.set("XRE_PROFILE_LOCAL_PATH", local.path);
+
+  let { rootDir, localDir, profile, didCreate } = selectStartupProfile([
+    "-P",
+    "Profile3",
+  ]);
+  checkStartupReason("restart");
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(rootDir.equals(root), "Should have selected the right root dir.");
+  Assert.ok(
+    localDir.equals(local),
+    "Should have selected the right local dir."
+  );
+  Assert.ok(profile, "A named profile matches this.");
+  Assert.equal(profile.name, "Profile1", "The right profile was matched.");
+
+  let service = getProfileService();
+  Assert.notEqual(
+    service.defaultProfile,
+    profile,
+    "Should not be the default profile."
+  );
+});
diff --git a/toolkit/profile/xpcshell/test_select_missing.js b/toolkit/profile/xpcshell/test_select_missing.js
new file mode 100644
index 0000000000..97da6d76b3
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_select_missing.js
@@ -0,0 +1,34 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that when choosing an unknown profile the profile manager is shown.
+ */
+
+add_task(async () => {
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: "Profile1",
+        path: "Path1",
+      },
+      {
+        name: "Profile2",
+        path: "Path2",
+        default: true,
+      },
+      {
+        name: "Profile3",
+        path: "Path3",
+      },
+    ],
+  };
+
+  writeProfilesIni(profileData);
+  checkProfileService(profileData);
+
+  testStartsProfileManager(["-P", "foo"]);
+});
diff --git a/toolkit/profile/xpcshell/test_select_named.js b/toolkit/profile/xpcshell/test_select_named.js
new file mode 100644
index 0000000000..abecba1f4d
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_select_named.js
@@ -0,0 +1,43 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that from a database of profiles the correct profile is selected.
+ */
+
+add_task(async () => {
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: "Profile1",
+        path: "Path1",
+      },
+      {
+        name: "Profile2",
+        path: "Path2",
+        default: true,
+      },
+      {
+        name: "Profile3",
+        path: "Path3",
+      },
+    ],
+  };
+
+  writeProfilesIni(profileData);
+
+  checkProfileService(profileData);
+
+  let { profile, didCreate } = selectStartupProfile(["-P", "Profile1"]);
+  checkStartupReason("argument-p");
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.equal(
+    profile.name,
+    "Profile1",
+    "Should have chosen the right profile"
+  );
+});
diff --git a/toolkit/profile/xpcshell/test_select_noname.js b/toolkit/profile/xpcshell/test_select_noname.js
new file mode 100644
index 0000000000..278b38089c
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_select_noname.js
@@ -0,0 +1,35 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that when passing the -P command line argument and not passing a
+ * profile name the profile manager is opened.
+ */
+
+add_task(async () => {
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: "Profile1",
+        path: "Path1",
+      },
+      {
+        name: "Profile2",
+        path: "Path2",
+        default: true,
+      },
+      {
+        name: "Profile3",
+        path: "Path3",
+      },
+    ],
+  };
+
+  writeProfilesIni(profileData);
+  checkProfileService(profileData);
+
+  testStartsProfileManager(["-P"]);
+});
diff --git a/toolkit/profile/xpcshell/test_select_profile_argument.js b/toolkit/profile/xpcshell/test_select_profile_argument.js
new file mode 100644
index 0000000000..70be506538
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_select_profile_argument.js
@@ -0,0 +1,50 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that selecting a profile directory with the "profile" argument finds
+ * the matching profile.
+ */
+
+add_task(async () => {
+  let root = makeRandomProfileDir("foo");
+  let local = gDataHomeLocal.clone();
+  local.append("foo");
+
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: "Profile1",
+        path: root.leafName,
+      },
+    ],
+  };
+
+  writeProfilesIni(profileData);
+  checkProfileService(profileData);
+
+  let { rootDir, localDir, profile, didCreate } = selectStartupProfile([
+    "-profile",
+    root.path,
+  ]);
+  checkStartupReason("argument-profile");
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(rootDir.equals(root), "Should have selected the right root dir.");
+  Assert.ok(
+    localDir.equals(local),
+    "Should have selected the right local dir."
+  );
+  Assert.ok(profile, "A named profile matches this.");
+  Assert.equal(profile.name, "Profile1", "The right profile was matched.");
+
+  let service = getProfileService();
+  Assert.notEqual(
+    service.defaultProfile,
+    profile,
+    "Should not be the default profile."
+  );
+});
diff --git a/toolkit/profile/xpcshell/test_select_profile_argument_new.js b/toolkit/profile/xpcshell/test_select_profile_argument_new.js
new file mode 100644
index 0000000000..570abbd19f
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_select_profile_argument_new.js
@@ -0,0 +1,43 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that selecting a profile directory with the "profile" argument finds
+ * doesn't match the incorrect profile.
+ */
+
+add_task(async () => {
+  let root = makeRandomProfileDir("foo");
+  let local = gDataHomeLocal.clone();
+  local.append("foo");
+  let empty = makeRandomProfileDir("empty");
+
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: "Profile1",
+        path: root.leafName,
+      },
+    ],
+  };
+
+  writeProfilesIni(profileData);
+  checkProfileService(profileData);
+
+  let { rootDir, localDir, profile, didCreate } = selectStartupProfile([
+    "-profile",
+    empty.path,
+  ]);
+  checkStartupReason("argument-profile");
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(rootDir.equals(empty), "Should have selected the right root dir.");
+  Assert.ok(
+    localDir.equals(empty),
+    "Should have selected the right local dir."
+  );
+  Assert.ok(!profile, "No named profile matches this.");
+});
diff --git a/toolkit/profile/xpcshell/test_select_profilemanager.js b/toolkit/profile/xpcshell/test_select_profilemanager.js
new file mode 100644
index 0000000000..7c8bdd820e
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_select_profilemanager.js
@@ -0,0 +1,34 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that when requested the profile manager is shown.
+ */
+
+add_task(async () => {
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: "Profile1",
+        path: "Path1",
+      },
+      {
+        name: "Profile2",
+        path: "Path2",
+        default: true,
+      },
+      {
+        name: "Profile3",
+        path: "Path3",
+      },
+    ],
+  };
+
+  writeProfilesIni(profileData);
+  checkProfileService(profileData);
+
+  testStartsProfileManager(["-profilemanager"]);
+});
diff --git a/toolkit/profile/xpcshell/test_single_profile_selected.js b/toolkit/profile/xpcshell/test_single_profile_selected.js
new file mode 100644
index 0000000000..1dc1f5c872
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_single_profile_selected.js
@@ -0,0 +1,73 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Previous versions of Firefox automatically used a single profile even if it
+ * wasn't marked as the default. So we should try to upgrade that one if it was
+ * last used by this build. This test checks the case where it was.
+ */
+
+add_task(async () => {
+  let defaultProfile = makeRandomProfileDir("default");
+
+  writeCompatibilityIni(defaultProfile);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: "default",
+        path: defaultProfile.leafName,
+        default: false,
+      },
+    ],
+  });
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile();
+  checkStartupReason("firstrun-claimed-default");
+
+  let hash = xreDirProvider.getInstallHash();
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    1,
+    "Should have the right number of profiles."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, "default", "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should be only one known install."
+  );
+  Assert.equal(
+    profileData.installs[hash].default,
+    defaultProfile.leafName,
+    "Should have marked the original default profile as the default for this install."
+  );
+  Assert.ok(
+    !profileData.installs[hash].locked,
+    "Should not have locked as we're not the default app."
+  );
+
+  checkProfileService(profileData);
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(
+    selectedProfile.rootDir.equals(defaultProfile),
+    "Should be using the right directory."
+  );
+  Assert.equal(selectedProfile.name, "default");
+});
diff --git a/toolkit/profile/xpcshell/test_single_profile_unselected.js b/toolkit/profile/xpcshell/test_single_profile_unselected.js
new file mode 100644
index 0000000000..3ad36de387
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_single_profile_unselected.js
@@ -0,0 +1,74 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Previous versions of Firefox automatically used a single profile even if it
+ * wasn't marked as the default. So we should try to upgrade that one if it was
+ * last used by this build. This test checks the case where it wasn't.
+ */
+
+add_task(async () => {
+  let defaultProfile = makeRandomProfileDir("default");
+
+  // Just pretend this profile was last used by something in the profile dir.
+  let greDir = gProfD.clone();
+  greDir.append("app");
+  writeCompatibilityIni(defaultProfile, greDir, greDir);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: "default",
+        path: defaultProfile.leafName,
+        default: false,
+      },
+    ],
+  });
+
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    1,
+    "Should have the right number of profiles."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, "default", "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  Assert.ok(!profileData.installs, "Should be no defaults for installs yet.");
+
+  checkProfileService(profileData);
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile();
+  checkStartupReason("firstrun-skipped-default");
+  Assert.ok(didCreate, "Should have created a new profile.");
+  Assert.ok(
+    !selectedProfile.rootDir.equals(defaultProfile),
+    "Should be using the right directory."
+  );
+  Assert.equal(selectedProfile.name, DEDICATED_NAME);
+
+  profileData = readProfilesIni();
+
+  profile = profileData.profiles[0];
+  Assert.equal(profile.name, "default", "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should now be marked as the old-style default.");
+
+  checkProfileService(profileData);
+});
diff --git a/toolkit/profile/xpcshell/test_skip_locked_environment.js b/toolkit/profile/xpcshell/test_skip_locked_environment.js
new file mode 100644
index 0000000000..f98f6dd88f
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_skip_locked_environment.js
@@ -0,0 +1,131 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that the environment variables are used to select a profile and that
+ * on the first run of a dedicated profile build we don't snatch it if it is
+ * locked by another install.
+ */
+
+add_task(async () => {
+  let root = makeRandomProfileDir("foo");
+  let local = gDataHomeLocal.clone();
+  local.append("foo");
+
+  writeCompatibilityIni(root);
+
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: PROFILE_DEFAULT,
+        path: root.leafName,
+        default: true,
+      },
+      {
+        name: "Profile2",
+        path: "Path2",
+      },
+      {
+        name: "Profile3",
+        path: "Path3",
+      },
+    ],
+    // Another install is using the profile and it is locked.
+    installs: {
+      otherinstall: {
+        default: root.leafName,
+        locked: true,
+      },
+    },
+  };
+
+  writeProfilesIni(profileData);
+  checkProfileService(profileData);
+
+  Services.env.set("XRE_PROFILE_PATH", root.path);
+  Services.env.set("XRE_PROFILE_LOCAL_PATH", local.path);
+
+  let { rootDir, localDir, profile, didCreate } = selectStartupProfile();
+  checkStartupReason("restart-skipped-default");
+
+  // Since there is already a profile with the desired name on dev-edition, a
+  // unique version will be used.
+  let expectedName = AppConstants.MOZ_DEV_EDITION
+    ? `${DEDICATED_NAME}-1`
+    : DEDICATED_NAME;
+
+  Assert.ok(didCreate, "Should have created a new profile.");
+  Assert.ok(!rootDir.equals(root), "Should have selected the right root dir.");
+  Assert.ok(
+    !localDir.equals(local),
+    "Should have selected the right local dir."
+  );
+  Assert.ok(profile, "A named profile was returned.");
+  Assert.equal(profile.name, expectedName, "The right profile name was used.");
+
+  let service = getProfileService();
+  Assert.equal(
+    service.defaultProfile,
+    profile,
+    "Should be the default profile."
+  );
+  Assert.equal(
+    service.currentProfile,
+    profile,
+    "Should be the current profile."
+  );
+
+  profileData = readProfilesIni();
+
+  Assert.equal(
+    profileData.profiles[0].name,
+    PROFILE_DEFAULT,
+    "Should be the right profile."
+  );
+  Assert.ok(
+    profileData.profiles[0].default,
+    "Should be the old default profile."
+  );
+  Assert.equal(
+    profileData.profiles[0].path,
+    root.leafName,
+    "Should be the correct path."
+  );
+  Assert.equal(
+    profileData.profiles[1].name,
+    expectedName,
+    "Should be the right profile."
+  );
+  Assert.ok(
+    !profileData.profiles[1].default,
+    "Should not be the old default profile."
+  );
+
+  let hash = xreDirProvider.getInstallHash();
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    2,
+    "Should be one known install."
+  );
+  Assert.notEqual(
+    profileData.installs[hash].default,
+    root.leafName,
+    "Should have marked the original default profile as the default for this install."
+  );
+  Assert.ok(
+    profileData.installs[hash].locked,
+    "Should have locked as we created the profile for this install."
+  );
+  Assert.equal(
+    profileData.installs.otherinstall.default,
+    root.leafName,
+    "Should have left the other profile as the default for the other install."
+  );
+  Assert.ok(
+    profileData.installs[hash].locked,
+    "Should still be locked to the other install."
+  );
+});
diff --git a/toolkit/profile/xpcshell/test_snap.js b/toolkit/profile/xpcshell/test_snap.js
new file mode 100644
index 0000000000..a9bf4ed08a
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_snap.js
@@ -0,0 +1,67 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that an old-style default profile not previously used by this build gets
+ * used in a snap environment.
+ */
+
+add_task(async () => {
+  let defaultProfile = makeRandomProfileDir("default");
+
+  // Just pretend this profile was last used by something in the profile dir.
+  let greDir = gProfD.clone();
+  greDir.append("app");
+  writeCompatibilityIni(defaultProfile, greDir, greDir);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: PROFILE_DEFAULT,
+        path: defaultProfile.leafName,
+        default: true,
+      },
+    ],
+  });
+
+  simulateSnapEnvironment();
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile();
+  checkStartupReason("default");
+
+  let profileData = readProfilesIni();
+  let installsINI = gDataHome.clone();
+  installsINI.append("installs.ini");
+  Assert.ok(
+    !installsINI.exists(),
+    "Installs database should not have been created."
+  );
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    1,
+    "Should have the right number of profiles."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, PROFILE_DEFAULT, "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+
+  checkProfileService(profileData);
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(
+    selectedProfile.rootDir.equals(defaultProfile),
+    "Should be using the right directory."
+  );
+  Assert.equal(selectedProfile.name, PROFILE_DEFAULT);
+});
diff --git a/toolkit/profile/xpcshell/test_snap_empty.js b/toolkit/profile/xpcshell/test_snap_empty.js
new file mode 100644
index 0000000000..1dbdc1d18a
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_snap_empty.js
@@ -0,0 +1,28 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that from a clean slate snap builds create an appropriate profile.
+ */
+
+add_task(async () => {
+  simulateSnapEnvironment();
+
+  let service = getProfileService();
+  let { profile, didCreate } = selectStartupProfile();
+  checkStartupReason("firstrun-created-default");
+
+  Assert.ok(didCreate, "Should have created a new profile.");
+  Assert.equal(
+    profile.name,
+    PROFILE_DEFAULT,
+    "Should have used the normal name."
+  );
+  if (AppConstants.MOZ_DEV_EDITION) {
+    Assert.equal(service.profileCount, 2, "Should be two profiles.");
+  } else {
+    Assert.equal(service.profileCount, 1, "Should be only one profile.");
+  }
+
+  checkProfileService();
+});
diff --git a/toolkit/profile/xpcshell/test_snatch_environment.js b/toolkit/profile/xpcshell/test_snatch_environment.js
new file mode 100644
index 0000000000..2241fb691c
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_snatch_environment.js
@@ -0,0 +1,101 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that the environment variables are used to select a profile and that
+ * on the first run of a dedicated profile build we snatch it if it was the
+ * default profile.
+ */
+
+add_task(async () => {
+  let root = makeRandomProfileDir("foo");
+  let local = gDataHomeLocal.clone();
+  local.append("foo");
+
+  writeCompatibilityIni(root);
+
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: PROFILE_DEFAULT,
+        path: root.leafName,
+        default: true,
+      },
+      {
+        name: "Profile2",
+        path: "Path2",
+      },
+      {
+        name: "Profile3",
+        path: "Path3",
+      },
+    ],
+    // Another install is using the profile but it isn't locked.
+    installs: {
+      otherinstall: {
+        default: root.leafName,
+      },
+    },
+  };
+
+  writeProfilesIni(profileData);
+  checkProfileService(profileData);
+
+  Services.env.set("XRE_PROFILE_PATH", root.path);
+  Services.env.set("XRE_PROFILE_LOCAL_PATH", local.path);
+
+  let { rootDir, localDir, profile, didCreate } = selectStartupProfile();
+  checkStartupReason("restart-claimed-default");
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(rootDir.equals(root), "Should have selected the right root dir.");
+  Assert.ok(
+    localDir.equals(local),
+    "Should have selected the right local dir."
+  );
+  Assert.ok(profile, "A named profile matches this.");
+  Assert.equal(profile.name, PROFILE_DEFAULT, "The right profile was matched.");
+
+  let service = getProfileService();
+  Assert.equal(
+    service.defaultProfile,
+    profile,
+    "Should be the default profile."
+  );
+  Assert.equal(
+    service.currentProfile,
+    profile,
+    "Should be the current profile."
+  );
+
+  profileData = readProfilesIni();
+  Assert.equal(
+    profileData.profiles[0].name,
+    PROFILE_DEFAULT,
+    "Should be the right profile."
+  );
+  Assert.ok(
+    profileData.profiles[0].default,
+    "Should still be the old default profile."
+  );
+
+  let hash = xreDirProvider.getInstallHash();
+  // The info about the other install will have been removed so it goes through first run on next startup.
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should be one known install."
+  );
+  Assert.equal(
+    profileData.installs[hash].default,
+    root.leafName,
+    "Should have marked the original default profile as the default for this install."
+  );
+  Assert.ok(
+    !profileData.installs[hash].locked,
+    "Should not have locked as we're not the default app."
+  );
+});
diff --git a/toolkit/profile/xpcshell/test_snatch_environment_default.js b/toolkit/profile/xpcshell/test_snatch_environment_default.js
new file mode 100644
index 0000000000..d93a0cfc12
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_snatch_environment_default.js
@@ -0,0 +1,101 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that the environment variables are used to select a profile and that
+ * on the first run of a dedicated profile build we snatch it if it was the
+ * default profile and lock it when we're the default app.
+ */
+
+add_task(async () => {
+  gIsDefaultApp = true;
+
+  let root = makeRandomProfileDir("foo");
+  let local = gDataHomeLocal.clone();
+  local.append("foo");
+
+  writeCompatibilityIni(root);
+
+  let profileData = {
+    options: {
+      startWithLastProfile: true,
+    },
+    profiles: [
+      {
+        name: PROFILE_DEFAULT,
+        path: root.leafName,
+        default: true,
+      },
+      {
+        name: "Profile2",
+        path: "Path2",
+      },
+      {
+        name: "Profile3",
+        path: "Path3",
+      },
+    ],
+    // Another install is using the profile but it isn't locked.
+    installs: {
+      otherinstall: {
+        default: root.leafName,
+      },
+    },
+  };
+
+  writeProfilesIni(profileData);
+  checkProfileService(profileData);
+
+  Services.env.set("XRE_PROFILE_PATH", root.path);
+  Services.env.set("XRE_PROFILE_LOCAL_PATH", local.path);
+
+  let { rootDir, localDir, profile, didCreate } = selectStartupProfile();
+  checkStartupReason("restart-claimed-default");
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(rootDir.equals(root), "Should have selected the right root dir.");
+  Assert.ok(
+    localDir.equals(local),
+    "Should have selected the right local dir."
+  );
+  Assert.ok(!!profile, "A named profile matches this.");
+  Assert.equal(profile.name, PROFILE_DEFAULT, "The right profile was matched.");
+
+  let service = getProfileService();
+  Assert.ok(
+    service.defaultProfile === profile,
+    "Should be the default profile."
+  );
+  Assert.ok(
+    service.currentProfile === profile,
+    "Should be the current profile."
+  );
+
+  profileData = readProfilesIni();
+  Assert.equal(
+    profileData.profiles[0].name,
+    PROFILE_DEFAULT,
+    "Should be the right profile."
+  );
+  Assert.ok(
+    profileData.profiles[0].default,
+    "Should still be the old default profile."
+  );
+
+  let hash = xreDirProvider.getInstallHash();
+  // The info about the other install will have been removed so it goes through first run on next startup.
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should be one known install."
+  );
+  Assert.equal(
+    profileData.installs[hash].default,
+    root.leafName,
+    "Should have marked the original default profile as the default for this install."
+  );
+  Assert.ok(
+    profileData.installs[hash].locked,
+    "Should have locked as we're the default app."
+  );
+});
diff --git a/toolkit/profile/xpcshell/test_startswithlast.js b/toolkit/profile/xpcshell/test_startswithlast.js
new file mode 100644
index 0000000000..1b1fef4415
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_startswithlast.js
@@ -0,0 +1,28 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that if profiles.ini is set to not start with the last profile then
+ * we show the profile manager in preference to assigning the old default.
+ */
+
+add_task(async () => {
+  let defaultProfile = makeRandomProfileDir("default");
+
+  writeCompatibilityIni(defaultProfile);
+
+  writeProfilesIni({
+    options: {
+      startWithLastProfile: false,
+    },
+    profiles: [
+      {
+        name: PROFILE_DEFAULT,
+        path: defaultProfile.leafName,
+        default: true,
+      },
+    ],
+  });
+
+  testStartsProfileManager();
+});
diff --git a/toolkit/profile/xpcshell/test_steal_inuse.js b/toolkit/profile/xpcshell/test_steal_inuse.js
new file mode 100644
index 0000000000..68263ceae1
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_steal_inuse.js
@@ -0,0 +1,77 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that an old-style default profile previously used by this build but
+ * that has already been claimed by a different build gets stolen by this build.
+ */
+
+add_task(async () => {
+  let defaultProfile = makeRandomProfileDir("default");
+
+  writeCompatibilityIni(defaultProfile);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: PROFILE_DEFAULT,
+        path: defaultProfile.leafName,
+        default: true,
+      },
+    ],
+    installs: {
+      otherhash: {
+        default: defaultProfile.leafName,
+      },
+    },
+  });
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile();
+  checkStartupReason("firstrun-claimed-default");
+
+  let hash = xreDirProvider.getInstallHash();
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    1,
+    "Should have the right number of profiles."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, PROFILE_DEFAULT, "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should only be one known installs."
+  );
+  Assert.equal(
+    profileData.installs[hash].default,
+    defaultProfile.leafName,
+    "Should have taken the original default profile as the default for the current install."
+  );
+  Assert.ok(
+    !profileData.installs[hash].locked,
+    "Should not have locked as we're not the default app."
+  );
+
+  checkProfileService(profileData);
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(
+    selectedProfile.rootDir.equals(defaultProfile),
+    "Should be using the right directory."
+  );
+  Assert.equal(selectedProfile.name, PROFILE_DEFAULT);
+});
diff --git a/toolkit/profile/xpcshell/test_update_selected_dedicated.js b/toolkit/profile/xpcshell/test_update_selected_dedicated.js
new file mode 100644
index 0000000000..a4c387b8f4
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_update_selected_dedicated.js
@@ -0,0 +1,72 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that an old-style default profile previously used by this build gets
+ * updated to a dedicated profile for this build.
+ */
+
+add_task(async () => {
+  let defaultProfile = makeRandomProfileDir("default");
+
+  writeCompatibilityIni(defaultProfile);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: PROFILE_DEFAULT,
+        path: defaultProfile.leafName,
+        default: true,
+      },
+    ],
+  });
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile();
+  checkStartupReason("firstrun-claimed-default");
+
+  let hash = xreDirProvider.getInstallHash();
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    1,
+    "Should have the right number of profiles."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, PROFILE_DEFAULT, "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should be only one known install."
+  );
+  Assert.equal(
+    profileData.installs[hash].default,
+    defaultProfile.leafName,
+    "Should have marked the original default profile as the default for this install."
+  );
+  Assert.ok(
+    !profileData.installs[hash].locked,
+    "Should not have locked as we're not the default app."
+  );
+
+  checkProfileService(profileData);
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(
+    selectedProfile.rootDir.equals(defaultProfile),
+    "Should be using the right directory."
+  );
+  Assert.equal(selectedProfile.name, PROFILE_DEFAULT);
+});
diff --git a/toolkit/profile/xpcshell/test_update_unknown_dedicated.js b/toolkit/profile/xpcshell/test_update_unknown_dedicated.js
new file mode 100644
index 0000000000..1fd8c30fbf
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_update_unknown_dedicated.js
@@ -0,0 +1,85 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that an old-style default profile not previously used by any build
+ * doesn't get updated to a dedicated profile for this build and we don't set
+ * the flag to show the user info about dedicated profiles.
+ */
+
+add_task(async () => {
+  let hash = xreDirProvider.getInstallHash();
+  let defaultProfile = makeRandomProfileDir("default");
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: PROFILE_DEFAULT,
+        path: defaultProfile.leafName,
+        default: true,
+      },
+    ],
+  });
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile();
+  checkStartupReason("firstrun-created-default");
+
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    2,
+    "Should have the right number of profiles."
+  );
+
+  // Since there is already a profile with the desired name on dev-edition, a
+  // unique version will be used.
+  let expectedName = AppConstants.MOZ_DEV_EDITION
+    ? `${DEDICATED_NAME}-1`
+    : DEDICATED_NAME;
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, PROFILE_DEFAULT, "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+  profile = profileData.profiles[1];
+  Assert.equal(profile.name, expectedName, "Should have the right name.");
+  Assert.notEqual(
+    profile.path,
+    defaultProfile.leafName,
+    "Should not be the original default profile."
+  );
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should be a default for installs."
+  );
+  Assert.equal(
+    profileData.installs[hash].default,
+    profile.path,
+    "Should have the right default profile."
+  );
+  Assert.ok(
+    profileData.installs[hash].locked,
+    "Should have locked as we created this profile for this install."
+  );
+
+  checkProfileService(profileData);
+
+  Assert.ok(didCreate, "Should have created a new profile.");
+  Assert.ok(
+    !selectedProfile.rootDir.equals(defaultProfile),
+    "Should not be using the old directory."
+  );
+  Assert.equal(selectedProfile.name, expectedName);
+});
diff --git a/toolkit/profile/xpcshell/test_update_unselected_dedicated.js b/toolkit/profile/xpcshell/test_update_unselected_dedicated.js
new file mode 100644
index 0000000000..4aa56eaaac
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_update_unselected_dedicated.js
@@ -0,0 +1,89 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests that an old-style default profile not previously used by this build gets
+ * ignored.
+ */
+
+add_task(async () => {
+  let hash = xreDirProvider.getInstallHash();
+  let defaultProfile = makeRandomProfileDir("default");
+
+  // Just pretend this profile was last used by something in the profile dir.
+  let greDir = gProfD.clone();
+  greDir.append("app");
+  writeCompatibilityIni(defaultProfile, greDir, greDir);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: PROFILE_DEFAULT,
+        path: defaultProfile.leafName,
+        default: true,
+      },
+    ],
+  });
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile();
+  checkStartupReason("firstrun-skipped-default");
+
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    2,
+    "Should have the right number of profiles."
+  );
+
+  // Since there is already a profile with the desired name on dev-edition, a
+  // unique version will be used.
+  let expectedName = AppConstants.MOZ_DEV_EDITION
+    ? `${DEDICATED_NAME}-1`
+    : DEDICATED_NAME;
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, PROFILE_DEFAULT, "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+  profile = profileData.profiles[1];
+  Assert.equal(profile.name, expectedName, "Should have the right name.");
+  Assert.notEqual(
+    profile.path,
+    defaultProfile.leafName,
+    "Should not be the original default profile."
+  );
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    1,
+    "Should be a default for this install."
+  );
+  Assert.equal(
+    profileData.installs[hash].default,
+    profile.path,
+    "Should have marked the new profile as the default for this install."
+  );
+  Assert.ok(
+    profileData.installs[hash].locked,
+    "Should have locked as we created this profile for this install."
+  );
+
+  checkProfileService(profileData);
+
+  Assert.ok(didCreate, "Should have created a new profile.");
+  Assert.ok(
+    !selectedProfile.rootDir.equals(defaultProfile),
+    "Should be using the right directory."
+  );
+  Assert.equal(selectedProfile.name, expectedName);
+});
diff --git a/toolkit/profile/xpcshell/test_use_dedicated.js b/toolkit/profile/xpcshell/test_use_dedicated.js
new file mode 100644
index 0000000000..d6bbdca4d8
--- /dev/null
+++ b/toolkit/profile/xpcshell/test_use_dedicated.js
@@ -0,0 +1,100 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Tests that if installs.ini lists a profile we use it as the default.
+ */
+
+add_task(async () => {
+  let hash = xreDirProvider.getInstallHash();
+  let defaultProfile = makeRandomProfileDir("default");
+  let dedicatedProfile = makeRandomProfileDir("dedicated");
+  let devProfile = makeRandomProfileDir("devedition");
+
+  // Make sure we don't steal the old-style default.
+  writeCompatibilityIni(defaultProfile);
+
+  writeProfilesIni({
+    profiles: [
+      {
+        name: "default",
+        path: defaultProfile.leafName,
+        default: true,
+      },
+      {
+        name: "dedicated",
+        path: dedicatedProfile.leafName,
+      },
+      {
+        name: "dev-edition-default",
+        path: devProfile.leafName,
+      },
+    ],
+    installs: {
+      [hash]: {
+        default: dedicatedProfile.leafName,
+      },
+      otherhash: {
+        default: "foobar",
+      },
+    },
+  });
+
+  let { profile: selectedProfile, didCreate } = selectStartupProfile();
+  checkStartupReason("default");
+
+  let profileData = readProfilesIni();
+
+  Assert.ok(
+    profileData.options.startWithLastProfile,
+    "Should be set to start with the last profile."
+  );
+  Assert.equal(
+    profileData.profiles.length,
+    3,
+    "Should have the right number of profiles."
+  );
+
+  let profile = profileData.profiles[0];
+  Assert.equal(profile.name, `dedicated`, "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    dedicatedProfile.leafName,
+    "Should be the expected dedicated profile."
+  );
+  Assert.ok(!profile.default, "Should not be marked as the old-style default.");
+
+  profile = profileData.profiles[1];
+  Assert.equal(profile.name, "default", "Should have the right name.");
+  Assert.equal(
+    profile.path,
+    defaultProfile.leafName,
+    "Should be the original default profile."
+  );
+  Assert.ok(profile.default, "Should be marked as the old-style default.");
+
+  Assert.equal(
+    Object.keys(profileData.installs).length,
+    2,
+    "Should be two known installs."
+  );
+  Assert.equal(
+    profileData.installs[hash].default,
+    dedicatedProfile.leafName,
+    "Should have kept the default for this install."
+  );
+  Assert.equal(
+    profileData.installs.otherhash.default,
+    "foobar",
+    "Should have kept the default for the other install."
+  );
+
+  checkProfileService(profileData);
+
+  Assert.ok(!didCreate, "Should not have created a new profile.");
+  Assert.ok(
+    selectedProfile.rootDir.equals(dedicatedProfile),
+    "Should be using the right directory."
+  );
+  Assert.equal(selectedProfile.name, "dedicated");
+});
diff --git a/toolkit/profile/xpcshell/xpcshell.ini b/toolkit/profile/xpcshell/xpcshell.ini
new file mode 100644
index 0000000000..f0793bad2e
--- /dev/null
+++ b/toolkit/profile/xpcshell/xpcshell.ini
@@ -0,0 +1,52 @@
+[DEFAULT]
+head = head.js
+skip-if = toolkit == 'android'
+
+[test_select_backgroundtasks_ephemeral.js]
+[test_select_backgroundtasks_not_ephemeral_create.js]
+[test_select_backgroundtasks_not_ephemeral_exists.js]
+[test_select_default.js]
+[test_select_profilemanager.js]
+[test_select_named.js]
+[test_select_missing.js]
+[test_select_noname.js]
+[test_create_default.js]
+[test_select_environment.js]
+[test_select_environment_named.js]
+[test_profile_reset.js]
+[test_clean.js]
+[test_previous_dedicated.js]
+[test_single_profile_selected.js]
+skip-if = devedition
+[test_single_profile_unselected.js]
+skip-if = devedition
+[test_update_selected_dedicated.js]
+[test_update_unknown_dedicated.js]
+[test_update_unselected_dedicated.js]
+[test_use_dedicated.js]
+[test_new_default.js]
+[test_steal_inuse.js]
+[test_snap.js]
+skip-if = toolkit != 'gtk'
+[test_snap_empty.js]
+skip-if = toolkit != 'gtk'
+[test_remove_default.js]
+[test_claim_locked.js]
+[test_lock.js]
+[test_startswithlast.js]
+[test_snatch_environment.js]
+[test_skip_locked_environment.js]
+[test_snatch_environment_default.js]
+[test_check_backup.js]
+[test_missing_profilesini.js]
+[test_remove.js]
+[test_conflict_profiles.js]
+[test_conflict_installs.js]
+[test_invalid_descriptor.js]
+[test_legacy_empty.js]
+[test_legacy_select.js]
+[test_fix_directory_case.js]
+[test_ignore_legacy_directory.js]
+[test_select_profile_argument.js]
+[test_select_profile_argument_new.js]
+[test_register_app_services_logger.js]