feat(RTC,JingleSessionPC): use the Promise based WebRTC APIs

It's 2018 after all...

modules/RTC/TraceablePeerConnection.js

     return localDescription;
 };
 
-TraceablePeerConnection.prototype.setLocalDescription = function(
-        description,
-        successCallback,
-        failureCallback) {
+TraceablePeerConnection.prototype.setLocalDescription = function(description) {
     let localSdp = description;
 
     this.trace('setLocalDescription::preTransform', dumpSDP(localSdp));
             dumpSDP(localSdp));
     }
 
-    this.peerconnection.setLocalDescription(localSdp,
-        () => {
-            this.trace('setLocalDescriptionOnSuccess');
-            const localUfrag = SDPUtil.getUfrag(localSdp.sdp);
+    return new Promise((resolve, reject) => {
+        this.peerconnection.setLocalDescription(localSdp)
+            .then(() => {
+                this.trace('setLocalDescriptionOnSuccess');
+                const localUfrag = SDPUtil.getUfrag(localSdp.sdp);
 
-            if (localUfrag !== this.localUfrag) {
-                this.localUfrag = localUfrag;
+                if (localUfrag !== this.localUfrag) {
+                    this.localUfrag = localUfrag;
+                    this.eventEmitter.emit(
+                        RTCEvents.LOCAL_UFRAG_CHANGED, this, localUfrag);
+                }
+                resolve();
+            })
+            .catch(err => {
+                this.trace('setLocalDescriptionOnFailure', err);
                 this.eventEmitter.emit(
-                    RTCEvents.LOCAL_UFRAG_CHANGED, this, localUfrag);
-            }
-            successCallback();
-        },
-        err => {
-            this.trace('setLocalDescriptionOnFailure', err);
-            this.eventEmitter.emit(
-                RTCEvents.SET_LOCAL_DESCRIPTION_FAILED,
-                err, this);
-            failureCallback(err);
-        }
-    );
+                    RTCEvents.SET_LOCAL_DESCRIPTION_FAILED,
+                    err, this);
+                reject(err);
+            });
+    });
 };
 
 /**
         });
     };
 
-TraceablePeerConnection.prototype.setRemoteDescription = function(
-        description,
-        successCallback,
-        failureCallback) {
+TraceablePeerConnection.prototype.setRemoteDescription = function(description) {
     this.trace('setRemoteDescription::preTransform', dumpSDP(description));
 
     // TODO the focus should squeze or explode the remote simulcast
         description = this._injectH264IfNotPresent(description);
     }
 
-    this.peerconnection.setRemoteDescription(
-        description,
-        () => {
-            this.trace('setRemoteDescriptionOnSuccess');
-            const remoteUfrag = SDPUtil.getUfrag(description.sdp);
+    return new Promise((resolve, reject) => {
+        this.peerconnection.setRemoteDescription(description)
+            .then(() => {
+                this.trace('setRemoteDescriptionOnSuccess');
+                const remoteUfrag = SDPUtil.getUfrag(description.sdp);
 
-            if (remoteUfrag !== this.remoteUfrag) {
-                this.remoteUfrag = remoteUfrag;
+                if (remoteUfrag !== this.remoteUfrag) {
+                    this.remoteUfrag = remoteUfrag;
+                    this.eventEmitter.emit(
+                        RTCEvents.REMOTE_UFRAG_CHANGED, this, remoteUfrag);
+                }
+                resolve();
+            })
+            .catch(err => {
+                this.trace('setRemoteDescriptionOnFailure', err);
                 this.eventEmitter.emit(
-                    RTCEvents.REMOTE_UFRAG_CHANGED, this, remoteUfrag);
-            }
-            successCallback();
-        },
-        err => {
-            this.trace('setRemoteDescriptionOnFailure', err);
-            this.eventEmitter.emit(
-                RTCEvents.SET_REMOTE_DESCRIPTION_FAILED,
-                err,
-                this);
-            failureCallback(err);
-        });
+                    RTCEvents.SET_REMOTE_DESCRIPTION_FAILED,
+                    err,
+                    this);
+                reject(err);
+            });
+    });
 };
 
 /**
     }
 };
 
-TraceablePeerConnection.prototype.createAnswer = function(
-        successCallback,
-        failureCallback,
-        constraints) {
+TraceablePeerConnection.prototype.createAnswer = function(constraints) {
     if (browser.supportsRtpSender() && this.isSimulcastOn()) {
         const videoSender
             = this.peerconnection.getSenders().find(sender =>
 
         videoSender.setParameters(simParams);
     }
-    this._createOfferOrAnswer(
-        false /* answer */, successCallback, failureCallback, constraints);
-};
 
-TraceablePeerConnection.prototype.createOffer = function(
-        successCallback,
-        failureCallback,
-        constraints) {
-    this._createOfferOrAnswer(
-        true /* offer */, successCallback, failureCallback, constraints);
+    return this._createOfferOrAnswer(false /* answer */, constraints);
 };
 
-/* eslint-disable max-params */
+TraceablePeerConnection.prototype.createOffer = function(constraints) {
+    return this._createOfferOrAnswer(true /* offer */, constraints);
+};
 
 TraceablePeerConnection.prototype._createOfferOrAnswer = function(
         isOffer,
-        successCallback,
-        failureCallback,
         constraints) {
     const logName = isOffer ? 'Offer' : 'Answer';
 
     this.trace(`create${logName}`, JSON.stringify(constraints, null, ' '));
 
-    const _successCallback = resultSdp => {
+    const handleSuccess = (resultSdp, resolveFn, rejectFn) => {
         try {
             this.trace(
                 `create${logName}OnSuccess::preTransform`, dumpSDP(resultSdp));
 
             // Add simulcast streams if simulcast is enabled
             if (this.isSimulcastOn()) {
-
                 // eslint-disable-next-line no-param-reassign
                 resultSdp = this.simulcast.mungeLocalDescription(resultSdp);
                 this.trace(
             logger.debug('Got local SSRCs MAP: ', ssrcMap);
             this._processLocalSSRCsMap(ssrcMap);
 
-            successCallback(resultSdp);
+            resolveFn(resultSdp);
         } catch (e) {
             this.trace(`create${logName}OnError`, e);
             this.trace(`create${logName}OnError`, dumpSDP(resultSdp));
             logger.error(`create${logName}OnError`, e, dumpSDP(resultSdp));
-            failureCallback(e);
+
+            rejectFn(e);
         }
     };
 
-    const _errorCallback = err => {
+    const handleFailure = (err, rejectFn) => {
         this.trace(`create${logName}OnFailure`, err);
         const eventType
             = isOffer
                 : RTCEvents.CREATE_ANSWER_FAILED;
 
         this.eventEmitter.emit(eventType, err, this);
-        failureCallback(err);
+
+        rejectFn(err);
     };
 
-    if (isOffer) {
-        this.peerconnection.createOffer(
-            _successCallback, _errorCallback, constraints);
-    } else {
-        this.peerconnection.createAnswer(
-            _successCallback, _errorCallback, constraints);
-    }
-};
+    return new Promise((resolve, reject) => {
+        let oaPromise;
 
-/* eslint-enable max-params */
+        if (isOffer) {
+            oaPromise = this.peerconnection.createOffer(constraints);
+        } else {
+            oaPromise = this.peerconnection.createAnswer(constraints);
+        }
+
+        oaPromise
+            .then(sdp => handleSuccess(sdp, resolve, reject))
+            .catch(error => handleFailure(error, reject));
+    });
+};
 
 /**
  * Extract primary SSRC from given {@link TrackSSRCInfo} object.
     }
 };
 
-TraceablePeerConnection.prototype.addIceCandidate = function(
-        candidate,
-        successCallback,
-        failureCallback) {
+TraceablePeerConnection.prototype.addIceCandidate = function(candidate) {
     this.trace('addIceCandidate', JSON.stringify({
         candidate: candidate.candidate,
         sdpMid: candidate.sdpMid,
         sdpMLineIndex: candidate.sdpMLineIndex,
         usernameFragment: candidate.usernameFragment
     }, null, ' '));
-    this.peerconnection.addIceCandidate(
-        candidate, successCallback, failureCallback);
+
+    return this.peerconnection.addIceCandidate(candidate);
 };
 
 /**

modules/xmpp/JingleSessionPC.js

         // and XMPP preserves order).
         const workFunction = finishedCallback => {
             for (const iceCandidate of iceCandidates) {
-                this.peerconnection.addIceCandidate(
-                    iceCandidate,
-                    () => {
-                        logger.debug('addIceCandidate ok!');
-                    },
-                    error => {
+                this.peerconnection.addIceCandidate(iceCandidate)
+                    .then(() => logger.debug('addIceCandidate ok!'))
+                    .catch(error => {
                         logger.error('addIceCandidate failed!', error);
                     });
             }
             for (const localTrack of localTracks) {
                 this.peerconnection.addTrack(localTrack);
             }
-            this.peerconnection.createOffer(
-                offerSdp => {
-                    this.peerconnection.setLocalDescription(
-                        offerSdp,
-                        () => {
+            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 => {
+                        })
+                        .catch(error => {
                             logger.error(
                                 'Failed to set local SDP', error, offerSdp);
                             finishedCallback(error);
                         });
-                },
-                error => {
+                })
+                .catch(error => {
                     logger.error(
                         'Failed to create an offer',
                         error,
                         this.mediaConstraints);
                     finishedCallback(error);
-                },
-                this.mediaConstraints);
+                });
         };
 
         this.modificationQueue.push(
      *  rejects with an error {string}
      */
     _renegotiate(optionalRemoteSdp) {
+        if (this.peerconnection.signalingState === 'closed') {
+            return Promise.reject('Attempted to renegotiate in state closed');
+        }
+
         const remoteSdp
             = optionalRemoteSdp || this.peerconnection.remoteDescription.sdp;
 
             sdp: remoteSdp
         });
 
-        return new Promise((resolve, reject) => {
-            if (this.peerconnection.signalingState === 'closed') {
-                reject('Attempted to renegotiate in state closed');
+        if (this.isInitiator) {
+            return this._initiatorRenegotiate(remoteDescription);
+        }
 
-                return;
-            }
-            if (this.isInitiator) {
-                this._initiatorRenegotiate(remoteDescription, resolve, reject);
-            } else {
-                this._responderRenegotiate(remoteDescription, resolve, reject);
-            }
-        });
+        return this._responderRenegotiate(remoteDescription);
     }
 
     /**
      * Renegotiate cycle implementation for the responder case.
      * @param {object} remoteDescription the SDP object as defined by the WebRTC
      * which will be used as remote description in the cycle.
-     * @param {function} resolve the success callback
-     * @param {function} reject the failure callback
      * @private
      */
-    _responderRenegotiate(remoteDescription, resolve, reject) {
-        // FIXME use WebRTC promise API to simplify things
+    _responderRenegotiate(remoteDescription) {
         logger.debug('Renegotiate: setting remote description');
-        this.peerconnection.setRemoteDescription(
-            remoteDescription,
-            () => {
+
+        return this.peerconnection.setRemoteDescription(remoteDescription)
+            .then(() => {
                 logger.debug('Renegotiate: creating answer');
-                this.peerconnection.createAnswer(
-                    answer => {
+
+                return this.peerconnection.createAnswer(this.mediaConstraints)
+                    .then(answer => {
                         logger.debug('Renegotiate: setting local description');
-                        this.peerconnection.setLocalDescription(
-                            answer,
-                            () => {
-                                resolve();
-                            },
-                            error => {
-                                reject(
-                                    `setLocalDescription failed: ${error}`);
-                            }
-                        );
-                    },
-                    error => reject(`createAnswer failed: ${error}`),
-                    this.mediaConstraints
-                );
-            },
-            error => reject(`setRemoteDescription failed: ${error}`)
-        );
+
+                        return this.peerconnection.setLocalDescription(answer);
+                    });
+            });
     }
 
     /**
      * Renegotiate cycle implementation for the initiator's case.
      * @param {object} remoteDescription the SDP object as defined by the WebRTC
      * which will be used as remote description in the cycle.
-     * @param {function} resolve the success callback
-     * @param {function} reject the failure callback
      * @private
      */
-    _initiatorRenegotiate(remoteDescription, resolve, reject) {
-        // FIXME use WebRTC promise API to simplify things
+    _initiatorRenegotiate(remoteDescription) {
         if (this.peerconnection.signalingState === 'have-local-offer') {
-
             // Skip createOffer and setLocalDescription or FF will fail
             logger.debug(
                 'Renegotiate: setting remote description');
-            this.peerconnection.setRemoteDescription(
-                remoteDescription,
-                () => {
+
+            /* eslint-disable arrow-body-style */
+
+            return this.peerconnection.setRemoteDescription(remoteDescription)
+                .then(() => {
                     // In case when the answer is being set for the first time,
                     // full sRD/sLD cycle is required to have the local
                     // description updated and SSRCs synchronized correctly.
                     // The reason for that is that renegotiate can not be called
                     // when adding tracks and they will not be reflected in
                     // the local SDP.
-                    this._initiatorRenegotiate(
-                        remoteDescription, resolve, reject);
-                },
-                error => reject(`setRemoteDescription failed: ${error}`)
-            );
-        } else {
-            logger.debug('Renegotiate: creating offer');
-            this.peerconnection.createOffer(
-                offer => {
-                    logger.debug('Renegotiate: setting local description');
-                    this.peerconnection.setLocalDescription(offer,
-                        () => {
-                            logger.debug(
-                                'Renegotiate: setting remote description');
-                            this.peerconnection.setRemoteDescription(
-                                remoteDescription,
-                                () => {
-                                    resolve();
-                                },
-                                error => reject(
-                                    `setRemoteDescription failed: ${error}`)
-                            );
-                        },
-                        error => {
-                            reject('setLocalDescription failed: ', error);
-                        });
-                },
-                error => reject(`createOffer failed: ${error}`),
-                this.mediaConstraints);
+                    return this._initiatorRenegotiate(remoteDescription);
+                });
+            /* eslint-enable arrow-body-style */
         }
+
+        logger.debug('Renegotiate: creating offer');
+
+        return this.peerconnection.createOffer(this.mediaConstraints)
+            .then(offer => {
+                logger.debug('Renegotiate: setting local description');
+
+                return this.peerconnection.setLocalDescription(offer)
+                    .then(() => {
+                        logger.debug(
+                            'Renegotiate: setting remote description');
+
+                        // eslint-disable-next-line max-len
+                        return this.peerconnection.setRemoteDescription(remoteDescription);
+                    });
+            });
     }
 
     /**