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

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

24 files changed, 10336 insertions, 0 deletions

diff --git a/comm/chat/modules/CLib.sys.mjs b/comm/chat/modules/CLib.sys.mjs
new file mode 100644
index 0000000000..35226b565b
--- /dev/null
+++ b/comm/chat/modules/CLib.sys.mjs
@@ -0,0 +1,64 @@
+/* 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 { ctypes } from "resource://gre/modules/ctypes.sys.mjs";
+
+var OS = Services.appinfo.OS.toLowerCase();
+
+// type defs
+
+var FILE = ctypes.StructType("FILE");
+var fname_t = ctypes.char.ptr;
+var wchar_t = ctypes.char16_t;
+
+// Set the abi and path to CLib based on the OS.
+var libcAbi, libcPath;
+var strdup = "strdup";
+var fopen = "fopen";
+
+switch (OS) {
+  case "win32":
+  case "winnt":
+    libcAbi = ctypes.winapi_abi;
+    libcPath = ctypes.libraryName("msvcrt");
+    strdup = "_strdup";
+    fopen = "_wfopen";
+    fname_t = wchar_t.ptr;
+    break;
+  case "darwin":
+  case "dragonfly":
+  case "netbsd":
+  case "openbsd":
+    libcAbi = ctypes.default_abi;
+    libcPath = ctypes.libraryName("c");
+    break;
+  case "freebsd":
+    libcAbi = ctypes.default_abi;
+    libcPath = "libc.so.7";
+    break;
+  case "linux":
+    libcAbi = ctypes.default_abi;
+    libcPath = "libc.so.6";
+    break;
+  default:
+    throw new Error("Unknown OS");
+}
+
+var libc = ctypes.open(libcPath);
+
+export var CLib = {
+  FILE,
+  memcmp: libc.declare(
+    "memcmp",
+    libcAbi,
+    ctypes.int,
+    ctypes.void_t.ptr,
+    ctypes.void_t.ptr,
+    ctypes.size_t
+  ),
+  free: libc.declare("free", libcAbi, ctypes.void_t, ctypes.void_t.ptr),
+  strdup: libc.declare(strdup, libcAbi, ctypes.char.ptr, ctypes.char.ptr),
+  fclose: libc.declare("fclose", libcAbi, ctypes.int, FILE.ptr),
+  fopen: libc.declare(fopen, libcAbi, FILE.ptr, fname_t, fname_t),
+};
diff --git a/comm/chat/modules/IMServices.sys.mjs b/comm/chat/modules/IMServices.sys.mjs
new file mode 100644
index 0000000000..eb6036b608
--- /dev/null
+++ b/comm/chat/modules/IMServices.sys.mjs
@@ -0,0 +1,50 @@
+/* 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 { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+export const IMServices = {};
+
+XPCOMUtils.defineLazyServiceGetter(
+  IMServices,
+  "accounts",
+  "@mozilla.org/chat/accounts-service;1",
+  "imIAccountsService"
+);
+XPCOMUtils.defineLazyServiceGetter(
+  IMServices,
+  "core",
+  "@mozilla.org/chat/core-service;1",
+  "imICoreService"
+);
+XPCOMUtils.defineLazyServiceGetter(
+  IMServices,
+  "cmd",
+  "@mozilla.org/chat/commands-service;1",
+  "imICommandsService"
+);
+XPCOMUtils.defineLazyServiceGetter(
+  IMServices,
+  "contacts",
+  "@mozilla.org/chat/contacts-service;1",
+  "imIContactsService"
+);
+XPCOMUtils.defineLazyServiceGetter(
+  IMServices,
+  "conversations",
+  "@mozilla.org/chat/conversations-service;1",
+  "imIConversationsService"
+);
+XPCOMUtils.defineLazyServiceGetter(
+  IMServices,
+  "tags",
+  "@mozilla.org/chat/tags-service;1",
+  "imITagsService"
+);
+XPCOMUtils.defineLazyServiceGetter(
+  IMServices,
+  "logs",
+  "@mozilla.org/chat/logger;1",
+  "imILogger"
+);
diff --git a/comm/chat/modules/InteractiveBrowser.sys.mjs b/comm/chat/modules/InteractiveBrowser.sys.mjs
new file mode 100644
index 0000000000..700bea8a61
--- /dev/null
+++ b/comm/chat/modules/InteractiveBrowser.sys.mjs
@@ -0,0 +1,138 @@
+/* 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/. */
+
+export class CancelledError extends Error {
+  constructor() {
+    super("Interactive browser request was cancelled");
+  }
+}
+
+export var InteractiveBrowser = {
+  /**
+   * URL to redirect to for completion of the redirect.
+   *
+   * @type {string}
+   */
+  COMPLETION_URL: "https://localhost",
+
+  /**
+   * Open an interactive browser prompt that should be redirected to the completion URL.
+   *
+   * @param {string} url - URL to start the interaction from.
+   * @param {string} promptText - Prompt for the user for context to the interaction.
+   * @returns {Promise<object>} Resolves when the redirect succeeds, else rejects.
+   */
+  waitForRedirect(url, promptText) {
+    return this._browserRequest(url).then(({ window, webProgress, signal }) => {
+      window.document.title = promptText;
+      return this._listenForRedirect({
+        window,
+        webProgress,
+        signal,
+      });
+    });
+  },
+
+  /**
+   * Open a browser window to request an interaction from the user.
+   *
+   * @param {string} url - URL to load in the browser window
+   * @returns {Promise<object>} If the url is loaded, resolves with an object
+   * containing the |window|, |webRequest| and a |signal|. The |signal| is an
+   * AbortSignal that gets triggered, when the "request is cancelled", i.e. the
+   * window is closed.
+   */
+  _browserRequest(url) {
+    return new Promise((resolve, reject) => {
+      let browserRequest = {
+        promptText: "",
+        iconURI: "",
+        url,
+        _active: true,
+        abortController: new AbortController(),
+        cancelled() {
+          if (!this._active) {
+            return;
+          }
+          reject(new CancelledError());
+          this.abortController.abort();
+          this._active = false;
+        },
+        loaded(window, webProgress) {
+          if (!this._active) {
+            return;
+          }
+          resolve({ window, webProgress, signal: this.abortController.signal });
+        },
+      };
+      Services.obs.notifyObservers(browserRequest, "browser-request");
+    });
+  },
+
+  /**
+   * Listen for a browser window to redirect to the specified URL.
+   *
+   * @param {Window} param0.window - Window to listen in.
+   * @param {nsIWebProgress} param0.webProgress - Web progress instance.
+   * @param {AbortSignal} param0.signal - Abort signal indicating that this should no longer listen for redirects.
+   * @returns {Promise<string>} Resolves with the resulting redirect URL.
+   */
+  _listenForRedirect({ window, webProgress, signal }) {
+    return new Promise((resolve, reject) => {
+      let listener = {
+        QueryInterface: ChromeUtils.generateQI([
+          Ci.nsIWebProgressListener,
+          Ci.nsISupportsWeakReference,
+        ]),
+        _abortListener: () => {
+          listener._cleanUp();
+          reject(new CancelledError());
+        },
+        _cleanUp() {
+          signal.removeEventListener("abort", listener._abortListener);
+          webProgress.removeProgressListener(this);
+          window.close();
+        },
+        _checkForRedirect(currentUrl) {
+          if (!currentUrl.startsWith(InteractiveBrowser.COMPLETION_URL)) {
+            return;
+          }
+          resolve(currentUrl);
+
+          this._cleanUp();
+        },
+        onStateChange(aWebProgress, request, stateFlags, aStatus) {
+          const wpl = Ci.nsIWebProgressListener;
+          if (stateFlags & (wpl.STATE_START | wpl.STATE_IS_NETWORK)) {
+            try {
+              this._checkForRedirect(request.name);
+            } catch (error) {
+              // Ignore |name| not implemented exception
+              if (error.result !== Cr.NS_ERROR_NOT_IMPLEMENTED) {
+                throw error;
+              }
+            }
+          }
+        },
+        onLocationChange(webProgress, request, location) {
+          this._checkForRedirect(location.spec);
+        },
+        onProgressChange() {},
+        onStatusChange() {},
+        onSecurityChange() {},
+      };
+
+      if (signal.aborted) {
+        reject(new CancelledError());
+        return;
+      }
+      signal.addEventListener("abort", listener._abortListener);
+      webProgress.addProgressListener(listener, Ci.nsIWebProgress.NOTIFY_ALL);
+      const browser = window.document.getElementById("requestFrame");
+      if (browser.currentURI.spec) {
+        listener._checkForRedirect(browser.currentURI.spec);
+      }
+    });
+  },
+};
diff --git a/comm/chat/modules/NormalizedMap.sys.mjs b/comm/chat/modules/NormalizedMap.sys.mjs
new file mode 100644
index 0000000000..863de6874f
--- /dev/null
+++ b/comm/chat/modules/NormalizedMap.sys.mjs
@@ -0,0 +1,48 @@
+/* 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/. */
+
+/*
+ * A Map that automatically normalizes keys before accessing the values.
+ *
+ * The constructor takes two parameters:
+ *  aNormalize:   A function which takes a string and returns the "normalized"
+ *                version of it.
+ *  aIterable:    A iterable to prefill the map with, keys will be normalized.
+ *
+ * Returns a Map object that will automatically run aNormalize on any operations
+ * involving keys.
+ */
+export class NormalizedMap extends Map {
+  constructor(aNormalize, aIterable = []) {
+    if (typeof aNormalize != "function") {
+      throw new Error("NormalizedMap must have a normalize function!");
+    }
+    // Create the wrapped Map; use the provided iterable after normalizing the
+    // keys.
+    let entries = [...aIterable].map(([key, val]) => [aNormalize(key), val]);
+    super(entries);
+    // Note: In derived classes, super() must be called before using 'this'.
+    this._normalize = aNormalize;
+  }
+
+  // Dummy normalize function.
+  _normalize(aKey) {
+    return aKey;
+  }
+
+  // Anything that accepts a key as an input needs to be manually overridden.
+  delete(key) {
+    return super.delete(this._normalize(key));
+  }
+  get(key) {
+    return super.get(this._normalize(key));
+  }
+  has(key) {
+    return super.has(this._normalize(key));
+  }
+  set(key, val) {
+    super.set(this._normalize(key), val);
+    return this;
+  }
+}
diff --git a/comm/chat/modules/OTR.sys.mjs b/comm/chat/modules/OTR.sys.mjs
new file mode 100644
index 0000000000..33784c6bd0
--- /dev/null
+++ b/comm/chat/modules/OTR.sys.mjs
@@ -0,0 +1,1506 @@
+/* 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 { BasePromiseWorker } from "resource://gre/modules/PromiseWorker.sys.mjs";
+import { ctypes } from "resource://gre/modules/ctypes.sys.mjs";
+import { IMServices } from "resource:///modules/IMServices.sys.mjs";
+import { CLib } from "resource:///modules/CLib.sys.mjs";
+import { OTRLibLoader } from "resource:///modules/OTRLib.sys.mjs";
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+XPCOMUtils.defineLazyGetter(
+  lazy,
+  "l10n",
+  () => new Localization(["messenger/otr/otr.ftl"], true)
+);
+
+function _str(id) {
+  return lazy.l10n.formatValueSync(id);
+}
+
+function _strArgs(id, args) {
+  return lazy.l10n.formatValueSync(id, args);
+}
+
+// some helpers
+
+function setInterval(fn, delay) {
+  let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+  timer.init(fn, delay, Ci.nsITimer.TYPE_REPEATING_SLACK);
+  return timer;
+}
+
+function clearInterval(timer) {
+  timer.cancel();
+}
+
+// See: https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/Using_js-ctypes/Working_with_data#Determining_if_two_pointers_are_equal
+function comparePointers(p, q) {
+  p = ctypes.cast(p, ctypes.uintptr_t).value.toString();
+  q = ctypes.cast(q, ctypes.uintptr_t).value.toString();
+  return p === q;
+}
+
+function trustFingerprint(fingerprint) {
+  return (
+    !fingerprint.isNull() &&
+    !fingerprint.contents.trust.isNull() &&
+    fingerprint.contents.trust.readString().length > 0
+  );
+}
+
+// Report whether you think the given user is online. Return 1 if you think
+// they are, 0 if you think they aren't, -1 if you're not sure.
+function isOnline(conv) {
+  let ret = -1;
+  if (conv.buddy) {
+    ret = conv.buddy.online ? 1 : 0;
+  }
+  return ret;
+}
+
+/**
+ *
+ * @param {string} filename - File in the profile.
+ * @returns {string} Full path to given file in the profile directory.
+ */
+function profilePath(filename) {
+  return PathUtils.join(
+    Services.dirsvc.get("ProfD", Ci.nsIFile).path,
+    filename
+  );
+}
+
+// OTRLib context wrapper
+
+function Context(context) {
+  this._context = context;
+}
+
+Context.prototype = {
+  constructor: Context,
+  get username() {
+    return this._context.contents.username.readString();
+  },
+  get account() {
+    return this._context.contents.accountname.readString();
+  },
+  get protocol() {
+    return this._context.contents.protocol.readString();
+  },
+  get msgstate() {
+    return this._context.contents.msgstate;
+  },
+  get fingerprint() {
+    return this._context.contents.active_fingerprint;
+  },
+  get trust() {
+    return trustFingerprint(this.fingerprint);
+  },
+};
+
+// otr module
+
+var OTRLib;
+
+export var OTR = {
+  hasRan: false,
+  libLoaded: false,
+  once() {
+    this.hasRan = true;
+    try {
+      OTRLib = OTRLibLoader.init();
+      if (!OTRLib) {
+        return;
+      }
+      if (OTRLib && OTRLib.init()) {
+        this.initUiOps();
+        OTR.libLoaded = true;
+      }
+    } catch (e) {
+      console.log(e);
+    }
+  },
+
+  privateKeyPath: profilePath("otr.private_key"),
+  fingerprintsPath: profilePath("otr.fingerprints"),
+  instanceTagsPath: profilePath("otr.instance_tags"),
+
+  init(opts) {
+    opts = opts || {};
+
+    if (!this.hasRan) {
+      this.once();
+    }
+
+    if (!OTR.libLoaded) {
+      return;
+    }
+
+    this.userstate = OTRLib.otrl_userstate_create();
+
+    // A map of UIConvs, keyed on the target.id
+    this._convos = new Map();
+    this._observers = [];
+    this._buffer = [];
+    this._pendingSystemMessages = [];
+    this._poll_timer = null;
+
+    // Async sending may fail in the transport protocols, so periodically
+    // drop old messages from the internal buffer. Should be rare.
+    const pluck_time = 1 * 60 * 1000;
+    this._pluck_timer = setInterval(() => {
+      let buf = this._buffer;
+      let i = 0;
+      while (i < buf.length) {
+        if (Date.now() - buf[i].time > pluck_time) {
+          this.log("dropping an old message: " + buf[i].display);
+          buf.splice(i, 1);
+        } else {
+          i += 1;
+        }
+      }
+      this._pendingSystemMessages = this._pendingSystemMessages.filter(
+        info => info.time + pluck_time < Date.now()
+      );
+    }, pluck_time);
+  },
+
+  close() {
+    if (this._poll_timer) {
+      clearInterval(this._poll_timer);
+      this._poll_timer = null;
+    }
+    if (this._pluck_timer) {
+      clearInterval(this._pluck_timer);
+      this._pluck_timer = null;
+    }
+    this._buffer = null;
+  },
+
+  log(msg) {
+    this.notifyObservers(msg, "otr:log");
+  },
+
+  // load stored files from my profile
+  loadFiles() {
+    return Promise.all([
+      IOUtils.exists(this.privateKeyPath).then(exists => {
+        if (
+          exists &&
+          OTRLib.otrl_privkey_read(this.userstate, this.privateKeyPath)
+        ) {
+          throw new Error("Failed to read private keys.");
+        }
+      }),
+      IOUtils.exists(this.fingerprintsPath).then(exists => {
+        if (
+          exists &&
+          OTRLib.otrl_privkey_read_fingerprints(
+            this.userstate,
+            this.fingerprintsPath,
+            null,
+            null
+          )
+        ) {
+          throw new Error("Failed to read fingerprints.");
+        }
+      }),
+      IOUtils.exists(this.instanceTagsPath).then(exists => {
+        if (
+          exists &&
+          OTRLib.otrl_instag_read(this.userstate, this.instanceTagsPath)
+        ) {
+          throw new Error("Failed to read instance tags.");
+        }
+      }),
+    ]);
+  },
+
+  // generate a private key in a worker
+  generatePrivateKey(account, protocol) {
+    let newkey = new ctypes.void_t.ptr();
+    let err = OTRLib.otrl_privkey_generate_start(
+      OTR.userstate,
+      account,
+      protocol,
+      newkey.address()
+    );
+    if (err || newkey.isNull()) {
+      return Promise.reject("otrl_privkey_generate_start (" + err + ")");
+    }
+
+    let keyPtrSrc = newkey.toSource();
+    let re = new RegExp(
+      '^ctypes\\.voidptr_t\\(ctypes\\.UInt64\\("0x([0-9a-fA-F]+)"\\)\\)$'
+    );
+    let address;
+    let match = re.exec(keyPtrSrc);
+    if (match) {
+      address = match[1];
+    }
+
+    if (!address) {
+      OTRLib.otrl_privkey_generate_cancelled(OTR.userstate, newkey);
+      throw new Error(
+        "generatePrivateKey failed to parse ptr.toSource(): " + keyPtrSrc
+      );
+    }
+
+    let worker = new BasePromiseWorker("chrome://chat/content/otrWorker.js");
+    return worker
+      .post("generateKey", [OTRLib.path, OTRLib.otrl_version, address])
+      .then(function () {
+        let err = OTRLib.otrl_privkey_generate_finish(
+          OTR.userstate,
+          newkey,
+          OTR.privateKeyPath
+        );
+        if (err) {
+          throw new Error("otrl_privkey_generate_calculate (" + err + ")");
+        }
+      })
+      .catch(function (err) {
+        if (!newkey.isNull()) {
+          OTRLib.otrl_privkey_generate_cancelled(OTR.userstate, newkey);
+        }
+        throw err;
+      });
+  },
+
+  generatePrivateKeySync(account, protocol) {
+    let newkey = new ctypes.void_t.ptr();
+    let err = OTRLib.otrl_privkey_generate_start(
+      OTR.userstate,
+      account,
+      protocol,
+      newkey.address()
+    );
+    if (err || newkey.isNull()) {
+      return "otrl_privkey_generate_start (" + err + ")";
+    }
+
+    err = OTRLib.otrl_privkey_generate_calculate(newkey);
+    if (!err) {
+      err = OTRLib.otrl_privkey_generate_finish(
+        OTR.userstate,
+        newkey,
+        OTR.privateKeyPath
+      );
+    }
+    if (err && !newkey.isNull()) {
+      OTRLib.otrl_privkey_generate_cancelled(OTR.userstate, newkey);
+    }
+
+    if (err) {
+      return "otrl_privkey_generate_calculate (" + err + ")";
+    }
+    return null;
+  },
+
+  // write fingerprints to file synchronously
+  writeFingerprints() {
+    if (
+      OTRLib.otrl_privkey_write_fingerprints(
+        this.userstate,
+        this.fingerprintsPath
+      )
+    ) {
+      throw new Error("Failed to write fingerprints.");
+    }
+  },
+
+  // generate instance tag synchronously
+  generateInstanceTag(account, protocol) {
+    if (
+      OTRLib.otrl_instag_generate(
+        this.userstate,
+        this.instanceTagsPath,
+        account,
+        protocol
+      )
+    ) {
+      throw new Error("Failed to generate instance tag.");
+    }
+  },
+
+  // get my fingerprint
+  privateKeyFingerprint(account, protocol) {
+    let fingerprint = OTRLib.otrl_privkey_fingerprint(
+      this.userstate,
+      new OTRLib.fingerprint_t(),
+      account,
+      protocol
+    );
+    return fingerprint.isNull() ? null : fingerprint.readString();
+  },
+
+  // return a human readable string for a fingerprint
+  hashToHuman(fingerprint) {
+    let hash;
+    try {
+      hash = fingerprint.contents.fingerprint;
+    } catch (e) {}
+    if (!hash || hash.isNull()) {
+      throw new Error("No fingerprint found.");
+    }
+    let human = new OTRLib.fingerprint_t();
+    OTRLib.otrl_privkey_hash_to_human(human, hash);
+    return human.readString();
+  },
+
+  base64encode(data, dataLen) {
+    // CData objects are initialized with zeroes.  The plus one gives us
+    // our null byte so that readString below is safe.
+    let buf = ctypes.char.array(Math.floor((dataLen + 2) / 3) * 4 + 1)();
+    OTRLib.otrl_base64_encode(buf, data, dataLen); // ignore returned size
+    return buf.readString(); // str
+  },
+
+  base64decode(str) {
+    let size = str.length;
+    // +1 here so that we're safe in calling readString on data in the tests.
+    let data = ctypes.unsigned_char.array(Math.floor((size + 3) / 4) * 3 + 1)();
+    OTRLib.otrl_base64_decode(data, str, size); // ignore returned len
+    // We aren't returning the dataLen since we know the hash length in our
+    // one use case so far.
+    return data;
+  },
+
+  // Fetch list of known fingerprints, either for the given account,
+  // or for all accounts, if parameter is null.
+  knownFingerprints(forAccount) {
+    let fps = [];
+    for (
+      let context = this.userstate.contents.context_root;
+      !context.isNull();
+      context = context.contents.next
+    ) {
+      // skip child contexts
+      if (!comparePointers(context.contents.m_context, context)) {
+        continue;
+      }
+      let wContext = new Context(context);
+
+      if (forAccount) {
+        if (
+          forAccount.normalizedName != wContext.account ||
+          forAccount.protocol.normalizedName != wContext.protocol
+        ) {
+          continue;
+        }
+      }
+
+      for (
+        let fingerprint = context.contents.fingerprint_root.next;
+        !fingerprint.isNull();
+        fingerprint = fingerprint.contents.next
+      ) {
+        let trust = trustFingerprint(fingerprint);
+        fps.push({
+          fpointer: fingerprint.contents.address(),
+          fingerprint: OTR.hashToHuman(fingerprint),
+          screenname: wContext.username,
+          trust,
+          purge: false,
+        });
+      }
+    }
+    return fps;
+  },
+
+  /**
+   * Returns true, if all requested fps were removed.
+   * Returns false, if at least one fps couldn't get removed,
+   * because it's currently actively used.
+   */
+  forgetFingerprints(fps) {
+    let result = true;
+    let write = false;
+    fps.forEach(function (obj, i) {
+      if (!obj.purge) {
+        return;
+      }
+      obj.purge = false; // reset early
+      let fingerprint = obj.fpointer;
+      if (fingerprint.isNull()) {
+        return;
+      }
+      // don't remove if fp is active and we're in an encrypted state
+      let context = fingerprint.contents.context.contents.m_context;
+      for (
+        let context_itr = context;
+        !context_itr.isNull() &&
+        comparePointers(context_itr.contents.m_context, context);
+        context_itr = context_itr.contents.next
+      ) {
+        if (
+          context_itr.contents.msgstate ===
+            OTRLib.messageState.OTRL_MSGSTATE_ENCRYPTED &&
+          comparePointers(context_itr.contents.active_fingerprint, fingerprint)
+        ) {
+          result = false;
+          return;
+        }
+      }
+      write = true;
+      OTRLib.otrl_context_forget_fingerprint(fingerprint, 1);
+      fps[i] = null; // null out removed fps
+    });
+    if (write) {
+      OTR.writeFingerprints();
+    }
+    return result;
+  },
+
+  addFingerprint(context, hex) {
+    let fingerprint = new OTRLib.hash_t();
+    if (hex.length != 40) {
+      throw new Error("Invalid fingerprint value.");
+    }
+    let bytes = hex.match(/.{1,2}/g);
+    for (let i = 0; i < 20; i++) {
+      fingerprint[i] = parseInt(bytes[i], 16);
+    }
+    return OTRLib.otrl_context_find_fingerprint(
+      context._context,
+      fingerprint,
+      1,
+      null
+    );
+  },
+
+  getFingerprintsForRecipient(account, protocol, recipient) {
+    let fingers = OTR.knownFingerprints();
+    return fingers.filter(function (fg) {
+      return (
+        fg.account == account &&
+        fg.protocol == protocol &&
+        fg.screenname == recipient
+      );
+    });
+  },
+
+  isFingerprintTrusted(fingerprint) {
+    return !!OTRLib.otrl_context_is_fingerprint_trusted(fingerprint);
+  },
+
+  // update trust in fingerprint
+  setTrust(fingerprint, trust, context) {
+    // ignore if no change in trust
+    if (context && trust === context.trust) {
+      return;
+    }
+    OTRLib.otrl_context_set_trust(fingerprint, trust ? "verified" : "");
+    this.writeFingerprints();
+    if (context) {
+      this.notifyTrust(context);
+    }
+  },
+
+  notifyTrust(context) {
+    this.notifyObservers(context, "otr:msg-state");
+    this.notifyObservers(context, "otr:trust-state");
+  },
+
+  authUpdate(context, progress, success) {
+    this.notifyObservers(
+      {
+        context,
+        progress,
+        success,
+      },
+      "otr:auth-update"
+    );
+  },
+
+  // expose message states
+  getMessageState() {
+    return OTRLib.messageState;
+  },
+
+  // get context from conv
+  getContext(conv) {
+    let context = OTRLib.otrl_context_find(
+      this.userstate,
+      conv.normalizedName,
+      conv.account.normalizedName,
+      // TODO: check why sometimes normalizedName is undefined, and if
+      // that's ok. Fallback wasn't necessary in the original code.
+      conv.account.protocol.normalizedName || "",
+      OTRLib.instag.OTRL_INSTAG_BEST,
+      1,
+      null,
+      null,
+      null
+    );
+    return new Context(context);
+  },
+
+  getContextFromRecipient(account, protocol, recipient) {
+    let context = OTRLib.otrl_context_find(
+      this.userstate,
+      recipient,
+      account,
+      protocol,
+      OTRLib.instag.OTRL_INSTAG_BEST,
+      1,
+      null,
+      null,
+      null
+    );
+    return new Context(context);
+  },
+
+  getUIConvFromContext(context) {
+    return this.getUIConvForRecipient(
+      context.account,
+      context.protocol,
+      context.username
+    );
+  },
+
+  getUIConvForRecipient(account, protocol, recipient) {
+    let uiConvs = this._convos.values();
+    let uiConv = uiConvs.next();
+    while (!uiConv.done) {
+      let conv = uiConv.value.target;
+      if (
+        conv.account.normalizedName === account &&
+        conv.account.protocol.normalizedName === protocol &&
+        conv.normalizedName === recipient
+      ) {
+        // console.log("=== getUIConvForRecipient found, account: " + account + "  protocol: " + protocol + "  recip: " + recipient);
+        return uiConv.value;
+      }
+      uiConv = uiConvs.next();
+    }
+    throw new Error("Couldn't find conversation.");
+  },
+
+  getUIConvFromConv(conv) {
+    // return this._convos.get(conv.id);
+    return IMServices.conversations.getUIConversation(conv);
+  },
+
+  disconnect(conv, remove) {
+    OTRLib.otrl_message_disconnect(
+      this.userstate,
+      this.uiOps.address(),
+      null,
+      conv.account.normalizedName,
+      conv.account.protocol.normalizedName,
+      conv.normalizedName,
+      OTRLib.instag.OTRL_INSTAG_BEST
+    );
+    if (remove) {
+      let uiConv = this.getUIConvFromConv(conv);
+      if (uiConv) {
+        this.removeConversation(uiConv);
+      }
+    } else {
+      this.notifyObservers(this.getContext(conv), "otr:disconnected");
+    }
+  },
+
+  getAccountPref(prefName, accountId, defaultVal) {
+    return Services.prefs.getBoolPref(
+      "messenger.account." + accountId + ".options." + prefName,
+      defaultVal
+    );
+  },
+
+  sendQueryMsg(conv) {
+    let req = this.getAccountPref(
+      "otrRequireEncryption",
+      conv.account.id,
+      Services.prefs.getBoolPref("chat.otr.default.requireEncryption")
+    );
+    let query = OTRLib.otrl_proto_default_query_msg(
+      conv.account.normalizedName,
+      req ? OTRLib.OTRL_POLICY_ALWAYS : OTRLib.OTRL_POLICY_OPPORTUNISTIC
+    );
+    if (query.isNull()) {
+      console.error(new Error("Sending query message failed."));
+      return;
+    }
+    // Use the default msg to format the version.
+    // We don't support v1 of the protocol so this should be fine.
+    let queryMsg = /^\?OTR.*?\?/.exec(query.readString())[0] + "\n";
+    // Avoid sending any numbers in the query message, because receiving
+    // software could misinterpret it as a protocol version.
+    // See https://bugzilla.mozilla.org/show_bug.cgi?id=1536108
+    let noNumbersName = conv.account.normalizedName.replace(/[0-9]/g, "#");
+    queryMsg += _strArgs("query-msg", { name: noNumbersName });
+    this.sendOTRSystemMessage(conv, queryMsg);
+    OTRLib.otrl_message_free(query);
+  },
+
+  _pendingSystemMessages: null,
+  /**
+   * Wrapper for system messages sent by OTR to ensure they are correctly
+   * handled through the OutgoingMessage event handlers.
+   *
+   * @param {prplIConversation} conv
+   * @param {string} message
+   */
+  sendOTRSystemMessage(conv, message) {
+    this._pendingSystemMessages.push({
+      message,
+      convId: conv.id,
+      time: Date.now(),
+    });
+    conv.sendMsg(message, false, false);
+  },
+
+  trustState: {
+    TRUST_NOT_PRIVATE: 0,
+    TRUST_UNVERIFIED: 1,
+    TRUST_PRIVATE: 2,
+    TRUST_FINISHED: 3,
+  },
+
+  // Check the attributes of the OTR context, and derive how that maps
+  // to one of the above trust states, which we'll show to the user.
+  // If we have an encrypted channel, it depends on the presence of a
+  // context.trust object, if we treat is as private or unverified.
+  trust(context) {
+    let level = this.trustState.TRUST_NOT_PRIVATE;
+    switch (context.msgstate) {
+      case OTRLib.messageState.OTRL_MSGSTATE_ENCRYPTED:
+        level = context.trust
+          ? this.trustState.TRUST_PRIVATE
+          : this.trustState.TRUST_UNVERIFIED;
+        break;
+      case OTRLib.messageState.OTRL_MSGSTATE_FINISHED:
+        level = this.trustState.TRUST_FINISHED;
+        break;
+    }
+    return level;
+  },
+
+  /** @param {Context} wContext - wrapped context. */
+  getAccountPrefBranch(wContext) {
+    let account = IMServices.accounts
+      .getAccounts()
+      .find(
+        acc =>
+          wContext.account == acc.normalizedName &&
+          wContext.protocol == acc.protocol.normalizedName
+      );
+    if (!account) {
+      return null;
+    }
+    return Services.prefs.getBranch(`messenger.account.${account.id}.`);
+  },
+
+  // uiOps callbacks
+
+  /**
+   * Return the OTR policy for the given context.
+   */
+  policy_cb(opdata, context) {
+    let wContext = new Context(context);
+    let pb = OTR.getAccountPrefBranch(wContext);
+    if (!pb) {
+      return new ctypes.unsigned_int(0);
+    }
+    try {
+      let conv = OTR.getUIConvFromContext(wContext);
+      // Ensure we never try to layer OTR on top of protocol native encryption.
+      if (
+        conv.encryptionState !== Ci.prplIConversation.ENCRYPTION_NOT_SUPPORTED
+      ) {
+        return new ctypes.unsigned_int(0);
+      }
+    } catch (error) {
+      // No conversation found for the context, fall through to default logic.
+    }
+    let prefRequire = pb.getBoolPref(
+      "options.otrRequireEncryption",
+      Services.prefs.getBoolPref("chat.otr.default.requireEncryption")
+    );
+    return prefRequire
+      ? OTRLib.OTRL_POLICY_ALWAYS
+      : OTRLib.OTRL_POLICY_OPPORTUNISTIC;
+  },
+
+  /**
+   * Create a private key for the given accountname/protocol if desired.
+   */
+  create_privkey_cb(opdata, accountname, protocol) {
+    let args = {
+      account: accountname.readString(),
+      protocol: protocol.readString(),
+    };
+    this.notifyObservers(args, "otr:generate");
+  },
+
+  /**
+   * Report whether you think the given user is online. Return 1 if you
+   * think they are, 0 if you think they aren't, -1 if you're not sure.
+   */
+  is_logged_in_cb(opdata, accountname, protocol, recipient) {
+    let conv = this.getUIConvForRecipient(
+      accountname.readString(),
+      protocol.readString(),
+      recipient.readString()
+    ).target;
+    return isOnline(conv);
+  },
+
+  /**
+   * Send the given IM to the given recipient from the given
+   * accountname/protocol.
+   */
+  inject_message_cb(opdata, accountname, protocol, recipient, message) {
+    let aMsg = message.readString();
+    this.log("inject_message_cb (msglen:" + aMsg.length + "): " + aMsg);
+    this.sendOTRSystemMessage(
+      this.getUIConvForRecipient(
+        accountname.readString(),
+        protocol.readString(),
+        recipient.readString()
+      ).target,
+      aMsg
+    );
+  },
+
+  /**
+   * new fingerprint for the given user has been received.
+   */
+  new_fingerprint_cb(opdata, us, accountname, protocol, username, fingerprint) {
+    let context = OTRLib.otrl_context_find(
+      us,
+      username,
+      accountname,
+      protocol,
+      OTRLib.instag.OTRL_INSTAG_MASTER,
+      1,
+      null,
+      null,
+      null
+    );
+
+    let seen = false;
+    let fp = context.contents.fingerprint_root.next;
+    while (!fp.isNull()) {
+      if (
+        CLib.memcmp(fingerprint, fp.contents.fingerprint, new ctypes.size_t(20))
+      ) {
+        seen = true;
+        break;
+      }
+      fp = fp.contents.next;
+    }
+
+    let wContext = new Context(context);
+    let defaultNudge = Services.prefs.getBoolPref(
+      "chat.otr.default.verifyNudge"
+    );
+    let prefNudge = defaultNudge;
+    let pb = OTR.getAccountPrefBranch(wContext);
+    if (pb) {
+      prefNudge = pb.getBoolPref("options.otrVerifyNudge", defaultNudge);
+    }
+
+    // Only nudge on new fingerprint, as opposed to always.
+    if (!prefNudge) {
+      this.notifyObservers(
+        wContext,
+        "otr:unverified",
+        seen ? "seen" : "unseen"
+      );
+    }
+  },
+
+  /**
+   * The list of known fingerprints has changed.  Write them to disk.
+   */
+  write_fingerprint_cb(opdata) {
+    this.writeFingerprints();
+  },
+
+  /**
+   * A ConnContext has entered a secure state.
+   */
+  gone_secure_cb(opdata, context) {
+    let wContext = new Context(context);
+    let defaultNudge = Services.prefs.getBoolPref(
+      "chat.otr.default.verifyNudge"
+    );
+    let prefNudge = defaultNudge;
+    let pb = OTR.getAccountPrefBranch(wContext);
+    if (pb) {
+      prefNudge = pb.getBoolPref("options.otrVerifyNudge", defaultNudge);
+    }
+    let strid = wContext.trust
+      ? "context-gone-secure-private"
+      : "context-gone-secure-unverified";
+    this.notifyObservers(wContext, "otr:msg-state");
+    this.sendAlert(wContext, _strArgs(strid, { name: wContext.username }));
+    if (prefNudge && !wContext.trust) {
+      this.notifyObservers(wContext, "otr:unverified", "unseen");
+    }
+  },
+
+  /**
+   * A ConnContext has left a secure state.
+   */
+  gone_insecure_cb(opdata, context) {
+    // This isn't used. See: https://bugs.otr.im/lib/libotr/issues/48
+  },
+
+  /**
+   * We have completed an authentication, using the D-H keys we already
+   * knew.
+   *
+   * @param is_reply    indicates whether we initiated the AKE.
+   */
+  still_secure_cb(opdata, context, is_reply) {
+    // Indicate the private conversation was refreshed.
+    if (!is_reply) {
+      context = new Context(context);
+      this.notifyObservers(context, "otr:msg-state");
+      this.sendAlert(
+        context,
+        _strArgs("context-still-secure", { name: context.username })
+      );
+    }
+  },
+
+  /**
+   * Find the maximum message size supported by this protocol.
+   */
+  max_message_size_cb(opdata, context) {
+    context = new Context(context);
+    // These values are, for the most part, from pidgin-otr's mms_table.
+    switch (context.protocol) {
+      case "irc":
+      case "prpl-irc":
+        return 417;
+      case "facebook":
+      case "gtalk":
+      case "odnoklassniki":
+      case "jabber":
+      case "xmpp":
+        return 65536;
+      case "prpl-yahoo":
+        return 799;
+      case "prpl-msn":
+        return 1409;
+      case "prpl-icq":
+        return 2346;
+      case "prpl-gg":
+        return 1999;
+      case "prpl-aim":
+      case "prpl-oscar":
+        return 2343;
+      case "prpl-novell":
+        return 1792;
+      default:
+        return 0;
+    }
+  },
+
+  /**
+   * We received a request from the buddy to use the current "extra"
+   * symmetric key.
+   */
+  received_symkey_cb(opdata, context, use, usedata, usedatalen, symkey) {
+    // Ignore until we have a use.
+  },
+
+  /**
+   * Return a string according to the error event.
+   */
+  otr_error_message_cb(opdata, context, err_code) {
+    context = new Context(context);
+    let msg;
+    switch (err_code) {
+      case OTRLib.errorCode.OTRL_ERRCODE_ENCRYPTION_ERROR:
+        msg = _str("error-enc");
+        break;
+      case OTRLib.errorCode.OTRL_ERRCODE_MSG_NOT_IN_PRIVATE:
+        msg = _strArgs("error-not-priv", context.username);
+        break;
+      case OTRLib.errorCode.OTRL_ERRCODE_MSG_UNREADABLE:
+        msg = _str("error-unreadable");
+        break;
+      case OTRLib.errorCode.OTRL_ERRCODE_MSG_MALFORMED:
+        msg = _str("error-malformed");
+        break;
+      default:
+        return null;
+    }
+    return CLib.strdup(msg);
+  },
+
+  /**
+   * Deallocate a string returned by otr_error_message_cb.
+   */
+  otr_error_message_free_cb(opdata, err_msg) {
+    if (!err_msg.isNull()) {
+      CLib.free(err_msg);
+    }
+  },
+
+  /**
+   * Return a string that will be prefixed to any resent message.
+   */
+  resent_msg_prefix_cb(opdata, context) {
+    return CLib.strdup(_str("resent"));
+  },
+
+  /**
+   * Deallocate a string returned by resent_msg_prefix.
+   */
+  resent_msg_prefix_free_cb(opdata, prefix) {
+    if (!prefix.isNull()) {
+      CLib.free(prefix);
+    }
+  },
+
+  /**
+   * Update the authentication UI with respect to SMP events.
+   */
+  handle_smp_event_cb(opdata, smp_event, context, progress_percent, question) {
+    context = new Context(context);
+    switch (smp_event) {
+      case OTRLib.smpEvent.OTRL_SMPEVENT_NONE:
+        break;
+      case OTRLib.smpEvent.OTRL_SMPEVENT_ASK_FOR_ANSWER:
+      case OTRLib.smpEvent.OTRL_SMPEVENT_ASK_FOR_SECRET:
+        this.notifyObservers(
+          {
+            context,
+            progress: progress_percent,
+            question: question.isNull() ? null : question.readString(),
+          },
+          "otr:auth-ask"
+        );
+        break;
+      case OTRLib.smpEvent.OTRL_SMPEVENT_CHEATED:
+        OTR.abortSMP(context);
+      /* falls through */
+      case OTRLib.smpEvent.OTRL_SMPEVENT_IN_PROGRESS:
+      case OTRLib.smpEvent.OTRL_SMPEVENT_SUCCESS:
+      case OTRLib.smpEvent.OTRL_SMPEVENT_FAILURE:
+      case OTRLib.smpEvent.OTRL_SMPEVENT_ABORT:
+        this.authUpdate(
+          context,
+          progress_percent,
+          smp_event === OTRLib.smpEvent.OTRL_SMPEVENT_SUCCESS
+        );
+        break;
+      case OTRLib.smpEvent.OTRL_SMPEVENT_ERROR:
+        OTR.abortSMP(context);
+        break;
+      default:
+        this.log("smp event: " + smp_event);
+    }
+  },
+
+  /**
+   * Handle and send the appropriate message(s) to the sender/recipient
+   * depending on the message events.
+   */
+  handle_msg_event_cb(opdata, msg_event, context, message, err) {
+    context = new Context(context);
+    switch (msg_event) {
+      case OTRLib.messageEvent.OTRL_MSGEVENT_NONE:
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_ENCRYPTION_REQUIRED:
+        this.sendAlert(
+          context,
+          _strArgs("msgevent-encryption-required-part1", {
+            name: context.username,
+          })
+        );
+        this.sendAlert(context, _str("msgevent-encryption-required-part2"));
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_ENCRYPTION_ERROR:
+        this.sendAlert(context, _str("msgevent-encryption-error"));
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_CONNECTION_ENDED:
+        this.sendAlert(
+          context,
+          _strArgs("msgevent-connection-ended", { name: context.username })
+        );
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_SETUP_ERROR:
+        this.sendAlert(
+          context,
+          _strArgs("msgevent-setup-error", { name: context.username })
+        );
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_MSG_REFLECTED:
+        this.sendAlert(context, _str("msgevent-msg-reflected"));
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_MSG_RESENT:
+        this.sendAlert(
+          context,
+          _strArgs("msgevent-msg-resent", { name: context.username })
+        );
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_RCVDMSG_NOT_IN_PRIVATE:
+        this.sendAlert(
+          context,
+          _strArgs("msgevent-rcvdmsg-not-private", { name: context.username })
+        );
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_RCVDMSG_UNREADABLE:
+        this.sendAlert(
+          context,
+          _strArgs("msgevent-rcvdmsg-unreadable", { name: context.username })
+        );
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_RCVDMSG_MALFORMED:
+        this.sendAlert(
+          context,
+          _strArgs("msgevent-rcvdmsg-malformed", { name: context.username })
+        );
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_LOG_HEARTBEAT_RCVD:
+        this.log(
+          _strArgs("msgevent-log-heartbeat-rcvd", { name: context.username })
+        );
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_LOG_HEARTBEAT_SENT:
+        this.log(
+          _strArgs("msgevent-log-heartbeat-sent", { name: context.username })
+        );
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_RCVDMSG_GENERAL_ERR:
+        this.sendAlert(context, _str("msgevent-rcvdmsg-general-err"));
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_RCVDMSG_UNENCRYPTED:
+        this.sendAlert(
+          context,
+          _strArgs("msgevent-rcvdmsg-unencrypted", {
+            name: context.username,
+            msg: message.isNull() ? "" : message.readString(),
+          })
+        );
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_RCVDMSG_UNRECOGNIZED:
+        this.sendAlert(
+          context,
+          _strArgs("msgevent-rcvdmsg-unrecognized", { name: context.username })
+        );
+        break;
+      case OTRLib.messageEvent.OTRL_MSGEVENT_RCVDMSG_FOR_OTHER_INSTANCE:
+        this.log(
+          _strArgs("msgevent-rcvdmsg-for-other-instance", {
+            name: context.username,
+          })
+        );
+        break;
+      default:
+        this.log("msg event: " + msg_event);
+    }
+  },
+
+  /**
+   * Create an instance tag for the given accountname/protocol if
+   * desired.
+   */
+  create_instag_cb(opdata, accountname, protocol) {
+    this.generateInstanceTag(accountname.readString(), protocol.readString());
+  },
+
+  /**
+   * When timer_control is called, turn off any existing periodic timer.
+   * Additionally, if interval > 0, set a new periodic timer to go off
+   * every interval seconds.
+   */
+  timer_control_cb(opdata, interval) {
+    if (this._poll_timer) {
+      clearInterval(this._poll_timer);
+      this._poll_timer = null;
+    }
+    if (interval > 0) {
+      this._poll_timer = setInterval(() => {
+        OTRLib.otrl_message_poll(this.userstate, this.uiOps.address(), null);
+      }, interval * 1000);
+    }
+  },
+
+  // end of uiOps
+
+  initUiOps() {
+    this.uiOps = new OTRLib.OtrlMessageAppOps();
+
+    let methods = [
+      "policy",
+      "create_privkey",
+      "is_logged_in",
+      "inject_message",
+      "update_context_list", // not implemented
+      "new_fingerprint",
+      "write_fingerprint",
+      "gone_secure",
+      "gone_insecure",
+      "still_secure",
+      "max_message_size",
+      "account_name", // not implemented
+      "account_name_free", // not implemented
+      "received_symkey",
+      "otr_error_message",
+      "otr_error_message_free",
+      "resent_msg_prefix",
+      "resent_msg_prefix_free",
+      "handle_smp_event",
+      "handle_msg_event",
+      "create_instag",
+      "convert_msg", // not implemented
+      "convert_free", // not implemented
+      "timer_control",
+    ];
+
+    for (let i = 0; i < methods.length; i++) {
+      let m = methods[i];
+      if (!this[m + "_cb"]) {
+        this.uiOps[m] = null;
+        continue;
+      }
+      // keep a pointer to this in memory to avoid crashing
+      this[m + "_cb"] = OTRLib[m + "_cb_t"](this[m + "_cb"].bind(this));
+      this.uiOps[m] = this[m + "_cb"];
+    }
+  },
+
+  sendAlert(context, msg) {
+    this.getUIConvFromContext(context).systemMessage(msg, false, true);
+  },
+
+  observe(aObject, aTopic, aMsg) {
+    switch (aTopic) {
+      case "sending-message":
+        this.onSend(aObject);
+        break;
+      case "received-message":
+        this.onReceive(aObject);
+        break;
+      case "new-ui-conversation":
+        this.addConversation(aObject);
+        break;
+      case "conversation-update-type":
+        if (this._convos.has(aObject.target.id)) {
+          this._convos.get(aObject.target.id).removeObserver(this);
+        }
+        this.addConversation(aObject);
+        break;
+      case "update-conv-encryption": {
+        // Disable OTR encryption when the chat protocol initiates encryption
+        // for the conversation.
+        const context = this.getContext(aObject);
+        const trust = this.trust(context);
+        if (
+          trust === this.trustState.TRUST_NOT_PRIVATE ||
+          trust === this.trustState.TRUST_PRIVATE
+        ) {
+          this.disconnect(aObject, false);
+        }
+        break;
+      }
+    }
+  },
+
+  addConversation(uiConv) {
+    let conv = uiConv.target;
+    if (conv.isChat) {
+      return;
+    }
+    this._convos.set(conv.id, uiConv);
+    uiConv.addObserver(this);
+  },
+
+  removeConversation(uiConv) {
+    uiConv.removeObserver(this);
+    this._convos.delete(uiConv.target.id);
+    this.clearMsgs(uiConv.target.id);
+  },
+
+  sendSecret(context, secret, question) {
+    let str = ctypes.char.array()(secret);
+    let strlen = new ctypes.size_t(str.length - 1);
+    OTRLib.otrl_message_initiate_smp_q(
+      this.userstate,
+      this.uiOps.address(),
+      null,
+      context._context,
+      question ? question : null,
+      str,
+      strlen
+    );
+  },
+
+  sendResponse(context, response) {
+    let str = ctypes.char.array()(response);
+    let strlen = new ctypes.size_t(str.length - 1);
+    OTRLib.otrl_message_respond_smp(
+      this.userstate,
+      this.uiOps.address(),
+      null,
+      context._context,
+      str,
+      strlen
+    );
+  },
+
+  abortSMP(context) {
+    OTRLib.otrl_message_abort_smp(
+      this.userstate,
+      this.uiOps.address(),
+      null,
+      context._context
+    );
+  },
+
+  onSend(om) {
+    if (om.cancelled) {
+      return;
+    }
+
+    let conv = om.conversation;
+    if (conv.isChat) {
+      return;
+    }
+
+    if (om.action) {
+      // embed /me into the message text for encrypted actions.
+      let context = this.getContext(conv);
+      if (context.msgstate != this.trustState.TRUST_NOT_PRIVATE) {
+        om.cancelled = true;
+        conv.sendMsg("/me " + om.message, false, false);
+      }
+      return;
+    }
+
+    // Skip if OTR sent this message.
+    let pendingIndex = this._pendingSystemMessages.findIndex(
+      info => info.convId == conv.id && info.message == om.message
+    );
+    if (pendingIndex > -1) {
+      this._pendingSystemMessages.splice(pendingIndex, 1);
+      return;
+    }
+
+    let newMessage = new ctypes.char.ptr();
+
+    this.log("pre sending: " + om.message);
+
+    let err = OTRLib.otrl_message_sending(
+      this.userstate,
+      this.uiOps.address(),
+      null,
+      conv.account.normalizedName,
+      conv.account.protocol.normalizedName,
+      conv.normalizedName,
+      OTRLib.instag.OTRL_INSTAG_BEST,
+      om.message,
+      null,
+      newMessage.address(),
+      OTRLib.fragPolicy.OTRL_FRAGMENT_SEND_ALL_BUT_LAST,
+      null,
+      null,
+      null
+    );
+
+    let msg = om.message;
+
+    if (err) {
+      om.cancelled = true;
+      console.error(new Error("Failed to send message. Returned code: " + err));
+    } else if (!newMessage.isNull()) {
+      msg = newMessage.readString();
+      // https://bugs.otr.im/lib/libotr/issues/52
+      if (!msg) {
+        om.cancelled = true;
+      }
+    }
+
+    if (!om.cancelled) {
+      // OTR handshakes only work while both peers are online.
+      // Sometimes we want to include a special whitespace suffix,
+      // which the OTR protocol uses to signal that the sender is willing
+      // to start an OTR session. Don't do that for offline messages.
+      // See: https://bugs.otr.im/lib/libotr/issues/102
+      if (isOnline(conv) === 0) {
+        let ind = msg.indexOf(OTRLib.OTRL_MESSAGE_TAG_BASE);
+        if (ind > -1) {
+          msg = msg.substring(0, ind);
+          let context = this.getContext(conv);
+          context._context.contents.otr_offer = OTRLib.otr_offer.OFFER_NOT;
+        }
+      }
+
+      this.bufferMsg(conv.id, om.message, msg);
+      om.message = msg;
+    }
+
+    this.log("post sending (" + !om.cancelled + "): " + om.message);
+    OTRLib.otrl_message_free(newMessage);
+  },
+
+  /**
+   *
+   * @param {imIMessage} im - Incoming message.
+   */
+  onReceive(im) {
+    if (im.cancelled || im.system) {
+      return;
+    }
+
+    let conv = im.conversation;
+    if (conv.isChat) {
+      return;
+    }
+
+    // After outgoing messages have been handled in onSend,
+    // they are again passed back to us, here in onReceive.
+    // This is our chance to prevent both outgoing and incoming OTR
+    // messages from being logged here.
+    if (im.originalMessage.startsWith("?OTR")) {
+      im.otrEncrypted = true;
+    }
+
+    if (im.outgoing) {
+      this.log("outgoing message to display: " + im.displayMessage);
+      this.pluckMsg(im);
+      return;
+    }
+
+    let newMessage = new ctypes.char.ptr();
+    let tlvs = new OTRLib.OtrlTLV.ptr();
+
+    let err = OTRLib.otrl_message_receiving(
+      this.userstate,
+      this.uiOps.address(),
+      null,
+      conv.account.normalizedName,
+      conv.account.protocol.normalizedName,
+      conv.normalizedName,
+      im.displayMessage,
+      newMessage.address(),
+      tlvs.address(),
+      null,
+      null,
+      null
+    );
+
+    // An OTR message was properly decrypted.
+    if (!newMessage.isNull()) {
+      im.displayMessage = newMessage.readString();
+      // Check if it was an encrypted action message.
+      if (im.displayMessage.startsWith("/me ")) {
+        im.action = true;
+        im.displayMessage = im.displayMessage.slice(4);
+      }
+    }
+
+    // search tlvs for a disconnect msg
+    // https://bugs.otr.im/lib/libotr/issues/54
+    let tlv = OTRLib.otrl_tlv_find(tlvs, OTRLib.tlvs.OTRL_TLV_DISCONNECTED);
+    if (!tlv.isNull()) {
+      let context = this.getContext(conv);
+      this.notifyObservers(context, "otr:disconnected");
+      this.sendAlert(
+        context,
+        _strArgs("tlv-disconnected", { name: conv.normalizedName })
+      );
+    }
+
+    if (err) {
+      this.log("error (" + err + ") ignoring: " + im.displayMessage);
+      im.cancelled = true; // ignore
+    }
+
+    OTRLib.otrl_tlv_free(tlvs);
+    OTRLib.otrl_message_free(newMessage);
+  },
+
+  // observer interface
+
+  addObserver(observer) {
+    if (!this._observers.includes(observer)) {
+      this._observers.push(observer);
+    }
+  },
+
+  removeObserver(observer) {
+    this._observers = this._observers.filter(o => o !== observer);
+  },
+
+  notifyObservers(aSubject, aTopic, aData) {
+    for (let observer of this._observers) {
+      observer.observe(aSubject, aTopic, aData);
+    }
+  },
+
+  // buffer messages
+
+  /**
+   * Remove messages that were making it through the system related to a
+   * conversation.
+   *
+   * @param {number} convId - ID of the conversation to purge all messages for.
+   */
+  clearMsgs(convId) {
+    this._buffer = this._buffer.filter(msg => msg.convId !== convId);
+    this._pendingSystemMessages = this._pendingSystemMessages.filter(
+      info => info.convId !== convId
+    );
+  },
+
+  /**
+   * Save unencrypted outgoing message to a buffer so we can restore it later
+   * on when displaying it.
+   *
+   * @param {number} convId - ID of the conversation.
+   * @param {string} display - Message to display.
+   * @param {string} sent - Message that was sent.
+   */
+  bufferMsg(convId, display, sent) {
+    this._buffer.push({
+      convId,
+      display,
+      sent,
+      time: Date.now(),
+    });
+  },
+
+  /**
+   * Get the unencrypted version of an outgoing OTR encrypted message that we
+   * are handling in the incoming message path for displaying. Also discards
+   * magic OTR bytes and such for displaying.
+   *
+   * @param {imIMessage} incomingMessage - Message with an outgoing tag.
+   * @returns
+   */
+  pluckMsg(incomingMessage) {
+    for (let i = 0; i < this._buffer.length; i++) {
+      let bufferedInfo = this._buffer[i];
+      if (
+        bufferedInfo.convId === incomingMessage.conversation.id &&
+        bufferedInfo.sent === incomingMessage.displayMessage
+      ) {
+        incomingMessage.displayMessage = bufferedInfo.display;
+        this._buffer.splice(i, 1);
+        this.log("displaying: " + bufferedInfo.display);
+        return;
+      }
+    }
+    // don't display if message wasn't buffered
+    if (incomingMessage.otrEncrypted) {
+      incomingMessage.cancelled = true;
+      this.log("not displaying: " + incomingMessage.displayMessage);
+    }
+  },
+};
+
+// exports
diff --git a/comm/chat/modules/OTRLib.sys.mjs b/comm/chat/modules/OTRLib.sys.mjs
new file mode 100644
index 0000000000..b9fddbe89e
--- /dev/null
+++ b/comm/chat/modules/OTRLib.sys.mjs
@@ -0,0 +1,1151 @@
+/* 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 otrl_version = [4, 1, 1];
+
+import { CLib } from "resource:///modules/CLib.sys.mjs";
+
+import { ctypes } from "resource://gre/modules/ctypes.sys.mjs";
+
+var systemOS = Services.appinfo.OS.toLowerCase();
+
+var abi = ctypes.default_abi;
+
+var libotr, libotrPath;
+
+function getLibraryFilename(baseName, suffix) {
+  return ctypes.libraryName(baseName) + suffix;
+}
+
+function getSystemVersionedFilename() {
+  let baseName;
+  let suffix;
+
+  switch (systemOS) {
+    case "winnt":
+      baseName = "libotr-5";
+      suffix = "";
+      break;
+    case "darwin":
+      baseName = "otr.5";
+      suffix = "";
+      break;
+    default:
+      baseName = "otr";
+      suffix = ".5";
+      break;
+  }
+
+  return getLibraryFilename(baseName, suffix);
+}
+
+function getDistributionFilename() {
+  let baseName;
+  let suffix;
+
+  if (systemOS === "winnt") {
+    baseName = "libotr";
+    suffix = "";
+  } else {
+    baseName = "otr";
+    suffix = "";
+  }
+
+  return getLibraryFilename(baseName, suffix);
+}
+
+function getDistributionFullPath() {
+  let binPath = Services.dirsvc.get("XpcomLib", Ci.nsIFile).path;
+  let binDir = PathUtils.parent(binPath);
+  return PathUtils.join(binDir, getDistributionFilename());
+}
+
+function tryLoadOTR(filename, info) {
+  libotrPath = filename;
+  try {
+    libotr = ctypes.open(filename);
+  } catch (e) {
+    return `Tried to load ${filename}${info}`;
+  }
+  return "";
+}
+
+function loadExternalOTRLib() {
+  const systemInfo = " from system's standard library locations.";
+
+  let info = "";
+  // Try to load using an absolute path from our install directory
+  if (!libotr) {
+    info += tryLoadOTR(getDistributionFullPath(), "");
+  }
+
+  // Try to load using our expected filename from system directories
+  if (!libotr) {
+    info += ", " + tryLoadOTR(getDistributionFilename(), systemInfo);
+  }
+
+  // Try to load using a versioned library name
+  if (!libotr) {
+    info += ", " + tryLoadOTR(getSystemVersionedFilename(), systemInfo);
+  }
+
+  // Try other filenames
+
+  if (!libotr && systemOS == "winnt") {
+    info += ", " + tryLoadOTR(getLibraryFilename("otr.5", ""), systemInfo);
+  }
+
+  if (!libotr && systemOS == "winnt") {
+    info += ", " + tryLoadOTR(getLibraryFilename("otr-5", ""), systemInfo);
+  }
+
+  if (!libotr) {
+    info += ", " + tryLoadOTR(getLibraryFilename("otr", ""), systemInfo);
+  }
+
+  if (!libotr) {
+    throw new Error("Cannot load required OTR library; " + info);
+  }
+}
+
+export var OTRLibLoader = {
+  init() {
+    loadExternalOTRLib();
+    if (libotr) {
+      enableOTRLibJS();
+    }
+    return OTRLib;
+  },
+};
+
+// Helper function to open files with the path properly encoded.
+var callWithFILEp = function () {
+  // Windows filenames are in UTF-16.
+  let charType = systemOS === "winnt" ? "jschar" : "char";
+
+  let args = Array.from(arguments);
+  let func = args.shift() + "_FILEp";
+  let mode = ctypes[charType].array()(args.shift());
+  let ind = args.shift();
+  let filename = ctypes[charType].array()(args[ind]);
+
+  let file = CLib.fopen(filename, mode);
+  if (file.isNull()) {
+    return 1;
+  }
+
+  // Swap filename with file.
+  args[ind] = file;
+
+  let ret = OTRLib[func].apply(OTRLib, args);
+  CLib.fclose(file);
+  return ret;
+};
+
+// type defs
+
+const FILE = CLib.FILE;
+
+const time_t = ctypes.long;
+const gcry_error_t = ctypes.unsigned_int;
+const gcry_cipher_hd_t = ctypes.StructType("gcry_cipher_handle").ptr;
+const gcry_md_hd_t = ctypes.StructType("gcry_md_handle").ptr;
+const gcry_mpi_t = ctypes.StructType("gcry_mpi").ptr;
+
+const otrl_instag_t = ctypes.unsigned_int;
+const OtrlPolicy = ctypes.unsigned_int;
+const OtrlTLV = ctypes.StructType("s_OtrlTLV");
+const ConnContext = ctypes.StructType("context");
+const ConnContextPriv = ctypes.StructType("context_priv");
+const OtrlMessageAppOps = ctypes.StructType("s_OtrlMessageAppOps");
+const OtrlAuthInfo = ctypes.StructType("OtrlAuthInfo");
+const Fingerprint = ctypes.StructType("s_fingerprint");
+const s_OtrlUserState = ctypes.StructType("s_OtrlUserState");
+const OtrlUserState = s_OtrlUserState.ptr;
+const OtrlSMState = ctypes.StructType("OtrlSMState");
+const DH_keypair = ctypes.StructType("DH_keypair");
+const OtrlPrivKey = ctypes.StructType("s_OtrlPrivKey");
+const OtrlInsTag = ctypes.StructType("s_OtrlInsTag");
+const OtrlPendingPrivKey = ctypes.StructType("s_OtrlPendingPrivKey");
+
+const OTRL_PRIVKEY_FPRINT_HUMAN_LEN = 45;
+const fingerprint_t = ctypes.char.array(OTRL_PRIVKEY_FPRINT_HUMAN_LEN);
+const hash_t = ctypes.unsigned_char.array(20);
+
+const app_data_free_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+]).ptr;
+
+// enums
+
+const OtrlErrorCode = ctypes.int;
+const OtrlSMPEvent = ctypes.int;
+const OtrlMessageEvent = ctypes.int;
+const OtrlFragmentPolicy = ctypes.int;
+const OtrlConvertType = ctypes.int;
+const OtrlMessageState = ctypes.int;
+const OtrlAuthState = ctypes.int;
+const OtrlSessionIdHalf = ctypes.int;
+const OtrlSMProgState = ctypes.int;
+const NextExpectedSMP = ctypes.int;
+
+// callback signatures
+
+const policy_cb_t = ctypes.FunctionType(abi, OtrlPolicy, [
+  ctypes.void_t.ptr,
+  ConnContext.ptr,
+]).ptr;
+
+const create_privkey_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  ctypes.char.ptr,
+  ctypes.char.ptr,
+]).ptr;
+
+const is_logged_in_cb_t = ctypes.FunctionType(abi, ctypes.int, [
+  ctypes.void_t.ptr,
+  ctypes.char.ptr,
+  ctypes.char.ptr,
+  ctypes.char.ptr,
+]).ptr;
+
+const inject_message_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  ctypes.char.ptr,
+  ctypes.char.ptr,
+  ctypes.char.ptr,
+  ctypes.char.ptr,
+]).ptr;
+
+const update_context_list_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+]).ptr;
+
+const new_fingerprint_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  OtrlUserState,
+  ctypes.char.ptr,
+  ctypes.char.ptr,
+  ctypes.char.ptr,
+  ctypes.unsigned_char.array(20),
+]).ptr;
+
+const write_fingerprint_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+]).ptr;
+
+const gone_secure_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  ConnContext.ptr,
+]).ptr;
+
+const gone_insecure_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  ConnContext.ptr,
+]).ptr;
+
+const still_secure_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  ConnContext.ptr,
+  ctypes.int,
+]).ptr;
+
+const max_message_size_cb_t = ctypes.FunctionType(abi, ctypes.int, [
+  ctypes.void_t.ptr,
+  ConnContext.ptr,
+]).ptr;
+
+const account_name_cb_t = ctypes.FunctionType(abi, ctypes.char.ptr, [
+  ctypes.void_t.ptr,
+  ctypes.char.ptr,
+  ctypes.char.ptr,
+]).ptr;
+
+const account_name_free_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  ctypes.char.ptr,
+]).ptr;
+
+const received_symkey_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  ConnContext.ptr,
+  ctypes.unsigned_int,
+  ctypes.unsigned_char.ptr,
+  ctypes.size_t,
+  ctypes.unsigned_char.ptr,
+]).ptr;
+
+const otr_error_message_cb_t = ctypes.FunctionType(abi, ctypes.char.ptr, [
+  ctypes.void_t.ptr,
+  ConnContext.ptr,
+  OtrlErrorCode,
+]).ptr;
+
+const otr_error_message_free_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  ctypes.char.ptr,
+]).ptr;
+
+const resent_msg_prefix_cb_t = ctypes.FunctionType(abi, ctypes.char.ptr, [
+  ctypes.void_t.ptr,
+  ConnContext.ptr,
+]).ptr;
+
+const resent_msg_prefix_free_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  ctypes.char.ptr,
+]).ptr;
+
+const handle_smp_event_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  OtrlSMPEvent,
+  ConnContext.ptr,
+  ctypes.unsigned_short,
+  ctypes.char.ptr,
+]).ptr;
+
+const handle_msg_event_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  OtrlMessageEvent,
+  ConnContext.ptr,
+  ctypes.char.ptr,
+  gcry_error_t,
+]).ptr;
+
+const create_instag_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  ctypes.char.ptr,
+  ctypes.char.ptr,
+]).ptr;
+
+const convert_msg_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  ConnContext.ptr,
+  OtrlConvertType,
+  ctypes.char.ptr.ptr,
+  ctypes.char.ptr,
+]).ptr;
+
+const convert_free_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  ConnContext.ptr,
+  ctypes.char.ptr,
+]).ptr;
+
+const timer_control_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
+  ctypes.void_t.ptr,
+  ctypes.unsigned_int,
+]).ptr;
+
+// defines
+
+s_OtrlUserState.define([
+  { context_root: ConnContext.ptr },
+  { privkey_root: OtrlPrivKey.ptr },
+  { instag_root: OtrlInsTag.ptr },
+  { pending_root: OtrlPendingPrivKey.ptr },
+  { timer_running: ctypes.int },
+]);
+
+Fingerprint.define([
+  { next: Fingerprint.ptr },
+  { tous: Fingerprint.ptr.ptr },
+  { fingerprint: ctypes.unsigned_char.ptr },
+  { context: ConnContext.ptr },
+  { trust: ctypes.char.ptr },
+]);
+
+DH_keypair.define([
+  { groupid: ctypes.unsigned_int },
+  { priv: gcry_mpi_t },
+  { pub: gcry_mpi_t },
+]);
+
+OtrlSMState.define([
+  { secret: gcry_mpi_t },
+  { x2: gcry_mpi_t },
+  { x3: gcry_mpi_t },
+  { g1: gcry_mpi_t },
+  { g2: gcry_mpi_t },
+  { g3: gcry_mpi_t },
+  { g3o: gcry_mpi_t },
+  { p: gcry_mpi_t },
+  { q: gcry_mpi_t },
+  { pab: gcry_mpi_t },
+  { qab: gcry_mpi_t },
+  { nextExpected: NextExpectedSMP },
+  { received_question: ctypes.int },
+  { sm_prog_state: OtrlSMProgState },
+]);
+
+OtrlAuthInfo.define([
+  { authstate: OtrlAuthState },
+  { context: ConnContext.ptr },
+  { our_dh: DH_keypair },
+  { our_keyid: ctypes.unsigned_int },
+  { encgx: ctypes.unsigned_char.ptr },
+  { encgx_len: ctypes.size_t },
+  { r: ctypes.unsigned_char.array(16) },
+  { hashgx: ctypes.unsigned_char.array(32) },
+  { their_pub: gcry_mpi_t },
+  { their_keyid: ctypes.unsigned_int },
+  { enc_c: gcry_cipher_hd_t },
+  { enc_cp: gcry_cipher_hd_t },
+  { mac_m1: gcry_md_hd_t },
+  { mac_m1p: gcry_md_hd_t },
+  { mac_m2: gcry_md_hd_t },
+  { mac_m2p: gcry_md_hd_t },
+  { their_fingerprint: ctypes.unsigned_char.array(20) },
+  { initiated: ctypes.int },
+  { protocol_version: ctypes.unsigned_int },
+  { secure_session_id: ctypes.unsigned_char.array(20) },
+  { secure_session_id_len: ctypes.size_t },
+  { session_id_half: OtrlSessionIdHalf },
+  { lastauthmsg: ctypes.char.ptr },
+  { commit_sent_time: time_t },
+]);
+
+ConnContext.define([
+  { next: ConnContext.ptr },
+  { tous: ConnContext.ptr.ptr },
+  { context_priv: ConnContextPriv.ptr },
+  { username: ctypes.char.ptr },
+  { accountname: ctypes.char.ptr },
+  { protocol: ctypes.char.ptr },
+  { m_context: ConnContext.ptr },
+  { recent_rcvd_child: ConnContext.ptr },
+  { recent_sent_child: ConnContext.ptr },
+  { recent_child: ConnContext.ptr },
+  { our_instance: otrl_instag_t },
+  { their_instance: otrl_instag_t },
+  { msgstate: OtrlMessageState },
+  { auth: OtrlAuthInfo },
+  { fingerprint_root: Fingerprint },
+  { active_fingerprint: Fingerprint.ptr },
+  { sessionid: ctypes.unsigned_char.array(20) },
+  { sessionid_len: ctypes.size_t },
+  { sessionid_half: OtrlSessionIdHalf },
+  { protocol_version: ctypes.unsigned_int },
+  { otr_offer: ctypes.int },
+  { app_data: ctypes.void_t.ptr },
+  { app_data_free: app_data_free_t },
+  { smstate: OtrlSMState.ptr },
+]);
+
+OtrlMessageAppOps.define([
+  { policy: policy_cb_t },
+  { create_privkey: create_privkey_cb_t },
+  { is_logged_in: is_logged_in_cb_t },
+  { inject_message: inject_message_cb_t },
+  { update_context_list: update_context_list_cb_t },
+  { new_fingerprint: new_fingerprint_cb_t },
+  { write_fingerprint: write_fingerprint_cb_t },
+  { gone_secure: gone_secure_cb_t },
+  { gone_insecure: gone_insecure_cb_t },
+  { still_secure: still_secure_cb_t },
+  { max_message_size: max_message_size_cb_t },
+  { account_name: account_name_cb_t },
+  { account_name_free: account_name_free_cb_t },
+  { received_symkey: received_symkey_cb_t },
+  { otr_error_message: otr_error_message_cb_t },
+  { otr_error_message_free: otr_error_message_free_cb_t },
+  { resent_msg_prefix: resent_msg_prefix_cb_t },
+  { resent_msg_prefix_free: resent_msg_prefix_free_cb_t },
+  { handle_smp_event: handle_smp_event_cb_t },
+  { handle_msg_event: handle_msg_event_cb_t },
+  { create_instag: create_instag_cb_t },
+  { convert_msg: convert_msg_cb_t },
+  { convert_free: convert_free_cb_t },
+  { timer_control: timer_control_cb_t },
+]);
+
+OtrlTLV.define([
+  { type: ctypes.unsigned_short },
+  { len: ctypes.unsigned_short },
+  { data: ctypes.unsigned_char.ptr },
+  { next: OtrlTLV.ptr },
+]);
+
+// policies
+
+// const OTRL_POLICY_ALLOW_V1 = 0x01;
+const OTRL_POLICY_ALLOW_V2 = 0x02;
+
+// const OTRL_POLICY_ALLOW_V3 = 0x04;
+// See https://bugzilla.mozilla.org/show_bug.cgi?id=1550474 re v3.
+
+const OTRL_POLICY_REQUIRE_ENCRYPTION = 0x08;
+const OTRL_POLICY_SEND_WHITESPACE_TAG = 0x10;
+const OTRL_POLICY_WHITESPACE_START_AKE = 0x20;
+
+// const OTRL_POLICY_ERROR_START_AKE = 0x40;
+// Disabled to avoid automatic resend and MITM, as explained in
+// https://github.com/arlolra/ctypes-otr/issues/55
+
+var OTRLib;
+
+function enableOTRLibJS() {
+  // this must be delayed until after "libotr" is initialized
+
+  OTRLib = {
+    path: libotrPath,
+
+    // libotr API version
+    otrl_version,
+
+    init() {
+      // apply version array as arguments to the init function
+      if (this.otrl_init.apply(this, this.otrl_version)) {
+        throw new Error("Couldn't initialize libotr.");
+      }
+      return true;
+    },
+
+    // proto.h
+
+    // If we ever see this sequence in a plaintext message, we'll assume the
+    // other side speaks OTR, and try to establish a connection.
+    OTRL_MESSAGE_TAG_BASE: " \t  \t\t\t\t \t \t \t  ",
+
+    OTRL_POLICY_OPPORTUNISTIC: new ctypes.unsigned_int(
+      OTRL_POLICY_ALLOW_V2 |
+        // OTRL_POLICY_ALLOW_V3 |
+        OTRL_POLICY_SEND_WHITESPACE_TAG |
+        OTRL_POLICY_WHITESPACE_START_AKE |
+        // OTRL_POLICY_ERROR_START_AKE |
+        0
+    ),
+
+    OTRL_POLICY_ALWAYS: new ctypes.unsigned_int(
+      OTRL_POLICY_ALLOW_V2 |
+        // OTRL_POLICY_ALLOW_V3 |
+        OTRL_POLICY_REQUIRE_ENCRYPTION |
+        OTRL_POLICY_WHITESPACE_START_AKE |
+        // OTRL_POLICY_ERROR_START_AKE |
+        0
+    ),
+
+    fragPolicy: {
+      OTRL_FRAGMENT_SEND_SKIP: 0,
+      OTRL_FRAGMENT_SEND_ALL: 1,
+      OTRL_FRAGMENT_SEND_ALL_BUT_FIRST: 2,
+      OTRL_FRAGMENT_SEND_ALL_BUT_LAST: 3,
+    },
+
+    // Return a pointer to a newly-allocated OTR query message, customized
+    // with our name.  The caller should free() the result when he's done
+    // with it.
+    otrl_proto_default_query_msg: libotr.declare(
+      "otrl_proto_default_query_msg",
+      abi,
+      ctypes.char.ptr,
+      ctypes.char.ptr,
+      OtrlPolicy
+    ),
+
+    // Initialize the OTR library. Pass the version of the API you are using.
+    otrl_init: libotr.declare(
+      "otrl_init",
+      abi,
+      gcry_error_t,
+      ctypes.unsigned_int,
+      ctypes.unsigned_int,
+      ctypes.unsigned_int
+    ),
+
+    // instag.h
+
+    instag: {
+      OTRL_INSTAG_MASTER: new ctypes.unsigned_int(0),
+      OTRL_INSTAG_BEST: new ctypes.unsigned_int(1),
+      OTRL_INSTAG_RECENT: new ctypes.unsigned_int(2),
+      OTRL_INSTAG_RECENT_RECEIVED: new ctypes.unsigned_int(3),
+      OTRL_INSTAG_RECENT_SENT: new ctypes.unsigned_int(4),
+      OTRL_MIN_VALID_INSTAG: new ctypes.unsigned_int(0x100),
+    },
+
+    // Get a new instance tag for the given account and write to file.  The FILE*
+    // must be open for writing.
+    otrl_instag_generate: callWithFILEp.bind(
+      null,
+      "otrl_instag_generate",
+      "wb",
+      1
+    ),
+    otrl_instag_generate_FILEp: libotr.declare(
+      "otrl_instag_generate_FILEp",
+      abi,
+      gcry_error_t,
+      OtrlUserState,
+      FILE.ptr,
+      ctypes.char.ptr,
+      ctypes.char.ptr
+    ),
+
+    // Read our instance tag from a file on disk into the given OtrlUserState.
+    // The FILE* must be open for reading.
+    otrl_instag_read: callWithFILEp.bind(null, "otrl_instag_read", "rb", 1),
+    otrl_instag_read_FILEp: libotr.declare(
+      "otrl_instag_read_FILEp",
+      abi,
+      gcry_error_t,
+      OtrlUserState,
+      FILE.ptr
+    ),
+
+    // Write our instance tags to a file on disk.  The FILE* must be open for
+    // writing.
+    otrl_instag_write: callWithFILEp.bind(null, "otrl_instag_write", "wb", 1),
+    otrl_instag_write_FILEp: libotr.declare(
+      "otrl_instag_write_FILEp",
+      abi,
+      gcry_error_t,
+      OtrlUserState,
+      FILE.ptr
+    ),
+
+    // auth.h
+
+    authState: {
+      OTRL_AUTHSTATE_NONE: 0,
+      OTRL_AUTHSTATE_AWAITING_DHKEY: 1,
+      OTRL_AUTHSTATE_AWAITING_REVEALSIG: 2,
+      OTRL_AUTHSTATE_AWAITING_SIG: 3,
+      OTRL_AUTHSTATE_V1_SETUP: 4,
+    },
+
+    // b64.h
+
+    // base64 encode data.  Insert no linebreaks or whitespace.
+    // The buffer base64data must contain at least ((datalen+2)/3)*4 bytes of
+    // space. This function will return the number of bytes actually used.
+    otrl_base64_encode: libotr.declare(
+      "otrl_base64_encode",
+      abi,
+      ctypes.size_t,
+      ctypes.char.ptr,
+      ctypes.unsigned_char.ptr,
+      ctypes.size_t
+    ),
+
+    // base64 decode data.  Skip non-base64 chars, and terminate at the
+    // first '=', or the end of the buffer.
+    // The buffer data must contain at least ((base64len+3) / 4) * 3 bytes
+    // of space. This function will return the number of bytes actually
+    // used.
+    otrl_base64_decode: libotr.declare(
+      "otrl_base64_decode",
+      abi,
+      ctypes.size_t,
+      ctypes.unsigned_char.ptr,
+      ctypes.char.ptr,
+      ctypes.size_t
+    ),
+
+    // context.h
+
+    otr_offer: {
+      OFFER_NOT: 0,
+      OFFER_SENT: 1,
+      OFFER_REJECTED: 2,
+      OFFER_ACCEPTED: 3,
+    },
+
+    messageState: {
+      OTRL_MSGSTATE_PLAINTEXT: 0,
+      OTRL_MSGSTATE_ENCRYPTED: 1,
+      OTRL_MSGSTATE_FINISHED: 2,
+    },
+
+    // Look up a connection context by name/account/protocol/instance from the
+    // given OtrlUserState.
+    otrl_context_find: libotr.declare(
+      "otrl_context_find",
+      abi,
+      ConnContext.ptr,
+      OtrlUserState,
+      ctypes.char.ptr,
+      ctypes.char.ptr,
+      ctypes.char.ptr,
+      otrl_instag_t,
+      ctypes.int,
+      ctypes.int.ptr,
+      ctypes.void_t.ptr,
+      ctypes.void_t.ptr
+    ),
+
+    // Set the trust level for a given fingerprint.
+    otrl_context_set_trust: libotr.declare(
+      "otrl_context_set_trust",
+      abi,
+      ctypes.void_t,
+      Fingerprint.ptr,
+      ctypes.char.ptr
+    ),
+
+    // Find a fingerprint in a given context, perhaps adding it if not present.
+    otrl_context_find_fingerprint: libotr.declare(
+      "otrl_context_find_fingerprint",
+      abi,
+      Fingerprint.ptr,
+      ConnContext.ptr,
+      hash_t,
+      ctypes.int,
+      ctypes.int.ptr
+    ),
+
+    // Forget a fingerprint (and maybe the whole context).
+    otrl_context_forget_fingerprint: libotr.declare(
+      "otrl_context_forget_fingerprint",
+      abi,
+      ctypes.void_t,
+      Fingerprint.ptr,
+      ctypes.int
+    ),
+
+    // Return true iff the given fingerprint is marked as trusted.
+    otrl_context_is_fingerprint_trusted: libotr.declare(
+      "otrl_context_is_fingerprint_trusted",
+      abi,
+      ctypes.int,
+      Fingerprint.ptr
+    ),
+
+    // dh.h
+
+    sessionIdHalf: {
+      OTRL_SESSIONID_FIRST_HALF_BOLD: 0,
+      OTRL_SESSIONID_SECOND_HALF_BOLD: 1,
+    },
+
+    // sm.h
+
+    nextExpectedSMP: {
+      OTRL_SMP_EXPECT1: 0,
+      OTRL_SMP_EXPECT2: 1,
+      OTRL_SMP_EXPECT3: 2,
+      OTRL_SMP_EXPECT4: 3,
+      OTRL_SMP_EXPECT5: 4,
+    },
+
+    smProgState: {
+      OTRL_SMP_PROG_OK: 0,
+      OTRL_SMP_PROG_CHEATED: -2,
+      OTRL_SMP_PROG_FAILED: -1,
+      OTRL_SMP_PROG_SUCCEEDED: 1,
+    },
+
+    // userstate.h
+
+    // Create a new OtrlUserState.
+    otrl_userstate_create: libotr.declare(
+      "otrl_userstate_create",
+      abi,
+      OtrlUserState
+    ),
+
+    // privkey.h
+
+    // Generate a private DSA key for a given account, storing it into a file on
+    // disk, and loading it into the given OtrlUserState. Overwrite any
+    // previously generated keys for that account in that OtrlUserState.
+    otrl_privkey_generate: callWithFILEp.bind(
+      null,
+      "otrl_privkey_generate",
+      "w+b",
+      1
+    ),
+    otrl_privkey_generate_FILEp: libotr.declare(
+      "otrl_privkey_generate_FILEp",
+      abi,
+      gcry_error_t,
+      OtrlUserState,
+      FILE.ptr,
+      ctypes.char.ptr,
+      ctypes.char.ptr
+    ),
+
+    // Begin a private key generation that will potentially take place in
+    // a background thread. This routine must be called from the main
+    // thread. It will set *newkeyp, which you can pass to
+    // otrl_privkey_generate_calculate in a background thread.  If it
+    // returns gcry_error(GPG_ERR_EEXIST), then a privkey creation for
+    // this accountname/protocol is already in progress, and *newkeyp will
+    // be set to NULL.
+    otrl_privkey_generate_start: libotr.declare(
+      "otrl_privkey_generate_start",
+      abi,
+      gcry_error_t,
+      OtrlUserState,
+      ctypes.char.ptr,
+      ctypes.char.ptr,
+      ctypes.void_t.ptr.ptr
+    ),
+
+    // Do the private key generation calculation. You may call this from a
+    // background thread.  When it completes, call
+    // otrl_privkey_generate_finish from the _main_ thread.
+    otrl_privkey_generate_calculate: libotr.declare(
+      "otrl_privkey_generate_calculate",
+      abi,
+      gcry_error_t,
+      ctypes.void_t.ptr
+    ),
+
+    // Call this from the main thread only. It will write the newly created
+    // private key into the given file and store it in the OtrlUserState.
+    otrl_privkey_generate_finish: callWithFILEp.bind(
+      null,
+      "otrl_privkey_generate_finish",
+      "w+b",
+      2
+    ),
+    otrl_privkey_generate_finish_FILEp: libotr.declare(
+      "otrl_privkey_generate_finish_FILEp",
+      abi,
+      gcry_error_t,
+      OtrlUserState,
+      ctypes.void_t.ptr,
+      FILE.ptr
+    ),
+
+    // Call this from the main thread only, in the event that the background
+    // thread generating the key is cancelled. The newkey is deallocated,
+    // and must not be used further.
+    otrl_privkey_generate_cancelled: libotr.declare(
+      "otrl_privkey_generate_cancelled",
+      abi,
+      gcry_error_t,
+      OtrlUserState,
+      ctypes.void_t.ptr
+    ),
+
+    // Read a sets of private DSA keys from a file on disk into the given
+    // OtrlUserState.
+    otrl_privkey_read: callWithFILEp.bind(null, "otrl_privkey_read", "rb", 1),
+    otrl_privkey_read_FILEp: libotr.declare(
+      "otrl_privkey_read_FILEp",
+      abi,
+      gcry_error_t,
+      OtrlUserState,
+      FILE.ptr
+    ),
+
+    // Read the fingerprint store from a file on disk into the given
+    // OtrlUserState.
+    otrl_privkey_read_fingerprints: callWithFILEp.bind(
+      null,
+      "otrl_privkey_read_fingerprints",
+      "rb",
+      1
+    ),
+    otrl_privkey_read_fingerprints_FILEp: libotr.declare(
+      "otrl_privkey_read_fingerprints_FILEp",
+      abi,
+      gcry_error_t,
+      OtrlUserState,
+      FILE.ptr,
+      ctypes.void_t.ptr,
+      ctypes.void_t.ptr
+    ),
+
+    // Write the fingerprint store from a given OtrlUserState to a file on disk.
+    otrl_privkey_write_fingerprints: callWithFILEp.bind(
+      null,
+      "otrl_privkey_write_fingerprints",
+      "wb",
+      1
+    ),
+    otrl_privkey_write_fingerprints_FILEp: libotr.declare(
+      "otrl_privkey_write_fingerprints_FILEp",
+      abi,
+      gcry_error_t,
+      OtrlUserState,
+      FILE.ptr
+    ),
+
+    // The length of a string representing a human-readable version of a
+    // fingerprint (including the trailing NUL).
+    OTRL_PRIVKEY_FPRINT_HUMAN_LEN,
+
+    // Human readable fingerprint type
+    fingerprint_t,
+
+    // fingerprint value
+    hash_t,
+
+    // Calculate a human-readable hash of our DSA public key. Return it in the
+    // passed fingerprint buffer. Return NULL on error, or a pointer to the given
+    // buffer on success.
+    otrl_privkey_fingerprint: libotr.declare(
+      "otrl_privkey_fingerprint",
+      abi,
+      ctypes.char.ptr,
+      OtrlUserState,
+      fingerprint_t,
+      ctypes.char.ptr,
+      ctypes.char.ptr
+    ),
+
+    // Convert a 20-byte hash value to a 45-byte human-readable value.
+    otrl_privkey_hash_to_human: libotr.declare(
+      "otrl_privkey_hash_to_human",
+      abi,
+      ctypes.void_t,
+      fingerprint_t,
+      hash_t
+    ),
+
+    // Calculate a raw hash of our DSA public key.  Return it in the passed
+    // fingerprint buffer.  Return NULL on error, or a pointer to the given
+    // buffer on success.
+    otrl_privkey_fingerprint_raw: libotr.declare(
+      "otrl_privkey_fingerprint_raw",
+      abi,
+      ctypes.unsigned_char.ptr,
+      OtrlUserState,
+      hash_t,
+      ctypes.char.ptr,
+      ctypes.char.ptr
+    ),
+
+    // uiOps callbacks
+    policy_cb_t,
+    create_privkey_cb_t,
+    is_logged_in_cb_t,
+    inject_message_cb_t,
+    update_context_list_cb_t,
+    new_fingerprint_cb_t,
+    write_fingerprint_cb_t,
+    gone_secure_cb_t,
+    gone_insecure_cb_t,
+    still_secure_cb_t,
+    max_message_size_cb_t,
+    account_name_cb_t,
+    account_name_free_cb_t,
+    received_symkey_cb_t,
+    otr_error_message_cb_t,
+    otr_error_message_free_cb_t,
+    resent_msg_prefix_cb_t,
+    resent_msg_prefix_free_cb_t,
+    handle_smp_event_cb_t,
+    handle_msg_event_cb_t,
+    create_instag_cb_t,
+    convert_msg_cb_t,
+    convert_free_cb_t,
+    timer_control_cb_t,
+
+    // message.h
+
+    OtrlMessageAppOps,
+
+    errorCode: {
+      OTRL_ERRCODE_NONE: 0,
+      OTRL_ERRCODE_ENCRYPTION_ERROR: 1,
+      OTRL_ERRCODE_MSG_NOT_IN_PRIVATE: 2,
+      OTRL_ERRCODE_MSG_UNREADABLE: 3,
+      OTRL_ERRCODE_MSG_MALFORMED: 4,
+    },
+
+    smpEvent: {
+      OTRL_SMPEVENT_NONE: 0,
+      OTRL_SMPEVENT_ERROR: 1,
+      OTRL_SMPEVENT_ABORT: 2,
+      OTRL_SMPEVENT_CHEATED: 3,
+      OTRL_SMPEVENT_ASK_FOR_ANSWER: 4,
+      OTRL_SMPEVENT_ASK_FOR_SECRET: 5,
+      OTRL_SMPEVENT_IN_PROGRESS: 6,
+      OTRL_SMPEVENT_SUCCESS: 7,
+      OTRL_SMPEVENT_FAILURE: 8,
+    },
+
+    messageEvent: {
+      OTRL_MSGEVENT_NONE: 0,
+      OTRL_MSGEVENT_ENCRYPTION_REQUIRED: 1,
+      OTRL_MSGEVENT_ENCRYPTION_ERROR: 2,
+      OTRL_MSGEVENT_CONNECTION_ENDED: 3,
+      OTRL_MSGEVENT_SETUP_ERROR: 4,
+      OTRL_MSGEVENT_MSG_REFLECTED: 5,
+      OTRL_MSGEVENT_MSG_RESENT: 6,
+      OTRL_MSGEVENT_RCVDMSG_NOT_IN_PRIVATE: 7,
+      OTRL_MSGEVENT_RCVDMSG_UNREADABLE: 8,
+      OTRL_MSGEVENT_RCVDMSG_MALFORMED: 9,
+      OTRL_MSGEVENT_LOG_HEARTBEAT_RCVD: 10,
+      OTRL_MSGEVENT_LOG_HEARTBEAT_SENT: 11,
+      OTRL_MSGEVENT_RCVDMSG_GENERAL_ERR: 12,
+      OTRL_MSGEVENT_RCVDMSG_UNENCRYPTED: 13,
+      OTRL_MSGEVENT_RCVDMSG_UNRECOGNIZED: 14,
+      OTRL_MSGEVENT_RCVDMSG_FOR_OTHER_INSTANCE: 15,
+    },
+
+    convertType: {
+      OTRL_CONVERT_SENDING: 0,
+      OTRL_CONVERT_RECEIVING: 1,
+    },
+
+    // Deallocate a message allocated by other otrl_message_* routines.
+    otrl_message_free: libotr.declare(
+      "otrl_message_free",
+      abi,
+      ctypes.void_t,
+      ctypes.char.ptr
+    ),
+
+    // Handle a message about to be sent to the network.
+    otrl_message_sending: libotr.declare(
+      "otrl_message_sending",
+      abi,
+      gcry_error_t,
+      OtrlUserState,
+      OtrlMessageAppOps.ptr,
+      ctypes.void_t.ptr,
+      ctypes.char.ptr,
+      ctypes.char.ptr,
+      ctypes.char.ptr,
+      otrl_instag_t,
+      ctypes.char.ptr,
+      OtrlTLV.ptr,
+      ctypes.char.ptr.ptr,
+      OtrlFragmentPolicy,
+      ConnContext.ptr.ptr,
+      ctypes.void_t.ptr,
+      ctypes.void_t.ptr
+    ),
+
+    // Handle a message just received from the network.
+    otrl_message_receiving: libotr.declare(
+      "otrl_message_receiving",
+      abi,
+      ctypes.int,
+      OtrlUserState,
+      OtrlMessageAppOps.ptr,
+      ctypes.void_t.ptr,
+      ctypes.char.ptr,
+      ctypes.char.ptr,
+      ctypes.char.ptr,
+      ctypes.char.ptr,
+      ctypes.char.ptr.ptr,
+      OtrlTLV.ptr.ptr,
+      ConnContext.ptr.ptr,
+      ctypes.void_t.ptr,
+      ctypes.void_t.ptr
+    ),
+
+    // Put a connection into the PLAINTEXT state, first sending the
+    // other side a notice that we're doing so if we're currently ENCRYPTED,
+    // and we think he's logged in. Affects only the specified instance.
+    otrl_message_disconnect: libotr.declare(
+      "otrl_message_disconnect",
+      abi,
+      ctypes.void_t,
+      OtrlUserState,
+      OtrlMessageAppOps.ptr,
+      ctypes.void_t.ptr,
+      ctypes.char.ptr,
+      ctypes.char.ptr,
+      ctypes.char.ptr,
+      otrl_instag_t
+    ),
+
+    // Call this function every so often, to clean up stale private state that
+    // may otherwise stick around in memory.
+    otrl_message_poll: libotr.declare(
+      "otrl_message_poll",
+      abi,
+      ctypes.void_t,
+      OtrlUserState,
+      OtrlMessageAppOps.ptr,
+      ctypes.void_t.ptr
+    ),
+
+    // Initiate the Socialist Millionaires' Protocol.
+    otrl_message_initiate_smp: libotr.declare(
+      "otrl_message_initiate_smp",
+      abi,
+      ctypes.void_t,
+      OtrlUserState,
+      OtrlMessageAppOps.ptr,
+      ctypes.void_t.ptr,
+      ConnContext.ptr,
+      ctypes.char.ptr,
+      ctypes.size_t
+    ),
+
+    // Initiate the Socialist Millionaires' Protocol and send a prompt
+    // question to the buddy.
+    otrl_message_initiate_smp_q: libotr.declare(
+      "otrl_message_initiate_smp_q",
+      abi,
+      ctypes.void_t,
+      OtrlUserState,
+      OtrlMessageAppOps.ptr,
+      ctypes.void_t.ptr,
+      ConnContext.ptr,
+      ctypes.char.ptr,
+      ctypes.char.ptr,
+      ctypes.size_t
+    ),
+
+    // Respond to a buddy initiating the Socialist Millionaires' Protocol.
+    otrl_message_respond_smp: libotr.declare(
+      "otrl_message_respond_smp",
+      abi,
+      ctypes.void_t,
+      OtrlUserState,
+      OtrlMessageAppOps.ptr,
+      ctypes.void_t.ptr,
+      ConnContext.ptr,
+      ctypes.char.ptr,
+      ctypes.size_t
+    ),
+
+    // Abort the SMP. Called when an unexpected SMP message breaks the
+    // normal flow.
+    otrl_message_abort_smp: libotr.declare(
+      "otrl_message_abort_smp",
+      abi,
+      ctypes.void_t,
+      OtrlUserState,
+      OtrlMessageAppOps.ptr,
+      ctypes.void_t.ptr,
+      ConnContext.ptr
+    ),
+
+    // tlv.h
+
+    tlvs: {
+      OTRL_TLV_PADDING: new ctypes.unsigned_short(0x0000),
+      OTRL_TLV_DISCONNECTED: new ctypes.unsigned_short(0x0001),
+      OTRL_TLV_SMP1: new ctypes.unsigned_short(0x0002),
+      OTRL_TLV_SMP2: new ctypes.unsigned_short(0x0003),
+      OTRL_TLV_SMP3: new ctypes.unsigned_short(0x0004),
+      OTRL_TLV_SMP4: new ctypes.unsigned_short(0x0005),
+      OTRL_TLV_SMP_ABORT: new ctypes.unsigned_short(0x0006),
+      OTRL_TLV_SMP1Q: new ctypes.unsigned_short(0x0007),
+      OTRL_TLV_SYMKEY: new ctypes.unsigned_short(0x0008),
+    },
+
+    OtrlTLV,
+
+    // Return the first TLV with the given type in the chain, or NULL if one
+    // isn't found.
+    otrl_tlv_find: libotr.declare(
+      "otrl_tlv_find",
+      abi,
+      OtrlTLV.ptr,
+      OtrlTLV.ptr,
+      ctypes.unsigned_short
+    ),
+
+    // Deallocate a chain of TLVs.
+    otrl_tlv_free: libotr.declare(
+      "otrl_tlv_free",
+      abi,
+      ctypes.void_t,
+      OtrlTLV.ptr
+    ),
+  };
+}
+
+// exports
diff --git a/comm/chat/modules/OTRUI.sys.mjs b/comm/chat/modules/OTRUI.sys.mjs
new file mode 100644
index 0000000000..fdf4771607
--- /dev/null
+++ b/comm/chat/modules/OTRUI.sys.mjs
@@ -0,0 +1,998 @@
+/* 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 { IMServices } from "resource:///modules/IMServices.sys.mjs";
+import { OTR } from "resource:///modules/OTR.sys.mjs";
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+XPCOMUtils.defineLazyGetter(
+  lazy,
+  "l10n",
+  () => new Localization(["messenger/otr/otrUI.ftl"], true)
+);
+
+function _str(id) {
+  return lazy.l10n.formatValueSync(id);
+}
+
+function _strArgs(id, args) {
+  return lazy.l10n.formatValueSync(id, args);
+}
+
+const OTR_ADD_FINGER_DIALOG_URL =
+  "chrome://chat/content/otr-add-fingerprint.xhtml";
+
+const AUTH_STATUS_UNVERIFIED = "otr-auth-unverified";
+var authLabelMap;
+var trustMap;
+
+function initStrings() {
+  authLabelMap = new Map([
+    ["otr:auth-error", _str("auth-error")],
+    ["otr:auth-success", _str("auth-success")],
+    ["otr:auth-success-them", _str("auth-success-them")],
+    ["otr:auth-fail", _str("auth-fail")],
+    ["otr:auth-waiting", _str("auth-waiting")],
+  ]);
+
+  let sl = _str("start-label");
+  let al = _str("auth-label");
+  let rfl = _str("refresh-label");
+  let ral = _str("reauth-label");
+
+  trustMap = new Map([
+    [
+      OTR.trustState.TRUST_NOT_PRIVATE,
+      {
+        startLabel: sl,
+        authLabel: al,
+        disableStart: false,
+        disableEnd: true,
+        disableAuth: true,
+        class: "not-private",
+      },
+    ],
+    [
+      OTR.trustState.TRUST_UNVERIFIED,
+      {
+        startLabel: rfl,
+        authLabel: al,
+        disableStart: false,
+        disableEnd: false,
+        disableAuth: false,
+        class: "unverified",
+      },
+    ],
+    [
+      OTR.trustState.TRUST_PRIVATE,
+      {
+        startLabel: rfl,
+        authLabel: ral,
+        disableStart: false,
+        disableEnd: false,
+        disableAuth: false,
+        class: "private",
+      },
+    ],
+    [
+      OTR.trustState.TRUST_FINISHED,
+      {
+        startLabel: sl,
+        authLabel: al,
+        disableStart: false,
+        disableEnd: false,
+        disableAuth: true,
+        class: "finished",
+      },
+    ],
+  ]);
+}
+
+var windowRefs = new Map();
+
+export var OTRUI = {
+  enabled: false,
+  stringsLoaded: false,
+  globalDoc: null,
+  visibleConv: null,
+
+  debug: false,
+  logMsg(msg) {
+    if (!OTRUI.debug) {
+      return;
+    }
+    Services.console.logStringMessage(msg);
+  },
+
+  addMenuObserver() {
+    for (let win of Services.ww.getWindowEnumerator()) {
+      OTRUI.addMenus(win);
+    }
+    Services.obs.addObserver(OTRUI, "domwindowopened");
+  },
+
+  removeMenuObserver() {
+    for (let win of Services.ww.getWindowEnumerator()) {
+      OTRUI.removeMenus(win);
+    }
+    Services.obs.removeObserver(OTRUI, "domwindowopened");
+  },
+
+  addMenus(win) {
+    let doc = win.document;
+    // Account for unready windows
+    if (doc.readyState !== "complete") {
+      let listen = function () {
+        win.removeEventListener("load", listen);
+        OTRUI.addMenus(win);
+      };
+      win.addEventListener("load", listen);
+    }
+  },
+
+  removeMenus(win) {
+    let doc = win.document;
+    OTRUI.removeBuddyContextMenu(doc);
+  },
+
+  addBuddyContextMenu(buddyContextMenu, doc, contact) {
+    if (!buddyContextMenu || !OTR.libLoaded) {
+      return; // Not the buddy list context menu
+    }
+
+    let sep = doc.createXULElement("menuseparator");
+    sep.setAttribute("id", "otrsep");
+    let menuitem = doc.createXULElement("menuitem");
+    menuitem.setAttribute("label", _str("buddycontextmenu-label"));
+    menuitem.setAttribute("id", "otrcont");
+    menuitem.addEventListener("command", () => {
+      let args = OTRUI.contactWrapper(contact);
+      args.wrappedJSObject = args;
+      let features = "chrome,modal,centerscreen,resizable=no,minimizable=no";
+      Services.ww.openWindow(
+        null,
+        OTR_ADD_FINGER_DIALOG_URL,
+        "",
+        features,
+        args
+      );
+    });
+
+    buddyContextMenu.addEventListener("popupshowing", e => {
+      let target = e.target.triggerNode;
+      if (target.localName == "richlistitem") {
+        menuitem.hidden = false;
+        sep.hidden = false;
+      } else {
+        /* probably imconv */
+        menuitem.hidden = true;
+        sep.hidden = true;
+      }
+    });
+
+    buddyContextMenu.appendChild(sep);
+    buddyContextMenu.appendChild(menuitem);
+  },
+
+  removeBuddyContextMenu(doc) {
+    let s = doc.getElementById("otrsep");
+    if (s) {
+      s.remove();
+    }
+    let p = doc.getElementById("otrcont");
+    if (p) {
+      p.remove();
+    }
+  },
+
+  loopKeyGenSuccess() {
+    ChromeUtils.idleDispatch(OTRUI.genNextMissingKey);
+  },
+
+  loopKeyGenFailure(param) {
+    ChromeUtils.idleDispatch(OTRUI.genNextMissingKey);
+    OTRUI.reportKeyGenFailure(param);
+  },
+
+  reportKeyGenFailure(param) {
+    throw new Error(_strArgs("otr-genkey-failed", { error: String(param) }));
+  },
+
+  accountsToGenKey: [],
+
+  genNextMissingKey() {
+    if (OTRUI.accountsToGenKey.length == 0) {
+      return;
+    }
+
+    let acc = OTRUI.accountsToGenKey.pop();
+    let fp = OTR.privateKeyFingerprint(acc.name, acc.prot);
+    if (!fp) {
+      OTR.generatePrivateKey(acc.name, acc.prot).then(
+        OTRUI.loopKeyGenSuccess,
+        OTRUI.loopKeyGenFailure
+      );
+    } else {
+      ChromeUtils.idleDispatch(OTRUI.genNextMissingKey);
+    }
+  },
+
+  genMissingKeys() {
+    for (let acc of IMServices.accounts.getAccounts()) {
+      OTRUI.accountsToGenKey.push({
+        name: acc.normalizedName,
+        prot: acc.protocol.normalizedName,
+      });
+    }
+    ChromeUtils.idleDispatch(OTRUI.genNextMissingKey);
+  },
+
+  async init() {
+    if (!OTRUI.stringsLoaded) {
+      // HACK: calling initStrings may fail the first time due to synchronous
+      // loading of the .ftl files. If we load the files and wait for a known
+      // value asynchronously, no such failure will happen.
+      //
+      // If the value "start-label" is removed, this will fail.
+      //
+      // Also, we can't reuse this Localization object elsewhere because it
+      // fails to load values synchronously (even after calling setIsSync).
+      await new Localization(["messenger/otr/otrUI.ftl"]).formatValue(
+        "start-label"
+      );
+
+      initStrings();
+      OTRUI.stringsLoaded = true;
+    }
+
+    this.debug = Services.prefs.getBoolPref("chat.otr.trace", false);
+
+    OTR.init({});
+    if (!OTR.libLoaded) {
+      return;
+    }
+
+    this.enabled = true;
+    this.notificationbox = null;
+
+    OTR.addObserver(OTRUI);
+    OTR.loadFiles()
+      .then(function () {
+        Services.obs.addObserver(OTR, "new-ui-conversation");
+        Services.obs.addObserver(OTR, "conversation-update-type");
+        // Disabled until #76 is resolved.
+        // Services.obs.addObserver(OTRUI, "contact-added", false);
+        Services.obs.addObserver(OTRUI, "account-added");
+        // Services.obs.addObserver(OTRUI, "contact-signed-off", false);
+        Services.obs.addObserver(OTRUI, "conversation-loaded");
+        Services.obs.addObserver(OTRUI, "conversation-closed");
+        Services.obs.addObserver(OTRUI, "prpl-quit");
+
+        for (let conv of IMServices.conversations.getConversations()) {
+          OTRUI.initConv(conv);
+        }
+        OTRUI.addMenuObserver();
+
+        ChromeUtils.idleDispatch(OTRUI.genMissingKeys);
+      })
+      .catch(function (err) {
+        // console.log("===> " + err + "\n");
+        throw err;
+      });
+  },
+
+  disconnect(aConv) {
+    if (aConv) {
+      return OTR.disconnect(aConv, true);
+    }
+    let allGood = true;
+    for (let conv of IMServices.conversations.getConversations()) {
+      if (conv.isChat) {
+        continue;
+      }
+      if (!OTR.disconnect(conv, true)) {
+        allGood = false;
+      }
+    }
+    return allGood;
+  },
+
+  openAuth(window, name, mode, uiConv, contactInfo) {
+    let otrAuth = this.globalDoc.querySelector(".otr-auth");
+    otrAuth.disabled = true;
+    let win = window.openDialog(
+      "chrome://chat/content/otr-auth.xhtml",
+      "auth=" + name,
+      "centerscreen,resizable=no,minimizable=no",
+      mode,
+      uiConv,
+      contactInfo
+    );
+    windowRefs.set(name, win);
+    window.addEventListener("beforeunload", function () {
+      otrAuth.disabled = false;
+      windowRefs.delete(name);
+    });
+  },
+
+  closeAuth(context) {
+    let win = windowRefs.get(context.username);
+    if (win) {
+      win.close();
+    }
+  },
+
+  /**
+   * Hide the encryption state container and any pending notifications.
+   *
+   * @param {Element} otrContainer
+   * @param {Context} [context]
+   */
+  noOtrPossible(otrContainer, context) {
+    otrContainer.hidden = true;
+
+    if (context) {
+      OTRUI.hideUserNotifications(context);
+    } else {
+      OTRUI.hideAllOTRNotifications();
+    }
+  },
+
+  sendSystemAlert(uiConv, conv, bundleId) {
+    uiConv.systemMessage(
+      _strArgs(bundleId, { name: conv.normalizedName }),
+      false,
+      true
+    );
+  },
+
+  setNotificationBox(notificationbox) {
+    this.globalBox = notificationbox;
+  },
+
+  /*
+   * These states are only relevant if OTR is the only encryption available for
+   * the conversation. Protocol provided encryption takes priority.
+   *  possible states:
+   *    tab isn't a 1:1, isChat == true
+   *      then OTR isn't possible, hide the button
+   *    tab is a 1:1, isChat == false
+   *      no conversation active, uiConv cannot be found
+   *        then OTR isn't possible YET, hide the button
+   *      conversation active, uiConv found
+   *        disconnected?
+   *          could the other side come back? should we keep the button?
+   *        set the state based on the OTR library state
+   */
+
+  /**
+   * Store a reference to the document, as well as the current conversation.
+   *
+   * @param {Element} aObject - conversation-browser instance (most importantly, has a _conv field)
+   */
+  addButton(aObject) {
+    this.globalDoc = aObject.ownerDocument;
+    let _conv = aObject._conv;
+    OTRUI.visibleConv = _conv;
+    if (
+      _conv.encryptionState === Ci.prplIConversation.ENCRYPTION_NOT_SUPPORTED
+    ) {
+      OTRUI.setMsgState(_conv, null, this.globalDoc, true);
+    }
+  },
+
+  /**
+   * Hide the encryption state information for the current conversation.
+   */
+  hideOTRButton() {
+    if (!OTR.libLoaded) {
+      return;
+    }
+    if (!this.globalDoc) {
+      return;
+    }
+    OTRUI.visibleConv = null;
+    let otrContainer = this.globalDoc.querySelector(".encryption-container");
+    OTRUI.noOtrPossible(otrContainer);
+  },
+
+  /**
+   * Sets the visible conversation of the OTR UI state and ensures
+   * the encryption state button is set up correctly.
+   *
+   * @param {prplIConversation} _conv
+   */
+  updateOTRButton(_conv) {
+    if (
+      _conv.encryptionState !== Ci.prplIConversation.ENCRYPTION_NOT_SUPPORTED
+    ) {
+      return;
+    }
+    if (!OTR.libLoaded) {
+      return;
+    }
+    if (!this.globalDoc) {
+      return;
+    }
+    OTRUI.visibleConv = _conv;
+    let convBinding;
+    for (let element of this.globalDoc.getElementById("conversationsBox")
+      .children) {
+      if (!element.hidden) {
+        convBinding = element;
+        break;
+      }
+    }
+    if (convBinding && convBinding._conv && convBinding._conv.target) {
+      OTRUI.setMsgState(_conv, null, this.globalDoc, false);
+    } else {
+      this.hideOTRButton();
+    }
+  },
+
+  /**
+   * Set encryption state on selector for conversation.
+   *
+   * @param {prplIConversation} _conv - Must match the visible conversation.
+   * @param {Context} [context] - The OTR context for the conversation.
+   * @param {DOMDocument} doc
+   * @param {boolean} [addSystemMessage] - If a system message with the conversation security.
+   */
+  setMsgState(_conv, context, doc, addSystemMessage) {
+    if (!this.visibleConv) {
+      return;
+    }
+    if (_conv != null && !(_conv === this.visibleConv)) {
+      return;
+    }
+
+    let otrContainer = doc.querySelector(".encryption-container");
+    let otrButton = doc.querySelector(".encryption-button");
+    if (_conv != null && _conv.isChat) {
+      OTRUI.noOtrPossible(otrContainer, context);
+      return;
+    }
+
+    if (!context && _conv != null) {
+      context = OTR.getContext(_conv);
+      if (!context) {
+        OTRUI.noOtrPossible(otrContainer, null);
+      }
+    }
+
+    try {
+      let uiConv = OTR.getUIConvFromContext(context);
+      if (uiConv != null && !(uiConv === this.visibleConv)) {
+        return;
+      }
+      if (
+        uiConv.encryptionState === Ci.prplIConversation.ENCRYPTION_ENABLED ||
+        uiConv.encryptionState === Ci.prplIConversation.ENCRYPTION_TRUSTED
+      ) {
+        return;
+      }
+
+      if (uiConv.isChat) {
+        OTRUI.noOtrPossible(otrContainer, context);
+        return;
+      }
+      if (addSystemMessage) {
+        let trust = OTRUI.getTrustSettings(context);
+        let id = "state-" + trust.class;
+        let msg;
+        if (OTR.trust(context) == OTR.trustState.TRUST_NOT_PRIVATE) {
+          msg = lazy.l10n.formatValueSync(id);
+        } else {
+          msg = lazy.l10n.formatValueSync(id, { name: context.username });
+        }
+        uiConv.systemMessage(msg, false, true);
+      }
+    } catch (e) {
+      OTRUI.noOtrPossible(otrContainer, context);
+      return;
+    }
+
+    otrContainer.hidden = false;
+    let otrStart = doc.querySelector(".otr-start");
+    let otrEnd = doc.querySelector(".otr-end");
+    let otrAuth = doc.querySelector(".otr-auth");
+    let trust = OTRUI.getTrustSettings(context);
+    otrButton.setAttribute(
+      "tooltiptext",
+      _strArgs("state-" + trust.class, { name: context.username })
+    );
+    otrButton.setAttribute("label", _str("state-" + trust.class + "-label"));
+    otrButton.className = "encryption-button encryption-" + trust.class;
+    otrStart.setAttribute("label", trust.startLabel);
+    otrStart.setAttribute("disabled", trust.disableStart);
+    otrEnd.setAttribute("disabled", trust.disableEnd);
+    otrAuth.setAttribute("label", trust.authLabel);
+    otrAuth.setAttribute("disabled", trust.disableAuth);
+    OTRUI.hideAllOTRNotifications();
+    OTRUI.showUserNotifications(context);
+  },
+
+  alertTrust(context) {
+    let uiConv = OTR.getUIConvFromContext(context);
+    let trust = OTRUI.getTrustSettings(context);
+    uiConv.systemMessage(
+      _strArgs("afterauth-" + trust.class, { name: context.username }),
+      false,
+      true
+    );
+  },
+
+  getTrustSettings(context) {
+    let result = trustMap.get(OTR.trust(context));
+    return result;
+  },
+
+  askAuth(aObject) {
+    let uiConv = OTR.getUIConvFromContext(aObject.context);
+    if (!uiConv) {
+      return;
+    }
+
+    let name = uiConv.target.normalizedName;
+    let msg = _strArgs("verify-request", { name });
+    // Trigger the update of the unread message counter.
+    uiConv.notifyVerifyOTR(msg);
+    Services.obs.notifyObservers(uiConv, "new-otr-verification-request");
+
+    let window = this.globalDoc.defaultView;
+    let buttons = [
+      {
+        label: _str("finger-verify"),
+        accessKey: _str("finger-verify-access-key"),
+        callback() {
+          OTRUI.openAuth(window, name, "ask", uiConv, aObject);
+          // prevent closing of notification bar when the button is hit
+          return true;
+        },
+      },
+      {
+        label: _str("finger-ignore"),
+        accessKey: _str("finger-ignore-access-key"),
+        callback() {
+          let context = OTR.getContext(uiConv.target);
+          OTR.abortSMP(context);
+        },
+      },
+    ];
+
+    let notification = this.globalBox.appendNotification(
+      `ask-auth-${name}`,
+      {
+        label: msg,
+        priority: this.globalBox.PRIORITY_WARNING_MEDIUM,
+      },
+      buttons
+    );
+
+    notification.removeAttribute("dismissable");
+  },
+
+  closeAskAuthNotification(aObject) {
+    let name = aObject.context.username;
+    let notification = this.globalBox.getNotificationWithValue(
+      `ask-auth-${name}`
+    );
+    if (!notification) {
+      return;
+    }
+
+    this.globalBox.removeNotification(notification);
+  },
+
+  closeUnverified(context) {
+    let uiConv = OTR.getUIConvFromContext(context);
+    if (!uiConv) {
+      return;
+    }
+
+    for (let notification of this.globalBox.allNotifications) {
+      if (
+        context.username == notification.getAttribute("user") &&
+        notification.getAttribute("value") == AUTH_STATUS_UNVERIFIED
+      ) {
+        notification.close();
+      }
+    }
+  },
+
+  hideUserNotifications(context) {
+    for (let notification of this.globalBox.allNotifications) {
+      if (context.username == notification.getAttribute("user")) {
+        notification.close();
+      }
+    }
+  },
+
+  hideAllOTRNotifications() {
+    for (let notification of this.globalBox.allNotifications) {
+      if (notification.getAttribute("protocol") == "otr") {
+        notification.setAttribute("hidden", "true");
+      }
+    }
+  },
+
+  showUserNotifications(context) {
+    let name = context.username;
+    for (let notification of this.globalBox.allNotifications) {
+      if (name == notification.getAttribute("user")) {
+        notification.removeAttribute("hidden");
+      }
+    }
+  },
+
+  notifyUnverified(context, seen) {
+    let uiConv = OTR.getUIConvFromContext(context);
+    if (!uiConv) {
+      return;
+    }
+
+    let name = context.username;
+    let window = this.globalDoc.defaultView;
+
+    let buttons = [
+      {
+        label: _str("finger-verify"),
+        accessKey: _str("finger-verify-access-key"),
+        callback() {
+          let name = uiConv.target.normalizedName;
+          OTRUI.openAuth(window, name, "start", uiConv);
+          // prevent closing of notification bar when the button is hit
+          return true;
+        },
+      },
+      {
+        label: _str("finger-ignore"),
+        accessKey: _str("finger-ignore-access-key"),
+        callback() {
+          let context = OTR.getContext(uiConv.target);
+          OTR.abortSMP(context);
+        },
+      },
+    ];
+
+    let notification = this.globalBox.appendNotification(
+      name,
+      {
+        label: _strArgs(`finger-${seen}`, { name }),
+        priority: this.globalBox.PRIORITY_WARNING_MEDIUM,
+      },
+      buttons
+    );
+
+    // Set the user attribute so we can show and hide notifications based on the
+    // currently viewed conversation.
+    notification.setAttribute("user", name);
+    // Set custom attributes for CSS styling.
+    notification.setAttribute("protocol", "otr");
+    notification.setAttribute("status", AUTH_STATUS_UNVERIFIED);
+    // Prevent users from dismissing this notification.
+    notification.removeAttribute("dismissable");
+
+    if (!this.visibleConv) {
+      return;
+    }
+
+    if (name !== this.visibleConv.normalizedName) {
+      this.hideUserNotifications(context);
+    }
+  },
+
+  closeVerification(context) {
+    let uiConv = OTR.getUIConvFromContext(context);
+    if (!uiConv) {
+      return;
+    }
+
+    let prevNotification = OTRUI.globalBox.getNotificationWithValue(
+      context.username
+    );
+    if (prevNotification) {
+      prevNotification.close();
+    }
+  },
+
+  notifyVerification(context, key, cancelable, verifiable) {
+    let uiConv = OTR.getUIConvFromContext(context);
+    if (!uiConv) {
+      return;
+    }
+
+    OTRUI.closeVerification(context);
+
+    let buttons = [];
+    if (cancelable) {
+      buttons = [
+        {
+          label: _str("auth-cancel"),
+          accessKey: _str("auth-cancel-access-key"),
+          callback() {
+            let context = OTR.getContext(uiConv.target);
+            OTR.abortSMP(context);
+          },
+        },
+      ];
+    }
+
+    if (verifiable) {
+      let window = this.globalDoc.defaultView;
+
+      buttons = [
+        {
+          label: _str("finger-verify"),
+          accessKey: _str("finger-verify-access-key"),
+          callback() {
+            let name = uiConv.target.normalizedName;
+            OTRUI.openAuth(window, name, "start", uiConv);
+            // prevent closing of notification bar when the button is hit
+            return true;
+          },
+        },
+        {
+          label: _str("finger-ignore"),
+          accessKey: _str("finger-ignore-access-key"),
+          callback() {
+            let context = OTR.getContext(uiConv.target);
+            OTR.abortSMP(context);
+          },
+        },
+      ];
+    }
+
+    // Change priority type based on the passed key.
+    let priority = this.globalBox.PRIORITY_WARNING_HIGH;
+    let dismissable = true;
+    switch (key) {
+      case "otr:auth-error":
+      case "otr:auth-fail":
+        priority = this.globalBox.PRIORITY_CRITICAL_HIGH;
+        break;
+      case "otr:auth-waiting":
+        priority = this.globalBox.PRIORITY_INFO_MEDIUM;
+        dismissable = false;
+        break;
+
+      default:
+        break;
+    }
+
+    OTRUI.closeUnverified(context);
+    let notification = this.globalBox.appendNotification(
+      context.username,
+      {
+        label: authLabelMap.get(key),
+        priority,
+      },
+      buttons
+    );
+
+    // Set the user attribute so we can show and hide notifications based on the
+    // currently viewed conversation.
+    notification.setAttribute("user", context.username);
+    // Set custom attributes for CSS styling.
+    notification.setAttribute("protocol", "otr");
+    notification.setAttribute("status", key);
+
+    // The notification API don't currently support a "success" PRIORITY flag,
+    // so we need to manually set it if we need to.
+    if (["otr:auth-success", "otr:auth-success-them"].includes(key)) {
+      notification.setAttribute("type", "success");
+    }
+
+    if (!dismissable) {
+      // Prevent users from dismissing this notification if something is in
+      // progress or an action is required.
+      notification.removeAttribute("dismissable");
+    }
+  },
+
+  updateAuth(aObj) {
+    // let uiConv = OTR.getUIConvFromContext(aObj.context);
+    if (!aObj.progress) {
+      OTRUI.closeAuth(aObj.context);
+      OTRUI.notifyVerification(aObj.context, "otr:auth-error", false, false);
+    } else if (aObj.progress === 100) {
+      let key;
+      let verifiable = false;
+      if (aObj.success) {
+        if (aObj.context.trust) {
+          key = "otr:auth-success";
+          OTR.notifyTrust(aObj.context);
+        } else {
+          key = "otr:auth-success-them";
+          verifiable = true;
+        }
+      } else {
+        key = "otr:auth-fail";
+        if (!aObj.context.trust) {
+          OTR.notifyTrust(aObj.context);
+        }
+      }
+      OTRUI.notifyVerification(aObj.context, key, false, verifiable);
+    } else {
+      // TODO: show the aObj.progress to the user with a
+      //   <progressmeter mode="determined" value="10" />
+      OTRUI.notifyVerification(aObj.context, "otr:auth-waiting", true, false);
+    }
+    OTRUI.closeAskAuthNotification(aObj);
+  },
+
+  onAccountCreated(acc) {
+    let account = acc.normalizedName;
+    let protocol = acc.protocol.normalizedName;
+    Promise.resolve();
+    if (OTR.privateKeyFingerprint(account, protocol) === null) {
+      OTR.generatePrivateKey(account, protocol).catch(
+        OTRUI.reportKeyGenFailure
+      );
+    }
+  },
+
+  contactWrapper(contact) {
+    // If the conversation already started.
+    if (contact.buddy) {
+      return {
+        account: contact.buddy.normalizedName,
+        protocol: contact.buddy.buddy.protocol.normalizedName,
+        screenname: contact.buddy.userName,
+      };
+    }
+
+    // For online and offline contacts without an open conversation.
+    return {
+      account:
+        contact.preferredBuddy.preferredAccountBuddy.account.normalizedName,
+      protocol: contact.preferredBuddy.protocol.normalizedName,
+      screenname: contact.preferredBuddy.preferredAccountBuddy.userName,
+    };
+  },
+
+  onContactAdded(contact) {
+    let args = OTRUI.contactWrapper(contact);
+    if (
+      OTR.getFingerprintsForRecipient(
+        args.account,
+        args.protocol,
+        args.screenname
+      ).length > 0
+    ) {
+      return;
+    }
+    args.wrappedJSObject = args;
+    let features = "chrome,modal,centerscreen,resizable=no,minimizable=no";
+    Services.ww.openWindow(null, OTR_ADD_FINGER_DIALOG_URL, "", features, args);
+  },
+
+  observe(aObject, aTopic, aMsg) {
+    let doc;
+    // console.log("====> observing topic: " + aTopic + " with msg: " + aMsg);
+    // console.log(aObject);
+
+    switch (aTopic) {
+      case "nsPref:changed":
+        break;
+      case "conversation-loaded":
+        doc = aObject.ownerDocument;
+        let windowtype = doc.documentElement.getAttribute("windowtype");
+        if (windowtype !== "mail:3pane") {
+          return;
+        }
+        OTRUI.addButton(aObject);
+        break;
+      case "conversation-closed":
+        if (aObject.isChat) {
+          return;
+        }
+        this.globalBox.removeAllNotifications();
+        OTRUI.closeAuth(OTR.getContext(aObject));
+        OTRUI.disconnect(aObject);
+        break;
+      // case "contact-signed-off":
+      //  break;
+      case "prpl-quit":
+        OTRUI.disconnect(null);
+        break;
+      case "domwindowopened":
+        OTRUI.addMenus(aObject);
+        break;
+      case "otr:generate": {
+        let result = OTR.generatePrivateKeySync(
+          aObject.account,
+          aObject.protocol
+        );
+        if (result != null) {
+          OTRUI.reportKeyGenFailure(result);
+        }
+        break;
+      }
+      case "otr:disconnected":
+      case "otr:msg-state":
+        if (
+          aTopic === "otr:disconnected" ||
+          OTR.trust(aObject) !== OTR.trustState.TRUST_UNVERIFIED
+        ) {
+          OTRUI.closeAuth(aObject);
+          OTRUI.closeUnverified(aObject);
+          OTRUI.closeVerification(aObject);
+        }
+        OTRUI.setMsgState(null, aObject, this.globalDoc, false);
+        break;
+      case "otr:unverified":
+        if (!this.globalDoc) {
+          let win = Services.wm.getMostRecentWindow("mail:3pane");
+          if (!win) {
+            return;
+          }
+          win.focus();
+          win.showChatTab();
+          this.globalDoc = win.document;
+        }
+        OTRUI.notifyUnverified(aObject, aMsg);
+        break;
+      case "otr:trust-state":
+        OTRUI.alertTrust(aObject);
+        break;
+      case "otr:log":
+        OTRUI.logMsg("otr: " + aObject);
+        break;
+      case "account-added":
+        OTRUI.onAccountCreated(aObject);
+        break;
+      case "contact-added":
+        OTRUI.onContactAdded(aObject);
+        break;
+      case "otr:auth-ask":
+        OTRUI.askAuth(aObject);
+        break;
+      case "otr:auth-update":
+        OTRUI.updateAuth(aObject);
+        break;
+      case "otr:cancel-ask-auth":
+        OTRUI.closeAskAuthNotification(aObject);
+        break;
+    }
+  },
+
+  initConv(binding) {
+    OTR.addConversation(binding._conv);
+    OTRUI.addButton(binding);
+  },
+
+  /**
+   * Restore the conversation to a state before OTR knew about it.
+   *
+   * @param {Element} binding - conversation-browser instance.
+   */
+  resetConv(binding) {
+    OTR.removeConversation(binding._conv);
+  },
+
+  destroy() {
+    if (!OTR.libLoaded) {
+      return;
+    }
+    OTRUI.disconnect(null);
+    Services.obs.removeObserver(OTR, "new-ui-conversation");
+    Services.obs.removeObserver(OTR, "conversation-update-type");
+    // Services.obs.removeObserver(OTRUI, "contact-added");
+    // Services.obs.removeObserver(OTRUI, "contact-signed-off");
+    Services.obs.removeObserver(OTRUI, "account-added");
+    Services.obs.removeObserver(OTRUI, "conversation-loaded");
+    Services.obs.removeObserver(OTRUI, "conversation-closed");
+    Services.obs.removeObserver(OTRUI, "prpl-quit");
+
+    for (let conv of IMServices.conversations.getConversations()) {
+      OTRUI.resetConv(conv);
+    }
+    OTR.removeObserver(OTRUI);
+    OTR.close();
+    OTRUI.removeMenuObserver();
+  },
+};
diff --git a/comm/chat/modules/ToLocaleFormat.sys.mjs b/comm/chat/modules/ToLocaleFormat.sys.mjs
new file mode 100644
index 0000000000..256a6fb5f0
--- /dev/null
+++ b/comm/chat/modules/ToLocaleFormat.sys.mjs
@@ -0,0 +1,208 @@
+/* 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/. */
+
+/**
+ * JS implementation of the deprecated Date.toLocaleFormat.
+ * aFormat follows strftime syntax,
+ * http://pubs.opengroup.org/onlinepubs/007908799/xsh/strftime.html
+ */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+XPCOMUtils.defineLazyGetter(
+  lazy,
+  "dateTimeFormatter",
+  () =>
+    new Services.intl.DateTimeFormat(undefined, {
+      dateStyle: "full",
+      timeStyle: "long",
+    })
+);
+XPCOMUtils.defineLazyGetter(
+  lazy,
+  "dateFormatter",
+  () =>
+    new Services.intl.DateTimeFormat(undefined, {
+      dateStyle: "full",
+    })
+);
+XPCOMUtils.defineLazyGetter(
+  lazy,
+  "timeFormatter",
+  () =>
+    new Services.intl.DateTimeFormat(undefined, {
+      timeStyle: "long",
+    })
+);
+
+function Day(t) {
+  return Math.floor(t.valueOf() / 86400000);
+}
+function DayFromYear(y) {
+  return (
+    365 * (y - 1970) +
+    Math.floor((y - 1969) / 4) -
+    Math.floor((y - 1901) / 100) +
+    Math.floor((y - 1601) / 400)
+  );
+}
+function DayWithinYear(t) {
+  return Day(t) - DayFromYear(t.getFullYear());
+}
+function weekday(aDate, option) {
+  return aDate.toLocaleString(undefined, { weekday: option });
+}
+function month(aDate, option) {
+  return aDate.toLocaleString(undefined, { month: option });
+}
+function hourMinSecTwoDigits(aDate) {
+  return aDate.toLocaleString(undefined, {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  });
+}
+function dayPeriod(aDate) {
+  let dtf = Intl.DateTimeFormat(undefined, { hour: "2-digit" });
+  let dayPeriodPart =
+    dtf.resolvedOptions().hour12 &&
+    dtf.formatToParts(aDate).find(part => part.type === "dayPeriod");
+  return dayPeriodPart ? dayPeriodPart.value : "";
+}
+function weekNumber(aDate, weekStart) {
+  let day = aDate.getDay();
+  if (weekStart) {
+    day = (day || 7) - weekStart;
+  }
+  return Math.max(Math.floor((DayWithinYear(aDate) + 7 - day) / 7), 0);
+}
+function weekNumberISO(t) {
+  let thisWeek = weekNumber(1, t);
+  let firstDayOfYear = (new Date(t.getFullYear(), 0, 1).getDay() || 7) - 1;
+  if (thisWeek === 0 && firstDayOfYear >= 4) {
+    return weekNumberISO(new Date(t.getFullYear() - 1, 11, 31));
+  }
+  if (t.getMonth() === 11 && t.getDate() - ((t.getDay() || 7) - 1) >= 29) {
+    return 1;
+  }
+  return thisWeek + (firstDayOfYear > 0 && firstDayOfYear < 4);
+}
+function weekYearISO(aDate) {
+  let thisWeek = weekNumber(1, aDate);
+  let firstDayOfYear = (new Date(aDate.getFullYear(), 0, 1).getDay() || 7) - 1;
+  if (thisWeek === 0 && firstDayOfYear >= 4) {
+    return aDate.getFullYear() - 1;
+  }
+  if (
+    aDate.getMonth() === 11 &&
+    aDate.getDate() - ((aDate.getDay() || 7) - 1) >= 29
+  ) {
+    return aDate.getFullYear() + 1;
+  }
+  return aDate.getFullYear();
+}
+function timeZoneOffset(aDate) {
+  let offset = aDate.getTimezoneOffset();
+  let tzoff = Math.floor(Math.abs(offset) / 60) * 100 + (Math.abs(offset) % 60);
+  return (offset < 0 ? "+" : "-") + String(tzoff).padStart(4, "0");
+}
+function timeZone(aDate) {
+  let dtf = Intl.DateTimeFormat(undefined, { timeZoneName: "short" });
+  let timeZoneNamePart = dtf
+    .formatToParts(aDate)
+    .find(part => part.type === "timeZoneName");
+  return timeZoneNamePart ? timeZoneNamePart.value : "";
+}
+
+const formatFunctions = {
+  a: aDate => weekday(aDate, "short"),
+  A: aDate => weekday(aDate, "long"),
+  b: aDate => month(aDate, "short"),
+  B: aDate => month(aDate, "long"),
+  c: aDate => lazy.dateTimeFormatter.format(aDate),
+  C: aDate => String(Math.trunc(aDate.getFullYear() / 100)),
+  d: aDate => String(aDate.getDate()),
+  D: aDate => ToLocaleFormat("%m/%d/%y", aDate),
+  e: aDate => String(aDate.getDate()),
+  F: aDate => ToLocaleFormat("%Y-%m-%d", aDate),
+  g: aDate => String(weekYearISO(aDate) % 100),
+  G: aDate => String(weekYearISO(aDate)),
+  h: aDate => month(aDate, "short"),
+  H: aDate => String(aDate.getHours()),
+  I: aDate => String(aDate.getHours() % 12 || 12),
+  j: aDate => String(DayWithinYear(aDate) + 1),
+  k: aDate => String(aDate.getHours()),
+  l: aDate => String(aDate.getHours() % 12 || 12),
+  m: aDate => String(aDate.getMonth() + 1),
+  M: aDate => String(aDate.getMinutes()),
+  n: () => "\n",
+  p: aDate => dayPeriod(aDate).toLocaleUpperCase(),
+  P: aDate => dayPeriod(aDate).toLocaleLowerCase(),
+  r: aDate => hourMinSecTwoDigits(aDate),
+  R: aDate => ToLocaleFormat("%H:%M", aDate),
+  s: aDate => String(Math.trunc(aDate.getTime() / 1000)),
+  S: aDate => String(aDate.getSeconds()),
+  t: () => "\t",
+  T: aDate => ToLocaleFormat("%H:%M:%S", aDate),
+  u: aDate => String(aDate.getDay() || 7),
+  U: aDate => String(weekNumber(aDate, 0)),
+  V: aDate => String(weekNumberISO(aDate)),
+  w: aDate => String(aDate.getDay()),
+  W: aDate => String(weekNumber(aDate, 1)),
+  x: aDate => lazy.dateFormatter.format(aDate),
+  X: aDate => lazy.timeFormatter.format(aDate),
+  y: aDate => String(aDate.getFullYear() % 100),
+  Y: aDate => String(aDate.getFullYear()),
+  z: aDate => timeZoneOffset(aDate),
+  Z: aDate => timeZone(aDate),
+  "%": () => "%",
+};
+const padding = {
+  C: { fill: "0", width: 2 },
+  d: { fill: "0", width: 2 },
+  e: { fill: " ", width: 2 },
+  g: { fill: "0", width: 2 },
+  H: { fill: "0", width: 2 },
+  I: { fill: "0", width: 2 },
+  j: { fill: "0", width: 3 },
+  k: { fill: " ", width: 2 },
+  l: { fill: " ", width: 2 },
+  m: { fill: "0", width: 2 },
+  M: { fill: "0", width: 2 },
+  S: { fill: "0", width: 2 },
+  U: { fill: "0", width: 2 },
+  V: { fill: "0", width: 2 },
+  W: { fill: "0", width: 2 },
+  y: { fill: "0", width: 2 },
+};
+
+export function ToLocaleFormat(aFormat, aDate) {
+  // Modified conversion specifiers E and O are ignored.
+  let specifiers = Object.keys(formatFunctions).join("");
+  let pattern = RegExp(`%#?(\\^)?([0_-]\\d*)?(?:[EO])?([${specifiers}])`, "g");
+
+  return aFormat.replace(
+    pattern,
+    (matched, upperCaseFlag, fillWidthFlags, specifier) => {
+      let result = formatFunctions[specifier](aDate);
+      if (upperCaseFlag) {
+        result = result.toLocaleUpperCase();
+      }
+      let fill = specifier in padding ? padding[specifier].fill : "";
+      let width = specifier in padding ? padding[specifier].width : 0;
+      if (fillWidthFlags) {
+        let newFill = fillWidthFlags[0];
+        let newWidth = fillWidthFlags.match(/\d+/);
+        if (newFill === "-" && newWidth === null) {
+          fill = "";
+        } else {
+          fill = newFill === "0" ? "0" : " ";
+          width = newWidth !== null ? Number(newWidth) : width;
+        }
+      }
+      return result.padStart(width, fill);
+    }
+  );
+}
diff --git a/comm/chat/modules/imContentSink.sys.mjs b/comm/chat/modules/imContentSink.sys.mjs
new file mode 100644
index 0000000000..b3ff617048
--- /dev/null
+++ b/comm/chat/modules/imContentSink.sys.mjs
@@ -0,0 +1,495 @@
+/* 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/. */
+
+var kAllowedURLs = aValue => /^(https?|ftp|mailto|magnet):/.test(aValue);
+var kAllowedMozClasses = aClassName =>
+  aClassName == "moz-txt-underscore" ||
+  aClassName == "moz-txt-tag" ||
+  aClassName == "ib-person";
+var kAllowedAnchorClasses = aClassName => aClassName == "ib-person";
+
+/* Tags whose content should be fully removed, and reported in the Error Console. */
+var kForbiddenTags = {
+  script: true,
+  style: true,
+};
+
+/**
+ * In strict mode, remove all formatting. Keep only links and line breaks.
+ *
+ * @type {CleanRules}
+ */
+var kStrictMode = {
+  attrs: {},
+
+  tags: {
+    a: {
+      title: true,
+      href: kAllowedURLs,
+      class: kAllowedAnchorClasses,
+    },
+    br: true,
+    p: true,
+  },
+
+  styles: {},
+};
+
+/**
+ * Standard mode allows basic formattings (bold, italic, underlined).
+ *
+ * @type {CleanRules}
+ */
+var kStandardMode = {
+  attrs: {
+    style: true,
+  },
+
+  tags: {
+    div: true,
+    a: {
+      title: true,
+      href: kAllowedURLs,
+      class: kAllowedAnchorClasses,
+    },
+    em: true,
+    strong: true,
+    b: true,
+    i: true,
+    u: true,
+    s: true,
+    span: {
+      class: kAllowedMozClasses,
+    },
+    br: true,
+    code: true,
+    ul: true,
+    li: true,
+    ol: {
+      start: true,
+    },
+    cite: true,
+    blockquote: true,
+    p: true,
+    del: true,
+    strike: true,
+    ins: true,
+    sub: true,
+    sup: true,
+    pre: true,
+    table: true,
+    thead: true,
+    tbody: true,
+    tr: true,
+    th: true,
+    td: true,
+    caption: true,
+    details: true,
+    summary: true,
+  },
+
+  styles: {
+    "font-style": true,
+    "font-weight": true,
+    "text-decoration-line": true,
+  },
+};
+
+/**
+ * Permissive mode allows just about anything that isn't going to mess up the chat window.
+ * In comparison to normal mode this primarily means elements that can vary font sizes and
+ * colors.
+ *
+ * @type {CleanRules}
+ */
+var kPermissiveMode = {
+  attrs: {
+    style: true,
+  },
+
+  tags: {
+    div: true,
+    a: {
+      title: true,
+      href: kAllowedURLs,
+      class: kAllowedAnchorClasses,
+    },
+    font: {
+      face: true,
+      color: true,
+      size: true,
+    },
+    em: true,
+    strong: true,
+    b: true,
+    i: true,
+    u: true,
+    s: true,
+    span: {
+      class: kAllowedMozClasses,
+    },
+    br: true,
+    hr: true,
+    code: true,
+    ul: true,
+    li: true,
+    ol: {
+      start: true,
+    },
+    cite: true,
+    blockquote: true,
+    p: true,
+    del: true,
+    strike: true,
+    ins: true,
+    sub: true,
+    sup: true,
+    pre: true,
+    table: true,
+    thead: true,
+    tbody: true,
+    tr: true,
+    th: true,
+    td: true,
+    caption: true,
+    details: true,
+    summary: true,
+    h1: true,
+    h2: true,
+    h3: true,
+    h4: true,
+    h5: true,
+    h6: true,
+  },
+
+  // FIXME: should be possible to use functions to filter values
+  styles: {
+    color: true,
+    font: true,
+    "font-family": true,
+    "font-size": true,
+    "font-style": true,
+    "font-weight": true,
+    "text-decoration-color": true,
+    "text-decoration-style": true,
+    "text-decoration-line": true,
+  },
+};
+
+var kModePref = "messenger.options.filterMode";
+var kModes = [kStrictMode, kStandardMode, kPermissiveMode];
+
+var gGlobalRuleset = null;
+
+function initGlobalRuleset() {
+  gGlobalRuleset = newRuleset();
+
+  Services.prefs.addObserver(kModePref, styleObserver);
+}
+
+var styleObserver = {
+  observe(aObject, aTopic, aMsg) {
+    if (aTopic != "nsPref:changed" || aMsg != kModePref) {
+      throw new Error("bad notification");
+    }
+
+    if (!gGlobalRuleset) {
+      throw new Error("gGlobalRuleset not initialized");
+    }
+
+    setBaseRuleset(getModePref(), gGlobalRuleset);
+  },
+};
+
+function getModePref() {
+  let baseNum = Services.prefs.getIntPref(kModePref);
+  if (baseNum < 0 || baseNum > 2) {
+    baseNum = 1;
+  }
+
+  return kModes[baseNum];
+}
+
+function setBaseRuleset(aBase, aResult) {
+  for (let property in aBase) {
+    aResult[property] = Object.create(aBase[property], aResult[property]);
+  }
+}
+
+function newRuleset(aBase) {
+  let result = {
+    tags: {},
+    attrs: {},
+    styles: {},
+  };
+  setBaseRuleset(aBase || getModePref(), result);
+  return result;
+}
+
+export function createDerivedRuleset() {
+  if (!gGlobalRuleset) {
+    initGlobalRuleset();
+  }
+  return newRuleset(gGlobalRuleset);
+}
+
+export function addGlobalAllowedTag(aTag, aAttrs = true) {
+  gGlobalRuleset.tags[aTag] = aAttrs;
+}
+
+export function removeGlobalAllowedTag(aTag) {
+  delete gGlobalRuleset.tags[aTag];
+}
+
+export function addGlobalAllowedAttribute(aAttr, aRule = true) {
+  gGlobalRuleset.attrs[aAttr] = aRule;
+}
+
+export function removeGlobalAllowedAttribute(aAttr) {
+  delete gGlobalRuleset.attrs[aAttr];
+}
+
+export function addGlobalAllowedStyleRule(aStyle, aRule = true) {
+  gGlobalRuleset.styles[aStyle] = aRule;
+}
+
+export function removeGlobalAllowedStyleRule(aStyle) {
+  delete gGlobalRuleset.styles[aStyle];
+}
+
+/**
+ * A dynamic rule which decides if an attribute is allowed based on the
+ * attribute's value.
+ *
+ * @callback  ValueRule
+ * @param {string} value - The attribute value.
+ * @returns {bool} - True if the attribute should be allowed.
+ *
+ * @example
+ *
+ *    aValue => aValue == 'about:blank'
+ */
+
+/**
+ * An object whose properties are the allowed attributes.
+ *
+ * The value of the property should be true to unconditionally accept the
+ * attribute, or a function which accepts the value of the attribute and
+ * returns a boolean of whether the attribute should be accepted or not.
+ *
+ * @typedef Ruleset
+ * @type {Object<string, (boolean | ValueRule)>}}
+ */
+
+/**
+ * A set of rules for which tags, attributes, and styles should be allowed when
+ * rendering HTML.
+ *
+ * See kStrictMode, kStandardMode, kPermissiveMode for examples of Rulesets.
+ *
+ * @typedef CleanRules
+ * @type {object}
+ * @property {Ruleset} attrs
+ *    An object whose properties are the allowed attributes for any tag.
+ * @property {Object<string, (boolean|Ruleset)>} tags
+ *    An object whose properties are the allowed tags.
+ *
+ *    The value can point to a {@link Ruleset} for that tag which augments the
+ *    ones provided by attrs. If either of the {@link Ruleset}s from attrs or
+ *    tags allows an attribute, then it is accepted.
+ * @property {Object<string, boolean>} styles
+ *    An object whose properties are the allowed CSS style rules.
+ *
+ *    The value of each property is unused.
+ *
+ *    FIXME: make styles accept functions to filter the CSS values like Ruleset.
+ *
+ * @example
+ *
+ *    {
+ *        attrs: { 'style': true },
+ *        tags: {
+ *            a: { 'href': true },
+ *        },
+ *        styles: {
+ *            'font-size': true
+ *        }
+ *    }
+ */
+
+/**
+ * A function to modify text nodes.
+ *
+ * @callback TextModifier
+ * @param {Node} - The text node to modify.
+ * @returns {int} - The number of nodes added.
+ *
+ *    -1 if the current textnode was deleted
+ *    0 if the node count is unchanged
+ *    positive value if nodes were added.
+ *
+ *    For instance, adding an <img> tag for a smiley adds 2 nodes:
+ *    the img tag
+ *    the new text node after the img tag.
+ */
+
+/**
+ * Removes nodes, attributes and styles that are not allowed according to the
+ * given rules.
+ *
+ * @param {Node} aNode
+ *    A DOM node to inspect recursively against the rules.
+ * @param {CleanRules} aRules
+ *    The rules for what tags, attributes, and styles are allowed.
+ * @param {TextModifier[]} aTextModifiers
+ *    A list of functions to modify text content.
+ */
+function cleanupNode(aNode, aRules, aTextModifiers) {
+  // Iterate each node and apply rules for what content is allowed. This has two
+  // modes: one for element nodes and one for text nodes.
+  for (let i = 0; i < aNode.childNodes.length; ++i) {
+    let node = aNode.childNodes[i];
+    if (
+      node.nodeType == node.ELEMENT_NODE &&
+      node.namespaceURI == "http://www.w3.org/1999/xhtml"
+    ) {
+      // If the node is an element, check if the node is an allowed tag.
+      let nodeName = node.localName;
+      if (!(nodeName in aRules.tags)) {
+        // If the node is not allowed, either remove it completely (if
+        // it is forbidden) or replace it with its children.
+        if (nodeName in kForbiddenTags) {
+          console.error(
+            "removing a " + nodeName + " tag from a message before display"
+          );
+        } else {
+          while (node.hasChildNodes()) {
+            aNode.insertBefore(node.firstChild, node);
+          }
+        }
+        aNode.removeChild(node);
+        // We want to process again the node at the index i which is
+        // now the first child of the node we removed
+        --i;
+        continue;
+      }
+
+      // This node is being kept, cleanup each child node.
+      cleanupNode(node, aRules, aTextModifiers);
+
+      // Cleanup the attributes of this node.
+      let attrs = node.attributes;
+      let acceptFunction = function (aAttrRules, aAttr) {
+        // An attribute is always accepted if its rule is true, or conditionally
+        // accepted if its rule is a function that evaluates to true.
+        // If its rule does not exist, it is removed.
+        let localName = aAttr.localName;
+        let rule = localName in aAttrRules && aAttrRules[localName];
+        return (
+          rule === true || (typeof rule == "function" && rule(aAttr.value))
+        );
+      };
+      for (let j = 0; j < attrs.length; ++j) {
+        let attr = attrs[j];
+        // If either the attribute is accepted for all tags or for this specific
+        // tag then it is allowed.
+        if (
+          !(
+            acceptFunction(aRules.attrs, attr) ||
+            (typeof aRules.tags[nodeName] == "object" &&
+              acceptFunction(aRules.tags[nodeName], attr))
+          )
+        ) {
+          node.removeAttribute(attr.name);
+          --j;
+        }
+      }
+
+      // Cleanup the style attribute.
+      let style = node.style;
+      for (let j = 0; j < style.length; ++j) {
+        if (!(style[j] in aRules.styles)) {
+          style.removeProperty(style[j]);
+          --j;
+        }
+      }
+
+      // If the style attribute is now empty or if it contained unsupported or
+      // unparsable CSS it should be dropped completely.
+      if (!style.length) {
+        node.removeAttribute("style");
+      }
+
+      // Sort the style attributes for easier checking/comparing later.
+      if (node.hasAttribute("style")) {
+        let trailingSemi = false;
+        let attrs = node.getAttribute("style").trim();
+        if (attrs.endsWith(";")) {
+          attrs = attrs.slice(0, -1);
+          trailingSemi = true;
+        }
+        attrs = attrs.split(";").map(a => a.trim());
+        attrs.sort();
+        node.setAttribute(
+          "style",
+          attrs.join("; ") + (trailingSemi ? ";" : "")
+        );
+      }
+    } else {
+      // We are on a text node, we need to apply the functions
+      // provided in the aTextModifiers array.
+
+      // Each of these function should return the number of nodes added:
+      //  * -1 if the current textnode was deleted
+      //  * 0 if the node count is unchanged
+      //  * positive value if nodes were added.
+      //     For instance, adding an <img> tag for a smiley adds 2 nodes:
+      //      - the img tag
+      //      - the new text node after the img tag.
+
+      // This is the number of nodes we need to process. If new nodes
+      // are created, the next text modifier functions have more nodes
+      // to process.
+      let textNodeCount = 1;
+      for (let modifier of aTextModifiers) {
+        for (let n = 0; n < textNodeCount; ++n) {
+          let textNode = aNode.childNodes[i + n];
+
+          // If we are processing nodes created by one of the previous
+          // text modifier function, some of the nodes are likely not
+          // text node, skip them.
+          if (
+            textNode.nodeType != textNode.TEXT_NODE &&
+            textNode.nodeType != textNode.CDATA_SECTION_NODE
+          ) {
+            continue;
+          }
+
+          let result = modifier(textNode);
+          textNodeCount += result;
+          n += result;
+        }
+      }
+
+      // newly created nodes should not be filtered, be sure we skip them!
+      i += textNodeCount - 1;
+    }
+  }
+}
+
+export function cleanupImMarkup(aText, aRuleset, aTextModifiers = []) {
+  if (!gGlobalRuleset) {
+    initGlobalRuleset();
+  }
+
+  let parser = new DOMParser();
+  // Wrap the text to be parsed in a <span> to avoid losing leading whitespace.
+  let doc = parser.parseFromString(
+    "<!DOCTYPE html><html><body><span>" + aText + "</span></body></html>",
+    "text/html"
+  );
+  let span = doc.querySelector("span");
+  cleanupNode(span, aRuleset || gGlobalRuleset, aTextModifiers);
+  return span.innerHTML;
+}
diff --git a/comm/chat/modules/imSmileys.sys.mjs b/comm/chat/modules/imSmileys.sys.mjs
new file mode 100644
index 0000000000..1658033786
--- /dev/null
+++ b/comm/chat/modules/imSmileys.sys.mjs
@@ -0,0 +1,184 @@
+/* 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/. */
+
+/** Used to add smileys to the content of a textnode. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+XPCOMUtils.defineLazyGetter(lazy, "gTextDecoder", () => {
+  return new TextDecoder();
+});
+
+ChromeUtils.defineModuleGetter(
+  lazy,
+  "NetUtil",
+  "resource://gre/modules/NetUtil.jsm"
+);
+
+var kEmoticonsThemePref = "messenger.options.emoticonsTheme";
+var kThemeFile = "theme.json";
+
+Object.defineProperty(lazy, "gTheme", {
+  configurable: true,
+  enumerable: true,
+
+  get() {
+    delete this.gTheme;
+    gPrefObserver.init();
+    return (this.gTheme = getTheme());
+  },
+});
+
+var gPrefObserver = {
+  init() {
+    Services.prefs.addObserver(kEmoticonsThemePref, gPrefObserver);
+  },
+
+  observe(aObject, aTopic, aMsg) {
+    if (aTopic != "nsPref:changed" || aMsg != kEmoticonsThemePref) {
+      throw new Error("bad notification");
+    }
+
+    lazy.gTheme = getTheme();
+  },
+};
+
+function getTheme(aName) {
+  let name = aName || Services.prefs.getCharPref(kEmoticonsThemePref);
+
+  let theme = {
+    name,
+    iconsHash: null,
+    json: null,
+    regExp: null,
+  };
+
+  if (name == "none") {
+    return theme;
+  }
+
+  if (name == "default") {
+    theme.baseUri = "chrome://instantbird-emoticons/skin/";
+  } else {
+    theme.baseUri = "chrome://" + theme.name + "/skin/";
+  }
+  try {
+    let channel = Services.io.newChannel(
+      theme.baseUri + kThemeFile,
+      null,
+      null,
+      null,
+      Services.scriptSecurityManager.getSystemPrincipal(),
+      null,
+      Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+      Ci.nsIContentPolicy.TYPE_IMAGE
+    );
+    let stream = channel.open();
+    let bytes = lazy.NetUtil.readInputStream(stream, stream.available());
+    theme.json = JSON.parse(lazy.gTextDecoder.decode(bytes));
+    stream.close();
+    theme.iconsHash = {};
+    for (let smiley of theme.json.smileys) {
+      for (let textCode of smiley.textCodes) {
+        theme.iconsHash[textCode] = smiley;
+      }
+    }
+  } catch (e) {
+    console.error(e);
+  }
+  return theme;
+}
+
+function getRegexp() {
+  if (lazy.gTheme.regExp) {
+    lazy.gTheme.regExp.lastIndex = 0;
+    return lazy.gTheme.regExp;
+  }
+
+  // return null if smileys are disabled
+  if (!lazy.gTheme.iconsHash) {
+    return null;
+  }
+
+  if ("" in lazy.gTheme.iconsHash) {
+    console.error(
+      "Emoticon " +
+        lazy.gTheme.iconsHash[""].filename +
+        " matches the empty string!"
+    );
+    delete lazy.gTheme.iconsHash[""];
+  }
+
+  let emoticonList = [];
+  for (let emoticon in lazy.gTheme.iconsHash) {
+    emoticonList.push(emoticon);
+  }
+
+  let exp = /[[\]{}()*+?.\\^$|]/g;
+  emoticonList = emoticonList
+    .sort()
+    .reverse()
+    .map(x => x.replace(exp, "\\$&"));
+
+  if (!emoticonList.length) {
+    // the theme contains no valid emoticon, make sure we will return
+    // early next time
+    lazy.gTheme.iconsHash = null;
+    return null;
+  }
+
+  lazy.gTheme.regExp = new RegExp(emoticonList.join("|"), "g");
+  return lazy.gTheme.regExp;
+}
+
+export function smileTextNode(aNode) {
+  /*
+   * Skip text nodes that contain the href in the child text node.
+   * We must check both the testNode.textContent and the aNode.data since they
+   * cover different cases:
+   *   textContent: The URL is split over multiple nodes for some reason
+   *   data: The URL is not the only content in the link, skip only the one node
+   * Check the class name to skip any autolinked nodes from mozTXTToHTMLConv.
+   */
+  let testNode = aNode;
+  while ((testNode = testNode.parentNode)) {
+    if (
+      testNode.nodeName.toLowerCase() == "a" &&
+      (testNode.getAttribute("href") == testNode.textContent.trim() ||
+        testNode.getAttribute("href") == aNode.data.trim() ||
+        testNode.className.includes("moz-txt-link-"))
+    ) {
+      return 0;
+    }
+  }
+
+  let result = 0;
+  let exp = getRegexp();
+  if (!exp) {
+    return result;
+  }
+
+  let match;
+  while ((match = exp.exec(aNode.data))) {
+    let smileNode = aNode.splitText(match.index);
+    aNode = smileNode.splitText(exp.lastIndex - match.index);
+    // at this point, smileNode is a text node with only the text
+    // of the smiley and aNode is a text node with the text after
+    // the smiley. The text in aNode hasn't been processed yet.
+    let smile = smileNode.data;
+    let elt = aNode.ownerDocument.createElement("span");
+    elt.appendChild(
+      aNode.ownerDocument.createTextNode(lazy.gTheme.iconsHash[smile].glyph)
+    );
+    // Add the title attribute (to show the original text in a tooltip) in case
+    // the replacement was done incorrectly.
+    elt.setAttribute("title", smile);
+    smileNode.parentNode.replaceChild(elt, smileNode);
+    result += 2;
+    exp.lastIndex = 0;
+  }
+  return result;
+}
diff --git a/comm/chat/modules/imStatusUtils.sys.mjs b/comm/chat/modules/imStatusUtils.sys.mjs
new file mode 100644
index 0000000000..58c594b117
--- /dev/null
+++ b/comm/chat/modules/imStatusUtils.sys.mjs
@@ -0,0 +1,57 @@
+/* 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 { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { l10nHelper } from "resource:///modules/imXPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/status.properties")
+);
+
+var imIStatusInfo = Ci.imIStatusInfo;
+var statusAttributes = {};
+statusAttributes[imIStatusInfo.STATUS_UNKNOWN] = "unknown";
+statusAttributes[imIStatusInfo.STATUS_OFFLINE] = "offline";
+statusAttributes[imIStatusInfo.STATUS_INVISIBLE] = "invisible";
+statusAttributes[imIStatusInfo.STATUS_MOBILE] = "mobile";
+statusAttributes[imIStatusInfo.STATUS_IDLE] = "idle";
+statusAttributes[imIStatusInfo.STATUS_AWAY] = "away";
+statusAttributes[imIStatusInfo.STATUS_UNAVAILABLE] = "unavailable";
+statusAttributes[imIStatusInfo.STATUS_AVAILABLE] = "available";
+
+export var Status = {
+  toAttribute: aStatusType =>
+    aStatusType in statusAttributes ? statusAttributes[aStatusType] : "unknown",
+
+  _labels: {},
+  toLabel(aStatusType, aStatusText) {
+    // aStatusType may be either one of the (integral) imIStatusInfo status
+    // constants, or one of the statusAttributes.
+    if (!(typeof aStatusType == "string")) {
+      aStatusType = this.toAttribute(aStatusType);
+    }
+
+    if (!(aStatusType in this._labels)) {
+      this._labels[aStatusType] = lazy._(aStatusType + "StatusType");
+    }
+
+    let label = this._labels[aStatusType];
+    if (aStatusText) {
+      label = lazy._("statusWithStatusMessage", label, aStatusText);
+    }
+
+    return label;
+  },
+
+  toFlag(aAttribute) {
+    for (let flag in statusAttributes) {
+      if (statusAttributes[flag] == aAttribute) {
+        return flag;
+      }
+    }
+    return imIStatusInfo.STATUS_UNKNOWN;
+  },
+};
diff --git a/comm/chat/modules/imTextboxUtils.sys.mjs b/comm/chat/modules/imTextboxUtils.sys.mjs
new file mode 100644
index 0000000000..979abb6f61
--- /dev/null
+++ b/comm/chat/modules/imTextboxUtils.sys.mjs
@@ -0,0 +1,19 @@
+/* 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/. */
+
+export var TextboxSize = {
+  _textboxAutoResizePrefName: "messenger.conversations.textbox.autoResize",
+  get autoResize() {
+    delete this.autoResize;
+    Services.prefs.addObserver(this._textboxAutoResizePrefName, this);
+    return (this.autoResize = Services.prefs.getBoolPref(
+      this._textboxAutoResizePrefName
+    ));
+  },
+  observe(aSubject, aTopic, aMsg) {
+    if (aTopic == "nsPref:changed" && aMsg == this._textboxAutoResizePrefName) {
+      this.autoResize = Services.prefs.getBoolPref(aMsg);
+    }
+  },
+};
diff --git a/comm/chat/modules/imThemes.sys.mjs b/comm/chat/modules/imThemes.sys.mjs
new file mode 100644
index 0000000000..5b7f0ee824
--- /dev/null
+++ b/comm/chat/modules/imThemes.sys.mjs
@@ -0,0 +1,1333 @@
+/* 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 { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+const ParserUtils = Cc["@mozilla.org/parserutils;1"].getService(
+  Ci.nsIParserUtils
+);
+
+var kMessagesStylePrefBranch = "messenger.options.messagesStyle.";
+var kThemePref = "theme";
+var kVariantPref = "variant";
+var kCombineConsecutivePref = "combineConsecutive";
+var kCombineConsecutiveIntervalPref = "combineConsecutiveInterval";
+
+var DEFAULT_THEME = "bubbles";
+var DEFAULT_THEMES = ["bubbles", "dark", "mail", "papersheets", "simple"];
+
+var kLineBreak = "@mozilla.org/windows-registry-key;1" in Cc ? "\r\n" : "\n";
+
+XPCOMUtils.defineLazyGetter(lazy, "gPrefBranch", () =>
+  Services.prefs.getBranch(kMessagesStylePrefBranch)
+);
+
+XPCOMUtils.defineLazyGetter(lazy, "TXTToHTML", function () {
+  let cs = Cc["@mozilla.org/txttohtmlconv;1"].getService(Ci.mozITXTToHTMLConv);
+  return aTXT => cs.scanTXT(aTXT, cs.kEntities);
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "gTimeFormatter", () => {
+  return new Services.intl.DateTimeFormat(undefined, {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  });
+});
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  DownloadUtils: "resource://gre/modules/DownloadUtils.sys.mjs",
+  ToLocaleFormat: "resource:///modules/ToLocaleFormat.sys.mjs",
+});
+
+var gCurrentTheme = null;
+
+function getChromeFile(aURI) {
+  try {
+    let channel = Services.io.newChannel(
+      aURI,
+      null,
+      null,
+      null,
+      Services.scriptSecurityManager.getSystemPrincipal(),
+      null,
+      Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+      Ci.nsIContentPolicy.TYPE_OTHER
+    );
+    let stream = channel.open();
+    let sstream = Cc["@mozilla.org/scriptableinputstream;1"].createInstance(
+      Ci.nsIScriptableInputStream
+    );
+    sstream.init(stream);
+    let text = sstream.read(sstream.available());
+    sstream.close();
+    return text;
+  } catch (e) {
+    if (e.result != Cr.NS_ERROR_FILE_NOT_FOUND) {
+      dump("Getting " + aURI + ": " + e + "\n");
+    }
+    return null;
+  }
+}
+
+function HTMLTheme(aBaseURI) {
+  let files = {
+    footer: "Footer.html",
+    header: "Header.html",
+    status: "Status.html",
+    statusNext: "NextStatus.html",
+    incomingContent: "Incoming/Content.html",
+    incomingContext: "Incoming/Context.html",
+    incomingNextContent: "Incoming/NextContent.html",
+    incomingNextContext: "Incoming/NextContext.html",
+    outgoingContent: "Outgoing/Content.html",
+    outgoingContext: "Outgoing/Context.html",
+    outgoingNextContent: "Outgoing/NextContent.html",
+    outgoingNextContext: "Outgoing/NextContext.html",
+  };
+
+  for (let id in files) {
+    let html = getChromeFile(aBaseURI + files[id]);
+    if (html) {
+      Object.defineProperty(this, id, { value: html });
+    }
+  }
+
+  if (!("incomingContent" in files)) {
+    throw new Error("Invalid theme: Incoming/Content.html is missing!");
+  }
+}
+
+HTMLTheme.prototype = {
+  get footer() {
+    return "";
+  },
+  get header() {
+    return "";
+  },
+  get status() {
+    return this.incomingContent;
+  },
+  get statusNext() {
+    return this.status;
+  },
+  get incomingContent() {
+    throw new Error("Incoming/Content.html is a required file");
+  },
+  get incomingNextContent() {
+    return this.incomingContent;
+  },
+  get outgoingContent() {
+    return this.incomingContent;
+  },
+  get outgoingNextContent() {
+    return this.incomingNextContent;
+  },
+  get incomingContext() {
+    return this.incomingContent;
+  },
+  get incomingNextContext() {
+    return this.incomingNextContent;
+  },
+  get outgoingContext() {
+    return this.hasOwnProperty("outgoingContent")
+      ? this.outgoingContent
+      : this.incomingContext;
+  },
+  get outgoingNextContext() {
+    return this.hasOwnProperty("outgoingNextContent")
+      ? this.outgoingNextContent
+      : this.incomingNextContext;
+  },
+};
+
+function plistToJSON(aElt) {
+  switch (aElt.localName) {
+    case "true":
+      return true;
+    case "false":
+      return false;
+    case "string":
+    case "data":
+      return aElt.textContent;
+    case "real":
+      return parseFloat(aElt.textContent);
+    case "integer":
+      return parseInt(aElt.textContent, 10);
+
+    case "dict":
+      let res = {};
+      let nodes = aElt.children;
+      for (let i = 0; i < nodes.length; ++i) {
+        if (nodes[i].nodeName == "key") {
+          let key = nodes[i].textContent;
+          ++i;
+          while (!Element.isInstance(nodes[i])) {
+            ++i;
+          }
+          res[key] = plistToJSON(nodes[i]);
+        }
+      }
+      return res;
+
+    case "array":
+      let array = [];
+      nodes = aElt.children;
+      for (let i = 0; i < nodes.length; ++i) {
+        if (Element.isInstance(nodes[i])) {
+          array.push(plistToJSON(nodes[i]));
+        }
+      }
+      return array;
+
+    default:
+      throw new Error("Unknown tag in plist file");
+  }
+}
+
+function getInfoPlistContent(aBaseURI) {
+  try {
+    let channel = Services.io.newChannel(
+      aBaseURI + "Info.plist",
+      null,
+      null,
+      null,
+      Services.scriptSecurityManager.getSystemPrincipal(),
+      null,
+      Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+      Ci.nsIContentPolicy.TYPE_OTHER
+    );
+    let stream = channel.open();
+    let parser = new DOMParser();
+    let doc = parser.parseFromStream(
+      stream,
+      null,
+      stream.available(),
+      "text/xml"
+    );
+    if (doc.documentElement.localName != "plist") {
+      throw new Error("Invalid Info.plist file");
+    }
+    let node = doc.documentElement.firstElementChild;
+    while (node && !Element.isInstance(node)) {
+      node = node.nextElementSibling;
+    }
+    if (!node || node.localName != "dict") {
+      throw new Error("Empty or invalid Info.plist file");
+    }
+    return plistToJSON(node);
+  } catch (e) {
+    console.error(e);
+    return null;
+  }
+}
+
+function getChromeBaseURI(aThemeName) {
+  if (DEFAULT_THEMES.includes(aThemeName)) {
+    return "chrome://messenger-messagestyles/skin/" + aThemeName + "/";
+  }
+  return "chrome://" + aThemeName + "/skin/";
+}
+
+export function getThemeByName(aName) {
+  let baseURI = getChromeBaseURI(aName);
+  let metadata = getInfoPlistContent(baseURI);
+  if (!metadata) {
+    throw new Error("Cannot load theme " + aName);
+  }
+
+  return {
+    name: aName,
+    variant: "default",
+    baseURI,
+    metadata,
+    html: new HTMLTheme(baseURI),
+    combineConsecutive: lazy.gPrefBranch.getBoolPref(kCombineConsecutivePref),
+    combineConsecutiveInterval: lazy.gPrefBranch.getIntPref(
+      kCombineConsecutiveIntervalPref
+    ),
+  };
+}
+
+export function getCurrentTheme() {
+  let name = lazy.gPrefBranch.getCharPref(kThemePref);
+  let variant = lazy.gPrefBranch.getCharPref(kVariantPref);
+  if (
+    gCurrentTheme &&
+    gCurrentTheme.name == name &&
+    gCurrentTheme.variant == variant
+  ) {
+    return gCurrentTheme;
+  }
+
+  try {
+    gCurrentTheme = getThemeByName(name);
+    gCurrentTheme.variant = variant;
+  } catch (e) {
+    console.error(e);
+    gCurrentTheme = getThemeByName(DEFAULT_THEME);
+    gCurrentTheme.variant = "default";
+  }
+
+  return gCurrentTheme;
+}
+
+function getDirectoryEntries(aDir) {
+  let ios = Services.io;
+  let uri = ios.newURI(aDir);
+  let cr = Cc["@mozilla.org/chrome/chrome-registry;1"].getService(
+    Ci.nsIXULChromeRegistry
+  );
+  while (uri.scheme == "chrome") {
+    uri = cr.convertChromeURL(uri);
+  }
+
+  // remove any trailing file name added by convertChromeURL
+  let spec = uri.spec.replace(/[^\/]+$/, "");
+  uri = ios.newURI(spec);
+
+  let results = [];
+  if (uri.scheme == "jar") {
+    uri.QueryInterface(Ci.nsIJARURI);
+    let strEntry = uri.JAREntry;
+    if (!strEntry) {
+      return [];
+    }
+
+    let zr = Cc["@mozilla.org/libjar/zip-reader;1"].createInstance(
+      Ci.nsIZipReader
+    );
+    let jarFile = uri.JARFile;
+    if (jarFile instanceof Ci.nsIJARURI) {
+      let innerZr = Cc["@mozilla.org/libjar/zip-reader;1"].createInstance(
+        Ci.nsIZipReader
+      );
+      innerZr.open(jarFile.JARFile.QueryInterface(Ci.nsIFileURL).file);
+      zr.openInner(innerZr, jarFile.JAREntry);
+    } else {
+      zr.open(jarFile.QueryInterface(Ci.nsIFileURL).file);
+    }
+
+    if (!zr.hasEntry(strEntry) || !zr.getEntry(strEntry).isDirectory) {
+      zr.close();
+      return [];
+    }
+
+    let escapedEntry = strEntry.replace(/([*?$[\]^~()\\])/g, "\\$1");
+    let filter = escapedEntry + "?*~" + escapedEntry + "?*/?*";
+    let entries = zr.findEntries(filter);
+
+    let parentLength = strEntry.length;
+    for (let entry of entries) {
+      results.push(entry.substring(parentLength));
+    }
+    zr.close();
+  } else if (uri.scheme == "file") {
+    uri.QueryInterface(Ci.nsIFileURL);
+    let dir = uri.file;
+
+    if (!dir.exists() || !dir.isDirectory()) {
+      return [];
+    }
+
+    for (let file of dir.directoryEntries) {
+      results.push(file.leafName);
+    }
+  }
+
+  return results;
+}
+
+export function getThemeVariants(aTheme) {
+  let variants = getDirectoryEntries(aTheme.baseURI + "Variants/");
+  return variants
+    .filter(v => v.endsWith(".css"))
+    .map(v => v.substring(0, v.length - 4));
+}
+
+/* helper function for replacements in messages */
+function getBuddyFromMessage(aMsg) {
+  if (aMsg.incoming) {
+    let conv = aMsg.conversation;
+    if (!conv.isChat) {
+      return conv.buddy;
+    }
+  }
+
+  return null;
+}
+
+function getStatusIconFromBuddy(aBuddy) {
+  let status = "unknown";
+  if (aBuddy) {
+    if (!aBuddy.online) {
+      status = "offline";
+    } else if (aBuddy.idle) {
+      status = "idle";
+    } else if (!aBuddy.available) {
+      status = "away";
+    } else {
+      status = "available";
+    }
+  }
+
+  return "chrome://chat/skin/" + status + "-16.png";
+}
+
+var footerReplacements = {
+  chatName: aConv => lazy.TXTToHTML(aConv.title),
+  sourceName: aConv =>
+    lazy.TXTToHTML(aConv.account.alias || aConv.account.name),
+  destinationName: aConv => lazy.TXTToHTML(aConv.name),
+  destinationDisplayName: aConv => lazy.TXTToHTML(aConv.title),
+  incomingIconPath(aConv) {
+    let buddy;
+    return (
+      (!aConv.isChat && (buddy = aConv.buddy) && buddy.buddyIconFilename) ||
+      "incoming_icon.png"
+    );
+  },
+  outgoingIconPath: aConv => "outgoing_icon.png",
+  timeOpened(aConv, aFormat) {
+    let date = new Date(aConv.startDate / 1000);
+    if (aFormat) {
+      return lazy.ToLocaleFormat(aFormat, date);
+    }
+    return lazy.gTimeFormatter.format(date);
+  },
+};
+
+function formatAutoResponce(aTxt) {
+  return Services.strings
+    .createBundle("chrome://chat/locale/conversations.properties")
+    .formatStringFromName("autoReply", [aTxt]);
+}
+
+var statusMessageReplacements = {
+  message: aMsg =>
+    '<span class="ib-msg-txt">' +
+    (aMsg.autoResponse ? formatAutoResponce(aMsg.message) : aMsg.message) +
+    "</span>",
+  time(aMsg, aFormat) {
+    let date = new Date(aMsg.time * 1000);
+    if (aFormat) {
+      return lazy.ToLocaleFormat(aFormat, date);
+    }
+    return lazy.gTimeFormatter.format(date);
+  },
+  timestamp: aMsg => aMsg.time,
+  shortTime(aMsg) {
+    return lazy.gTimeFormatter.format(new Date(aMsg.time * 1000));
+  },
+  messageClasses(aMsg) {
+    let msgClass = [];
+
+    if (aMsg.system) {
+      msgClass.push("event");
+    } else {
+      msgClass.push("message");
+
+      if (aMsg.incoming) {
+        msgClass.push("incoming");
+      } else if (aMsg.outgoing) {
+        msgClass.push("outgoing");
+      }
+
+      if (aMsg.action) {
+        msgClass.push("action");
+      }
+
+      if (aMsg.autoResponse) {
+        msgClass.push("autoreply");
+      }
+    }
+
+    if (aMsg.containsNick) {
+      msgClass.push("nick");
+    }
+    if (aMsg.error) {
+      msgClass.push("error");
+    }
+    if (aMsg.delayed) {
+      msgClass.push("delayed");
+    }
+    if (aMsg.notification) {
+      msgClass.push("notification");
+    }
+    if (aMsg.noFormat) {
+      msgClass.push("monospaced");
+    }
+    if (aMsg.noCollapse) {
+      msgClass.push("no-collapse");
+    }
+
+    return msgClass.join(" ");
+  },
+};
+
+function formatSender(aName, isEncrypted = false) {
+  let otr = isEncrypted ? " message-encrypted" : "";
+  return `<span class="ib-sender${otr}">${lazy.TXTToHTML(aName)}</span>`;
+}
+var messageReplacements = {
+  userIconPath(aMsg) {
+    // If the protocol plugin provides an icon for the message, use it.
+    let iconURL = aMsg.iconURL;
+    if (iconURL) {
+      return iconURL;
+    }
+
+    // For outgoing messages, use the current user icon.
+    if (aMsg.outgoing) {
+      iconURL = aMsg.conversation.account.statusInfo.getUserIcon();
+      if (iconURL) {
+        return iconURL.spec;
+      }
+    }
+
+    // Fallback to the theme's default icons.
+    return (aMsg.incoming ? "Incoming" : "Outgoing") + "/buddy_icon.svg";
+  },
+  senderScreenName: aMsg => formatSender(aMsg.who, aMsg.isEncrypted),
+  sender: aMsg => formatSender(aMsg.alias || aMsg.who, aMsg.isEncrypted),
+  senderColor: aMsg => aMsg.color,
+  senderStatusIcon: aMsg => getStatusIconFromBuddy(getBuddyFromMessage(aMsg)),
+  messageDirection: aMsg => "ltr",
+  // no theme actually use this, don't bother making sure this is the real
+  // serverside alias
+  senderDisplayName: aMsg =>
+    formatSender(aMsg.alias || aMsg.who, aMsg.isEncrypted),
+  service: aMsg => aMsg.conversation.account.protocol.name,
+  textbackgroundcolor: (aMsg, aFormat) => "transparent", // FIXME?
+  __proto__: statusMessageReplacements,
+};
+
+var statusReplacements = {
+  status: aMsg => "", // FIXME
+  statusIcon(aMsg) {
+    let conv = aMsg.conversation;
+    let buddy = null;
+    if (!conv.isChat) {
+      buddy = conv.buddy;
+    }
+    return getStatusIconFromBuddy(buddy);
+  },
+  __proto__: statusMessageReplacements,
+};
+
+var kReplacementRegExp = /%([a-zA-Z]*)(\{([^\}]*)\})?%/g;
+
+function replaceKeywordsInHTML(aHTML, aReplacements, aReplacementArg) {
+  kReplacementRegExp.lastIndex = 0;
+  let previousIndex = 0;
+  let result = "";
+  let match;
+  while ((match = kReplacementRegExp.exec(aHTML))) {
+    let content = "";
+    if (match[1] in aReplacements) {
+      content = aReplacements[match[1]](aReplacementArg, match[3]);
+    } else {
+      console.error(
+        "Unknown replacement string %" + match[1] + "% in message styles."
+      );
+    }
+    result += aHTML.substring(previousIndex, match.index) + content;
+    previousIndex = kReplacementRegExp.lastIndex;
+  }
+
+  return result + aHTML.slice(previousIndex);
+}
+
+/**
+ * Determine if a message should be grouped with a previous message.
+ *
+ * @param {object} aTheme - The theme the messages will be displayed in.
+ * @param {imIMessage} aMsg - The message that is about to be appended.
+ * @param {imIMessage} aPreviousMsg - The last message that was displayed.
+ * @returns {boolean} If the message should be grouped with the previous one.
+ */
+export function isNextMessage(aTheme, aMsg, aPreviousMsg) {
+  if (
+    !aTheme.combineConsecutive ||
+    (hasMetadataKey(aTheme, "DisableCombineConsecutive") &&
+      getMetadata(aTheme, "DisableCombineConsecutive"))
+  ) {
+    return false;
+  }
+
+  if (!aPreviousMsg) {
+    return false;
+  }
+
+  if (aMsg.system && aPreviousMsg.system) {
+    return true;
+  }
+
+  if (
+    aMsg.who != aPreviousMsg.who ||
+    aMsg.outgoing != aPreviousMsg.outgoing ||
+    aMsg.incoming != aPreviousMsg.incoming ||
+    aMsg.system != aPreviousMsg.system
+  ) {
+    return false;
+  }
+
+  let timeDifference = aMsg.time - aPreviousMsg.time;
+  return (
+    timeDifference >= 0 && timeDifference <= aTheme.combineConsecutiveInterval
+  );
+}
+
+/**
+ * Determine whether the message was a next message when it was initially
+ * inserted.
+ *
+ * @param {imIMessage} msg
+ * @param {DOMDocument} doc
+ * @returns {boolean} If the message is a next message. Returns false if the
+ *   message doesn't already exist in the conversation.
+ */
+export function wasNextMessage(msg, doc) {
+  return Boolean(
+    doc.querySelector(`#Chat [data-remote-id="${CSS.escape(msg.remoteId)}"]`)
+      ?.dataset.isNext
+  );
+}
+
+/**
+ * Create an HTML string to insert the message into the conversation.
+ *
+ * @param {imIMessage} aMsg
+ * @param {object} aTheme
+ * @param {boolean} aIsNext - If this message is immediately following a
+ *   message of the same origin. Used for visual grouping.
+ * @param {boolean} aIsContext - If this message was already read by the user
+ *   previously and just provided for context.
+ * @returns {string} Raw HTML for the message.
+ */
+export function getHTMLForMessage(aMsg, aTheme, aIsNext, aIsContext) {
+  let html, replacements;
+  if (aMsg.system) {
+    html = aIsNext ? aTheme.html.statusNext : aTheme.html.status;
+    replacements = statusReplacements;
+  } else {
+    html = aMsg.incoming ? "incoming" : "outgoing";
+    if (aIsNext) {
+      html += "Next";
+    }
+    html += aIsContext ? "Context" : "Content";
+    html = aTheme.html[html];
+    replacements = messageReplacements;
+    if (aMsg.action) {
+      let actionMessageTemplate = "* %message% *";
+      if (hasMetadataKey(aTheme, "ActionMessageTemplate")) {
+        actionMessageTemplate = getMetadata(aTheme, "ActionMessageTemplate");
+      }
+      html = html.replace(/%message%/g, actionMessageTemplate);
+    }
+  }
+
+  return replaceKeywordsInHTML(html, replacements, aMsg);
+}
+
+/**
+ *
+ * @param {imIMessage} aMsg
+ * @param {string} aHTML
+ * @param {DOMDocument} aDoc
+ * @param {boolean} aIsNext
+ * @returns {Element}
+ */
+export function insertHTMLForMessage(aMsg, aHTML, aDoc, aIsNext) {
+  let insert = aDoc.getElementById("insert");
+  if (insert && !aIsNext) {
+    insert.remove();
+    insert = null;
+  }
+
+  let parent = insert ? insert.parentNode : aDoc.getElementById("Chat");
+  let documentFragment = getDocumentFragmentFromHTML(aDoc, aHTML);
+
+  // If the parent already has a remote ID, we remove it, since it now contains
+  // multiple different messages.
+  if (parent.dataset.remoteId) {
+    for (let child of parent.children) {
+      child.dataset.remoteId = parent.dataset.remoteId;
+      child.dataset.isNext = true;
+    }
+    delete parent.dataset.remoteId;
+  }
+
+  let result = documentFragment.firstElementChild;
+  // store the prplIMessage object in each of the "root" node that
+  // will be inserted into the document, so that selection code can
+  // retrieve the message by just looking at the parent node until it
+  // finds something.
+  for (let root = result; root; root = root.nextElementSibling) {
+    // Skip the insert placeholder.
+    if (root.id === "insert") {
+      continue;
+    }
+    root._originalMsg = aMsg;
+    // Store remote ID of the message in the DOM for fast retrieval
+    root.dataset.remoteId = aMsg.remoteId;
+    if (aIsNext) {
+      root.dataset.isNext = aIsNext;
+    }
+  }
+
+  // make sure the result is an HTMLElement and not some text (whitespace)...
+  while (
+    result &&
+    !(
+      result.nodeType == result.ELEMENT_NODE &&
+      result.namespaceURI == "http://www.w3.org/1999/xhtml"
+    )
+  ) {
+    result = result.nextElementSibling;
+  }
+  if (insert) {
+    parent.replaceChild(documentFragment, insert);
+  } else {
+    parent.appendChild(documentFragment);
+  }
+  return result;
+}
+
+/**
+ * Replace the HTML of an already displayed message based on the matching
+ * remote ID.
+ *
+ * @param {imIMessage} msg - Message to insert the updated contents of.
+ * @param {string} html - The HTML contents to insert.
+ * @param {Document} doc - The HTML document the message should be replaced
+ *   in.
+ * @param {boolean} isNext - If this message is immediately following a
+ *   message of the same origin. Used for visual grouping.
+ */
+export function replaceHTMLForMessage(msg, html, doc, isNext) {
+  // If the updated message has no remote ID, do nothing.
+  if (!msg.remoteId) {
+    return;
+  }
+  let message = getExistingMessage(msg.remoteId, doc);
+
+  // If we couldn't find a matching message, do nothing.
+  if (!message.length) {
+    return;
+  }
+
+  let documentFragment = getDocumentFragmentFromHTML(doc, html);
+  // We don't want to add an insert point when replacing a message.
+  documentFragment.querySelector("#insert")?.remove();
+  // store the prplIMessage object in each of the "root" nodes that
+  // will be inserted into the document, so that the selection code can
+  // retrieve the message by just looking at the parent node until it
+  // finds something.
+  for (
+    let root = documentFragment.firstElementChild;
+    root;
+    root = root.nextElementSibling
+  ) {
+    root._originalMsg = msg;
+    root.dataset.remoteId = msg.remoteId;
+    if (isNext) {
+      root.dataset.isNext = isNext;
+    }
+  }
+
+  // Remove all but the first element of the original message
+  if (message.length > 1) {
+    let range = doc.createRange();
+    range.setStartBefore(message[1]);
+    range.setEndAfter(message[message.length - 1]);
+    range.deleteContents();
+  }
+  // Insert the new message into the DOM
+  message[0].replaceWith(documentFragment);
+}
+
+/**
+ * Remove all elements belonging to a message from the document, based on the
+ * remote ID of the message.
+ *
+ * @param {string} remoteId
+ * @param {Document} doc
+ */
+export function removeMessage(remoteId, doc) {
+  let message = getExistingMessage(remoteId, doc);
+
+  // If we couldn't find a matching message, do nothing.
+  if (!message.length) {
+    return;
+  }
+
+  // Remove all elements of the original message
+  let range = doc.createRange();
+  range.setStartBefore(message[0]);
+  range.setEndAfter(message[message.length - 1]);
+  range.deleteContents();
+}
+
+function hasMetadataKey(aTheme, aKey) {
+  return (
+    aKey in aTheme.metadata ||
+    (aTheme.variant != "default" &&
+      aKey + ":" + aTheme.variant in aTheme.metadata) ||
+    ("DefaultVariant" in aTheme.metadata &&
+      aKey + ":" + aTheme.metadata.DefaultVariant in aTheme.metadata)
+  );
+}
+
+function getMetadata(aTheme, aKey) {
+  if (
+    aTheme.variant != "default" &&
+    aKey + ":" + aTheme.variant in aTheme.metadata
+  ) {
+    return aTheme.metadata[aKey + ":" + aTheme.variant];
+  }
+
+  if (
+    "DefaultVariant" in aTheme.metadata &&
+    aKey + ":" + aTheme.metadata.DefaultVariant in aTheme.metadata
+  ) {
+    return aTheme.metadata[aKey + ":" + aTheme.metadata.DefaultVariant];
+  }
+
+  return aTheme.metadata[aKey];
+}
+
+export function initHTMLDocument(aConv, aTheme, aDoc) {
+  let base = aDoc.createElement("base");
+  base.href = aTheme.baseURI;
+  aDoc.head.appendChild(base);
+
+  // Screen readers may read the title of the document, so provide one
+  // to avoid an ugly fallback to the URL (see bug 1165).
+  aDoc.title = aConv.title;
+
+  function addCSS(aHref) {
+    let link = aDoc.createElement("link");
+    link.setAttribute("rel", "stylesheet");
+    link.setAttribute("href", aHref);
+    link.setAttribute("type", "text/css");
+    aDoc.head.appendChild(link);
+  }
+  addCSS("chrome://chat/skin/conv.css");
+  addCSS("chrome://messenger/skin/icons.css");
+
+  // add css to handle DefaultFontFamily and DefaultFontSize
+  let cssText = "";
+  if (hasMetadataKey(aTheme, "DefaultFontFamily")) {
+    cssText += "font-family: " + getMetadata(aTheme, "DefaultFontFamily") + ";";
+  }
+  if (hasMetadataKey(aTheme, "DefaultFontSize")) {
+    cssText += "font-size: " + getMetadata(aTheme, "DefaultFontSize") + ";";
+  }
+  if (cssText) {
+    addCSS("data:text/css,*{ " + cssText + " }");
+  }
+
+  // add the main CSS file of the theme
+  if (aTheme.metadata.MessageViewVersion >= 3 || aTheme.variant == "default") {
+    addCSS("main.css");
+  }
+
+  // add the CSS file of the variant
+  if (aTheme.variant != "default") {
+    addCSS("Variants/" + aTheme.variant + ".css");
+  } else if ("DefaultVariant" in aTheme.metadata) {
+    addCSS("Variants/" + aTheme.metadata.DefaultVariant + ".css");
+  }
+  aDoc.body.id = "ibcontent";
+
+  // We insert the whole content of body: chat div, footer
+  let html = '<div id="Chat" aria-live="polite"></div>';
+  html += replaceKeywordsInHTML(aTheme.html.footer, footerReplacements, aConv);
+
+  let frag = getDocumentFragmentFromHTML(aDoc, html);
+  aDoc.body.appendChild(frag);
+  if (!aTheme.metadata.NoScript) {
+    const scriptTag = aDoc.createElement("script");
+    scriptTag.src = "inline.js";
+    aDoc.body.appendChild(scriptTag);
+  }
+  aDoc.defaultView.convertTimeUnits = lazy.DownloadUtils.convertTimeUnits;
+}
+
+/* Selection stuff */
+function getEllipsis() {
+  let ellipsis = "[\u2026]";
+
+  try {
+    ellipsis = Services.prefs.getComplexValue(
+      "messenger.conversations.selections.ellipsis",
+      Ci.nsIPrefLocalizedString
+    ).data;
+  } catch (e) {}
+  return ellipsis;
+}
+
+function _serializeDOMObject(aDocument, aInitFunction) {
+  // This shouldn't really be a constant, as we want to support
+  // text/html too in the future.
+  const type = "text/plain";
+
+  let encoder = Cu.createDocumentEncoder(type);
+  encoder.init(aDocument, type, Ci.nsIDocumentEncoder.OutputPreformatted);
+  aInitFunction(encoder);
+  let result = encoder.encodeToString();
+  return result;
+}
+
+function serializeRange(aRange) {
+  return _serializeDOMObject(
+    aRange.startContainer.ownerDocument,
+    function (aEncoder) {
+      aEncoder.setRange(aRange);
+    }
+  );
+}
+
+function serializeNode(aNode) {
+  return _serializeDOMObject(aNode.ownerDocument, function (aEncoder) {
+    aEncoder.setNode(aNode);
+  });
+}
+
+/* This function is used to pretty print a selection inside a conversation area */
+export function serializeSelection(aSelection) {
+  // We have two kinds of selection serialization:
+  //  - The short version, used when only a part of message is
+  //    selected, or if nothing interesting is selected
+  let shortSelection = "";
+
+  //  - The long version, which is used:
+  //      * when both some of the message text and some of the context
+  //        (sender, time, ...) is selected;
+  //      * when several messages are selected at once
+  //    This version uses an array, with each message formatted
+  //    through the theme system.
+  let longSelection = [];
+
+  // We first assume that we are going to use the short version, but
+  // while working on creating the short version, we prepare
+  // everything to be able to switch to the long version if we later
+  // discover that it is in fact needed.
+  let shortVersionPossible = true;
+
+  // Sometimes we need to know if a selection range is inside the same
+  // message as the previous selection range, so we keep track of the
+  // last message we have processed.
+  let lastMessage = null;
+
+  for (let i = 0; i < aSelection.rangeCount; ++i) {
+    let range = aSelection.getRangeAt(i);
+    let messages = getMessagesForRange(range);
+
+    // If at least one selected message has some of its text selected,
+    // remove from the selection all the messages that have no text
+    // selected
+    let testFunction = msg => msg.isTextSelected();
+    if (messages.some(testFunction)) {
+      messages = messages.filter(testFunction);
+    }
+
+    if (!messages.length) {
+      // Do it only if it wouldn't override a better already found selection
+      if (!shortSelection) {
+        shortSelection = serializeRange(range);
+      }
+      continue;
+    }
+
+    if (
+      shortVersionPossible &&
+      messages.length == 1 &&
+      (!messages[0].isTextSelected() || messages[0].onlyTextSelected()) &&
+      (!lastMessage ||
+        lastMessage.msg == messages[0].msg ||
+        lastMessage.msg.who == messages[0].msg.who)
+    ) {
+      if (shortSelection) {
+        if (lastMessage.msg != messages[0].msg) {
+          // Add the ellipsis only if the previous message was cut
+          if (lastMessage.cutEnd) {
+            shortSelection += " " + getEllipsis();
+          }
+          shortSelection += kLineBreak;
+        } else {
+          shortSelection += " " + getEllipsis() + " ";
+        }
+      }
+      shortSelection += serializeRange(range);
+      longSelection.push(messages[0].getFormattedMessage());
+    } else {
+      shortVersionPossible = false;
+      for (let m = 0; m < messages.length; ++m) {
+        let message = messages[m];
+        if (m == 0 && lastMessage && lastMessage.msg == message.msg) {
+          let text = message.getSelectedText();
+          if (message.cutEnd) {
+            text += " " + getEllipsis();
+          }
+          longSelection[longSelection.length - 1] += " " + text;
+        } else {
+          longSelection.push(message.getFormattedMessage());
+        }
+      }
+    }
+    lastMessage = messages[messages.length - 1];
+  }
+
+  if (shortVersionPossible) {
+    return shortSelection || aSelection.toString();
+  }
+  return longSelection.join(kLineBreak);
+}
+
+function SelectedMessage(aRootNode, aRange) {
+  this._rootNodes = [aRootNode];
+  this._range = aRange;
+}
+
+SelectedMessage.prototype = {
+  get msg() {
+    return this._rootNodes[0]._originalMsg;
+  },
+  addRoot(aRootNode) {
+    this._rootNodes.push(aRootNode);
+  },
+
+  // Helper function that returns the first span node of class
+  // ib-msg-text under the rootNodes of the selected message.
+  _getSpanNode() {
+    // first use the cached value if any
+    if (this._spanNode) {
+      return this._spanNode;
+    }
+
+    let spanNode = null;
+    // If we could use NodeFilter.webidl, we wouldn't have to make up our own
+    // object. FILTER_REJECT is not used here, but included for completeness.
+    const NodeFilter = {
+      SHOW_ELEMENT: 0x1,
+      FILTER_ACCEPT: 1,
+      FILTER_REJECT: 2,
+      FILTER_SKIP: 3,
+    };
+    // helper filter function for the tree walker
+    let filter = function (node) {
+      return node.className == "ib-msg-txt"
+        ? NodeFilter.FILTER_ACCEPT
+        : NodeFilter.FILTER_SKIP;
+    };
+    // walk the DOM subtrees of each root, keep the first correct span node
+    for (let i = 0; !spanNode && i < this._rootNodes.length; ++i) {
+      let rootNode = this._rootNodes[i];
+      // the TreeWalker doesn't test the root node, special case it first
+      if (filter(rootNode) == NodeFilter.FILTER_ACCEPT) {
+        spanNode = rootNode;
+        break;
+      }
+      let treeWalker = rootNode.ownerDocument.createTreeWalker(
+        rootNode,
+        NodeFilter.SHOW_ELEMENT,
+        { acceptNode: filter },
+        false
+      );
+      spanNode = treeWalker.nextNode();
+    }
+
+    return (this._spanNode = spanNode);
+  },
+
+  // Initialize _textSelected and _otherSelected; if _textSelected is true,
+  // also initialize _selectedText and _cutBegin/End.
+  _initSelectedText() {
+    if ("_textSelected" in this) {
+      // Already initialized.
+      return;
+    }
+
+    let spanNode = this._getSpanNode();
+    if (!spanNode) {
+      // can happen if the message text is under a separate root node
+      // that isn't selected at all
+      this._textSelected = false;
+      this._otherSelected = true;
+      return;
+    }
+    let startPoint = this._range.comparePoint(spanNode, 0);
+    // Note that we are working on the HTML DOM, including text nodes,
+    // so we need to use childNodes here and below.
+    let endPoint = this._range.comparePoint(
+      spanNode,
+      spanNode.childNodes.length
+    );
+    if (startPoint <= 0 && endPoint >= 0) {
+      let range = this._range.cloneRange();
+      if (startPoint >= 0) {
+        range.setStart(spanNode, 0);
+      }
+      if (endPoint <= 0) {
+        range.setEnd(spanNode, spanNode.childNodes.length);
+      }
+      this._selectedText = serializeRange(range);
+
+      // if the selected text is empty, set _selectedText to false
+      // this happens if the carret is at the offset 0 in the span node
+      this._textSelected = this._selectedText != "";
+    } else {
+      this._textSelected = false;
+    }
+    if (this._textSelected) {
+      // to check if the start or end is cut, the result of
+      // comparePoint is not enough because the selection range may
+      // start or end in a text node instead of the span node
+
+      if (startPoint == -1) {
+        let range = spanNode.ownerDocument.createRange();
+        range.setStart(spanNode, 0);
+        range.setEnd(this._range.startContainer, this._range.startOffset);
+        this._cutBegin = serializeRange(range) != "";
+      } else {
+        this._cutBegin = false;
+      }
+
+      if (endPoint == 1) {
+        let range = spanNode.ownerDocument.createRange();
+        range.setStart(this._range.endContainer, this._range.endOffset);
+        range.setEnd(spanNode, spanNode.childNodes.length);
+        this._cutEnd = !/^(\r?\n)?$/.test(serializeRange(range));
+      } else {
+        this._cutEnd = false;
+      }
+    }
+    this._otherSelected =
+      (startPoint >= 0 || endPoint <= 0) && // eliminate most negative cases
+      (!this._textSelected ||
+        serializeRange(this._range).length > this._selectedText.length);
+  },
+  get cutBegin() {
+    this._initSelectedText();
+    return this._textSelected && this._cutBegin;
+  },
+  get cutEnd() {
+    this._initSelectedText();
+    return this._textSelected && this._cutEnd;
+  },
+  isTextSelected() {
+    this._initSelectedText();
+    return this._textSelected;
+  },
+  onlyTextSelected() {
+    this._initSelectedText();
+    return !this._otherSelected;
+  },
+  getSelectedText() {
+    this._initSelectedText();
+    return this._textSelected ? this._selectedText : "";
+  },
+  getFormattedMessage() {
+    // First, get the selected text
+    this._initSelectedText();
+    let msg = this.msg;
+    let text;
+    if (this._textSelected) {
+      // Add ellipsis is needed
+      text =
+        (this._cutBegin ? getEllipsis() + " " : "") +
+        this._selectedText +
+        (this._cutEnd ? " " + getEllipsis() : "");
+    } else {
+      let div = this._rootNodes[0].ownerDocument.createElement("div");
+      let divChildren = getDocumentFragmentFromHTML(
+        div.ownerDocument,
+        msg.autoResponse ? formatAutoResponce(msg.message) : msg.message
+      );
+      div.appendChild(divChildren);
+      text = serializeNode(div);
+    }
+
+    // then get the suitable replacements and templates for this message
+    let getLocalizedPrefWithDefault = function (aName, aDefault) {
+      try {
+        let prefBranch = Services.prefs.getBranch(
+          "messenger.conversations.selections."
+        );
+        return prefBranch.getComplexValue(aName, Ci.nsIPrefLocalizedString)
+          .data;
+      } catch (e) {
+        return aDefault;
+      }
+    };
+    let html, replacements;
+    if (msg.system) {
+      replacements = statusReplacements;
+      html = getLocalizedPrefWithDefault(
+        "systemMessagesTemplate",
+        "%time% - %message%"
+      );
+    } else {
+      replacements = messageReplacements;
+      if (msg.action) {
+        html = getLocalizedPrefWithDefault(
+          "actionMessagesTemplate",
+          "%time% * %sender% %message%"
+        );
+      } else {
+        html = getLocalizedPrefWithDefault(
+          "contentMessagesTemplate",
+          "%time% - %sender%: %message%"
+        );
+      }
+    }
+
+    // Overrides default replacements so that they don't add a span node.
+    // Also, this uses directly the text variable so that we don't
+    // have to change the content of msg.message and revert it
+    // afterwards.
+    replacements = {
+      message: aMsg => text,
+      sender: aMsg => aMsg.alias || aMsg.who,
+      __proto__: replacements,
+    };
+
+    // Finally, let the theme system do the magic!
+    return replaceKeywordsInHTML(html, replacements, msg);
+  },
+};
+
+export function getMessagesForRange(aRange) {
+  let result = []; // will hold the final result
+  let messages = {}; // used to prevent duplicate messages in the result array
+
+  // cache the range boundaries, they will be used a lot
+  let endNode = aRange.endContainer;
+  let startNode = aRange.startContainer;
+
+  // Helper function to recursively look for _originalMsg JS
+  // properties on DOM nodes, and stop when endNode is reached.
+  // Found nodes are pushed into the rootNodes array.
+  let processSubtree = function (aNode) {
+    if (aNode._originalMsg) {
+      // store the result
+      if (!(aNode._originalMsg.id in messages)) {
+        // we've found a new message!
+        let newMessage = new SelectedMessage(aNode, aRange);
+        messages[aNode._originalMsg.id] = newMessage;
+        result.push(newMessage);
+      } else {
+        // we've found another root of an already known message
+        messages[aNode._originalMsg.id].addRoot(aNode);
+      }
+    }
+
+    // check if we have reached the end node
+    if (aNode == endNode) {
+      return true;
+    }
+
+    // recurse through children
+    if (
+      aNode.nodeType == aNode.ELEMENT_NODE &&
+      aNode.namespaceURI == "http://www.w3.org/1999/xhtml"
+    ) {
+      for (let i = 0; i < aNode.children.length; ++i) {
+        if (processSubtree(aNode.children[i])) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  };
+
+  let currentNode = aRange.commonAncestorContainer;
+  if (
+    currentNode.nodeType == currentNode.ELEMENT_NODE &&
+    currentNode.namespaceURI == "http://www.w3.org/1999/xhtml"
+  ) {
+    // Determine the index of the first and last children of currentNode
+    // that we should process.
+    let found = false;
+    let start = 0;
+    if (currentNode == startNode) {
+      // we want to process all children
+      found = true;
+      start = aRange.startOffset;
+    } else {
+      // startNode needs to be a direct child of currentNode
+      while (startNode.parentNode != currentNode) {
+        startNode = startNode.parentNode;
+      }
+    }
+    let end;
+    if (currentNode == endNode) {
+      end = aRange.endOffset;
+    } else {
+      end = currentNode.children.length;
+    }
+
+    for (let i = start; i < end; ++i) {
+      let node = currentNode.children[i];
+
+      // don't do anything until we find the startNode
+      found = found || node == startNode;
+      if (!found) {
+        continue;
+      }
+
+      if (processSubtree(node)) {
+        break;
+      }
+    }
+  }
+
+  // The selection may not include any root node of the first touched
+  // message, in this case, the DOM traversal of the DOM range
+  // couldn't give us the first message. Make sure we actually have
+  // the message in which the range starts.
+  let firstRoot = aRange.startContainer;
+  while (firstRoot && !firstRoot._originalMsg) {
+    firstRoot = firstRoot.parentNode;
+  }
+  if (firstRoot && !(firstRoot._originalMsg.id in messages)) {
+    result.unshift(new SelectedMessage(firstRoot, aRange));
+  }
+
+  return result;
+}
+
+/**
+ * Turns a raw HTML string into a DocumentFragment usable in the provided
+ * document.
+ *
+ * @param {Document} doc - The Document the fragment will belong to.
+ * @param {string} html  - The target HTML to be parsed.
+ *
+ * @returns {DocumentFragment}
+ */
+export function getDocumentFragmentFromHTML(doc, html) {
+  let uri = Services.io.newURI(doc.baseURI);
+  let flags = Ci.nsIParserUtils.SanitizerAllowStyle;
+  let context = doc.createElement("div");
+  return ParserUtils.parseFragment(html, flags, false, uri, context);
+}
+
+/**
+ * Get all nodes that make up the given message if any.
+ *
+ * @param {string} remoteId - Remote ID of the message to get
+ * @param {Document} doc - Document the message is in.
+ * @returns {NodeList} Node list of all the parts of the message, or an empty
+ *  list if the message is not found.
+ */
+function getExistingMessage(remoteId, doc) {
+  let parent = doc.getElementById("Chat");
+  return parent.querySelectorAll(`[data-remote-id="${CSS.escape(remoteId)}"]`);
+}
diff --git a/comm/chat/modules/imXPCOMUtils.sys.mjs b/comm/chat/modules/imXPCOMUtils.sys.mjs
new file mode 100644
index 0000000000..4a48f2116d
--- /dev/null
+++ b/comm/chat/modules/imXPCOMUtils.sys.mjs
@@ -0,0 +1,249 @@
+/* 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 { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+var kLogLevelPref = "purple.debug.loglevel";
+
+/**
+ * Creates an nsIScriptError instance and logs it.
+ *
+ * @param aModule
+ *        string identifying the module within which the error occurred.
+ * @param aLevel
+ *        the error level as defined in imIDebugMessage.
+ * @param aMessage
+ *        the error message string.
+ * @param aOriginalError
+ *        (optional) JS Error object containing the location where the
+ *        actual error occurred. Its error message is appended to aMessage.
+ */
+export function scriptError(aModule, aLevel, aMessage, aOriginalError) {
+  // Figure out the log level, based on the module and the prefs set.
+  // The module name is split on periods, and if no pref is set the pref with
+  // the last section removed is attempted (until no sections are left, using
+  // the global default log level).
+  let logLevel = -1;
+  let logKeys = ["level"].concat(aModule.split("."));
+  for (; logKeys.length > 0; logKeys.pop()) {
+    let logKey = logKeys.join(".");
+    if (logKey in lazy.gLogLevels) {
+      logLevel = lazy.gLogLevels[logKey];
+      break;
+    }
+  }
+
+  // Only continue if we will log this message.
+  if (logLevel > aLevel && !("imAccount" in this)) {
+    return;
+  }
+
+  let flag = Ci.nsIScriptError.warningFlag;
+  if (aLevel >= Ci.imIDebugMessage.LEVEL_ERROR) {
+    flag = Ci.nsIScriptError.errorFlag;
+  }
+
+  let scriptError = Cc["@mozilla.org/scripterror;1"].createInstance(
+    Ci.nsIScriptError
+  );
+  let caller = Components.stack.caller;
+  let sourceLine = aModule || caller.sourceLine;
+  if (caller.name) {
+    if (sourceLine) {
+      sourceLine += ": ";
+    }
+    sourceLine += caller.name;
+  }
+  let fileName = caller.filename;
+  let lineNumber = caller.lineNumber;
+  if (aOriginalError) {
+    aMessage += "\n" + (aOriginalError.message || aOriginalError);
+    if (aOriginalError.fileName) {
+      fileName = aOriginalError.fileName;
+    }
+    if (aOriginalError.lineNumber) {
+      lineNumber = aOriginalError.lineNumber;
+    }
+  }
+  scriptError.init(
+    aMessage,
+    fileName,
+    sourceLine,
+    lineNumber,
+    null,
+    flag,
+    "component javascript"
+  );
+
+  if (logLevel <= aLevel) {
+    dump(aModule + ": " + aMessage + "\n");
+    if (aLevel == Ci.imIDebugMessage.LEVEL_LOG && logLevel == aLevel) {
+      Services.console.logStringMessage(aMessage);
+    } else {
+      Services.console.logMessage(scriptError);
+    }
+  }
+  if ("imAccount" in this) {
+    this.imAccount.logDebugMessage(scriptError, aLevel);
+  }
+}
+
+export function initLogModule(aModule, aObj = {}) {
+  aObj.DEBUG = scriptError.bind(aObj, aModule, Ci.imIDebugMessage.LEVEL_DEBUG);
+  aObj.LOG = scriptError.bind(aObj, aModule, Ci.imIDebugMessage.LEVEL_LOG);
+  aObj.WARN = scriptError.bind(aObj, aModule, Ci.imIDebugMessage.LEVEL_WARNING);
+  aObj.ERROR = scriptError.bind(aObj, aModule, Ci.imIDebugMessage.LEVEL_ERROR);
+  return aObj;
+}
+
+const lazy = {};
+XPCOMUtils.defineLazyGetter(lazy, "gLogLevels", function () {
+  // This object functions both as an obsever as well as a dict keeping the
+  // log levels with prefs; the log levels all start with "level" (i.e. "level"
+  // for the global level, "level.irc" for the IRC module).  The dual-purpose
+  // is necessary to make sure the observe is left alive while being a weak ref
+  // to avoid cycles with the pref service.
+  let logLevels = {
+    observe(aSubject, aTopic, aData) {
+      let module = "level" + aData.substr(kLogLevelPref.length);
+      if (Services.prefs.getPrefType(aData) == Services.prefs.PREF_INT) {
+        lazy.gLogLevels[module] = Services.prefs.getIntPref(aData);
+      } else {
+        delete lazy.gLogLevels[module];
+      }
+    },
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIObserver",
+      "nsISupportsWeakReference",
+    ]),
+  };
+
+  // Add weak pref observer to see log level pref changes.
+  Services.prefs.addObserver(kLogLevelPref, logLevels, true /* weak */);
+
+  // Initialize with existing log level prefs.
+  for (let pref of Services.prefs.getChildList(kLogLevelPref)) {
+    if (Services.prefs.getPrefType(pref) == Services.prefs.PREF_INT) {
+      logLevels["level" + pref.substr(kLogLevelPref.length)] =
+        Services.prefs.getIntPref(pref);
+    }
+  }
+
+  // Let environment variables override prefs.
+  Services.env
+    .get("PRPL_LOG")
+    .split(/[;,]/)
+    .filter(n => n != "")
+    .forEach(function (env) {
+      let [, module, level] = env.match(/(?:(.*?)[:=])?(\d+)/);
+      logLevels["level" + (module ? "." + module : "")] = parseInt(level, 10);
+    });
+
+  return logLevels;
+});
+
+export function executeSoon(aFunction) {
+  Services.tm.mainThread.dispatch(aFunction, Ci.nsIEventTarget.DISPATCH_NORMAL);
+}
+
+/* Common nsIClassInfo and QueryInterface implementation
+ * shared by all generic objects implemented in this file. */
+export function ClassInfo(aInterfaces, aDescription = "JS Proto Object") {
+  if (!(this instanceof ClassInfo)) {
+    return new ClassInfo(aInterfaces, aDescription);
+  }
+
+  if (!Array.isArray(aInterfaces)) {
+    aInterfaces = [aInterfaces];
+  }
+
+  for (let i of aInterfaces) {
+    if (typeof i == "string" && !(i in Ci)) {
+      Services.console.logStringMessage("ClassInfo: unknown interface " + i);
+    }
+  }
+
+  this._interfaces = aInterfaces.map(i => (typeof i == "string" ? Ci[i] : i));
+
+  this.classDescription = aDescription;
+}
+
+ClassInfo.prototype = {
+  // eslint-disable-next-line mozilla/use-chromeutils-generateqi
+  QueryInterface(iid) {
+    if (
+      iid.equals(Ci.nsISupports) ||
+      iid.equals(Ci.nsIClassInfo) ||
+      this._interfaces.some(i => i.equals(iid))
+    ) {
+      return this;
+    }
+
+    throw Components.Exception("", Cr.NS_ERROR_NO_INTERFACE);
+  },
+  get interfaces() {
+    return [Ci.nsIClassInfo, Ci.nsISupports].concat(this._interfaces);
+  },
+  getScriptableHelper: () => null,
+  contractID: null,
+  classID: null,
+  flags: 0,
+};
+
+export function l10nHelper(aChromeURL) {
+  let bundle = Services.strings.createBundle(aChromeURL);
+  return function (aStringId) {
+    try {
+      if (arguments.length == 1) {
+        return bundle.GetStringFromName(aStringId);
+      }
+      return bundle.formatStringFromName(
+        aStringId,
+        Array.prototype.slice.call(arguments, 1)
+      );
+    } catch (e) {
+      console.error(e);
+      dump("Failed to get " + aStringId + "\n");
+      return aStringId;
+    }
+  };
+}
+
+/**
+ * Constructs an nsISimpleEnumerator for the given array of items.
+ * Copied from netwerk/test/httpserver/httpd.js
+ *
+ * @param items : Array
+ *   the items, which must all implement nsISupports
+ */
+export function nsSimpleEnumerator(items) {
+  this._items = items;
+  this._nextIndex = 0;
+}
+
+nsSimpleEnumerator.prototype = {
+  hasMoreElements() {
+    return this._nextIndex < this._items.length;
+  },
+  getNext() {
+    if (!this.hasMoreElements()) {
+      throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
+    }
+
+    return this._items[this._nextIndex++];
+  },
+  QueryInterface: ChromeUtils.generateQI(["nsISimpleEnumerator"]),
+  [Symbol.iterator]() {
+    return this._items.values();
+  },
+};
+
+export var EmptyEnumerator = {
+  hasMoreElements: () => false,
+  getNext() {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
+  },
+  QueryInterface: ChromeUtils.generateQI(["nsISimpleEnumerator"]),
+  *[Symbol.iterator]() {},
+};
diff --git a/comm/chat/modules/jsProtoHelper.sys.mjs b/comm/chat/modules/jsProtoHelper.sys.mjs
new file mode 100644
index 0000000000..b792a02ffe
--- /dev/null
+++ b/comm/chat/modules/jsProtoHelper.sys.mjs
@@ -0,0 +1,1796 @@
+/* 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 { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import {
+  initLogModule,
+  nsSimpleEnumerator,
+  l10nHelper,
+  ClassInfo,
+} from "resource:///modules/imXPCOMUtils.sys.mjs";
+import { IMServices } from "resource:///modules/IMServices.sys.mjs";
+
+const lazy = {};
+
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/conversations.properties")
+);
+
+XPCOMUtils.defineLazyGetter(lazy, "TXTToHTML", function () {
+  let cs = Cc["@mozilla.org/txttohtmlconv;1"].getService(Ci.mozITXTToHTMLConv);
+  return aTXT => cs.scanTXT(aTXT, cs.kEntities);
+});
+
+function OutgoingMessage(aMsg, aConversation) {
+  this.message = aMsg;
+  this.conversation = aConversation;
+}
+OutgoingMessage.prototype = {
+  __proto__: ClassInfo("imIOutgoingMessage", "Outgoing Message"),
+  cancelled: false,
+  action: false,
+  notification: false,
+};
+
+export var GenericAccountPrototype = {
+  __proto__: ClassInfo("prplIAccount", "generic account object"),
+  get wrappedJSObject() {
+    return this;
+  },
+  _init(aProtocol, aImAccount) {
+    this.protocol = aProtocol;
+    this.imAccount = aImAccount;
+    initLogModule(aProtocol.id, this);
+  },
+  observe(aSubject, aTopic, aData) {},
+  remove() {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+  unInit() {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+  connect() {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+  disconnect() {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+  createConversation(aName) {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+  joinChat(aComponents) {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+  setBool(aName, aVal) {},
+  setInt(aName, aVal) {},
+  setString(aName, aVal) {},
+
+  get name() {
+    return this.imAccount.name;
+  },
+  get connected() {
+    return this.imAccount.connected;
+  },
+  get connecting() {
+    return this.imAccount.connecting;
+  },
+  get disconnected() {
+    return this.imAccount.disconnected;
+  },
+  get disconnecting() {
+    return this.imAccount.disconnecting;
+  },
+  _connectionErrorReason: Ci.prplIAccount.NO_ERROR,
+  get connectionErrorReason() {
+    return this._connectionErrorReason;
+  },
+
+  /**
+   * Convert a socket's nsITransportSecurityInfo into a prplIAccount connection error. Store
+   * the nsITransportSecurityInfo and the connection location on the account so the
+   * certificate exception dialog can access the information.
+   *
+   * @param {Socket} aSocket - Socket where the connection error occurred.
+   * @returns {number} The prplIAccount error constant describing the problem.
+   */
+  handleConnectionSecurityError(aSocket) {
+    // Stash away the connectionTarget and securityInfo.
+    this._connectionTarget = aSocket.host + ":" + aSocket.port;
+    let securityInfo = (this._securityInfo = aSocket.securityInfo);
+
+    if (!securityInfo) {
+      return Ci.prplIAccount.ERROR_CERT_NOT_PROVIDED;
+    }
+
+    if (securityInfo.isUntrusted) {
+      if (securityInfo.serverCert && securityInfo.serverCert.isSelfSigned) {
+        return Ci.prplIAccount.ERROR_CERT_SELF_SIGNED;
+      }
+      return Ci.prplIAccount.ERROR_CERT_UNTRUSTED;
+    }
+
+    if (securityInfo.isNotValidAtThisTime) {
+      if (
+        securityInfo.serverCert &&
+        securityInfo.serverCert.validity.notBefore < Date.now() * 1000
+      ) {
+        return Ci.prplIAccount.ERROR_CERT_NOT_ACTIVATED;
+      }
+      return Ci.prplIAccount.ERROR_CERT_EXPIRED;
+    }
+
+    if (securityInfo.isDomainMismatch) {
+      return Ci.prplIAccount.ERROR_CERT_HOSTNAME_MISMATCH;
+    }
+
+    // XXX ERROR_CERT_FINGERPRINT_MISMATCH
+
+    return Ci.prplIAccount.ERROR_CERT_OTHER_ERROR;
+  },
+  _connectionTarget: "",
+  get connectionTarget() {
+    return this._connectionTarget;
+  },
+  _securityInfo: null,
+  get securityInfo() {
+    return this._securityInfo;
+  },
+
+  reportConnected() {
+    this.imAccount.observe(this, "account-connected", null);
+  },
+  reportConnecting(aConnectionStateMsg) {
+    // Delete any leftover errors from the previous connection.
+    delete this._connectionTarget;
+    delete this._securityInfo;
+
+    if (!this.connecting) {
+      this.imAccount.observe(this, "account-connecting", null);
+    }
+    if (aConnectionStateMsg) {
+      this.imAccount.observe(
+        this,
+        "account-connect-progress",
+        aConnectionStateMsg
+      );
+    }
+  },
+  reportDisconnected() {
+    this.imAccount.observe(this, "account-disconnected", null);
+  },
+  reportDisconnecting(aConnectionErrorReason, aConnectionErrorMessage) {
+    this._connectionErrorReason = aConnectionErrorReason;
+    this.imAccount.observe(
+      this,
+      "account-disconnecting",
+      aConnectionErrorMessage
+    );
+    this.cancelPendingBuddyRequests();
+    this.cancelPendingChatRequests();
+    this.cancelPendingVerificationRequests();
+  },
+
+  // Called when the user adds a new buddy from the UI.
+  addBuddy(aTag, aName) {
+    IMServices.contacts.accountBuddyAdded(
+      new AccountBuddy(this, null, aTag, aName)
+    );
+  },
+  // Called during startup for each of the buddies in the local buddy list.
+  loadBuddy(aBuddy, aTag) {
+    try {
+      return new AccountBuddy(this, aBuddy, aTag);
+    } catch (x) {
+      dump(x + "\n");
+      return null;
+    }
+  },
+
+  _pendingBuddyRequests: null,
+  addBuddyRequest(aUserName, aGrantCallback, aDenyCallback) {
+    if (!this._pendingBuddyRequests) {
+      this._pendingBuddyRequests = [];
+    }
+    let buddyRequest = {
+      get account() {
+        return this._account.imAccount;
+      },
+      get userName() {
+        return aUserName;
+      },
+      _account: this,
+      // Grant and deny callbacks both receive the auth request object as an
+      // argument for further use.
+      grant() {
+        aGrantCallback(this);
+        this._remove();
+      },
+      deny() {
+        aDenyCallback(this);
+        this._remove();
+      },
+      cancel() {
+        Services.obs.notifyObservers(
+          this,
+          "buddy-authorization-request-canceled"
+        );
+        this._remove();
+      },
+      _remove() {
+        this._account.removeBuddyRequest(this);
+      },
+      QueryInterface: ChromeUtils.generateQI(["prplIBuddyRequest"]),
+    };
+    this._pendingBuddyRequests.push(buddyRequest);
+    Services.obs.notifyObservers(buddyRequest, "buddy-authorization-request");
+  },
+  removeBuddyRequest(aRequest) {
+    if (!this._pendingBuddyRequests) {
+      return;
+    }
+
+    this._pendingBuddyRequests = this._pendingBuddyRequests.filter(
+      r => r !== aRequest
+    );
+  },
+  /**
+   * Cancel a pending buddy request.
+   *
+   * @param {string} aUserName - The username the request is for.
+   */
+  cancelBuddyRequest(aUserName) {
+    if (!this._pendingBuddyRequests) {
+      return;
+    }
+
+    for (let request of this._pendingBuddyRequests) {
+      if (request.userName == aUserName) {
+        request.cancel();
+        break;
+      }
+    }
+  },
+  cancelPendingBuddyRequests() {
+    if (!this._pendingBuddyRequests) {
+      return;
+    }
+
+    for (let request of this._pendingBuddyRequests) {
+      request.cancel();
+    }
+    delete this._pendingBuddyRequests;
+  },
+
+  _pendingChatRequests: null,
+  /**
+   * Inform the user about a new conversation invitation.
+   *
+   * @param {string} conversationName - Name of the conversation the user is
+   *   invited to.
+   * @param {(prplIChatRequest) => void} grantCallback - Function to be called
+   *   when the invite is accepted.
+   * @param {(prplIChatRequest?, boolean) => void} [denyCallback] - Function to
+   *   be called when the invite is rejected. If omitted, |canDeny| will be
+   *   |false|. Callback is passed a boolean indicating whether the rejection should be
+   *   sent to the other party. It being false is equivalent to ignoring the invite, in
+   *   which case the callback should try to apply the ignore on the protocol level.
+   */
+  addChatRequest(conversationName, grantCallback, denyCallback) {
+    if (!this._pendingChatRequests) {
+      this._pendingChatRequests = new Set();
+    }
+    let inviteHandling = Services.prefs.getIntPref(
+      "messenger.conversations.autoAcceptChatInvitations"
+    );
+    // Only auto-reject invites that can be denied.
+    if (inviteHandling <= 0 && denyCallback) {
+      const shouldReject = inviteHandling == -1;
+      denyCallback(null, shouldReject);
+      return;
+    }
+    let resolvePromise;
+    let rejectPromise;
+    let completePromise = new Promise((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    });
+    /** @implements {prplIChatRequest} */
+    let chatRequest = {
+      get account() {
+        return this._account.imAccount;
+      },
+      get conversationName() {
+        return conversationName;
+      },
+      get canDeny() {
+        return Boolean(denyCallback);
+      },
+      _account: this,
+      // Grant and deny callbacks both receive the auth request object as an
+      // argument for further use.
+      grant() {
+        resolvePromise(true);
+        grantCallback(this);
+        this._remove();
+      },
+      deny() {
+        if (!denyCallback) {
+          throw new Error("Can not deny this invitation.");
+        }
+        resolvePromise(false);
+        denyCallback(this, true);
+        this._remove();
+      },
+      cancel() {
+        rejectPromise(new Error("Cancelled"));
+        this._remove();
+      },
+      completePromise,
+      _remove() {
+        this._account.removeChatRequest(this);
+      },
+      QueryInterface: ChromeUtils.generateQI(["prplIChatRequest"]),
+    };
+    this._pendingChatRequests.add(chatRequest);
+    Services.obs.notifyObservers(chatRequest, "conv-authorization-request");
+  },
+  removeChatRequest(aRequest) {
+    if (!this._pendingChatRequests) {
+      return;
+    }
+
+    this._pendingChatRequests.delete(aRequest);
+  },
+  /**
+   * Cancel a pending chat request.
+   *
+   * @param {string} conversationName - The conversation the request is for.
+   */
+  cancelChatRequest(conversationName) {
+    if (!this._pendingChatRequests) {
+      return;
+    }
+
+    for (let request of this._pendingChatRequests) {
+      if (request.conversationName == conversationName) {
+        request.cancel();
+        break;
+      }
+    }
+  },
+  cancelPendingChatRequests() {
+    if (!this._pendingChatRequests) {
+      return;
+    }
+
+    for (let request of this._pendingChatRequests) {
+      request.cancel();
+    }
+    this._pendingChatRequests = null;
+  },
+
+  requestBuddyInfo(aBuddyName) {},
+
+  get canJoinChat() {
+    return false;
+  },
+  getChatRoomFields() {
+    if (!this.chatRoomFields) {
+      return [];
+    }
+    let fieldNames = Object.keys(this.chatRoomFields);
+    return fieldNames.map(
+      fieldName => new ChatRoomField(fieldName, this.chatRoomFields[fieldName])
+    );
+  },
+  getChatRoomDefaultFieldValues(aDefaultChatName) {
+    if (!this.chatRoomFields) {
+      return new ChatRoomFieldValues({});
+    }
+
+    let defaultFieldValues = {};
+    for (let fieldName in this.chatRoomFields) {
+      defaultFieldValues[fieldName] = this.chatRoomFields[fieldName].default;
+    }
+
+    if (aDefaultChatName && "parseDefaultChatName" in this) {
+      let parsedDefaultChatName = this.parseDefaultChatName(aDefaultChatName);
+      for (let field in parsedDefaultChatName) {
+        defaultFieldValues[field] = parsedDefaultChatName[field];
+      }
+    }
+
+    return new ChatRoomFieldValues(defaultFieldValues);
+  },
+  requestRoomInfo(aCallback) {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+  getRoomInfo(aName) {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+  get isRoomInfoStale() {
+    return false;
+  },
+
+  getPref(aName, aType) {
+    return this.prefs.prefHasUserValue(aName)
+      ? this.prefs["get" + aType + "Pref"](aName)
+      : this.protocol._getOptionDefault(aName);
+  },
+  getInt(aName) {
+    return this.getPref(aName, "Int");
+  },
+  getBool(aName) {
+    return this.getPref(aName, "Bool");
+  },
+  getString(aName) {
+    return this.prefs.prefHasUserValue(aName)
+      ? this.prefs.getStringPref(aName)
+      : this.protocol._getOptionDefault(aName);
+  },
+
+  get prefs() {
+    return (
+      this._prefs ||
+      (this._prefs = Services.prefs.getBranch(
+        "messenger.account." + this.imAccount.id + ".options."
+      ))
+    );
+  },
+
+  get normalizedName() {
+    return this.normalize(this.name);
+  },
+  normalize(aName) {
+    return aName.toLowerCase();
+  },
+
+  getSessions() {
+    return [];
+  },
+  reportSessionsChanged() {
+    Services.obs.notifyObservers(this.imAccount, "account-sessions-changed");
+  },
+
+  _pendingVerificationRequests: null,
+  /**
+   *
+   * @param {string} aDisplayName - Display name the request is from.
+   * @param {() => Promise<{challenge: string, challengeDescription: string?}>} aGetChallenge - Accept request and generate
+   *   the challenge.
+   * @param {AbortSignal} [aAbortSignal] - Abort signal to indicate the request
+   *   was cancelled.
+   * @returns {Promise<boolean>} Completion promise for the verification.
+   *   Boolean indicates the result of the verification, rejection is a cancel.
+   */
+  addVerificationRequest(aDisplayName, aGetChallenge, aAbortSignal) {
+    if (!this._pendingVerificationRequests) {
+      this._pendingVerificationRequests = [];
+    }
+    let verificationRequest = {
+      _account: this,
+      get account() {
+        return this._account.imAccount;
+      },
+      get subject() {
+        return aDisplayName;
+      },
+      get challengeType() {
+        return Ci.imISessionVerification.CHALLENGE_TEXT;
+      },
+      get challenge() {
+        return this._challenge;
+      },
+      get challengeDescription() {
+        return this._challengeDescription;
+      },
+      _challenge: "",
+      _challengeDescription: "",
+      _canceled: false,
+      completePromise: null,
+      async verify() {
+        const { challenge, challengeDescription = "" } = await aGetChallenge();
+        this._challenge = challenge;
+        this._challengeDescription = challengeDescription;
+      },
+      submitResponse(challengeMatches) {
+        this._accept(challengeMatches);
+        this._remove();
+      },
+      cancel() {
+        if (this._canceled) {
+          return;
+        }
+        this._canceled = true;
+        Services.obs.notifyObservers(
+          this,
+          "buddy-verification-request-canceled"
+        );
+        this._deny();
+        this._remove();
+      },
+      _remove() {
+        this._account.removeVerificationRequest(this);
+      },
+      QueryInterface: ChromeUtils.generateQI([
+        "imIIncomingSessionVerification",
+      ]),
+    };
+    verificationRequest.completePromise = new Promise((resolve, reject) => {
+      verificationRequest._accept = resolve;
+      verificationRequest._deny = reject;
+    });
+    this._pendingVerificationRequests.push(verificationRequest);
+    Services.obs.notifyObservers(
+      verificationRequest,
+      "buddy-verification-request"
+    );
+    if (aAbortSignal) {
+      aAbortSignal.addEventListener(
+        "abort",
+        () => {
+          verificationRequest.cancel();
+        },
+        { once: true }
+      );
+      if (aAbortSignal.aborted) {
+        verificationRequest.cancel();
+      }
+    }
+    return verificationRequest.completePromise;
+  },
+  /**
+   * Remove a verification request for this account.
+   *
+   * @param {imIIncomingSessionVerification} aRequest
+   */
+  removeVerificationRequest(aRequest) {
+    if (!this._pendingVerificationRequests) {
+      return;
+    }
+    this._pendingVerificationRequests =
+      this._pendingVerificationRequests.filter(r => r !== aRequest);
+  },
+  cancelPendingVerificationRequests() {
+    if (!this._pendingVerificationRequests) {
+      return;
+    }
+    for (let request of this._pendingVerificationRequests) {
+      request.cancel();
+    }
+    this._pendingVerificationRequests = null;
+  },
+
+  _encryptionStatus: [],
+  get encryptionStatus() {
+    return this._encryptionStatus;
+  },
+  set encryptionStatus(newStatus) {
+    this._encryptionStatus = newStatus;
+    Services.obs.notifyObservers(
+      this.imAccount,
+      "account-encryption-status-changed",
+      newStatus
+    );
+  },
+};
+
+export var GenericAccountBuddyPrototype = {
+  __proto__: ClassInfo("prplIAccountBuddy", "generic account buddy object"),
+  get DEBUG() {
+    return this._account.DEBUG;
+  },
+  get LOG() {
+    return this._account.LOG;
+  },
+  get WARN() {
+    return this._account.WARN;
+  },
+  get ERROR() {
+    return this._account.ERROR;
+  },
+
+  _init(aAccount, aBuddy, aTag, aUserName) {
+    if (!aBuddy && !aUserName) {
+      throw new Error("aUserName is required when aBuddy is null");
+    }
+
+    this._tag = aTag;
+    this._account = aAccount;
+    this._buddy = aBuddy;
+    if (aBuddy) {
+      let displayName = aBuddy.displayName;
+      if (displayName != aUserName) {
+        this._serverAlias = displayName;
+      }
+    }
+    this._userName = aUserName;
+  },
+  unInit() {
+    delete this._tag;
+    delete this._account;
+    delete this._buddy;
+  },
+
+  get account() {
+    return this._account.imAccount;
+  },
+  set buddy(aBuddy) {
+    if (this._buddy) {
+      throw Components.Exception("", Cr.NS_ERROR_ALREADY_INITIALIZED);
+    }
+    this._buddy = aBuddy;
+  },
+  get buddy() {
+    return this._buddy;
+  },
+  get tag() {
+    return this._tag;
+  },
+  set tag(aNewTag) {
+    let oldTag = this._tag;
+    this._tag = aNewTag;
+    IMServices.contacts.accountBuddyMoved(this, oldTag, aNewTag);
+  },
+
+  _notifyObservers(aTopic, aData) {
+    try {
+      this._buddy.observe(this, "account-buddy-" + aTopic, aData);
+    } catch (e) {
+      this.ERROR(e);
+    }
+  },
+
+  _userName: "",
+  get userName() {
+    return this._userName || this._buddy.userName;
+  },
+  get normalizedName() {
+    return this._account.normalize(this.userName);
+  },
+  _serverAlias: "",
+  get serverAlias() {
+    return this._serverAlias;
+  },
+  set serverAlias(aNewAlias) {
+    let old = this.displayName;
+    this._serverAlias = aNewAlias;
+    if (old != this.displayName) {
+      this._notifyObservers("display-name-changed", old);
+    }
+  },
+
+  /**
+   * Method called to start verification of the buddy. Same signature as
+   * _startVerification of GenericSessionPrototype. If the property is not a
+   * function, |canVerifyIdentity| is false.
+   *
+   * @type {() => {challenge: string, challengeDescription: string?, handleResult: (boolean) => void, cancel: () => void, cancelPromise: Promise}?}
+   */
+  _startVerification: null,
+  get canVerifyIdentity() {
+    return typeof this._startVerification === "function";
+  },
+  _identityVerified: false,
+  get identityVerified() {
+    return this.canVerifyIdentity && this._identityVerified;
+  },
+  verifyIdentity() {
+    if (!this.canVerifyIdentity) {
+      throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+    }
+    if (this.identityVerified) {
+      return Promise.resolve();
+    }
+    return this._startVerification().then(
+      ({
+        challenge,
+        challengeDescription,
+        handleResult,
+        cancel,
+        cancelPromise,
+      }) => {
+        const verifier = new SessionVerification(
+          challenge,
+          this.userName,
+          challengeDescription
+        );
+        verifier.completePromise.then(
+          result => handleResult(result),
+          () => cancel()
+        );
+        cancelPromise.then(() => verifier.cancel());
+        return verifier;
+      }
+    );
+  },
+
+  remove() {
+    IMServices.contacts.accountBuddyRemoved(this);
+  },
+
+  // imIStatusInfo implementation
+  get displayName() {
+    return this.serverAlias || this.userName;
+  },
+  _buddyIconFilename: "",
+  get buddyIconFilename() {
+    return this._buddyIconFilename;
+  },
+  set buddyIconFilename(aNewFileName) {
+    this._buddyIconFilename = aNewFileName;
+    this._notifyObservers("icon-changed");
+  },
+  _statusType: 0,
+  get statusType() {
+    return this._statusType;
+  },
+  get online() {
+    return this._statusType > Ci.imIStatusInfo.STATUS_OFFLINE;
+  },
+  get available() {
+    return this._statusType == Ci.imIStatusInfo.STATUS_AVAILABLE;
+  },
+  get idle() {
+    return this._statusType == Ci.imIStatusInfo.STATUS_IDLE;
+  },
+  get mobile() {
+    return this._statusType == Ci.imIStatusInfo.STATUS_MOBILE;
+  },
+  _statusText: "",
+  get statusText() {
+    return this._statusText;
+  },
+
+  // This is for use by the protocol plugin, it's not exposed in the
+  // imIStatusInfo interface.
+  // All parameters are optional and will be ignored if they are null
+  // or undefined.
+  setStatus(aStatusType, aStatusText, aAvailabilityDetails) {
+    // Ignore omitted parameters.
+    if (aStatusType === undefined || aStatusType === null) {
+      aStatusType = this._statusType;
+    }
+    if (aStatusText === undefined || aStatusText === null) {
+      aStatusText = this._statusText;
+    }
+    if (aAvailabilityDetails === undefined || aAvailabilityDetails === null) {
+      aAvailabilityDetails = this._availabilityDetails;
+    }
+
+    // Decide which notifications should be fired.
+    let notifications = [];
+    if (
+      this._statusType != aStatusType ||
+      this._availabilityDetails != aAvailabilityDetails
+    ) {
+      notifications.push("availability-changed");
+    }
+    if (this._statusType != aStatusType || this._statusText != aStatusText) {
+      notifications.push("status-changed");
+      if (this.online && aStatusType <= Ci.imIStatusInfo.STATUS_OFFLINE) {
+        notifications.push("signed-off");
+      }
+      if (!this.online && aStatusType > Ci.imIStatusInfo.STATUS_OFFLINE) {
+        notifications.push("signed-on");
+      }
+    }
+
+    // Actually change the stored status.
+    [this._statusType, this._statusText, this._availabilityDetails] = [
+      aStatusType,
+      aStatusText,
+      aAvailabilityDetails,
+    ];
+
+    // Fire the notifications.
+    notifications.forEach(function (aTopic) {
+      this._notifyObservers(aTopic);
+    }, this);
+  },
+
+  _availabilityDetails: 0,
+  get availabilityDetails() {
+    return this._availabilityDetails;
+  },
+
+  get canSendMessage() {
+    return this.online;
+  },
+
+  getTooltipInfo: () => [],
+  createConversation() {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+};
+
+// aUserName is required only if aBuddy is null, i.e., we are adding a buddy.
+function AccountBuddy(aAccount, aBuddy, aTag, aUserName) {
+  this._init(aAccount, aBuddy, aTag, aUserName);
+}
+AccountBuddy.prototype = GenericAccountBuddyPrototype;
+
+export var GenericMessagePrototype = {
+  __proto__: ClassInfo("prplIMessage", "generic message object"),
+
+  _lastId: 0,
+  _init(aWho, aMessage, aObject, aConversation) {
+    this.id = ++GenericMessagePrototype._lastId;
+    this.time = Math.floor(new Date() / 1000);
+    this.who = aWho;
+    this.message = aMessage;
+    this.originalMessage = aMessage;
+    this.conversation = aConversation;
+
+    if (aObject) {
+      for (let i in aObject) {
+        this[i] = aObject[i];
+      }
+    }
+  },
+  _alias: "",
+  get alias() {
+    return this._alias || this.who;
+  },
+  _iconURL: "",
+  get iconURL() {
+    // If the protocol plugin has explicitly set an icon for the message, use it.
+    if (this._iconURL) {
+      return this._iconURL;
+    }
+
+    // Otherwise, attempt to find a buddy for incoming messages, and forward the call.
+    if (this.incoming && this.conversation && !this.conversation.isChat) {
+      let buddy = this.conversation.buddy;
+      if (buddy) {
+        return buddy.buddyIconFilename;
+      }
+    }
+    return "";
+  },
+  conversation: null,
+  remoteId: "",
+
+  outgoing: false,
+  incoming: false,
+  system: false,
+  autoResponse: false,
+  containsNick: false,
+  noLog: false,
+  error: false,
+  delayed: false,
+  noFormat: false,
+  containsImages: false,
+  notification: false,
+  noLinkification: false,
+  noCollapse: false,
+  isEncrypted: false,
+  action: false,
+  deleted: false,
+
+  getActions() {
+    return [];
+  },
+
+  whenDisplayed() {},
+  whenRead() {},
+};
+
+export function Message(aWho, aMessage, aObject, aConversation) {
+  this._init(aWho, aMessage, aObject, aConversation);
+}
+
+Message.prototype = GenericMessagePrototype;
+
+export var GenericConversationPrototype = {
+  __proto__: ClassInfo("prplIConversation", "generic conversation object"),
+  get wrappedJSObject() {
+    return this;
+  },
+
+  get DEBUG() {
+    return this._account.DEBUG;
+  },
+  get LOG() {
+    return this._account.LOG;
+  },
+  get WARN() {
+    return this._account.WARN;
+  },
+  get ERROR() {
+    return this._account.ERROR;
+  },
+
+  _init(aAccount, aName) {
+    this._account = aAccount;
+    this._name = aName;
+    this._observers = [];
+    this._date = new Date() * 1000;
+    IMServices.conversations.addConversation(this);
+  },
+
+  _id: 0,
+  get id() {
+    return this._id;
+  },
+  set id(aId) {
+    if (this._id) {
+      throw Components.Exception("", Cr.NS_ERROR_ALREADY_INITIALIZED);
+    }
+    this._id = aId;
+  },
+
+  addObserver(aObserver) {
+    if (!this._observers.includes(aObserver)) {
+      this._observers.push(aObserver);
+    }
+  },
+  removeObserver(aObserver) {
+    this._observers = this._observers.filter(o => o !== aObserver);
+  },
+  notifyObservers(aSubject, aTopic, aData) {
+    for (let observer of this._observers) {
+      try {
+        observer.observe(aSubject, aTopic, aData);
+      } catch (e) {
+        this.ERROR(e);
+      }
+    }
+  },
+
+  prepareForSending: aOutgoingMessage => [aOutgoingMessage.message],
+  prepareForDisplaying(aImMessage) {
+    if (aImMessage.displayMessage !== aImMessage.message) {
+      this.DEBUG(
+        "Preparing:\n" +
+          aImMessage.message +
+          "\nDisplaying:\n" +
+          aImMessage.displayMessage
+      );
+    }
+  },
+  sendMsg(aMsg, aAction = false, aNotification = false) {
+    // Add-ons (eg. pastebin) have an opportunity to cancel the message at this
+    // point, or change the text content of the message.
+    // If an add-on wants to split a message, it should truncate the first
+    // message, and insert new messages using the conversation's sendMsg method.
+    let om = new OutgoingMessage(aMsg, this);
+    om.action = aAction;
+    om.notification = aNotification;
+    this.notifyObservers(om, "preparing-message");
+    if (om.cancelled) {
+      return;
+    }
+
+    // Protocols have an opportunity here to preprocess messages before they are
+    // sent (eg. split long messages). If a message is split here, the split
+    // will be visible in the UI.
+    let messages = this.prepareForSending(om);
+    let isAction = om.action;
+    let isNotification = om.notification;
+
+    for (let msg of messages) {
+      // Add-ons (eg. OTR) have an opportunity to tweak or cancel the message
+      // at this point.
+      om = new OutgoingMessage(msg, this);
+      om.action = isAction;
+      om.notification = isNotification;
+      this.notifyObservers(om, "sending-message");
+      if (om.cancelled) {
+        continue;
+      }
+      this.dispatchMessage(om.message, om.action, om.notification);
+    }
+  },
+  dispatchMessage(message, action, notification) {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+  sendTyping: aString => Ci.prplIConversation.NO_TYPING_LIMIT,
+
+  close() {
+    Services.obs.notifyObservers(this, "closing-conversation");
+    IMServices.conversations.removeConversation(this);
+  },
+  unInit() {
+    delete this._account;
+    delete this._observers;
+  },
+
+  /**
+   * Create a prplIMessage instance from params.
+   *
+   * @param {string} who - Nick of the participant who sent the message.
+   * @param {string} text - Raw message contents.
+   * @param {object} properties - Additional properties of the message.
+   * @returns {prplIMessage}
+   */
+  createMessage(who, text, properties) {
+    return new Message(who, text, properties, this);
+  },
+
+  writeMessage(aWho, aText, aProperties) {
+    const message = this.createMessage(aWho, aText, aProperties);
+    this.notifyObservers(message, "new-text");
+  },
+
+  /**
+   * Update the contents of a message.
+   *
+   * @param {string} who - Nick of the participant who sent the message.
+   * @param {string} text - Raw contents of the message.
+   * @param {object} properties - Additional properties of the message. Should
+   *   specify a |remoteId| to find the previous version of this message.
+   */
+  updateMessage(who, text, properties) {
+    const message = this.createMessage(who, text, properties);
+    this.notifyObservers(message, "update-text");
+  },
+
+  /**
+   * Remove a message from the conversation. Does not affect logs, use
+   * updateMessage with a deleted property to remove from logs.
+   *
+   * @param {string} remoteId - Remote ID of the event to remove.
+   */
+  removeMessage(remoteId) {
+    this.notifyObservers(null, "remove-text", remoteId);
+  },
+
+  get account() {
+    return this._account.imAccount;
+  },
+  get name() {
+    return this._name;
+  },
+  get normalizedName() {
+    return this._account.normalize(this.name);
+  },
+  get title() {
+    return this.name;
+  },
+  get startDate() {
+    return this._date;
+  },
+  _convIconFilename: "",
+  get convIconFilename() {
+    return this._convIconFilename;
+  },
+  set convIconFilename(aNewFilename) {
+    this._convIconFilename = aNewFilename;
+    this.notifyObservers(this, "update-conv-icon");
+  },
+
+  get encryptionState() {
+    return Ci.prplIConversation.ENCRYPTION_NOT_SUPPORTED;
+  },
+  initializeEncryption() {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+};
+
+export var GenericConvIMPrototype = {
+  __proto__: GenericConversationPrototype,
+  _interfaces: [Ci.prplIConversation, Ci.prplIConvIM],
+  classDescription: "generic ConvIM object",
+
+  updateTyping(aState, aName) {
+    if (aState == this.typingState) {
+      return;
+    }
+
+    if (aState == Ci.prplIConvIM.NOT_TYPING) {
+      delete this.typingState;
+    } else {
+      this.typingState = aState;
+    }
+    this.notifyObservers(null, "update-typing", aName);
+  },
+
+  get isChat() {
+    return false;
+  },
+  buddy: null,
+  typingState: Ci.prplIConvIM.NOT_TYPING,
+  get convIconFilename() {
+    // By default, pass through information from the buddy for IM conversations
+    // that don't have their own icon.
+    const convIconFilename = this._convIconFilename;
+    if (convIconFilename) {
+      return convIconFilename;
+    }
+    return this.buddy?.buddyIconFilename;
+  },
+};
+
+export var GenericConvChatPrototype = {
+  __proto__: GenericConversationPrototype,
+  _interfaces: [Ci.prplIConversation, Ci.prplIConvChat],
+  classDescription: "generic ConvChat object",
+
+  _init(aAccount, aName, aNick) {
+    // _participants holds prplIConvChatBuddy objects.
+    this._participants = new Map();
+    this.nick = aNick;
+    GenericConversationPrototype._init.call(this, aAccount, aName);
+  },
+
+  get isChat() {
+    return true;
+  },
+
+  // Stores the prplIChatRoomFieldValues required to join this channel
+  // to enable later reconnections. If null, the MUC will not be reconnected
+  // automatically after disconnections.
+  chatRoomFields: null,
+
+  _topic: "",
+  _topicSetter: null,
+  get topic() {
+    return this._topic;
+  },
+  get topicSettable() {
+    return false;
+  },
+  get topicSetter() {
+    return this._topicSetter;
+  },
+  /**
+   * Set the topic of a conversation.
+   *
+   * @param {string} aTopic - The new topic. If an update message is sent to
+   *   the conversation, this will be HTML escaped before being sent.
+   * @param {string} aTopicSetter - The user who last modified the topic.
+   * @param {string} aQuiet - If false, a message notifying about the topic
+   *   change will be sent to the conversation.
+   */
+  setTopic(aTopic, aTopicSetter, aQuiet) {
+    // Only change the topic if the topic and/or topic setter has changed.
+    if (
+      this._topic == aTopic &&
+      (!this._topicSetter || this._topicSetter == aTopicSetter)
+    ) {
+      return;
+    }
+
+    this._topic = aTopic;
+    this._topicSetter = aTopicSetter;
+
+    this.notifyObservers(null, "chat-update-topic");
+
+    if (aQuiet) {
+      return;
+    }
+
+    // Send the topic as a message.
+    let message;
+    if (aTopicSetter) {
+      if (aTopic) {
+        message = lazy._("topicChanged", aTopicSetter, lazy.TXTToHTML(aTopic));
+      } else {
+        message = lazy._("topicCleared", aTopicSetter);
+      }
+    } else {
+      aTopicSetter = null;
+      if (aTopic) {
+        message = lazy._("topicSet", this.name, lazy.TXTToHTML(aTopic));
+      } else {
+        message = lazy._("topicNotSet", this.name);
+      }
+    }
+    this.writeMessage(aTopicSetter, message, { system: true });
+  },
+
+  get nick() {
+    return this._nick;
+  },
+  set nick(aNick) {
+    this._nick = aNick;
+    let escapedNick = this._nick.replace(/[[\]{}()*+?.\\^$|]/g, "\\$&");
+    this._pingRegexp = new RegExp("(?:^|\\W)" + escapedNick + "(?:\\W|$)", "i");
+  },
+
+  _left: false,
+  get left() {
+    return this._left;
+  },
+  set left(aLeft) {
+    if (aLeft == this._left) {
+      return;
+    }
+    this._left = aLeft;
+    this.notifyObservers(null, "update-conv-chatleft");
+  },
+
+  _joining: false,
+  get joining() {
+    return this._joining;
+  },
+  set joining(aJoining) {
+    if (aJoining == this._joining) {
+      return;
+    }
+    this._joining = aJoining;
+    this.notifyObservers(null, "update-conv-chatjoining");
+  },
+
+  getParticipant(aName) {
+    return this._participants.has(aName) ? this._participants.get(aName) : null;
+  },
+  getParticipants() {
+    // Convert the values of the Map into an array.
+    return Array.from(this._participants.values());
+  },
+  getNormalizedChatBuddyName: aChatBuddyName => aChatBuddyName,
+
+  // Updates the nick of a participant in conversation to a new one.
+  updateNick(aOldNick, aNewNick, isOwnNick) {
+    let message;
+    let isParticipant = this._participants.has(aOldNick);
+    if (isOwnNick) {
+      // If this is the user's nick, change it.
+      this.nick = aNewNick;
+      message = lazy._("nickSet.you", aNewNick);
+
+      // If the account was disconnected, it's OK the user is not a participant.
+      if (!isParticipant) {
+        return;
+      }
+    } else if (!isParticipant) {
+      this.ERROR(
+        "Trying to rename nick that doesn't exist! " +
+          aOldNick +
+          " to " +
+          aNewNick
+      );
+      return;
+    } else {
+      message = lazy._("nickSet", aOldNick, aNewNick);
+    }
+
+    // Get the original participant and then remove it.
+    let participant = this._participants.get(aOldNick);
+    this._participants.delete(aOldNick);
+
+    // Update the nickname and add it under the new nick.
+    participant.name = aNewNick;
+    this._participants.set(aNewNick, participant);
+
+    this.notifyObservers(participant, "chat-buddy-update", aOldNick);
+    this.writeMessage(aOldNick, message, { system: true });
+  },
+
+  // Removes a participant from conversation.
+  removeParticipant(aNick) {
+    if (!this._participants.has(aNick)) {
+      return;
+    }
+
+    let stringNickname = Cc["@mozilla.org/supports-string;1"].createInstance(
+      Ci.nsISupportsString
+    );
+    stringNickname.data = aNick;
+    this.notifyObservers(
+      new nsSimpleEnumerator([stringNickname]),
+      "chat-buddy-remove"
+    );
+    this._participants.delete(aNick);
+  },
+
+  // Removes all participant in conversation.
+  removeAllParticipants() {
+    let stringNicknames = [];
+    this._participants.forEach(function (aParticipant) {
+      let stringNickname = Cc["@mozilla.org/supports-string;1"].createInstance(
+        Ci.nsISupportsString
+      );
+      stringNickname.data = aParticipant.name;
+      stringNicknames.push(stringNickname);
+    });
+    this.notifyObservers(
+      new nsSimpleEnumerator(stringNicknames),
+      "chat-buddy-remove"
+    );
+    this._participants.clear();
+  },
+
+  createMessage(who, text, properties) {
+    properties.containsNick =
+      "incoming" in properties && this._pingRegexp.test(text);
+    return GenericConversationPrototype.createMessage.apply(this, arguments);
+  },
+};
+
+export var GenericConvChatBuddyPrototype = {
+  __proto__: ClassInfo("prplIConvChatBuddy", "generic ConvChatBuddy object"),
+
+  _name: "",
+  get name() {
+    return this._name;
+  },
+  set name(aName) {
+    this._name = aName;
+  },
+  alias: "",
+  buddy: false,
+  buddyIconFilename: "",
+
+  voiced: false,
+  moderator: false,
+  admin: false,
+  founder: false,
+  typing: false,
+
+  /**
+   * Method called to start verification of the buddy. Same signature as
+   * _startVerification of GenericSessionPrototype. If the property is not a
+   * function, |canVerifyIdentity| is false.
+   *
+   * @type {() => {challenge: string, challengeDescription: string?, handleResult: (boolean) => void, cancel: () => void, cancelPromise: Promise}?}
+   */
+  _startVerification: null,
+  get canVerifyIdentity() {
+    return typeof this._startVerification === "function";
+  },
+  _identityVerified: false,
+  get identityVerified() {
+    return this.canVerifyIdentity && this._identityVerified;
+  },
+  verifyIdentity() {
+    if (!this.canVerifyIdentity) {
+      throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+    }
+    if (this.identityVerified) {
+      return Promise.resolve();
+    }
+    return this._startVerification().then(
+      ({
+        challenge,
+        challengeDescription,
+        handleResult,
+        cancel,
+        cancelPromise,
+      }) => {
+        const verifier = new SessionVerification(
+          challenge,
+          this.name,
+          challengeDescription
+        );
+        verifier.completePromise.then(
+          result => handleResult(result),
+          () => cancel()
+        );
+        cancelPromise.then(() => verifier.cancel());
+        return verifier;
+      }
+    );
+  },
+};
+
+export function TooltipInfo(aLabel, aValue, aType = Ci.prplITooltipInfo.pair) {
+  this.type = aType;
+  if (aType == Ci.prplITooltipInfo.status) {
+    this.label = aLabel.toString();
+    this.value = aValue || "";
+  } else if (aType == Ci.prplITooltipInfo.icon) {
+    this.value = aValue;
+  } else if (
+    aLabel === undefined ||
+    aType == Ci.prplITooltipInfo.sectionBreak
+  ) {
+    this.type = Ci.prplITooltipInfo.sectionBreak;
+  } else {
+    this.label = aLabel;
+    if (aValue === undefined) {
+      this.type = Ci.prplITooltipInfo.sectionHeader;
+    } else {
+      this.value = aValue;
+    }
+  }
+}
+
+TooltipInfo.prototype = ClassInfo("prplITooltipInfo", "generic tooltip info");
+
+/* aOption is an object containing:
+ *  - label: localized text to display (recommended: use a getter with _)
+ *  - default: the default value for this option. The type of the
+ *      option will be determined based on the type of the default value.
+ *      If the default value is a string, the option will be of type
+ *      list if listValues has been provided. In that case the default
+ *      value should be one of the listed values.
+ *  - [optional] listValues: only if this option can only take a list of
+ *      predefined values. This is an object of the form:
+ *        {value1: localizedLabel, value2: ...}.
+ *  - [optional] masked: boolean, if true the UI shouldn't display the value.
+ *      This could typically be used for password field.
+ *      Warning: The UI currently doesn't support this.
+ */
+function purplePref(aName, aOption) {
+  this.name = aName; // Preference name
+  this.label = aOption.label; // Text to display
+
+  if (aOption.default === undefined || aOption.default === null) {
+    throw new Error(
+      "A default value for the option is required to determine its type."
+    );
+  }
+  this._defaultValue = aOption.default;
+
+  const kTypes = { boolean: "Bool", string: "String", number: "Int" };
+  let type = kTypes[typeof aOption.default];
+  if (!type) {
+    throw new Error("Invalid option type");
+  }
+
+  if (type == "String" && "listValues" in aOption) {
+    type = "List";
+    this._listValues = aOption.listValues;
+  }
+  this.type = Ci.prplIPref["type" + type];
+
+  if ("masked" in aOption && aOption.masked) {
+    this.masked = true;
+  }
+}
+purplePref.prototype = {
+  __proto__: ClassInfo("prplIPref", "generic account option preference"),
+
+  masked: false,
+
+  // Default value
+  getBool() {
+    return this._defaultValue;
+  },
+  getInt() {
+    return this._defaultValue;
+  },
+  getString() {
+    return this._defaultValue;
+  },
+  getList() {
+    // Convert a JavaScript object map {"value 1": "label 1", ...}
+    let keys = Object.keys(this._listValues);
+    return keys.map(key => new purpleKeyValuePair(this._listValues[key], key));
+  },
+  getListDefault() {
+    return this._defaultValue;
+  },
+};
+
+function purpleKeyValuePair(aName, aValue) {
+  this.name = aName;
+  this.value = aValue;
+}
+purpleKeyValuePair.prototype = ClassInfo(
+  "prplIKeyValuePair",
+  "generic Key Value Pair"
+);
+
+function UsernameSplit(aValues) {
+  this._values = aValues;
+}
+UsernameSplit.prototype = {
+  __proto__: ClassInfo("prplIUsernameSplit", "username split object"),
+
+  get label() {
+    return this._values.label;
+  },
+  get separator() {
+    return this._values.separator;
+  },
+  get defaultValue() {
+    return this._values.defaultValue;
+  },
+};
+
+function ChatRoomField(aIdentifier, aField) {
+  this.identifier = aIdentifier;
+  this.label = aField.label;
+  this.required = !!aField.required;
+
+  let type = "TEXT";
+  if (typeof aField.default == "number") {
+    type = "INT";
+    this.min = aField.min;
+    this.max = aField.max;
+  } else if (aField.isPassword) {
+    type = "PASSWORD";
+  }
+  this.type = Ci.prplIChatRoomField["TYPE_" + type];
+}
+ChatRoomField.prototype = ClassInfo(
+  "prplIChatRoomField",
+  "ChatRoomField object"
+);
+
+function ChatRoomFieldValues(aMap) {
+  this.values = aMap;
+}
+ChatRoomFieldValues.prototype = {
+  __proto__: ClassInfo("prplIChatRoomFieldValues", "ChatRoomFieldValues"),
+
+  getValue(aIdentifier) {
+    return this.values.hasOwnProperty(aIdentifier)
+      ? this.values[aIdentifier]
+      : null;
+  },
+  setValue(aIdentifier, aValue) {
+    this.values[aIdentifier] = aValue;
+  },
+};
+
+// the name getter and the getAccount method need to be implemented by
+// protocol plugins.
+export var GenericProtocolPrototype = {
+  __proto__: ClassInfo("prplIProtocol", "Generic protocol object"),
+
+  init(aId) {
+    if (aId != this.id) {
+      throw new Error(
+        "Creating an instance of " +
+          aId +
+          " but this object implements " +
+          this.id
+      );
+    }
+  },
+  get id() {
+    return "prpl-" + this.normalizedName;
+  },
+  get iconBaseURI() {
+    return "chrome://chat/skin/prpl-generic/";
+  },
+
+  getAccount(aImAccount) {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+
+  _getOptionDefault(aName) {
+    if (this.options && this.options.hasOwnProperty(aName)) {
+      return this.options[aName].default;
+    }
+    throw new Error(aName + " has no default value in " + this.id + ".");
+  },
+  getOptions() {
+    if (!this.options) {
+      return [];
+    }
+
+    let purplePrefs = [];
+    for (let [name, option] of Object.entries(this.options)) {
+      purplePrefs.push(new purplePref(name, option));
+    }
+    return purplePrefs;
+  },
+  usernamePrefix: "",
+  getUsernameSplit() {
+    if (!this.usernameSplits || !this.usernameSplits.length) {
+      return [];
+    }
+    return this.usernameSplits.map(split => new UsernameSplit(split));
+  },
+
+  /**
+   * Protocol agnostic implementation that splits the username by the pattern
+   * defined with |usernamePrefix| and |usernameSplits| on the protocol.
+   * Prefers the first occurrence of a separator.
+   *
+   * @param {string} aName - Username to split.
+   * @returns {string[]} Parts of the username or empty array if the username
+   *   doesn't match the splitting format.
+   */
+  splitUsername(aName) {
+    let remainingName = aName;
+    if (this.usernamePrefix) {
+      if (!remainingName.startsWith(this.usernamePrefix)) {
+        return [];
+      }
+      remainingName = remainingName.slice(this.usernamePrefix.length);
+    }
+    if (!this.usernameSplits || !this.usernameSplits.length) {
+      return [remainingName];
+    }
+    const parts = [];
+    for (const split of this.usernameSplits) {
+      if (!remainingName.includes(split.separator)) {
+        return [];
+      }
+      const separatorIndex = remainingName.indexOf(split.separator);
+      parts.push(remainingName.slice(0, separatorIndex));
+      remainingName = remainingName.slice(
+        separatorIndex + split.separator.length
+      );
+    }
+    parts.push(remainingName);
+    return parts;
+  },
+
+  registerCommands() {
+    if (!this.commands) {
+      return;
+    }
+
+    this.commands.forEach(function (command) {
+      if (!command.hasOwnProperty("name") || !command.hasOwnProperty("run")) {
+        throw new Error("Every command must have a name and a run function.");
+      }
+      if (!("QueryInterface" in command)) {
+        command.QueryInterface = ChromeUtils.generateQI(["imICommand"]);
+      }
+      if (!command.hasOwnProperty("usageContext")) {
+        command.usageContext = Ci.imICommand.CMD_CONTEXT_ALL;
+      }
+      if (!command.hasOwnProperty("priority")) {
+        command.priority = Ci.imICommand.CMD_PRIORITY_PRPL;
+      }
+      IMServices.cmd.registerCommand(command, this.id);
+    }, this);
+  },
+
+  // NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED errors are too noisy
+  get usernameEmptyText() {
+    return "";
+  },
+  accountExists: () => false, // FIXME
+
+  get chatHasTopic() {
+    return false;
+  },
+  get noPassword() {
+    return false;
+  },
+  get passwordOptional() {
+    return false;
+  },
+  get slashCommandsNative() {
+    return false;
+  },
+  get canEncrypt() {
+    return false;
+  },
+
+  get classDescription() {
+    return this.name + " Protocol";
+  },
+  get contractID() {
+    return "@mozilla.org/chat/" + this.normalizedName + ";1";
+  },
+};
+
+/**
+ * Text challenge session verification flow. Starts the UI flow.
+ *
+ * @param {string} challenge - String the challenge should display.
+ * @param {string} subject - Human readable identifier of the other side of the
+ *  challenge.
+ * @param {string} [challengeDescription] - Description of the challenge
+ *  contents.
+ */
+function SessionVerification(challenge, subject, challengeDescription) {
+  this._challenge = challenge;
+  this._subject = subject;
+  if (challengeDescription) {
+    this._description = challengeDescription;
+  }
+  this._responsePromise = new Promise((resolve, reject) => {
+    this._submit = resolve;
+    this._cancel = reject;
+  });
+}
+SessionVerification.prototype = {
+  __proto__: ClassInfo(
+    "imISessionVerification",
+    "generic session verification object"
+  ),
+  _challengeType: Ci.imISessionVerification.CHALLENGE_TEXT,
+  _challenge: "",
+  _description: "",
+  _responsePromise: null,
+  _submit: null,
+  _cancel: null,
+  _cancelled: false,
+  get challengeType() {
+    return this._challengeType;
+  },
+  get challenge() {
+    return this._challenge;
+  },
+  get challengeDescription() {
+    return this._description;
+  },
+  get subject() {
+    return this._subject;
+  },
+  get completePromise() {
+    return this._responsePromise;
+  },
+  submitResponse(challengeMatches) {
+    this._submit(challengeMatches);
+  },
+  cancel() {
+    if (this._cancelled) {
+      return;
+    }
+    this._cancelled = true;
+    this._cancel();
+  },
+};
+
+export var GenericSessionPrototype = {
+  __proto__: ClassInfo("prplISession", "generic session object"),
+  /**
+   * Initialize the session.
+   *
+   * @param {prplIAccount} account - Account the session is related to.
+   * @param {string} id - ID of the session.
+   * @param {boolean} [trusted=false] - If the session is trusted.
+   * @param {boolean} [currentSession=false] - If the session represents the.
+   *  session we're connected as.
+   */
+  _init(account, id, trusted = false, currentSession = false) {
+    this._account = account;
+    this._id = id;
+    this._trusted = trusted;
+    this._currentSession = currentSession;
+  },
+  _account: null,
+  _id: "",
+  _trusted: false,
+  _currentSession: false,
+  get id() {
+    return this._id;
+  },
+  get trusted() {
+    return this._trusted;
+  },
+  set trusted(newTrust) {
+    this._trusted = newTrust;
+    this._account.reportSessionsChanged();
+  },
+  get currentSession() {
+    return this._currentSession;
+  },
+  /**
+   * Handle the start of the session verification process. The protocol is
+   * expected to update the trusted property on the session if it becomes
+   * trusted after verification.
+   *
+   * @returns {Promise<{challenge: string, challengeDescription: string?, handleResult: (boolean) => void, cancel: () => void, cancelPromise: Promise<void>}>}
+   *  Promise resolves to an object holding the challenge string, as well as a
+   *  callback that handles the result of the verification flow. The cancel
+   *  callback is called when the verification is cancelled and the cancelPromise
+   *  is used for the protocol to report when the other side cancels.
+   *  The cancel callback will be called when the cancel promise resolves.
+   */
+  _startVerification() {
+    return Promise.reject(
+      Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED)
+    );
+  },
+  verify() {
+    if (this.trusted) {
+      return Promise.resolve();
+    }
+    return this._startVerification().then(
+      ({
+        challenge,
+        challengeDescription,
+        handleResult,
+        cancel,
+        cancelPromise,
+      }) => {
+        const verifier = new SessionVerification(
+          challenge,
+          this.id,
+          challengeDescription
+        );
+        verifier.completePromise.then(
+          result => handleResult(result),
+          () => cancel()
+        );
+        cancelPromise.then(() => verifier.cancel());
+        return verifier;
+      }
+    );
+  },
+};
diff --git a/comm/chat/modules/moz.build b/comm/chat/modules/moz.build
new file mode 100644
index 0000000000..b3ae019739
--- /dev/null
+++ b/comm/chat/modules/moz.build
@@ -0,0 +1,25 @@
+# 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/.
+
+XPCSHELL_TESTS_MANIFESTS += ["test/xpcshell.ini"]
+
+EXTRA_JS_MODULES += [
+    "CLib.sys.mjs",
+    "imContentSink.sys.mjs",
+    "IMServices.sys.mjs",
+    "imSmileys.sys.mjs",
+    "imStatusUtils.sys.mjs",
+    "imTextboxUtils.sys.mjs",
+    "imThemes.sys.mjs",
+    "imXPCOMUtils.sys.mjs",
+    "InteractiveBrowser.sys.mjs",
+    "jsProtoHelper.sys.mjs",
+    "NormalizedMap.sys.mjs",
+    "OTR.sys.mjs",
+    "OTRLib.sys.mjs",
+    "OTRUI.sys.mjs",
+    "socket.sys.mjs",
+    "ToLocaleFormat.sys.mjs",
+]
diff --git a/comm/chat/modules/socket.sys.mjs b/comm/chat/modules/socket.sys.mjs
new file mode 100644
index 0000000000..9253e0e96b
--- /dev/null
+++ b/comm/chat/modules/socket.sys.mjs
@@ -0,0 +1,644 @@
+/* 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/. */
+
+/*
+ * Combines a lot of the Mozilla networking interfaces into a sane interface for
+ * simple(r) handling of a low-level socket which sends text content.
+ *
+ * This implements nsIStreamListener, nsIRequestObserver, nsITransportEventSink
+ * and nsIProtocolProxyCallback.
+ *
+ * This uses nsIRoutedSocketTransportService, nsIServerSocket, nsIThreadManager,
+ * nsIScriptableInputStream, nsIInputStreamPump, nsIProxyService, nsIProxyInfo.
+ *
+ * High-level methods:
+ *   connect(<originHost>, <originPort>[, ("starttls" | "ssl" | "udp")
+ *           [, <proxy>[, <host>, <port>]]])
+ *   disconnect()
+ *   sendData(String <data>[, <logged data>])
+ *   sendString(String <data>[, <encoding>[, <logged data>]])
+ *   startTLS()
+ *   resetPingTimer()
+ *   cancelDisconnectTimer()
+ *
+ * High-level properties:
+ *   delimiter
+ *   inputSegmentSize
+ *   outputSegmentSize
+ *   proxyFlags
+ *   connectTimeout (default is no timeout)
+ *   readWriteTimeout (default is no timeout)
+ *   disconnected
+ *   securityInfo
+ *
+ * Users should "subclass" this object, i.e. set their .__proto__ to be it. And
+ * then implement:
+ *   onConnection()
+ *   onConnectionHeard()
+ *   onConnectionTimedOut()
+ *   onConnectionReset()
+ *   onConnectionSecurityError(unsigned long aTLSError, optional AString aNSSErrorMessage)
+ *   onConnectionClosed()
+ *   onDataReceived(String <data>)
+ *   onTransportStatus(nsISocketTransport <transport>, nsresult <status>,
+ *                     unsigned long <progress>, unsigned long <progress max>)
+ *   sendPing()
+ *   LOG(<message>)
+ *   DEBUG(<message>)
+ *
+ * Optional features:
+ *   The ping functionality: Included in the socket object is a higher level
+ *   "ping" messaging system, which is commonly used in instant messaging
+ *   protocols. The ping functionality works by calling a user defined method,
+ *   sendPing(), if resetPingTimer() is not called after two minutes. If no
+ *   ping response is received after 30 seconds, the socket will disconnect.
+ *   Thus, a socket using this functionality should:
+ *     1. Implement sendPing() to send an appropriate ping message for the
+ *        protocol.
+ *     2. Call resetPingTimer() to start the ping messages.
+ *     3. Call resetPingTimer() each time a message is received (i.e. the
+ *        socket is known to still be alive).
+ *     4. Call cancelDisconnectTimer() when a ping response is received.
+ */
+
+/*
+ * To Do:
+ *   Add a message queue to keep from flooding a server (just an array, just
+ *     keep shifting the first element off and calling as setTimeout for the
+ *     desired flood time?).
+ */
+
+import { executeSoon } from "resource:///modules/imXPCOMUtils.sys.mjs";
+import {
+  clearTimeout,
+  requestIdleCallback,
+  setTimeout,
+} from "resource://gre/modules/Timer.sys.mjs";
+
+// Network errors see: xpcom/base/nsError.h
+var NS_ERROR_MODULE_NETWORK = 2152398848;
+var NS_ERROR_NET_TIMEOUT = NS_ERROR_MODULE_NETWORK + 14;
+var NS_ERROR_NET_RESET = NS_ERROR_MODULE_NETWORK + 20;
+var NS_ERROR_UNKNOWN_HOST = NS_ERROR_MODULE_NETWORK + 30;
+
+var ScriptableInputStream = Components.Constructor(
+  "@mozilla.org/scriptableinputstream;1",
+  "nsIScriptableInputStream",
+  "init"
+);
+var InputStreamPump = Components.Constructor(
+  "@mozilla.org/network/input-stream-pump;1",
+  "nsIInputStreamPump",
+  "init"
+);
+var ScriptableUnicodeConverter = Components.Constructor(
+  "@mozilla.org/intl/scriptableunicodeconverter",
+  "nsIScriptableUnicodeConverter"
+);
+
+/**
+ * @implements {nsIStreamListener}
+ * @implements {nsIRequestObserver}
+ * @implements {nsITransportEventSink}
+ * @implements {nsIProtocolProxyCallback}
+ */
+export var Socket = {
+  // Set this for non-binary mode to automatically parse the stream into chunks
+  // separated by delimiter.
+  delimiter: "",
+
+  // Set this for the segment size of outgoing binary streams.
+  outputSegmentSize: 0,
+
+  // Flags used by nsIProxyService when resolving a proxy.
+  proxyFlags: Ci.nsIProtocolProxyService.RESOLVE_PREFER_SOCKS_PROXY,
+
+  // Time (in seconds) for nsISocketTransport to continue trying before
+  // reporting a failure, 0 is forever.
+  connectTimeout: 0,
+  readWriteTimeout: 0,
+
+  // A nsITransportSecurityInfo instance giving details about the certificate error.
+  securityInfo: null,
+
+  /*
+   *****************************************************************************
+   ******************************* Public methods ******************************
+   *****************************************************************************
+   */
+  // Synchronously open a connection.
+  // It connects to aHost and aPort, but uses aOriginHost and aOriginPort for
+  // checking the certificate for them (see nsIRoutedSocketTransportService
+  // in nsISocketTransportService.idl).
+  connect(
+    aOriginHost,
+    aOriginPort,
+    aSecurity,
+    aProxy,
+    aHost = aOriginHost,
+    aPort = aOriginPort
+  ) {
+    if (Services.io.offline) {
+      throw Components.Exception("Offline, can't connect", Cr.NS_ERROR_FAILURE);
+    }
+
+    // This won't work for Linux due to bug 758848.
+    Services.obs.addObserver(this, "wake_notification");
+
+    this.LOG("Connecting to: " + aHost + ":" + aPort);
+    this.originHost = aOriginHost;
+    this.originPort = aOriginPort;
+    this.host = aHost;
+    this.port = aPort;
+    this.disconnected = false;
+
+    this._pendingData = [];
+    delete this._stopRequestStatus;
+
+    // Array of security options
+    this.security = aSecurity || [];
+
+    // Choose a proxy, use the given one, otherwise get one from the proxy
+    // service
+    if (aProxy) {
+      this._createTransport(aProxy);
+    } else {
+      try {
+        // Attempt to get a default proxy from the proxy service.
+        let proxyService = Cc[
+          "@mozilla.org/network/protocol-proxy-service;1"
+        ].getService(Ci.nsIProtocolProxyService);
+
+        // Add a URI scheme since, by default, some protocols (i.e. IRC) don't
+        // have a URI scheme before the host.
+        let uri = Services.io.newURI("http://" + this.host);
+        // This will return null when the result is known immediately and
+        // the callback will just be dispatched to the current thread.
+        this._proxyCancel = proxyService.asyncResolve(
+          uri,
+          this.proxyFlags,
+          this
+        );
+      } catch (e) {
+        console.error(e);
+        // We had some error getting the proxy service, just don't use one.
+        this._createTransport(null);
+      }
+    }
+  },
+
+  // Disconnect all open streams.
+  disconnect() {
+    this.LOG("Disconnect");
+
+    // Don't handle any remaining unhandled data.
+    this._pendingData = [];
+
+    // Close all input and output streams.
+    if ("_inputStream" in this) {
+      this._inputStream.close();
+      delete this._inputStream;
+    }
+    if ("_outputStream" in this) {
+      this._outputStream.close();
+      delete this._outputStream;
+    }
+    if ("transport" in this) {
+      this.transport.close(Cr.NS_OK);
+      delete this.transport;
+    }
+
+    if ("_proxyCancel" in this) {
+      if (this._proxyCancel) {
+        // Has to give a failure code.
+        this._proxyCancel.cancel(Cr.NS_ERROR_ABORT);
+      }
+      delete this._proxyCancel;
+    }
+
+    if (this._pingTimer) {
+      clearTimeout(this._pingTimer);
+      delete this._pingTimer;
+      delete this._resetPingTimerPending;
+    }
+    this.cancelDisconnectTimer();
+
+    delete this._lastAliveTime;
+    Services.obs.removeObserver(this, "wake_notification");
+
+    this.disconnected = true;
+  },
+
+  // Send data on the output stream. Provide aLoggedData to log something
+  // different than what is actually sent.
+  sendData(/* string */ aData, aLoggedData = aData) {
+    this.LOG("Sending:\n" + aLoggedData);
+
+    try {
+      this._outputStream.write(aData, aData.length);
+    } catch (e) {
+      console.error(e);
+    }
+  },
+
+  // Send a string to the output stream after converting the encoding. Provide
+  // aLoggedData to log something different than what is actually sent.
+  sendString(aString, aEncoding = "UTF-8", aLoggedData = aString) {
+    this.LOG("Sending:\n" + aLoggedData);
+
+    let converter = new ScriptableUnicodeConverter();
+    converter.charset = aEncoding;
+    try {
+      let stream = converter.convertToInputStream(aString);
+      this._outputStream.writeFrom(stream, stream.available());
+    } catch (e) {
+      console.error(e);
+    }
+  },
+
+  disconnected: true,
+
+  startTLS() {
+    this.transport.tlsSocketControl
+      .QueryInterface(Ci.nsITLSSocketControl)
+      .StartTLS();
+  },
+
+  // If using the ping functionality, this should be called whenever a message is
+  // received (e.g. when it is known the socket is still open). Calling this for
+  // the first time enables the ping functionality.
+  resetPingTimer() {
+    // Clearing and setting timeouts is expensive, so we do it at most
+    // once per eventloop spin cycle.
+    if (this._resetPingTimerPending) {
+      return;
+    }
+    this._resetPingTimerPending = true;
+    executeSoon(this._delayedResetPingTimer.bind(this));
+  },
+  kTimeBeforePing: 120000, // 2 min
+  kTimeAfterPingBeforeDisconnect: 30000, // 30 s
+  _delayedResetPingTimer() {
+    if (!this._resetPingTimerPending) {
+      return;
+    }
+    delete this._resetPingTimerPending;
+    if (this._pingTimer) {
+      clearTimeout(this._pingTimer);
+    }
+    // Send a ping every 2 minutes if there's no traffic on the socket.
+    this._pingTimer = setTimeout(
+      this._sendPing.bind(this),
+      this.kTimeBeforePing
+    );
+  },
+
+  // If using the ping functionality, this should be called when a ping receives
+  // a response.
+  cancelDisconnectTimer() {
+    if (!this._disconnectTimer) {
+      return;
+    }
+    clearTimeout(this._disconnectTimer);
+    delete this._disconnectTimer;
+  },
+
+  // Plenty of time may have elapsed if the computer wakes from sleep, so check
+  // if we should reconnect immediately.
+  _lastAliveTime: null,
+  observe(aSubject, aTopic, aData) {
+    if (aTopic != "wake_notification") {
+      return;
+    }
+    let elapsedTime = Date.now() - this._lastAliveTime;
+    // If there never was any activity before we went to sleep,
+    // or if we've been waiting for a ping response for over 30s,
+    // or if the last activity on the socket is longer ago than we usually
+    //   allow before we timeout,
+    // declare the connection timed out immediately.
+    if (
+      !this._lastAliveTime ||
+      (this._disconnectTimer &&
+        elapsedTime > this.kTimeAfterPingBeforeDisconnect) ||
+      elapsedTime > this.kTimeBeforePing + this.kTimeAfterPingBeforeDisconnect
+    ) {
+      this.onConnectionTimedOut();
+    } else if (this._pingTimer) {
+      // If there was a ping timer running when the computer went to sleep,
+      // ping immediately to discover if we are still connected.
+      clearTimeout(this._pingTimer);
+      this._sendPing();
+    }
+  },
+
+  /*
+   *****************************************************************************
+   ***************************** Interface methods *****************************
+   *****************************************************************************
+   */
+  /*
+   * nsIProtocolProxyCallback methods
+   */
+  onProxyAvailable(aRequest, aURI, aProxyInfo, aStatus) {
+    if (!("_proxyCancel" in this)) {
+      this.LOG("onProxyAvailable called, but disconnect() was called before.");
+      return;
+    }
+
+    if (aProxyInfo) {
+      if (aProxyInfo.type == "http") {
+        this.LOG("ignoring http proxy");
+        aProxyInfo = null;
+      } else {
+        this.LOG(
+          "using " +
+            aProxyInfo.type +
+            " proxy: " +
+            aProxyInfo.host +
+            ":" +
+            aProxyInfo.port
+        );
+      }
+    }
+    this._createTransport(aProxyInfo);
+    delete this._proxyCancel;
+  },
+
+  /*
+   * nsIStreamListener methods
+   */
+  // onDataAvailable, called by Mozilla's networking code.
+  // Buffers the data, and parses it into discrete messages.
+  onDataAvailable(aRequest, aInputStream, aOffset, aCount) {
+    if (this.disconnected) {
+      return;
+    }
+    this._lastAliveTime = Date.now();
+
+    if (this.delimiter) {
+      // Load the data from the stream.
+      this._incomingDataBuffer += this._scriptableInputStream.read(aCount);
+      let data = this._incomingDataBuffer.split(this.delimiter);
+
+      // Store the (possibly) incomplete part.
+      this._incomingDataBuffer = data.pop();
+      if (!data.length) {
+        return;
+      }
+
+      // Add the strings to the queue.
+      this._pendingData = this._pendingData.concat(data);
+    } else {
+      // Add the whole string to the queue.
+      this._pendingData.push(this._scriptableInputStream.read(aCount));
+    }
+    this._activateQueue();
+  },
+
+  _pendingData: [],
+  _handlingQueue: false,
+  _activateQueue() {
+    if (this._handlingQueue) {
+      return;
+    }
+    this._handlingQueue = requestIdleCallback(this._handleQueue.bind(this));
+  },
+  // Asynchronously send each string to the handle data function.
+  async _handleQueue(timing) {
+    while (this._pendingData.length) {
+      this.onDataReceived(this._pendingData.shift());
+      // One pendingData entry generally takes less than 1ms to handle.
+      if (timing.timeRemaining() < 1) {
+        break;
+      }
+    }
+    if (this._pendingData.length) {
+      this._handlingQueue = requestIdleCallback(this._handleQueue.bind(this));
+      return;
+    }
+    delete this._handlingQueue;
+    // If there was a stop request, handle it.
+    if ("_stopRequestStatus" in this) {
+      await this._handleStopRequest(this._stopRequestStatus);
+    }
+  },
+
+  /*
+   * nsIRequestObserver methods
+   */
+  // Signifies the beginning of an async request
+  onStartRequest(aRequest) {
+    if (this.disconnected) {
+      // Ignore this if we're already disconnected.
+      return;
+    }
+    this.DEBUG("onStartRequest");
+  },
+  // Called to signify the end of an asynchronous request.
+  onStopRequest(aRequest, aStatus) {
+    if (this.disconnected) {
+      // We're already disconnected, so nothing left to do here.
+      return;
+    }
+
+    this.DEBUG("onStopRequest (" + aStatus + ")");
+    this._stopRequestStatus = aStatus;
+    // The stop request will be handled when the queue is next empty.
+    this._activateQueue();
+  },
+  // Close the connection after receiving a stop request.
+  async _handleStopRequest(aStatus) {
+    if (this.disconnected) {
+      return;
+    }
+    this.disconnected = true;
+    // If the host cannot be resolved, reset the connection to attempt to
+    // reconnect.
+    if (aStatus == NS_ERROR_NET_RESET || aStatus == NS_ERROR_UNKNOWN_HOST) {
+      this.onConnectionReset();
+    } else if (aStatus == NS_ERROR_NET_TIMEOUT) {
+      this.onConnectionTimedOut();
+    } else if (!Components.isSuccessCode(aStatus)) {
+      let nssErrorsService = Cc["@mozilla.org/nss_errors_service;1"].getService(
+        Ci.nsINSSErrorsService
+      );
+      this.securityInfo =
+        await this.transport.tlsSocketControl?.asyncGetSecurityInfo();
+      this.onConnectionSecurityError(
+        aStatus,
+        nssErrorsService.getErrorMessage(aStatus)
+      );
+    }
+    this.onConnectionClosed();
+  },
+
+  /*
+   * nsITransportEventSink methods
+   */
+  onTransportStatus(aTransport, aStatus, aProgress, aProgressmax) {
+    // Don't send status change notifications after the socket has been closed.
+    // The event sink can't be removed after opening the transport, so we can't
+    // do better than adding a null check here.
+    if (!this.transport) {
+      return;
+    }
+
+    const nsITransportEventSinkStatus = {
+      0x4b0003: "STATUS_RESOLVING",
+      0x4b000b: "STATUS_RESOLVED",
+      0x4b0007: "STATUS_CONNECTING_TO",
+      0x4b0004: "STATUS_CONNECTED_TO",
+      0x4b0005: "STATUS_SENDING_TO",
+      0x4b000a: "STATUS_WAITING_FOR",
+      0x4b0006: "STATUS_RECEIVING_FROM",
+    };
+    let status = nsITransportEventSinkStatus[aStatus];
+    this.DEBUG(
+      "onTransportStatus(" + (status || "0x" + aStatus.toString(16)) + ")"
+    );
+
+    if (status == "STATUS_CONNECTED_TO") {
+      // Notify that the connection has been established.
+      this.onConnection();
+    }
+  },
+
+  /*
+   *****************************************************************************
+   ****************************** Private methods ******************************
+   *****************************************************************************
+   */
+  _resetBuffers() {
+    this._incomingDataBuffer = "";
+    this._outgoingDataBuffer = [];
+  },
+
+  _createTransport(aProxy) {
+    this.proxy = aProxy;
+
+    // Empty incoming and outgoing data storage buffers
+    this._resetBuffers();
+
+    // Create a routed socket transport
+    // We connect to host and port, but the origin host and origin port are
+    // given to PSM (e.g. check the certificate).
+    let socketTS = Cc[
+      "@mozilla.org/network/socket-transport-service;1"
+    ].getService(Ci.nsIRoutedSocketTransportService);
+    this.transport = socketTS.createRoutedTransport(
+      this.security,
+      this.originHost,
+      this.originPort,
+      this.host,
+      this.port,
+      this.proxy,
+      null
+    );
+
+    this._openStreams();
+  },
+
+  // Open the incoming and outgoing streams, and init the nsISocketTransport.
+  _openStreams() {
+    // TODO: is this still required after bug 1547096?
+    this.transport.securityCallbacks = this;
+
+    // Set the timeouts for the nsISocketTransport for both a connect event and
+    // a read/write. Only set them if the user has provided them.
+    if (this.connectTimeout) {
+      this.transport.setTimeout(
+        Ci.nsISocketTransport.TIMEOUT_CONNECT,
+        this.connectTimeout
+      );
+    }
+    if (this.readWriteTimeout) {
+      this.transport.setTimeout(
+        Ci.nsISocketTransport.TIMEOUT_READ_WRITE,
+        this.readWriteTimeout
+      );
+    }
+
+    this.transport.setEventSink(this, Services.tm.currentThread);
+
+    // No limit on the output stream buffer
+    this._outputStream = this.transport.openOutputStream(
+      0,
+      this.outputSegmentSize,
+      -1
+    );
+    if (!this._outputStream) {
+      throw new Error("Error getting output stream.");
+    }
+
+    this._inputStream = this.transport.openInputStream(
+      0, // flags
+      0, // Use default segment size
+      0
+    ); // Use default segment count
+    if (!this._inputStream) {
+      throw new Error("Error getting input stream.");
+    }
+
+    // Handle character mode
+    this._scriptableInputStream = new ScriptableInputStream(this._inputStream);
+
+    this.pump = new InputStreamPump(
+      this._inputStream, // Data to read
+      0, // Use default segment size
+      0, // Use default segment length
+      false
+    ); // Do not close when done
+    this.pump.asyncRead(this);
+  },
+
+  _pingTimer: null,
+  _disconnectTimer: null,
+  _sendPing() {
+    delete this._pingTimer;
+    this.sendPing();
+    this._disconnectTimer = setTimeout(
+      this.onConnectionTimedOut.bind(this),
+      this.kTimeAfterPingBeforeDisconnect
+    );
+  },
+
+  /*
+   *****************************************************************************
+   ********************* Methods for subtypes to override **********************
+   *****************************************************************************
+   */
+  LOG(aString) {},
+  DEBUG(aString) {},
+  // Called when a connection is established.
+  onConnection() {},
+  // Called when a socket is accepted after listening.
+  onConnectionHeard() {},
+  // Called when a connection times out.
+  onConnectionTimedOut() {},
+  // Called when a socket request's network is reset.
+  onConnectionReset() {},
+  // Called when the certificate provided by the server didn't satisfy NSS.
+  onConnectionSecurityError(aTLSError, aNSSErrorMessage) {},
+  // Called when the other end has closed the connection.
+  onConnectionClosed() {},
+
+  // Called when ASCII data is available.
+  onDataReceived(/* string */ aData) {},
+
+  // If using the ping functionality, this is called when a new ping message
+  // should be sent on the socket.
+  sendPing() {},
+
+  /* QueryInterface and nsIInterfaceRequestor implementations */
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIStreamListener",
+    "nsIRequestObserver",
+    "nsITransportEventSink",
+    "nsIProtocolProxyCallback",
+  ]),
+
+  getInterface(iid) {
+    return this.QueryInterface(iid);
+  },
+};
diff --git a/comm/chat/modules/test/test_InteractiveBrowser.js b/comm/chat/modules/test/test_InteractiveBrowser.js
new file mode 100644
index 0000000000..eb39d7048b
--- /dev/null
+++ b/comm/chat/modules/test/test_InteractiveBrowser.js
@@ -0,0 +1,280 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { InteractiveBrowser, CancelledError } = ChromeUtils.importESModule(
+  "resource:///modules/InteractiveBrowser.sys.mjs"
+);
+const { TestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/TestUtils.sys.mjs"
+);
+
+add_task(async function test_waitForRedirectOnLocationChange() {
+  const url = "https://example.com";
+  const promptText = "lorem ipsum";
+  const { window, webProgress } = getRequestStubs();
+
+  const observeTopic = TestUtils.topicObserved("browser-request");
+  let resolved = false;
+  const request = InteractiveBrowser.waitForRedirect(url, promptText).then(
+    redirectUrl => {
+      resolved = true;
+      return redirectUrl;
+    }
+  );
+  const [subject] = await observeTopic;
+
+  subject.wrappedJSObject.loaded(window, webProgress);
+  await TestUtils.waitForTick();
+  ok(webProgress.listener, "Progress listener added");
+  equal(window.document.title, promptText, "Window title set");
+
+  const intermediate = "https://intermediate.example.com/";
+  webProgress.listener.onLocationChange(
+    webProgress,
+    {
+      name: intermediate + 1,
+    },
+    {
+      spec: intermediate + 1,
+    }
+  );
+  ok(
+    webProgress.listener,
+    "Progress listener still there after intermediary redirect"
+  );
+  ok(!resolved, "Still waiting for redirect");
+  webProgress.listener.onStateChange(
+    webProgress,
+    {
+      name: intermediate + 2,
+    },
+    Ci.nsIWebProgressListener.STATE_START,
+    null
+  );
+  ok(webProgress.listener, "Listener still there after second redirect");
+  ok(!resolved, "Still waiting for redirect 2");
+
+  const completionUrl = InteractiveBrowser.COMPLETION_URL + "/test?code=asdf";
+  webProgress.listener.onLocationChange(
+    webProgress,
+    {
+      name: completionUrl,
+    },
+    {
+      spec: completionUrl,
+    }
+  );
+
+  const redirectedUrl = await request;
+  ok(resolved, "Redirect complete");
+  equal(redirectedUrl, completionUrl);
+
+  ok(!webProgress.listener);
+  ok(window.closed);
+});
+
+add_task(async function test_waitForRedirectOnStateChangeStart() {
+  const url = "https://example.com";
+  const promptText = "lorem ipsum";
+  const { window, webProgress } = getRequestStubs();
+
+  const observeTopic = TestUtils.topicObserved("browser-request");
+  let resolved = false;
+  const request = InteractiveBrowser.waitForRedirect(url, promptText).then(
+    redirectUrl => {
+      resolved = true;
+      return redirectUrl;
+    }
+  );
+  const [subject] = await observeTopic;
+
+  subject.wrappedJSObject.loaded(window, webProgress);
+  await TestUtils.waitForTick();
+  ok(webProgress.listener, "Progress listener added");
+  equal(window.document.title, promptText, "Window title set");
+
+  const intermediate = "https://intermediate.example.com/";
+  webProgress.listener.onStateChange(
+    webProgress,
+    {
+      name: intermediate,
+    },
+    Ci.nsIWebProgressListener.STATE_START,
+    null
+  );
+  ok(webProgress.listener);
+  ok(!resolved);
+
+  const completionUrl = InteractiveBrowser.COMPLETION_URL + "/test?code=asdf";
+  webProgress.listener.onStateChange(
+    webProgress,
+    {
+      name: completionUrl,
+    },
+    Ci.nsIWebProgressListener.STATE_START
+  );
+
+  const redirectedUrl = await request;
+  ok(resolved, "Redirect complete");
+  equal(redirectedUrl, completionUrl);
+
+  ok(!webProgress.listener);
+  ok(window.closed);
+});
+
+add_task(async function test_waitForRedirectOnStateChangeStart() {
+  const url = "https://example.com";
+  const promptText = "lorem ipsum";
+  const { window, webProgress } = getRequestStubs();
+
+  const observeTopic = TestUtils.topicObserved("browser-request");
+  let resolved = false;
+  const request = InteractiveBrowser.waitForRedirect(url, promptText).then(
+    redirectUrl => {
+      resolved = true;
+      return redirectUrl;
+    }
+  );
+  const [subject] = await observeTopic;
+
+  subject.wrappedJSObject.loaded(window, webProgress);
+  await TestUtils.waitForTick();
+  ok(webProgress.listener, "Progress listener added");
+  equal(window.document.title, promptText, "Window title set");
+
+  const intermediate = "https://intermediate.example.com/";
+  webProgress.listener.onStateChange(
+    webProgress,
+    {
+      name: intermediate,
+    },
+    Ci.nsIWebProgressListener.STATE_IS_NETWORK,
+    null
+  );
+  ok(webProgress.listener);
+  ok(!resolved);
+
+  const completionUrl = InteractiveBrowser.COMPLETION_URL + "/test?code=asdf";
+  webProgress.listener.onStateChange(
+    webProgress,
+    {
+      name: completionUrl,
+    },
+    Ci.nsIWebProgressListener.STATE_IS_NETWORK
+  );
+
+  const redirectedUrl = await request;
+  ok(resolved, "Redirect complete");
+  equal(redirectedUrl, completionUrl);
+
+  ok(!webProgress.listener);
+  ok(window.closed);
+});
+
+add_task(async function test_waitForRedirectCancelled() {
+  const url = "https://example.com";
+  const promptText = "lorem ipsum";
+  const observeTopic = TestUtils.topicObserved("browser-request");
+  const request = InteractiveBrowser.waitForRedirect(url, promptText);
+  const [subject] = await observeTopic;
+
+  subject.wrappedJSObject.cancelled();
+
+  await rejects(request, CancelledError);
+});
+
+add_task(async function test_waitForRedirectImmediatelyAborted() {
+  const url = "https://example.com";
+  const promptText = "lorem ipsum";
+  const { window, webProgress } = getRequestStubs();
+
+  const observeTopic = TestUtils.topicObserved("browser-request");
+  const request = InteractiveBrowser.waitForRedirect(url, promptText);
+  const [subject] = await observeTopic;
+
+  subject.wrappedJSObject.loaded(window, webProgress);
+  subject.wrappedJSObject.cancelled();
+  await TestUtils.waitForTick();
+  ok(!webProgress.listener);
+
+  await rejects(request, CancelledError);
+});
+
+add_task(async function test_waitForRedirectAbortEvent() {
+  const url = "https://example.com";
+  const promptText = "lorem ipsum";
+  const { window, webProgress } = getRequestStubs();
+
+  const observeTopic = TestUtils.topicObserved("browser-request");
+  const request = InteractiveBrowser.waitForRedirect(url, promptText);
+  const [subject] = await observeTopic;
+
+  subject.wrappedJSObject.loaded(window, webProgress);
+  await TestUtils.waitForTick();
+  ok(webProgress.listener);
+  equal(window.document.title, promptText);
+
+  subject.wrappedJSObject.cancelled();
+  await rejects(request, CancelledError);
+  ok(!webProgress.listener);
+  ok(window.closed);
+});
+
+add_task(async function test_waitForRedirectAlreadyArrived() {
+  const url = "https://example.com";
+  const completionUrl = InteractiveBrowser.COMPLETION_URL + "/test?code=asdf";
+  const promptText = "lorem ipsum";
+  const { window, webProgress } = getRequestStubs();
+  window.initialURI = completionUrl;
+
+  const observeTopic = TestUtils.topicObserved("browser-request");
+  let resolved = false;
+  const request = InteractiveBrowser.waitForRedirect(url, promptText).then(
+    redirectUrl => {
+      resolved = true;
+      return redirectUrl;
+    }
+  );
+  const [subject] = await observeTopic;
+
+  subject.wrappedJSObject.loaded(window, webProgress);
+  const redirectedUrl = await request;
+
+  equal(window.document.title, promptText, "Window title set");
+  ok(resolved, "Redirect complete");
+  equal(redirectedUrl, completionUrl);
+
+  ok(!webProgress.listener);
+  ok(window.closed);
+});
+
+function getRequestStubs() {
+  const mocks = {
+    window: {
+      close() {
+        this.closed = true;
+      },
+      document: {
+        getElementById() {
+          return {
+            currentURI: {
+              spec: mocks.window.initialURI,
+            },
+          };
+        },
+      },
+      initialURI: "",
+    },
+    webProgress: {
+      addProgressListener(listener) {
+        this.listener = listener;
+      },
+      removeProgressListener(listener) {
+        if (this.listener === listener) {
+          delete this.listener;
+        }
+      },
+    },
+  };
+  return mocks;
+}
diff --git a/comm/chat/modules/test/test_NormalizedMap.js b/comm/chat/modules/test/test_NormalizedMap.js
new file mode 100644
index 0000000000..cad5bcd4d8
--- /dev/null
+++ b/comm/chat/modules/test/test_NormalizedMap.js
@@ -0,0 +1,80 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { NormalizedMap } = ChromeUtils.importESModule(
+  "resource:///modules/NormalizedMap.sys.mjs"
+);
+
+function test_setter_getter() {
+  let m = new NormalizedMap(aStr => aStr.toLowerCase());
+  m.set("foo", "bar");
+  m.set("BaZ", "blah");
+  Assert.equal(m.has("FOO"), true);
+  Assert.equal(m.has("BaZ"), true);
+  Assert.equal(m.get("FOO"), "bar");
+
+  let keys = Array.from(m.keys());
+  Assert.equal(keys[0], "foo");
+  Assert.equal(keys[1], "baz");
+
+  let values = Array.from(m.values());
+  Assert.equal(values[0], "bar");
+  Assert.equal(values[1], "blah");
+
+  Assert.equal(m.size, 2);
+
+  run_next_test();
+}
+
+function test_constructor() {
+  let k = new NormalizedMap(
+    aStr => aStr.toLowerCase(),
+    [
+      ["A", 2],
+      ["b", 3],
+    ]
+  );
+  Assert.equal(k.get("b"), 3);
+  Assert.equal(k.get("a"), 2);
+  Assert.equal(k.get("B"), 3);
+  Assert.equal(k.get("A"), 2);
+
+  run_next_test();
+}
+
+function test_iterator() {
+  let k = new NormalizedMap(aStr => aStr.toLowerCase());
+  k.set("FoO", "bar");
+
+  for (let [key, value] of k) {
+    Assert.equal(key, "foo");
+    Assert.equal(value, "bar");
+  }
+
+  run_next_test();
+}
+
+function test_delete() {
+  let m = new NormalizedMap(aStr => aStr.toLowerCase());
+  m.set("foo", "bar");
+  m.set("BaZ", "blah");
+
+  Assert.equal(m.delete("blah"), false);
+
+  Assert.equal(m.delete("FOO"), true);
+  Assert.equal(m.size, 1);
+
+  Assert.equal(m.delete("baz"), true);
+  Assert.equal(m.size, 0);
+
+  run_next_test();
+}
+
+function run_test() {
+  add_test(test_setter_getter);
+  add_test(test_constructor);
+  add_test(test_iterator);
+  add_test(test_delete);
+
+  run_next_test();
+}
diff --git a/comm/chat/modules/test/test_filtering.js b/comm/chat/modules/test/test_filtering.js
new file mode 100644
index 0000000000..33c8fcf262
--- /dev/null
+++ b/comm/chat/modules/test/test_filtering.js
@@ -0,0 +1,479 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// These tests run into issues if there isn't a profile directory, see bug 1542397.
+do_get_profile();
+
+var { IMServices } = ChromeUtils.importESModule(
+  "resource:///modules/IMServices.sys.mjs"
+);
+var {
+  cleanupImMarkup,
+  createDerivedRuleset,
+  addGlobalAllowedTag,
+  removeGlobalAllowedTag,
+  addGlobalAllowedAttribute,
+  removeGlobalAllowedAttribute,
+  addGlobalAllowedStyleRule,
+  removeGlobalAllowedStyleRule,
+} = ChromeUtils.importESModule("resource:///modules/imContentSink.sys.mjs");
+
+var kModePref = "messenger.options.filterMode";
+var kStrictMode = 0,
+  kStandardMode = 1,
+  kPermissiveMode = 2;
+
+function run_test() {
+  let defaultMode = Services.prefs.getIntPref(kModePref);
+
+  add_test(test_strictMode);
+  add_test(test_standardMode);
+  add_test(test_permissiveMode);
+  add_test(test_addGlobalAllowedTag);
+  add_test(test_addGlobalAllowedAttribute);
+  add_test(test_addGlobalAllowedStyleRule);
+  add_test(test_createDerivedRuleset);
+
+  Services.prefs.setIntPref(kModePref, defaultMode);
+  run_next_test();
+}
+
+// Sanity check: a string without HTML markup shouldn't be modified.
+function test_plainText() {
+  const strings = [
+    "foo",
+    "foo  ", // preserve trailing whitespace
+    "  foo", // preserve leading indent
+    "&lt;html&gt;&amp;", // keep escaped characters
+  ];
+  for (let string of strings) {
+    Assert.equal(string, cleanupImMarkup(string));
+  }
+}
+
+function test_paragraphs() {
+  const strings = ["<p>foo</p><p>bar</p>", "<p>foo<br>bar</p>", "foo<br>bar"];
+  for (let string of strings) {
+    Assert.equal(string, cleanupImMarkup(string));
+  }
+}
+
+function test_stripScripts() {
+  const strings = [
+    ["<script>alert('hey')</script>", ""],
+    ["foo <script>alert('hey')</script>", "foo "],
+    ["<p onclick=\"alert('hey')\">foo</p>", "<p>foo</p>"],
+    ["<p onmouseover=\"alert('hey')\">foo</p>", "<p>foo</p>"],
+  ];
+  for (let [input, expectedOutput] of strings) {
+    Assert.equal(expectedOutput, cleanupImMarkup(input));
+  }
+}
+
+function test_links() {
+  // http, https, ftp and mailto links should be preserved.
+  const ok = [
+    "http://example.com/",
+    "https://example.com/",
+    "ftp://example.com/",
+    "mailto:foo@example.com",
+  ];
+  for (let string of ok) {
+    string = '<a href="' + string + '">foo</a>';
+    Assert.equal(string, cleanupImMarkup(string));
+  }
+
+  // other links should be removed
+  const bad = [
+    "chrome://global/content/",
+    "about:",
+    "about:blank",
+    "foo://bar/",
+    "",
+  ];
+  for (let string of bad) {
+    Assert.equal(
+      "<a>foo</a>",
+      cleanupImMarkup('<a href="' + string + '">foo</a>')
+    );
+  }
+
+  // keep link titles
+  let string = '<a title="foo bar">foo</a>';
+  Assert.equal(string, cleanupImMarkup(string));
+}
+
+function test_table() {
+  const table =
+    "<table>" +
+    "<caption>test table</caption>" +
+    "<thead>" +
+    "<tr>" +
+    "<th>key</th>" +
+    "<th>data</th>" +
+    "</tr>" +
+    "</thead>" +
+    "<tbody>" +
+    "<tr>" +
+    "<td>lorem</td>" +
+    "<td>ipsum</td>" +
+    "</tr>" +
+    "</tbody>" +
+    "</table>";
+  Assert.equal(table, cleanupImMarkup(table));
+}
+
+function test_allModes() {
+  test_plainText();
+  test_paragraphs();
+  test_stripScripts();
+  test_links();
+  // Remove random classes.
+  Assert.equal("<p>foo</p>", cleanupImMarkup('<p class="foobar">foo</p>'));
+  // Test unparsable style.
+  Assert.equal("<p>foo</p>", cleanupImMarkup('<p style="not-valid">foo</p>'));
+}
+
+function test_strictMode() {
+  Services.prefs.setIntPref(kModePref, kStrictMode);
+  test_allModes();
+
+  // check that basic formatting is stripped in strict mode.
+  for (let tag of [
+    "div",
+    "em",
+    "strong",
+    "b",
+    "i",
+    "u",
+    "s",
+    "span",
+    "code",
+    "ul",
+    "li",
+    "ol",
+    "cite",
+    "blockquote",
+    "del",
+    "strike",
+    "ins",
+    "sub",
+    "sup",
+    "pre",
+    "td",
+    "details",
+    "h1",
+  ]) {
+    Assert.equal("foo", cleanupImMarkup("<" + tag + ">foo</" + tag + ">"));
+  }
+
+  // check that font settings are removed.
+  Assert.equal(
+    "foo",
+    cleanupImMarkup('<font face="Times" color="pink">foo</font>')
+  );
+  Assert.equal(
+    "<p>foo</p>",
+    cleanupImMarkup('<p style="font-weight: bold;">foo</p>')
+  );
+
+  // Discard hr
+  Assert.equal("foobar", cleanupImMarkup("foo<hr>bar"));
+
+  run_next_test();
+}
+
+function test_standardMode() {
+  Services.prefs.setIntPref(kModePref, kStandardMode);
+  test_allModes();
+  test_table();
+
+  // check that basic formatting is kept in standard mode.
+  for (let tag of [
+    "div",
+    "em",
+    "strong",
+    "b",
+    "i",
+    "u",
+    "s",
+    "span",
+    "code",
+    "ul",
+    "li",
+    "ol",
+    "cite",
+    "blockquote",
+    "del",
+    "sub",
+    "sup",
+    "pre",
+    "strike",
+    "ins",
+    "details",
+  ]) {
+    let string = "<" + tag + ">foo</" + tag + ">";
+    Assert.equal(string, cleanupImMarkup(string));
+  }
+
+  // Keep special allowed classes.
+  for (let className of ["moz-txt-underscore", "moz-txt-tag"]) {
+    let string = '<span class="' + className + '">foo</span>';
+    Assert.equal(string, cleanupImMarkup(string));
+  }
+
+  // Remove font settings
+  let font_string = '<font face="Times" color="pink" size="3">foo</font>';
+  Assert.equal("foo", cleanupImMarkup(font_string));
+
+  // Discard hr
+  Assert.equal("foobar", cleanupImMarkup("foo<hr>bar"));
+
+  const okCSS = ["font-style: italic", "font-weight: bold"];
+  for (let css of okCSS) {
+    let string = '<span style="' + css + '">foo</span>';
+    Assert.equal(string, cleanupImMarkup(string));
+  }
+  // text-decoration is a shorthand for several text-decoration properties, but
+  // standard mode only allows text-decoration-line.
+  Assert.equal(
+    '<span style="text-decoration-line: underline;">foo</span>',
+    cleanupImMarkup('<span style="text-decoration: underline">foo</span>')
+  );
+
+  const badCSS = [
+    "color: pink;",
+    "font-family: Times",
+    "font-size: larger",
+    "display: none",
+    "visibility: hidden",
+    "unsupported-by-gecko: blah",
+  ];
+  for (let css of badCSS) {
+    Assert.equal(
+      "<span>foo</span>",
+      cleanupImMarkup('<span style="' + css + '">foo</span>')
+    );
+  }
+  // The shorthand 'font' is decomposed to non-shorthand properties,
+  // and not recomposed as some non-shorthand properties are filtered out.
+  Assert.equal(
+    '<span style="font-style: normal; font-weight: normal;">foo</span>',
+    cleanupImMarkup('<span style="font: 15px normal">foo</span>')
+  );
+
+  // Discard headings
+  const heading1 = "test heading";
+  Assert.equal(heading1, cleanupImMarkup(`<h1>${heading1}</h1>`));
+
+  // Setting the start number of an <ol> is allowed
+  const olWithOffset = '<ol start="2"><li>two</li><li>three</li></ol>';
+  Assert.equal(olWithOffset, cleanupImMarkup(olWithOffset));
+
+  run_next_test();
+}
+
+function test_permissiveMode() {
+  Services.prefs.setIntPref(kModePref, kPermissiveMode);
+  test_allModes();
+  test_table();
+
+  // Check that all formatting is kept in permissive mode.
+  for (let tag of [
+    "div",
+    "em",
+    "strong",
+    "b",
+    "i",
+    "u",
+    "span",
+    "code",
+    "ul",
+    "li",
+    "ol",
+    "cite",
+    "blockquote",
+    "del",
+    "sub",
+    "sup",
+    "pre",
+    "strike",
+    "ins",
+    "details",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+  ]) {
+    let string = "<" + tag + ">foo</" + tag + ">";
+    Assert.equal(string, cleanupImMarkup(string));
+  }
+
+  // Keep special allowed classes.
+  for (let className of ["moz-txt-underscore", "moz-txt-tag"]) {
+    let string = '<span class="' + className + '">foo</span>';
+    Assert.equal(string, cleanupImMarkup(string));
+  }
+
+  // Keep font settings
+  const fontAttributes = ['face="Times"', 'color="pink"', 'size="3"'];
+  for (let fontAttribute of fontAttributes) {
+    let string = "<font " + fontAttribute + ">foo</font>";
+    Assert.equal(string, cleanupImMarkup(string));
+  }
+
+  // Allow hr
+  let hr_string = "foo<hr>bar";
+  Assert.equal(hr_string, cleanupImMarkup(hr_string));
+
+  // Allow most CSS rules changing the text appearance.
+  const okCSS = [
+    "font-style: italic",
+    "font-weight: bold",
+    "color: pink;",
+    "font-family: Times",
+    "font-size: larger",
+  ];
+  for (let css of okCSS) {
+    let string = '<span style="' + css + '">foo</span>';
+    Assert.equal(string, cleanupImMarkup(string));
+  }
+  // text-decoration is a shorthand for several text-decoration properties, but
+  // permissive mode only allows text-decoration-color, text-decoration-line,
+  // and text-decoration-style.
+  Assert.equal(
+    '<span style="text-decoration-color: currentcolor; text-decoration-line: underline; text-decoration-style: solid;">foo</span>',
+    cleanupImMarkup('<span style="text-decoration: underline;">foo</span>')
+  );
+
+  // The shorthand 'font' is decomposed to non-shorthand properties,
+  // and not recomposed as some non-shorthand properties are filtered out.
+  Assert.equal(
+    '<span style="font-family: normal; font-size: 15px; ' +
+      'font-style: normal; font-weight: normal;">foo</span>',
+    cleanupImMarkup('<span style="font: 15px normal">foo</span>')
+  );
+
+  // But still filter out dangerous CSS rules.
+  const badCSS = [
+    "display: none",
+    "visibility: hidden",
+    "unsupported-by-gecko: blah",
+  ];
+  for (let css of badCSS) {
+    Assert.equal(
+      "<span>foo</span>",
+      cleanupImMarkup('<span style="' + css + '">foo</span>')
+    );
+  }
+
+  run_next_test();
+}
+
+function test_addGlobalAllowedTag() {
+  Services.prefs.setIntPref(kModePref, kStrictMode);
+
+  // Check that <hr> isn't allowed by default in strict mode.
+  // Note: we use <hr> instead of <img> to avoid mailnews' content policy
+  // messing things up.
+  Assert.equal("", cleanupImMarkup("<hr>"));
+
+  // Allow <hr> without attributes.
+  addGlobalAllowedTag("hr");
+  Assert.equal("<hr>", cleanupImMarkup("<hr>"));
+  Assert.equal("<hr>", cleanupImMarkup('<hr src="http://example.com/">'));
+  removeGlobalAllowedTag("hr");
+
+  // Allow <hr> with an unfiltered src attribute.
+  addGlobalAllowedTag("hr", { src: true });
+  Assert.equal("<hr>", cleanupImMarkup('<hr alt="foo">'));
+  Assert.equal(
+    '<hr src="http://example.com/">',
+    cleanupImMarkup('<hr src="http://example.com/">')
+  );
+  Assert.equal(
+    '<hr src="chrome://global/skin/img.png">',
+    cleanupImMarkup('<hr src="chrome://global/skin/img.png">')
+  );
+  removeGlobalAllowedTag("hr");
+
+  // Allow <hr> with an src attribute taking only http(s) urls.
+  addGlobalAllowedTag("hr", { src: aValue => /^https?:/.test(aValue) });
+  Assert.equal(
+    '<hr src="http://example.com/">',
+    cleanupImMarkup('<hr src="http://example.com/">')
+  );
+  Assert.equal(
+    "<hr>",
+    cleanupImMarkup('<hr src="chrome://global/skin/img.png">')
+  );
+  removeGlobalAllowedTag("hr");
+
+  run_next_test();
+}
+
+function test_addGlobalAllowedAttribute() {
+  Services.prefs.setIntPref(kModePref, kStrictMode);
+
+  // Check that id isn't allowed by default in strict mode.
+  Assert.equal("<br>", cleanupImMarkup('<br id="foo">'));
+
+  // Allow id unconditionally.
+  addGlobalAllowedAttribute("id");
+  Assert.equal('<br id="foo">', cleanupImMarkup('<br id="foo">'));
+  removeGlobalAllowedAttribute("id");
+
+  // Allow id only with numbers.
+  addGlobalAllowedAttribute("id", aId => /^\d+$/.test(aId));
+  Assert.equal('<br id="123">', cleanupImMarkup('<br id="123">'));
+  Assert.equal("<br>", cleanupImMarkup('<br id="foo">'));
+  removeGlobalAllowedAttribute("id");
+
+  run_next_test();
+}
+
+function test_addGlobalAllowedStyleRule() {
+  // We need at least the standard mode to have the style attribute allowed.
+  Services.prefs.setIntPref(kModePref, kStandardMode);
+
+  // Check that clear isn't allowed by default in strict mode.
+  Assert.equal("<br>", cleanupImMarkup('<br style="clear: both;">'));
+
+  // Allow clear.
+  addGlobalAllowedStyleRule("clear");
+  Assert.equal(
+    '<br style="clear: both;">',
+    cleanupImMarkup('<br style="clear: both;">')
+  );
+  removeGlobalAllowedStyleRule("clear");
+
+  run_next_test();
+}
+
+function test_createDerivedRuleset() {
+  Services.prefs.setIntPref(kModePref, kStandardMode);
+
+  let rules = createDerivedRuleset();
+
+  let string = "<hr>";
+  Assert.equal("", cleanupImMarkup(string));
+  Assert.equal("", cleanupImMarkup(string, rules));
+  rules.tags.hr = true;
+  Assert.equal(string, cleanupImMarkup(string, rules));
+
+  string = '<br id="123">';
+  Assert.equal("<br>", cleanupImMarkup(string));
+  Assert.equal("<br>", cleanupImMarkup(string, rules));
+  rules.attrs.id = true;
+  Assert.equal(string, cleanupImMarkup(string, rules));
+
+  string = '<br style="clear: both;">';
+  Assert.equal("<br>", cleanupImMarkup(string));
+  Assert.equal("<br>", cleanupImMarkup(string, rules));
+  rules.styles.clear = true;
+  Assert.equal(string, cleanupImMarkup(string, rules));
+
+  run_next_test();
+}
diff --git a/comm/chat/modules/test/test_imThemes.js b/comm/chat/modules/test/test_imThemes.js
new file mode 100644
index 0000000000..61171fe121
--- /dev/null
+++ b/comm/chat/modules/test/test_imThemes.js
@@ -0,0 +1,342 @@
+/* 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 {
+  initHTMLDocument,
+  insertHTMLForMessage,
+  getHTMLForMessage,
+  replaceHTMLForMessage,
+  wasNextMessage,
+  removeMessage,
+  isNextMessage,
+} = ChromeUtils.importESModule("resource:///modules/imThemes.sys.mjs");
+const { MockDocument } = ChromeUtils.importESModule(
+  "resource://testing-common/MockDocument.sys.mjs"
+);
+
+const BASIC_CONV_DOCUMENT_HTML =
+  '<!DOCTYPE html><html><body><div id="Chat"></div></body></html>';
+
+add_task(function test_initHTMLDocument() {
+  const window = {};
+  const document = MockDocument.createTestDocument(
+    "chrome://chat/content/conv.html",
+    "<!DOCTYPE html><html><head></head><body></body></html>"
+  );
+  Object.defineProperty(document, "defaultView", {
+    value: window,
+  });
+  const conversation = {
+    title: "test",
+  };
+  const theme = {
+    baseURI: "chrome://messenger-messagestyles/skin/test/",
+    variant: "default",
+    metadata: {},
+    html: {
+      footer: "",
+      script: 'console.log("hi");',
+    },
+  };
+  initHTMLDocument(conversation, theme, document);
+  equal(typeof document.defaultView.convertTimeUnits, "function");
+  equal(document.querySelector("base").href, theme.baseURI);
+  ok(
+    document.querySelector(
+      'link[rel="stylesheet"][href="chrome://chat/skin/conv.css"]'
+    )
+  );
+  ok(document.querySelector('link[rel="stylesheet"][href="main.css"]'));
+
+  equal(document.body.id, "ibcontent");
+  ok(document.getElementById("Chat"));
+  equal(document.querySelector("script").src, theme.baseURI + "inline.js");
+});
+
+add_task(function test_insertHTMLForMessage() {
+  const document = MockDocument.createTestDocument(
+    "chrome://chat/content/conv.html",
+    BASIC_CONV_DOCUMENT_HTML
+  );
+  const html = '<div style="background: blue;">foo bar</div>';
+  const message = {};
+  insertHTMLForMessage(message, html, document, false);
+  const messageElement = document.querySelector("#Chat > div");
+  strictEqual(messageElement._originalMsg, message);
+  equal(messageElement.style.backgroundColor, "blue");
+  equal(messageElement.textContent, "foo bar");
+  ok(!messageElement.dataset.isNext);
+});
+
+add_task(function test_insertHTMLForMessage_next() {
+  const document = MockDocument.createTestDocument(
+    "chrome://chat/content/conv.html",
+    BASIC_CONV_DOCUMENT_HTML
+  );
+  const html = '<div style="background: blue;">foo bar</div>';
+  const message = {};
+  insertHTMLForMessage(message, html, document, true);
+  const messageElement = document.querySelector("#Chat > div");
+  strictEqual(messageElement._originalMsg, message);
+  equal(messageElement.style.backgroundColor, "blue");
+  equal(messageElement.textContent, "foo bar");
+  ok(messageElement.dataset.isNext);
+});
+
+add_task(function test_getHTMLForMessage() {
+  const message = {
+    incoming: true,
+    system: false,
+    message: "foo bar",
+    who: "userId",
+    alias: "display name",
+    color: "#ffbbff",
+  };
+  const theme = {
+    html: {
+      incomingContent:
+        '<span style="color: %senderColor%;">%sender%</span>%message%',
+    },
+  };
+  const html = getHTMLForMessage(message, theme, false, false);
+  equal(
+    html,
+    '<span style="color: #ffbbff;"><span class="ib-sender">display name</span></span><span class="ib-msg-txt">foo bar</span>'
+  );
+});
+
+add_task(function test_replaceHTMLForMessage() {
+  const document = MockDocument.createTestDocument(
+    "chrome://chat/content/conv.html",
+    BASIC_CONV_DOCUMENT_HTML
+  );
+  const html = '<div style="background: blue;">foo bar</div>';
+  const message = {
+    remoteId: "foo",
+  };
+  insertHTMLForMessage(message, html, document, false);
+  const messageElement = document.querySelector("#Chat > div");
+  strictEqual(messageElement._originalMsg, message);
+  equal(messageElement.style.backgroundColor, "blue");
+  equal(messageElement.textContent, "foo bar");
+  equal(messageElement.dataset.remoteId, "foo");
+  ok(!messageElement.dataset.isNext);
+  const updatedHtml =
+    '<div style="background: green;">lorem ipsum</div><div id="insert"></div>';
+  const updatedMessage = {
+    remoteId: "foo",
+  };
+  replaceHTMLForMessage(updatedMessage, updatedHtml, document, true);
+  const updatedMessageElement = document.querySelector("#Chat > div");
+  strictEqual(updatedMessageElement._originalMsg, updatedMessage);
+  equal(updatedMessageElement.style.backgroundColor, "green");
+  equal(updatedMessageElement.textContent, "lorem ipsum");
+  equal(updatedMessageElement.dataset.remoteId, "foo");
+  ok(updatedMessageElement.dataset.isNext);
+  ok(
+    !document.querySelector("#insert"),
+    "Insert anchor in template is ignored when replacing"
+  );
+});
+
+add_task(function test_replaceHTMLForMessageWithoutExistingMessage() {
+  const document = MockDocument.createTestDocument(
+    "chrome://chat/content/conv.html",
+    BASIC_CONV_DOCUMENT_HTML
+  );
+  const updatedHtml = '<div style="background: green;">lorem ipsum</div>';
+  const updatedMessage = {
+    remoteId: "foo",
+  };
+  replaceHTMLForMessage(updatedMessage, updatedHtml, document, false);
+  const updatedMessageElement = document.querySelector("#Chat > div");
+  ok(!updatedMessageElement);
+});
+
+add_task(function test_replaceHTMLForMessageWithoutRemoteId() {
+  const document = MockDocument.createTestDocument(
+    "chrome://chat/content/conv.html",
+    BASIC_CONV_DOCUMENT_HTML
+  );
+  const html = '<div style="background: blue;">foo bar</div>';
+  const message = {
+    remoteId: "foo",
+  };
+  insertHTMLForMessage(message, html, document, false);
+  const messageElement = document.querySelector("#Chat > div");
+  strictEqual(messageElement._originalMsg, message);
+  equal(messageElement.style.backgroundColor, "blue");
+  equal(messageElement.textContent, "foo bar");
+  equal(messageElement.dataset.remoteId, "foo");
+  ok(!messageElement.dataset.isNext);
+  const updatedHtml = '<div style="background: green;">lorem ipsum</div>';
+  const updatedMessage = {};
+  replaceHTMLForMessage(updatedMessage, updatedHtml, document, false);
+  const updatedMessageElement = document.querySelector("#Chat > div");
+  strictEqual(updatedMessageElement._originalMsg, message);
+  equal(updatedMessageElement.style.backgroundColor, "blue");
+  equal(updatedMessageElement.textContent, "foo bar");
+  equal(updatedMessageElement.dataset.remoteId, "foo");
+  ok(!updatedMessageElement.dataset.isNext);
+});
+
+add_task(function test_wasNextMessage_isNext() {
+  const document = MockDocument.createTestDocument(
+    "chrome://chat/content/conv.html",
+    BASIC_CONV_DOCUMENT_HTML
+  );
+  const html = "<div>foo bar</div>";
+  const message = {
+    remoteId: "foo",
+  };
+  insertHTMLForMessage(message, html, document, true);
+  ok(wasNextMessage(message, document));
+});
+
+add_task(function test_wasNextMessage_isNotNext() {
+  const document = MockDocument.createTestDocument(
+    "chrome://chat/content/conv.html",
+    BASIC_CONV_DOCUMENT_HTML
+  );
+  const html = "<div>foo bar</div>";
+  const message = {
+    remoteId: "foo",
+  };
+  insertHTMLForMessage(message, html, document, false);
+  ok(!wasNextMessage(message, document));
+});
+
+add_task(function test_wasNextMessage_noPreviousVersion() {
+  const document = MockDocument.createTestDocument(
+    "chrome://chat/content/conv.html",
+    BASIC_CONV_DOCUMENT_HTML
+  );
+  const message = {
+    remoteId: "foo",
+  };
+  ok(!wasNextMessage(message, document));
+});
+
+add_task(function test_removeMessage() {
+  const document = MockDocument.createTestDocument(
+    "chrome://chat/content/conv.html",
+    BASIC_CONV_DOCUMENT_HTML
+  );
+  const html = '<div style="background: blue;">foo bar</div>';
+  const message = {
+    remoteId: "foo",
+  };
+  insertHTMLForMessage(message, html, document, false);
+  const messageElement = document.querySelector("#Chat > div");
+  strictEqual(messageElement._originalMsg, message);
+  equal(messageElement.style.backgroundColor, "blue");
+  equal(messageElement.textContent, "foo bar");
+  equal(messageElement.dataset.remoteId, "foo");
+  ok(!messageElement.dataset.isNext);
+  removeMessage("foo", document);
+  const messageElements = document.querySelectorAll("#Chat > div");
+  equal(messageElements.length, 0);
+});
+
+add_task(function test_removeMessage_noMatchingMessage() {
+  const document = MockDocument.createTestDocument(
+    "chrome://chat/content/conv.html",
+    BASIC_CONV_DOCUMENT_HTML
+  );
+  const html = '<div style="background: blue;">foo bar</div>';
+  const message = {
+    remoteId: "foo",
+  };
+  insertHTMLForMessage(message, html, document, false);
+  const messageElement = document.querySelector("#Chat > div");
+  strictEqual(messageElement._originalMsg, message);
+  equal(messageElement.style.backgroundColor, "blue");
+  equal(messageElement.textContent, "foo bar");
+  equal(messageElement.dataset.remoteId, "foo");
+  ok(!messageElement.dataset.isNext);
+  removeMessage("bar", document);
+  const messageElements = document.querySelectorAll("#Chat > div");
+  notEqual(messageElements.length, 0);
+});
+
+add_task(function test_isNextMessage() {
+  const theme = {
+    combineConsecutive: true,
+    metadata: {},
+    combineConsecutiveInterval: 300,
+  };
+  const messagePairs = [
+    {
+      message: {},
+      previousMessage: null,
+      isNext: false,
+    },
+    {
+      message: {
+        system: true,
+      },
+      previousMessage: {
+        system: true,
+      },
+      isNext: true,
+    },
+    {
+      message: {
+        who: "foo",
+      },
+      previousMessage: {
+        who: "bar",
+      },
+      isNext: false,
+    },
+    {
+      message: {
+        outgoing: true,
+      },
+      isNext: false,
+    },
+    {
+      message: {
+        incoming: true,
+      },
+      isNext: false,
+    },
+    {
+      message: {
+        system: true,
+      },
+      isNext: false,
+    },
+    {
+      message: {
+        time: 100,
+      },
+      previousMessage: {
+        time: 100,
+      },
+      isNext: true,
+    },
+    {
+      message: {
+        time: 300,
+      },
+      previousMessage: {
+        time: 100,
+      },
+      isNext: true,
+    },
+    {
+      message: {
+        time: 500,
+      },
+      previousMessage: {
+        time: 100,
+      },
+      isNext: false,
+    },
+  ];
+  for (const { message, previousMessage = {}, isNext } of messagePairs) {
+    equal(isNextMessage(theme, message, previousMessage), isNext);
+  }
+});
diff --git a/comm/chat/modules/test/test_jsProtoHelper.js b/comm/chat/modules/test/test_jsProtoHelper.js
new file mode 100644
index 0000000000..b87ec27241
--- /dev/null
+++ b/comm/chat/modules/test/test_jsProtoHelper.js
@@ -0,0 +1,159 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { GenericConvIMPrototype } = ChromeUtils.importESModule(
+  "resource:///modules/jsProtoHelper.sys.mjs"
+);
+
+var _id = 0;
+function Conversation(name) {
+  this._name = name;
+  this._observers = [];
+  this._date = Date.now() * 1000;
+  this.id = ++_id;
+}
+Conversation.prototype = {
+  __proto__: GenericConvIMPrototype,
+  _account: {
+    imAccount: {
+      protocol: { name: "Fake Protocol" },
+      alias: "",
+      name: "Fake Account",
+    },
+    ERROR(e) {
+      throw e;
+    },
+    DEBUG() {},
+  },
+};
+
+// ROT13, used as an example transformation.
+function rot13(aString) {
+  return aString.replace(/[a-zA-Z]/g, function (c) {
+    return String.fromCharCode(
+      c.charCodeAt(0) + (c.toLowerCase() < "n" ? 1 : -1) * 13
+    );
+  });
+}
+
+// A test that cancels a message before it can be sent.
+add_task(function test_cancel_send_message() {
+  let conv = new Conversation();
+  conv.dispatchMessage = function (aMsg) {
+    ok(
+      false,
+      "The message should have been halted in the conversation service."
+    );
+  };
+
+  let sending = false;
+  conv.addObserver({
+    observe(aObject, aTopic, aMsg) {
+      switch (aTopic) {
+        case "sending-message":
+          ok(
+            aObject.QueryInterface(Ci.imIOutgoingMessage),
+            "Wrong message type."
+          );
+          aObject.cancelled = true;
+          sending = true;
+          break;
+        case "new-text":
+          ok(
+            false,
+            "No other notification should be fired for a cancelled message."
+          );
+          break;
+      }
+    },
+  });
+  conv.sendMsg("Hi!");
+  ok(sending, "The sending-message notification was never fired.");
+});
+
+// A test that ensures protocols get a chance to prepare a message before
+// sending and displaying.
+add_task(function test_prpl_message_prep() {
+  let conv = new Conversation();
+  conv.dispatchMessage = function (aMsg) {
+    this.writeMessage("user", aMsg, { outgoing: true });
+  };
+
+  conv.prepareForSending = function (aMsg) {
+    ok(aMsg.QueryInterface(Ci.imIOutgoingMessage), "Wrong message type.");
+    equal(aMsg.message, msg, "Expected the original message.");
+    prepared = true;
+    return [prefix + aMsg.message];
+  };
+
+  conv.prepareForDisplaying = function (aMsg) {
+    equal(aMsg.displayMessage, prefix + msg, "Expected the prefixed message.");
+    aMsg.displayMessage = aMsg.displayMessage.slice(prefix.length);
+  };
+
+  let msg = "Hi!";
+  let prefix = "test> ";
+
+  let prepared = false;
+  let receivedMsg = false;
+  conv.addObserver({
+    observe(aObject, aTopic) {
+      if (aTopic === "preparing-message") {
+        equal(aObject.message, msg, "Expected the original message");
+      } else if (aTopic === "sending-message") {
+        equal(aObject.message, prefix + msg, "Expected the prefixed message.");
+      } else if (aTopic === "new-text") {
+        ok(aObject.QueryInterface(Ci.prplIMessage), "Wrong message type.");
+        ok(prepared, "The message was not prepared before sending.");
+        equal(aObject.message, prefix + msg, "Expected the prefixed message.");
+        receivedMsg = true;
+        aObject.displayMessage = aObject.originalMessage;
+        conv.prepareForDisplaying(aObject);
+        equal(aObject.displayMessage, msg, "Expected the original message");
+      }
+    },
+  });
+
+  conv.sendMsg(msg);
+  ok(receivedMsg, "The new-text notification was never fired.");
+});
+
+// A test that ensures protocols can split messages before they are sent.
+add_task(function test_split_message_before_sending() {
+  let msgCount = 0;
+  let prepared = false;
+
+  let msg = "This is a looo\nooong message.\nThis one is short.";
+  let msgs = msg.split("\n");
+
+  let conv = new Conversation();
+  conv.dispatchMessage = function (aMsg) {
+    equal(aMsg, msgs[msgCount++], "Sending an unexpected message.");
+  };
+  conv.prepareForSending = function (aMsg) {
+    ok(aMsg.QueryInterface(Ci.imIOutgoingMessage), "Wrong message type.");
+    prepared = true;
+    return aMsg.message.split("\n");
+  };
+
+  conv.sendMsg(msg);
+
+  ok(prepared, "Message wasn't prepared for sending.");
+  equal(msgCount, 3, "Not enough messages were sent.");
+});
+
+add_task(function test_removeMessage() {
+  let didRemove = false;
+  let conv = new Conversation();
+  conv.addObserver({
+    observe(subject, topic, data) {
+      if (topic === "remove-text") {
+        equal(data, "foo");
+        didRemove = true;
+      }
+    },
+  });
+
+  conv.removeMessage("foo");
+  ok(didRemove);
+});
diff --git a/comm/chat/modules/test/test_otrlib.js b/comm/chat/modules/test/test_otrlib.js
new file mode 100644
index 0000000000..4b321359f9
--- /dev/null
+++ b/comm/chat/modules/test/test_otrlib.js
@@ -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/. */
+
+/**
+ * Test for libotr.
+ */
+
+"use strict";
+
+const { OTRLibLoader } = ChromeUtils.importESModule(
+  "resource:///modules/OTRLib.sys.mjs"
+);
+
+/**
+ * Initialize libotr.
+ */
+add_setup(async function () {
+  let libOTR = await OTRLibLoader.init();
+  Assert.ok(libOTR.otrl_version, "libotr did load");
+});
diff --git a/comm/chat/modules/test/xpcshell.ini b/comm/chat/modules/test/xpcshell.ini
new file mode 100644
index 0000000000..d12004fd37
--- /dev/null
+++ b/comm/chat/modules/test/xpcshell.ini
@@ -0,0 +1,10 @@
+[DEFAULT]
+head =
+tail =
+
+[test_filtering.js]
+[test_imThemes.js]
+[test_InteractiveBrowser.js]
+[test_jsProtoHelper.js]
+[test_NormalizedMap.js]
+[test_otrlib.js]