fix(mute/unmute): Make mute/unmute async

Trigger renegotiation only for plan-b when tracks are muted or unmuted

modules/RTC/TPCUtils.js

     /**
      * Adds a track on the RTCRtpSender as part of the unmute operation.
      * @param {JitsiLocalTrack} localTrack - track to be unmuted.
-     * @returns {Promise<void>}
+     * @returns {Promise<boolean>} - Promise that resolves to false if unmute
+     * operation is successful, a reject otherwise.
      */
     addTrackUnmute(localTrack) {
         const mediaType = localTrack.getType();
             .find(t => t.receiver && t.receiver.track && t.receiver.track.kind === mediaType);
 
         if (!transceiver) {
-            logger.error(`RTCRtpTransceiver for ${mediaType} on ${this.pc} not found`);
-
-            return false;
+            return Promise.reject(new Error(`RTCRtpTransceiver for ${mediaType} not found`));
         }
         logger.debug(`Adding ${localTrack} on ${this.pc}`);
 
             this.pc.localTracks.set(localTrack.rtcId, localTrack);
             transceiver.direction = 'sendrecv';
 
-            return true;
+            return Promise.resolve(false);
         }
 
         return transceiver.sender.replaceTrack(track)
             .then(() => {
                 this.pc.localTracks.set(localTrack.rtcId, localTrack);
+
+                return Promise.resolve(false);
             });
     }
 
     /**
      * Removes the track from the RTCRtpSender as part of the mute operation.
      * @param {JitsiLocalTrack} localTrack - track to be removed.
-     * @returns {Promise<void>}
+     * @returns {Promise<boolean>} - Promise that resolves to false if unmute
+     * operation is successful, a reject otherwise.
      */
     removeTrackMute(localTrack) {
         const mediaType = localTrack.getType();
             .find(t => t.sender && t.sender.track && t.sender.track.id === localTrack.getTrackId());
 
         if (!transceiver) {
-            logger.error(`RTCRtpTransceiver for ${mediaType} on ${this.pc} not found`);
-
-            return false;
+            return Promise.reject(new Error(`RTCRtpTransceiver for ${mediaType} not found`));
         }
 
         logger.debug(`Removing ${localTrack} on ${this.pc}`);
         return transceiver.sender.replaceTrack(null)
             .then(() => {
                 this.pc.localTracks.delete(localTrack.rtcId);
+
+                return Promise.resolve(false);
             });
     }
 

modules/RTC/TraceablePeerConnection.js

  * Adds local track as part of the unmute operation.
  * @param {JitsiLocalTrack} track the track to be added as part of the unmute
  * operation
- * @return {boolean} <tt>true</tt> if the state of underlying PC has changed and
- * the renegotiation is required or <tt>false</tt> otherwise.
+ * @return {Promise<boolean>} Promise that resolves to true if the underlying PeerConnection's
+ * state has changed and renegotiation is required, false if no renegotiation is needed or
+ * Promise is rejected when something goes wrong.
  */
 TraceablePeerConnection.prototype.addTrackUnmute = function(track) {
     if (browser.usesUnifiedPlan()) {
     }
     if (!this._assertTrackBelongs('addTrackUnmute', track)) {
         // Abort
-        return false;
+        return Promise.reject('Track not found on the peerconnection');
     }
 
     logger.info(`Adding ${track} as unmute to ${this}`);
         logger.error(
             `Unable to add ${track} as unmute to ${this} - no WebRTC stream`);
 
-        return false;
+        return Promise.reject('Stream not found');
     }
     this._addStream(webRtcStream);
 
-    return true;
+    return Promise.resolve(true);
 };
 
 /**
  * Removes local track as part of the mute operation.
  * @param {JitsiLocalTrack} localTrack the local track to be remove as part of
  * the mute operation.
- * @return {boolean} <tt>true</tt> if the underlying PeerConnection's state has
- * changed and the renegotiation is required or <tt>false</tt> otherwise.
+ * @return {Promise<boolean>} Promise that resolves to true if the underlying PeerConnection's
+ * state has changed and renegotiation is required, false if no renegotiation is needed or
+ * Promise is rejected when something goes wrong.
  */
 TraceablePeerConnection.prototype.removeTrackMute = function(localTrack) {
     if (browser.usesUnifiedPlan()) {
 
     if (!this._assertTrackBelongs('removeStreamMute', localTrack)) {
         // Abort - nothing to be done here
-        return false;
+        return Promise.reject('Track not found in the peerconnection');
     }
     if (webRtcStream) {
         logger.info(
             `Removing ${localTrack} as mute from ${this}`);
         this._removeStream(webRtcStream);
 
-        return true;
+        return Promise.resolve(true);
     }
 
     logger.error(`removeStreamMute - no WebRTC stream for ${localTrack}`);
 
-    return false;
+    return Promise.reject('Stream not found');
 };
 
 /**

modules/xmpp/JingleSessionPC.js

                 return;
             }
             const oldLocalSDP = tpc.localDescription.sdp;
-            const tpcOperation
+            const operationPromise
                 = isMute
-                    ? tpc.removeTrackMute.bind(tpc, track)
-                    : tpc.addTrackUnmute.bind(tpc, track);
+                    ? tpc.removeTrackMute(track)
+                    : tpc.addTrackUnmute(track);
 
-            if (!tpcOperation()) {
-                finishedCallback(`${operationName} failed!`);
-
-            // Do not renegotiate when browser is running in Unified-plan mode.
-            } else if (!oldLocalSDP || !tpc.remoteDescription.sdp || browser.usesUnifiedPlan()) {
-                finishedCallback();
-            } else {
-                this._renegotiate()
-                    .then(() => {
-                        // The results are ignored, as this check failure is not
-                        // enough to fail the whole operation. It will log
-                        // an error inside.
-                        this._verifyNoSSRCChanged(
-                            operationName, new SDP(oldLocalSDP));
+            operationPromise
+                .then(shouldRenegotiate => {
+                    if (shouldRenegotiate && oldLocalSDP && tpc.remoteDescription.sdp) {
+                        this._renegotiate()
+                            .then(() => {
+                                // The results are ignored, as this check failure is not
+                                // enough to fail the whole operation. It will log
+                                // an error inside.
+                                this._verifyNoSSRCChanged(
+                                    operationName, new SDP(oldLocalSDP));
+                                finishedCallback();
+                            });
+                    } else {
                         finishedCallback();
-                    },
-                    finishedCallback /* will be called with an error */);
-            }
+                    }
+                },
+                finishedCallback /* will be called with an error */);
         };
 
         return new Promise((resolve, reject) => {