fix(conference): fire failed event on o/a failure

JitsiConferenceErrors.js

     = 'conference.incompatible_server_versions';
 
 /**
- * Indicates that jingle fatal error happened.
+ * Indicates that offer/answer had failed.
  */
-export const JINGLE_FATAL_ERROR = 'conference.jingleFatalError';
+export const OFFER_ANSWER_FAILED = 'conference.offerAnswerFailed';
 
 /**
  * Indicates that password cannot be set for this conference.

JitsiConferenceEventManager.js

             });
         });
 
+    chatRoom.addListener(XMPPEvents.RENEGOTIATION_FAILED, (e, session) => {
+        if (!session.isP2P) {
+            conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
+                JitsiConferenceErrors.OFFER_ANSWER_FAILED, e);
+        }
+    });
+
     this.chatRoomForwarder.forward(XMPPEvents.ROOM_JOIN_ERROR,
         JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.CONNECTION_ERROR);
         JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.GRACEFUL_SHUTDOWN);
 
-    chatRoom.addListener(XMPPEvents.JINGLE_FATAL_ERROR,
-        (session, error) => {
-            if (!session.isP2P) {
-                conference.eventEmitter.emit(
-                    JitsiConferenceEvents.CONFERENCE_FAILED,
-                    JitsiConferenceErrors.JINGLE_FATAL_ERROR, error);
-            }
-        });
-
     chatRoom.addListener(XMPPEvents.CONNECTION_ICE_FAILED,
         jingleSession => {
             conference._onIceConnectionFailed(jingleSession);
     this.chatRoomForwarder.forward(XMPPEvents.PHONE_NUMBER_CHANGED,
         JitsiConferenceEvents.PHONE_NUMBER_CHANGED);
 
-    chatRoom.addListener(
-        XMPPEvents.CONFERENCE_SETUP_FAILED,
-        (jingleSession, error) => {
-            if (!jingleSession.isP2P) {
-                conference.eventEmitter.emit(
-                    JitsiConferenceEvents.CONFERENCE_FAILED,
-                    JitsiConferenceErrors.SETUP_FAILED,
-                    error);
-            }
-        });
-
     chatRoom.setParticipantPropertyListener((node, from) => {
         const participant = conference.getParticipantById(from);
 
     rtc.addListener(RTCEvents.CREATE_ANSWER_FAILED,
         (e, tpc) => {
             conference.statistics.sendCreateAnswerFailed(e, tpc);
+            if (!tpc.isP2P) {
+                conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
+                    JitsiConferenceErrors.OFFER_ANSWER_FAILED, e);
+            }
         });
 
     rtc.addListener(RTCEvents.CREATE_OFFER_FAILED,
         (e, tpc) => {
             conference.statistics.sendCreateOfferFailed(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) => {
             conference.statistics.sendSetLocalDescFailed(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) => {
             conference.statistics.sendSetRemoteDescFailed(e, tpc);
+            if (!tpc.isP2P) {
+                conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
+                    JitsiConferenceErrors.OFFER_ANSWER_FAILED, e);
+            }
         });
 
     rtc.addListener(RTCEvents.LOCAL_TRACK_SSRC_UPDATED,

modules/xmpp/JingleSessionPC.js

                             this.isInitiator ? 'answer: ' : 'offer: '}${error}`,
                         newRemoteSdp);
 
-                    this._onJingleFatalError(error);
                     finishedCallback(error);
                 });
         };
      */
     _renegotiate(optionalRemoteSdp) {
         if (this.peerconnection.signalingState === 'closed') {
-            return Promise.reject('Attempted to renegotiate in state closed');
+            const error = new Error('Attempted to renegotiate in state closed');
+
+            this.room.eventEmitter.emit(XMPPEvents.RENEGOTIATION_FAILED, error, this);
+
+            return Promise.reject(error);
         }
 
         const remoteSdp
             = optionalRemoteSdp || this.peerconnection.remoteDescription.sdp;
 
         if (!remoteSdp) {
-            return Promise.reject(
-                'Can not renegotiate without remote description,'
-                    + `- current state: ${this.state}`);
+            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);
         }
 
         const remoteDescription = new RTCSessionDescription({
         };
     }
 
-    /**
-     *
-     * @param error
-     * @private
-     */
-    _onJingleFatalError(error) {
-        if (this.room) {
-            this.room.eventEmitter.emit(
-                XMPPEvents.CONFERENCE_SETUP_FAILED, this, error);
-            this.room.eventEmitter.emit(
-                XMPPEvents.JINGLE_FATAL_ERROR, this, error);
-        }
-    }
-
     /**
      * Returns the ice connection state for the peer connection.
      * @returns the ice connection state for the peer connection.

service/xmpp/XMPPEvents.js

     // The conference properties (as advertised by jicofo) have changed
     CONFERENCE_PROPERTIES_CHANGED: 'xmpp.conference_properties_changed',
 
-    CONFERENCE_SETUP_FAILED: 'xmpp.conference_setup_failed',
-
     /**
      * This event is triggered when the ICE connects for the first time.
      */
      */
     ICE_RESTART_SUCCESS: 'rtc.ice_restart_success',
 
-    /* Event fired when XMPP error is returned to any request, it is meant to be
-     * used to report 'signaling' errors to CallStats
-     *
-     * {
-     *   code: {XMPP error code}
-     *   reason: {XMPP error condition}
-     *   source = request.tree()
-     *   session = {JingleSession instance}
-     * }
-     */
-    JINGLE_ERROR: 'xmpp.jingle_error',
-
-    // Event fired when we have failed to set initial offer
-    JINGLE_FATAL_ERROR: 'xmpp.jingle_fatal_error',
-
     /**
      * Designates an event indicating that we were kicked from the XMPP MUC.
      * @param {boolean} isSelfPresence - whether it is for local participant
     // Designates an event indicating that we received statistics from a
     // 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',
     ROOM_CONNECT_NOT_ALLOWED_ERROR: 'xmpp.room_connect_error.not_allowed',