Merge pull request #372 from jitsi/move_jingle_session

Move JingleSessionPC from ChatRoom to JitsiConference

JitsiConference.js

  * @constructor
  */
 function JitsiConference(options) {
-    if(!options.name || options.name.toLowerCase() !== options.name) {
+    if (!options.name || options.name.toLowerCase() !== options.name) {
         var errmsg
             = "Invalid conference name (no conference name passed or it "
                 + "contains invalid characters like capital letters)!";
     this._init(options);
     this.componentsVersions = new ComponentsVersions(this);
     this.participants = {};
+    /**
+     * Jingle Session instance
+     * @type {JingleSessionPC}
+     */
+    this.jingleSession = null;
     this.lastDominantSpeaker = null;
     this.dtmfManager = null;
     this.somebodySupportsDTMF = false;
  * @param connection {JitsiConnection} overrides this.connection
  */
 JitsiConference.prototype._init = function (options) {
-    if(!options)
+    if (!options)
         options = {};
 
     // Override connection and xmpp properties (Usefull if the connection
     // reloaded)
-    if(options.connection) {
+    if (options.connection) {
         this.connection = options.connection;
         this.xmpp = this.connection.xmpp;
         // Setup XMPP events only if we have new connection object.
 
     this.room.updateDeviceAvailability(RTC.getDeviceAvailability());
 
-    if(!this.rtc) {
+    if (!this.rtc) {
         this.rtc = new RTC(this, options);
         this.eventManager.setupRTCListeners();
     }
                 options.config.peerDisconnectedThroughRtcTimeout);
     this.participantConnectionStatus.init();
 
-    if(!this.statistics) {
+    if (!this.statistics) {
         this.statistics = new Statistics(this.xmpp, {
             callStatsID: this.options.config.callStatsID,
             callStatsSecret: this.options.config.callStatsSecret,
  * @param password {string} the password
  */
 JitsiConference.prototype.join = function (password) {
-    if(this.room)
+    if (this.room)
         this.room.join(password);
 };
 
     this.getLocalTracks().forEach(track => this.onTrackRemoved(track));
 
     this.rtc.closeAllDataChannels();
-    if(this.statistics)
+    if (this.statistics)
         this.statistics.dispose();
 
     // leave the conference
             // ChatRoom instance.
             this.getParticipants().forEach(
                 participant => this.onMemberLeft(participant.getJid()));
+            // Close the JingleSession
+            if (this.jingleSession) {
+                this.jingleSession.close();
+                this.jingleSession = null;
+            }
         });
     }
 
  * Note: consider adding eventing functionality by extending an EventEmitter impl, instead of rolling ourselves
  */
 JitsiConference.prototype.on = function (eventId, handler) {
-    if(this.eventEmitter)
+    if (this.eventEmitter)
         this.eventEmitter.on(eventId, handler);
 };
 
  * Note: consider adding eventing functionality by extending an EventEmitter impl, instead of rolling ourselves
  */
 JitsiConference.prototype.off = function (eventId, handler) {
-    if(this.eventEmitter)
+    if (this.eventEmitter)
         this.eventEmitter.removeListener(eventId, handler);
 };
 
  * @param handler {Function} handler for the command
  */
  JitsiConference.prototype.addCommandListener = function (command, handler) {
-    if(this.room)
+    if (this.room)
         this.room.addPresenceListener(command, handler);
  };
 
   * @param command {String} the name of the command
   */
  JitsiConference.prototype.removeCommandListener = function (command) {
-    if(this.room)
+    if (this.room)
         this.room.removePresenceListener(command);
  };
 
  * @param message the text message.
  */
 JitsiConference.prototype.sendTextMessage = function (message) {
-    if(this.room)
+    if (this.room)
         this.room.sendMessage(message);
 };
 
  * @param values {Object} with keys and values that will be sent.
  **/
 JitsiConference.prototype.sendCommand = function (name, values) {
-    if(this.room) {
+    if (this.room) {
         this.room.addToPresence(name, values);
         this.room.sendPresence();
     }
  * @param name {String} the name of the command.
  **/
 JitsiConference.prototype.removeCommand = function (name) {
-    if(this.room)
+    if (this.room)
         this.room.removeFromPresence(name);
 };
 
  * @param name the display name to set
  */
 JitsiConference.prototype.setDisplayName = function(name) {
-    if(this.room){
+    if (this.room){
         // remove previously set nickname
         this.room.removeFromPresence("nick");
 
  * @return {Transcriber} the transcriber object
  */
 JitsiConference.prototype.getTranscriber = function(){
-    if(this.transcriber === undefined){
+    if (this.transcriber === undefined){
         this.transcriber = new Transcriber();
         //add all existing local audio tracks to the transcriber
         this.rtc.localTracks.forEach(function (localTrack) {
-            if(localTrack.isAudioTrack()){
+            if (localTrack.isAudioTrack()){
                 this.transcriber.addTrack(localTrack);
             }
         }.bind(this));
         //and all remote audio tracks
         this.rtc.remoteTracks.forEach(function (remoteTrack){
-            if(remoteTrack.isAudioTrack()){
+            if (remoteTrack.isAudioTrack()){
                 this.transcriber.addTrack(remoteTrack);
             }
         }.bind(this));
 /**
  * Removes JitsiLocalTrack from the conference and performs
  * a new offer/answer cycle.
- * @param track the JitsiLocalTrack object.
+ * @param {JitsiLocalTrack} track
  * @returns {Promise}
  */
 JitsiConference.prototype.removeTrack = function (track) {
             newTrack.ssrcHandler);
     }
     // Now replace the stream at the lower levels
-    return this.room.replaceStream (oldTrack, newTrack)
+    return this._doReplaceTrack(oldTrack, newTrack)
         .then(() => {
             if (oldTrack) {
                 this.onTrackRemoved(oldTrack);
         });
 };
 
+/**
+ * Replaces the tracks at the lower level by going through the Jingle session
+ * and WebRTC peer connection. The method will resolve immediately if there is
+ * currently no JingleSession started.
+ * @param {JitsiLocalTrack|null} oldTrack the track to be removed during
+ * the process or <tt>null</t> if the method should act as "add track"
+ * @param {JitsiLocalTrack|null} newTrack the new track to be added or
+ * <tt>null</tt> if the method should act as "remove track"
+ * @return {Promise}
+ * @private
+ */
+JitsiConference.prototype._doReplaceTrack = function (oldTrack, newTrack) {
+    if (this.jingleSession) {
+        return this.jingleSession.replaceTrack(oldTrack, newTrack);
+    } else {
+        return Promise.resolve();
+    }
+};
+
 /**
  * Operations related to creating a new track
  * @param {JitsiLocalTrack} newTrack the new track being created
     this.eventEmitter.emit(JitsiConferenceEvents.TRACK_ADDED, newTrack);
 };
 
+/**
+ * Adds loca WebRTC stream to the conference.
+ * @param {MediaStream} stream new stream that will be added.
+ * @param {function} callback callback executed after successful stream addition.
+ * @param {function(error)} errorCallback callback executed if stream addition fail.
+ * @param {object} ssrcInfo object with information about the SSRCs associated with the
+ * stream.
+ * @param {boolean} [dontModifySources] if <tt>true</tt> _modifySources won't be
+ * called. The option is used for adding stream, before the Jingle call is
+ * started. That is before the 'session-accept' is sent.
+ */
+JitsiConference.prototype._addLocalStream
+    = function (stream, callback, errorCallback, ssrcInfo, dontModifySources) {
+    if (this.jingleSession) {
+        this.jingleSession.addStream(
+            stream, callback, errorCallback, ssrcInfo, dontModifySources);
+    } else {
+        // We are done immediately
+        logger.warn("Add local MediaStream - no JingleSession started yet");
+        callback();
+    }
+};
+
+/**
+ * Remove local WebRTC media stream.
+ * @param {MediaStream} stream the stream that will be removed.
+ * @param {function} callback callback executed after successful stream removal.
+ * @param {function} errorCallback callback executed if stream removal fail.
+ * @param {object} ssrcInfo object with information about the SSRCs associated
+ * with the stream.
+ */
+JitsiConference.prototype.removeLocalStream
+    = function (stream, callback, errorCallback, ssrcInfo) {
+    if (this.jingleSession) {
+        this.jingleSession.removeStream(
+            stream, callback, errorCallback, ssrcInfo);
+    } else {
+        // We are done immediately
+        logger.warn("Remove local MediaStream - no JingleSession started yet");
+        callback();
+    }
+};
+
+/**
+ * Generate ssrc info object for a stream with the following properties:
+ * - ssrcs - Array of the ssrcs associated with the stream.
+ * - groups - Array of the groups associated with the stream.
+ */
+JitsiConference.prototype._generateNewStreamSSRCInfo = function () {
+    if (!this.jingleSession) {
+        logger.warn("The call haven't been started. " +
+            "Cannot generate ssrc info at the moment!");
+        return null;
+    }
+    return this.jingleSession.generateNewStreamSSRCInfo();
+};
+
 /**
  * Get role of the local user.
  * @returns {string} user role: 'moderator' or 'none'
     // Add track to JitsiParticipant.
     participant._tracks.push(track);
 
-    if(this.transcriber){
+    if (this.transcriber){
         this.transcriber.addTrack(track);
     }
 
     }
 
     // Accept incoming call
-    this.room.setJingleSession(jingleSession);
+    this.jingleSession = jingleSession;
     this.room.connectionTimes["session.initiate"] = now;
     // Log "session.restart"
     if (this.wasStopped) {
          *  problems between sdp-interop and trying to keep the ssrcs
          *  consistent
          */
-        if(localTrack.isVideoTrack() && localTrack.isMuted() && !RTCBrowserType.isFirefox()) {
+        if (localTrack.isVideoTrack() && localTrack.isMuted() && !RTCBrowserType.isFirefox()) {
             /**
              * Handles issues when the stream is added before the peerconnection
              * is created. The peerconnection is created when second participant
              * In order to solve issues like the above one here we have to
              * generate the ssrc information for the track .
              */
-            localTrack._setSSRC(
-                this.room.generateNewStreamSSRCInfo());
+            localTrack._setSSRC(this._generateNewStreamSSRCInfo());
             ssrcInfo = {
                 mtype: localTrack.getType(),
                 type: "addMuted",
             };
         }
         try {
-            this.room.addStream(
+            this._addLocalStream(
                 localTrack.getOriginalStream(), function () {}, function () {},
-                ssrcInfo, true);
+                ssrcInfo, true /* don't modify SSRCs */);
         } catch(e) {
             GlobalOnErrorHandler.callErrorHandler(e);
             logger.error(e);
         this.statistics.stopCallStats();
     }
     // Current JingleSession is invalid so set it to null on the room
-    this.room.setJingleSession(null);
+    this.jingleSession = null;
     // Let the RTC service do any cleanups
     this.rtc.onCallEnded();
     // PeerConnection has been closed which means that SSRCs stored in
  * Returns true if recording is supported and false if not.
  */
 JitsiConference.prototype.isRecordingSupported = function () {
-    if(this.room)
+    if (this.room)
         return this.room.isRecordingSupported();
     return false;
 };
  * Starts/stops the recording
  */
 JitsiConference.prototype.toggleRecording = function (options) {
-    if(this.room)
+    if (this.room)
         return this.room.toggleRecording(options, function (status, error) {
             this.eventEmitter.emit(
                 JitsiConferenceEvents.RECORDER_STATE_CHANGED, status, error);
  * Returns true if the SIP calls are supported and false otherwise
  */
 JitsiConference.prototype.isSIPCallingSupported = function () {
-    if(this.room)
+    if (this.room)
         return this.room.isSIPCallingSupported();
     return false;
 };
  * @param number the number
  */
 JitsiConference.prototype.dial = function (number) {
-    if(this.room)
+    if (this.room)
         return this.room.dial(number);
     return new Promise(function(resolve, reject){
         reject(new Error("The conference is not created yet!"));});
  * Hangup an existing call
  */
 JitsiConference.prototype.hangup = function () {
-    if(this.room)
+    if (this.room)
         return this.room.hangup();
     return new Promise(function(resolve, reject){
         reject(new Error("The conference is not created yet!"));});
  * Returns the phone number for joining the conference.
  */
 JitsiConference.prototype.getPhoneNumber = function () {
-    if(this.room)
+    if (this.room)
         return this.room.getPhoneNumber();
     return null;
 };
  * Returns the pin for joining the conference with phone.
  */
 JitsiConference.prototype.getPhonePin = function () {
-    if(this.room)
+    if (this.room)
         return this.room.getPhonePin();
     return null;
 };
  * for its session.
  */
 JitsiConference.prototype.getConnectionState = function () {
-    if(this.room)
-        return this.room.getConnectionState();
-    return null;
+    if (this.jingleSession) {
+        return this.jingleSession.getIceConnectionState();
+    } else {
+        return null;
+    }
 };
 
 /**

modules/RTC/JitsiLocalTrack.js

  * @returns {Promise}
  */
 JitsiLocalTrack.prototype._addStreamToConferenceAsUnmute = function () {
-    if (!this.conference || !this.conference.room) {
+    if (!this.conference) {
         return Promise.resolve();
     }
 
     var self = this;
 
     return new Promise(function(resolve, reject) {
-        self.conference.room.addStream(
+        self.conference._addLocalStream(
             self.stream,
             resolve,
             (error) => reject(new Error(error)),
  */
 JitsiLocalTrack.prototype._removeStreamFromConferenceAsMute =
 function (successCallback, errorCallback) {
-    if (!this.conference || !this.conference.room) {
+    if (!this.conference) {
         successCallback();
         return;
     }
 
-    this.conference.room.removeStream(
+    this.conference.removeLocalStream(
         this.stream,
         successCallback,
         (error) => errorCallback(new Error(error)),

modules/xmpp/ChatRoom.js

         this.moderator = new Moderator(this.roomjid, this.xmpp, this.eventEmitter,
             {connection: this.xmpp.options, conference: this.options});
         this.initPresenceMap();
-        this.session = null;
         this.lastPresences = {};
         this.phoneNumber = null;
         this.phonePin = null;
         return null;
     }
 
-    setJingleSession (session){
-        this.session = session;
-    }
-
-    /**
-     * Replaces oldStream with newStream and performs a single offer/answer
-     *  cycle after both operations are done.  Either oldStream or newStream
-     *  can be null; replacing a valid 'oldStream' with a null 'newStream'
-     *  effectively just removes 'oldStream'
-     * @param oldStream the current stream in use to be replaced
-     * @param newStream the new stream to use
-     * @returns {Promise}
-     */
-    replaceStream (oldStream, newStream) {
-        if (this.session) {
-            return this.session.replaceStream(oldStream, newStream);
-        }
-        return Promise.resolve();
-    }
-
-    /**
-     * Remove stream.
-     * @param stream stream that will be removed.
-     * @param callback callback executed after successful stream removal.
-     * @param errorCallback callback executed if stream removal fail.
-     * @param ssrcInfo object with information about the SSRCs associated with the
-     * stream.
-     */
-    removeStream (stream, callback, errorCallback, ssrcInfo) {
-        if(!this.session) {
-            callback();
-            return;
-        }
-        this.session.removeStream(stream, callback, errorCallback, ssrcInfo);
-    }
-
-    /**
-     * Adds stream.
-     * @param stream new stream that will be added.
-     * @param callback callback executed after successful stream addition.
-     * @param errorCallback callback executed if stream addition fail.
-     * @param ssrcInfo object with information about the SSRCs associated with the
-     * stream.
-     * @param dontModifySources {boolean} if true _modifySources won't be called.
-     * Used for streams added before the call start.
-     */
-    addStream (stream, callback, errorCallback, ssrcInfo, dontModifySources) {
-        if(this.session) {
-            // FIXME: will block switchInProgress on true value in case of exception
-            this.session.addStream(stream, callback, errorCallback, ssrcInfo,
-                dontModifySources);
-        } else {
-            // We are done immediately
-            logger.warn("No conference handler or conference not started yet");
-            callback();
-        }
-    }
-
-    /**
-     * Generate ssrc info object for a stream with the following properties:
-     * - ssrcs - Array of the ssrcs associated with the stream.
-     * - groups - Array of the groups associated with the stream.
-     */
-    generateNewStreamSSRCInfo () {
-        if(!this.session) {
-            logger.warn("The call haven't been started. " +
-                "Cannot generate ssrc info at the moment!");
-            return null;
-        }
-        return this.session.generateNewStreamSSRCInfo();
-    }
-
     setVideoMute (mute, callback) {
         this.sendVideoInfoPresence(mute);
         if(callback)
         return this.phonePin;
     }
 
-    /**
-     * Returns the connection state for the current session.
-     */
-    getConnectionState () {
-        if(!this.session)
-            return null;
-        return this.session.getIceConnectionState();
-    }
-
     /**
      * Mutes remote participant.
      * @param jid of the participant
      * rejected.
      */
     leave () {
-        this._dispose();
         return new Promise((resolve, reject) => {
             let timeout = setTimeout(() => onMucLeft(true), 5000);
             let eventEmitter = this.eventEmitter;
             this.doLeave();
         });
     }
-
-    /**
-     * Disposes the conference, closes the jingle session.
-     */
-    _dispose () {
-        if (this.session) {
-            this.session.close();
-        }
-    }
 }

modules/xmpp/JingleSession.js

 import * as JingleSessionState from "./JingleSessionState";
 
 function JingleSession(me, sid, peerjid, connection,
-                       media_constraints, ice_config, service, eventEmitter) {
+                       media_constraints, ice_config) {
     /**
      * Our JID.
      */
      */
     this.connection = connection;
 
-    /**
-     * The XMPP service.
-     */
-    this.service = service;
-
-    /**
-     * The event emitter.
-     */
-    this.eventEmitter = eventEmitter;
-
     /**
      * Whether to use dripping or not. Dripping is sending trickle candidates
      * not one-by-one.

modules/xmpp/JingleSessionPC.js

  */
 var IQ_TIMEOUT = 10000;
 
-// Jingle stuff
+/**
+ * Creates new <tt>JingleSessionPC</tt>
+ * @param {string} me our JID
+ * @param {string} sid the Jingle Session ID - random string which
+ * identifies the session
+ * @param {string} peerjid remote peer JID
+ * @param {Strophe.Connection} connection Strophe XMPP connection instance
+ * used to send packets.
+ * @param media_constraints the media constraints object passed to
+ * createOffer/Answer, as defined by the WebRTC standard
+ * @param ice_config the ICE servers config object as defined by the WebRTC
+ * standard.
+ * @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.
+ */
 function JingleSessionPC(me, sid, peerjid, connection,
-                         media_constraints, ice_config, service, eventEmitter) {
+                         media_constraints, ice_config, options) {
     JingleSession.call(this, me, sid, peerjid, connection,
-                       media_constraints, ice_config, service, eventEmitter);
+                       media_constraints, ice_config);
 
     this.lasticecandidate = false;
     this.closed = false;
      */
     this.ssrcOwners = {};
 
-    this.webrtcIceUdpDisable = !!this.service.options.webrtcIceUdpDisable;
-    this.webrtcIceTcpDisable = !!this.service.options.webrtcIceTcpDisable;
+    this.webrtcIceUdpDisable = !!options.webrtcIceUdpDisable;
+    this.webrtcIceTcpDisable = !!options.webrtcIceTcpDisable;
     /**
      * Flag used to enforce ICE failure through the URL parameter for
      * the automatic testing purpose.
      * @type {boolean}
      */
-    this.failICE = !!this.service.options.failICE;
+    this.failICE = !!options.failICE;
 
     this.modificationQueue = async.queue(this._processQueueTasks.bind(this), 1);
 }
     this.wasstable = false;
 
     this.peerconnection = new TraceablePeerConnection(
-            this.connection.jingle.ice_config,
-            RTC.getPCConstraints(),
-            this);
+        this.connection.jingle.ice_config,
+        RTC.getPCConstraints(),
+        /* Options */
+        {
+            disableSimulcast: this.room.options.disableSimulcast,
+            disableRtx: this.room.options.disableRtx,
+            preferH264: this.room.options.preferH264
+        },
+        // TPC is using room's eventEmitter, so that all XMPPEvents can be
+        // captured from ChatRoom. But at the same time it makes hard
+        // or impossible to deal with more than one TPC instance without
+        // further refactoring.
+        this.room.eventEmitter);
 
     this.peerconnection.onicecandidate = function (ev) {
         if (!ev) {
             for (var i = 0; i < cands.length; i++) {
                 var candidate = SDPUtil.candidateToJingle(cands[i].candidate);
                 // Mangle ICE candidate if 'failICE' test option is enabled
-                if (this.service.options.failICE) {
+                if (this.failICE) {
                     candidate.ip = "1.1.1.1";
                 }
                 cand.c('candidate', candidate).up();
  *  cycle after both operations are done.  Either oldStream or newStream
  *  can be null; replacing a valid 'oldStream' with a null 'newStream'
  *  effectively just removes 'oldStream'
- * @param oldStream the current stream in use to be replaced
- * @param newStream the new stream to use
+ * @param {JitsiLocalTrack|null} oldTrack the current track in use to be
+ * replaced
+ * @param {JitsiLocalTrack|null} newTrack the new track to use
  * @returns {Promise} which resolves once the replacement is complete
  *  with no arguments or rejects with an error {string}
  */
-JingleSessionPC.prototype.replaceStream = function (oldStream, newStream) {
+JingleSessionPC.prototype.replaceTrack = function (oldTrack, newTrack) {
     return new Promise((resolve, reject) => {
         let workFunction = (finishedCallback) => {
             let oldSdp = new SDP(this.peerconnection.localDescription.sdp);
-            this.removeStreamFromPeerConnection(oldStream);
-            this.addStreamToPeerConnection(newStream);
+            this.removeStreamFromPeerConnection(oldTrack);
+            this.addStreamToPeerConnection(newTrack);
             this._renegotiate()
                 .then(() => {
                     var newSdp = new SDP(this.peerconnection.localDescription.sdp);
                     this.notifyMySSRCUpdate(oldSdp, newSdp);
                     finishedCallback();
                 }, (error) => {
-                    logger.error("replaceStream renegotiation failed: " + error);
+                    logger.error("replaceTrack renegotiation failed: " + error);
                     finishedCallback(error);
                 });
         };
  * stream.
  * @param dontModifySources {boolean} if true _modifySources won't be called.
  * Used for streams added before the call start.
- * NOTE(brian): there is a decent amount of overlap here with replaceStream that
+ * NOTE(brian): there is a decent amount of overlap here with replaceTrack that
  *  could be re-used...however we can't leverage that currently because the
  *  extra work we do here must be in the work function context and if we
- *  then called replaceStream we'd be adding another task on the queue
- *  from within a task which would then deadlock.  The 'replaceStream' core
+ *  then called replaceTrack we'd be adding another task on the queue
+ *  from within a task which would then deadlock.  The 'replaceTrack' core
  *  logic should be moved into a helper function that could be called within
  *  the 'doReplaceStream' task or the 'doAddStream' task (for example)
  */

modules/xmpp/TraceablePeerConnection.js

 
 var SIMULCAST_LAYERS = 3;
 
-function TraceablePeerConnection(ice_config, constraints, session) {
+/**
+ * Creates new instance of 'TraceablePeerConnection'.
+ *
+ * @param {object} ice_config WebRTC 'PeerConnection' ICE config
+ * @param {object} constraints WebRTC 'PeerConnection' constraints
+ * @param {object} options <tt>TracablePeerConnection</tt> config options.
+ * @param {boolean} options.disableSimulcast if set to 'true' will disable
+ * the simulcast
+ * @param {boolean} options.disableRtx if set to 'true' will disable the RTX
+ * @param {boolean} options.preferH264 if set to 'true' H264 will be preferred
+ * over other video codecs.
+ * @param {EventEmitter} eventEmitter the emitter which wil be used by the new
+ * instance to emit events.
+ *
+ * @constructor
+ */
+function TraceablePeerConnection(ice_config,
+                                 constraints, options, eventEmitter) {
     var self = this;
-    this.session = session;
+    this.options = options;
     var RTCPeerConnectionType = null;
     if (RTCBrowserType.isFirefox()) {
         RTCPeerConnectionType = mozRTCPeerConnection;
         explodeRemoteSimulcast: false});
     this.sdpConsistency = new SdpConsistency();
     this.rtxModifier = new RtxModifier();
-    this.eventEmitter = this.session.room.eventEmitter;
+    this.eventEmitter = eventEmitter;
 
     // override as desired
     this.trace = function (what, info) {
         this.peerconnection.addStream(stream);
     if (ssrcInfo && ssrcInfo.type === "addMuted") {
         this.sdpConsistency.setPrimarySsrc(ssrcInfo.ssrc.ssrcs[0]);
-        const simGroup = 
+        const simGroup =
             ssrcInfo.ssrc.groups.find(groupInfo => {
                 return groupInfo.group.semantics === "SIM";
             });
         if (fidGroups) {
             const rtxSsrcMapping = new Map();
             fidGroups.forEach(fidGroup => {
-                const fidGroupSsrcs = 
+                const fidGroupSsrcs =
                     SDPUtil.parseGroupSsrcs(fidGroup.group);
                 const primarySsrc = fidGroupSsrcs[0];
                 const rtxSsrc = fidGroupSsrcs[1];
     description = this.simulcast.mungeRemoteDescription(description);
     this.trace('setRemoteDescription::postTransform (simulcast)', dumpSDP(description));
 
-    if (this.session.room.options.preferH264) {
+    if (this.options.preferH264) {
         const parsedSdp = transform.parse(description.sdp);
         const videoMLine = parsedSdp.media.find(m => m.type === "video");
         SDPUtil.preferVideoCodec(videoMLine, "h264");
                 }
 
                 // Add simulcast streams if simulcast is enabled
-                if (!this.session.room.options.disableSimulcast
+                if (!this.options.disableSimulcast
                     && this.simulcast.isSupported()) {
                     answer = this.simulcast.mungeLocalDescription(answer);
                     this.trace(
                         dumpSDP(answer));
                 }
 
-                if (!this.session.room.options.disableRtx && !RTCBrowserType.isFirefox()) {
+                if (!this.options.disableRtx && !RTCBrowserType.isFirefox()) {
                     answer.sdp = this.rtxModifier.modifyRtxSsrcs(answer.sdp);
                     this.trace(
                         'createAnswerOnSuccess::postTransform (rtx modifier)',
  */
 TraceablePeerConnection.prototype.generateNewStreamSSRCInfo = function () {
     let ssrcInfo = {ssrcs: [], groups: []};
-    if (!this.session.room.options.disableSimulcast
+    if (!this.options.disableSimulcast
         && this.simulcast.isSupported()) {
         for (let i = 0; i < SIMULCAST_LAYERS; i++) {
             ssrcInfo.ssrcs.push(SDPUtil.generateSsrc());
     } else {
         ssrcInfo = {ssrcs: [SDPUtil.generateSsrc()], groups: []};
     }
-    if (!this.session.room.options.disableRtx) {
+    if (!this.options.disableRtx) {
         // Specifically use a for loop here because we'll
         //  be adding to the list we're iterating over, so we
         //  only want to iterate through the items originally
             ssrcInfo.ssrcs.push(rtxSsrc);
             ssrcInfo.groups.push({
                 primarySSRC: primarySsrc,
-                group: { 
+                group: {
                     ssrcs: primarySsrc + " " + rtxSsrc,
                     semantics: "FID"
                 }

modules/xmpp/strophe.emuc.js

         return true;
     }
 
-    setJingleSession (from, session) {
-        const room = this.rooms[Strophe.getBareJidFromJid(from)];
-        if(!room)
-            return;
-
-        room.setJingleSession(session);
-    }
-
     onMute(iq) {
         const from = iq.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];

modules/xmpp/strophe.jingle.js

                         fromJid,
                         this.connection,
                         this.media_constraints,
-                        this.ice_config, this.xmpp);
+                        this.ice_config, this.xmpp.options);
 
                 this.sessions[sess.sid] = sess;