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

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

1 files changed, 3034 insertions, 0 deletions

diff --git a/comm/mail/extensions/openpgp/content/ui/enigmailMsgComposeOverlay.js b/comm/mail/extensions/openpgp/content/ui/enigmailMsgComposeOverlay.js
new file mode 100644
index 0000000000..db973f0ee9
--- /dev/null
+++ b/comm/mail/extensions/openpgp/content/ui/enigmailMsgComposeOverlay.js
@@ -0,0 +1,3034 @@
+/*
+ * 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 https://mozilla.org/MPL/2.0/.
+ */
+
+"use strict";
+
+/* import-globals-from ../../../../components/compose/content/MsgComposeCommands.js */
+/* import-globals-from ../../../../components/compose/content/addressingWidgetOverlay.js */
+/* global MsgAccountManager */
+/* global gCurrentIdentity */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+var EnigmailCore = ChromeUtils.import(
+  "chrome://openpgp/content/modules/core.jsm"
+).EnigmailCore;
+var EnigmailFuncs = ChromeUtils.import(
+  "chrome://openpgp/content/modules/funcs.jsm"
+).EnigmailFuncs;
+var { EnigmailLog } = ChromeUtils.import(
+  "chrome://openpgp/content/modules/log.jsm"
+);
+var EnigmailArmor = ChromeUtils.import(
+  "chrome://openpgp/content/modules/armor.jsm"
+).EnigmailArmor;
+var EnigmailData = ChromeUtils.import(
+  "chrome://openpgp/content/modules/data.jsm"
+).EnigmailData;
+var EnigmailDialog = ChromeUtils.import(
+  "chrome://openpgp/content/modules/dialog.jsm"
+).EnigmailDialog;
+var EnigmailWindows = ChromeUtils.import(
+  "chrome://openpgp/content/modules/windows.jsm"
+).EnigmailWindows;
+var EnigmailKeyRing = ChromeUtils.import(
+  "chrome://openpgp/content/modules/keyRing.jsm"
+).EnigmailKeyRing;
+var EnigmailURIs = ChromeUtils.import(
+  "chrome://openpgp/content/modules/uris.jsm"
+).EnigmailURIs;
+var EnigmailConstants = ChromeUtils.import(
+  "chrome://openpgp/content/modules/constants.jsm"
+).EnigmailConstants;
+var EnigmailDecryption = ChromeUtils.import(
+  "chrome://openpgp/content/modules/decryption.jsm"
+).EnigmailDecryption;
+var EnigmailEncryption = ChromeUtils.import(
+  "chrome://openpgp/content/modules/encryption.jsm"
+).EnigmailEncryption;
+var EnigmailWkdLookup = ChromeUtils.import(
+  "chrome://openpgp/content/modules/wkdLookup.jsm"
+).EnigmailWkdLookup;
+var EnigmailMime = ChromeUtils.import(
+  "chrome://openpgp/content/modules/mime.jsm"
+).EnigmailMime;
+var EnigmailMsgRead = ChromeUtils.import(
+  "chrome://openpgp/content/modules/msgRead.jsm"
+).EnigmailMsgRead;
+var EnigmailMimeEncrypt = ChromeUtils.import(
+  "chrome://openpgp/content/modules/mimeEncrypt.jsm"
+).EnigmailMimeEncrypt;
+const { EnigmailCryptoAPI } = ChromeUtils.import(
+  "chrome://openpgp/content/modules/cryptoAPI.jsm"
+);
+const { OpenPGPAlias } = ChromeUtils.import(
+  "chrome://openpgp/content/modules/OpenPGPAlias.jsm"
+);
+var { jsmime } = ChromeUtils.import("resource:///modules/jsmime.jsm");
+
+var l10nOpenPGP = new Localization(["messenger/openpgp/openpgp.ftl"]);
+
+// Account encryption policy values:
+// const kEncryptionPolicy_Never = 0;
+// 'IfPossible' was used by ns4.
+// const kEncryptionPolicy_IfPossible = 1;
+var kEncryptionPolicy_Always = 2;
+
+var Enigmail = {};
+
+const IOSERVICE_CONTRACTID = "@mozilla.org/network/io-service;1";
+const LOCAL_FILE_CONTRACTID = "@mozilla.org/file/local;1";
+
+Enigmail.msg = {
+  editor: null,
+  dirty: 0,
+  // dirty means: composer contents were modified by this code, right?
+  processed: null, // contains information for undo of inline signed/encrypt
+  timeoutId: null, // TODO: once set, it's never reset
+  sendPgpMime: true,
+  //sendMode: null, // the current default for sending a message (0, SIGN, ENCRYPT, or SIGN|ENCRYPT)
+  //sendModeDirty: false, // send mode or final send options changed?
+
+  // processed strings to signal final encrypt/sign/pgpmime state:
+  statusEncryptedStr: "???",
+  statusSignedStr: "???",
+  //statusPGPMimeStr: "???",
+  //statusSMimeStr: "???",
+  //statusInlinePGPStr: "???",
+  statusAttachOwnKey: "???",
+
+  sendProcess: false,
+  composeBodyReady: false,
+  modifiedAttach: null,
+  lastFocusedWindow: null,
+  draftSubjectEncrypted: false,
+  attachOwnKeyObj: {
+    attachedObj: null,
+    attachedKey: null,
+  },
+
+  keyLookupDone: [],
+
+  addrOnChangeTimeout: 250,
+  /* timeout when entering something into the address field */
+
+  async composeStartup() {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.composeStartup\n"
+    );
+
+    if (!gMsgCompose || !gMsgCompose.compFields) {
+      EnigmailLog.DEBUG(
+        "enigmailMsgComposeOverlay.js: no gMsgCompose, leaving\n"
+      );
+      return;
+    }
+
+    gMsgCompose.RegisterStateListener(Enigmail.composeStateListener);
+    Enigmail.msg.composeBodyReady = false;
+
+    // Listen to message sending event
+    addEventListener(
+      "compose-send-message",
+      Enigmail.msg.sendMessageListener.bind(Enigmail.msg),
+      true
+    );
+
+    await OpenPGPAlias.load().catch(console.error);
+
+    Enigmail.msg.composeOpen();
+    //Enigmail.msg.processFinalState();
+  },
+
+  // TODO: call this from global compose when options change
+  enigmailComposeProcessFinalState() {
+    //Enigmail.msg.processFinalState();
+  },
+
+  /*
+  handleClick: function(event, modifyType) {
+    EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: Enigmail.msg.handleClick\n");
+    switch (event.button) {
+      case 2:
+        // do not process the event any further
+        // needed on Windows to prevent displaying the context menu
+        event.preventDefault();
+        this.doPgpButton();
+        break;
+      case 0:
+        this.doPgpButton(modifyType);
+        break;
+    }
+  },
+  */
+
+  /* return whether the account specific setting key is enabled or disabled
+   */
+  /*
+  getAccDefault: function(key) {
+    //EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: Enigmail.msg.getAccDefault: identity="+this.identity.key+"("+this.identity.email+") key="+key+"\n");
+    let res = null;
+    let mimePreferOpenPGP = this.identity.getIntAttribute("mimePreferOpenPGP");
+    let isSmimeEnabled = Enigmail.msg.isSmimeEnabled();
+    let wasEnigmailEnabledForIdentity = Enigmail.msg.wasEnigmailEnabledForIdentity();
+    let preferSmimeByDefault = false;
+
+    if (isSmimeEnabled && wasEnigmailEnabledForIdentity) {
+    }
+
+    if (wasEnigmailEnabledForIdentity) {
+      switch (key) {
+        case 'sign':
+          if (preferSmimeByDefault) {
+            res = (this.identity.signMail);
+          }
+          else {
+            res = (this.identity.getIntAttribute("defaultSigningPolicy") > 0);
+          }
+          break;
+        case 'encrypt':
+          if (preferSmimeByDefault) {
+            res = (this.identity.encryptionPolicy > 0);
+          }
+          else {
+            res = (this.identity.getIntAttribute("defaultEncryptionPolicy") > 0);
+          }
+          break;
+        case 'sign-pgp':
+          res = (this.identity.getIntAttribute("defaultSigningPolicy") > 0);
+          break;
+        case 'pgpMimeMode':
+          res = this.identity.getBoolAttribute(key);
+          break;
+        case 'attachPgpKey':
+          res = this.identity.attachPgpKey;
+          break;
+      }
+      //EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: Enigmail.msg.getAccDefault:   "+key+"="+res+"\n");
+      return res;
+    }
+    else if (Enigmail.msg.isSmimeEnabled()) {
+      switch (key) {
+        case 'sign':
+          res = this.identity.signMail;
+          break;
+        case 'encrypt':
+          res = (this.identity.encryptionPolicy > 0);
+          break;
+        default:
+          res = false;
+      }
+      return res;
+    }
+    else {
+      // every detail is disabled if OpenPGP in general is disabled:
+      switch (key) {
+        case 'sign':
+        case 'encrypt':
+        case 'pgpMimeMode':
+        case 'attachPgpKey':
+        case 'sign-pgp':
+          return false;
+      }
+    }
+
+    // should not be reached
+    EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: Enigmail.msg.getAccDefault:   internal error: invalid key '" + key + "'\n");
+    return null;
+  },
+  */
+
+  /**
+   * Determine if any of Enigmail (OpenPGP) or S/MIME encryption is enabled for the account
+   */
+  /*
+  isAnyEncryptionEnabled: function() {
+    let id = getCurrentIdentity();
+
+    return ((id.getUnicharAttribute("encryption_cert_name") !== "") ||
+      Enigmail.msg.wasEnigmailEnabledForIdentity());
+  },
+  */
+
+  isSmimeEnabled() {
+    return (
+      gCurrentIdentity.getUnicharAttribute("signing_cert_name") !== "" ||
+      gCurrentIdentity.getUnicharAttribute("encryption_cert_name") !== ""
+    );
+  },
+
+  /**
+   * Determine if any of Enigmail (OpenPGP) or S/MIME signing is enabled for the account
+   */
+  /*
+  getSigningEnabled: function() {
+    let id = getCurrentIdentity();
+
+    return ((id.getUnicharAttribute("signing_cert_name") !== "") ||
+      Enigmail.msg.wasEnigmailEnabledForIdentity());
+  },
+  */
+
+  /*
+  getSmimeSigningEnabled: function() {
+    let id = getCurrentIdentity();
+
+    if (!id.getUnicharAttribute("signing_cert_name")) return false;
+
+    return id.signMail;
+  },
+  */
+
+  /*
+  // set the current default for sending a message
+  // depending on the identity
+  processAccountSpecificDefaultOptions: function() {
+    EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: Enigmail.msg.processAccountSpecificDefaultOptions\n");
+
+    const SIGN = EnigmailConstants.SEND_SIGNED;
+    const ENCRYPT = EnigmailConstants.SEND_ENCRYPTED;
+
+    this.sendMode = 0;
+
+    if (this.getSmimeSigningEnabled()) {
+      this.sendMode |= SIGN;
+    }
+
+    if (!Enigmail.msg.wasEnigmailEnabledForIdentity()) {
+      return;
+    }
+
+    if (this.getAccDefault("encrypt")) {
+      this.sendMode |= ENCRYPT;
+    }
+    if (this.getAccDefault("sign")) {
+      this.sendMode |= SIGN;
+    }
+
+    //this.sendPgpMime = this.getAccDefault("pgpMimeMode");
+    //console.debug("processAccountSpecificDefaultOptions sendPgpMime: " + this.sendPgpMime);
+    gAttachMyPublicPGPKey = this.getAccDefault("attachPgpKey");
+    this.setOwnKeyStatus();
+    this.attachOwnKeyObj.attachedObj = null;
+    this.attachOwnKeyObj.attachedKey = null;
+
+    //this.finalSignDependsOnEncrypt = (this.getAccDefault("signIfEnc") || this.getAccDefault("signIfNotEnc"));
+  },
+  */
+
+  getOriginalMsgUri() {
+    let draftId = gMsgCompose.compFields.draftId;
+    let msgUri = null;
+
+    if (draftId) {
+      // original message is draft
+      msgUri = draftId.replace(/\?.*$/, "");
+    } else if (gMsgCompose.originalMsgURI) {
+      // original message is a "true" mail
+      msgUri = gMsgCompose.originalMsgURI;
+    }
+
+    return msgUri;
+  },
+
+  getMsgHdr(msgUri) {
+    try {
+      if (!msgUri) {
+        msgUri = this.getOriginalMsgUri();
+      }
+      if (msgUri) {
+        return gMessenger.msgHdrFromURI(msgUri);
+      }
+    } catch (ex) {
+      // See also bug 1635648
+      console.debug("exception in getMsgHdr: " + ex);
+      EnigmailLog.DEBUG(
+        "enigmailMessengerOverlay.js: exception in getMsgHdr: " + ex + "\n"
+      );
+    }
+    return null;
+  },
+
+  getMsgProperties(draft, msgUri, msgHdr, mimeMsg, obtainedDraftFlagsObj) {
+    EnigmailLog.DEBUG(
+      "enigmailMessengerOverlay.js: Enigmail.msg.getMsgProperties:\n"
+    );
+    obtainedDraftFlagsObj.value = false;
+
+    let self = this;
+    let properties = 0;
+    try {
+      if (msgHdr) {
+        properties = msgHdr.getUint32Property("enigmail");
+
+        if (draft) {
+          if (self.getSavedDraftOptions(mimeMsg)) {
+            obtainedDraftFlagsObj.value = true;
+          }
+          updateEncryptionDependencies();
+        }
+      }
+    } catch (ex) {
+      EnigmailLog.DEBUG(
+        "enigmailMessengerOverlay.js: Enigmail.msg.getMsgProperties: got exception '" +
+          ex.toString() +
+          "'\n"
+      );
+    }
+
+    if (EnigmailURIs.isEncryptedUri(msgUri)) {
+      properties |= EnigmailConstants.DECRYPTION_OKAY;
+    }
+
+    return properties;
+  },
+
+  getSavedDraftOptions(mimeMsg) {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.getSavedDraftOptions\n"
+    );
+    if (!mimeMsg || !mimeMsg.headers.has("x-enigmail-draft-status")) {
+      return false;
+    }
+
+    let stat = mimeMsg.headers.get("x-enigmail-draft-status").join("");
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.getSavedDraftOptions: draftStatus: " +
+        stat +
+        "\n"
+    );
+
+    if (stat.substr(0, 1) == "N") {
+      switch (Number(stat.substr(1, 1))) {
+        case 2:
+          // treat as "user decision to enable encryption, disable auto"
+          gUserTouchedSendEncrypted = true;
+          gSendEncrypted = true;
+          updateEncryptionDependencies();
+          break;
+        case 0:
+          // treat as "user decision to disable encryption, disable auto"
+          gUserTouchedSendEncrypted = true;
+          gSendEncrypted = false;
+          updateEncryptionDependencies();
+          break;
+        case 1:
+        default:
+          // treat as "no user decision, automatic mode"
+          break;
+      }
+
+      switch (Number(stat.substr(2, 1))) {
+        case 2:
+          gSendSigned = true;
+          gUserTouchedSendSigned = true;
+          break;
+        case 0:
+          gUserTouchedSendSigned = true;
+          gSendSigned = false;
+          break;
+        case 1:
+        default:
+          // treat as "no user decision, automatic mode, based on encryption or other prefs"
+          break;
+      }
+
+      switch (Number(stat.substr(3, 1))) {
+        case 1:
+          break;
+        case EnigmailConstants.ENIG_FORCE_SMIME:
+          // 3
+          gSelectedTechnologyIsPGP = false;
+          break;
+        case 2: // pgp/mime
+        case 0: // inline
+        default:
+          gSelectedTechnologyIsPGP = true;
+          break;
+      }
+
+      switch (Number(stat.substr(4, 1))) {
+        case 1:
+          gUserTouchedAttachMyPubKey = true;
+          gAttachMyPublicPGPKey = true;
+          break;
+        case 2:
+          gUserTouchedAttachMyPubKey = false;
+          break;
+        case 0:
+        default:
+          gUserTouchedAttachMyPubKey = true;
+          gAttachMyPublicPGPKey = false;
+          break;
+      }
+
+      switch (Number(stat.substr(4, 1))) {
+        case 1:
+          gUserTouchedAttachMyPubKey = true;
+          gAttachMyPublicPGPKey = true;
+          break;
+        case 2:
+          gUserTouchedAttachMyPubKey = false;
+          break;
+        case 0:
+        default:
+          gUserTouchedAttachMyPubKey = true;
+          gAttachMyPublicPGPKey = false;
+          break;
+      }
+
+      switch (Number(stat.substr(5, 1))) {
+        case 1:
+          gUserTouchedEncryptSubject = true;
+          gEncryptSubject = true;
+          break;
+        case 2:
+          gUserTouchedEncryptSubject = false;
+          break;
+        case 0:
+        default:
+          gUserTouchedEncryptSubject = true;
+          gEncryptSubject = false;
+          break;
+      }
+    }
+    //Enigmail.msg.setOwnKeyStatus();
+    return true;
+  },
+
+  composeOpen() {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.composeOpen\n"
+    );
+
+    let msgUri = null;
+    let msgHdr = null;
+
+    msgUri = this.getOriginalMsgUri();
+    if (msgUri) {
+      msgHdr = this.getMsgHdr(msgUri);
+      if (msgHdr) {
+        try {
+          let msgUrl = EnigmailMsgRead.getUrlFromUriSpec(msgUri);
+          EnigmailMime.getMimeTreeFromUrl(msgUrl.spec, false, mimeMsg => {
+            Enigmail.msg.continueComposeOpenWithMimeTree(
+              msgUri,
+              msgHdr,
+              mimeMsg
+            );
+          });
+        } catch (ex) {
+          EnigmailLog.DEBUG(
+            "enigmailMessengerOverlay.js: composeOpen: exception in getMimeTreeFromUrl: " +
+              ex +
+              "\n"
+          );
+          this.continueComposeOpenWithMimeTree(msgUri, msgHdr, null);
+        }
+      } else {
+        this.continueComposeOpenWithMimeTree(msgUri, msgHdr, null);
+      }
+    } else {
+      this.continueComposeOpenWithMimeTree(msgUri, msgHdr, null);
+    }
+  },
+
+  continueComposeOpenWithMimeTree(msgUri, msgHdr, mimeMsg) {
+    let selectedElement = document.activeElement;
+
+    let msgIsDraft =
+      gMsgCompose.type === Ci.nsIMsgCompType.Draft ||
+      gMsgCompose.type === Ci.nsIMsgCompType.Template;
+
+    if (!gSendEncrypted || msgIsDraft) {
+      let useEncryptionUnlessWeHaveDraftInfo = false;
+      let usePGPUnlessWeKnowOtherwise = false;
+      let useSMIMEUnlessWeKnowOtherwise = false;
+
+      if (msgIsDraft) {
+        let globalSaysItsEncrypted =
+          gEncryptedURIService &&
+          gMsgCompose.originalMsgURI &&
+          gEncryptedURIService.isEncrypted(gMsgCompose.originalMsgURI);
+
+        if (globalSaysItsEncrypted) {
+          useEncryptionUnlessWeHaveDraftInfo = true;
+          useSMIMEUnlessWeKnowOtherwise = true;
+        }
+      }
+
+      let obtainedDraftFlagsObj = { value: false };
+      if (msgUri) {
+        let msgFlags = this.getMsgProperties(
+          msgIsDraft,
+          msgUri,
+          msgHdr,
+          mimeMsg,
+          obtainedDraftFlagsObj
+        );
+        if (msgFlags & EnigmailConstants.DECRYPTION_OKAY) {
+          usePGPUnlessWeKnowOtherwise = true;
+          useSMIMEUnlessWeKnowOtherwise = false;
+        }
+        if (msgIsDraft && obtainedDraftFlagsObj.value) {
+          useEncryptionUnlessWeHaveDraftInfo = false;
+          usePGPUnlessWeKnowOtherwise = false;
+          useSMIMEUnlessWeKnowOtherwise = false;
+        }
+        if (!msgIsDraft) {
+          if (msgFlags & EnigmailConstants.DECRYPTION_OKAY) {
+            EnigmailLog.DEBUG(
+              "enigmailMsgComposeOverlay.js: Enigmail.msg.composeOpen: has encrypted originalMsgUri\n"
+            );
+            EnigmailLog.DEBUG(
+              "originalMsgURI=" + gMsgCompose.originalMsgURI + "\n"
+            );
+            gSendEncrypted = true;
+            updateEncryptionDependencies();
+            gSelectedTechnologyIsPGP = true;
+            useEncryptionUnlessWeHaveDraftInfo = false;
+            usePGPUnlessWeKnowOtherwise = false;
+            useSMIMEUnlessWeKnowOtherwise = false;
+          }
+        }
+        this.removeAttachedKey();
+      }
+
+      if (useEncryptionUnlessWeHaveDraftInfo) {
+        gSendEncrypted = true;
+        updateEncryptionDependencies();
+      }
+      if (gSendEncrypted && !obtainedDraftFlagsObj.value) {
+        gSendSigned = true;
+      }
+      if (usePGPUnlessWeKnowOtherwise) {
+        gSelectedTechnologyIsPGP = true;
+      } else if (useSMIMEUnlessWeKnowOtherwise) {
+        gSelectedTechnologyIsPGP = false;
+      }
+    }
+
+    // check for attached signature files and remove them
+    var bucketList = document.getElementById("attachmentBucket");
+    if (bucketList.hasChildNodes()) {
+      var node = bucketList.firstChild;
+      while (node) {
+        if (node.attachment.contentType == "application/pgp-signature") {
+          if (!this.findRelatedAttachment(bucketList, node)) {
+            // Let's release the attachment object held by the node else it won't go away until the window is destroyed
+            node.attachment = null;
+            node = bucketList.removeChild(node);
+          }
+        }
+        node = node.nextSibling;
+      }
+    }
+
+    // If we removed all the children and the bucket wasn't meant
+    // to stay open, close it.
+    if (!Services.prefs.getBoolPref("mail.compose.show_attachment_pane")) {
+      UpdateAttachmentBucket(bucketList.hasChildNodes());
+    }
+
+    this.warnUserIfSenderKeyExpired();
+
+    //this.processFinalState();
+    if (selectedElement) {
+      selectedElement.focus();
+    }
+  },
+
+  // check if an signature is related to another attachment
+  findRelatedAttachment(bucketList, node) {
+    // check if filename ends with .sig
+    if (node.attachment.name.search(/\.sig$/i) < 0) {
+      return null;
+    }
+
+    var relatedNode = bucketList.firstChild;
+    var findFile = node.attachment.name.toLowerCase();
+    var baseAttachment = null;
+    while (relatedNode) {
+      if (relatedNode.attachment.name.toLowerCase() + ".sig" == findFile) {
+        baseAttachment = relatedNode.attachment;
+      }
+      relatedNode = relatedNode.nextSibling;
+    }
+    return baseAttachment;
+  },
+
+  async attachOwnKey(id) {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.attachOwnKey: " + id + "\n"
+    );
+
+    if (
+      this.attachOwnKeyObj.attachedKey &&
+      this.attachOwnKeyObj.attachedKey != id
+    ) {
+      // remove attached key if user ID changed
+      this.removeAttachedKey();
+    }
+    let revokedIDs = EnigmailKeyRing.findRevokedPersonalKeysByEmail(
+      gCurrentIdentity.email
+    );
+
+    if (!this.attachOwnKeyObj.attachedKey) {
+      let hex = "0x" + id;
+      var attachedObj = await this.extractAndAttachKey(
+        hex,
+        revokedIDs,
+        gCurrentIdentity.email,
+        true,
+        true // one key plus revocations
+      );
+      if (attachedObj) {
+        this.attachOwnKeyObj.attachedObj = attachedObj;
+        this.attachOwnKeyObj.attachedKey = hex;
+      }
+    }
+  },
+
+  async extractAndAttachKey(
+    primaryId,
+    revokedIds,
+    emailForFilename,
+    warnOnError
+  ) {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.extractAndAttachKey: \n"
+    );
+    var enigmailSvc = EnigmailCore.getService(window);
+    if (!enigmailSvc) {
+      return null;
+    }
+
+    var tmpFile = Services.dirsvc.get("TmpD", Ci.nsIFile);
+    tmpFile.append("key.asc");
+    tmpFile.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, 0o600);
+
+    // save file
+    var exitCodeObj = {};
+    var errorMsgObj = {};
+
+    await EnigmailKeyRing.extractPublicKeys(
+      [], // full
+      [primaryId], // reduced
+      revokedIds, // minimal
+      tmpFile,
+      exitCodeObj,
+      errorMsgObj
+    );
+    if (exitCodeObj.value !== 0) {
+      if (warnOnError) {
+        EnigmailDialog.alert(window, errorMsgObj.value);
+      }
+      return null;
+    }
+
+    // create attachment
+    var tmpFileURI = Services.io.newFileURI(tmpFile);
+    var keyAttachment = Cc[
+      "@mozilla.org/messengercompose/attachment;1"
+    ].createInstance(Ci.nsIMsgAttachment);
+    keyAttachment.url = tmpFileURI.spec;
+    keyAttachment.name = primaryId.substr(-16, 16);
+    if (keyAttachment.name.search(/^0x/) < 0) {
+      keyAttachment.name = "0x" + keyAttachment.name;
+    }
+    let withRevSuffix = "";
+    if (revokedIds && revokedIds.length) {
+      withRevSuffix = "_and_old_rev";
+    }
+    keyAttachment.name =
+      "OpenPGP_" + keyAttachment.name + withRevSuffix + ".asc";
+    keyAttachment.temporary = true;
+    keyAttachment.contentType = "application/pgp-keys";
+    keyAttachment.size = tmpFile.fileSize;
+
+    if (
+      !gAttachmentBucket.itemChildren.find(
+        item => item.attachment.name == keyAttachment.name
+      )
+    ) {
+      await this.addAttachment(keyAttachment);
+    }
+
+    gContentChanged = true;
+    return keyAttachment;
+  },
+
+  addAttachment(attachment) {
+    return AddAttachments([attachment]);
+  },
+
+  removeAttachedKey() {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.removeAttachedKey: \n"
+    );
+
+    let bucketList = document.getElementById("attachmentBucket");
+    let node = bucketList.firstElementChild;
+
+    if (bucketList.itemCount && this.attachOwnKeyObj.attachedObj) {
+      // Undo attaching own key.
+      while (node) {
+        if (node.attachment.url == this.attachOwnKeyObj.attachedObj.url) {
+          node = bucketList.removeChild(node);
+          // Let's release the attachment object held by the node else it won't
+          // go away until the window is destroyed.
+          node.attachment = null;
+          this.attachOwnKeyObj.attachedObj = null;
+          this.attachOwnKeyObj.attachedKey = null;
+          node = null; // exit loop.
+        } else {
+          node = node.nextSibling;
+        }
+      }
+
+      // Update the visibility of the attachment pane.
+      UpdateAttachmentBucket(bucketList.itemCount);
+    }
+  },
+
+  getSecurityParams(compFields = null) {
+    if (!compFields) {
+      if (!gMsgCompose) {
+        return null;
+      }
+
+      compFields = gMsgCompose.compFields;
+    }
+
+    return compFields.composeSecure;
+  },
+
+  setSecurityParams(newSecurityParams) {
+    if (!gMsgCompose || !gMsgCompose.compFields) {
+      return;
+    }
+    gMsgCompose.compFields.composeSecure = newSecurityParams;
+  },
+
+  // Used on send failure, to reset the pre-send modifications
+  resetUpdatedFields() {
+    this.removeAttachedKey();
+
+    // reset subject
+    let p = Enigmail.msg.getSecurityParams();
+    if (p && EnigmailMimeEncrypt.isEnigmailCompField(p)) {
+      let si = p.wrappedJSObject;
+      if (si.originalSubject) {
+        gMsgCompose.compFields.subject = si.originalSubject;
+      }
+    }
+  },
+
+  replaceEditorText(text) {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.replaceEditorText:\n"
+    );
+
+    this.editorSelectAll();
+    // Overwrite text in clipboard for security
+    // (Otherwise plaintext will be available in the clipbaord)
+
+    if (this.editor.textLength > 0) {
+      this.editorInsertText("Enigmail");
+    } else {
+      this.editorInsertText(" ");
+    }
+
+    this.editorSelectAll();
+    this.editorInsertText(text);
+  },
+
+  /**
+   * Determine if Enigmail is enabled for the account
+   */
+
+  isEnigmailEnabledForIdentity() {
+    return !!gCurrentIdentity.getUnicharAttribute("openpgp_key_id");
+  },
+
+  /**
+   * Determine if Autocrypt is enabled for the account
+   */
+  isAutocryptEnabled() {
+    return false;
+    /*
+    if (Enigmail.msg.wasEnigmailEnabledForIdentity()) {
+      let srv = this.getCurrentIncomingServer();
+      return (srv ? srv.getBoolValue("enableAutocrypt") : false);
+    }
+
+    return false;
+    */
+  },
+
+  /*
+  doPgpButton: function(what) {
+    EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: Enigmail.msg.doPgpButton: what=" + what + "\n");
+
+    if (Enigmail.msg.wasEnigmailEnabledForIdentity()) {
+      EnigmailCore.getService(window); // try to access Enigmail to launch the wizard if needed
+    }
+
+    // ignore settings for this account?
+    try {
+      if (!this.isAnyEncryptionEnabled() && !this.getSigningEnabled()) {
+        return;
+      }
+    }
+    catch (ex) {}
+
+    switch (what) {
+      case 'sign':
+      case 'encrypt':
+        this.setSendMode(what);
+        break;
+
+      case 'trustKeys':
+        this.tempTrustAllKeys();
+        break;
+
+      case 'nothing':
+        break;
+
+      case 'displaySecuritySettings':
+        this.displaySecuritySettings();
+        break;
+      default:
+        this.displaySecuritySettings();
+    }
+
+  },
+  */
+
+  // changes the DEFAULT sendMode
+  // - also called internally for saved emails
+  /*
+  setSendMode: function(sendMode) {
+    EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: Enigmail.msg.setSendMode: sendMode=" + sendMode + "\n");
+    const SIGN = EnigmailConstants.SEND_SIGNED;
+    const ENCRYPT = EnigmailConstants.SEND_ENCRYPTED;
+
+    var origSendMode = this.sendMode;
+    switch (sendMode) {
+      case 'sign':
+        this.sendMode |= SIGN;
+        break;
+      case 'encrypt':
+        this.sendMode |= ENCRYPT;
+        break;
+      default:
+        EnigmailDialog.alert(window, "Enigmail.msg.setSendMode - unexpected value: " + sendMode);
+        break;
+    }
+    // sendMode changed ?
+    // - sign and send are internal initializations
+    if (!this.sendModeDirty && (this.sendMode != origSendMode) && sendMode != 'sign' && sendMode != 'encrypt') {
+      this.sendModeDirty = true;
+    }
+    this.processFinalState();
+  },
+  */
+
+  /**
+    key function to process the final encrypt/sign/pgpmime state from all settings
+   *
+    @param sendFlags: contains the sendFlags if the message is really processed. Optional, can be null
+      - uses as INPUT:
+         - this.sendMode
+         - this.encryptForced, this.encryptSigned
+      - uses as OUTPUT:
+         - this.statusEncrypt, this.statusSign
+
+    no return value
+  */
+  processFinalState(sendFlags) {},
+
+  /* check if encryption is possible (have keys for everyone or not)
+   */
+  async determineSendFlags() {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.focusChange: Enigmail.msg.determineSendFlags\n"
+    );
+
+    let detailsObj = {};
+    var compFields = gMsgCompose.compFields;
+
+    if (!Enigmail.msg.composeBodyReady) {
+      compFields = Cc[
+        "@mozilla.org/messengercompose/composefields;1"
+      ].createInstance(Ci.nsIMsgCompFields);
+    }
+    Recipients2CompFields(compFields);
+
+    // disabled, see bug 1625135
+    // gMsgCompose.expandMailingLists();
+
+    if (Enigmail.msg.isEnigmailEnabledForIdentity()) {
+      var toAddrList = [];
+      var arrLen = {};
+      var recList;
+      if (compFields.to) {
+        recList = compFields.splitRecipients(compFields.to, true, arrLen);
+        this.addRecipients(toAddrList, recList);
+      }
+      if (compFields.cc) {
+        recList = compFields.splitRecipients(compFields.cc, true, arrLen);
+        this.addRecipients(toAddrList, recList);
+      }
+      if (compFields.bcc) {
+        recList = compFields.splitRecipients(compFields.bcc, true, arrLen);
+        this.addRecipients(toAddrList, recList);
+      }
+
+      let addresses = [];
+      try {
+        addresses = EnigmailFuncs.stripEmail(toAddrList.join(", ")).split(",");
+      } catch (ex) {}
+
+      // Resolve all the email addresses if possible.
+      await EnigmailKeyRing.getValidKeysForAllRecipients(addresses, detailsObj);
+      //this.autoPgpEncryption = (validKeyList !== null);
+    }
+
+    // process and signal new resulting state
+    //this.processFinalState();
+
+    return detailsObj;
+  },
+
+  /*
+  displaySecuritySettings: function() {
+    EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: Enigmail.msg.displaySecuritySettings\n");
+
+    var inputObj = {
+      gSendEncrypted: gSendEncrypted,
+      gSendSigned: gSendSigned,
+      success: false,
+      resetDefaults: false
+    };
+    window.openDialog("chrome://openpgp/content/ui/enigmailEncryptionDlg.xhtml", "", "dialog,modal,centerscreen", inputObj);
+
+    if (!inputObj.success) return; // Cancel pressed
+
+    if (inputObj.resetDefaults) {
+      // reset everything to defaults
+      this.encryptForced = 1;
+      this.signForced = 1;
+    }
+    else {
+      if (this.signForced != inputObj.sign) {
+        this.dirty = 2;
+        this.signForced = inputObj.sign;
+      }
+
+        this.dirty = 2;
+
+      this.encryptForced = inputObj.encrypt;
+    }
+
+    //this.processFinalState();
+  },
+  */
+
+  addRecipients(toAddrList, recList) {
+    for (var i = 0; i < recList.length; i++) {
+      try {
+        toAddrList.push(
+          EnigmailFuncs.stripEmail(recList[i].replace(/[",]/g, ""))
+        );
+      } catch (ex) {}
+    }
+  },
+
+  setDraftStatus(doEncrypt) {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.setDraftStatus - enabling draft mode\n"
+    );
+
+    // Draft Status:
+    // N (for new style) plus 5 digits:
+    // 1: encryption
+    // 2: signing
+    // 3: PGP/MIME
+    // 4: attach own key
+    // 5: subject encrypted
+
+    var draftStatus = "N";
+
+    // Encryption:
+    // 2 -> required/enabled
+    // 0 -> disabled
+
+    if (!gUserTouchedSendEncrypted && !gIsRelatedToEncryptedOriginal) {
+      // After opening draft, it's allowed to use automatic decision.
+      draftStatus += "1";
+    } else {
+      // After opening draft, use the same state that is set now.
+      draftStatus += gSendEncrypted ? "2" : "0";
+    }
+
+    if (!gUserTouchedSendSigned) {
+      // After opening draft, it's allowed to use automatic decision.
+      draftStatus += "1";
+    } else {
+      // After opening draft, use the same state that is set now.
+      // Signing:
+      // 2 -> enabled
+      // 0 -> disabled
+      draftStatus += gSendSigned ? "2" : "0";
+    }
+
+    // MIME/technology
+    // ENIG_FORCE_SMIME == 3 -> S/MIME
+    // ENIG_FORCE_ALWAYS == 2 -> PGP/MIME
+    // 0 -> PGP inline
+    if (gSelectedTechnologyIsPGP) {
+      // inline signing currently not implemented
+      draftStatus += "2";
+    } else {
+      draftStatus += "3";
+    }
+
+    if (!gUserTouchedAttachMyPubKey) {
+      draftStatus += "2";
+    } else {
+      draftStatus += gAttachMyPublicPGPKey ? "1" : "0";
+    }
+
+    if (!gUserTouchedEncryptSubject) {
+      draftStatus += "2";
+    } else {
+      draftStatus += gSendEncrypted && gEncryptSubject ? "1" : "0";
+    }
+
+    this.setAdditionalHeader("X-Enigmail-Draft-Status", draftStatus);
+  },
+
+  getSenderUserId() {
+    let keyId = gCurrentIdentity?.getUnicharAttribute("openpgp_key_id");
+    return keyId ? "0x" + keyId : null;
+  },
+
+  /**
+   * Determine if S/MIME or OpenPGP should be used
+   *
+   * @param sendFlags: Number - input send flags.
+   *
+   * @return: Boolean:
+   *   1: use OpenPGP
+   *   0: use S/MIME
+   */
+  /*
+  preferPgpOverSmime: function(sendFlags) {
+
+    let si = Enigmail.msg.getSecurityParams(null);
+    let isSmime = !EnigmailMimeEncrypt.isEnigmailCompField(si);
+
+    if (isSmime &&
+      (sendFlags & (EnigmailConstants.SEND_SIGNED | EnigmailConstants.SEND_ENCRYPTED))) {
+
+      if (si.requireEncryptMessage || si.signMessage) {
+
+        if (sendFlags & EnigmailConstants.SAVE_MESSAGE) {
+          // use S/MIME if it's enabled for saving drafts
+          return 0;
+        }
+        else {
+          return this.mimePreferOpenPGP;
+        }
+      }
+    }
+
+    return 1;
+  },
+  */
+
+  /* Manage the wrapping of inline signed mails
+   *
+   * @wrapresultObj: Result:
+   * @wrapresultObj.cancelled, true if send operation is to be cancelled, else false
+   * @wrapresultObj.usePpgMime, true if message send option was changed to PGP/MIME, else false
+   */
+
+  async wrapInLine(wrapresultObj) {
+    EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: WrapInLine\n");
+    wrapresultObj.cancelled = false;
+    wrapresultObj.usePpgMime = false;
+    try {
+      const dce = Ci.nsIDocumentEncoder;
+      var editor = gMsgCompose.editor.QueryInterface(Ci.nsIEditorMailSupport);
+      var encoderFlags = dce.OutputFormatted | dce.OutputLFLineBreak;
+
+      var wrapWidth = Services.prefs.getIntPref("mailnews.wraplength");
+      if (wrapWidth > 0 && wrapWidth < 68 && editor.wrapWidth > 0) {
+        if (
+          EnigmailDialog.confirmDlg(
+            window,
+            await l10nOpenPGP.formatValue("minimal-line-wrapping", {
+              width: wrapWidth,
+            })
+          )
+        ) {
+          wrapWidth = 68;
+          Services.prefs.setIntPref("mailnews.wraplength", wrapWidth);
+        }
+      }
+
+      if (wrapWidth && editor.wrapWidth > 0) {
+        // First use standard editor wrap mechanism:
+        editor.wrapWidth = wrapWidth - 2;
+        editor.rewrap(true);
+        editor.wrapWidth = wrapWidth;
+
+        // Now get plaintext from editor
+        var wrapText = this.editorGetContentAs("text/plain", encoderFlags);
+
+        // split the lines into an array
+        wrapText = wrapText.split(/\r\n|\r|\n/g);
+
+        var i = 0;
+        var excess = 0;
+        // inspect all lines of mail text to detect if we still have excessive lines which the "standard" editor wrapper leaves
+        for (i = 0; i < wrapText.length; i++) {
+          if (wrapText[i].length > wrapWidth) {
+            excess = 1;
+          }
+        }
+
+        if (excess) {
+          EnigmailLog.DEBUG(
+            "enigmailMsgComposeOverlay.js: Excess lines detected\n"
+          );
+          var resultObj = {};
+          window.openDialog(
+            "chrome://openpgp/content/ui/enigmailWrapSelection.xhtml",
+            "",
+            "dialog,modal,centerscreen",
+            resultObj
+          );
+          try {
+            if (resultObj.cancelled) {
+              // cancel pressed -> do not send, return instead.
+              wrapresultObj.cancelled = true;
+              return;
+            }
+          } catch (ex) {
+            // cancel pressed -> do not send, return instead.
+            wrapresultObj.cancelled = true;
+            return;
+          }
+
+          var limitedLine = "";
+          var restOfLine = "";
+
+          var WrapSelect = resultObj.Select;
+          switch (WrapSelect) {
+            case "0": // Selection: Force rewrap
+              for (i = 0; i < wrapText.length; i++) {
+                if (wrapText[i].length > wrapWidth) {
+                  // If the current line is too long, limit it hard to wrapWidth and insert the rest as the next line into wrapText array
+                  limitedLine = wrapText[i].slice(0, wrapWidth);
+                  restOfLine = wrapText[i].slice(wrapWidth);
+
+                  // We should add quotes at the beginning of "restOfLine", if limitedLine is a quoted line
+                  // However, this would be purely academic, because limitedLine will always be "standard"-wrapped
+                  // by the editor-rewrapper at the space between quote sign (>) and the quoted text.
+
+                  wrapText.splice(i, 1, limitedLine, restOfLine);
+                }
+              }
+              break;
+            case "1": // Selection: Send as is
+              break;
+            case "2": // Selection: Use MIME
+              wrapresultObj.usePpgMime = true;
+              break;
+            case "3": // Selection: Edit manually -> do not send, return instead.
+              wrapresultObj.cancelled = true;
+              return;
+          } //switch
+        }
+        // Now join all lines together again and feed it back into the compose editor.
+        var newtext = wrapText.join("\n");
+        this.replaceEditorText(newtext);
+      }
+    } catch (ex) {
+      EnigmailLog.DEBUG(
+        "enigmailMsgComposeOverlay.js: Exception while wrapping=" + ex + "\n"
+      );
+    }
+  },
+
+  // Save draft message. We do not want most of the other processing for encrypted mails here...
+  async saveDraftMessage(senderKeyIsGnuPG) {
+    EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: saveDraftMessage()\n");
+
+    // If we have an encryption key configured, then encrypt saved
+    // drafts by default, as a precaution. This is independent from the
+    // final decision of sending the message encrypted or not.
+    // However, we allow the user to disable encrypted drafts.
+    let doEncrypt =
+      Enigmail.msg.isEnigmailEnabledForIdentity() &&
+      gCurrentIdentity.autoEncryptDrafts;
+
+    this.setDraftStatus(doEncrypt);
+
+    if (!doEncrypt) {
+      try {
+        let p = Enigmail.msg.getSecurityParams();
+        if (EnigmailMimeEncrypt.isEnigmailCompField(p)) {
+          p.wrappedJSObject.sendFlags = 0;
+        }
+      } catch (ex) {
+        console.debug(ex);
+      }
+
+      return true;
+    }
+
+    let sendFlags =
+      EnigmailConstants.SEND_PGP_MIME |
+      EnigmailConstants.SEND_ENCRYPTED |
+      EnigmailConstants.SEND_ENCRYPT_TO_SELF |
+      EnigmailConstants.SAVE_MESSAGE;
+
+    if (gEncryptSubject) {
+      sendFlags |= EnigmailConstants.ENCRYPT_SUBJECT;
+    }
+    if (senderKeyIsGnuPG) {
+      sendFlags |= EnigmailConstants.SEND_SENDER_KEY_EXTERNAL;
+    }
+
+    let fromAddr = this.getSenderUserId();
+
+    let enigmailSvc = EnigmailCore.getService(window);
+    if (!enigmailSvc) {
+      return true;
+    }
+
+    let senderKeyUsable = await EnigmailEncryption.determineOwnKeyUsability(
+      sendFlags,
+      fromAddr,
+      senderKeyIsGnuPG
+    );
+    if (senderKeyUsable.errorMsg) {
+      let fullAlert = await document.l10n.formatValue(
+        "msg-compose-cannot-save-draft"
+      );
+      fullAlert += " - " + senderKeyUsable.errorMsg;
+      EnigmailDialog.alert(window, fullAlert);
+      return false;
+    }
+
+    //if (this.preferPgpOverSmime(sendFlags) === 0) return true; // use S/MIME
+
+    let secInfo;
+
+    let param = Enigmail.msg.getSecurityParams();
+
+    if (EnigmailMimeEncrypt.isEnigmailCompField(param)) {
+      secInfo = param.wrappedJSObject;
+    } else {
+      try {
+        secInfo = EnigmailMimeEncrypt.createMimeEncrypt(param);
+        if (secInfo) {
+          Enigmail.msg.setSecurityParams(secInfo);
+        }
+      } catch (ex) {
+        EnigmailLog.writeException(
+          "enigmailMsgComposeOverlay.js: Enigmail.msg.saveDraftMessage",
+          ex
+        );
+        return false;
+      }
+    }
+
+    secInfo.sendFlags = sendFlags;
+    secInfo.UIFlags = 0;
+    secInfo.senderEmailAddr = fromAddr;
+    secInfo.recipients = "";
+    secInfo.bccRecipients = "";
+    secInfo.originalSubject = gMsgCompose.compFields.subject;
+    this.dirty = 1;
+
+    if (sendFlags & EnigmailConstants.ENCRYPT_SUBJECT) {
+      gMsgCompose.compFields.subject = "";
+    }
+
+    return true;
+  },
+
+  createEnigmailSecurityFields(oldSecurityInfo) {
+    let newSecurityInfo = EnigmailMimeEncrypt.createMimeEncrypt(
+      Enigmail.msg.getSecurityParams()
+    );
+
+    if (!newSecurityInfo) {
+      throw Components.Exception("", Cr.NS_ERROR_FAILURE);
+    }
+
+    Enigmail.msg.setSecurityParams(newSecurityInfo);
+  },
+
+  /*
+  sendSmimeEncrypted: function(msgSendType, sendFlags, isOffline) {
+    let recList;
+    let toAddrList = [];
+    let arrLen = {};
+    const DeliverMode = Ci.nsIMsgCompDeliverMode;
+
+    switch (msgSendType) {
+      case DeliverMode.SaveAsDraft:
+      case DeliverMode.SaveAsTemplate:
+      case DeliverMode.AutoSaveAsDraft:
+        break;
+      default:
+        if (gAttachMyPublicPGPKey) {
+          await this.attachOwnKey();
+          Attachments2CompFields(gMsgCompose.compFields); // update list of attachments
+        }
+    }
+
+    gSMFields.signMessage = (sendFlags & EnigmailConstants.SEND_SIGNED ? true : false);
+    gSMFields.requireEncryptMessage = (sendFlags & EnigmailConstants.SEND_ENCRYPTED ? true : false);
+
+    Enigmail.msg.setSecurityParams(gSMFields);
+
+    let conf = this.isSendConfirmationRequired(sendFlags);
+
+    if (conf === null) return false;
+    if (conf) {
+      // confirm before send requested
+      let msgCompFields = gMsgCompose.compFields;
+      let splitRecipients = msgCompFields.splitRecipients;
+
+      if (msgCompFields.to.length > 0) {
+        recList = splitRecipients(msgCompFields.to, true, arrLen);
+        this.addRecipients(toAddrList, recList);
+      }
+
+      if (msgCompFields.cc.length > 0) {
+        recList = splitRecipients(msgCompFields.cc, true, arrLen);
+        this.addRecipients(toAddrList, recList);
+      }
+
+      switch (msgSendType) {
+        case DeliverMode.SaveAsDraft:
+        case DeliverMode.SaveAsTemplate:
+        case DeliverMode.AutoSaveAsDraft:
+          break;
+        default:
+          if (!this.confirmBeforeSend(toAddrList.join(", "), "", sendFlags, isOffline)) {
+            return false;
+          }
+      }
+    }
+
+    return true;
+  },
+  */
+
+  getEncryptionFlags() {
+    let f = 0;
+
+    if (gSendEncrypted) {
+      f |= EnigmailConstants.SEND_ENCRYPTED;
+    } else {
+      f &= ~EnigmailConstants.SEND_ENCRYPTED;
+    }
+
+    if (gSendSigned) {
+      f |= EnigmailConstants.SEND_SIGNED;
+    } else {
+      f &= ~EnigmailConstants.SEND_SIGNED;
+    }
+
+    if (gSendEncrypted && gSendSigned) {
+      if (Services.prefs.getBoolPref("mail.openpgp.separate_mime_layers")) {
+        f |= EnigmailConstants.SEND_TWO_MIME_LAYERS;
+      }
+    }
+
+    if (gSendEncrypted && gEncryptSubject) {
+      f |= EnigmailConstants.ENCRYPT_SUBJECT;
+    }
+
+    return f;
+  },
+
+  resetDirty() {
+    let newSecurityInfo = null;
+
+    if (this.dirty) {
+      // make sure the sendFlags are reset before the message is processed
+      // (it may have been set by a previously cancelled send operation!)
+
+      let si = Enigmail.msg.getSecurityParams();
+
+      if (EnigmailMimeEncrypt.isEnigmailCompField(si)) {
+        si.sendFlags = 0;
+        si.originalSubject = gMsgCompose.compFields.subject;
+      } else {
+        try {
+          newSecurityInfo = EnigmailMimeEncrypt.createMimeEncrypt(si);
+          if (newSecurityInfo) {
+            newSecurityInfo.sendFlags = 0;
+            newSecurityInfo.originalSubject = gMsgCompose.compFields.subject;
+
+            Enigmail.msg.setSecurityParams(newSecurityInfo);
+          }
+        } catch (ex) {
+          EnigmailLog.writeException(
+            "enigmailMsgComposeOverlay.js: Enigmail.msg.resetDirty",
+            ex
+          );
+        }
+      }
+    }
+
+    return newSecurityInfo;
+  },
+
+  async determineMsgRecipients(sendFlags) {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.determineMsgRecipients: currentId=" +
+        gCurrentIdentity +
+        ", " +
+        gCurrentIdentity.email +
+        "\n"
+    );
+
+    let fromAddr = gCurrentIdentity.email;
+    let toAddrList = [];
+    let recList;
+    let bccAddrList = [];
+    let arrLen = {};
+    let splitRecipients;
+
+    if (!Enigmail.msg.isEnigmailEnabledForIdentity()) {
+      return true;
+    }
+
+    let optSendFlags = 0;
+    let msgCompFields = gMsgCompose.compFields;
+    let newsgroups = msgCompFields.newsgroups;
+
+    if (Services.prefs.getBoolPref("temp.openpgp.encryptToSelf")) {
+      optSendFlags |= EnigmailConstants.SEND_ENCRYPT_TO_SELF;
+    }
+
+    sendFlags |= optSendFlags;
+
+    var userIdValue = this.getSenderUserId();
+    if (userIdValue) {
+      fromAddr = userIdValue;
+    }
+
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.determineMsgRecipients:gMsgCompose=" +
+        gMsgCompose +
+        "\n"
+    );
+
+    splitRecipients = msgCompFields.splitRecipients;
+
+    if (msgCompFields.to.length > 0) {
+      recList = splitRecipients(msgCompFields.to, true, arrLen);
+      this.addRecipients(toAddrList, recList);
+    }
+
+    if (msgCompFields.cc.length > 0) {
+      recList = splitRecipients(msgCompFields.cc, true, arrLen);
+      this.addRecipients(toAddrList, recList);
+    }
+
+    // We allow sending to BCC recipients, we assume the user interface
+    // has warned the user that there is no privacy of BCC recipients.
+    if (msgCompFields.bcc.length > 0) {
+      recList = splitRecipients(msgCompFields.bcc, true, arrLen);
+      this.addRecipients(bccAddrList, recList);
+    }
+
+    if (newsgroups) {
+      toAddrList.push(newsgroups);
+
+      if (sendFlags & EnigmailConstants.SEND_ENCRYPTED) {
+        if (!Services.prefs.getBoolPref("temp.openpgp.encryptToNews")) {
+          document.l10n.formatValue("sending-news").then(value => {
+            EnigmailDialog.alert(window, value);
+          });
+          return false;
+        } else if (
+          !EnigmailDialog.confirmBoolPref(
+            window,
+            await l10nOpenPGP.formatValue("send-to-news-warning"),
+            "temp.openpgp.warnOnSendingNewsgroups",
+            await l10nOpenPGP.formatValue("msg-compose-button-send")
+          )
+        ) {
+          return false;
+        }
+      }
+    }
+
+    return {
+      sendFlags,
+      optSendFlags,
+      fromAddr,
+      toAddrList,
+      bccAddrList,
+    };
+  },
+
+  prepareSending(sendFlags, toAddrStr, gpgKeys, isOffline) {
+    // perform confirmation dialog if necessary/requested
+    if (
+      sendFlags & EnigmailConstants.SEND_WITH_CHECK &&
+      !this.messageSendCheck()
+    ) {
+      // Abort send
+      if (!this.processed) {
+        this.removeAttachedKey();
+      }
+
+      return false;
+    }
+
+    return true;
+  },
+
+  prepareSecurityInfo(
+    sendFlags,
+    uiFlags,
+    rcpt,
+    newSecurityInfo,
+    autocryptGossipHeaders
+  ) {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.prepareSecurityInfo(): Using PGP/MIME, flags=" +
+        sendFlags +
+        "\n"
+    );
+
+    let oldSecurityInfo = Enigmail.msg.getSecurityParams();
+
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.prepareSecurityInfo: oldSecurityInfo = " +
+        oldSecurityInfo +
+        "\n"
+    );
+
+    if (!newSecurityInfo) {
+      this.createEnigmailSecurityFields(Enigmail.msg.getSecurityParams());
+      newSecurityInfo = Enigmail.msg.getSecurityParams().wrappedJSObject;
+    }
+
+    newSecurityInfo.originalSubject = gMsgCompose.compFields.subject;
+    newSecurityInfo.originalReferences = gMsgCompose.compFields.references;
+
+    if (sendFlags & EnigmailConstants.SEND_ENCRYPTED) {
+      if (sendFlags & EnigmailConstants.ENCRYPT_SUBJECT) {
+        gMsgCompose.compFields.subject = "";
+      }
+
+      if (Services.prefs.getBoolPref("temp.openpgp.protectReferencesHdr")) {
+        gMsgCompose.compFields.references = "";
+      }
+    }
+
+    newSecurityInfo.sendFlags = sendFlags;
+    newSecurityInfo.UIFlags = uiFlags;
+    newSecurityInfo.senderEmailAddr = rcpt.fromAddr;
+    newSecurityInfo.bccRecipients = rcpt.bccAddrStr;
+    newSecurityInfo.autocryptGossipHeaders = autocryptGossipHeaders;
+
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.prepareSecurityInfo: securityInfo = " +
+        newSecurityInfo +
+        "\n"
+    );
+    return newSecurityInfo;
+  },
+
+  async prepareSendMsg(msgSendType) {
+    // msgSendType: value from nsIMsgCompDeliverMode
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.prepareSendMsg: msgSendType=" +
+        msgSendType +
+        ", gSendSigned=" +
+        gSendSigned +
+        ", gSendEncrypted=" +
+        gSendEncrypted +
+        "\n"
+    );
+
+    const SIGN = EnigmailConstants.SEND_SIGNED;
+    const ENCRYPT = EnigmailConstants.SEND_ENCRYPTED;
+    const DeliverMode = Ci.nsIMsgCompDeliverMode;
+
+    var ioService = Services.io;
+    // EnigSend: Handle both plain and encrypted messages below
+    var isOffline = ioService && ioService.offline;
+
+    let senderKeyIsGnuPG =
+      Services.prefs.getBoolPref("mail.openpgp.allow_external_gnupg") &&
+      gCurrentIdentity.getBoolAttribute("is_gnupg_key_id");
+
+    let sendFlags = this.getEncryptionFlags();
+
+    switch (msgSendType) {
+      case DeliverMode.SaveAsDraft:
+      case DeliverMode.SaveAsTemplate:
+      case DeliverMode.AutoSaveAsDraft:
+        EnigmailLog.DEBUG(
+          "enigmailMsgComposeOverlay.js: Enigmail.msg.prepareSendMsg: detected save draft\n"
+        );
+
+        // saving drafts is simpler and works differently than the rest of Enigmail.
+        // All rules except account-settings are ignored.
+        return this.saveDraftMessage(senderKeyIsGnuPG);
+    }
+
+    this.unsetAdditionalHeader("x-enigmail-draft-status");
+
+    let msgCompFields = gMsgCompose.compFields;
+    let newsgroups = msgCompFields.newsgroups; // Check if sending to any newsgroups
+
+    if (
+      msgCompFields.to === "" &&
+      msgCompFields.cc === "" &&
+      msgCompFields.bcc === "" &&
+      newsgroups === ""
+    ) {
+      // don't attempt to send message if no recipient specified
+      var bundle = document.getElementById("bundle_composeMsgs");
+      EnigmailDialog.alert(window, bundle.getString("12511"));
+      return false;
+    }
+
+    let senderKeyId = gCurrentIdentity.getUnicharAttribute("openpgp_key_id");
+
+    if ((gSendEncrypted || gSendSigned) && !senderKeyId) {
+      let msgId = gSendEncrypted
+        ? "cannot-send-enc-because-no-own-key"
+        : "cannot-send-sig-because-no-own-key";
+      let fullAlert = await document.l10n.formatValue(msgId, {
+        key: gCurrentIdentity.email,
+      });
+      EnigmailDialog.alert(window, fullAlert);
+      return false;
+    }
+
+    if (senderKeyIsGnuPG) {
+      sendFlags |= EnigmailConstants.SEND_SENDER_KEY_EXTERNAL;
+    }
+
+    if ((gSendEncrypted || gSendSigned) && senderKeyId) {
+      let senderKeyUsable = await EnigmailEncryption.determineOwnKeyUsability(
+        sendFlags,
+        senderKeyId,
+        senderKeyIsGnuPG
+      );
+      if (senderKeyUsable.errorMsg) {
+        let fullAlert = await document.l10n.formatValue(
+          "cannot-use-own-key-because",
+          {
+            problem: senderKeyUsable.errorMsg,
+          }
+        );
+        EnigmailDialog.alert(window, fullAlert);
+        return false;
+      }
+    }
+
+    let cannotEncryptMissingInfo = false;
+    if (gSendEncrypted) {
+      let canEncryptDetails = await this.determineSendFlags();
+      if (canEncryptDetails.errArray.length != 0) {
+        cannotEncryptMissingInfo = true;
+      }
+    }
+
+    if (gWindowLocked) {
+      EnigmailDialog.alert(
+        window,
+        await document.l10n.formatValue("window-locked")
+      );
+      return false;
+    }
+
+    let newSecurityInfo = this.resetDirty();
+    this.dirty = 1;
+
+    try {
+      this.modifiedAttach = null;
+
+      // fill fromAddr, toAddrList, bcc etc
+      let rcpt = await this.determineMsgRecipients(sendFlags);
+      if (typeof rcpt === "boolean") {
+        return rcpt;
+      }
+      sendFlags = rcpt.sendFlags;
+
+      if (cannotEncryptMissingInfo) {
+        showMessageComposeSecurityStatus(true);
+        return false;
+      }
+
+      if (this.sendPgpMime) {
+        // Use PGP/MIME
+        sendFlags |= EnigmailConstants.SEND_PGP_MIME;
+      }
+
+      let toAddrStr = rcpt.toAddrList.join(", ");
+      let bccAddrStr = rcpt.bccAddrList.join(", ");
+
+      if (gAttachMyPublicPGPKey) {
+        await this.attachOwnKey(senderKeyId);
+      }
+
+      let autocryptGossipHeaders = await this.getAutocryptGossip();
+
+      /*
+      if (this.preferPgpOverSmime(sendFlags) === 0) {
+        // use S/MIME
+        Attachments2CompFields(gMsgCompose.compFields); // update list of attachments
+        sendFlags = 0;
+        return true;
+      }
+      */
+
+      var usingPGPMime =
+        sendFlags & EnigmailConstants.SEND_PGP_MIME &&
+        sendFlags & (ENCRYPT | SIGN);
+
+      // ----------------------- Rewrapping code, taken from function "encryptInline"
+
+      if (sendFlags & ENCRYPT && !usingPGPMime) {
+        throw new Error("Sending encrypted inline not supported!");
+      }
+      if (sendFlags & SIGN && !usingPGPMime && gMsgCompose.composeHTML) {
+        throw new Error(
+          "Sending signed inline only supported for plain text composition!"
+        );
+      }
+
+      // Check wrapping, if sign only and inline and plaintext
+      if (
+        sendFlags & SIGN &&
+        !(sendFlags & ENCRYPT) &&
+        !usingPGPMime &&
+        !gMsgCompose.composeHTML
+      ) {
+        var wrapresultObj = {};
+
+        await this.wrapInLine(wrapresultObj);
+
+        if (wrapresultObj.usePpgMime) {
+          sendFlags |= EnigmailConstants.SEND_PGP_MIME;
+          usingPGPMime = EnigmailConstants.SEND_PGP_MIME;
+        }
+        if (wrapresultObj.cancelled) {
+          return false;
+        }
+      }
+
+      var uiFlags = EnigmailConstants.UI_INTERACTIVE;
+
+      if (usingPGPMime) {
+        uiFlags |= EnigmailConstants.UI_PGP_MIME;
+      }
+
+      if (sendFlags & (ENCRYPT | SIGN) && usingPGPMime) {
+        // Use PGP/MIME
+        newSecurityInfo = this.prepareSecurityInfo(
+          sendFlags,
+          uiFlags,
+          rcpt,
+          newSecurityInfo,
+          autocryptGossipHeaders
+        );
+        newSecurityInfo.recipients = toAddrStr;
+        newSecurityInfo.bccRecipients = bccAddrStr;
+      } else if (!this.processed && sendFlags & (ENCRYPT | SIGN)) {
+        // use inline PGP
+
+        let sendInfo = {
+          sendFlags,
+          fromAddr: rcpt.fromAddr,
+          toAddr: toAddrStr,
+          bccAddr: bccAddrStr,
+          uiFlags,
+          bucketList: document.getElementById("attachmentBucket"),
+        };
+
+        if (!(await this.signInline(sendInfo))) {
+          return false;
+        }
+      }
+
+      // update the list of attachments
+      Attachments2CompFields(msgCompFields);
+
+      if (
+        !this.prepareSending(
+          sendFlags,
+          rcpt.toAddrList.join(", "),
+          toAddrStr + ", " + bccAddrStr,
+          isOffline
+        )
+      ) {
+        return false;
+      }
+
+      if (msgCompFields.characterSet != "ISO-2022-JP") {
+        if (
+          (usingPGPMime && sendFlags & (ENCRYPT | SIGN)) ||
+          (!usingPGPMime && sendFlags & ENCRYPT)
+        ) {
+          try {
+            // make sure plaintext is not changed to 7bit
+            if (typeof msgCompFields.forceMsgEncoding == "boolean") {
+              msgCompFields.forceMsgEncoding = true;
+              EnigmailLog.DEBUG(
+                "enigmailMsgComposeOverlay.js: Enigmail.msg.prepareSendMsg: enabled forceMsgEncoding\n"
+              );
+            }
+          } catch (ex) {
+            console.debug(ex);
+          }
+        }
+      }
+    } catch (ex) {
+      EnigmailLog.writeException(
+        "enigmailMsgComposeOverlay.js: Enigmail.msg.prepareSendMsg",
+        ex
+      );
+      return false;
+    }
+
+    // The encryption process for PGP/MIME messages follows "here". It's
+    // called automatically from nsMsgCompose->sendMsg().
+    // registration for this is done in core.jsm: startup()
+
+    return true;
+  },
+
+  async signInline(sendInfo) {
+    // sign message using inline-PGP
+
+    if (sendInfo.sendFlags & ENCRYPT) {
+      throw new Error("Encryption not supported in inline messages!");
+    }
+    if (gMsgCompose.composeHTML) {
+      throw new Error(
+        "Signing inline only supported for plain text composition!"
+      );
+    }
+
+    const dce = Ci.nsIDocumentEncoder;
+    const SIGN = EnigmailConstants.SEND_SIGNED;
+    const ENCRYPT = EnigmailConstants.SEND_ENCRYPTED;
+
+    var enigmailSvc = EnigmailCore.getService(window);
+    if (!enigmailSvc) {
+      return false;
+    }
+
+    if (Services.prefs.getBoolPref("mail.strictly_mime")) {
+      if (
+        EnigmailDialog.confirmIntPref(
+          window,
+          await l10nOpenPGP.formatValue("quoted-printable-warn"),
+          "temp.openpgp.quotedPrintableWarn"
+        )
+      ) {
+        Services.prefs.setBoolPref("mail.strictly_mime", false);
+      }
+    }
+
+    var sendFlowed = Services.prefs.getBoolPref(
+      "mailnews.send_plaintext_flowed"
+    );
+    var encoderFlags = dce.OutputFormatted | dce.OutputLFLineBreak;
+
+    // plaintext: Wrapping code has been moved to superordinate function prepareSendMsg to enable interactive format switch
+
+    var exitCodeObj = {};
+    var statusFlagsObj = {};
+    var errorMsgObj = {};
+    var exitCode;
+
+    // Get plain text
+    // (Do we need to set the nsIDocumentEncoder.* flags?)
+    var origText = this.editorGetContentAs("text/plain", encoderFlags);
+    if (!origText) {
+      origText = "";
+    }
+
+    if (origText.length > 0) {
+      // Sign/encrypt body text
+
+      var escText = origText; // Copy plain text for possible escaping
+
+      if (sendFlowed) {
+        // Prevent space stuffing a la RFC 2646 (format=flowed).
+
+        //EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: escText["+encoderFlags+"] = '"+escText+"'\n");
+
+        escText = escText.replace(/^From /gm, "~From ");
+        escText = escText.replace(/^>/gm, "|");
+        escText = escText.replace(/^[ \t]+$/gm, "");
+        escText = escText.replace(/^ /gm, "~ ");
+
+        //EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: escText = '"+escText+"'\n");
+        // Replace plain text and get it again
+        this.replaceEditorText(escText);
+
+        escText = this.editorGetContentAs("text/plain", encoderFlags);
+      }
+
+      // Replace plain text and get it again (to avoid linewrapping problems)
+      this.replaceEditorText(escText);
+
+      escText = this.editorGetContentAs("text/plain", encoderFlags);
+
+      //EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: escText["+encoderFlags+"] = '"+escText+"'\n");
+
+      var charset = this.editorGetCharset();
+      EnigmailLog.DEBUG(
+        "enigmailMsgComposeOverlay.js: Enigmail.msg.signInline: charset=" +
+          charset +
+          "\n"
+      );
+
+      // Encode plaintext to charset from unicode
+      var plainText = EnigmailData.convertFromUnicode(escText, charset);
+
+      // this will sign, not encrypt
+      var cipherText = EnigmailEncryption.encryptMessage(
+        window,
+        sendInfo.uiFlags,
+        plainText,
+        sendInfo.fromAddr,
+        sendInfo.toAddr,
+        sendInfo.bccAddr,
+        sendInfo.sendFlags,
+        exitCodeObj,
+        statusFlagsObj,
+        errorMsgObj
+      );
+
+      exitCode = exitCodeObj.value;
+
+      //EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: cipherText = '"+cipherText+"'\n");
+      if (cipherText && exitCode === 0) {
+        // Encryption/signing succeeded; overwrite plaintext
+
+        cipherText = cipherText.replace(/\r\n/g, "\n");
+
+        // Decode ciphertext from charset to unicode and overwrite
+        this.replaceEditorText(
+          EnigmailData.convertToUnicode(cipherText, charset)
+        );
+
+        // Save original text (for undo)
+        this.processed = {
+          origText,
+          charset,
+        };
+      } else {
+        // Restore original text
+        this.replaceEditorText(origText);
+
+        if (sendInfo.sendFlags & SIGN) {
+          // Encryption/signing failed
+
+          this.sendAborted(window, errorMsgObj);
+          return false;
+        }
+      }
+    }
+
+    return true;
+  },
+
+  async sendAborted(window, errorMsgObj) {
+    if (errorMsgObj && errorMsgObj.value) {
+      var txt = errorMsgObj.value;
+      var txtLines = txt.split(/\r?\n/);
+      var errorMsg = "";
+      for (var i = 0; i < txtLines.length; ++i) {
+        var line = txtLines[i];
+        var tokens = line.split(/ /);
+        // process most important business reasons for invalid recipient (and sender) errors:
+        if (
+          tokens.length == 3 &&
+          (tokens[0] == "INV_RECP" || tokens[0] == "INV_SGNR")
+        ) {
+          var reason = tokens[1];
+          var key = tokens[2];
+          if (reason == "10") {
+            errorMsg +=
+              (await document.l10n.formatValue("key-not-trusted", { key })) +
+              "\n";
+          } else if (reason == "1") {
+            errorMsg +=
+              (await document.l10n.formatValue("key-not-found", { key })) +
+              "\n";
+          } else if (reason == "4") {
+            errorMsg +=
+              (await document.l10n.formatValue("key-revoked", { key })) + "\n";
+          } else if (reason == "5") {
+            errorMsg +=
+              (await document.l10n.formatValue("key-expired", { key })) + "\n";
+          }
+        }
+      }
+      if (errorMsg !== "") {
+        txt = errorMsg + "\n" + txt;
+      }
+      EnigmailDialog.info(
+        window,
+        (await document.l10n.formatValue("send-aborted")) + "\n" + txt
+      );
+    } else {
+      let [title, message] = await document.l10n.formatValues([
+        { id: "send-aborted" },
+        { id: "msg-compose-internal-error" },
+      ]);
+      EnigmailDialog.info(window, title + "\n" + message);
+    }
+  },
+
+  messageSendCheck() {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.messageSendCheck\n"
+    );
+
+    try {
+      var warn = Services.prefs.getBoolPref("mail.warn_on_send_accel_key");
+
+      if (warn) {
+        var checkValue = {
+          value: false,
+        };
+        var bundle = document.getElementById("bundle_composeMsgs");
+        var buttonPressed = EnigmailDialog.getPromptSvc().confirmEx(
+          window,
+          bundle.getString("sendMessageCheckWindowTitle"),
+          bundle.getString("sendMessageCheckLabel"),
+          EnigmailDialog.getPromptSvc().BUTTON_TITLE_IS_STRING *
+            EnigmailDialog.getPromptSvc().BUTTON_POS_0 +
+            EnigmailDialog.getPromptSvc().BUTTON_TITLE_CANCEL *
+              EnigmailDialog.getPromptSvc().BUTTON_POS_1,
+          bundle.getString("sendMessageCheckSendButtonLabel"),
+          null,
+          null,
+          bundle.getString("CheckMsg"),
+          checkValue
+        );
+        if (buttonPressed !== 0) {
+          return false;
+        }
+        if (checkValue.value) {
+          Services.prefs.setBoolPref("mail.warn_on_send_accel_key", false);
+        }
+      }
+    } catch (ex) {}
+
+    return true;
+  },
+
+  /**
+   * set non-standard message Header
+   * (depending on TB version)
+   *
+   * hdr: String: header type (e.g. X-Enigmail-Version)
+   * val: String: header data (e.g. 1.2.3.4)
+   */
+  setAdditionalHeader(hdr, val) {
+    if ("otherRandomHeaders" in gMsgCompose.compFields) {
+      // TB <= 36
+      gMsgCompose.compFields.otherRandomHeaders += hdr + ": " + val + "\r\n";
+    } else {
+      gMsgCompose.compFields.setHeader(hdr, val);
+    }
+  },
+
+  unsetAdditionalHeader(hdr) {
+    gMsgCompose.compFields.deleteHeader(hdr);
+  },
+
+  // called just before sending
+  modifyCompFields() {
+    try {
+      if (
+        !Enigmail.msg.isEnigmailEnabledForIdentity() ||
+        !gCurrentIdentity.sendAutocryptHeaders
+      ) {
+        return;
+      }
+      if ((gSendSigned || gSendEncrypted) && !gSelectedTechnologyIsPGP) {
+        // If we're sending an S/MIME message, we don't want to send
+        // the OpenPGP autocrypt header.
+        return;
+      }
+      this.setAutocryptHeader();
+    } catch (ex) {
+      EnigmailLog.writeException(
+        "enigmailMsgComposeOverlay.js: Enigmail.msg.modifyCompFields",
+        ex
+      );
+    }
+  },
+
+  getCurrentIncomingServer() {
+    let currentAccountKey = getCurrentAccountKey();
+    let account = MailServices.accounts.getAccount(currentAccountKey);
+
+    return account.incomingServer; /* returns nsIMsgIncomingServer */
+  },
+
+  /**
+   * Obtain all Autocrypt-Gossip header lines that should be included in
+   * the outgoing message, excluding the sender's (from) email address.
+   * If there is just one recipient (ignoring the from address),
+   * no headers will be returned.
+   *
+   * @returns {string} - All header lines including line endings,
+   *                     could be the empty string.
+   */
+  async getAutocryptGossip() {
+    let fromMail = EnigmailFuncs.stripEmail(gMsgCompose.compFields.from);
+    let replyToMail = EnigmailFuncs.stripEmail(gMsgCompose.compFields.replyTo);
+
+    let optionalReplyToGossip = "";
+    if (replyToMail != fromMail) {
+      optionalReplyToGossip = ", " + gMsgCompose.compFields.replyTo;
+    }
+
+    // Assumes that extractHeaderAddressMailboxes will separate all
+    // entries with the sequence comma-space.
+    let allEmails = MailServices.headerParser
+      .extractHeaderAddressMailboxes(
+        gMsgCompose.compFields.to +
+          ", " +
+          gMsgCompose.compFields.cc +
+          optionalReplyToGossip
+      )
+      .split(/, /);
+
+    // Use a Set to ensure we have each address only once.
+    let uniqueEmails = new Set();
+    for (let e of allEmails) {
+      uniqueEmails.add(e);
+    }
+
+    // Potentially to/cc might contain the sender email address.
+    // Remove it, if it's there.
+    uniqueEmails.delete(fromMail);
+
+    // When sending to yourself, only, allEmails.length is 0.
+    // When sending to exactly one other person (with or without
+    // "from" in to/cc), then allEmails.length is 1. In that scenario,
+    // that recipient obviously already has their own key, and doesn't
+    // need the gossip. The sender's key will be included in the
+    // separate autocrypt (non-gossip) header.
+
+    if (uniqueEmails.size < 2) {
+      return "";
+    }
+
+    let gossip = "";
+    for (const email of uniqueEmails) {
+      let k = await EnigmailKeyRing.getRecipientAutocryptKeyForEmail(email);
+      if (!k) {
+        continue;
+      }
+      let keyData =
+        " " + k.replace(/(.{72})/g, "$1\r\n ").replace(/\r\n $/, "");
+      gossip +=
+        "Autocrypt-Gossip: addr=" + email + "; keydata=\r\n" + keyData + "\r\n";
+    }
+
+    return gossip;
+  },
+
+  setAutocryptHeader() {
+    let senderKeyId = gCurrentIdentity.getUnicharAttribute("openpgp_key_id");
+    if (!senderKeyId) {
+      return;
+    }
+
+    let fromMail = gCurrentIdentity.email;
+    try {
+      fromMail = EnigmailFuncs.stripEmail(gMsgCompose.compFields.from);
+    } catch (ex) {}
+
+    let keyData = EnigmailKeyRing.getAutocryptKey("0x" + senderKeyId, fromMail);
+
+    if (keyData) {
+      keyData =
+        " " + keyData.replace(/(.{72})/g, "$1\r\n ").replace(/\r\n $/, "");
+      this.setAdditionalHeader(
+        "Autocrypt",
+        "addr=" + fromMail + "; keydata=\r\n" + keyData
+      );
+    }
+  },
+
+  /**
+   * Handle the 'compose-send-message' event from TB
+   */
+  sendMessageListener(event) {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.sendMessageListener\n"
+    );
+
+    let msgcomposeWindow = document.getElementById("msgcomposeWindow");
+    let sendMsgType = Number(msgcomposeWindow.getAttribute("msgtype"));
+
+    if (
+      !(
+        this.sendProcess &&
+        sendMsgType == Ci.nsIMsgCompDeliverMode.AutoSaveAsDraft
+      )
+    ) {
+      this.modifyCompFields();
+      if (!gSelectedTechnologyIsPGP) {
+        return;
+      }
+
+      this.sendProcess = true;
+      //let bc = document.getElementById("enigmail-bc-sendprocess");
+
+      try {
+        const cApi = EnigmailCryptoAPI();
+        let encryptResult = cApi.sync(this.prepareSendMsg(sendMsgType));
+        if (!encryptResult) {
+          this.resetUpdatedFields();
+          event.preventDefault();
+          event.stopPropagation();
+        }
+      } catch (ex) {
+        console.error("GenericSendMessage FAILED: " + ex);
+        this.resetUpdatedFields();
+        event.preventDefault();
+        event.stopPropagation();
+      }
+    } else {
+      EnigmailLog.DEBUG(
+        "enigmailMsgComposeOverlay.js: Enigmail.msg.sendMessageListener: sending in progress - autosave aborted\n"
+      );
+      event.preventDefault();
+      event.stopPropagation();
+    }
+    this.sendProcess = false;
+  },
+
+  async decryptQuote(interactive) {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.decryptQuote: " +
+        interactive +
+        "\n"
+    );
+
+    if (gWindowLocked || this.processed) {
+      return;
+    }
+
+    var enigmailSvc = EnigmailCore.getService(window);
+    if (!enigmailSvc) {
+      return;
+    }
+
+    const dce = Ci.nsIDocumentEncoder;
+    var encoderFlags = dce.OutputFormatted | dce.OutputLFLineBreak;
+
+    var docText = this.editorGetContentAs("text/plain", encoderFlags);
+
+    var blockBegin = docText.indexOf("-----BEGIN PGP ");
+    if (blockBegin < 0) {
+      return;
+    }
+
+    // Determine indentation string
+    var indentBegin = docText.substr(0, blockBegin).lastIndexOf("\n");
+    var indentStr = docText.substring(indentBegin + 1, blockBegin);
+
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.decryptQuote: indentStr='" +
+        indentStr +
+        "'\n"
+    );
+
+    var beginIndexObj = {};
+    var endIndexObj = {};
+    var indentStrObj = {};
+    var blockType = EnigmailArmor.locateArmoredBlock(
+      docText,
+      0,
+      indentStr,
+      beginIndexObj,
+      endIndexObj,
+      indentStrObj
+    );
+    if (blockType != "MESSAGE" && blockType != "SIGNED MESSAGE") {
+      return;
+    }
+
+    var beginIndex = beginIndexObj.value;
+    var endIndex = endIndexObj.value;
+
+    var head = docText.substr(0, beginIndex);
+    var tail = docText.substr(endIndex + 1);
+
+    var pgpBlock = docText.substr(beginIndex, endIndex - beginIndex + 1);
+    var indentRegexp;
+
+    if (indentStr) {
+      if (indentStr == "> ") {
+        // replace ">> " with "> > " to allow correct quoting
+        pgpBlock = pgpBlock.replace(/^>>/gm, "> >");
+      }
+
+      // Escape regex chars.
+      let escapedIndent1 = indentStr.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
+
+      // Delete indentation
+      indentRegexp = new RegExp("^" + escapedIndent1, "gm");
+
+      pgpBlock = pgpBlock.replace(indentRegexp, "");
+      //tail     =     tail.replace(indentRegexp, "");
+
+      if (indentStr.match(/[ \t]*$/)) {
+        indentStr = indentStr.replace(/[ \t]*$/gm, "");
+        // Escape regex chars.
+        let escapedIndent2 = indentStr.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
+        indentRegexp = new RegExp("^" + escapedIndent2 + "$", "gm");
+
+        pgpBlock = pgpBlock.replace(indentRegexp, "");
+      }
+
+      // Handle blank indented lines
+      pgpBlock = pgpBlock.replace(/^[ \t]*>[ \t]*$/gm, "");
+      //tail     =     tail.replace(/^[ \t]*>[ \t]*$/g, "");
+
+      // Trim leading space in tail
+      tail = tail.replace(/^\s*\n/m, "\n");
+    }
+
+    if (tail.search(/\S/) < 0) {
+      // No non-space characters in tail; delete it
+      tail = "";
+    }
+
+    //EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: Enigmail.msg.decryptQuote: pgpBlock='"+pgpBlock+"'\n");
+
+    var charset = this.editorGetCharset();
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.decryptQuote: charset=" +
+        charset +
+        "\n"
+    );
+
+    // Encode ciphertext from unicode to charset
+    var cipherText = EnigmailData.convertFromUnicode(pgpBlock, charset);
+
+    // Decrypt message
+    var signatureObj = {};
+    signatureObj.value = "";
+    var exitCodeObj = {};
+    var statusFlagsObj = {};
+    var userIdObj = {};
+    var keyIdObj = {};
+    var sigDetailsObj = {};
+    var errorMsgObj = {};
+    var blockSeparationObj = {};
+    var encToDetailsObj = {};
+
+    var uiFlags = EnigmailConstants.UI_UNVERIFIED_ENC_OK;
+
+    var plainText = "";
+
+    plainText = EnigmailDecryption.decryptMessage(
+      window,
+      uiFlags,
+      cipherText,
+      null, // date
+      signatureObj,
+      exitCodeObj,
+      statusFlagsObj,
+      keyIdObj,
+      userIdObj,
+      sigDetailsObj,
+      errorMsgObj,
+      blockSeparationObj,
+      encToDetailsObj
+    );
+    // Decode plaintext from charset to unicode
+    plainText = EnigmailData.convertToUnicode(plainText, charset).replace(
+      /\r\n/g,
+      "\n"
+    );
+
+    //if (Services.prefs.getBoolPref("temp.openpgp.keepSettingsForReply")) {
+    if (statusFlagsObj.value & EnigmailConstants.DECRYPTION_OKAY) {
+      //this.setSendMode('encrypt');
+
+      // TODO : Check, when is this code reached?
+      // automatic enabling encryption currently depends on
+      // adjustSignEncryptAfterIdentityChanged to be always reached
+      gIsRelatedToEncryptedOriginal = true;
+      gSendEncrypted = true;
+      updateEncryptionDependencies();
+    }
+    //}
+
+    var exitCode = exitCodeObj.value;
+
+    if (exitCode !== 0) {
+      // Error processing
+      var errorMsg = errorMsgObj.value;
+
+      var statusLines = errorMsg ? errorMsg.split(/\r?\n/) : [];
+
+      var displayMsg;
+      if (statusLines && statusLines.length) {
+        // Display only first ten lines of error message
+        while (statusLines.length > 10) {
+          statusLines.pop();
+        }
+
+        displayMsg = statusLines.join("\n");
+
+        if (interactive) {
+          EnigmailDialog.info(window, displayMsg);
+        }
+      }
+    }
+
+    if (blockType == "MESSAGE" && exitCode === 0 && plainText.length === 0) {
+      plainText = " ";
+    }
+
+    if (!plainText) {
+      if (blockType != "SIGNED MESSAGE") {
+        return;
+      }
+
+      // Extract text portion of clearsign block
+      plainText = EnigmailArmor.extractSignaturePart(
+        pgpBlock,
+        EnigmailConstants.SIGNATURE_TEXT
+      );
+    }
+
+    const nsIMsgCompType = Ci.nsIMsgCompType;
+    var doubleDashSeparator = Services.prefs.getBoolPref(
+      "temp.openpgp.doubleDashSeparator"
+    );
+    if (
+      gMsgCompose.type != nsIMsgCompType.Template &&
+      gMsgCompose.type != nsIMsgCompType.Draft &&
+      doubleDashSeparator
+    ) {
+      var signOffset = plainText.search(/[\r\n]-- +[\r\n]/);
+
+      if (signOffset < 0 && blockType == "SIGNED MESSAGE") {
+        signOffset = plainText.search(/[\r\n]--[\r\n]/);
+      }
+
+      if (signOffset > 0) {
+        // Strip signature portion of quoted message
+        plainText = plainText.substr(0, signOffset + 1);
+      }
+    }
+
+    this.editorSelectAll();
+
+    //EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: Enigmail.msg.decryptQuote: plainText='"+plainText+"'\n");
+
+    if (head) {
+      this.editorInsertText(head);
+    }
+
+    var quoteElement;
+
+    if (indentStr) {
+      quoteElement = this.editorInsertAsQuotation(plainText);
+    } else {
+      this.editorInsertText(plainText);
+    }
+
+    if (tail) {
+      this.editorInsertText(tail);
+    }
+
+    if (statusFlagsObj.value & EnigmailConstants.DECRYPTION_OKAY) {
+      this.checkInlinePgpReply(head, tail);
+    }
+
+    if (interactive) {
+      return;
+    }
+
+    // Position cursor
+    var replyOnTop = gCurrentIdentity.replyOnTop;
+
+    if (!indentStr || !quoteElement) {
+      replyOnTop = 1;
+    }
+
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.decryptQuote: replyOnTop=" +
+        replyOnTop +
+        ", quoteElement=" +
+        quoteElement +
+        "\n"
+    );
+
+    if (this.editor.selectionController) {
+      var selection = this.editor.selectionController;
+      selection.completeMove(false, false); // go to start;
+
+      switch (replyOnTop) {
+        case 0:
+          // Position after quote
+          this.editor.endOfDocument();
+          if (tail) {
+            for (let cPos = 0; cPos < tail.length; cPos++) {
+              selection.characterMove(false, false); // move backwards
+            }
+          }
+          break;
+
+        case 2:
+          // Select quote
+
+          if (head) {
+            for (let cPos = 0; cPos < head.length; cPos++) {
+              selection.characterMove(true, false);
+            }
+          }
+          selection.completeMove(true, true);
+          if (tail) {
+            for (let cPos = 0; cPos < tail.length; cPos++) {
+              selection.characterMove(false, true); // move backwards
+            }
+          }
+          break;
+
+        default:
+          // Position at beginning of document
+
+          if (this.editor) {
+            this.editor.beginningOfDocument();
+          }
+      }
+
+      this.editor.selectionController.scrollSelectionIntoView(
+        Ci.nsISelectionController.SELECTION_NORMAL,
+        Ci.nsISelectionController.SELECTION_ANCHOR_REGION,
+        true
+      );
+    }
+
+    //this.processFinalState();
+  },
+
+  checkInlinePgpReply(head, tail) {
+    const CT = Ci.nsIMsgCompType;
+    let hLines = head.search(/[^\s>]/) < 0 ? 0 : 1;
+
+    if (hLines > 0) {
+      switch (gMsgCompose.type) {
+        case CT.Reply:
+        case CT.ReplyAll:
+        case CT.ReplyToSender:
+        case CT.ReplyToGroup:
+        case CT.ReplyToSenderAndGroup:
+        case CT.ReplyToList: {
+          // if head contains at only a few line of text, we assume it's the
+          // header above the quote (e.g. XYZ wrote:) and the user's signature
+
+          let h = head.split(/\r?\n/);
+          hLines = -1;
+
+          for (let i = 0; i < h.length; i++) {
+            if (h[i].search(/[^\s>]/) >= 0) {
+              hLines++;
+            }
+          }
+        }
+      }
+    }
+
+    if (
+      hLines > 0 &&
+      (!gCurrentIdentity.sigOnReply || gCurrentIdentity.sigBottom)
+    ) {
+      // display warning if no signature on top of message
+      this.displayPartialEncryptedWarning();
+    } else if (hLines > 10) {
+      this.displayPartialEncryptedWarning();
+    } else if (
+      tail.search(/[^\s>]/) >= 0 &&
+      !(gCurrentIdentity.sigOnReply && gCurrentIdentity.sigBottom)
+    ) {
+      // display warning if no signature below message
+      this.displayPartialEncryptedWarning();
+    }
+  },
+
+  editorInsertText(plainText) {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.editorInsertText\n"
+    );
+    if (this.editor) {
+      var mailEditor;
+      try {
+        mailEditor = this.editor.QueryInterface(Ci.nsIEditorMailSupport);
+        mailEditor.insertTextWithQuotations(plainText);
+      } catch (ex) {
+        EnigmailLog.DEBUG(
+          "enigmailMsgComposeOverlay.js: Enigmail.msg.editorInsertText: no mail editor\n"
+        );
+        this.editor.insertText(plainText);
+      }
+    }
+  },
+
+  editorInsertAsQuotation(plainText) {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.editorInsertAsQuotation\n"
+    );
+    if (this.editor) {
+      var mailEditor;
+      try {
+        mailEditor = this.editor.QueryInterface(Ci.nsIEditorMailSupport);
+      } catch (ex) {}
+
+      if (!mailEditor) {
+        return 0;
+      }
+
+      EnigmailLog.DEBUG(
+        "enigmailMsgComposeOverlay.js: Enigmail.msg.editorInsertAsQuotation: mailEditor=" +
+          mailEditor +
+          "\n"
+      );
+
+      mailEditor.insertAsCitedQuotation(plainText, "", false);
+
+      return 1;
+    }
+    return 0;
+  },
+
+  isSenderKeyExpired() {
+    const senderKeyId = this.getSenderUserId();
+
+    if (senderKeyId) {
+      const key = EnigmailKeyRing.getKeyById(senderKeyId);
+      return key?.expiryTime && Math.round(Date.now() / 1000) > key.expiryTime;
+    }
+
+    return false;
+  },
+
+  removeNotificationIfPresent(name) {
+    const notif = gComposeNotification.getNotificationWithValue(name);
+    if (notif) {
+      gComposeNotification.removeNotification(notif);
+    }
+  },
+
+  warnUserThatSenderKeyExpired() {
+    const label = {
+      "l10n-id": "openpgp-selection-status-error",
+      "l10n-args": { key: this.getSenderUserId() },
+    };
+
+    const buttons = [
+      {
+        "l10n-id": "settings-context-open-account-settings-item2",
+        callback() {
+          MsgAccountManager(
+            "am-e2e.xhtml",
+            MailServices.accounts.getServersForIdentity(gCurrentIdentity)[0]
+          );
+          Services.wm.getMostRecentWindow("mail:3pane")?.focus();
+          return true;
+        },
+      },
+    ];
+
+    gComposeNotification.appendNotification(
+      "openpgpSenderKeyExpired",
+      {
+        label,
+        priority: gComposeNotification.PRIORITY_WARNING_MEDIUM,
+      },
+      buttons
+    );
+  },
+
+  warnUserIfSenderKeyExpired() {
+    if (!this.isSenderKeyExpired()) {
+      this.removeNotificationIfPresent("openpgpSenderKeyExpired");
+      return;
+    }
+
+    this.warnUserThatSenderKeyExpired();
+  },
+
+  /**
+   * Display a notification to the user at the bottom of the window
+   *
+   * @param priority: Number - Priority of the message [1 = high (error) ... 3 = low (info)]
+   * @param msgText: String - Text to be displayed in notification bar
+   * @param messageId: String - Unique message type identification
+   * @param detailsText: String - optional text to be displayed by clicking on "Details" button.
+   *                              if null or "", then the Detail button will no be displayed.
+   */
+  async notifyUser(priority, msgText, messageId, detailsText) {
+    let prio;
+
+    switch (priority) {
+      case 1:
+        prio = gComposeNotification.PRIORITY_CRITICAL_MEDIUM;
+        break;
+      case 3:
+        prio = gComposeNotification.PRIORITY_INFO_MEDIUM;
+        break;
+      default:
+        prio = gComposeNotification.PRIORITY_WARNING_MEDIUM;
+    }
+
+    let buttonArr = [];
+
+    if (detailsText && detailsText.length > 0) {
+      let [accessKey, label] = await document.l10n.formatValues([
+        { id: "msg-compose-details-button-access-key" },
+        { id: "msg-compose-details-button-label" },
+      ]);
+
+      buttonArr.push({
+        accessKey,
+        label,
+        callback(aNotificationBar, aButton) {
+          EnigmailDialog.info(window, detailsText);
+        },
+      });
+    }
+    gComposeNotification.appendNotification(
+      messageId,
+      {
+        label: msgText,
+        priority: prio,
+      },
+      buttonArr
+    );
+  },
+
+  /**
+   * Display a warning message if we are replying to or forwarding
+   * a partially decrypted inline-PGP email
+   */
+  async displayPartialEncryptedWarning() {
+    let [msgLong, msgShort] = await document.l10n.formatValues([
+      { id: "msg-compose-partially-encrypted-inlinePGP" },
+      { id: "msg-compose-partially-encrypted-short" },
+    ]);
+
+    this.notifyUser(1, msgShort, "notifyPartialDecrypt", msgLong);
+  },
+
+  editorSelectAll() {
+    if (this.editor) {
+      this.editor.selectAll();
+    }
+  },
+
+  editorGetCharset() {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.editorGetCharset\n"
+    );
+    return this.editor.documentCharacterSet;
+  },
+
+  editorGetContentAs(mimeType, flags) {
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: Enigmail.msg.editorGetContentAs\n"
+    );
+    if (this.editor) {
+      return this.editor.outputToString(mimeType, flags);
+    }
+
+    return null;
+  },
+
+  async focusChange() {
+    // call original TB function
+    CommandUpdate_MsgCompose();
+
+    var focusedWindow = top.document.commandDispatcher.focusedWindow;
+
+    // we're just setting focus to where it was before
+    if (focusedWindow == Enigmail.msg.lastFocusedWindow) {
+      // skip
+      return;
+    }
+
+    Enigmail.msg.lastFocusedWindow = focusedWindow;
+  },
+
+  /**
+   * Merge multiple  Re: Re: into one Re: in message subject
+   */
+  fixMessageSubject() {
+    let subjElem = document.getElementById("msgSubject");
+    if (subjElem) {
+      let r = subjElem.value.replace(/^(Re: )+/, "Re: ");
+      if (r !== subjElem.value) {
+        subjElem.value = r;
+        if (typeof subjElem.oninput === "function") {
+          subjElem.oninput();
+        }
+      }
+    }
+  },
+};
+
+Enigmail.composeStateListener = {
+  NotifyComposeFieldsReady() {
+    // Note: NotifyComposeFieldsReady is only called when a new window is created (i.e. not in case a window object is reused).
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: ECSL.NotifyComposeFieldsReady\n"
+    );
+
+    try {
+      Enigmail.msg.editor = gMsgCompose.editor.QueryInterface(Ci.nsIEditor);
+    } catch (ex) {}
+
+    if (!Enigmail.msg.editor) {
+      return;
+    }
+
+    Enigmail.msg.fixMessageSubject();
+
+    function enigDocStateListener() {}
+
+    enigDocStateListener.prototype = {
+      QueryInterface: ChromeUtils.generateQI(["nsIDocumentStateListener"]),
+
+      NotifyDocumentWillBeDestroyed() {
+        EnigmailLog.DEBUG(
+          "enigmailMsgComposeOverlay.js: EDSL.enigDocStateListener.NotifyDocumentWillBeDestroyed\n"
+        );
+      },
+
+      NotifyDocumentStateChanged(nowDirty) {
+        EnigmailLog.DEBUG(
+          "enigmailMsgComposeOverlay.js: EDSL.enigDocStateListener.NotifyDocumentStateChanged\n"
+        );
+      },
+    };
+
+    var docStateListener = new enigDocStateListener();
+
+    Enigmail.msg.editor.addDocumentStateListener(docStateListener);
+  },
+
+  ComposeProcessDone(aResult) {
+    // Note: called after a mail was sent (or saved)
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: ECSL.ComposeProcessDone: " + aResult + "\n"
+    );
+
+    if (aResult != Cr.NS_OK) {
+      Enigmail.msg.removeAttachedKey();
+    }
+
+    // ensure that securityInfo is set back to S/MIME flags (especially required if draft was saved)
+    if (gSMFields) {
+      Enigmail.msg.setSecurityParams(gSMFields);
+    }
+  },
+
+  NotifyComposeBodyReady() {
+    EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: ECSL.ComposeBodyReady\n");
+
+    var isEmpty, isEditable;
+
+    isEmpty = Enigmail.msg.editor.documentIsEmpty;
+    isEditable = Enigmail.msg.editor.isDocumentEditable;
+    Enigmail.msg.composeBodyReady = true;
+
+    EnigmailLog.DEBUG(
+      "enigmailMsgComposeOverlay.js: ECSL.ComposeBodyReady: isEmpty=" +
+        isEmpty +
+        ", isEditable=" +
+        isEditable +
+        "\n"
+    );
+
+    /*
+    if (Enigmail.msg.disableSmime) {
+      if (gMsgCompose && gMsgCompose.compFields && Enigmail.msg.getSecurityParams()) {
+        let si = Enigmail.msg.getSecurityParams(null);
+        si.signMessage = false;
+        si.requireEncryptMessage = false;
+      }
+      else {
+        EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: ECSL.ComposeBodyReady: could not disable S/MIME\n");
+      }
+    }
+    */
+
+    if (isEditable && !isEmpty) {
+      if (!Enigmail.msg.timeoutId && !Enigmail.msg.dirty) {
+        Enigmail.msg.timeoutId = setTimeout(function () {
+          Enigmail.msg.decryptQuote(false);
+        }, 0);
+      }
+    }
+
+    // This must be called by the last registered NotifyComposeBodyReady()
+    // stateListener. We need this in order to know when the entire init
+    // sequence of the composeWindow has finished, so the WebExtension compose
+    // API can do its final modifications.
+    window.composeEditorReady = true;
+    window.dispatchEvent(new CustomEvent("compose-editor-ready"));
+  },
+
+  SaveInFolderDone(folderURI) {
+    //EnigmailLog.DEBUG("enigmailMsgComposeOverlay.js: ECSL.SaveInFolderDone\n");
+  },
+};
+
+window.addEventListener(
+  "load",
+  Enigmail.msg.composeStartup.bind(Enigmail.msg),
+  {
+    capture: false,
+    once: true,
+  }
+);
+
+window.addEventListener("compose-window-unload", () => {
+  if (gMsgCompose) {
+    gMsgCompose.UnregisterStateListener(Enigmail.composeStateListener);
+  }
+});