fix(TPC) add muted tracks to TPC but not to the RTCPeerConnection.

Fixes https://github.com/jitsi/jitsi-meet/issues/9988.

modules/RTC/TPCUtils.js

         ];
     }
 
-    /**
-     * Returns the transceiver associated with a given RTCRtpSender/RTCRtpReceiver.
-     *
-     * @param {string} mediaType - type of track associated with the transceiver 'audio' or 'video'.
-     * @param {JitsiLocalTrack} localTrack - local track to be used for lookup.
-     * @returns {RTCRtpTransceiver}
-     */
-    _findTransceiver(mediaType, localTrack = null) {
-        let transceiver = null;
-
-        // Check if the local track has been removed from the peerconnection already.
-        const trackRemoved = !localTrack
-            || (localTrack
-                && browser.doesVideoMuteByStreamRemove()
-                && localTrack.isVideoTrack()
-                && localTrack.isMuted());
-
-        if (trackRemoved) {
-            transceiver = this.pc.peerconnection.getTransceivers()
-                .find(t => t.receiver?.track?.kind === mediaType);
-        } else if (localTrack) {
-            transceiver = this.pc.peerconnection.getTransceivers()
-                .find(t => t.sender?.track?.id === localTrack.getTrackId());
-        }
-
-        return transceiver;
-    }
-
     /**
      * Obtains stream encodings that need to be configured on the given track based
      * on the track media type and the simulcast setting.
         });
     }
 
+    /**
+     * Returns the transceiver associated with a given RTCRtpSender/RTCRtpReceiver.
+     *
+     * @param {string} mediaType - type of track associated with the transceiver 'audio' or 'video'.
+     * @param {JitsiLocalTrack} localTrack - local track to be used for lookup.
+     * @returns {RTCRtpTransceiver}
+     */
+    findTransceiver(mediaType, localTrack = null) {
+        const transceiver = localTrack?.track && localTrack.getOriginalStream()
+            ? this.pc.peerconnection.getTransceivers().find(t => t.sender?.track?.id === localTrack.getTrackId())
+            : this.pc.peerconnection.getTransceivers().find(t => t.receiver?.track?.kind === mediaType);
+
+        return transceiver;
+    }
+
     /**
      * Takes in a *unified plan* offer and inserts the appropriate
      * parameters for adding simulcast receive support.
         }
     }
 
-    /**
-     * Adds a track on the RTCRtpSender as part of the unmute operation.
-     * @param {JitsiLocalTrack} localTrack - track to be unmuted.
-     * @returns {Promise<void>} - resolved when done.
-     */
-    addTrackUnmute(localTrack) {
-        const mediaType = localTrack.getType();
-        const track = localTrack.getTrack();
-        const transceiver = this._findTransceiver(mediaType);
-
-        if (!transceiver) {
-            return Promise.reject(new Error(`RTCRtpTransceiver for ${mediaType} not found`));
-        }
-        logger.debug(`${this.pc} Adding ${localTrack}`);
-
-        return transceiver.sender.replaceTrack(track);
-    }
-
     /**
      * Returns the calculated active state of the simulcast encodings based on the frame height requested for the send
      * stream. All the encodings that have a resolution lower than the frame height requested will be enabled.
         return encodingsBitrates;
     }
 
-    /**
-     * Removes the track from the RTCRtpSender as part of the mute operation.
-     * @param {JitsiLocalTrack} localTrack - track to be removed.
-     * @returns {Promise<void>} - resolved when done.
-     */
-    removeTrackMute(localTrack) {
-        const mediaType = localTrack.getType();
-        const transceiver = this._findTransceiver(mediaType, localTrack);
-
-        if (!transceiver) {
-            return Promise.reject(new Error(`RTCRtpTransceiver for ${mediaType} not found`));
-        }
-
-        logger.debug(`${this.pc} Removing ${localTrack}`);
-
-        return transceiver.sender.replaceTrack(null);
-    }
-
     /**
      * Replaces the existing track on a RTCRtpSender with the given track.
      * @param {JitsiLocalTrack} oldTrack - existing track on the sender that needs to be removed.
      * @returns {Promise<void>} - resolved when done.
      */
     replaceTrack(oldTrack, newTrack) {
-        if (oldTrack && newTrack) {
-            const mediaType = newTrack.getType();
-            const stream = newTrack.getOriginalStream();
-
-            // Ignore cases when the track is replaced while the device is in a muted state,like
-            // replacing camera when video muted or replacing mic when audio muted. These JitsiLocalTracks
-            // do not have a mediastream attached. Replace track will be called again when the device is
-            // unmuted and the track will be replaced on the peerconnection then.
-            if (!stream) {
-                this.pc.localTracks.delete(oldTrack.rtcId);
-                this.pc.localTracks.set(newTrack.rtcId, newTrack);
-
-                return Promise.resolve();
-            }
-
-            const transceiver = this._findTransceiver(mediaType, oldTrack);
-            const track = newTrack.getTrack();
+        const mediaType = newTrack?.getType() ?? oldTrack?.getType();
+        const transceiver = this.findTransceiver(mediaType, oldTrack);
+        const track = newTrack?.getTrack() ?? null;
 
-            if (!transceiver) {
-                return Promise.reject(new Error('replace track failed'));
-            }
-            logger.debug(`${this.pc} Replacing ${oldTrack} with ${newTrack}`);
-
-            return transceiver.sender.replaceTrack(track)
-                .then(() => {
-                    const ssrc = this.pc.localSSRCs.get(oldTrack.rtcId);
-
-                    this.pc.localTracks.delete(oldTrack.rtcId);
-                    this.pc.localSSRCs.delete(oldTrack.rtcId);
-                    this.pc._addedStreams = this.pc._addedStreams.filter(s => s !== stream);
-                    this.pc.localTracks.set(newTrack.rtcId, newTrack);
-
-                    this.pc._addedStreams.push(stream);
-                    this.pc.localSSRCs.set(newTrack.rtcId, ssrc);
-                });
-        } else if (oldTrack && !newTrack) {
-            return this.removeTrackMute(oldTrack)
-                .then(() => {
-                    const mediaType = oldTrack.getType();
-                    const transceiver = this._findTransceiver(mediaType);
-
-                    // Change the direction on the transceiver to 'recvonly' so that a 'removetrack'
-                    // is fired on the associated media stream on the remote peer.
-                    if (transceiver) {
-                        transceiver.direction = MediaDirection.RECVONLY;
-                    }
-
-                    // Remove the old track from the list of local tracks.
-                    this.pc.localTracks.delete(oldTrack.rtcId);
-                    this.pc.localSSRCs.delete(oldTrack.rtcId);
-                });
-        } else if (newTrack && !oldTrack) {
-            return this.addTrackUnmute(newTrack)
-                .then(() => {
-                    const mediaType = newTrack.getType();
-                    const transceiver = this._findTransceiver(mediaType, newTrack);
-
-                    // Change the direction on the transceiver back to 'sendrecv' so that a 'track'
-                    // event is fired on the remote peer.
-                    if (transceiver) {
-                        transceiver.direction = MediaDirection.SENDRECV;
-                    }
-
-                    // Avoid configuring the encodings on Chromium/Safari until simulcast is configured
-                    // for the newly added track using SDP munging which happens during the renegotiation.
-                    const promise = browser.usesSdpMungingForSimulcast()
-                        ? Promise.resolve()
-                        : this.setEncodings(newTrack);
-
-                    return promise
-                        .then(() => {
-                            // Add the new track to the list of local tracks.
-                            this.pc.localTracks.set(newTrack.rtcId, newTrack);
-                        });
-                });
+        if (!transceiver) {
+            return Promise.reject(new Error('replace track failed'));
         }
+        logger.debug(`${this.pc} Replacing ${oldTrack} with ${newTrack}`);
 
-        logger.info(`${this.pc} TPCUtils.replaceTrack called with no new track and no old track`);
-
-        return Promise.resolve();
+        return transceiver.sender.replaceTrack(track);
     }
 
     /**
      */
     setEncodings(track) {
         const mediaType = track.getType();
-        const transceiver = this._findTransceiver(mediaType, track);
+        const transceiver = this.findTransceiver(mediaType, track);
         const parameters = transceiver?.sender?.getParameters();
 
         // Resolve if the encodings are not available yet. This happens immediately after the track is added to the

modules/RTC/TraceablePeerConnection.js

     }
 
     this.localTracks.set(rtcId, track);
+    const webrtcStream = track.getOriginalStream();
 
     if (this._usesUnifiedPlan) {
-        try {
-            this.tpcUtils.addTrack(track, isInitiator);
-        } catch (error) {
-            logger.error(`${this} Adding track=${track} failed: ${error?.message}`);
+        logger.debug(`${this} TPC.addTrack using unified plan`);
+        if (webrtcStream) {
+            try {
+                this.tpcUtils.addTrack(track, isInitiator);
+            } catch (error) {
+                logger.error(`${this} Adding track=${track} failed: ${error?.message}`);
 
-            return Promise.reject(error);
+                return Promise.reject(error);
+            }
         }
     } else {
         // Use addStream API for the plan-b case.
-        const webrtcStream = track.getOriginalStream();
-
         if (webrtcStream) {
             this._addStream(webrtcStream);
 
 
     // On Firefox, the encodings have to be configured on the sender only after the transceiver is created.
     if (browser.isFirefox()) {
-        promiseChain = promiseChain.then(() => this.tpcUtils.setEncodings(track));
+        promiseChain = promiseChain.then(() => webrtcStream && this.tpcUtils.setEncodings(track));
     }
 
     return promiseChain;
 
 /**
  * Adds local track as part of the unmute operation.
- * @param {JitsiLocalTrack} track the track to be added as part of the unmute
- * operation
+ * @param {JitsiLocalTrack} track the track to be added as part of the unmute operation.
+ *
  * @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) {
+    logger.info(`${this} Adding track=${track} as unmute`);
+
     if (!this._assertTrackBelongs('addTrackUnmute', track)) {
         // Abort
+
         return Promise.reject('Track not found on the peerconnection');
     }
 
-    logger.info(`${this} Adding track=${track} as unmute`);
     const webRtcStream = track.getOriginalStream();
 
     if (!webRtcStream) {
     }
 
     if (this._usesUnifiedPlan) {
-        return this.tpcUtils.addTrackUnmute(track);
+        return this.tpcUtils.replaceTrack(null, track).then(() => this.isP2P);
     }
 
     this._addStream(webRtcStream);
 TraceablePeerConnection.prototype._assertTrackBelongs = function(
         methodName,
         localTrack) {
-    const doesBelong = this.localTracks.has(localTrack.rtcId);
+    const doesBelong = this.localTracks.has(localTrack?.rtcId);
 
     if (!doesBelong) {
         logger.error(`${this} ${methodName}: track=${localTrack} does not belong to pc`);
  * Otherwise no renegotiation is needed.
  */
 TraceablePeerConnection.prototype.replaceTrack = function(oldTrack, newTrack) {
+    if (!(oldTrack || newTrack)) {
+        logger.info(`${this} replaceTrack called with no new track and no old track`);
+
+        return Promise.resolve();
+    }
+
     if (this._usesUnifiedPlan) {
         logger.debug(`${this} TPC.replaceTrack using unified plan`);
+        const stream = newTrack?.getOriginalStream();
+        const promise = newTrack && !stream
+
+            // Ignore cases when the track is replaced while the device is in a muted state.
+            // The track will be replaced again on the peerconnection when the user unmutes.
+            ? Promise.resolve()
+            : this.tpcUtils.replaceTrack(oldTrack, newTrack);
+
+        return promise
+            .then(() => {
+                oldTrack && this.localTracks.delete(oldTrack.rtcId);
+                newTrack && this.localTracks.set(newTrack.rtcId, newTrack);
 
-        // Renegotiate only in the case of P2P. We rely on 'negotiationeeded' to be fired for JVB.
-        return this.tpcUtils.replaceTrack(oldTrack, newTrack).then(() => this.isP2P);
+                const mediaType = newTrack?.getType() ?? oldTrack?.getType();
+                const transceiver = this.tpcUtils.findTransceiver(mediaType, oldTrack);
+
+                if (transceiver) {
+                    // Set the transceiver direction.
+                    transceiver.direction = newTrack ? MediaDirection.SENDRECV : MediaDirection.RECVONLY;
+                }
+
+                // Avoid configuring the encodings on Chromium/Safari until simulcast is configured
+                // for the newly added track using SDP munging which happens during the renegotiation.
+                const configureEncodingsPromise = browser.usesSdpMungingForSimulcast() || !newTrack
+                    ? Promise.resolve()
+                    : this.tpcUtils.setEncodings(newTrack);
+
+                // Renegotiate only in the case of P2P. We rely on 'negotiationeeded' to be fired for JVB.
+                return configureEncodingsPromise.then(() => this.isP2P);
+            });
     }
 
     logger.debug(`${this} TPC.replaceTrack using plan B`);
     }
 
     if (this._usesUnifiedPlan) {
-        return this.tpcUtils.removeTrackMute(localTrack);
+        return this.tpcUtils.replaceTrack(localTrack, null);
     }
 
     if (webRtcStream) {

modules/xmpp/JingleSessionPC.js

                     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));
+                                // The results are ignored, as this check failure is not enough to fail the whole
+                                // operation. It will log an error inside for plan-b.
+                                !this.usesUnifiedPlan && this._verifyNoSSRCChanged(operationName, new SDP(oldLocalSDP));
+                                const newLocalSdp = tpc.localDescription.sdp;
+
+                                // Signal the ssrc if an unmute operation results in a new ssrc being generated.
+                                this.notifyMySSRCUpdate(new SDP(oldLocalSDP), new SDP(newLocalSdp));
                                 finishedCallback();
                             });
                     } else {