ref(e2ee): extract E2EEncryption module

Moves the logics which deal with JitsiConference events to a separate module.

JitsiConference.js

     from './modules/connectivity/IceFailedHandling';
 import ParticipantConnectionStatusHandler
     from './modules/connectivity/ParticipantConnectionStatus';
-import E2EEContext from './modules/e2ee/E2EEContext';
+import { E2EEncryption } from './modules/e2ee/E2EEncryption';
 import E2ePing from './modules/e2eping/e2eping';
 import Jvb121EventGenerator from './modules/event/Jvb121EventGenerator';
 import RecordingManager from './modules/recording/RecordingManager';
     this.recordingManager = new RecordingManager(this.room);
     this._conferenceJoinAnalyticsEventSent = false;
 
-    const config = this.options.config;
-
-    if (browser.supportsInsertableStreams() && !(config.testing && config.testing.disableE2EE)) {
-        this._e2eeCtx = new E2EEContext({ salt: this.options.name });
+    if (this.isE2EESupported()) {
+        this._e2eEncryption = new E2EEncryption(this, { salt: this.options.name });
     }
 }
 
         actorParticipant = this.participants[actorId];
     }
 
-    // Setup E2EE on the sender that is created for the unmuted track.
-    if (this._e2eeCtx && !track.isMuted() && browser.doesVideoMuteByStreamRemove()) {
-        if (this.p2pJingleSession) {
-            this._setupSenderE2EEForTrack(this.p2pJingleSession, track);
-        }
-        if (this.jvbJingleSession) {
-            this._setupSenderE2EEForTrack(this.jvbJingleSession, track);
-        }
-    }
-
     this.eventEmitter.emit(JitsiConferenceEvents.TRACK_MUTE_CHANGED, track, actorParticipant);
 };
 
         this.room.setVideoMute(newTrack.isMuted());
     }
 
-    // Setup E2EE on the new track that has been added
-    // to the conference, apply it on all the open peerconnections.
-    if (this._e2eeCtx) {
-        if (this.p2pJingleSession) {
-            this._setupSenderE2EEForTrack(this.p2pJingleSession, newTrack);
-        }
-        if (this.jvbJingleSession) {
-            this._setupSenderE2EEForTrack(this.jvbJingleSession, newTrack);
-        }
-    }
-
     newTrack.muteHandler = this._fireMuteChangeEvent.bind(this, newTrack);
     newTrack.audioLevelHandler = this._fireAudioLevelChangeEvent.bind(this);
     newTrack.addEventListener(
         return;
     }
 
-    // Setup E2EE handling, if supported.
-    this._setupReceiverE2EEForTrack(track);
-
     const id = track.getParticipantId();
     const participant = this.getParticipantById(id);
 
     if (this.p2pJingleSession === session) {
         logger.info('P2P setAnswer');
 
-        // Setup E2EE.
-        const localTracks = this.getLocalTracks();
-
-        for (const track of localTracks) {
-            this._setupSenderE2EEForTrack(session, track);
-        }
-
         this.p2pJingleSession.setAnswer(answer);
         this.eventEmitter.emit(JitsiConferenceEvents._MEDIA_SESSION_STARTED, this.p2pJingleSession);
     }
                         JitsiConferenceEvents._MEDIA_SESSION_ACTIVE_CHANGED,
                         jingleSession);
                 }
-
-                // Setup E2EE.
-                for (const track of localTracks) {
-                    this._setupSenderE2EEForTrack(jingleSession, track);
-                }
             },
             error => {
                 GlobalOnErrorHandler.callErrorHandler(error);
             this.eventEmitter.emit(
                 JitsiConferenceEvents._MEDIA_SESSION_STARTED,
                 this.p2pJingleSession);
-
-            // Setup E2EE.
-            for (const track of localTracks) {
-                this._setupSenderE2EEForTrack(jingleSession, track);
-            }
         },
         error => {
             logger.error(
  * @returns {boolean}
  */
 JitsiConference.prototype.isE2EESupported = function() {
-    return Boolean(this._e2eeCtx);
+    const config = this.options.config;
+
+    return browser.supportsInsertableStreams() && !(config.testing && config.testing.disableE2EE);
 };
 
 /**
  * @returns {void}
  */
 JitsiConference.prototype.setE2EEKey = function(key) {
-    if (!this._e2eeCtx) {
+    if (!this._e2eEncryption) {
         logger.warn('Cannot set E2EE key: there is no defined context, platform is likely unsupported.');
 
         return;
     }
 
-    this._e2eeCtx.setKey(key);
+    this._e2eEncryption.setKey(key);
 };
 
 /**
         this.room.getLobby().approveAccess(id);
     }
 };
-
-/**
- * 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(session, track) {
-    if (!this._e2eeCtx) {
-        return;
-    }
-    const pc = session.peerconnection;
-    const sender = pc.findSenderForTrack(track.track);
-
-    if (sender) {
-        this._e2eeCtx.handleSender(sender, track.getType(), track.getParticipantId());
-    } 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) {
-    if (!this._e2eeCtx) {
-        return;
-    }
-    const session = track.isP2P ? this.p2pJingleSession : this.jvbJingleSession;
-    const pc = session && session.peerconnection;
-
-    if (pc) {
-        const receiver = pc.findReceiverForTrack(track.track);
-
-        if (receiver) {
-            this._e2eeCtx.handleReceiver(receiver, track.getType(), track.getParticipantId());
-        } else {
-            logger.warn(`Could not handle E2EE for remote ${track.getType()} track: receiver not found`);
-        }
-    }
-};

modules/RTC/TraceablePeerConnection.js

 
     remoteTracksMap.set(mediaType, remoteTrack);
 
-    this.eventEmitter.emit(RTCEvents.REMOTE_TRACK_ADDED, remoteTrack);
+    this.eventEmitter.emit(RTCEvents.REMOTE_TRACK_ADDED, remoteTrack, this);
 };
 
 /* eslint-enable max-params */
     return this.localSSRCs.get(rtcId);
 };
 
+/**
+ * Checks if given track belongs to this peerconnection instance.
+ *
+ * @param {JitsiLocalTrack|JitsiRemoteTrack} track - The track to be checked.
+ * @returns {boolean}
+ */
+TraceablePeerConnection.prototype.containsTrack = function(track) {
+    if (track.isLocal()) {
+        return this.localTracks.has(track.rtcId);
+    }
+
+    const participantId = track.getParticipantId();
+    const remoteTracksMap = this.remoteTracks.get(participantId);
+
+    return Boolean(remoteTracksMap && remoteTracksMap.get(track.getType()) === track);
+};
+
 /**
  * Add {@link JitsiLocalTrack} to this TPC.
  * @param {JitsiLocalTrack} track

modules/e2ee/E2EEncryption.js

+/* global __filename */
+import { getLogger } from 'jitsi-meet-logger';
+
+import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
+import browser from '../browser';
+import RTCEvents from '../../service/RTC/RTCEvents';
+
+import E2EEContext from './E2EEContext';
+
+const logger = getLogger(__filename);
+
+/**
+ * This module integrates {@link E2EEContext} with {@link JitsiConference} in order to enable E2E encryption.
+ */
+export class E2EEncryption {
+    /**
+     * A constructor.
+     * @param {JitsiConference} conference - The conference instance for which E2E encryption is to be enabled.
+     * @param {Object} options
+     * @param {string} options.salt - Salt to be used for key deviation. Check {@link E2EEContext} for more details.
+     */
+    constructor(conference, { salt }) {
+        this.conference = conference;
+        this._e2eeCtx = new E2EEContext({ salt });
+        this.conference.on(
+            JitsiConferenceEvents._MEDIA_SESSION_STARTED,
+            this._onMediaSessionStarted.bind(this));
+
+        // FIXME add events to TraceablePeerConnection which will allow to see when there's new receiver or sender
+        //  added instead of shenanigans around conference track events and track muted.
+        this.conference.on(
+            JitsiConferenceEvents.TRACK_ADDED,
+            track => track.isLocal() && this._onLocalTrackAdded(track));
+        this.conference.rtc.on(
+            RTCEvents.REMOTE_TRACK_ADDED,
+            (track, tpc) => this._setupReceiverE2EEForTrack(tpc, track));
+        this.conference.on(
+            JitsiConferenceEvents.TRACK_MUTE_CHANGED,
+            this._trackMuteChanged.bind(this));
+    }
+
+    /**
+     * Setups E2E encryption for the new session.
+     * @param {JingleSessionPC} session - the new media session.
+     * @private
+     */
+    _onMediaSessionStarted(session) {
+        const localTracks = this.conference.getLocalTracks();
+
+        for (const track of localTracks) {
+            this._setupSenderE2EEForTrack(session, track);
+        }
+    }
+
+    /**
+     * Setup E2EE on the new track that has been added to the conference, apply it on all the open peerconnections.
+     * @param {JitsiLocalTrack} track - the new track that's being added to the conference.
+     * @private
+     */
+    _onLocalTrackAdded(track) {
+        for (const session of this.conference._getMediaSessions()) {
+            this._setupSenderE2EEForTrack(session, track);
+        }
+    }
+
+    /**
+     * Sets the key to be used for End-To-End encryption.
+     *
+     * @param {string} key - the key to be used.
+     * @returns {void}
+     */
+    setKey(key) {
+        this._e2eeCtx.setKey(key);
+    }
+
+    /**
+     * Setup E2EE for the receiving side.
+     *
+     * @returns {void}
+     */
+    _setupReceiverE2EEForTrack(tpc, track) {
+        const receiver = tpc.findReceiverForTrack(track.track);
+
+        if (receiver) {
+            this._e2eeCtx.handleReceiver(receiver, track.getType(), track.getParticipantId());
+        } else {
+            logger.warn(`Could not handle E2EE for ${track}: receiver not found in: ${tpc}`);
+        }
+    }
+
+    /**
+     * Setup E2EE for the sending side.
+     *
+     * @param {JingleSessionPC} session - the session which sends the media produced by the track.
+     * @param {JitsiLocalTrack} track - the local track for which e2e encoder will be configured.
+     * @returns {void}
+     */
+    _setupSenderE2EEForTrack(session, track) {
+        const pc = session.peerconnection;
+        const sender = pc && pc.findSenderForTrack(track.track);
+
+        if (sender) {
+            this._e2eeCtx.handleSender(sender, track.getType(), track.getParticipantId());
+        } else {
+            logger.warn(`Could not handle E2EE for ${track}: sender not found in ${pc}`);
+        }
+    }
+
+    /**
+     * Setup E2EE on the sender that is created for the unmuted local video track.
+     * @param {JitsiLocalTrack} track - the track for which muted status has changed.
+     * @private
+     */
+    _trackMuteChanged(track) {
+        if (browser.doesVideoMuteByStreamRemove() && track.isLocal() && track.isVideoTrack() && !track.isMuted()) {
+            for (const session of this.conference._getMediaSessions()) {
+                this._setupSenderE2EEForTrack(session, track);
+            }
+        }
+    }
+}