Implements attach method in JitsiConnection. Fixes token auth.

JitsiConnection.js

     this.appID = appID;
     this.token = token;
     this.options = options;
-    this.xmpp = new XMPP(options);
+    this.xmpp = new XMPP(options, token);
     this.conferences = {};
 }
 
 /**
  * Connect the client with the server.
- * @param options {object} connecting options (for example authentications parameters).
+ * @param options {object} connecting options
+ * (for example authentications parameters).
  */
 JitsiConnection.prototype.connect = function (options) {
     if(!options)
     this.xmpp.connect(options.id, options.password);
 }
 
+/**
+ * Attach to existing connection. Can be used for optimizations. For example:
+ * if the connection is created on the server we can attach to it and start
+ * using it.
+ *
+ * @param options {object} connecting options - rid, sid and jid.
+ */
+JitsiConnection.prototype.attach = function (options) {
+    this.xmpp.attach(options);
+}
+
 /**
  * Disconnect the client from the server.
  */

connection_optimization/external_connect.js

+/**
+ * Requests the given webservice that will create the connection and will return
+ * the necessary details(rid, sid and jid) to attach to this connection and
+ * start using it. This script can be used for optimizing the connection startup
+ * time. The function will send AJAX request to a webservice that should
+ * create the bosh session much faster than the client because the webservice
+ * can be started on the same machine as the XMPP serever.
+ *
+ * NOTE: It's vert important to execute this function as early as you can for
+ * optimal results.
+ *
+ * @param webserviceUrl the url for the web service that is going to create the
+ * connection.
+ * @param success_callback callback function called with the result of the AJAX
+ * request if the request was successfull. The callback will receive one
+ * parameter which will be JS Object with properties - rid, sid and jid. This
+ * result should be passed to JitsiConnection.attach method in order to use that
+ * connection.
+ * @param error_callback callback function called the AJAX request fail. This
+ * callback is going to receive one parameter which is going to be JS error
+ * object with a reason for failure in it.
+ */
+function createConnectionExternally(webserviceUrl, success_callback,
+    error_callback) {
+    if (!window.XMLHttpRequest) {
+        error_callback(new Error("XMLHttpRequest is not supported!"));
+        return;
+    }
+
+    var xhttp = new XMLHttpRequest();
+
+    xhttp.onreadystatechange = function() {
+        if (xhttp.readyState == 4) {
+            if (xhttp.status == 200) {
+                try {
+                    var data = JSON.parse(xhttp.responseText);
+                    success_callback(data);
+                } catch (e) {
+                    error_callback(e);
+                }
+            } else {
+                error_callback(new Error("XMLHttpRequest error. Status: " +
+                    xhttp.status + ". Error message: " + xhttp.statusText));
+            }
+        }
+    };
+
+    xhttp.open("GET", webserviceUrl, true);
+    xhttp.send();
+}

modules/xmpp/ChatRoom.js

     if(password)
         this.password = password;
     var self = this;
-    this.moderator.allocateConferenceFocus(function()
-    {
-        self.sendPresence(true);
-    }.bind(this));
+    this.moderator.allocateConferenceFocus(function () {});
+    self.sendPresence(true);
 };
 
 ChatRoom.prototype.sendPresence = function (fromJoin) {

modules/xmpp/xmpp.js

 
 var authenticatedUser = false;
 
-function createConnection(bosh) {
+function createConnection(bosh, token) {
     bosh = bosh || '/http-bind';
 
     // Append token as URL param
-    if (this.token) {
-        bosh += (bosh.indexOf('?') == -1 ? '?' : '&') + 'token=' + this.token;
+    if (token) {
+        bosh += (bosh.indexOf('?') == -1 ? '?' : '&') + 'token=' + token;
     }
 
     return new Strophe.Connection(bosh);
     require("./strophe.logger")();
 }
 
-function XMPP(options) {
+function XMPP(options, token) {
     this.eventEmitter = new EventEmitter();
     this.connection = null;
     this.disconnectInProgress = false;
     this.options = options;
     initStrophePlugins(this);
 
-    this.connection = createConnection(options.bosh);
+    this.connection = createConnection(options.bosh, token);
 
     // Setup a disconnect on unload as a way to facilitate API consumers. It
     // sounds like they would want that. A problem for them though may be if
 
 XMPP.prototype.getConnection = function () { return this.connection; };
 
+/**
+ * Receive connection status changes and handles them.
+ * @password {string} the password passed in connect method
+ * @status the connection status
+ * @msg message
+ */
+XMPP.prototype.connectionHandler = function (password, status, msg) {
+    logger.log("(TIME) Strophe " + Strophe.getStatusString(status) +
+        (msg ? "[" + msg + "]" : "") + "\t:" + window.performance.now());
+    if (status === Strophe.Status.CONNECTED ||
+        status === Strophe.Status.ATTACHED) {
+        if (this.options.useStunTurn) {
+            this.connection.jingle.getStunAndTurnCredentials();
+        }
+
+        logger.info("My Jabber ID: " + this.connection.jid);
+
+        // Schedule ping ?
+        var pingJid = this.connection.domain;
+        this.connection.ping.hasPingSupport(
+            pingJid,
+            function (hasPing) {
+                if (hasPing)
+                    this.connection.ping.startInterval(pingJid);
+                else
+                    logger.warn("Ping NOT supported by " + pingJid);
+            }.bind(this));
+
+        if (password)
+            authenticatedUser = true;
+        if (this.connection && this.connection.connected &&
+            Strophe.getResourceFromJid(this.connection.jid)) {
+            // .connected is true while connecting?
+//                this.connection.send($pres());
+            this.eventEmitter.emit(
+                    JitsiConnectionEvents.CONNECTION_ESTABLISHED,
+                    Strophe.getResourceFromJid(this.connection.jid));
+        }
+    } else if (status === Strophe.Status.CONNFAIL) {
+        if (msg === 'x-strophe-bad-non-anon-jid') {
+            this.anonymousConnectionFailed = true;
+        } else {
+            this.connectionFailed = true;
+        }
+        this.lastErrorMsg = msg;
+    } else if (status === Strophe.Status.DISCONNECTED) {
+        // Stop ping interval
+        this.connection.ping.stopInterval();
+        this.disconnectInProgress = false;
+        if (this.anonymousConnectionFailed) {
+            // prompt user for username and password
+            this.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
+                JitsiConnectionErrors.PASSWORD_REQUIRED);
+        } else if(this.connectionFailed) {
+            this.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
+                JitsiConnectionErrors.OTHER_ERROR,
+                msg ? msg : this.lastErrorMsg);
+        } else {
+            this.eventEmitter.emit(
+                    JitsiConnectionEvents.CONNECTION_DISCONNECTED,
+                    msg ? msg : this.lastErrorMsg);
+        }
+    } else if (status === Strophe.Status.AUTHFAIL) {
+        // wrong password or username, prompt user
+        this.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
+            JitsiConnectionErrors.PASSWORD_REQUIRED);
+
+    }
+}
+
 XMPP.prototype._connect = function (jid, password) {
-    var self = this;
     // connection.connect() starts the connection process.
     //
     // As the connection process proceeds, the user supplied callback will
     //  Status.DISCONNECTING - The connection is currently being terminated
     //  Status.ATTACHED - The connection has been attached
 
-    var anonymousConnectionFailed = false;
-    var connectionFailed = false;
-    var lastErrorMsg;
-    this.connection.connect(jid, password, function (status, msg) {
-        logger.log("(TIME) Strophe " + Strophe.getStatusString(status) +
-            (msg ? "[" + msg + "]" : "") + "\t:" + window.performance.now());
-        if (status === Strophe.Status.CONNECTED) {
-            if (self.options.useStunTurn) {
-                self.connection.jingle.getStunAndTurnCredentials();
-            }
-
-            logger.info("My Jabber ID: " + self.connection.jid);
-
-            // Schedule ping ?
-            var pingJid = self.connection.domain;
-            self.connection.ping.hasPingSupport(
-                pingJid,
-                function (hasPing) {
-                    if (hasPing)
-                        self.connection.ping.startInterval(pingJid);
-                    else
-                        logger.warn("Ping NOT supported by " + pingJid);
-                }
-            );
-
-            if (password)
-                authenticatedUser = true;
-            if (self.connection && self.connection.connected &&
-                Strophe.getResourceFromJid(self.connection.jid)) {
-                // .connected is true while connecting?
-//                self.connection.send($pres());
-                self.eventEmitter.emit(
-                        JitsiConnectionEvents.CONNECTION_ESTABLISHED,
-                        Strophe.getResourceFromJid(self.connection.jid));
-            }
-        } else if (status === Strophe.Status.CONNFAIL) {
-            if (msg === 'x-strophe-bad-non-anon-jid') {
-                anonymousConnectionFailed = true;
-            } else {
-                connectionFailed = true;
-            }
-            lastErrorMsg = msg;
-        } else if (status === Strophe.Status.DISCONNECTED) {
-            // Stop ping interval
-            self.connection.ping.stopInterval();
-            self.disconnectInProgress = false;
-            if (anonymousConnectionFailed) {
-                // prompt user for username and password
-                self.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
-                    JitsiConnectionErrors.PASSWORD_REQUIRED);
-            } else if(connectionFailed) {
-                self.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
-                    JitsiConnectionErrors.OTHER_ERROR,
-                    msg ? msg : lastErrorMsg);
-            } else {
-                self.eventEmitter.emit(
-                        JitsiConnectionEvents.CONNECTION_DISCONNECTED,
-                        msg ? msg : lastErrorMsg);
-            }
-        } else if (status === Strophe.Status.AUTHFAIL) {
-            // wrong password or username, prompt user
-            self.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
-                JitsiConnectionErrors.PASSWORD_REQUIRED);
+    this.anonymousConnectionFailed = false;
+    this.connectionFailed = false;
+    this.lastErrorMsg;
+    this.connection.connect(jid, password,
+        this.connectionHandler.bind(this, password));
+}
 
-        }
-    });
+/**
+ * Attach to existing connection. Can be used for optimizations. For example:
+ * if the connection is created on the server we can attach to it and start
+ * using it.
+ *
+ * @param options {object} connecting options - rid, sid, jid and password.
+ */
+ XMPP.prototype.attach = function (options) {
+    logger.log("(TIME) Strophe attaching\t:" + window.performance.now(),options, options.jid);
+    this.connection.attach(options.jid, options.sid, parseInt(options.rid,10)+1,
+        this.connectionHandler.bind(this, options.password));
 }
 
 XMPP.prototype.connect = function (jid, password) {