Stores measured times and exposes them

JitsiConference.js

     return data;
 };
 
+/**
+ * Returns measured performanceTimes.
+ */
+JitsiConference.prototype.getPerformanceTimes = function () {
+    return this.room.performanceTimes;
+};
+
 /**
  * Sends the given feedback through CallStats if enabled.
  *
  */
 function setupListeners(conference) {
     conference.xmpp.addListener(
-        XMPPEvents.CALL_INCOMING, function (jingleSession, jingleOffer) {
+        XMPPEvents.CALL_INCOMING, function (jingleSession, jingleOffer, now) {
 
         if (conference.room.isFocus(jingleSession.peerjid)) {
             // Accept incoming call
             conference.room.setJingleSession(jingleSession);
+            conference.room.performanceTimes["session.initiate"] = now;
             jingleSession.initialize(false /* initiator */, conference.room);
             conference.rtc.onIncommingCall(jingleSession);
             jingleSession.acceptOffer(jingleOffer, null,

JitsiConnection.js

     this.xmpp.removeListener(event, listener);
 }
 
+/**
+ * Returns measured performanceTimes.
+ */
+JitsiConnection.prototype.getPerformanceTimes = function () {
+    return this.xmpp.performanceTimes;
+};
+
 module.exports = JitsiConnection;

connection_optimization/external_connect.js

 
     xhttp.onreadystatechange = function() {
         if (xhttp.readyState == xhttp.DONE) {
-            console.log("(TIME) external connect XHR done:\t",
-                window.performance.now());
+            var now = window.performanceTimes["external_connect.done"] =
+                window.performance.now();
+            console.log("(TIME) external connect XHR done:\t", now);
             if (xhttp.status == HTTP_STATUS_OK) {
                 try {
                     var data = JSON.parse(xhttp.responseText);
     xhttp.timeout = 3000;
 
     xhttp.open("GET", webserviceUrl, true);
-    console.log("(TIME) Sending external connect XHR:\t",
-        window.performance.now());
+    window.performanceTimes = {};
+    var now = window.performanceTimes["external_connect.sending"] =
+        window.performance.now();
+    console.log("(TIME) Sending external connect XHR:\t", now);
     xhttp.send();
 }

modules/xmpp/ChatRoom.js

     this.lastPresences = {};
     this.phoneNumber = null;
     this.phonePin = null;
+    this.performanceTimes = {};
 }
 
 ChatRoom.prototype.initPresenceMap = function () {
         }
         if (!this.joined) {
             this.joined = true;
-            console.log("(TIME) MUC joined:\t", window.performance.now());
+            var now = this.performanceTimes["muc.joined"] =
+                window.performance.now();
+            console.log("(TIME) MUC joined:\t", now);
             this.eventEmitter.emit(XMPPEvents.MUC_JOINED);
         }
     } else if (this.members[from] === undefined) {

modules/xmpp/JingleSessionPC.js

      */
     this.peerconnection.oniceconnectionstatechange = function (event) {
         if (!(self && self.peerconnection)) return;
+        self.room.performanceTimes["ice.state"] =
+            self.room.performanceTimes["ice.state"] || [];
+        var now = window.performance.now();
+        self.room.performanceTimes["ice.state"].push(
+            {state: self.peerconnection.iceConnectionState, time: now});
         logger.log("(TIME) ICE " + self.peerconnection.iceConnectionState +
-                    ":\t", window.performance.now());
+                    ":\t", now);
         self.updateModifySourcesQueue();
         switch (self.peerconnection.iceConnectionState) {
             case 'connected':

modules/xmpp/strophe.jingle.js

             // see http://xmpp.org/extensions/xep-0166.html#concepts-session
             switch (action) {
                 case 'session-initiate':
-                    console.log("(TIME) received session-initiate:\t",
-                                window.performance.now());
+                    var now = window.performance.now();
+                    console.log("(TIME) received session-initiate:\t", now);
                     var startMuted = $(iq).find('jingle>startmuted');
                     if (startMuted && startMuted.length > 0) {
                         var audioMuted = startMuted.attr("audio");
                     var jingleOffer = $(iq).find('>jingle');
                     // FIXME there's no nice way with event to get the reason
                     // why the call was rejected
-                    eventEmitter.emit(XMPPEvents.CALL_INCOMING, sess, jingleOffer);
+                    eventEmitter.emit(XMPPEvents.CALL_INCOMING, sess, jingleOffer, now);
                     if (!sess.active())
                     {
                         // Call not accepted
         }
     });
 };
-

modules/xmpp/xmpp.js

     this.eventEmitter = new EventEmitter();
     this.connection = null;
     this.disconnectInProgress = false;
-
+    this.performanceTimes = {status: []};
     this.forceMuted = false;
     this.options = options;
     initStrophePlugins(this);
  * @msg message
  */
 XMPP.prototype.connectionHandler = function (password, status, msg) {
+    var now = window.performance.now();
+    this.performanceTimes["status"].push(
+        {state: Strophe.getStatusString(status),
+        time: now});
     logger.log("(TIME) Strophe " + Strophe.getStatusString(status) +
-        (msg ? "[" + msg + "]" : "") + "\t:" + window.performance.now());
+        (msg ? "[" + msg + "]" : "") + ":\t", now);
     if (status === Strophe.Status.CONNECTED ||
         status === Strophe.Status.ATTACHED) {
         if (this.options.useStunTurn) {
  * @param options {object} connecting options - rid, sid, jid and password.
  */
  XMPP.prototype.attach = function (options) {
-    logger.log("(TIME) Strophe Attaching\t:" + window.performance.now());
+    var now = this.performanceTimes["attaching"] = window.performance.now();
+    logger.log("(TIME) Strophe Attaching\t:" + now);
     this.connection.attach(options.jid, options.sid, parseInt(options.rid,10)+1,
         this.connectionHandler.bind(this, options.password));
 }