Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

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

1 files changed, 1237 insertions, 0 deletions

diff --git a/comm/chat/components/src/imAccounts.sys.mjs b/comm/chat/components/src/imAccounts.sys.mjs
new file mode 100644
index 0000000000..f06b503fa6
--- /dev/null
+++ b/comm/chat/components/src/imAccounts.sys.mjs
@@ -0,0 +1,1237 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { clearTimeout, setTimeout } from "resource://gre/modules/Timer.sys.mjs";
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import {
+  ClassInfo,
+  executeSoon,
+  l10nHelper,
+} from "resource:///modules/imXPCOMUtils.sys.mjs";
+
+const { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+import { IMServices } from "resource:///modules/IMServices.sys.mjs";
+import {
+  GenericAccountPrototype,
+  GenericAccountBuddyPrototype,
+} from "resource:///modules/jsProtoHelper.sys.mjs";
+
+const lazy = {};
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/accounts.properties")
+);
+XPCOMUtils.defineLazyGetter(lazy, "_maxDebugMessages", () =>
+  Services.prefs.getIntPref("messenger.accounts.maxDebugMessages")
+);
+XPCOMUtils.defineLazyServiceGetter(
+  lazy,
+  "HttpProtocolHandler",
+  "@mozilla.org/network/protocol;1?name=http",
+  "nsIHttpProtocolHandler"
+);
+
+var kPrefAutologinPending = "messenger.accounts.autoLoginPending";
+let kPrefAccountOrder = "mail.accountmanager.accounts";
+var kPrefAccountPrefix = "messenger.account.";
+var kAccountKeyPrefix = "account";
+var kAccountOptionPrefPrefix = "options.";
+var kPrefAccountName = "name";
+var kPrefAccountPrpl = "prpl";
+var kPrefAccountAutoLogin = "autoLogin";
+var kPrefAccountAutoJoin = "autoJoin";
+var kPrefAccountAlias = "alias";
+var kPrefAccountFirstConnectionState = "firstConnectionState";
+
+var gUserCanceledPrimaryPasswordPrompt = false;
+
+var SavePrefTimer = {
+  saveNow() {
+    if (this._timer) {
+      clearTimeout(this._timer);
+      this._timer = null;
+    }
+    Services.prefs.savePrefFile(null);
+  },
+  _timer: null,
+  unInitTimer() {
+    if (this._timer) {
+      this.saveNow();
+    }
+  },
+  initTimer() {
+    if (!this._timer) {
+      this._timer = setTimeout(this.saveNow.bind(this), 5000);
+    }
+  },
+};
+
+var AutoLoginCounter = {
+  _count: 0,
+  startAutoLogin() {
+    ++this._count;
+    if (this._count != 1) {
+      return;
+    }
+    Services.prefs.setIntPref(kPrefAutologinPending, Date.now() / 1000);
+    SavePrefTimer.saveNow();
+  },
+  finishedAutoLogin() {
+    --this._count;
+    if (this._count != 0) {
+      return;
+    }
+    Services.prefs.clearUserPref(kPrefAutologinPending);
+    SavePrefTimer.initTimer();
+  },
+};
+
+function UnknownProtocol(aPrplId) {
+  this.id = aPrplId;
+}
+UnknownProtocol.prototype = {
+  __proto__: ClassInfo("prplIProtocol", "Unknown protocol"),
+  get name() {
+    return "";
+  },
+  get normalizedName() {
+    // Use the ID, but remove the 'prpl-' prefix.
+    return this.id.replace(/^prpl-/, "");
+  },
+  get iconBaseURI() {
+    return "chrome://chat/skin/prpl-unknown/";
+  },
+  getOptions() {
+    return [];
+  },
+  get usernamePrefix() {
+    return "";
+  },
+  getUsernameSplit() {
+    return [];
+  },
+  get usernameEmptyText() {
+    return "";
+  },
+
+  getAccount(aKey, aName) {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+  accountExists() {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+
+  // false seems an acceptable default for all options
+  // (they should never be called anyway).
+  get chatHasTopic() {
+    return false;
+  },
+  get noPassword() {
+    return false;
+  },
+  get passwordOptional() {
+    return true;
+  },
+  get slashCommandsNative() {
+    return false;
+  },
+  get canEncrypt() {
+    return false;
+  },
+};
+
+// An unknown prplIAccount.
+function UnknownAccount(aAccount) {
+  this._init(aAccount.protocol, aAccount);
+}
+UnknownAccount.prototype = GenericAccountPrototype;
+
+function UnknownAccountBuddy(aAccount, aBuddy, aTag) {
+  this._init(new UnknownAccount(aAccount), aBuddy, aTag);
+}
+UnknownAccountBuddy.prototype = GenericAccountBuddyPrototype;
+
+/**
+ * @param {string} aKey - Account key for preferences.
+ * @param {string} [aName] - Name of the account if it is new. Will be stored
+ *  in account preferences. If not provided, the value from the account
+ *  preferences is used instead.
+ * @param {string} [aPrplId] - Protocol ID for this account if it is new. Will
+ *  be stored in account preferences. If not provided, the value from the
+ *  account preferences is used instead.
+ */
+function imAccount(aKey, aName, aPrplId) {
+  if (!aKey.startsWith(kAccountKeyPrefix)) {
+    throw Components.Exception(`Invalid key: ${aKey}`, Cr.NS_ERROR_INVALID_ARG);
+  }
+
+  this.id = aKey;
+  this.numericId = parseInt(aKey.substr(kAccountKeyPrefix.length));
+  gAccountsService._keepAccount(this);
+  this.prefBranch = Services.prefs.getBranch(kPrefAccountPrefix + aKey + ".");
+
+  if (aName) {
+    this.name = aName;
+    this.prefBranch.setStringPref(kPrefAccountName, aName);
+
+    this.firstConnectionState = Ci.imIAccount.FIRST_CONNECTION_UNKNOWN;
+  } else {
+    this.name = this.prefBranch.getStringPref(kPrefAccountName);
+  }
+
+  let prplId = aPrplId;
+  if (prplId) {
+    this.prefBranch.setCharPref(kPrefAccountPrpl, prplId);
+  } else {
+    prplId = this.prefBranch.getCharPref(kPrefAccountPrpl);
+  }
+
+  // Get the protocol plugin, or fallback to an UnknownProtocol instance.
+  this.protocol = IMServices.core.getProtocolById(prplId);
+  if (!this.protocol) {
+    this.protocol = new UnknownProtocol(prplId);
+    this._connectionErrorReason = Ci.imIAccount.ERROR_UNKNOWN_PRPL;
+    return;
+  }
+
+  // Ensure the account is correctly stored in blist.sqlite.
+  IMServices.contacts.storeAccount(this.numericId, this.name, prplId);
+
+  // Get the prplIAccount from the protocol plugin.
+  this.prplAccount = this.protocol.getAccount(this);
+
+  // Send status change notifications to the account.
+  this.observedStatusInfo = null; // (To execute the setter).
+
+  // If we have never finished the first connection attempt for this account,
+  // mark the account as having caused a crash.
+  if (this.firstConnectionState == Ci.imIAccount.FIRST_CONNECTION_PENDING) {
+    this.firstConnectionState = Ci.imIAccount.FIRST_CONNECTION_CRASHED;
+  }
+
+  Services.logins.initializationPromise.then(() => {
+    // If protocol is falsy remove() was called on this instance while waiting
+    // for the promise to resolve. Since the instance was disposed there is
+    // nothing to do.
+    if (!this.protocol) {
+      return;
+    }
+
+    // Check for errors that should prevent connection attempts.
+    if (this._passwordRequired && !this.password) {
+      this._connectionErrorReason = Ci.imIAccount.ERROR_MISSING_PASSWORD;
+    } else if (
+      this.firstConnectionState == Ci.imIAccount.FIRST_CONNECTION_CRASHED
+    ) {
+      this._connectionErrorReason = Ci.imIAccount.ERROR_CRASHED;
+    }
+  });
+}
+
+imAccount.prototype = {
+  __proto__: ClassInfo(["imIAccount", "prplIAccount"], "im account object"),
+
+  name: "",
+  id: "",
+  numericId: 0,
+  protocol: null,
+  prplAccount: null,
+  connectionState: Ci.imIAccount.STATE_DISCONNECTED,
+  connectionStateMsg: "",
+  connectionErrorMessage: "",
+  _connectionErrorReason: Ci.prplIAccount.NO_ERROR,
+  get connectionErrorReason() {
+    if (
+      this._connectionErrorReason != Ci.prplIAccount.NO_ERROR &&
+      (this._connectionErrorReason != Ci.imIAccount.ERROR_MISSING_PASSWORD ||
+        !this._password)
+    ) {
+      return this._connectionErrorReason;
+    }
+    return this.prplAccount.connectionErrorReason;
+  },
+
+  observe(aSubject, aTopic, aData) {
+    if (aTopic == "account-connect-progress") {
+      this.connectionStateMsg = aData;
+    } else if (aTopic == "account-connecting") {
+      if (this.prplAccount.connectionErrorReason != Ci.prplIAccount.NO_ERROR) {
+        delete this.connectionErrorMessage;
+        if (this.timeOfNextReconnect - Date.now() > 1000) {
+          // This is a manual reconnection, reset the auto-reconnect stuff
+          this.timeOfLastConnect = 0;
+          this._cancelReconnection();
+        }
+      }
+      if (this.firstConnectionState != Ci.imIAccount.FIRST_CONNECTION_OK) {
+        this.firstConnectionState = Ci.imIAccount.FIRST_CONNECTION_PENDING;
+      }
+      this.connectionState = Ci.imIAccount.STATE_CONNECTING;
+    } else if (aTopic == "account-connected") {
+      this.connectionState = Ci.imIAccount.STATE_CONNECTED;
+      this._finishedAutoLogin();
+      this.timeOfLastConnect = Date.now();
+      if (this.firstConnectionState != Ci.imIAccount.FIRST_CONNECTION_OK) {
+        this.firstConnectionState = Ci.imIAccount.FIRST_CONNECTION_OK;
+      }
+      delete this.connectionStateMsg;
+
+      if (
+        this.canJoinChat &&
+        this.prefBranch.prefHasUserValue(kPrefAccountAutoJoin)
+      ) {
+        let autojoin = this.prefBranch.getStringPref(kPrefAccountAutoJoin);
+        if (autojoin) {
+          for (let room of autojoin.trim().split(/,\s*/)) {
+            if (room) {
+              this.joinChat(this.getChatRoomDefaultFieldValues(room));
+            }
+          }
+        }
+      }
+    } else if (aTopic == "account-disconnecting") {
+      this.connectionState = Ci.imIAccount.STATE_DISCONNECTING;
+      this.connectionErrorMessage = aData;
+      delete this.connectionStateMsg;
+      this._finishedAutoLogin();
+
+      let firstConnectionState = this.firstConnectionState;
+      if (
+        firstConnectionState != Ci.imIAccount.FIRST_CONNECTION_OK &&
+        firstConnectionState != Ci.imIAccount.FIRST_CONNECTION_CRASHED
+      ) {
+        this.firstConnectionState = Ci.imIAccount.FIRST_CONNECTION_UNKNOWN;
+      }
+
+      let connectionErrorReason = this.prplAccount.connectionErrorReason;
+      if (connectionErrorReason != Ci.prplIAccount.NO_ERROR) {
+        if (
+          connectionErrorReason == Ci.prplIAccount.ERROR_NETWORK_ERROR ||
+          connectionErrorReason == Ci.prplIAccount.ERROR_ENCRYPTION_ERROR
+        ) {
+          this._startReconnectTimer();
+        }
+        this._sendNotification("account-connect-error");
+      }
+    } else if (aTopic == "account-disconnected") {
+      this.connectionState = Ci.imIAccount.STATE_DISCONNECTED;
+      let connectionErrorReason = this.prplAccount.connectionErrorReason;
+      if (connectionErrorReason != Ci.prplIAccount.NO_ERROR) {
+        // If the account was disconnected with an error, save the debug messages.
+        this._omittedDebugMessagesBeforeError += this._omittedDebugMessages;
+        if (this._debugMessagesBeforeError) {
+          this._omittedDebugMessagesBeforeError +=
+            this._debugMessagesBeforeError.length;
+        }
+        this._debugMessagesBeforeError = this._debugMessages;
+      } else {
+        // After a clean disconnection, drop the debug messages that
+        // could have been left by a previous error.
+        delete this._omittedDebugMessagesBeforeError;
+        delete this._debugMessagesBeforeError;
+      }
+      delete this._omittedDebugMessages;
+      delete this._debugMessages;
+      if (
+        this._statusObserver &&
+        connectionErrorReason == Ci.prplIAccount.NO_ERROR &&
+        this.statusInfo.statusType > Ci.imIStatusInfo.STATUS_OFFLINE
+      ) {
+        // If the status changed back to online while an account was still
+        // disconnecting, it was not reconnected automatically at that point,
+        // so we must do it now. (This happens for protocols like IRC where
+        // disconnection is not immediate.)
+        this._sendNotification(aTopic, aData);
+        this.connect();
+        return;
+      }
+    } else {
+      throw Components.Exception("", Cr.NS_ERROR_UNEXPECTED);
+    }
+    this._sendNotification(aTopic, aData);
+  },
+
+  _debugMessages: null,
+  _omittedDebugMessages: 0,
+  _debugMessagesBeforeError: null,
+  _omittedDebugMessagesBeforeError: 0,
+  logDebugMessage(aMessage, aLevel) {
+    if (!this._debugMessages) {
+      this._debugMessages = [];
+    }
+    if (
+      lazy._maxDebugMessages &&
+      this._debugMessages.length >= lazy._maxDebugMessages
+    ) {
+      this._debugMessages.shift();
+      ++this._omittedDebugMessages;
+    }
+    this._debugMessages.push({ logLevel: aLevel, message: aMessage });
+  },
+  _createDebugMessage(aMessage) {
+    let scriptError = Cc["@mozilla.org/scripterror;1"].createInstance(
+      Ci.nsIScriptError
+    );
+    scriptError.init(
+      aMessage,
+      "",
+      "",
+      0,
+      null,
+      Ci.nsIScriptError.warningFlag,
+      "component javascript"
+    );
+    return { logLevel: 0, message: scriptError };
+  },
+  getDebugMessages() {
+    let messages = [];
+    if (this._omittedDebugMessagesBeforeError) {
+      let text = this._omittedDebugMessagesBeforeError + " messages omitted";
+      messages.push(this._createDebugMessage(text));
+    }
+    if (this._debugMessagesBeforeError) {
+      messages = messages.concat(this._debugMessagesBeforeError);
+    }
+    if (this._omittedDebugMessages) {
+      let text = this._omittedDebugMessages + " messages omitted";
+      messages.push(this._createDebugMessage(text));
+    }
+    if (this._debugMessages) {
+      messages = messages.concat(this._debugMessages);
+    }
+    if (messages.length) {
+      let appInfo = Services.appinfo;
+      let header =
+        `${appInfo.name} ${appInfo.version} (${appInfo.appBuildID}), ` +
+        `Gecko ${appInfo.platformVersion} (${appInfo.platformBuildID}) ` +
+        `on ${lazy.HttpProtocolHandler.oscpu}`;
+      messages.unshift(this._createDebugMessage(header));
+    }
+
+    return messages;
+  },
+
+  _observedStatusInfo: null,
+  get observedStatusInfo() {
+    return this._observedStatusInfo;
+  },
+  _statusObserver: null,
+  set observedStatusInfo(aUserStatusInfo) {
+    if (!this.prplAccount) {
+      return;
+    }
+    if (this._statusObserver) {
+      this.statusInfo.removeObserver(this._statusObserver);
+    }
+    this._observedStatusInfo = aUserStatusInfo;
+    if (this._statusObserver) {
+      this.statusInfo.addObserver(this._statusObserver);
+    }
+  },
+  _removeStatusObserver() {
+    if (this._statusObserver) {
+      this.statusInfo.removeObserver(this._statusObserver);
+      delete this._statusObserver;
+    }
+  },
+  get statusInfo() {
+    return this._observedStatusInfo || IMServices.core.globalUserStatus;
+  },
+
+  reconnectAttempt: 0,
+  timeOfLastConnect: 0,
+  timeOfNextReconnect: 0,
+  _reconnectTimer: null,
+  _startReconnectTimer() {
+    if (Services.io.offline) {
+      console.error("_startReconnectTimer called while offline");
+      return;
+    }
+
+    /* If the last successful connection is older than 10 seconds, reset the
+       number of reconnection attempts. */
+    const kTimeBeforeSuccessfulConnection = 10;
+    if (
+      this.timeOfLastConnect &&
+      this.timeOfLastConnect + kTimeBeforeSuccessfulConnection * 1000 <
+        Date.now()
+    ) {
+      delete this.reconnectAttempt;
+      delete this.timeOfLastConnect;
+    }
+
+    let timers = Services.prefs
+      .getCharPref("messenger.accounts.reconnectTimer")
+      .split(",");
+    let delay = timers[Math.min(this.reconnectAttempt, timers.length - 1)];
+    let msDelay = parseInt(delay) * 1000;
+    ++this.reconnectAttempt;
+    this.timeOfNextReconnect = Date.now() + msDelay;
+    this._reconnectTimer = setTimeout(this.connect.bind(this), msDelay);
+  },
+
+  _sendNotification(aTopic, aData) {
+    Services.obs.notifyObservers(this, aTopic, aData);
+  },
+
+  get firstConnectionState() {
+    try {
+      return this.prefBranch.getIntPref(kPrefAccountFirstConnectionState);
+    } catch (e) {
+      return Ci.imIAccount.FIRST_CONNECTION_OK;
+    }
+  },
+  set firstConnectionState(aState) {
+    if (aState == Ci.imIAccount.FIRST_CONNECTION_OK) {
+      this.prefBranch.clearUserPref(kPrefAccountFirstConnectionState);
+    } else {
+      this.prefBranch.setIntPref(kPrefAccountFirstConnectionState, aState);
+      // We want to save this pref immediately when trying to connect.
+      if (aState == Ci.imIAccount.FIRST_CONNECTION_PENDING) {
+        SavePrefTimer.saveNow();
+      } else {
+        SavePrefTimer.initTimer();
+      }
+    }
+  },
+
+  _pendingReconnectForConnectionInfoChange: false,
+  _connectionInfoChanged() {
+    // The next connection will be the first connection with these parameters.
+    this.firstConnectionState = Ci.imIAccount.FIRST_CONNECTION_UNKNOWN;
+
+    // We want to attempt to reconnect with the new settings only if a
+    // previous attempt failed or a connection attempt is currently
+    // pending (so we can return early if the account is currently
+    // connected or disconnected without error).
+    // The code doing the reconnection attempt is wrapped within an
+    // executeSoon call so that when multiple settings are changed at
+    // once we don't attempt to reconnect until they are all saved.
+    // If a reconnect attempt is already scheduled, we can also return early.
+    if (
+      this._pendingReconnectForConnectionInfoChange ||
+      this.connected ||
+      (this.disconnected &&
+        this.connectionErrorReason == Ci.prplIAccount.NO_ERROR)
+    ) {
+      return;
+    }
+
+    this._pendingReconnectForConnectionInfoChange = true;
+    executeSoon(
+      function () {
+        delete this._pendingReconnectForConnectionInfoChange;
+        // If the connection parameters have changed while we were
+        // trying to connect, cancel the ongoing connection attempt and
+        // try again with the new parameters.
+        if (this.connecting) {
+          this.disconnect();
+          this.connect();
+          return;
+        }
+        // If the account was disconnected because of a non-fatal
+        // connection error, retry now that we have new parameters.
+        let errorReason = this.connectionErrorReason;
+        if (
+          this.disconnected &&
+          errorReason != Ci.prplIAccount.NO_ERROR &&
+          errorReason != Ci.imIAccount.ERROR_MISSING_PASSWORD &&
+          errorReason != Ci.imIAccount.ERROR_CRASHED &&
+          errorReason != Ci.imIAccount.ERROR_UNKNOWN_PRPL
+        ) {
+          this.connect();
+        }
+      }.bind(this)
+    );
+  },
+
+  // If the protocol plugin is missing, we can't access the normalizedName,
+  // but in lots of cases this.name is equivalent.
+  get normalizedName() {
+    return this.prplAccount ? this.prplAccount.normalizedName : this.name;
+  },
+  normalize(aName) {
+    return this.prplAccount ? this.prplAccount.normalize(aName) : aName;
+  },
+
+  _sendUpdateNotification() {
+    this._sendNotification("account-updated");
+  },
+
+  set alias(val) {
+    if (val) {
+      this.prefBranch.setStringPref(kPrefAccountAlias, val);
+    } else {
+      this.prefBranch.clearUserPref(kPrefAccountAlias);
+    }
+    this._sendUpdateNotification();
+  },
+  get alias() {
+    try {
+      return this.prefBranch.getStringPref(kPrefAccountAlias);
+    } catch (e) {
+      return "";
+    }
+  },
+
+  _password: "",
+  get password() {
+    if (this._password) {
+      return this._password;
+    }
+
+    // Avoid prompting the user for the primary password more than once at startup.
+    if (gUserCanceledPrimaryPasswordPrompt) {
+      return "";
+    }
+
+    let passwordURI = "im://" + this.protocol.id;
+    let logins;
+    try {
+      logins = Services.logins.findLogins(passwordURI, null, passwordURI);
+    } catch (e) {
+      this._handlePrimaryPasswordException(e);
+      return "";
+    }
+    let normalizedName = this.normalizedName;
+    for (let login of logins) {
+      if (login.username == normalizedName) {
+        this._password = login.password;
+        if (
+          this._connectionErrorReason == Ci.imIAccount.ERROR_MISSING_PASSWORD
+        ) {
+          // We have found a password for an account marked as missing password,
+          // re-check all others accounts missing a password. But first,
+          // remove the error on our own account to avoid re-checking it.
+          delete this._connectionErrorReason;
+          gAccountsService._checkIfPasswordStillMissing();
+        }
+        return this._password;
+      }
+    }
+    return "";
+  },
+  _checkIfPasswordStillMissing() {
+    if (
+      this._connectionErrorReason != Ci.imIAccount.ERROR_MISSING_PASSWORD ||
+      !this.password
+    ) {
+      return;
+    }
+
+    delete this._connectionErrorReason;
+    this._sendUpdateNotification();
+  },
+  get _passwordRequired() {
+    return !this.protocol.noPassword && !this.protocol.passwordOptional;
+  },
+  set password(aPassword) {
+    this._password = aPassword;
+    if (gUserCanceledPrimaryPasswordPrompt) {
+      return;
+    }
+    let newLogin = Cc["@mozilla.org/login-manager/loginInfo;1"].createInstance(
+      Ci.nsILoginInfo
+    );
+    let passwordURI = "im://" + this.protocol.id;
+    newLogin.init(
+      passwordURI,
+      null,
+      passwordURI,
+      this.normalizedName,
+      aPassword,
+      "",
+      ""
+    );
+    try {
+      let logins = Services.logins.findLogins(passwordURI, null, passwordURI);
+      let saved = false;
+      for (let login of logins) {
+        if (newLogin.matches(login, true)) {
+          if (aPassword) {
+            Services.logins.modifyLogin(login, newLogin);
+          } else {
+            Services.logins.removeLogin(login);
+          }
+          saved = true;
+          break;
+        }
+      }
+      if (!saved && aPassword) {
+        Services.logins.addLogin(newLogin);
+      }
+    } catch (e) {
+      this._handlePrimaryPasswordException(e);
+    }
+
+    this._connectionInfoChanged();
+    if (
+      aPassword &&
+      this._connectionErrorReason == Ci.imIAccount.ERROR_MISSING_PASSWORD
+    ) {
+      this._connectionErrorReason = Ci.imIAccount.NO_ERROR;
+    } else if (!aPassword && this._passwordRequired) {
+      this._connectionErrorReason = Ci.imIAccount.ERROR_MISSING_PASSWORD;
+    }
+    this._sendUpdateNotification();
+  },
+  _handlePrimaryPasswordException(aException) {
+    if (aException.result != Cr.NS_ERROR_ABORT) {
+      throw aException;
+    }
+
+    gUserCanceledPrimaryPasswordPrompt = true;
+    executeSoon(function () {
+      gUserCanceledPrimaryPasswordPrompt = false;
+    });
+  },
+
+  get autoLogin() {
+    return this.prefBranch.getBoolPref(kPrefAccountAutoLogin, true);
+  },
+  set autoLogin(val) {
+    this.prefBranch.setBoolPref(kPrefAccountAutoLogin, val);
+    SavePrefTimer.initTimer();
+    this._sendUpdateNotification();
+  },
+  _autoLoginPending: false,
+  checkAutoLogin() {
+    // No auto-login if: the account has an error at the imIAccount level
+    // (unknown protocol, missing password, first connection crashed),
+    // the account is already connected or connecting, or autoLogin is off.
+    if (
+      this._connectionErrorReason != Ci.prplIAccount.NO_ERROR ||
+      this.connecting ||
+      this.connected ||
+      !this.autoLogin
+    ) {
+      return;
+    }
+
+    this._autoLoginPending = true;
+    AutoLoginCounter.startAutoLogin();
+    try {
+      this.connect();
+    } catch (e) {
+      console.error(e);
+      this._finishedAutoLogin();
+    }
+  },
+  _finishedAutoLogin() {
+    if (!this.hasOwnProperty("_autoLoginPending")) {
+      return;
+    }
+    delete this._autoLoginPending;
+    AutoLoginCounter.finishedAutoLogin();
+  },
+
+  // Delete the account (from the preferences, mozStorage, and call unInit).
+  remove() {
+    let login = Cc["@mozilla.org/login-manager/loginInfo;1"].createInstance(
+      Ci.nsILoginInfo
+    );
+    let passwordURI = "im://" + this.protocol.id;
+    // Note: the normalizedName may not be exactly right if the
+    // protocol plugin is missing.
+    login.init(passwordURI, null, passwordURI, this.normalizedName, "", "", "");
+    let logins = Services.logins.findLogins(passwordURI, null, passwordURI);
+    for (let l of logins) {
+      if (login.matches(l, true)) {
+        Services.logins.removeLogin(l);
+        break;
+      }
+    }
+    if (this.connected || this.connecting) {
+      this.disconnect();
+    }
+    if (this.prplAccount) {
+      this.prplAccount.remove();
+    }
+    this.unInit();
+    IMServices.contacts.forgetAccount(this.numericId);
+    for (let prefName of this.prefBranch.getChildList("")) {
+      this.prefBranch.clearUserPref(prefName);
+    }
+  },
+  unInit() {
+    // remove any pending reconnection timer.
+    this._cancelReconnection();
+
+    // Keeping a status observer could cause an immediate reconnection.
+    this._removeStatusObserver();
+
+    // remove any pending autologin preference used for crash detection.
+    this._finishedAutoLogin();
+
+    // If the first connection was pending on quit, we set it back to unknown.
+    if (this.firstConnectionState == Ci.imIAccount.FIRST_CONNECTION_PENDING) {
+      this.firstConnectionState = Ci.imIAccount.FIRST_CONNECTION_UNKNOWN;
+    }
+
+    // and make sure we cleanup the save pref timer.
+    SavePrefTimer.unInitTimer();
+
+    if (this.prplAccount) {
+      this.prplAccount.unInit();
+    }
+
+    delete this.protocol;
+    delete this.prplAccount;
+  },
+
+  get _ensurePrplAccount() {
+    if (this.prplAccount) {
+      return this.prplAccount;
+    }
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+  connect() {
+    if (!this.prplAccount) {
+      throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+    }
+
+    if (this._passwordRequired) {
+      // If the previous connection attempt failed because we have a wrong password,
+      // clear the passwor cache so that if there's no password in the password
+      // manager the user gets prompted again.
+      if (
+        this.connectionErrorReason ==
+        Ci.prplIAccount.ERROR_AUTHENTICATION_FAILED
+      ) {
+        delete this._password;
+      }
+
+      let password = this.password;
+      if (!password) {
+        let prompts = Services.prompt;
+        let shouldSave = { value: false };
+        password = { value: "" };
+        if (
+          !prompts.promptPassword(
+            null,
+            lazy._("passwordPromptTitle", this.name),
+            lazy._("passwordPromptText", this.name),
+            password,
+            lazy._("passwordPromptSaveCheckbox"),
+            shouldSave
+          )
+        ) {
+          return;
+        }
+
+        if (shouldSave.value) {
+          this.password = password.value;
+        } else {
+          this._password = password.value;
+        }
+      }
+    }
+
+    if (!this._statusObserver) {
+      this._statusObserver = {
+        observe: function (aSubject, aTopic, aData) {
+          // Disconnect or reconnect the account automatically, otherwise notify
+          // the prplAccount instance.
+          let statusType = aSubject.statusType;
+          let connectionErrorReason = this.connectionErrorReason;
+          if (statusType == Ci.imIStatusInfo.STATUS_OFFLINE) {
+            if (this.connected || this.connecting) {
+              this.prplAccount.disconnect();
+            }
+            this._cancelReconnection();
+          } else if (
+            statusType > Ci.imIStatusInfo.STATUS_OFFLINE &&
+            this.disconnected &&
+            (connectionErrorReason == Ci.prplIAccount.NO_ERROR ||
+              connectionErrorReason == Ci.prplIAccount.ERROR_NETWORK_ERROR ||
+              connectionErrorReason == Ci.prplIAccount.ERROR_ENCRYPTION_ERROR)
+          ) {
+            this.prplAccount.connect();
+          } else if (this.connected) {
+            this.prplAccount.observe(aSubject, aTopic, aData);
+          }
+        }.bind(this),
+      };
+
+      this.statusInfo.addObserver(this._statusObserver);
+    }
+
+    if (
+      !Services.io.offline &&
+      this.statusInfo.statusType > Ci.imIStatusInfo.STATUS_OFFLINE &&
+      this.disconnected
+    ) {
+      this.prplAccount.connect();
+    }
+  },
+  disconnect() {
+    this._removeStatusObserver();
+    if (!this.disconnected) {
+      this._ensurePrplAccount.disconnect();
+    }
+  },
+
+  get disconnected() {
+    return this.connectionState == Ci.imIAccount.STATE_DISCONNECTED;
+  },
+  get connected() {
+    return this.connectionState == Ci.imIAccount.STATE_CONNECTED;
+  },
+  get connecting() {
+    return this.connectionState == Ci.imIAccount.STATE_CONNECTING;
+  },
+  get disconnecting() {
+    return this.connectionState == Ci.imIAccount.STATE_DISCONNECTING;
+  },
+
+  _cancelReconnection() {
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      delete this._reconnectTimer;
+    }
+    delete this.reconnectAttempt;
+    delete this.timeOfNextReconnect;
+  },
+  cancelReconnection() {
+    if (!this.disconnected) {
+      throw Components.Exception("", Cr.NS_ERROR_UNEXPECTED);
+    }
+
+    // Ensure we don't keep a status observer that could re-enable the
+    // auto-reconnect timers.
+    this.disconnect();
+
+    this._cancelReconnection();
+  },
+  createConversation(aName) {
+    return this._ensurePrplAccount.createConversation(aName);
+  },
+  addBuddy(aTag, aName) {
+    this._ensurePrplAccount.addBuddy(aTag, aName);
+  },
+  loadBuddy(aBuddy, aTag) {
+    if (this.prplAccount) {
+      return this.prplAccount.loadBuddy(aBuddy, aTag);
+    }
+    // Generate dummy account buddies for unknown protocols.
+    return new UnknownAccountBuddy(this, aBuddy, aTag);
+  },
+  requestBuddyInfo(aBuddyName) {
+    this._ensurePrplAccount.requestBuddyInfo(aBuddyName);
+  },
+  getChatRoomFields() {
+    return this._ensurePrplAccount.getChatRoomFields();
+  },
+  getChatRoomDefaultFieldValues(aDefaultChatName) {
+    return this._ensurePrplAccount.getChatRoomDefaultFieldValues(
+      aDefaultChatName
+    );
+  },
+  get canJoinChat() {
+    return this.prplAccount ? this.prplAccount.canJoinChat : false;
+  },
+  joinChat(aComponents) {
+    this._ensurePrplAccount.joinChat(aComponents);
+  },
+  setBool(aName, aVal) {
+    this.prefBranch.setBoolPref(kAccountOptionPrefPrefix + aName, aVal);
+    this._connectionInfoChanged();
+    if (this.prplAccount) {
+      this.prplAccount.setBool(aName, aVal);
+    }
+    SavePrefTimer.initTimer();
+  },
+  setInt(aName, aVal) {
+    this.prefBranch.setIntPref(kAccountOptionPrefPrefix + aName, aVal);
+    this._connectionInfoChanged();
+    if (this.prplAccount) {
+      this.prplAccount.setInt(aName, aVal);
+    }
+    SavePrefTimer.initTimer();
+  },
+  setString(aName, aVal) {
+    this.prefBranch.setStringPref(kAccountOptionPrefPrefix + aName, aVal);
+    this._connectionInfoChanged();
+    if (this.prplAccount) {
+      this.prplAccount.setString(aName, aVal);
+    }
+    SavePrefTimer.initTimer();
+  },
+  save() {
+    SavePrefTimer.saveNow();
+  },
+
+  getSessions() {
+    return this._ensurePrplAccount.getSessions();
+  },
+  get encryptionStatus() {
+    return this._ensurePrplAccount.encryptionStatus;
+  },
+};
+
+var gAccountsService = null;
+
+export function AccountsService() {}
+AccountsService.prototype = {
+  initAccounts() {
+    this._initAutoLoginStatus();
+    this._accounts = [];
+    this._accountsById = {};
+    gAccountsService = this;
+    let accountIdArray = MailServices.accounts.accounts
+      .map(account => account.incomingServer.getCharValue("imAccount"))
+      .filter(accountKey => accountKey?.startsWith(kAccountKeyPrefix));
+    for (let account of accountIdArray) {
+      new imAccount(account);
+    }
+
+    this._prefObserver = this.observe.bind(this);
+    Services.prefs.addObserver(kPrefAccountOrder, this._prefObserver);
+  },
+
+  _prefObserver: null,
+  observe(aSubject, aTopic, aData) {
+    if (aTopic != "nsPref:changed" || aData != kPrefAccountOrder) {
+      return;
+    }
+
+    const imAccounts = MailServices.accounts.accounts
+      .map(account => account.incomingServer.getCharValue("imAccount"))
+      .filter(k => k?.startsWith(kAccountKeyPrefix))
+      .map(k =>
+        this.getAccountByNumericId(parseInt(k.substr(kAccountKeyPrefix.length)))
+      )
+      .filter(a => a);
+
+    // Only update _accounts if it's a reorder operation
+    if (imAccounts.length == this._accounts.length) {
+      this._accounts = imAccounts;
+      Services.obs.notifyObservers(this, "account-list-updated");
+    }
+  },
+
+  unInitAccounts() {
+    for (let account of this._accounts) {
+      account.unInit();
+    }
+    gAccountsService = null;
+    delete this._accounts;
+    delete this._accountsById;
+    Services.prefs.removeObserver(kPrefAccountOrder, this._prefObserver);
+    delete this._prefObserver;
+  },
+
+  autoLoginStatus: Ci.imIAccountsService.AUTOLOGIN_ENABLED,
+  _initAutoLoginStatus() {
+    /* If auto-login is already disabled, do nothing */
+    if (this.autoLoginStatus != Ci.imIAccountsService.AUTOLOGIN_ENABLED) {
+      return;
+    }
+
+    let prefs = Services.prefs;
+    if (!prefs.getIntPref("messenger.startup.action")) {
+      // the value 0 means that we start without connecting the accounts
+      this.autoLoginStatus = Ci.imIAccountsService.AUTOLOGIN_USER_DISABLED;
+      return;
+    }
+
+    /* Disable auto-login if we are running in safe mode */
+    if (Services.appinfo.inSafeMode) {
+      this.autoLoginStatus = Ci.imIAccountsService.AUTOLOGIN_SAFE_MODE;
+      return;
+    }
+
+    /* Check if we crashed at the last startup during autologin */
+    let autoLoginPending;
+    if (
+      prefs.getPrefType(kPrefAutologinPending) == prefs.PREF_INVALID ||
+      !(autoLoginPending = prefs.getIntPref(kPrefAutologinPending))
+    ) {
+      // if the pref isn't set, then we haven't crashed: keep autologin enabled
+      return;
+    }
+
+    // Last autologin hasn't finished properly.
+    // For now, assume it's because of a crash.
+    this.autoLoginStatus = Ci.imIAccountsService.AUTOLOGIN_CRASH;
+    prefs.deleteBranch(kPrefAutologinPending);
+
+    // If the crash reporter isn't built, we can't know anything more.
+    if (!("nsICrashReporter" in Ci)) {
+      return;
+    }
+
+    try {
+      // Try to get more info with breakpad
+      let lastCrashTime = 0;
+
+      /* Locate the LastCrash file */
+      let lastCrash = Services.dirsvc.get("UAppData", Ci.nsIFile);
+      lastCrash.append("Crash Reports");
+      lastCrash.append("LastCrash");
+      if (lastCrash.exists()) {
+        /* Ok, the file exists, now let's try to read it */
+        let is = Cc["@mozilla.org/network/file-input-stream;1"].createInstance(
+          Ci.nsIFileInputStream
+        );
+        let sis = Cc["@mozilla.org/scriptableinputstream;1"].createInstance(
+          Ci.nsIScriptableInputStream
+        );
+        is.init(lastCrash, -1, 0, 0);
+        sis.init(sis);
+
+        lastCrashTime = parseInt(sis.read(lastCrash.fileSize));
+
+        sis.close();
+      }
+      // The file not existing is totally acceptable, it just means that
+      // either we never crashed or breakpad is not enabled.
+      // In this case, lastCrashTime will keep its 0 initialization value.
+
+      /* dump("autoLoginPending = " + autoLoginPending +
+              ", lastCrash = " + lastCrashTime +
+              ", difference = " + lastCrashTime - autoLoginPending + "\n");*/
+
+      if (lastCrashTime < autoLoginPending) {
+        // the last crash caught by breakpad is older than our last autologin
+        // attempt.
+        // If breakpad is currently enabled, we can be confident that
+        // autologin was interrupted for an exterior reason
+        // (application killed by the user, power outage, ...)
+        try {
+          Services.appinfo
+            .QueryInterface(Ci.nsICrashReporter)
+            .annotateCrashReport("=", "");
+        } catch (e) {
+          // This should fail with NS_ERROR_INVALID_ARG if breakpad is enabled,
+          // and NS_ERROR_NOT_INITIALIZED if it is not.
+          if (e.result != Cr.NS_ERROR_NOT_INITIALIZED) {
+            this.autoLoginStatus = Ci.imIAccountsService.AUTOLOGIN_ENABLED;
+          }
+        }
+      }
+    } catch (e) {
+      // if we failed to get the last crash time, then keep the
+      // AUTOLOGIN_CRASH value in mAutoLoginStatus and return.
+    }
+  },
+
+  processAutoLogin() {
+    if (!this._accounts) {
+      // if we're already shutting down
+      return;
+    }
+
+    for (let account of this._accounts) {
+      account.checkAutoLogin();
+    }
+
+    // Make sure autologin is now enabled, so that we don't display a
+    // message stating that it is disabled and asking the user if it
+    // should be processed now.
+    this.autoLoginStatus = Ci.imIAccountsService.AUTOLOGIN_ENABLED;
+
+    // Notify observers so that any message stating that autologin is
+    // disabled can be removed
+    Services.obs.notifyObservers(this, "autologin-processed");
+  },
+
+  _checkingIfPasswordStillMissing: false,
+  _checkIfPasswordStillMissing() {
+    // Avoid recursion.
+    if (this._checkingIfPasswordStillMissing) {
+      return;
+    }
+
+    this._checkingIfPasswordStillMissing = true;
+    for (let account of this._accounts) {
+      account._checkIfPasswordStillMissing();
+    }
+    delete this._checkingIfPasswordStillMissing;
+  },
+
+  getAccountById(aAccountId) {
+    if (!aAccountId.startsWith(kAccountKeyPrefix)) {
+      throw Components.Exception(
+        `Invalid id: ${aAccountId}`,
+        Cr.NS_ERROR_INVALID_ARG
+      );
+    }
+
+    let id = parseInt(aAccountId.substr(kAccountKeyPrefix.length));
+    return this.getAccountByNumericId(id);
+  },
+
+  _keepAccount(aAccount) {
+    this._accounts.push(aAccount);
+    this._accountsById[aAccount.numericId] = aAccount;
+  },
+  getAccountByNumericId(aAccountId) {
+    return this._accountsById[aAccountId];
+  },
+  getAccounts() {
+    return this._accounts;
+  },
+
+  createAccount(aName, aPrpl) {
+    // Ensure an account with the same name and protocol doesn't already exist.
+    let prpl = IMServices.core.getProtocolById(aPrpl);
+    if (!prpl) {
+      throw Components.Exception("", Cr.NS_ERROR_UNEXPECTED);
+    }
+    if (prpl.accountExists(aName)) {
+      console.error("Attempted to create a duplicate account!");
+      throw Components.Exception("", Cr.NS_ERROR_ALREADY_INITIALIZED);
+    }
+
+    /* First get a unique id for the new account. */
+    let id;
+    for (id = 1; ; ++id) {
+      if (this._accountsById.hasOwnProperty(id)) {
+        continue;
+      }
+
+      /* id isn't used by a known account, double check it isn't
+       already used in the sqlite database. This should never
+       happen, except if we have a corrupted profile. */
+      if (!IMServices.contacts.accountIdExists(id)) {
+        break;
+      }
+      Services.console.logStringMessage(
+        "No account " +
+          id +
+          " but there is some data in the buddy list for an account with this number. Your profile may be corrupted."
+      );
+    }
+
+    /* Actually create the new account. */
+    let key = kAccountKeyPrefix + id;
+    let account = new imAccount(key, aName, aPrpl);
+
+    Services.obs.notifyObservers(account, "account-added");
+    return account;
+  },
+
+  deleteAccount(aAccountId) {
+    let account = this.getAccountById(aAccountId);
+    if (!account) {
+      throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG);
+    }
+
+    let index = this._accounts.indexOf(account);
+    if (index == -1) {
+      throw Components.Exception("", Cr.NS_ERROR_UNEXPECTED);
+    }
+
+    let id = account.numericId;
+    account.remove();
+    this._accounts.splice(index, 1);
+    delete this._accountsById[id];
+    Services.obs.notifyObservers(account, "account-removed");
+  },
+
+  QueryInterface: ChromeUtils.generateQI(["imIAccountsService"]),
+  classDescription: "Accounts",
+};