ref(JingleSessionPC): detach from room.options

The options are coming from the config anyway.

JitsiConference.js

             value: now
         }));
     try {
-        jingleSession.initialize(false /* initiator */, this.room, this.rtc);
+        jingleSession.initialize(this.room, this.rtc, this.options.config);
     } catch (error) {
         GlobalOnErrorHandler.callErrorHandler(error);
     }
     // Accept the offer
     this.p2pJingleSession = jingleSession;
 
-    this.p2pJingleSession.initialize(
-        false /* initiator */, this.room, this.rtc);
+    this.p2pJingleSession.initialize(this.room, this.rtc, this.options.config);
 
     logger.info('Starting CallStats for P2P connection...');
 
     logger.info(
         'Created new P2P JingleSession', this.room.myroomjid, remoteJid);
 
-    this.p2pJingleSession.initialize(true /* initiator */, this.room, this.rtc);
+    this.p2pJingleSession.initialize(this.room, this.rtc, this.options.config);
 
     logger.info('Starting CallStats for P2P connection...');
 

modules/xmpp/JingleSession.js

      * the PeerConnection onCreateAnswer/Offer as defined by the WebRTC.
      * @param {Object} iceConfig the ICE servers config object as defined by
      * the WebRTC. Passed to the PeerConnection's constructor.
+     * @param {boolean} isInitiator indicates if it will be the side which
+     * initiates the session.
      */
     constructor(
             sid,
             remoteJid,
             connection,
             mediaConstraints,
-            iceConfig) {
+            iceConfig,
+            isInitiator) {
         this.sid = sid;
         this.localJid = localJid;
         this.remoteJid = remoteJid;
         this.mediaConstraints = mediaConstraints;
         this.iceConfig = iceConfig;
 
+        /**
+         * Indicates whether this instance is an initiator or an answerer of
+         * the Jingle session.
+         * @type {boolean}
+         */
+        this.isInitiator = isInitiator;
+
+        this.initiator = this.isInitiator ? this.localJid : this.remoteJid;
+
+        this.responder = this.isInitiator ? this.remoteJid : this.localJid;
+
         /**
          * Whether to use dripping or not. Dripping is sending trickle
          * candidates not one-by-one.
 
     /**
      * Prepares this object to initiate a session.
-     * @param {boolean} isInitiator whether we will be the Jingle initiator.
      * @param {ChatRoom} room the chat room for the conference associated with
      * this session
      * @param {RTC} rtc the RTC service instance
+     * @param {object} options - the options, see implementing class's
+     * {@link #doInitialize} description for more details.
      */
-    initialize(isInitiator, room, rtc) {
+    initialize(room, rtc, options) {
         if (this.state !== null) {
             const errmsg
                 = `attempt to initiate on session ${this.sid}
         this.room = room;
         this.rtc = rtc;
         this.state = JingleSessionState.PENDING;
-        this.initiator = isInitiator ? this.localJid : this.remoteJid;
-        this.responder = isInitiator ? this.remoteJid : this.localJid;
-        this.doInitialize();
+        this.doInitialize(options);
     }
 
     /**
      * The implementing class finishes initialization here. Called at the end of
      * {@link initialize}.
+     * @param {Object} options - The options specific to the implementing class.
      * @protected
      */
-    doInitialize() {} // eslint-disable-line no-empty-function
+    doInitialize(options) { } // eslint-disable-line no-unused-vars, no-empty-function, max-len
 
     /* eslint-disable no-unused-vars, no-empty-function */
 

modules/xmpp/JingleSessionPC.js

  */
 const DEFAULT_MAX_STATS = 300;
 
+/**
+ * @typedef {Object} JingleSessionPCOptions
+ * @property {Object} abTesting - A/B testing related options (ask George).
+ * @property {boolean} abTesting.enableSuspendVideoTest - enables the suspend
+ * video test ?(ask George).
+ * @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} 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.
+ * @property {boolean} gatherStats - Described in the config.js[1].
+ * @property {object} p2p - Peer to peer related options (FIXME those could be
+ * fetched from config.p2p on the upper level).
+ * @property {boolean} p2p.disableH264 - Described in the config.js[1].
+ * @property {boolean} p2p.preferH264 - Described in the config.js[1].
+ * @property {boolean} preferH264 - Described in the config.js[1].
+ * @property {Object} testing - Testing and/or experimental options.
+ * @property {boolean} testing.enableFirefoxSimulcast - Described in the
+ * config.js[1].
+ * @property {boolean} webrtcIceUdpDisable - Described in the config.js[1].
+ * @property {boolean} webrtcIceTcpDisable - Described in the config.js[1].
+ *
+ * [1]: https://github.com/jitsi/jitsi-meet/blob/master/config.js
+ */
 /**
  *
  */
      * @param {boolean} isP2P indicates whether this instance is
      * meant to be used in a direct, peer to peer connection or <tt>false</tt>
      * if it's a JVB connection.
-     * @param {boolean} isInitiator indicates whether or not we are the side
-     * which sends the 'session-initiate'.
-     * @param {object} options a set of config options
-     * @param {boolean} options.webrtcIceUdpDisable <tt>true</tt> to block UDP
-     * candidates.
-     * @param {boolean} options.webrtcIceTcpDisable <tt>true</tt> to block TCP
-     * candidates.
-     * @param {boolean} options.failICE it's an option used in the tests. Set to
-     * <tt>true</tt> to block any real candidates and make the ICE fail.
-     *
+     * @param {boolean} isInitiator indicates if it will be the side which
+     * initiates the session.
      * @constructor
      *
      * @implements {SignalingLayer}
             mediaConstraints,
             iceConfig,
             isP2P,
-            isInitiator,
-            options) {
+            isInitiator) {
         super(
-            sid, localJid, remoteJid, connection, mediaConstraints, iceConfig);
+            sid,
+            localJid,
+            remoteJid, connection, mediaConstraints, iceConfig, isInitiator);
 
         /**
          * Stores result of {@link window.performance.now()} at the time when
         this.lasticecandidate = false;
         this.closed = false;
 
-        /**
-         * Indicates whether this instance is an initiator or an answerer of
-         * the Jingle session.
-         * @type {boolean}
-         */
-        this.isInitiator = isInitiator;
-
         /**
          * Indicates whether or not this <tt>JingleSessionPC</tt> is used in
          * a peer to peer type of session.
          */
         this.signalingLayer = new SignalingLayerImpl();
 
-        this.webrtcIceUdpDisable = Boolean(options.webrtcIceUdpDisable);
-        this.webrtcIceTcpDisable = Boolean(options.webrtcIceTcpDisable);
-
-        /**
-         * Flag used to enforce ICE failure through the URL parameter for
-         * the automatic testing purpose.
-         * @type {boolean}
-         */
-        this.failICE = Boolean(options.failICE);
-
         this.modificationQueue
             = async.queue(this._processQueueTasks.bind(this), 1);
 
     }
 
     /**
-     *
+     * @inheritDoc
+     * @param {JingleSessionPCOptions} options  - a set of config options.
      */
-    doInitialize() {
+    doInitialize(options) {
+        this.failICE = Boolean(options.failICE);
         this.lasticecandidate = false;
+        this.options = options;
 
-        // True if reconnect is in progress
+        /**
+         * {@code true} if reconnect is in progress.
+         * @type {boolean}
+         */
         this.isReconnect = false;
 
-        // Set to true if the connection was ever stable
+        /**
+         * Set to {@code true} if the connection was ever stable
+         * @type {boolean}
+         */
         this.wasstable = false;
+        this.webrtcIceUdpDisable = Boolean(options.webrtcIceUdpDisable);
+        this.webrtcIceTcpDisable = Boolean(options.webrtcIceTcpDisable);
 
-        const pcOptions = { disableRtx: this.room.options.disableRtx };
+        const pcOptions = { disableRtx: options.disableRtx };
 
-        if (this.room.options.gatherStats) {
+        if (options.gatherStats) {
             pcOptions.maxstats = DEFAULT_MAX_STATS;
         }
 
         if (this.isP2P) {
             // simulcast needs to be disabled for P2P (121) calls
             pcOptions.disableSimulcast = true;
-            pcOptions.disableH264
-                = this.room.options.p2p && this.room.options.p2p.disableH264;
-            pcOptions.preferH264
-                = this.room.options.p2p && this.room.options.p2p.preferH264;
+            pcOptions.disableH264 = options.p2p && options.p2p.disableH264;
+            pcOptions.preferH264 = options.p2p && options.p2p.preferH264;
 
-            const abtestSuspendVideo = this._abtestSuspendVideoEnabled();
+            const abtestSuspendVideo = this._abtestSuspendVideoEnabled(options);
 
             if (typeof abtestSuspendVideo !== 'undefined') {
                 pcOptions.abtestSuspendVideo = abtestSuspendVideo;
         } else {
             // H264 does not support simulcast, so it needs to be disabled.
             pcOptions.disableSimulcast
-                = this.room.options.disableSimulcast
-                    || (this.room.options.preferH264
-                            && !this.room.options.disableH264);
-            pcOptions.preferH264 = this.room.options.preferH264;
+                = options.disableSimulcast
+                    || (options.preferH264 && !options.disableH264);
+            pcOptions.preferH264 = options.preferH264;
             pcOptions.enableFirefoxSimulcast
-                = this.room.options.testing
-                    && this.room.options.testing.enableFirefoxSimulcast;
-            pcOptions.enableLayerSuspension
-                = this.room.options.enableLayerSuspension;
+                = options.testing && options.testing.enableFirefoxSimulcast;
+            pcOptions.enableLayerSuspension = options.enableLayerSuspension;
         }
 
         this.peerconnection
         // The signaling layer will bind it's listeners at this point
         this.signalingLayer.setChatRoom(this.room);
 
-        if (!this.isP2P && this.room.options.enableLayerSuspension) {
+        if (!this.isP2P && options.enableLayerSuspension) {
             // If this is the bridge session, we'll listen for
             // IS_SELECTED_CHANGED events and notify the peer connection
             this.rtc.addListener(RTCEvents.IS_SELECTED_CHANGED,
                         `Error renegotiating after setting new remote ${
                             this.isInitiator ? 'answer: ' : 'offer: '}${error}`,
                         newRemoteSdp);
+
+                    // FIXME remove static method - there's no need
                     JingleSessionPC.onJingleFatalError(this, error);
                     finishedCallback(error);
                 });
      * If the A/B test for suspend video is disabled according to the room's
      * configuration, returns undefined. Otherwise returns a boolean which
      * indicates whether the suspend video option should be enabled or disabled.
+     * @param {JingleSessionPCOptions} options - The config options.
      */
-    _abtestSuspendVideoEnabled() {
-        if (!this.room.options.abTesting
-            || !this.room.options.abTesting.enableSuspendVideoTest) {
+    _abtestSuspendVideoEnabled({ abTesting }) {
+        if (!abTesting || !abTesting.enableSuspendVideoTest) {
             return;
         }
 

modules/xmpp/strophe.jingle.js

                     this.mediaConstraints,
                     isP2P ? this.p2pIceConfig : this.jvbIceConfig,
                     isP2P,
-                    /* initiator */ false,
-                    this.xmpp.options);
+                    /* initiator */ false);
 
             this.sessions[sess.sid] = sess;
 
                 this.mediaConstraints,
                 this.p2pIceConfig,
                 /* P2P */ true,
-                /* initiator */ true,
-                this.xmpp.options);
+                /* initiator */ true);
 
         this.sessions[sess.sid] = sess;