hips: fix enabling E2EE for tracks added later to the conference

JitsiConference.js

 
     this.eventEmitter.emit(JitsiConferenceEvents.TRACK_ADDED, newTrack);
 
-    // Setup E2EE handling, if supported.
-    if (!this.isP2PActive() && this._e2eeCtx) {
-        const activeTPC = this.getActivePeerConnection();
-        const sender = activeTPC ? activeTPC.findSenderForTrack(newTrack.track) : null;
-
-        if (sender) {
-            this._e2eeCtx.handleSender(sender, newTrack.getType());
-        } else {
-            logger.warn(`Could not handle E2EE for local ${newTrack.getType()} track: sender not found`);
-        }
-    }
+    this._setupSenderE2EEForTrack(newTrack);
 };
 
 /**
     }
 
     // Setup E2EE handling, if supported.
-    if (!this.isP2PActive() && this._e2eeCtx) {
-        const activeTPC = this.getActivePeerConnection();
-        const receiver = activeTPC ? activeTPC.findReceiverForTrack(track.track) : null;
-
-        if (receiver) {
-            this._e2eeCtx.handleReceiver(receiver, track.getType());
-        } else {
-            logger.warn(`Could not handle E2EE for remote ${track.getType()} track: receiver not found`);
-        }
-    }
+    this._setupReceiverE2EEForTrack(track);
 
     const id = track.getParticipantId();
     const participant = this.getParticipantById(id);
  * @param {JitsiRemoteTrack} removedTrack
  */
 JitsiConference.prototype.onRemoteTrackRemoved = function(removedTrack) {
-    // TODO: handle E2EE.
-
     this.getParticipants().forEach(participant => {
         const tracks = participant.getTracks();
 
     this._setBridgeChannel(jingleOffer, jingleSession.peerconnection);
 
     // Add local tracks to the session
+    const localTracks = this.getLocalTracks();
+
     try {
         jingleSession.acceptOffer(
             jingleOffer,
                 if (this.isP2PActive() && this.jvbJingleSession) {
                     this._suspendMediaTransferForJvbConnection();
                 }
+
+                // Setup E2EE.
+                for (const track of localTracks) {
+                    this._setupSenderE2EEForTrack(track);
+                }
             },
             error => {
                 GlobalOnErrorHandler.callErrorHandler(error);
                 logger.error(
                     'Failed to accept incoming Jingle session', error);
             },
-            this.getLocalTracks()
+            localTracks
         );
 
         // Start callstats as soon as peerconnection is initialized,
 
     this._e2eeCtx.setKey(key);
 };
+
+/**
+ * Setup E2EE for the sending side, if supported.
+ * Note that this is only done for the JVB Peer Connecction.
+ *
+ * @returns {void}
+ */
+JitsiConference.prototype._setupSenderE2EEForTrack = function(track) {
+    const jvbPc = this.jvbJingleSession ? this.jvbJingleSession.peerconnection : null;
+
+    if (jvbPc && this._e2eeCtx) {
+        const sender = jvbPc.findSenderForTrack(track.track);
+
+        if (sender) {
+            this._e2eeCtx.handleSender(sender, track.getType());
+        } else {
+            logger.warn(`Could not handle E2EE for local ${track.getType()} track: sender not found`);
+        }
+    }
+};
+
+/**
+ * Setup E2EE for the receiving side, if supported.
+ * Note that this is only done for the JVB Peer Connecction.
+ *
+ * @returns {void}
+ */
+JitsiConference.prototype._setupReceiverE2EEForTrack = function(track) {
+    const jvbPc = this.jvbJingleSession ? this.jvbJingleSession.peerconnection : null;
+
+    if (jvbPc && this._e2eeCtx) {
+        const receiver = jvbPc.findReceiverForTrack(track.track);
+
+        if (receiver) {
+            this._e2eeCtx.handleReceiver(receiver, track.getType());
+        } else {
+            logger.warn(`Could not handle E2EE for remote ${track.getType()} track: receiver not found`);
+        }
+    }
+};

modules/e2ee/E2EEContext.js

     undefined: 1 // frame.type is not set on audio
 };
 
+// Flag to set on senders / receivers to avoid setting up the encryption transform
+// more than once.
+const kJitsiE2EE = Symbol('kJitsiE2EE');
 
 /**
  * Context encapsulating the cryptography bits required for E2EE.
      * @param {string} kind - The kind of track this receiver belongs to.
      */
     handleReceiver(receiver, kind) {
+        if (receiver[kJitsiE2EE]) {
+            return;
+        }
+
         const receiverStreams
             = kind === 'video' ? receiver.createEncodedVideoStreams() : receiver.createEncodedAudioStreams();
         const transform = new TransformStream({
         receiverStreams.readableStream
             .pipeThrough(transform)
             .pipeTo(receiverStreams.writableStream);
+
+        receiver[kJitsiE2EE] = true;
     }
 
     /**
      * @param {string} kind - The kind of track this sender belongs to.
      */
     handleSender(sender, kind) {
+        if (sender[kJitsiE2EE]) {
+            return;
+        }
+
         const senderStreams
             = kind === 'video' ? sender.createEncodedVideoStreams() : sender.createEncodedAudioStreams();
         const transform = new TransformStream({
         senderStreams.readableStream
             .pipeThrough(transform)
             .pipeTo(senderStreams.writableStream);
+
+        sender[kJitsiE2EE] = true;
     }
 
     /**