fix(Conference) Do not kick endpoint out on renegotiation errors.

JitsiConference.js

     if (this.p2pJingleSession === session) {
         logger.info('P2P setAnswer');
 
-        this.p2pJingleSession.setAnswer(answer);
-        this.eventEmitter.emit(JitsiConferenceEvents._MEDIA_SESSION_STARTED, this.p2pJingleSession);
+        this.p2pJingleSession.setAnswer(answer)
+            .then(() => {
+                this.eventEmitter.emit(JitsiConferenceEvents._MEDIA_SESSION_STARTED, this.p2pJingleSession);
+            })
+            .catch(error => {
+                logger.error('Error setting P2P answer', error);
+                if (this.p2pJingleSession) {
+                    this.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
+                        JitsiConferenceErrors.OFFER_ANSWER_FAILED, error);
+                }
+            });
     }
 };
 
                 });
             },
             error => {
-                logger.error('Failed to accept incoming Jingle session', error);
+                logger.error('Failed to accept incoming JVB Jingle session', error);
+                this.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
+                    JitsiConferenceErrors.OFFER_ANSWER_FAILED, error);
             },
             localTracks
         );
             });
         },
         error => {
-            logger.error(
-                'Failed to accept incoming P2P Jingle session', error);
+            logger.error('Failed to accept incoming P2P Jingle session', error);
+            if (this.p2pJingleSession) {
+                this.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
+                    JitsiConferenceErrors.OFFER_ANSWER_FAILED, error);
+            }
         },
         localTracks);
 };
 
     const localTracks = this.getLocalTracks();
 
-    this.p2pJingleSession.invite(localTracks);
+    this.p2pJingleSession.invite(localTracks)
+        .then(() => {
+            this.p2pJingleSession.addEventListener(MediaSessionEvents.VIDEO_CODEC_CHANGED, () => {
+                this.eventEmitter.emit(JitsiConferenceEvents.VIDEO_CODEC_CHANGED);
+            });
+        })
+        .catch(error => {
+            logger.error('Failed to start P2P Jingle session', error);
 
-    this.p2pJingleSession.addEventListener(MediaSessionEvents.VIDEO_CODEC_CHANGED, () => {
-        this.eventEmitter.emit(JitsiConferenceEvents.VIDEO_CODEC_CHANGED);
-    });
+            if (this.p2pJingleSession) {
+                this.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
+                JitsiConferenceErrors.OFFER_ANSWER_FAILED, error);
+            }
+        });
 };
 
 /**

JitsiConferenceEventManager.js

             });
         });
 
-    chatRoom.addListener(XMPPEvents.RENEGOTIATION_FAILED, (e, session) => {
-        if (!session.isP2P) {
-            conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
-                JitsiConferenceErrors.OFFER_ANSWER_FAILED, e);
-        }
-    });
-
     chatRoom.addListener(JitsiTrackEvents.TRACK_OWNER_SET, (track, owner, sourceName, videoType) => {
         if (track.getParticipantId() !== owner || track.getSourceName() !== sourceName) {
             conference.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
                 logger.warn(`Ignoring ENDPOINT_STATS_RECEIVED for a non-existant participant: ${from}`);
             }
         });
-
-    rtc.addListener(RTCEvents.CREATE_ANSWER_FAILED,
-        (e, tpc) => {
-            if (!tpc.isP2P) {
-                conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
-                    JitsiConferenceErrors.OFFER_ANSWER_FAILED, e);
-            }
-        });
-
-    rtc.addListener(RTCEvents.CREATE_OFFER_FAILED,
-        (e, tpc) => {
-            if (!tpc.isP2P) {
-                conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
-                    JitsiConferenceErrors.OFFER_ANSWER_FAILED, e);
-            }
-        });
-
-    rtc.addListener(RTCEvents.SET_LOCAL_DESCRIPTION_FAILED,
-        (e, tpc) => {
-            if (!tpc.isP2P) {
-                conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
-                    JitsiConferenceErrors.OFFER_ANSWER_FAILED, e);
-            }
-        });
-
-    rtc.addListener(RTCEvents.SET_REMOTE_DESCRIPTION_FAILED,
-        (e, tpc) => {
-            if (!tpc.isP2P) {
-                conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
-                    JitsiConferenceErrors.OFFER_ANSWER_FAILED, e);
-            }
-        });
 };
 
 /**

modules/RTC/TraceablePeerConnection.js

                 resolve();
             }, err => {
                 this.trace('setLocalDescriptionOnFailure', err);
-                this.eventEmitter.emit(RTCEvents.SET_LOCAL_DESCRIPTION_FAILED, err, this);
                 reject(err);
             });
     });
                 this._initializeDtlsTransport();
 
                 resolve();
-            }, err => {
+            })
+            .catch(err => {
                 this.trace('setRemoteDescriptionOnFailure', err);
-                this.eventEmitter.emit(RTCEvents.SET_REMOTE_DESCRIPTION_FAILED, err, this);
                 reject(err);
             });
     });
 
     const handleFailure = (err, rejectFn) => {
         this.trace(`create${logName}OnFailure`, err);
-        const eventType
-            = isOffer
-                ? RTCEvents.CREATE_OFFER_FAILED
-                : RTCEvents.CREATE_ANSWER_FAILED;
-
-        this.eventEmitter.emit(eventType, err, this);
-
         rejectFn(err);
     };
 

modules/xmpp/JingleSessionPC.js

      * error {string}
      * @private
      */
-    _renegotiate(optionalRemoteSdp) {
+    async _renegotiate(optionalRemoteSdp) {
         if (this.peerconnection.signalingState === 'closed') {
-            const error = new Error('Attempted to renegotiate in state closed');
-
-            this.room.eventEmitter.emit(XMPPEvents.RENEGOTIATION_FAILED, error, this);
-
-            return Promise.reject(error);
+            throw new Error('Attempted to renegotiate in state closed');
         }
 
         const remoteSdp = optionalRemoteSdp || this.peerconnection.remoteDescription.sdp;
 
         if (!remoteSdp) {
-            const error = new Error(`Can not renegotiate without remote description, current state: ${this.state}`);
-
-            this.room.eventEmitter.emit(XMPPEvents.RENEGOTIATION_FAILED, error, this);
-
-            return Promise.reject(error);
+            throw new Error(`Cannot renegotiate without remote description, state=${this.state}`);
         }
 
         const remoteDescription = {
 
         logger.debug(`${this} Renegotiate: setting remote description`);
 
-        return this.peerconnection.setRemoteDescription(remoteDescription)
-            .then(() => {
-                logger.debug(`${this} Renegotiate: creating answer`);
-
-                return this.peerconnection.createAnswer(this.mediaConstraints);
-            })
-            .then(answer => {
-                logger.debug(`${this} Renegotiate: setting local description`);
+        try {
+            await this.peerconnection.setRemoteDescription(remoteDescription);
+            logger.debug(`${this} Renegotiate: creating answer`);
+            const answer = await this.peerconnection.createAnswer(this.mediaConstraints);
 
-                return this.peerconnection.setLocalDescription(answer);
-            })
-            .then(() => {
-                if (oldLocalSDP) {
-                    // Send the source updates after every renegotiation cycle.
-                    this.notifyMySSRCUpdate(new SDP(oldLocalSDP), new SDP(this.peerconnection.localDescription.sdp));
-                }
-            });
+            logger.debug(`${this} Renegotiate: setting local description`);
+            await this.peerconnection.setLocalDescription(answer);
+            if (oldLocalSDP) {
+                // Send the source updates after every renegotiation cycle.
+                this.notifyMySSRCUpdate(new SDP(oldLocalSDP), new SDP(this.peerconnection.localDescription.sdp));
+            }
+        } catch (error) {
+            logger.error(`${this} Renegotiate failed:`, error);
+            throw error;
+        }
     }
 
     /**
      *
      * @param {Array<JitsiLocalTrack>} localTracks the local tracks that will be added, before the offer/answer cycle
      * executes (for the local track addition to be an atomic operation together with the offer/answer).
-     * @returns {void}
+     * @returns {Promise<void>} that resolves when the offer is sent to the remote peer, rejected otherwise.
      */
-    invite(localTracks = []) {
+    async invite(localTracks = []) {
         if (!this.isInitiator) {
             throw new Error('Trying to invite from the responder session');
         }
             addTracks.push(this.peerconnection.addTrack(track, this.isInitiator));
         }
 
-        Promise.all(addTracks)
-            .then(() => this.peerconnection.createOffer(this.mediaConstraints))
-            .then(offerSdp => this.peerconnection.setLocalDescription(offerSdp))
-            .then(() => {
-                this.peerconnection.processLocalSdpForTransceiverInfo(localTracks);
-                this._sendSessionInitiate(this.peerconnection.localDescription.sdp);
-            })
-            .then(() => {
-                logger.debug(`${this} invite executed - OK`);
-            })
-            .catch(error => {
-                logger.error(`${this} invite error`, error);
-            });
+        try {
+            await Promise.all(addTracks);
+            const offerSdp = await this.peerconnection.createOffer(this.mediaConstraints);
+
+            await this.peerconnection.setLocalDescription(offerSdp);
+            this.peerconnection.processLocalSdpForTransceiverInfo(localTracks);
+            this._sendSessionInitiate(this.peerconnection.localDescription.sdp);
+
+            logger.debug(`${this} invite executed - OK`);
+        } catch (error) {
+            logger.error(`${this} invite error`, error);
+            throw error;
+        }
     }
 
     /**
      * Sets the answer received from the remote peer as the remote description.
      *
      * @param {Element} jingleAnswer - The jingle answer element.
-     * @returns {void}
-     * @throws {Error} if the method is called on a responder session.
+     * @returns {Promise<void>} that resolves when the answer is set as the remote description, rejected otherwise.
      */
-    setAnswer(jingleAnswer) {
+    async setAnswer(jingleAnswer) {
         if (!this.isInitiator) {
             throw new Error('Trying to set an answer on the responder session');
         }
             sdp: newRemoteSdp.raw
         };
 
-        this.peerconnection.setRemoteDescription(remoteDescription)
-            .then(() => {
-                if (this.state === JingleSessionState.PENDING) {
-                    this.state = JingleSessionState.ACTIVE;
+        try {
+            await this.peerconnection.setRemoteDescription(remoteDescription);
+            if (this.state === JingleSessionState.PENDING) {
+                this.state = JingleSessionState.ACTIVE;
 
-                    // Start processing tasks on the modification queue.
-                    logger.debug(`${this} Resuming the modification queue after session is established!`);
-                    this.modificationQueue.resume();
-                    const newLocalSdp = new SDP(this.peerconnection.localDescription.sdp);
+                // Start processing tasks on the modification queue.
+                logger.debug(`${this} Resuming the modification queue after session is established!`);
+                this.modificationQueue.resume();
+                const newLocalSdp = new SDP(this.peerconnection.localDescription.sdp);
 
-                    this._sendContentModify();
-                    this.notifyMySSRCUpdate(oldLocalSdp, newLocalSdp);
-                }
-            })
-            .then(() => {
-                logger.debug(`${this} setAnswer task done`);
-            })
-            .catch(error => {
-                logger.error(`${this} setAnswer task failed: ${error}`);
-            });
+                this._sendContentModify();
+                this.notifyMySSRCUpdate(oldLocalSdp, newLocalSdp);
+            }
+            logger.debug(`${this} setAnswer task done`);
+        } catch (error) {
+            logger.error(`${this} setAnswer task failed: ${error}`);
+            throw error;
+        }
     }
 
     /**

service/RTC/RTCEvents.spec.ts

 describe( "/service/RTC/RTCEvents members", () => {
     const {
         BRIDGE_BWE_STATS_RECEIVED,
-        CREATE_ANSWER_FAILED,
-        CREATE_OFFER_FAILED,
         DATA_CHANNEL_OPEN,
         DATA_CHANNEL_CLOSED,
         ENDPOINT_CONN_STATUS_CHANGED,
         REMOTE_TRACK_MUTE,
         REMOTE_TRACK_REMOVED,
         REMOTE_TRACK_UNMUTE,
-        SET_LOCAL_DESCRIPTION_FAILED,
-        SET_REMOTE_DESCRIPTION_FAILED,
         AUDIO_OUTPUT_DEVICE_CHANGED,
         DEVICE_LIST_CHANGED,
         DEVICE_LIST_WILL_CHANGE,
 
     it( "known members", () => {
         expect( BRIDGE_BWE_STATS_RECEIVED ).toBe( 'rtc.bridge_bwe_stats_received' );
-        expect( CREATE_ANSWER_FAILED ).toBe( 'rtc.create_answer_failed' );
-        expect( CREATE_OFFER_FAILED ).toBe( 'rtc.create_offer_failed' );
         expect( DATA_CHANNEL_OPEN ).toBe( 'rtc.data_channel_open' );
         expect( DATA_CHANNEL_CLOSED ).toBe( 'rtc.data_channel_closed' );
         expect( ENDPOINT_CONN_STATUS_CHANGED ).toBe( 'rtc.endpoint_conn_status_changed' );
         expect( REMOTE_TRACK_MUTE ).toBe( 'rtc.remote_track_mute' );
         expect( REMOTE_TRACK_REMOVED ).toBe( 'rtc.remote_track_removed' );
         expect( REMOTE_TRACK_UNMUTE ).toBe( 'rtc.remote_track_unmute' );
-        expect( SET_LOCAL_DESCRIPTION_FAILED ).toBe( 'rtc.set_local_description_failed' );
-        expect( SET_REMOTE_DESCRIPTION_FAILED ).toBe( 'rtc.set_remote_description_failed' );
         expect( AUDIO_OUTPUT_DEVICE_CHANGED ).toBe( 'rtc.audio_output_device_changed' );
         expect( DEVICE_LIST_CHANGED ).toBe( 'rtc.device_list_changed' );
         expect( DEVICE_LIST_WILL_CHANGE ).toBe( 'rtc.device_list_will_change' );
 
         if ( RTCEvents ) {
             expect( RTCEvents.BRIDGE_BWE_STATS_RECEIVED ).toBe( 'rtc.bridge_bwe_stats_received' );
-            expect( RTCEvents.CREATE_ANSWER_FAILED ).toBe( 'rtc.create_answer_failed' );
-            expect( RTCEvents.CREATE_OFFER_FAILED ).toBe( 'rtc.create_offer_failed' );
             expect( RTCEvents.DATA_CHANNEL_OPEN ).toBe( 'rtc.data_channel_open' );
             expect( RTCEvents.DATA_CHANNEL_CLOSED ).toBe( 'rtc.data_channel_closed' );
             expect( RTCEvents.ENDPOINT_CONN_STATUS_CHANGED ).toBe( 'rtc.endpoint_conn_status_changed' );
             expect( RTCEvents.REMOTE_TRACK_MUTE ).toBe( 'rtc.remote_track_mute' );
             expect( RTCEvents.REMOTE_TRACK_REMOVED ).toBe( 'rtc.remote_track_removed' );
             expect( RTCEvents.REMOTE_TRACK_UNMUTE ).toBe( 'rtc.remote_track_unmute' );
-            expect( RTCEvents.SET_LOCAL_DESCRIPTION_FAILED ).toBe( 'rtc.set_local_description_failed' );
-            expect( RTCEvents.SET_REMOTE_DESCRIPTION_FAILED ).toBe( 'rtc.set_remote_description_failed' );
             expect( RTCEvents.AUDIO_OUTPUT_DEVICE_CHANGED ).toBe( 'rtc.audio_output_device_changed' );
             expect( RTCEvents.DEVICE_LIST_CHANGED ).toBe( 'rtc.device_list_changed' );
             expect( RTCEvents.DEVICE_LIST_WILL_CHANGE ).toBe( 'rtc.device_list_will_change' );
 
         if ( RTCEventsDefault ) {
             expect( RTCEventsDefault.BRIDGE_BWE_STATS_RECEIVED ).toBe( 'rtc.bridge_bwe_stats_received' );
-            expect( RTCEventsDefault.CREATE_ANSWER_FAILED ).toBe( 'rtc.create_answer_failed' );
-            expect( RTCEventsDefault.CREATE_OFFER_FAILED ).toBe( 'rtc.create_offer_failed' );
             expect( RTCEventsDefault.DATA_CHANNEL_OPEN ).toBe( 'rtc.data_channel_open' );
             expect( RTCEventsDefault.DATA_CHANNEL_CLOSED ).toBe( 'rtc.data_channel_closed' );
             expect( RTCEventsDefault.ENDPOINT_CONN_STATUS_CHANGED ).toBe( 'rtc.endpoint_conn_status_changed' );
             expect( RTCEventsDefault.REMOTE_TRACK_MUTE ).toBe( 'rtc.remote_track_mute' );
             expect( RTCEventsDefault.REMOTE_TRACK_REMOVED ).toBe( 'rtc.remote_track_removed' );
             expect( RTCEventsDefault.REMOTE_TRACK_UNMUTE ).toBe( 'rtc.remote_track_unmute' );
-            expect( RTCEventsDefault.SET_LOCAL_DESCRIPTION_FAILED ).toBe( 'rtc.set_local_description_failed' );
-            expect( RTCEventsDefault.SET_REMOTE_DESCRIPTION_FAILED ).toBe( 'rtc.set_remote_description_failed' );
             expect( RTCEventsDefault.AUDIO_OUTPUT_DEVICE_CHANGED ).toBe( 'rtc.audio_output_device_changed' );
             expect( RTCEventsDefault.DEVICE_LIST_CHANGED ).toBe( 'rtc.device_list_changed' );
             expect( RTCEventsDefault.DEVICE_LIST_WILL_CHANGE ).toBe( 'rtc.device_list_will_change' );

service/RTC/RTCEvents.ts

      */
     BRIDGE_BWE_STATS_RECEIVED = 'rtc.bridge_bwe_stats_received',
 
-    /**
-     * Indicates error while create answer call.
-     */
-    CREATE_ANSWER_FAILED = 'rtc.create_answer_failed',
-
-    /**
-     * Indicates error while create offer call.
-     */
-    CREATE_OFFER_FAILED = 'rtc.create_offer_failed',
-
     /**
      * Indicates that the data channel has been closed.
      */
      */
     SENDER_VIDEO_CONSTRAINTS_CHANGED = 'rtc.sender_video_constraints_changed',
 
-    /**
-     * Indicates error while set local description.
-     */
-    SET_LOCAL_DESCRIPTION_FAILED = 'rtc.set_local_description_failed',
-
-    /**
-     * Indicates error while set remote description.
-     */
-    SET_REMOTE_DESCRIPTION_FAILED = 'rtc.set_remote_description_failed',
-
     /**
      * Designates an event indicating that some video SSRCs that have already been signaled will now map to new remote
      * sources.
 }
 
 export const BRIDGE_BWE_STATS_RECEIVED = RTCEvents.BRIDGE_BWE_STATS_RECEIVED;
-export const CREATE_ANSWER_FAILED = RTCEvents.CREATE_ANSWER_FAILED;
-export const CREATE_OFFER_FAILED = RTCEvents.CREATE_OFFER_FAILED;
 export const DATA_CHANNEL_OPEN = RTCEvents.DATA_CHANNEL_OPEN;
 export const DATA_CHANNEL_CLOSED = RTCEvents.DATA_CHANNEL_CLOSED;
 export const ENDPOINT_CONN_STATUS_CHANGED = RTCEvents.ENDPOINT_CONN_STATUS_CHANGED;
 export const REMOTE_TRACK_MUTE = RTCEvents.REMOTE_TRACK_MUTE;
 export const REMOTE_TRACK_REMOVED = RTCEvents.REMOTE_TRACK_REMOVED;
 export const REMOTE_TRACK_UNMUTE = RTCEvents.REMOTE_TRACK_UNMUTE;
-export const SET_LOCAL_DESCRIPTION_FAILED = RTCEvents.SET_LOCAL_DESCRIPTION_FAILED;
-export const SET_REMOTE_DESCRIPTION_FAILED = RTCEvents.SET_REMOTE_DESCRIPTION_FAILED;
 export const AUDIO_OUTPUT_DEVICE_CHANGED = RTCEvents.AUDIO_OUTPUT_DEVICE_CHANGED;
 export const DEVICE_LIST_CHANGED = RTCEvents.DEVICE_LIST_CHANGED;
 export const DEVICE_LIST_WILL_CHANGE = RTCEvents.DEVICE_LIST_WILL_CHANGE;

service/xmpp/XMPPEvents.spec.ts

         expect( XMPPEvents.READY_TO_JOIN ).toBe( 'xmpp.ready_to_join' );
         expect( XMPPEvents.RECORDER_STATE_CHANGED ).toBe( 'xmpp.recorderStateChanged' );
         expect( XMPPEvents.REMOTE_STATS ).toBe( 'xmpp.remote_stats' );
-        expect( XMPPEvents.RENEGOTIATION_FAILED ).toBe( 'xmpp.renegotiation_failed' );
-        expect( XMPPEvents.RESERVATION_ERROR ).toBe( 'xmpp.room_reservation_error' );
         expect( XMPPEvents.ROOM_CONNECT_ERROR ).toBe( 'xmpp.room_connect_error' );
         expect( XMPPEvents.ROOM_CONNECT_NOT_ALLOWED_ERROR ).toBe( 'xmpp.room_connect_error.not_allowed' );
         expect( XMPPEvents.ROOM_JOIN_ERROR ).toBe( 'xmpp.room_join_error' );

service/xmpp/XMPPEvents.ts

     // participant in the MUC.
     REMOTE_STATS = 'xmpp.remote_stats',
 
-    /**
-     * Indicates that the offer / answer renegotiation has failed.
-     */
-    RENEGOTIATION_FAILED = 'xmpp.renegotiation_failed',
-
     RESERVATION_ERROR = 'xmpp.room_reservation_error',
 
     ROOM_CONNECT_ERROR = 'xmpp.room_connect_error',

types/hand-crafted/service/RTC/RTCEvents.d.ts

 export enum RTCEvents {
-  CREATE_ANSWER_FAILED = 'rtc.create_answer_failed',
-  CREATE_OFFER_FAILED = 'rtc.create_offer_failed',
   DATA_CHANNEL_OPEN = 'rtc.data_channel_open',
   ENDPOINT_CONN_STATUS_CHANGED = 'rtc.endpoint_conn_status_changed',
   DOMINANT_SPEAKER_CHANGED = 'rtc.dominant_speaker_changed',
   REMOTE_TRACK_MUTE = 'rtc.remote_track_mute',
   REMOTE_TRACK_REMOVED = 'rtc.remote_track_removed',
   REMOTE_TRACK_UNMUTE = 'rtc.remote_track_unmute',
-  SET_LOCAL_DESCRIPTION_FAILED = 'rtc.set_local_description_failed',
-  SET_REMOTE_DESCRIPTION_FAILED = 'rtc.set_remote_description_failed',
   AUDIO_OUTPUT_DEVICE_CHANGED = 'rtc.audio_output_device_changed',
   DEVICE_LIST_CHANGED = 'rtc.device_list_changed',
   DEVICE_LIST_WILL_CHANGE = 'rtc.device_list_will_change',

types/hand-crafted/service/xmpp/XMPPEvents.d.ts

   READY_TO_JOIN = 'xmpp.ready_to_join',
   RECORDER_STATE_CHANGED = 'xmpp.recorderStateChanged',
   REMOTE_STATS = 'xmpp.remote_stats',
-  RENEGOTIATION_FAILED = 'xmpp.renegotiation_failed',
   RESERVATION_ERROR = 'xmpp.room_reservation_error',
   ROOM_CONNECT_ERROR = 'xmpp.room_connect_error',
   ROOM_CONNECT_NOT_ALLOWED_ERROR = 'xmpp.room_connect_error.not_allowed',