ref: remove JingleSession from ChatRoom

JitsiConference.js

     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;
             // ChatRoom instance.
             this.getParticipants().forEach(
                 participant => this.onMemberLeft(participant.getJid()));
+            // Close the JingleSession
+            if (this.jingleSession) {
+                this.jingleSession.close();
+                this.jingleSession = null;
+            }
         });
     }
 
             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 {JitsiLocalTrackn|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.replaceStream(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 true _modifySources won't be called.
+ * Used for streams added before the call start.
+ */
+JitsiConference.prototype.addLocalWebRTCStream
+    = 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.removeLocalWebRTCStream
+    = 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'
     }
 
     // Accept incoming call
-    this.room.setJingleSession(jingleSession);
+    this.jingleSession = jingleSession;
     this.room.connectionTimes["session.initiate"] = now;
     // Log "session.restart"
     if (this.wasStopped) {
              * 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.addLocalWebRTCStream(
                 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
  * for its session.
  */
 JitsiConference.prototype.getConnectionState = function () {
-    if(this.room)
-        return this.room.getConnectionState();
+    if(this.jingleSession)
+        return this.jingleSession.getIceConnectionState();
     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.addLocalWebRTCStream(
             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.removeLocalWebRTCStream(
         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/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)];