fix(JingleSessionPC): execute 'invite' on the queue

Invite must be executed on the queue to avoid strange things happening
on the beginning of the call. For example when the local tracks are
added just after the invite was called.

Move the JingleSessionPC to ACTIVE state, as soon as the first
_renegotiate is executed in PENDING state.

modules/xmpp/JingleSessionPC.js

         this.setOfferAnswerCycle(
             jingleOffer,
             () => {
-                this.state = JingleSessionState.ACTIVE;
-
                 // 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
         if (!this.isInitiator) {
             throw new Error('Trying to invite from the responder session');
         }
-        for (const localTrack of localTracks) {
-            this.peerconnection.addTrack(localTrack);
-        }
-        this.peerconnection.createOffer(
-            this.sendSessionInitiate.bind(this),
-            error => logger.error('Failed to create offer', error),
-            this.mediaConstraints);
+        const workFunction = finishedCallback => {
+            for (const localTrack of localTracks) {
+                this.peerconnection.addTrack(localTrack);
+            }
+            this.peerconnection.createOffer(
+                sdp => {
+                    this.sendSessionInitiate(
+                        sdp,
+                        finishedCallback,
+                        finishedCallback
+                    );
+                },
+                error => {
+                    logger.error(
+                        'Failed to create an offer',
+                        error,
+                        this.mediaConstraints);
+                    finishedCallback(error);
+                },
+                this.mediaConstraints);
+        };
+
+        this.modificationQueue.push(
+            workFunction,
+            error => {
+                if (error) {
+                    logger.error('invite error', error);
+                } else {
+                    logger.debug('invite executed - OK');
+                }
+            });
     }
 
     /**
      * Sends 'session-initiate' to the remote peer.
      * @param {object} sdp the local session description object as defined by
      * the WebRTC standard.
+     * @param {function} success executed when the operation succeeds.
+     * @param {function(error)} failure executed when the operation fails with
+     * an error passed as an argument.
      * @private
      */
-    sendSessionInitiate(sdp) {
+    sendSessionInitiate(sdp, success, failure) {
         logger.log('createdOffer', sdp);
         const sendJingle = () => {
             let init = $iq({
                     logger.error('"session-initiate" error', error);
                 },
                 IQ_TIMEOUT);
+
+            // NOTE the callback is executed immediately as we don't want to
+            // wait for the XMPP response which would delay the startup process.
+            success();
         };
 
         this.peerconnection.setLocalDescription(
             sdp, sendJingle,
             error => {
                 logger.error('session-init setLocalDescription failed', error);
+                failure(error);
             }
         );
     }
         this.setOfferAnswerCycle(
             jingleAnswer,
             () => {
-                this.state = JingleSessionState.ACTIVE;
                 logger.info('setAnswer - succeeded');
             },
             error => {
 
             const newRemoteSdp
                 = this._processNewJingleOfferIq(jingleOfferAnswerIq);
+            const oldLocalSdp
+                = this.peerconnection.localDescription.sdp;
 
             this._renegotiate(newRemoteSdp)
                 .then(() => {
+                    if (this.state === JingleSessionState.PENDING) {
+                        this.state = JingleSessionState.ACTIVE;
+                    }
+
+                    // Old local SDP will be available when we're setting answer
+                    // for the first time, but not when offer and it's fine
+                    // since we're generating an answer now it will contain all
+                    // our SSRCs
+                    if (oldLocalSdp) {
+                        const newLocalSdp
+                            = new SDP(this.peerconnection.localDescription.sdp);
+
+                        this.notifyMySSRCUpdate(
+                            new SDP(oldLocalSdp), newLocalSdp);
+                    }
+
                     finishedCallback();
                 }, error => {
                     logger.error(
      *  rejects with an error {string}
      */
     _renegotiate(optionalRemoteSdp) {
+        const currentRemoteSdp = this.peerconnection.remoteDescription.sdp;
+
+        // FIXME new SDP() may not be necessary - raw SDP is needed anyway
         const remoteSdp
             = optionalRemoteSdp
-                || new SDP(this.peerconnection.remoteDescription.sdp);
+                || (currentRemoteSdp && new SDP(currentRemoteSdp));
+
+        if (!remoteSdp) {
+            return Promise.reject(
+                'Can not renegotiate without remote description,'
+                    + `- current state: ${this.state}`);
+        }
+
         const remoteDescription = new RTCSessionDescription({
             type: this.isInitiator ? 'answer' : 'offer',
             sdp: remoteSdp.raw
                 this.peerconnection.addTrack(newTrack);
             }
 
-            if ((oldTrack || newTrack) && oldLocalSdp) {
+            if ((oldTrack || newTrack)
+                && this.state === JingleSessionState.ACTIVE) {
                 this._renegotiate()
                     .then(() => {
                         const newLocalSDP