Adds analytics events for connection times.

Moves render time calculations in the library.

JitsiConferenceEventManager.js

 
     this.chatRoomForwarder.forward(XMPPEvents.MUC_JOINED,
         JitsiConferenceEvents.CONFERENCE_JOINED);
+    // send some analytics events
+    chatRoom.addListener(XMPPEvents.MUC_JOINED,
+        function ()
+        {
+            for (var ckey in chatRoom.connectionTimes){
+                var cvalue = chatRoom.connectionTimes[ckey];
+                AnalyticsAdapter.sendEvent('conference.' + ckey, cvalue);
+            }
+            for (var xkey in chatRoom.xmpp.connectionTimes){
+                var xvalue = chatRoom.xmpp.connectionTimes[xkey];
+                AnalyticsAdapter.sendEvent('xmpp.' + xkey, xvalue);
+            }
+        });
 
     this.chatRoomForwarder.forward(XMPPEvents.ROOM_JOIN_ERROR,
         JitsiConferenceEvents.CONFERENCE_FAILED,
         var now = window.performance.now();
         logger.log("(TIME) data channel opened ", now);
         conference.room.connectionTimes["data.channel.opened"] = now;
+        AnalyticsAdapter.sendEvent('conference.dataChannel.open', now);
     });
 
     this.rtcForwarder.forward(RTCEvents.LASTN_CHANGED,

modules/RTC/JitsiRemoteTrack.js

 var JitsiTrack = require("./JitsiTrack");
 var JitsiTrackEvents = require("../../JitsiTrackEvents");
+var RTCBrowserType = require("./RTCBrowserType");
+
+var ttfmTrackerAudioAttached = false;
+var ttfmTrackerVideoAttached = false;
 
 /**
  * Represents a single media track (either audio or video).
     this.eventEmitter.emit(JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED, type);
 };
 
+/**
+ * Attach time to first media tracker only if there is conference and only
+ * for the first element.
+ * @param container the HTML container which can be 'video' or 'audio' element.
+ *        It can also be 'object' element if Temasys plugin is in use and this
+ *        method has been called previously on video or audio HTML element.
+ * @private
+ */
+JitsiRemoteTrack.prototype._attachTTFMTracker = function (container) {
+    if((ttfmTrackerAudioAttached && this.isAudioTrack())
+        || (ttfmTrackerVideoAttached && this.isVideoTrack()))
+        return;
+
+    if (this.isAudioTrack())
+        ttfmTrackerAudioAttached = true;
+    if (this.isVideoTrack())
+        ttfmTrackerVideoAttached = true;
+
+    // FIXME: this is not working for temasys
+    container.addEventListener("canplay", function () {
+        var type = (this.isVideoTrack() ? 'video' : 'audio');
+
+        var now = window.performance.now();
+        console.log("(TIME) Render " + type + ":\t", now);
+
+        var ttfm = now
+            - (this.conference.getConnectionTimes()["session.initiate"]
+            - this.conference.getConnectionTimes()["muc.joined"]);
+        this.conference.getConnectionTimes()[type + ".ttfm"] = ttfm;
+        console.log("(TIME) TTFM " + type + ":\t", ttfm);
+    }.bind(this));
+};
+
 module.exports = JitsiRemoteTrack;

modules/RTC/JitsiTrack.js

 
     this._maybeFireTrackAttached(container);
 
+    this._attachTTFMTracker(container);
+
     return container;
 };
 
     }
 };
 
+/**
+ * Attach time to first media tracker only if there is conference and only
+ * for the first element.
+ * @param container the HTML container which can be 'video' or 'audio' element.
+ *        It can also be 'object' element if Temasys plugin is in use and this
+ *        method has been called previously on video or audio HTML element.
+ * @private
+ */
+JitsiTrack.prototype._attachTTFMTracker = function (container) {
+};
+
 /**
  * Removes attached event listeners.
  *

modules/xmpp/JingleSessionPC.js

 var RTCBrowserType = require("../RTC/RTCBrowserType");
 var RTC = require("../RTC/RTC");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
+var AnalyticsAdapter = require("../statistics/AnalyticsAdapter");
 
 /**
  * Constant tells how long we're going to wait for IQ response, before timeout
             self.peerconnection.iceConnectionState] = now;
         logger.log("(TIME) ICE " + self.peerconnection.iceConnectionState +
                     ":\t", now);
+        AnalyticsAdapter.sendEvent(
+            'ice.' + self.peerconnection.iceConnectionState, now);
         switch (self.peerconnection.iceConnectionState) {
             case 'connected':
 

modules/xmpp/strophe.jingle.js

 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var RTCBrowserType = require("../RTC/RTCBrowserType");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
-
+var AnalyticsAdapter = require("../statistics/AnalyticsAdapter");
 
 module.exports = function(XMPP, eventEmitter) {
     Strophe.addConnectionPlugin('jingle', {
                             .up();
                         this.terminate(sess.sid);
                     }
+                    AnalyticsAdapter.sendEvent('xmpp.session-initiate', now);
                     break;
                 case 'session-terminate':
                     logger.log('terminating...', sess.sid);
                     this.terminate(sess.sid, reasonCondition, reasonText);
                     break;
                 case 'transport-replace':
-                    logger.info("(TIME) Start transport replace",
-                                window.performance.now());
+                    var now = window.performance.now();
+                    logger.info("(TIME) Start transport replace", now);
+                    AnalyticsAdapter.sendEvent(
+                        'xmpp.transport-replace.start', now);
+
                     sess.replaceTransport($(iq).find('>jingle'),
                         function () {
+                            var now = window.performance.now();
                             logger.info(
-                                "(TIME) Transport replace success!",
-                                window.performance.now());
+                                "(TIME) Transport replace success!", now);
+                            AnalyticsAdapter.sendEvent(
+                                'xmpp.transport-replace.success', now);
                         },
                         function(error) {
                             GlobalOnErrorHandler.callErrorHandler(error);