Merge pull request #583 from jitsi/sRD_failure

ref(JitsiLocalTrack): get rid of 'setMutedInProgress'

modules/RTC/JitsiLocalTrack.js

 
         let promise = Promise.resolve();
 
-        /**
-         * Set to <tt>true</tt> when there's ongoing "mute/unmute" operation in
-         * progress. Used by {@link LocalSdpMunger}.
-         *
-         * @public
-         * @type {boolean}
-         */
-        this.setMutedInProgress = true;
-
         // A function that will print info about muted status transition
         const logMuteInfo = () => logger.info(`Mute ${this}: ${muted}`);
 
 
         return promise
             .then(() => this._sendMuteStatus(muted))
-            .then(
-                /* onFulfilled */ () => {
-                    this.setMutedInProgress = false;
-                },
-                /* onRejected */ error => {
-                    this.setMutedInProgress = false;
-
-                    throw error;
-                })
             .then(() => this.emit(TRACK_MUTE_CHANGED, this));
     }
 

modules/RTC/LocalSdpMunger.js

 
         for (const videoTrack of localVideos) {
             const muted = videoTrack.isMuted();
-            const { setMutedInProgress } = videoTrack;
-            const shouldFakeSdp = muted || setMutedInProgress;
+            const mediaStream = videoTrack.getOriginalStream();
+
+            // During the mute/unmute operation there are periods of time when
+            // the track's underlying MediaStream is not added yet to
+            // the PeerConnection. The SDP needs to be munged in such case.
+            const isInPeerConnection
+                = mediaStream && this.tpc.isMediaStreamInPc(mediaStream);
+            const shouldFakeSdp = muted || !isInPeerConnection;
 
             logger.debug(
                 `${this.tpc} ${videoTrack} muted: ${muted
-                    }, is mute/unmute in progress: ${setMutedInProgress
+                    }, is in PeerConnection: ${isInPeerConnection
                     } => should fake sdp ? : ${shouldFakeSdp}`);
 
             if (!shouldFakeSdp) {

modules/RTC/TraceablePeerConnection.js

      */
     this.localTracks = new Map();
 
+    /**
+     * Keeps tracks of the WebRTC <tt>MediaStream</tt>s that have been added to
+     * the underlying WebRTC PeerConnection.
+     * @type {Set}
+     * @private
+     */
+    this._addedStreams = new Set();
+
     /**
      * @typedef {Object} TPCGroupInfo
      * @property {string} semantics the SSRC groups semantics
  */
 TraceablePeerConnection.prototype._addStream = function(mediaStream) {
     this.peerconnection.addStream(mediaStream);
+    this._addedStreams.add(mediaStream);
 };
 
 /**
     } else {
         this.peerconnection.removeStream(mediaStream);
     }
+    this._addedStreams.delete(mediaStream);
 };
 
 /**
     return doesBelong;
 };
 
+/**
+ * Tells if the given WebRTC <tt>MediaStream</tt> has been added to
+ * the underlying WebRTC PeerConnection.
+ * @param {MediaStream} mediaStream
+ * @returns {boolean}
+ */
+TraceablePeerConnection.prototype.isMediaStreamInPc = function(mediaStream) {
+    return this._addedStreams.has(mediaStream);
+};
+
 /**
  * Remove local track from this TPC.
  * @param {JitsiLocalTrack} localTrack the track to be removed from this TPC.
     }
     this.remoteTracks.clear();
 
+    this._addedStreams.clear();
+
     if (!this.rtc._removePeerConnection(this)) {
         logger.error('RTC._removePeerConnection returned false');
     }

modules/xmpp/JingleSessionPC.js

 
         if (Object.keys(addedMedia).length) {
             logger.error(
-                `Some SSRC were added on ${operationName}`, addedMedia);
+                `${this} - some SSRC were added on ${operationName}`,
+                addedMedia);
 
             return false;
         }
 
         if (Object.keys(removedMedia).length) {
             logger.error(
-                `Some SSRCs were removed on ${operationName}`, removedMedia);
+                `${this} - some SSRCs were removed on ${operationName}`,
+                removedMedia);
 
             return false;
         }