ref(RTC): RTCRtpSender.setParameters promise

Handle the promise returned by RTCRtpSender.setParameters.

modules/RTC/TPCUtils.js

     /**
     * Adds {@link JitsiLocalTrack} to the WebRTC peerconnection for the first time.
     * @param {JitsiLocalTrack} track - track to be added to the peerconnection.
-    * @returns {boolean} Returns true if the operation is successful,
-    * false otherwise.
+    * @returns {void}
     */
     addTrack(localTrack, isInitiator = true) {
         const track = localTrack.getTrack();
     /**
      * Adds a track on the RTCRtpSender as part of the unmute operation.
      * @param {JitsiLocalTrack} localTrack - track to be unmuted.
-     * @returns {Promise<boolean>} - Promise that resolves to false if unmute
-     * operation is successful, a reject otherwise.
+     * @returns {Promise<void>} - resolved when done.
      */
     addTrackUnmute(localTrack) {
         const mediaType = localTrack.getType();
 
             if (stream) {
                 this.pc.peerconnection.addStream(localTrack.getOriginalStream());
-                this.setEncodings(localTrack);
-                this.pc.localTracks.set(localTrack.rtcId, localTrack);
-                transceiver.direction = 'sendrecv';
 
-                // Construct the simulcast stream constraints for the newly added track.
-                if (localTrack.isVideoTrack()
-                    && localTrack.videoType === VideoType.CAMERA
-                    && this.pc.isSimulcastOn()) {
-                    this.setSimulcastStreamConstraints(localTrack.getTrack());
-                }
+                return this.setEncodings(localTrack).then(() => {
+                    this.pc.localTracks.set(localTrack.rtcId, localTrack);
+                    transceiver.direction = 'sendrecv';
+
+                    // Construct the simulcast stream constraints for the newly added track.
+                    if (localTrack.isVideoTrack()
+                        && localTrack.videoType === VideoType.CAMERA
+                        && this.pc.isSimulcastOn()) {
+                        this.setSimulcastStreamConstraints(localTrack.getTrack());
+                    }
+                });
             }
 
-            return Promise.resolve(false);
+            return Promise.resolve();
         }
 
         return transceiver.sender.replaceTrack(track)
             .then(() => {
                 this.pc.localTracks.set(localTrack.rtcId, localTrack);
-
-                return Promise.resolve(false);
             });
     }
 
      * Replaces the existing track on a RTCRtpSender with the given track.
      * @param {JitsiLocalTrack} oldTrack - existing track on the sender that needs to be removed.
      * @param {JitsiLocalTrack} newTrack - new track that needs to be added to the sender.
-     * @returns {Promise<false>} Promise that resolves with false as we don't want
-     * renegotiation to be triggered automatically after this operation. Renegotiation is
-     * done when the browser fires the negotiationeeded event.
+     * @returns {Promise<void>} - resolved when done.
      */
     replaceTrack(oldTrack, newTrack) {
         if (oldTrack && newTrack) {
         } else if (newTrack && !oldTrack) {
             const ssrc = this.pc.localSSRCs.get(newTrack.rtcId);
 
-            if (!this.addTrackUnmute(newTrack)) {
-                return Promise.reject(new Error('replace track failed'));
-            }
-            newTrack.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED, newTrack);
-            this.pc.localTracks.set(newTrack.rtcId, newTrack);
-            this.pc.localSSRCs.set(newTrack.rtcId, ssrc);
+            this.addTrackUnmute(newTrack)
+                .then(() => {
+                    newTrack.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED, newTrack);
+                    this.pc.localTracks.set(newTrack.rtcId, newTrack);
+                    this.pc.localSSRCs.set(newTrack.rtcId, ssrc);
+                });
         }
 
-        return Promise.resolve(false);
+        return Promise.resolve();
     }
 
     /**
     * the connection should be kept alive.
     * @param {boolean} active - true to enable audio media transmission or
     * false to disable.
-    * @returns {false} - returns false always so that renegotiation is not automatically
-    * triggered after this operation.
+    * @returns {Promise<void>} - resolved when done.
     */
     setAudioTransferActive(active) {
         return this.setMediaTransferActive('audio', active);
      * Set the simulcast stream encoding properties on the RTCRtpSender.
      * @param {JitsiLocalTrack} track - the current track in use for which
      * the encodings are to be set.
+     * @returns {Promise<void>} - resolved when done.
      */
     setEncodings(track) {
         const transceiver = this.pc.peerconnection.getTransceivers()
         const parameters = transceiver.sender.getParameters();
 
         parameters.encodings = this._getStreamEncodings(track);
-        transceiver.sender.setParameters(parameters);
+
+        return transceiver.sender.setParameters(parameters);
     }
 
     /**
      * @param {String} mediaType - 'audio' or 'video'
      * @param {boolean} active - true to enable media transmission or false
      * to disable.
-     * @returns {false} - returns false always so that renegotiation is not automatically
-     * triggered after this operation
+     * @returns {Promise<void>} - resolved when done.
      */
     setMediaTransferActive(mediaType, active) {
         const transceivers = this.pc.peerconnection.getTransceivers()
         const localTracks = Array.from(this.pc.localTracks.values())
             .filter(track => track.getType() === mediaType);
 
+        const setParamPromises = [];
+
         if (active) {
             transceivers.forEach(transceiver => {
                 if (localTracks.length) {
                         parameters.encodings.forEach(encoding => {
                             encoding.active = true;
                         });
-                        transceiver.sender.setParameters(parameters);
+                        setParamPromises.push(transceiver.sender.setParameters(parameters));
                     }
                 } else {
                     transceiver.direction = 'recvonly';
             });
         }
 
-        return false;
+        return Promise.all(setParamPromises);
     }
 
     /**
     * the connection should be kept alive.
     * @param {boolean} active - true to enable video media transmission or
     * false to disable.
-    * @returns {false} - returns false always so that renegotiation is not automatically
-    * triggered after this operation.
+    * @returns {Promise<void>} - resolved when done.
     */
     setVideoTransferActive(active) {
         return this.setMediaTransferActive('video', active);

modules/RTC/TraceablePeerConnection.js

 /**
  * Add {@link JitsiLocalTrack} to this TPC.
  * @param {JitsiLocalTrack} track
+ * @returns {Promise<void>} - resolved when done.
  */
 TraceablePeerConnection.prototype.addTrack = function(track, isInitiator = false) {
     const rtcId = track.rtcId;
     logger.info(`add ${track} to: ${this}`);
 
     if (this.localTracks.has(rtcId)) {
-        logger.error(`${track} is already in ${this}`);
 
-        return;
+        return Promise.reject(new Error(`${track} is already in ${this}`));
     }
 
     this.localTracks.set(rtcId, track);
     if (browser.usesUnifiedPlan() && isInitiator) {
-        return this.tpcUtils.addTrack(track, isInitiator);
+        this.tpcUtils.addTrack(track, isInitiator);
+
+        return Promise.resolve();
     }
 
     const webrtcStream = track.getOriginalStream();
     } else if (!browser.doesVideoMuteByStreamRemove()
                 || track.isAudioTrack()
                 || (track.isVideoTrack() && !track.isMuted())) {
-        logger.error(`${this} no WebRTC stream for: ${track}`);
+        return Promise.reject(new Error(`${this} no WebRTC stream for: ${track}`));
     }
 
     // Muted video tracks do not have WebRTC stream
         }
     }
 
+    let promiseChain = Promise.resolve();
+
     if (browser.usesUnifiedPlan() && !browser.usesSdpMungingForSimulcast()) {
-        this.tpcUtils.setEncodings(track);
+        promiseChain = this.tpcUtils.setEncodings(track);
     }
 
     // Construct the simulcast stream constraints for the newly added track.
     if (track.isVideoTrack() && track.videoType === VideoType.CAMERA && this.isSimulcastOn()) {
         this.tpcUtils.setSimulcastStreamConstraints(track.getTrack());
     }
+
+    return promiseChain;
 };
 
 /**
  */
 TraceablePeerConnection.prototype.replaceTrack = function(oldTrack, newTrack) {
     if (browser.usesUnifiedPlan()) {
-        return this.tpcUtils.replaceTrack(oldTrack, newTrack);
+        return this.tpcUtils.replaceTrack(oldTrack, newTrack)
+            .then(() => false);
     }
+
+    let promiseChain = Promise.resolve();
+
     if (oldTrack) {
         this.removeTrack(oldTrack);
     }
     if (newTrack) {
-        this.addTrack(newTrack);
+        promiseChain = this.addTrack(newTrack);
     }
 
-    return Promise.resolve(true);
+    return promiseChain.then(() => true);
 };
 
 /**
 TraceablePeerConnection.prototype.setAudioTransferActive = function(active) {
     logger.debug(`${this} audio transfer active: ${active}`);
     if (browser.usesUnifiedPlan()) {
-        return this.tpcUtils.setAudioTransferActive(active);
+        return this.tpcUtils.setAudioTransferActive(active)
+            .then(() => false);
     }
     const changed = this.audioTransferActive !== active;
 
  * resolution or framerate will be preferred when bandwidth or cpu is constrained.
  * Sets it to 'maintain-framerate' when a camera track is added to the pc, sets it
  * to 'maintain-resolution' when a desktop track is being shared instead.
- * @returns {void}
+ * @returns {Promise<void>}
  */
 TraceablePeerConnection.prototype.setSenderVideoDegradationPreference = function() {
     if (!this.peerconnection.getSenders) {
         logger.debug('Browser does not support RTCRtpSender');
 
-        return;
+        return Promise.resolve();
     }
     const localVideoTrack = Array.from(this.localTracks.values()).find(t => t.isVideoTrack());
     const videoSender = this.findSenderByKind(MediaType.VIDEO);
 
     if (!videoSender) {
-        return;
+        return Promise.resolve();
     }
     const parameters = videoSender.getParameters();
 
     if (!parameters.encodings || !parameters.encodings.length) {
-        return;
+        return Promise.resolve();
     }
     for (const encoding in parameters.encodings) {
         if (parameters.encodings.hasOwnProperty(encoding)) {
             parameters.encodings[encoding].degradationPreference = preference;
         }
     }
-    videoSender.setParameters(parameters);
+
+    return videoSender.setParameters(parameters);
 };
 
 /**
  * simulcast is implemented.
  * @param {JitsiLocalTrack} localTrack - the local track whose
  * max bitrate is to be configured.
+ * @returns {Promise<void>}
  */
 TraceablePeerConnection.prototype.setMaxBitRate = function(localTrack = null) {
     if (!localTrack) {
         localTrack = Array.from(this.localTracks.values()).find(t => t.isVideoTrack());
 
         if (!localTrack) {
-            return;
+            return Promise.resolve();
         }
     }
     const trackId = localTrack.track.id;
     if (!((this.options.videoQuality && this.options.videoQuality.maxBitratesVideo)
         || (browser.usesPlanB() && this.options.capScreenshareBitrate && videoType === VideoType.DESKTOP))
         || browser.usesUnifiedPlan()) {
-        return;
+        return Promise.resolve();
     }
 
     if (!this.peerconnection.getSenders) {
         logger.debug('Browser doesn\'t support RTCRtpSender');
 
-        return;
+        return Promise.resolve();
     }
     const presenterEnabled = localTrack._originalStream
         && localTrack._originalStream.id !== localTrack.getStreamId();
 
+    const setSenderParamPromises = [];
+
     this.peerconnection.getSenders()
         .filter(s => s.track && s.track.id === trackId)
         .forEach(sender => {
                                     : HD_BITRATE;
                     }
                 }
-                sender.setParameters(parameters);
+                setSenderParamPromises.push(sender.setParameters(parameters));
             } catch (err) {
                 logger.error('Browser does not support getParameters/setParamters '
                     + 'or setting max bitrate on the encodings: ', err);
             }
         });
+
+    return Promise.all(setSenderParamPromises)
+        .then(() => Promise.resolve());
 };
 
 TraceablePeerConnection.prototype.setRemoteDescription = function(description) {
 TraceablePeerConnection.prototype.setVideoTransferActive = function(active) {
     logger.debug(`${this} video transfer active: ${active}`);
     if (browser.usesUnifiedPlan()) {
-        return this.tpcUtils.setVideoTransferActive(active);
+        return this.tpcUtils.setVideoTransferActive(active)
+            .then(() => false);
     }
     const changed = this.videoTransferActive !== active;
 

modules/xmpp/JingleSessionPC.js

      * added, before the offer/answer cycle executes (for the local track
      * addition to be an atomic operation together with the offer/answer).
      */
-    invite(localTracks) {
+    invite(localTracks = []) {
         if (!this.isInitiator) {
             throw new Error('Trying to invite from the responder session');
         }
         const workFunction = finishedCallback => {
+            const addTracks = [];
+
             for (const localTrack of localTracks) {
-                this.peerconnection.addTrack(localTrack, true /* isInitiator */);
+                addTracks.push(this.peerconnection.addTrack(localTrack, true /* isInitiator */));
             }
-            this.peerconnection.createOffer(this.mediaConstraints)
-                .then(offerSdp => {
-                    this.peerconnection.setLocalDescription(offerSdp)
-                        .then(() => {
-                            // NOTE that the offer is obtained from
-                            // the localDescription getter as it needs to go
-                            // though the transformation chain.
-                            this.sendSessionInitiate(
-                                this.peerconnection.localDescription.sdp);
-                            finishedCallback();
-                        }, error => {
-                            logger.error(
-                                'Failed to set local SDP', error, offerSdp);
-                            finishedCallback(error);
-                        });
-                }, error => {
-                    logger.error(
-                        'Failed to create an offer',
-                        error,
-                        this.mediaConstraints);
-                    finishedCallback(error);
-                });
+
+            Promise.all(addTracks)
+                .then(() => this.peerconnection.createOffer(this.mediaConstraints))
+                .then(offerSdp => this.peerconnection.setLocalDescription(offerSdp))
+                .then(() => {
+                    // NOTE that the offer is obtained from the localDescription getter as it needs to go though
+                    // the transformation chain.
+                    this.sendSessionInitiate(this.peerconnection.localDescription.sdp);
+                })
+                .then(() => finishedCallback(), error => finishedCallback(error));
         };
 
         this.modificationQueue.push(
      * executes (for the local track addition to be an atomic operation together
      * with the offer/answer).
      */
-    setOfferAnswerCycle(jingleOfferAnswerIq, success, failure, localTracks) {
+    setOfferAnswerCycle(jingleOfferAnswerIq, success, failure, localTracks = []) {
         const workFunction = finishedCallback => {
+            const addTracks = [];
 
-            if (localTracks) {
-                for (const track of localTracks) {
-                    this.peerconnection.addTrack(track);
-                }
+            for (const track of localTracks) {
+                addTracks.push(this.peerconnection.addTrack(track));
             }
 
             const newRemoteSdp
                 this._bridgeSessionId = bridgeSessionId;
             }
 
-            this._renegotiate(newRemoteSdp.raw)
+            Promise.all(addTracks)
+                .then(() => this._renegotiate(newRemoteSdp.raw))
                 .then(() => {
                     if (this.state === JingleSessionState.PENDING) {
                         this.state = JingleSessionState.ACTIVE;
                         this.notifyMySSRCUpdate(
                             new SDP(oldLocalSdp), newLocalSdp);
                     }
-
-                    finishedCallback();
-                }, error => {
-                    logger.error(
-                        `Error renegotiating after setting new remote ${
-                            this.isInitiator ? 'answer: ' : 'offer: '}${error}`,
-                        newRemoteSdp);
-
-                    finishedCallback(error);
-                });
+                })
+                .then(() => finishedCallback(), error => finishedCallback(error));
         };
 
         this.modificationQueue.push(
                             const newLocalSDP = new SDP(this.peerconnection.localDescription.sdp);
 
                             this.notifyMySSRCUpdate(new SDP(oldLocalSdp), newLocalSDP);
-                        },
-                        finishedCallback /* will be called with en error */);
+                        });
                     }
 
-                    promise.then(() => {
+                    return promise.then(() => {
                         if (newTrack && newTrack.isVideoTrack()) {
+                            // FIXME set all sender parameters in one go?
                             // Set the degradation preference on the new video sender.
-                            this.peerconnection.setSenderVideoDegradationPreference();
-
-                            // Apply the cached video constraints on the new video sender.
-                            this.peerconnection.setSenderVideoConstraint();
-
-                            // Configure max bitrate on the video sender when media is routed through JVB.
-                            if (!this.isP2P) {
-                                this.peerconnection.setMaxBitRate(newTrack);
-                            }
+                            return this.peerconnection.setSenderVideoDegradationPreference()
+
+                                // Apply the cached video constraints on the new video sender.
+                                .then(() => this.peerconnection.setSenderVideoConstraint())
+                                .then(() => {
+                                    // Configure max bitrate on the video sender when media is routed through JVB.
+                                    if (!this.isP2P) {
+                                        return this.peerconnection.setMaxBitRate(newTrack);
+                                    }
+                                });
                         }
-                        finishedCallback();
-                    }, finishedCallback /* will be called with en error */);
+                    });
                 })
-                .catch(err => {
-                    finishedCallback(err);
-                });
+                .then(() => finishedCallback(), error => finishedCallback(error));
         };
 
         return new Promise((resolve, reject) => {