Extracts sendSessionInitiate into separate method, adds docs and setOfferCycle method

modules/xmpp/JingleSessionPC.js

@@ -279,19 +279,69 @@ JingleSessionPC.prototype.readSsrcInfo = function (contents) {
     });
 };
 
+/**
+ * Does accept incoming Jingle 'session-initiate' and should send
+ * 'session-accept' in result.
+ * @param jingleOffer jQuery selector pointing to the jingle element of
+ *        the offer IQ
+ * @param success callback called when we accept incoming session successfully
+ *        and receive RESULT packet to 'session-accept' sent.
+ * @param failure function(error) called if for any reason we fail to accept
+ *        the incoming offer. 'error' argument can be used to log some details
+ *        about the error.
+ */
 JingleSessionPC.prototype.acceptOffer = function(jingleOffer,
                                                  success, failure) {
     this.state = 'active';
-    this.setRemoteDescription(jingleOffer, 'offer',
+    this.setOfferCycle(jingleOffer,
+        function() {
+            // setOfferCycle succeeded, now we have self.localSDP up to date
+            // Let's send an answer !
+            // FIXME we may not care about RESULT packet for session-accept
+            // then we should either call 'success' here immediately or
+            // modify sendSessionAccept method to do that
+            this.sendSessionAccept(this.localSDP, success, failure);
+        }.bind(this),
+        failure);
+};
+
+/**
+ * This is a setRemoteDescription/setLocalDescription cycle which starts at
+ * converting Strophe Jingle IQ into remote offer SDP. Once converted
+ * setRemoteDescription, createAnswer and setLocalDescription calls follow.
+ * @param jingleOfferIq jQuery selector pointing to the jingle element of
+ *        the offer IQ
+ * @param success callback called when sRD/sLD cycle finishes successfully.
+ * @param failure callback called with an error object as an argument if we fail
+ *        at any point during setRD, createAnswer, setLD.
+ */
+JingleSessionPC.prototype.setOfferCycle = function (jingleOfferIq,
+                                                          success,
+                                                          failure) {
+    // Set Jingle offer as RD
+    this.setOffer(jingleOfferIq,
         function() {
-            this.sendAnswer(success, failure);
+            // Set offer OK, now let's try create an answer
+            this.createAnswer(function(answer) {
+                    // Create answer OK, set it as local SDP
+                    this.setLocalDescription(answer, success, failure);
+                }.bind(this),
+                failure);
         }.bind(this),
         failure);
 };
 
-JingleSessionPC.prototype.setRemoteDescription = function (elem, desctype,
-                                                           success, failure) {
-    //logger.log('setting remote description... ', desctype);
+/**
+ * Sets remote offer on PeerConnection by converting given Jingle offer IQ into
+ * SDP and setting it as remote description.
+ * @param jingleOfferIq  jQuery selector pointing to the jingle element of
+ *        the offer IQ
+ * @param success callback called when setRemoteDescription on PeerConnection
+ *        succeeds
+ * @param failure callback called with an error argument when
+ *        setRemoteDescription fails.
+ */
+JingleSessionPC.prototype.setOffer = function (jingleOfferIq, success, failure) {
     this.remoteSDP = new SDP('');
     if (this.webrtcIceTcpDisable) {
         this.remoteSDP.removeTcpCandidates = true;
@@ -300,9 +350,10 @@ JingleSessionPC.prototype.setRemoteDescription = function (elem, desctype,
         this.remoteSDP.removeUdpCandidates = true;
     }
 
-    this.remoteSDP.fromJingle(elem);
-    this.readSsrcInfo($(elem).find(">content"));
-    var remotedesc = new RTCSessionDescription({type: desctype, sdp: this.remoteSDP.raw});
+    this.remoteSDP.fromJingle(jingleOfferIq);
+    this.readSsrcInfo($(jingleOfferIq).find(">content"));
+    var remotedesc
+        = new RTCSessionDescription({type: 'offer', sdp: this.remoteSDP.raw});
 
     this.peerconnection.setRemoteDescription(remotedesc,
         function () {
@@ -320,56 +371,39 @@ JingleSessionPC.prototype.setRemoteDescription = function (elem, desctype,
     );
 };
 
-JingleSessionPC.prototype.sendAnswer = function (success, failure) {
+/**
+ * This is a wrapper to PeerConnection.createAnswer in order to generate failure
+ * event when error occurs. It also includes "media_constraints" if any are set
+ * on this JingleSessionPC instance.
+ * @param success callback called when PC.createAnswer succeeds, SDP will be
+ *        the first argument
+ * @param failure callback called with error argument when setAnswer fails
+ */
+JingleSessionPC.prototype.createAnswer = function (success, failure) {
     //logger.log('createAnswer');
+    var self = this;
     this.peerconnection.createAnswer(
-        function (sdp) {
-            this.createdAnswer(sdp, success, failure);
-        }.bind(this),
+        success,
         function (error) {
             logger.error("createAnswer failed", error);
             if (failure)
                 failure(error);
-            this.room.eventEmitter.emit(
+            self.room.eventEmitter.emit(
                     XMPPEvents.CONFERENCE_SETUP_FAILED, error);
-        }.bind(this),
+        },
         this.media_constraints
     );
 };
 
-JingleSessionPC.prototype.createdAnswer = function (sdp, success, failure) {
-    //logger.log('createAnswer callback');
+JingleSessionPC.prototype.setLocalDescription = function (sdp, success,
+                                                               failure) {
     var self = this;
     this.localSDP = new SDP(sdp.sdp);
-    var sendJingle = function (ssrcs) {
-                var accept = $iq({to: self.peerjid,
-                    type: 'set'})
-                    .c('jingle', {xmlns: 'urn:xmpp:jingle:1',
-                        action: 'session-accept',
-                        initiator: self.initiator,
-                        responder: self.responder,
-                        sid: self.sid });
-                if (self.webrtcIceTcpDisable) {
-                    self.localSDP.removeTcpCandidates = true;
-                }
-                if (self.webrtcIceUdpDisable) {
-                    self.localSDP.removeUdpCandidates = true;
-                }
-                self.localSDP.toJingle(
-                    accept,
-                    self.initiator == self.me ? 'initiator' : 'responder',
-                    ssrcs);
-                self.fixJingle(accept);
-                self.connection.sendIQ(accept,
-                    success,
-                    self.newJingleErrorHandler(accept, failure),
-                    IQ_TIMEOUT);
-    };
     sdp.sdp = this.localSDP.raw;
     this.peerconnection.setLocalDescription(sdp,
         function () {
-            //logger.log('setLocalDescription success');
-            sendJingle(success, failure);
+            if (success)
+                success();
         },
         function (error) {
             logger.error('setLocalDescription failed', error);
@@ -378,6 +412,8 @@ JingleSessionPC.prototype.createdAnswer = function (sdp, success, failure) {
             self.room.eventEmitter.emit(XMPPEvents.CONFERENCE_SETUP_FAILED);
         }
     );
+    // Some checks for STUN and TURN candiates present in local SDP
+    // Eventually could be removed as we don't really care
     var cands = SDPUtil.find_lines(this.localSDP.raw, 'a=candidate:');
     for (var j = 0; j < cands.length; j++) {
         var cand = SDPUtil.parse_icecandidate(cands[j]);
@@ -389,6 +425,45 @@ JingleSessionPC.prototype.createdAnswer = function (sdp, success, failure) {
     }
 };
 
+/**
+ * Sends Jingle 'session-accept' message.
+ * @param localSDP the 'SDP' object with local session description
+ * @param success callback called when we recive 'RESULT' packet for
+ *        'session-accept'
+ * @param failure function(error) called when we receive an error response or
+ *        when the request has timed out.
+ */
+JingleSessionPC.prototype.sendSessionAccept = function (localSDP,
+                                                        success, failure) {
+    var accept = $iq({to: this.peerjid,
+        type: 'set'})
+        .c('jingle', {xmlns: 'urn:xmpp:jingle:1',
+            action: 'session-accept',
+            initiator: this.initiator,
+            responder: this.responder,
+            sid: this.sid });
+    if (this.webrtcIceTcpDisable) {
+        localSDP.removeTcpCandidates = true;
+    }
+    if (this.webrtcIceUdpDisable) {
+        localSDP.removeUdpCandidates = true;
+    }
+    localSDP.toJingle(
+        accept,
+        this.initiator == this.me ? 'initiator' : 'responder',
+        null);
+    this.fixJingle(accept);
+
+    // Calling tree() to print something useful
+    accept = accept.tree();
+    logger.info("Sending session-accept", accept);
+
+    this.connection.sendIQ(accept,
+        success,
+        this.newJingleErrorHandler(accept, failure),
+        IQ_TIMEOUT);
+};
+
 JingleSessionPC.prototype.terminate = function (reason,  text,
                                                 success, failure) {
     var term = $iq({to: this.peerjid,
@@ -404,6 +479,10 @@ JingleSessionPC.prototype.terminate = function (reason,  text,
         term.up().c('text').t(text);
     }
 
+    // Calling tree() to print something useful
+    term = term.tree();
+    logger.info("Sending session-terminate", term);
+
     this.connection.sendIQ(
         term, success, this.newJingleErrorHandler(term, failure), IQ_TIMEOUT);