diff options
Diffstat (limited to 'comm/chat/modules/OTRUI.sys.mjs')
| -rw-r--r-- | comm/chat/modules/OTRUI.sys.mjs | 998 |
1 files changed, 998 insertions, 0 deletions
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(); + }, +}; |