ref: recreate peerconnections to enable e2ee

Delays e2e encryption initialization until any encryption key is set.
Recreates peerconnections in order to enable insertable streams
only if the e2ee is used. This is to avoid bug around insertable streams
which may cause audio issue when the main JavaScript thread is loaded:

https://bugs.chromium.org/p/chromium/issues/detail?id=1103280

JitsiConference.js

     this.videoSIPGWHandler = new VideoSIPGW(this.room);
     this.recordingManager = new RecordingManager(this.room);
     this._conferenceJoinAnalyticsEventSent = false;
-
-    if (this.isE2EESupported()) {
-        this._e2eEncryption = new E2EEncryption(this, { salt: this.options.name });
-    }
 }
 
 // FIXME convert JitsiConference to ES6 - ASAP !
         }));
 
     try {
-        jingleSession.initialize(this.room, this.rtc, this.options.config);
+        jingleSession.initialize(this.room, this.rtc, {
+            ...this.options.config,
+            enableInsertableStreams: Boolean(this._e2eEncryption)
+        });
     } catch (error) {
         GlobalOnErrorHandler.callErrorHandler(error);
     }
     this.p2pJingleSession = jingleSession;
     this._sendConferenceJoinAnalyticsEvent();
 
-    this.p2pJingleSession.initialize(this.room, this.rtc, this.options.config);
+    this.p2pJingleSession.initialize(
+        this.room,
+        this.rtc, {
+            ...this.options.config,
+            enableInsertableStreams: Boolean(this._e2eEncryption)
+        });
 
     logger.info('Starting CallStats for P2P connection...');
 
         'Created new P2P JingleSession', this.room.myroomjid, remoteJid);
     this._sendConferenceJoinAnalyticsEvent();
 
-    this.p2pJingleSession.initialize(this.room, this.rtc, this.options.config);
+    this.p2pJingleSession.initialize(
+        this.room,
+        this.rtc, {
+            ...this.options.config,
+            enableInsertableStreams: Boolean(this._e2eEncryption)
+        });
 
     logger.info('Starting CallStats for P2P connection...');
 
     return browser.supportsInsertableStreams() && !(config.testing && config.testing.disableE2EE);
 };
 
+/**
+ * Initializes the E2E encryption module. Currently any active media session muste be restarted due to
+ * the limitation that the insertable streams constraint can only be set when a new PeerConnection instance is created.
+ *
+ * @private
+ * @returns {void}
+ */
+JitsiConference.prototype._initializeE2EEncryption = function() {
+    this._e2eEncryption = new E2EEncryption(this, { salt: this.options.name });
+
+    // Need to re-create the peerconnections in order to apply the insertable streams constraint
+    this.p2pJingleSession && this.stopP2PSession();
+
+    const jvbJingleSession = this.jvbJingleSession;
+
+    jvbJingleSession && jvbJingleSession.terminate(
+        null /* success callback => we don't care */,
+        error => {
+            logger.warn(`An error occurred while trying to terminate ${jvbJingleSession}`, error);
+        }, {
+            reason: 'success',
+            reasonDescription: 'restart required',
+            requestRestart: true,
+            sendSessionTerminate: true
+        });
+
+    this._maybeStartOrStopP2P(false);
+};
+
 /**
  * Sets the key to be used for End-To-End encryption.
  *
  * @returns {void}
  */
 JitsiConference.prototype.setE2EEKey = function(key) {
-    if (!this._e2eEncryption) {
-        logger.warn('Cannot set E2EE key: there is no defined context, platform is likely unsupported.');
+    if (!this.isE2EESupported()) {
+        logger.warn('Cannot set E2EE key: platform is not supported.');
 
         return;
     }
 
+    if (!this._e2eEncryption) {
+        this._initializeE2EEncryption();
+    }
+
     this._e2eEncryption.setKey(key);
 };
 

modules/RTC/RTC.js

      * @param {boolean} isP2P Indicates whether or not the new TPC will be used
      *      in a peer to peer type of session.
      * @param {object} options The config options.
+     * @param {boolean} options.enableInsertableStreams - Set to true when the insertable streams constraints is to be
+     * enabled on the PeerConnection.
      * @param {boolean} options.disableSimulcast If set to 'true' will disable
      *      the simulcast.
      * @param {boolean} options.disableRtx If set to 'true' will disable the
 
         // FIXME: We should rename iceConfig to pcConfig.
 
-        if (browser.supportsInsertableStreams() && !(this.options.testing && this.options.testing.disableE2EE)) {
+        if (options.enableInsertableStreams) {
             logger.debug('E2EE - setting insertable streams constraints');
             iceConfig.encodedInsertableStreams = true;
             iceConfig.forceEncodedAudioInsertableStreams = true; // legacy, to be removed in M85.

modules/xmpp/JingleSession.js

      * @param {Object} options
      * @param {string} [options.reason] XMPP Jingle error condition
      * @param {string} [options.reasonDescription] some meaningful error message
+     * @param {boolean} [options.requestRestart=false] set to true to ask Jicofo to start a new session one this once is
+     * terminated.
      * @param {boolean} [options.sendSessionTerminate=true] set to false to skip
      * sending session-terminate. It may not make sense to send it if the XMPP
      * connection has been closed already or if the remote peer has disconnected

modules/xmpp/JingleSessionPC.js

  * @property {boolean} disableH264 - Described in the config.js[1].
  * @property {boolean} disableRtx - Described in the config.js[1].
  * @property {boolean} disableSimulcast - Described in the config.js[1].
+ * @property {boolean} enableInsertableStreams - Set to true when the insertable streams constraints is to be enabled
+ * on the PeerConnection.
  * @property {boolean} enableLayerSuspension - Described in the config.js[1].
  * @property {boolean} failICE - it's an option used in the tests. Set to
  * <tt>true</tt> to block any real candidates and make the ICE fail.
             pcOptions.maxstats = DEFAULT_MAX_STATS;
         }
         pcOptions.capScreenshareBitrate = false;
+        pcOptions.enableInsertableStreams = options.enableInsertableStreams;
+
         if (this.isP2P) {
             // simulcast needs to be disabled for P2P (121) calls
             pcOptions.disableSimulcast = true;
                 && sessionTerminate.c(
                     'bridge-session', {
                         xmlns: 'http://jitsi.org/protocol/focus',
-                        id: this._bridgeSessionId
+                        id: this._bridgeSessionId,
+                        restart: options && options.requestRestart === true
                     }).up();
 
             // Calling tree() to print something useful