JitsiAuthConnection -> authenticateAndUpgradeRole

With JitsiAuthConnection the API consumer has to:
1. JitsiConference.createAuthenticationConnection,
2. JitsiAuthConnecition.authenticateAndUpgradeRole,
3. Wait on the Promise of 2,
4. Maybe cancel the JitsiAuthConnection of 1.

With authenticateAndUpgradeRole the API consumer has to:
1. JitsiConference.authenticateAndUpgradeRole,
2. Wait on the thenableWithCancel of 1.
3. Maybe cancel the thenableWithCancel of 1.

JitsiAuthConnection.js

@@ -1,141 +0,0 @@
-import * as JitsiConnectionEvents from './JitsiConnectionEvents';
-import XMPP from './modules/xmpp/xmpp';
-
-/**
- * Class creates separate XMPP connection and tries to connect using given
- * credentials. Once connected will contact Jicofo to obtain and store session
- * ID which is then used by the parent conference to upgrade user's role to
- * moderator. It's also used to join the conference when starting from anonymous
- * domain and only authenticated users are allowed to create new rooms.
- */
-export default class JitsiAuthConnection {
-    /**
-     * Creates new <tt>JitsiAuthConnection</tt> for given conference.
-     * @param {JitsiConference} conference
-     * @constructor
-     */
-    constructor(conference) {
-        this.conference = conference;
-        this.xmpp = new XMPP(conference.connection.options);
-        this.canceled = false;
-        this._promise = null;
-    }
-
-    /**
-     * @typedef {Object} UpgradeRoleError
-     * @property {JitsiConnectionErrors} [connectionError] - One of
-     * {@link JitsiConnectionErrors} which occurred when trying to connect to
-     * the XMPP server.
-     * @property {String} [authenticationError] - One of XMPP error conditions
-     * returned by Jicofo on authentication attempt. See
-     * https://xmpp.org/rfcs/rfc3920.html#streams-error.
-     * @property {String} [message] - More details about the error.
-     *
-     * NOTE If neither one of the errors is present it means that the operation
-     * has been canceled.
-     */
-    /**
-     * Connects to the XMPP server using given credentials and contacts Jicofo
-     * in order to obtain a session ID (which is then stored in the local
-     * storage). User's role of the parent conference will be upgraded to
-     * moderator (by Jicofo).
-     *
-     * @param {Object} options
-     * @param {string} options.id - XMPP user's ID (user@xmpp-server.com).
-     * @param {string} options.password - User's password used to login.
-     * @param {string} [options.roomPassword] - Room password required to join
-     * the MUC room.
-     * @param {Function} [options.onLoginSuccessful] - Callback called when
-     * logging into the XMPP server was successful. The next step will be to
-     * obtain new session ID from Jicofo and join the MUC using it which will
-     * effectively upgrade the current user's role to moderator.
-     *
-     * @returns {Promise} Resolved in case the authentication was successful
-     * and the session Id has been stored in the settings. Will be rejected with
-     * {@link UpgradeRoleError} which will have either 'connectionError'
-     * or 'authenticationError' field set depending on which of the steps has
-     * failed. If {@link cancel} is called before the operation is finished then
-     * the promise will be resolved with an empty object (no error set).
-     */
-    authenticateAndUpgradeRole({ id,
-                                 password,
-                                 roomPassword,
-                                 onLoginSuccessful }) {
-        if (this._promise) {
-            return this._promise;
-        }
-        this._promise = new Promise((resolve, reject) => {
-            const connectionEstablished = () => {
-                if (this.canceled) {
-                    return;
-                }
-
-                // Let the caller know that the XMPP login was successful
-                onLoginSuccessful && onLoginSuccessful();
-
-                // Now authenticate with Jicofo and get new session ID
-                this.room
-                    = this.xmpp.createRoom(
-                        this.conference.options.name,
-                        this.conference.options.config);
-                this.room.moderator.authenticate()
-                    .then(() => {
-                        if (this.canceled) {
-                            return;
-                        }
-
-                        this.xmpp.disconnect();
-
-                        // At this point we should have new session ID stored in
-                        // the settings. Jicofo will allow to join the room.
-                        this.conference.join(roomPassword);
-
-                        resolve();
-                    })
-                    .catch(error => {
-                        this.xmpp.disconnect();
-
-                        reject({
-                            authenticationError: error.error,
-                            message: error.message
-                        });
-                    });
-            };
-
-            this.xmpp.addListener(
-                JitsiConnectionEvents.CONNECTION_ESTABLISHED,
-                connectionEstablished);
-            this.xmpp.addListener(
-                JitsiConnectionEvents.CONNECTION_FAILED,
-                (error, msg) => reject({
-                    connectionError: error,
-                    message: msg
-                }));
-            this.xmpp.addListener(
-                JitsiConnectionEvents.CONNECTION_DISCONNECTED,
-                () => {
-                    if (this.canceled) {
-                        reject({ });
-                    }
-                });
-
-            if (this.canceled) {
-                reject({ });
-            } else {
-                this.xmpp.connect(id, password);
-            }
-        });
-
-        return this._promise;
-    }
-
-    /**
-     * Cancels the authentication if it's currently in progress. The promise
-     * returned by {@link authenticateAndUpgradeRole} will be rejected with
-     * an empty object (none of the error fields set).
-     */
-    cancel() {
-        this.canceled = true;
-        this.xmpp.disconnect();
-    }
-}

JitsiConference.js

@@ -6,7 +6,7 @@ import ConnectionQuality from './modules/connectivity/ConnectionQuality';
 import { getLogger } from 'jitsi-meet-logger';
 import GlobalOnErrorHandler from './modules/util/GlobalOnErrorHandler';
 import EventEmitter from 'events';
-import JitsiAuthConnection from './JitsiAuthConnection';
+import authenticateAndUpgradeRole from './authenticateAndUpgradeRole';
 import * as JitsiConferenceErrors from './JitsiConferenceErrors';
 import JitsiConferenceEventManager from './JitsiConferenceEventManager';
 import * as JitsiConferenceEvents from './JitsiConferenceEvents';
@@ -305,13 +305,15 @@ JitsiConference.prototype.join = function(password) {
 };
 
 /**
- * Creates new {@link JitsiAuthConnection} which authenticates and upgrades
- * the user's role to moderator.
+ * Authenticates and upgrades the role of the local participant/user.
  *
- * @returns {JitsiAuthConnection}
+ * @returns {Object} A <tt>thenable</tt> which (1) settles when the process of
+ * authenticating and upgrading the role of the local participant/user finishes
+ * and (2) has a <tt>cancel</tt> method that allows the caller to interrupt the
+ * process.
  */
-JitsiConference.prototype.createAuthenticationConnection = function() {
-    return new JitsiAuthConnection(this);
+JitsiConference.prototype.authenticateAndUpgradeRole = function(...args) {
+    return authenticateAndUpgradeRole.apply(this, args);
 };
 
 /**

authenticateAndUpgradeRole.js

@@ -0,0 +1,149 @@
+import {
+    CONNECTION_DISCONNECTED,
+    CONNECTION_ESTABLISHED,
+    CONNECTION_FAILED
+} from './JitsiConnectionEvents';
+import XMPP from './modules/xmpp/xmpp';
+
+/**
+ * @typedef {Object} UpgradeRoleError
+ *
+ * @property {JitsiConnectionErrors} [connectionError] - One of
+ * {@link JitsiConnectionErrors} which occurred when trying to connect to the
+ * XMPP server.
+ * @property {String} [authenticationError] - One of XMPP error conditions
+ * returned by Jicofo on authentication attempt. See
+ * {@link https://xmpp.org/rfcs/rfc3920.html#streams-error}.
+ * @property {String} [message] - More details about the error.
+ *
+ * NOTE If neither one of the errors is present, then the operation has been
+ * canceled.
+ */
+
+/* eslint-disable no-invalid-this */
+
+/**
+ * Connects to the XMPP server using the specified credentials and contacts
+ * Jicofo in order to obtain a session ID (which is then stored in the local
+ * storage). The user's role of the parent conference will be upgraded to
+ * moderator (by Jicofo). It's also used to join the conference when starting
+ * from anonymous domain and only authenticated users are allowed to create new
+ * rooms.
+ *
+ * @param {Object} options
+ * @param {string} options.id - XMPP user's ID to log in. For example,
+ * user@xmpp-server.com.
+ * @param {string} options.password - XMPP user's password to log in with.
+ * @param {string} [options.roomPassword] - The password to join the MUC with.
+ * @param {Function} [options.onLoginSuccessful] - Callback called when logging
+ * into the XMPP server was successful. The next step will be to obtain a new
+ * session ID from Jicofo and join the MUC using it which will effectively
+ * upgrade the user's role to moderator.
+ * @returns {Object} A <tt>thenable</tt> which (1) settles when the process of
+ * authenticating and upgrading the role of the specified XMPP user finishes and
+ * (2) has a <tt>cancel</tt> method that allows the caller to interrupt the
+ * process. If the process finishes successfully, the session ID has been stored
+ * in the settings and the <tt>thenable</tt> is resolved. If the process
+ * finishes with failure, the <tt>thenable</tt> is rejected with reason of type
+ * {@link UpgradeRoleError} which will have either <tt>connectionError</tt> or
+ * <tt>authenticationError</tt> property set depending on which of the steps has
+ * failed. If <tt>cancel</tt> is called before the process finishes, then the
+ * thenable will be rejected with an empty object (i.e. no error property will
+ * be set on the rejection reason).
+ */
+export default function authenticateAndUpgradeRole({
+    // 1. Log the specified XMPP user in.
+    id,
+    password,
+
+    // 2. Let the API client/consumer know as soon as the XMPP user has been
+    //    successfully logged in.
+    onLoginSuccessful,
+
+    // 3. Join the MUC.
+    roomPassword
+}) {
+    let canceled = false;
+    let rejectPromise;
+    let xmpp = new XMPP(this.connection.options);
+
+    const process = new Promise((resolve, reject) => {
+        // The process is represented by a Thenable with a cancel method. The
+        // Thenable is implemented using Promise and the cancel using the
+        // Promise's reject function.
+        rejectPromise = reject;
+
+
+        xmpp.addListener(
+            CONNECTION_DISCONNECTED,
+            () => {
+                xmpp = undefined;
+            });
+        xmpp.addListener(
+            CONNECTION_ESTABLISHED,
+            () => {
+                if (canceled) {
+                    return;
+                }
+
+                // Let the caller know that the XMPP login was successful.
+                onLoginSuccessful && onLoginSuccessful();
+
+                // Now authenticate with Jicofo and get a new session ID.
+                const room
+                    = xmpp.createRoom(this.options.name, this.options.config);
+
+                room.moderator.authenticate()
+                    .then(() => {
+                        xmpp && xmpp.disconnect();
+
+                        if (canceled) {
+                            return;
+                        }
+
+                        // At this point we should have the new session ID
+                        // stored in the settings. Jicofo will allow to join the
+                        // room.
+                        this.join(roomPassword);
+
+                        resolve();
+                    })
+                    .catch(({ error, message }) => {
+                        xmpp.disconnect();
+
+                        reject({
+                            authenticationError: error,
+                            message
+                        });
+                    });
+            });
+        xmpp.addListener(
+            CONNECTION_FAILED,
+            (connectionError, message) => {
+                reject({
+                    connectionError,
+                    message
+                });
+                xmpp = undefined;
+            });
+
+        canceled || xmpp.connect(id, password);
+    });
+
+    /**
+     * Cancels the process, if it's in progress, of authenticating and upgrading
+     * the role of the local participant/user.
+     *
+     * @public
+     * @returns {void}
+     */
+    process.cancel = () => {
+        canceled = true;
+        rejectPromise({});
+        xmpp && xmpp.disconnect();
+    };
+
+    return process;
+}
+
+/* eslint-enable no-invalid-this */

modules/xmpp/moderator.js

@@ -465,14 +465,13 @@ Moderator.prototype.authenticate = function() {
             result => {
                 this.parseSessionId(result);
                 resolve();
-            }, errorIq => {
-                reject({
-                    error: $(errorIq).find('iq>error :first')
-                                     .prop('tagName'),
-                    message: $(errorIq).find('iq>error>text')
-                                       .text()
-                });
-            }
+            },
+            errorIq => reject({
+                error: $(errorIq).find('iq>error :first')
+                                 .prop('tagName'),
+                message: $(errorIq).find('iq>error>text')
+                                   .text()
+            })
         );
     });
 };