CONNECTION_FAILED error as object

Gradually, we exploded the error of CONNECTION_FAILED in multiple
redux state properties. The explosion makes maintenance harder because
the properties have to be updated in sync. Collect them in an object
resembling an Error instance.

connection.js

             ConnectionEvents.CONNECTION_FAILED,
             connectionFailedHandler);
 
-        function connectionFailedHandler(error, errMsg) {
-            APP.store.dispatch(connectionFailed(connection, error, errMsg));
+        function connectionFailedHandler(error, message, credentials) {
+            APP.store.dispatch(
+                connectionFailed(connection, error, message, credentials));
 
             if (isFatalJitsiConnectionError(error)) {
                 connection.removeEventListener(

react/features/authentication/actions.js

  * @private
  * @returns {{
  *     type: UPGRADE_ROLE_FINISHED,
- *     error: Object
+ *     error: ?Object
  * }}
  */
-function _upgradeRoleFinished(error) {
+function _upgradeRoleFinished(error: ?Object) {
+    if (error) {
+        // Make the specified error object resemble an Error instance (to the
+        // extent that jitsi-meet needs it).
+        const {
+            authenticationError,
+            connectionError,
+            ...other
+        } = error;
+
+        error = { // eslint-disable-line no-param-reassign
+            name: authenticationError || connectionError,
+            ...other
+        };
+    }
+
     return {
         type: UPGRADE_ROLE_FINISHED,
         error

react/features/authentication/components/LoginDialog.native.js

         /**
          * The error which occurred during login/authentication.
          */
-        _error: PropTypes.string,
-
-        /**
-         * The credential that the user has failed to authenticate with.
-         */
-        _errorCredentials: PropTypes.object,
-
-        /**
-         * Any extra details about the error provided by lib-jitsi-meet.
-         */
-        _errorDetails: PropTypes.string,
+        _error: PropTypes.object,
 
         /**
          * Redux store dispatch method.
         const {
             _connecting: connecting,
             _error: error,
-            _errorCredentials: errorCredentials,
-            _errorDetails: errorDetails,
             t
         } = this.props;
 
-        let messageKey = '';
-        const messageOptions = {};
+        let messageKey;
+        let messageOptions;
 
-        if (error === JitsiConnectionErrors.PASSWORD_REQUIRED) {
-            // Show the message if there's been a user ID or password provided.
-            messageKey
-                = errorCredentials
-                        && (errorCredentials.jid || errorCredentials.password)
-                    ? 'dialog.incorrectPassword'
-                    : null;
-        } else if (error) {
-            messageKey = 'dialog.connectErrorWithMsg';
-            messageOptions.msg = `${error} ${errorDetails}`;
+        if (error) {
+            const { name } = error;
+
+            if (name === JitsiConnectionErrors.PASSWORD_REQUIRED) {
+                // Show a message that the credentials are incorrect only if the
+                // credentials which have caused the connection to fail are the
+                // ones which the user sees.
+                const { credentials } = error;
+
+                if (credentials
+                        && credentials.jid
+                            === toJid(
+                                this.state.username,
+                                this.props._configHosts)
+                        && credentials.password === this.state.password) {
+                    messageKey = 'dialog.incorrectPassword';
+                }
+            } else if (name) {
+                messageKey = 'dialog.connectErrorWithMsg';
+                messageOptions || (messageOptions = {});
+                messageOptions.msg = `${name} ${error.message}`;
+            }
         }
 
         return (
                 titleKey = 'dialog.passwordRequired'>
                 <View style = { styles.loginDialog }>
                     <TextInput
+                        autoCapitalize = { 'none' }
+                        autoCorrect = { false }
                         onChangeText = { this._onUsernameChange }
                         placeholder = { 'user@domain.com' }
                         style = { styles.loginDialogTextInput }
                     <Text style = { styles.loginDialogText }>
                         {
                             messageKey
-                                ? t(messageKey, messageOptions)
+                                ? t(messageKey, messageOptions || {})
                                 : connecting
                                     ? t('connection.CONNECTING')
                                     : ''
  *     _conference: JitsiConference,
  *     _configHosts: Object,
  *     _connecting: boolean,
- *     _error: string,
- *     _errorCredentials: Object,
- *     _errorDetails: string
+ *     _error: Object
  * }}
  */
 function _mapStateToProps(state) {
     const { hosts: configHosts } = state['features/base/config'];
     const {
         connecting,
-        credentials,
-        error: connectionError,
-        errorMessage: connectionErrorMessage
+        error: connectionError
     } = state['features/base/connection'];
 
-    let error;
-    let errorCredentials;
-    let errorDetails;
-
-    if (connectionError) {
-        error = connectionError;
-        errorCredentials = credentials;
-        errorDetails = connectionErrorMessage;
-    } else if (upgradeRoleError) {
-        error
-            = upgradeRoleError.connectionError
-                || upgradeRoleError.authenticationError;
-        errorCredentials = upgradeRoleError.credentials;
-        errorDetails = upgradeRoleError.message;
-    }
-
     return {
         _conference: authRequired,
         _configHosts: configHosts,
         _connecting: Boolean(connecting) || Boolean(upgradeRoleInProgress),
-        _error: error,
-        _errorCredentials: errorCredentials,
-        _errorDetails: errorDetails
+        _error: connectionError || upgradeRoleError
     };
 }
 

react/features/authentication/middleware.js

         _hideLoginDialog(store);
         break;
 
-    case CONNECTION_FAILED:
-        action.error === JitsiConnectionErrors.PASSWORD_REQUIRED
+    case CONNECTION_FAILED: {
+        const { error } = action;
+
+        error
+            && error.name === JitsiConnectionErrors.PASSWORD_REQUIRED
             && store.dispatch(_openLoginDialog());
         break;
+    }
 
     case STOP_WAIT_FOR_OWNER:
         _clearExistingWaitForOwnerTimeout(store);

react/features/base/connection/actionTypes.js

  * {
  *     type: CONNECTION_FAILED,
  *     connection: JitsiConnection,
- *     error: string,
- *     message: string
+ *     error: Object | string
  * }
  */
 export const CONNECTION_FAILED = Symbol('CONNECTION_FAILED');

react/features/base/connection/actions.native.js

          * disconnected.
          *
          * @param {string} message - Disconnect reason.
-         * @returns {void}
          * @private
+         * @returns {void}
          */
         function _onConnectionDisconnected(message: string) {
             connection.removeEventListener(
         /**
          * Resolves external promise when connection is established.
          *
-         * @returns {void}
          * @private
+         * @returns {void}
          */
         function _onConnectionEstablished() {
             unsubscribe();
          * used to authenticate and the authentication failed.
          * @param {string} [credentials.jid] - The XMPP user's ID.
          * @param {string} [credentials.password] - The XMPP user's password.
-         * @returns {void}
          * @private
+         * @returns {void}
          */
         function _onConnectionFailed(err, msg, credentials) {
             unsubscribe();
  * @returns {{
  *     type: CONNECTION_FAILED,
  *     connection: JitsiConnection,
- *     credentials: Object,
- *     error: string,
- *     message: string
+ *     error: Object
  * }}
  */
 export function connectionFailed(
     return {
         type: CONNECTION_FAILED,
         connection,
-        credentials,
-        error,
-        message
+
+        // Make the error resemble an Error instance (to the extent that
+        // jitsi-meet needs it).
+        error: {
+            credentials:
+                credentials && Object.keys(credentials).length
+                    ? credentials
+                    : undefined,
+            message,
+            name: error
+        }
     };
 }
 

react/features/base/connection/reducer.js

     return assign(state, {
         connecting: undefined,
         connection,
-        error: undefined,
-        errorMessage: undefined
+        error: undefined
     });
 }
 
  */
 function _connectionFailed(
         state: Object,
-        { connection, credentials, error, message }: {
+        { connection, error }: {
             connection: Object,
-            credentials: ?Object,
-            error: string,
-            message: ?string
+            error: Object | string
         }) {
     if (state.connection && state.connection !== connection) {
         return state;
     return assign(state, {
         connecting: undefined,
         connection: undefined,
-        credentials,
-        error,
-        errorMessage: message
+        error
     });
 }
 
         { connection }: { connection: Object }) {
     return assign(state, {
         connecting: connection,
-        credentials: undefined,
-        error: undefined,
-        errorMessage: undefined
+        error: undefined
     });
 }
 

react/features/base/lib-jitsi-meet/functions.js

  * that category. I've currently named the category fatal because it appears to
  * be used in the cases of unrecoverable errors that necessitate a reload.
  *
- * @param {string} error - The JitsiConnectionErrors instance to
- * categorize/classify.
+ * @param {Object|string} error - The JitsiConnectionErrors instance to
+ * categorize/classify or an Error-like object.
  * @returns {boolean} True if the specified JitsiConnectionErrors instance
  * indicates a fatal JitsiConnection error; otherwise, false.
  */
-export function isFatalJitsiConnectionError(error: string) {
+export function isFatalJitsiConnectionError(error: Object | string) {
+    if (typeof error !== 'string') {
+        error = error.name; // eslint-disable-line no-param-reassign
+    }
+
     return (
         error === JitsiConnectionErrors.CONNECTION_DROPPED_ERROR
             || error === JitsiConnectionErrors.OTHER_ERROR

react/features/overlay/reducer.js

  * @returns {Object} The new state of the feature overlay after the reduction of
  * the specified action.
  */
-function _connectionFailed(state, { error, message }) {
+function _connectionFailed(state, { error }) {
     if (isFatalJitsiConnectionError(error)) {
+        const { message } = error;
+
         logger.error(`FATAL XMPP connection error: ${message}`);
 
         return assign(state, {
             // From all of the cases above only CONNECTION_DROPPED_ERROR is
             // considered a network type of failure.
             isNetworkFailure:
-                error === JitsiConnectionErrors.CONNECTION_DROPPED_ERROR,
+                error.name === JitsiConnectionErrors.CONNECTION_DROPPED_ERROR,
             reason: `xmpp-conn-dropped: ${message}`
         });
     }