Adds all SRD/SLD to modifySourcesQueue and removes modifySourcesQueue.pause calls

JitsiConference.js

     this.room.addListener(XMPPEvents.SENDRECV_STREAMS_CHANGED,
         track.ssrcHandler);
 
-    return new Promise(function (resolve) {
+    return new Promise(function (resolve, reject) {
         this.room.addStream(track.getOriginalStream(), function () {
             if (track.isVideoTrack()) {
                 this.removeCommand("videoType");
 
             this.eventEmitter.emit(JitsiConferenceEvents.TRACK_ADDED, track);
             resolve(track);
-        }.bind(this));
+        }.bind(this), function (error) {
+            reject(error);
+        });
     }.bind(this));
 };
 
         }
         return Promise.resolve();
     }
-    return new Promise(function (resolve) {
+    return new Promise(function (resolve, reject) {
         this.room.removeStream(track.getOriginalStream(), function(){
             track._setSSRC(null);
             //FIXME: This dependacy is not necessary. This is quick fix.
 
             this.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
             resolve();
-        }.bind(this), {
+        }.bind(this), function (error) {
+            reject(error);
+        }, {
             mtype: track.getType(),
             type: "remove",
             ssrc: track.ssrc});

modules/RTC/JitsiLocalTrack.js

     } else {
         if (mute) {
             this.dontFireRemoveEvent = true;
-            this.rtc.room.removeStream(this.stream, function () {},
-                {mtype: this.type, type: "mute", ssrc: this.ssrc});
-            RTCUtils.stopMediaStream(this.stream);
-            setStreamToNull = true;
-            if(isAudio)
-                this.rtc.room.setAudioMute(mute, callbackFunction);
-            else
-                this.rtc.room.setVideoMute(mute, callbackFunction);
-            //FIXME: Maybe here we should set the SRC for the containers to something
+            this.rtc.room.removeStream(this.stream, function () {
+                    RTCUtils.stopMediaStream(this.stream);
+                    setStreamToNull = true;
+                    if(isAudio)
+                        this.rtc.room.setAudioMute(mute, callbackFunction);
+                    else
+                        this.rtc.room.setVideoMute(mute, callbackFunction);
+                    //FIXME: Maybe here we should set the SRC for the containers to something
+                }.bind(this),
+                function (error) {
+                    reject(error);
+                }, {mtype: this.type, type: "mute", ssrc: this.ssrc});
+
         } else {
             var self = this;
             // FIXME why are we doing all this audio type checks and
                             else
                                 self.rtc.room.setVideoMute(
                                     mute, callbackFunction);
+                        }, function (error) {
+                            reject(error);
                         }, {
                             mtype: self.type,
                             type: "unmute",

modules/RTC/RTC.js

         }
         try {
             this.room.addStream(
-                localTrack.getOriginalStream(), function () {}, ssrcInfo, true);
+                localTrack.getOriginalStream(), function () {}, function () {},
+                ssrcInfo, true);
         } catch(e) {
             GlobalOnErrorHandler.callErrorHandler(e);
             logger.error(e);

modules/xmpp/ChatRoom.js

     this.session = session;
 };
 
-
-ChatRoom.prototype.removeStream = function (stream, callback, ssrcInfo) {
+/**
+ * Remove stream.
+ * @param stream stream that will be removed.
+ * @param callback callback executed after successful stream removal.
+ * @param errorCallback callback executed if stream removal fail.
+ * @param ssrcInfo object with information about the SSRCs associated with the
+ * stream.
+ */
+ChatRoom.prototype.removeStream = function (stream, callback, errorCallback,
+    ssrcInfo) {
     if(!this.session) {
         callback();
         return;
     }
-    this.session.removeStream(stream, callback, ssrcInfo);
+    this.session.removeStream(stream, callback, errorCallback, ssrcInfo);
 };
 
 /**
  * Adds stream.
  * @param stream new stream that will be added.
  * @param callback callback executed after successful stream addition.
+ * @param errorCallback callback executed if stream addition fail.
  * @param ssrcInfo object with information about the SSRCs associated with the
  * stream.
  * @param dontModifySources {boolean} if true _modifySources won't be called.
  * Used for streams added before the call start.
  */
-ChatRoom.prototype.addStream = function (stream, callback, ssrcInfo,
-    dontModifySources) {
+ChatRoom.prototype.addStream = function (stream, callback, errorCallback,
+    ssrcInfo, dontModifySources) {
     if(this.session) {
         // FIXME: will block switchInProgress on true value in case of exception
-        this.session.addStream(stream, callback, ssrcInfo, dontModifySources);
+        this.session.addStream(stream, callback, errorCallback, ssrcInfo,
+            dontModifySources);
     } else {
         // We are done immediately
         logger.warn("No conference handler or conference not started yet");

modules/xmpp/JingleSessionPC.js

     JingleSession.call(this, me, sid, peerjid, connection,
                        media_constraints, ice_config, service, eventEmitter);
     this.localSDP = null;
-    this.remoteSDP = null;
 
-    this.hadstuncandidate = false;
-    this.hadturncandidate = false;
     this.lasticecandidate = false;
     this.closed = false;
 
     this.addssrc = [];
     this.removessrc = [];
-    this.pendingop = null;
     this.modifyingLocalStreams = false;
     this.modifiedSSRCs = {};
 
      */
     this.ssrcOwners = {};
 
+    this.jingleOfferIq = null;
     this.webrtcIceUdpDisable = !!this.service.options.webrtcIceUdpDisable;
     this.webrtcIceTcpDisable = !!this.service.options.webrtcIceTcpDisable;
 
     this.modifySourcesQueue = async.queue(this._modifySources.bind(this), 1);
-    // We start with the queue paused. We resume it when the signaling state is
-    // stable and the ice connection state is connected.
-    this.modifySourcesQueue.pause();
 }
 
 JingleSessionPC.prototype = Object.create(JingleSession.prototype);
 JingleSessionPC.prototype.constructor = JingleSessionPC;
 
 
-JingleSessionPC.prototype.updateModifySourcesQueue = function() {
-    var signalingState = this.peerconnection.signalingState;
-    var iceConnectionState = this.peerconnection.iceConnectionState;
-    if (signalingState === 'stable' && iceConnectionState === 'connected') {
-        this.modifySourcesQueue.resume();
-    } else {
-        this.modifySourcesQueue.pause();
-    }
-};
-
 JingleSessionPC.prototype.doInitialize = function () {
     var self = this;
-
-    this.hadstuncandidate = false;
-    this.hadturncandidate = false;
     this.lasticecandidate = false;
     // True if reconnect is in progress
     this.isreconnect = false;
         if (self.peerconnection.signalingState === 'stable') {
             self.wasstable = true;
         }
-        self.updateModifySourcesQueue();
     };
     /**
      * The oniceconnectionstatechange event handler contains the code to execute when the iceconnectionstatechange event,
             self.peerconnection.iceConnectionState] = now;
         logger.log("(TIME) ICE " + self.peerconnection.iceConnectionState +
                     ":\t", now);
-        self.updateModifySourcesQueue();
         switch (self.peerconnection.iceConnectionState) {
             case 'connected':
 
         }
         ice.xmlns = 'urn:xmpp:jingle:transports:ice-udp:1';
 
-        if (jcand.type === 'srflx') {
-            this.hadstuncandidate = true;
-        } else if (jcand.type === 'relay') {
-            this.hadturncandidate = true;
-        }
-
         if (this.usedrip) {
             if (this.drip_container.length === 0) {
                 // start 20ms callout
         logger.log('sendIceCandidate: last candidate.');
         // FIXME: remember to re-think in ICE-restart
         this.lasticecandidate = true;
-        logger.log('Have we encountered any srflx candidates? ' + this.hadstuncandidate);
-        logger.log('Have we encountered any relay candidates? ' + this.hadturncandidate);
     }
 };
 
 JingleSessionPC.prototype.setOfferCycle = function (jingleOfferIq,
                                                           success,
                                                           failure) {
-    // Set Jingle offer as RD
-    this.setOffer(jingleOfferIq,
-        function() {
-            // Set offer OK, now let's try create an answer
-            this.createAnswer(function(answer) {
-                    // Create answer OK, set it as local SDP
-                    this.setLocalDescription(answer, success, failure);
-                }.bind(this),
-                failure);
-        }.bind(this),
-        failure);
-};
-
-/**
- * Sets remote offer on PeerConnection by converting given Jingle offer IQ into
- * SDP and setting it as remote description.
- * @param jingleOfferIq  jQuery selector pointing to the jingle element of
- *        the offer IQ
- * @param success callback called when setRemoteDescription on PeerConnection
- *        succeeds
- * @param failure callback called with an error argument when
- *        setRemoteDescription fails.
- */
-JingleSessionPC.prototype.setOffer = function (jingleOfferIq, success, failure) {
-    this.remoteSDP = new SDP('');
-    if (this.webrtcIceTcpDisable) {
-        this.remoteSDP.removeTcpCandidates = true;
-    }
-    if (this.webrtcIceUdpDisable) {
-        this.remoteSDP.removeUdpCandidates = true;
-    }
-
-    this.remoteSDP.fromJingle(jingleOfferIq);
-    this.readSsrcInfo($(jingleOfferIq).find(">content"));
-    var remotedesc
-        = new RTCSessionDescription({type: 'offer', sdp: this.remoteSDP.raw});
-
-    this.peerconnection.setRemoteDescription(remotedesc,
-        function () {
-            //logger.log('setRemoteDescription success');
-            if (success) {
-                success();
-            }
-        },
-        function (e) {
-            logger.error('setRemoteDescription error', e);
-            if (failure)
-                failure(e);
-            JingleSessionPC.onJingleFatalError(this, e);
-        }.bind(this)
-    );
-};
-
-/**
- * This is a wrapper to PeerConnection.createAnswer in order to generate failure
- * event when error occurs. It also includes "media_constraints" if any are set
- * on this JingleSessionPC instance.
- * @param success callback called when PC.createAnswer succeeds, SDP will be
- *        the first argument
- * @param failure callback called with error argument when setAnswer fails
- */
-JingleSessionPC.prototype.createAnswer = function (success, failure) {
-    //logger.log('createAnswer');
-    var self = this;
-    this.peerconnection.createAnswer(
-        function (answer) {
-            var modifiedAnswer = new SDP(answer.sdp);
-            JingleSessionPC._fixAnswerRFC4145Setup(
-                /* offer */ self.remoteSDP,
-                /* answer */ modifiedAnswer);
-            answer.sdp = modifiedAnswer.raw;
-            success(answer);
-        },
-        function (error) {
-            logger.error("createAnswer failed", error);
-            if (failure)
-                failure(error);
-            self.room.eventEmitter.emit(
-                    XMPPEvents.CONFERENCE_SETUP_FAILED, error);
-        },
-        this.media_constraints
-    );
-};
-
-JingleSessionPC.prototype.setLocalDescription = function (sdp, success,
-                                                               failure) {
-    var self = this;
-    this.localSDP = new SDP(sdp.sdp);
-    sdp.sdp = this.localSDP.raw;
-    this.peerconnection.setLocalDescription(sdp,
-        function () {
-            if (success)
-                success();
-        },
-        function (error) {
-            logger.error('setLocalDescription failed', error);
-            if (failure)
-                failure(error);
-            self.room.eventEmitter.emit(
-                    XMPPEvents.CONFERENCE_SETUP_FAILED, error);
-        }
-    );
-    // Some checks for STUN and TURN candiates present in local SDP
-    // Eventually could be removed as we don't really care
-    var cands = SDPUtil.find_lines(this.localSDP.raw, 'a=candidate:');
-    for (var j = 0; j < cands.length; j++) {
-        var cand = SDPUtil.parse_icecandidate(cands[j]);
-        if (cand.type == 'srflx') {
-            this.hadstuncandidate = true;
-        } else if (cand.type == 'relay') {
-            this.hadturncandidate = true;
-        }
-    }
+    this.jingleOfferIq = jingleOfferIq;
+    this.modifySourcesQueue.push(success, function (error) {
+        if(!error)
+            return;
+        if (failure)
+            failure(error);
+        JingleSessionPC.onJingleFatalError(this, error);
+    }.bind(this));
 };
 
 /**
  * @param elem An array of Jingle "content" elements.
  */
 JingleSessionPC.prototype.addSource = function (elem) {
-
     var self = this;
     // FIXME: dirty waiting
     if (!this.peerconnection.localDescription)
  * @param elem An array of Jingle "content" elements.
  */
 JingleSessionPC.prototype.removeSource = function (elem) {
-
     var self = this;
     // FIXME: dirty waiting
     if (!this.peerconnection.localDescription) {
 };
 
 JingleSessionPC.prototype._modifySources = function (successCallback, queueCallback) {
-    var self = this;
+    var self = this, sdp = null, media_constraints;
 
     if (this.peerconnection.signalingState == 'closed') return;
-    if (!(this.addssrc.length || this.removessrc.length || this.pendingop !== null
-        || this.modifyingLocalStreams)){
+    if (!(this.addssrc.length || this.removessrc.length
+        || this.modifyingLocalStreams || this.jingleOfferIq !== null)){
         // There is nothing to do since scheduled job might have been
         // executed by another succeeding call
         if(successCallback){
         return;
     }
 
-    // Reset switch streams flags
-    this.modifyingLocalStreams = false;
+    if(this.jingleOfferIq) {
+        fromSessionInitiate = true;
+        sdp = new SDP('');
+        if (this.webrtcIceTcpDisable) {
+            sdp.removeTcpCandidates = true;
+        }
+        if (this.webrtcIceUdpDisable) {
+            sdp.removeUdpCandidates = true;
+        }
 
-    var sdp = new SDP(this.peerconnection.remoteDescription.sdp);
+        sdp.fromJingle(this.jingleOfferIq);
+        this.readSsrcInfo($(this.jingleOfferIq).find(">content"));
+        this.jingleOfferIq = null;
+        media_constraints = this.media_constraints;
+    } else {
+        // Reset switch streams flags
+        this.modifyingLocalStreams = false;
+
+        sdp = new SDP(this.peerconnection.remoteDescription.sdp);
+    }
 
     // add sources
     this.addssrc.forEach(function(lines, idx) {
             }
 
             self.peerconnection.createAnswer(
-                function(modifiedAnswer) {
-                    // change video direction, see https://github.com/jitsi/jitmeet/issues/41
-                    if (self.pendingop !== null) {
-                        var sdp = new SDP(modifiedAnswer.sdp);
-                        if (sdp.media.length > 1) {
-                            switch(self.pendingop) {
-                                case 'mute':
-                                    sdp.media[1] = sdp.media[1].replace('a=sendrecv', 'a=recvonly');
-                                    break;
-                                case 'unmute':
-                                    sdp.media[1] = sdp.media[1].replace('a=recvonly', 'a=sendrecv');
-                                    break;
-                            }
-                            sdp.raw = sdp.session + sdp.media.join('');
-                            modifiedAnswer.sdp = sdp.raw;
-                        }
-                        self.pendingop = null;
-                    }
-
+                function(answer) {
                     // FIXME: pushing down an answer while ice connection state
                     // is still checking is bad...
                     //logger.log(self.peerconnection.iceConnectionState);
 
-                    // trying to work around another chrome bug
-                    //modifiedAnswer.sdp = modifiedAnswer.sdp.replace(/a=setup:active/g, 'a=setup:actpass');
-                    self.peerconnection.setLocalDescription(modifiedAnswer,
+                    var modifiedAnswer = new SDP(answer.sdp);
+                    JingleSessionPC._fixAnswerRFC4145Setup(
+                        /* offer */ sdp,
+                        /* answer */ modifiedAnswer);
+                    answer.sdp = modifiedAnswer.raw;
+                    self.localSDP = new SDP(answer.sdp);
+                    answer.sdp = self.localSDP.raw;
+                    self.peerconnection.setLocalDescription(answer,
                         function() {
                             successCallback && successCallback();
                             queueCallback();
 /**
  * Adds stream.
  * @param stream new stream that will be added.
- * @param success_callback callback executed after successful stream addition.
+ * @param callback callback executed after successful stream addition.
+ * @param errorCallback callback executed if stream addition fail.
  * @param ssrcInfo object with information about the SSRCs associated with the
  * stream.
  * @param dontModifySources {boolean} if true _modifySources won't be called.
  * Used for streams added before the call start.
- * @throws error if modifySourcesQueue is paused.
  */
-JingleSessionPC.prototype.addStream = function (stream, callback, ssrcInfo,
-    dontModifySources) {
+JingleSessionPC.prototype.addStream = function (stream, callback, errorCallback,
+    ssrcInfo, dontModifySources) {
     // Remember SDP to figure out added/removed SSRCs
     var oldSdp = null;
     if(this.peerconnection && this.peerconnection.localDescription) {
         return;
     }
 
-    if(this.modifySourcesQueue.paused) {
-        // if this.modifySourcesQueue.paused, modifySources won't be called and
-        // the SDPs won't be updated. Basically removeStream will fail. That's
-        // why we are throwing the error to inform the callers of the method.
-        throw new Error("modifySourcesQueue paused");
-        return;
-    }
-
     if(stream || ssrcInfo)
         this.peerconnection.addStream(stream, ssrcInfo);
 
                 self.modifiedSSRCs[ssrcInfo.type] || [];
             self.modifiedSSRCs[ssrcInfo.type].push(ssrcInfo);
         }
-        callback();
         var newSdp = new SDP(self.peerconnection.localDescription.sdp);
         logger.log("SDPs", oldSdp, newSdp);
         self.notifyMySSRCUpdate(oldSdp, newSdp);
+    }, function (error) {
+        if(!error) {
+            callback();
+        } else {
+            errorCallback(error);
+        }
     });
 }
 
 /**
  * Remove streams.
  * @param stream stream that will be removed.
- * @param success_callback callback executed after successful stream addition.
+ * @param callback callback executed after successful stream addition.
+ * @param errorCallback callback executed if stream addition fail.
  * @param ssrcInfo object with information about the SSRCs associated with the
  * stream.
- * @throws error if modifySourcesQueue is paused.
  */
-JingleSessionPC.prototype.removeStream = function (stream, callback, ssrcInfo) {
+JingleSessionPC.prototype.removeStream = function (stream, callback, errorCallback,
+    ssrcInfo) {
     // Conference is not active
     if(!this.peerconnection) {
         callback();
         }
 
         if(!track) {
-            logger.log("Cannot remove tracks: no tracks.");
-            callback();
-            return;
-        }
-
-        if(this.modifySourcesQueue.paused) {
-            // if this.modifySourcesQueue.paused, modifySources won't be called and
-            // the SDPs won't be updated. Basically removeStream will fail. That's
-            // why we are throwing the error to inform the callers of the method.
-            throw new Error("modifySourcesQueue paused");
+            var msg = "Cannot remove tracks: no tracks.";
+            logger.log(msg);
+            errorCallback(new Error(msg));
             return;
         }
 
         } else {
             logger.log("Cannot remove tracks: no RTPSender.");
         }
-    } else if(this.modifySourcesQueue.paused) {
-        // if this.modifySourcesQueue.paused, modifySources won't be called and
-        // the SDPs won't be updated. Basically removeStream will fail. That's
-        // why we are throwing the error to inform the callers of the method.
-        throw new Error("modifySourcesQueue paused");
-        return;
     } else if(stream)
         this.peerconnection.removeStream(stream, false, ssrcInfo);
     // else
     this.modifySourcesQueue.push(function() {
         logger.log('modify sources done');
 
-        callback();
-
         var newSdp = new SDP(self.peerconnection.localDescription.sdp);
         if(ssrcInfo) {
             self.modifiedSSRCs[ssrcInfo.type] =
         }
         logger.log("SDPs", oldSdp, newSdp);
         self.notifyMySSRCUpdate(oldSdp, newSdp);
+    }, function (error) {
+        if(!error) {
+            callback();
+        } else {
+            errorCallback(error);
+        }
     });
 }