fix(ssrc-rewriting): Fire track removed/added instead of owner changed.

When an existing SSRC for a remote track gets re-mapped from one source to another, fire a TRACK_REMOVED event followed by TRACK_ADDED event instead of TRACK_OWNER_CHANGED event. This should simplify the application logic for track handling.

JitsiConference.js

     }
 
     tracksToBeRemoved.forEach(track => {
+        // Fire the event before renegotiation is done so that the thumbnails can be removed immediately.
+        this.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
+
         if (FeatureFlags.isSsrcRewritingSupported()) {
             track.setSourceName(null);
             track.setOwner(null);
-        } else {
-            // Fire the event before renegotiation is done so that the thumbnails can be removed immediately.
-            this.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
         }
     });
 
  */
 JitsiConference.prototype._addRemoteTracks = function(logName, remoteTracks) {
     for (const track of remoteTracks) {
-        // There will be orphan (with no owner) tracks when ssrc-rewriting is enabled and all of them need to be addded
-        // back to the conference.
-        if (FeatureFlags.isSsrcRewritingSupported() || this.participants.has(track.ownerEndpointId)) {
+        if (this.participants.has(track.ownerEndpointId)) {
             logger.info(`Adding remote ${logName} track: ${track}`);
             this.onRemoteTrackAdded(track);
         }

JitsiConferenceEventManager.js

         }
     });
 
-    chatRoom.addListener(JitsiTrackEvents.TRACK_REMOVED, track => {
+    chatRoom.addListener(JitsiTrackEvents.TRACK_OWNER_ADDED, track => {
+        conference.eventEmitter.emit(JitsiConferenceEvents.TRACK_ADDED, track);
+    });
+    chatRoom.addListener(JitsiTrackEvents.TRACK_OWNER_REMOVED, track => {
         conference.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
     });
 

JitsiTrackEvents.spec.ts

         TRACK_AUDIO_LEVEL_CHANGED,
         TRACK_AUDIO_OUTPUT_CHANGED,
         TRACK_MUTE_CHANGED,
+        TRACK_OWNER_ADDED,
+        TRACK_OWNER_REMOVED,
         TRACK_STREAMING_STATUS_CHANGED,
         TRACK_VIDEOTYPE_CHANGED,
         NO_DATA_FROM_SOURCE,
         NO_AUDIO_INPUT,
-        TRACK_OWNER_CHANGED,
-        TRACK_REMOVED,
         JitsiTrackEvents,
         ...others
     } = exported;
         expect( TRACK_AUDIO_LEVEL_CHANGED ).toBe( 'track.audioLevelsChanged' );
         expect( TRACK_AUDIO_OUTPUT_CHANGED ).toBe( 'track.audioOutputChanged' );
         expect( TRACK_MUTE_CHANGED ).toBe( 'track.trackMuteChanged' );
+        expect( TRACK_OWNER_ADDED ).toBe( 'track.owner_added' );
+        expect( TRACK_OWNER_REMOVED ).toBe( 'track.owner_removed' );
         expect( TRACK_STREAMING_STATUS_CHANGED ).toBe( 'track.streaming_status_changed' );
         expect( TRACK_VIDEOTYPE_CHANGED ).toBe( 'track.videoTypeChanged' );
         expect( NO_DATA_FROM_SOURCE ).toBe( 'track.no_data_from_source' );
         expect( NO_AUDIO_INPUT ).toBe( 'track.no_audio_input' );
-        expect( TRACK_OWNER_CHANGED ).toBe( 'track.owner_changed' );
-        expect( TRACK_REMOVED ).toBe( 'track.removed' );
 
         expect( JitsiTrackEvents ).toBeDefined();
 
         expect( JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED ).toBe( 'track.audioLevelsChanged' );
         expect( JitsiTrackEvents.TRACK_AUDIO_OUTPUT_CHANGED ).toBe( 'track.audioOutputChanged' );
         expect( JitsiTrackEvents.TRACK_MUTE_CHANGED ).toBe( 'track.trackMuteChanged' );
+        expect( JitsiTrackEvents.TRACK_OWNER_ADDED ).toBe( 'track.owner_added' );
+        expect( JitsiTrackEvents.TRACK_OWNER_REMOVED ).toBe( 'track.owner_removed' );
         expect( JitsiTrackEvents.TRACK_STREAMING_STATUS_CHANGED ).toBe( 'track.streaming_status_changed' );
         expect( JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED ).toBe( 'track.videoTypeChanged' );
         expect( JitsiTrackEvents.NO_DATA_FROM_SOURCE ).toBe( 'track.no_data_from_source' );
         expect( JitsiTrackEvents.NO_AUDIO_INPUT ).toBe( 'track.no_audio_input' );
-        expect( JitsiTrackEvents.TRACK_OWNER_CHANGED ).toBe( 'track.owner_changed' );
-        expect( JitsiTrackEvents.TRACK_REMOVED ).toBe( 'track.removed' );
     } );
 
     it( "unknown members", () => {

JitsiTrackEvents.ts

      */
     NO_AUDIO_INPUT = 'track.no_audio_input',
 
+    /**
+     * Indicates that a new owner has been assigned to a remote track when SSRC rewriting is enabled.
+     */
+    TRACK_OWNER_ADDED = 'track.owner_added',
+
+    /**
+     * Indicates that an owner has been removed from a remote track when SSRC rewriting is enabled.
+     */
+    TRACK_OWNER_REMOVED = 'track.owner_removed',
+
     /**
      * Event fired whenever video track's streaming changes.
      * First argument is the sourceName of the track and the second is a string indicating if the connection is currently
      * The current status value can be obtained by calling JitsiRemoteTrack.getTrackStreamingStatus().
      */
     TRACK_STREAMING_STATUS_CHANGED = 'track.streaming_status_changed',
-
-    /**
-     * An SSRC has been remapped. The track is now associated with a new participant.
-     */
-    TRACK_OWNER_CHANGED = 'track.owner_changed',
-
-    /**
-     * A track is being removed. Fired when a session terminates for tracks
-     * that persist in ssrc-rewriting mode.
-     */
-    TRACK_REMOVED = 'track.removed',
 };
 
 // exported for backward compatibility
 export const TRACK_VIDEOTYPE_CHANGED = JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED;
 export const NO_DATA_FROM_SOURCE = JitsiTrackEvents.NO_DATA_FROM_SOURCE;
 export const NO_AUDIO_INPUT = JitsiTrackEvents.NO_AUDIO_INPUT;
+export const TRACK_OWNER_ADDED = JitsiTrackEvents.TRACK_OWNER_ADDED;
+export const TRACK_OWNER_REMOVED = JitsiTrackEvents.TRACK_OWNER_REMOVED;
 export const TRACK_STREAMING_STATUS_CHANGED = JitsiTrackEvents.TRACK_STREAMING_STATUS_CHANGED;
-export const TRACK_OWNER_CHANGED = JitsiTrackEvents.TRACK_OWNER_CHANGED;
-export const TRACK_REMOVED = JitsiTrackEvents.TRACK_REMOVED;

modules/RTC/JitsiRemoteTrack.js

      */
     setOwner(owner) {
         this.ownerEndpointId = owner;
-        this.emit(JitsiTrackEvents.TRACK_OWNER_CHANGED, owner);
     }
 
     /**

modules/RTC/TraceablePeerConnection.js

      */
     this.isP2P = isP2P;
 
+    /**
+     * A map that holds remote tracks signaled on the peerconnection indexed by their SSRC.
+     * @type {Map<number, JitsiRemoteTrack>}
+     */
+    this.remoteTracksBySsrc = new Map();
+
     /**
      * The map holds remote tracks associated with this peer connection. It maps user's JID to media type and a set of
      * remote tracks.
  */
 TraceablePeerConnection.prototype.getRemoteTracks = function(endpointId, mediaType) {
     let remoteTracks = [];
+
+    if (FeatureFlags.isSsrcRewritingSupported()) {
+        for (const remoteTrack of this.remoteTracksBySsrc.values()) {
+            const owner = remoteTrack.getParticipantId();
+
+            if (owner && (!endpointId || owner === endpointId)) {
+                if (!mediaType || remoteTrack.getType() === mediaType) {
+                    remoteTracks.push(remoteTrack);
+                }
+            }
+        }
+
+        return remoteTracks;
+    }
+
     const endpoints = endpointId ? [ endpointId ] : this.remoteTracks.keys();
 
     for (const endpoint of endpoints) {
  * @return {JitsiTrack|null}
  */
 TraceablePeerConnection.prototype.getTrackBySSRC = function(ssrc) {
+    if (FeatureFlags.isSsrcRewritingSupported()) {
+        return this.remoteTracksBySsrc.get(ssrc);
+    }
+
     if (typeof ssrc !== 'number') {
         throw new Error(`SSRC ${ssrc} is not a number`);
     }
         sourceName) {
     logger.info(`${this} creating remote track[endpoint=${ownerEndpointId},ssrc=${ssrc},`
         + `type=${mediaType},sourceName=${sourceName}]`);
-    let remoteTracksMap = this.remoteTracks.get(ownerEndpointId);
+    let remoteTracksMap;
+    let userTracksByMediaType;
 
-    if (!remoteTracksMap) {
-        remoteTracksMap = new Map();
-        remoteTracksMap.set(MediaType.AUDIO, new Set());
-        remoteTracksMap.set(MediaType.VIDEO, new Set());
-        this.remoteTracks.set(ownerEndpointId, remoteTracksMap);
-    }
+    if (FeatureFlags.isSsrcRewritingSupported()) {
+        const existingTrack = this.remoteTracksBySsrc.get(ssrc);
 
-    const userTracksByMediaType = remoteTracksMap.get(mediaType);
+        if (existingTrack) {
+            logger.info(`${this} ignored duplicated track event for SSRC[ssrc=${ssrc},type=${mediaType}]`);
 
-    if (userTracksByMediaType?.size
-        && Array.from(userTracksByMediaType).find(jitsiTrack => jitsiTrack.getTrack() === track)) {
-        // Ignore duplicated event which can originate either from 'onStreamAdded' or 'onTrackAdded'.
-        logger.info(`${this} ignored duplicated track event for track[endpoint=${ownerEndpointId},type=${mediaType}]`);
+            return;
+        }
+    } else {
+        remoteTracksMap = this.remoteTracks.get(ownerEndpointId);
 
-        return;
+        if (!remoteTracksMap) {
+            remoteTracksMap = new Map();
+            remoteTracksMap.set(MediaType.AUDIO, new Set());
+            remoteTracksMap.set(MediaType.VIDEO, new Set());
+            this.remoteTracks.set(ownerEndpointId, remoteTracksMap);
+        }
+
+        userTracksByMediaType = remoteTracksMap.get(mediaType);
+
+        if (userTracksByMediaType?.size
+            && Array.from(userTracksByMediaType).find(jitsiTrack => jitsiTrack.getTrack() === track)) {
+            // Ignore duplicated event which can originate either from 'onStreamAdded' or 'onTrackAdded'.
+            logger.info(`${this} ignored duplicated track event for track[endpoint=${ownerEndpointId},`
+                + `type=${mediaType}]`);
+
+            return;
+        }
     }
 
     const remoteTrack
                 this.isP2P,
                 sourceName);
 
-    userTracksByMediaType.add(remoteTrack);
+    if (FeatureFlags.isSsrcRewritingSupported()) {
+        this.remoteTracksBySsrc.set(ssrc, remoteTrack);
+    } else {
+        userTracksByMediaType.add(remoteTrack);
+    }
+
     this.eventEmitter.emit(RTCEvents.REMOTE_TRACK_ADDED, remoteTrack, this);
 };
 
     toBeRemoved.dispose();
     const participantId = toBeRemoved.getParticipantId();
 
-    if (!participantId && FeatureFlags.isSsrcRewritingSupported()) {
+    if (FeatureFlags.isSsrcRewritingSupported() && !participantId) {
         return;
-    }
-    const userTracksByMediaType = this.remoteTracks.get(participantId);
+    } else if (!FeatureFlags.isSsrcRewritingSupported()) {
+        const userTracksByMediaType = this.remoteTracks.get(participantId);
 
-    if (!userTracksByMediaType) {
-        logger.error(`${this} removeRemoteTrack: no remote tracks map for endpoint=${participantId}`);
-    } else if (!userTracksByMediaType.get(toBeRemoved.getType())?.delete(toBeRemoved)) {
-        logger.error(`${this} Failed to remove ${toBeRemoved} - type mapping messed up ?`);
+        if (!userTracksByMediaType) {
+            logger.error(`${this} removeRemoteTrack: no remote tracks map for endpoint=${participantId}`);
+        } else if (!userTracksByMediaType.get(toBeRemoved.getType())?.delete(toBeRemoved)) {
+            logger.error(`${this} Failed to remove ${toBeRemoved} - type mapping messed up ?`);
+        }
     }
+
     this.eventEmitter.emit(RTCEvents.REMOTE_TRACK_REMOVED, toBeRemoved);
 };
 
     this.signalingLayer.off(SignalingEvents.PEER_VIDEO_TYPE_CHANGED, this._peerVideoTypeChanged);
     this.peerconnection.removeEventListener('track', this.onTrack);
 
-    for (const peerTracks of this.remoteTracks.values()) {
-        for (const remoteTracks of peerTracks.values()) {
-            for (const remoteTrack of remoteTracks) {
-                this._removeRemoteTrack(remoteTrack);
+    if (FeatureFlags.isSsrcRewritingSupported()) {
+        for (const remoteTrack of this.remoteTracksBySsrc.values()) {
+            this._removeRemoteTrack(remoteTrack);
+        }
+        this.remoteTracksBySsrc.clear();
+    } else {
+        for (const peerTracks of this.remoteTracks.values()) {
+            for (const remoteTracks of peerTracks.values()) {
+                for (const remoteTrack of remoteTracks) {
+                    this._removeRemoteTrack(remoteTrack);
+                }
             }
         }
+        this.remoteTracks.clear();
     }
-    this.remoteTracks.clear();
 
     this._dtmfSender = null;
     this._dtmfTonesQueue = [];

modules/xmpp/JingleSessionPC.js

                     const track = this.peerconnection.getTrackBySSRC(oldSsrc);
 
                     if (track) {
-                        track.setSourceName(undefined);
-                        track.setOwner(undefined);
-                        track._setVideoType(undefined);
+                        track.setSourceName(null);
+                        track.setOwner(null);
+                        track._setVideoType(null);
+                        this.room.eventEmitter.emit(JitsiTrackEvents.TRACK_OWNER_REMOVED, track);
                     }
                 }
             } else {
                 logger.debug(`Existing SSRC re-mapped ${ssrc}: new owner=${owner}, source-name=${source}`);
                 const track = this.peerconnection.getTrackBySSRC(ssrc);
 
+                this.room.eventEmitter.emit(JitsiTrackEvents.TRACK_OWNER_REMOVED, track);
+
                 this._signalingLayer.setSSRCOwner(ssrc, owner, source);
                 track.setSourceName(source);
                 track.setOwner(owner);
 
+                this.room.eventEmitter.emit(JitsiTrackEvents.TRACK_OWNER_ADDED, track);
+
                 // Update the muted state and the video type on the track since the presence for this track could have
                 // been received before the updated source map is received on the bridge channel.
                 const peerMediaInfo = this._signalingLayer.getPeerMediaInfo(owner, mediaType, source);