Merge pull request #114 from jitsi/remove-stats-repetitions

Remove repetitions

modules/statistics/RTPStatsCollector.js

 var browserSupported = RTCBrowserType.isChrome() ||
         RTCBrowserType.isOpera() || RTCBrowserType.isFirefox();
 
-var keyMap = {};
-keyMap[RTCBrowserType.RTC_BROWSER_FIREFOX] = {
+/**
+ * The LibJitsiMeet browser-agnostic names of the browser-specific keys reported
+ * by RTCPeerConnection#getStats mapped by RTCBrowserType.
+ */
+var KEYS_BY_BROWSER_TYPE = {};
+KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_FIREFOX] = {
     "ssrc": "ssrc",
     "packetsReceived": "packetsReceived",
     "packetsLost": "packetsLost",
     "bytesReceived": "bytesReceived",
     "bytesSent": "bytesSent"
 };
-keyMap[RTCBrowserType.RTC_BROWSER_CHROME] = {
+KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME] = {
     "receiveBandwidth": "googAvailableReceiveBandwidth",
     "sendBandwidth": "googAvailableSendBandwidth",
     "remoteAddress": "googRemoteAddress",
     "audioInputLevel": "audioInputLevel",
     "audioOutputLevel": "audioOutputLevel"
 };
-keyMap[RTCBrowserType.RTC_BROWSER_OPERA] =
-    keyMap[RTCBrowserType.RTC_BROWSER_CHROME];
-keyMap[RTCBrowserType.RTC_BROWSER_IEXPLORER] =
-    keyMap[RTCBrowserType.RTC_BROWSER_CHROME];
-keyMap[RTCBrowserType.RTC_BROWSER_SAFARI] =
-    keyMap[RTCBrowserType.RTC_BROWSER_CHROME];
+KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_OPERA] =
+    KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
+KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_IEXPLORER] =
+    KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
+KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_SAFARI] =
+    KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
 /**
  * Calculates packet lost percent using the number of lost packets and the
  * number of all packet.
     return Math.round((lostPackets/totalPackets)*100);
 }
 
-function getStatValue(item, name) {
-    var browserType = RTCBrowserType.getBrowserType();
-    if (!keyMap[browserType][name])
-        throw "The property isn't supported!";
-    var key = keyMap[browserType][name];
-    return (RTCBrowserType.isChrome() || RTCBrowserType.isOpera()) ?
-        item.stat(key) : item[key];
-}
-
 function formatAudioLevel(audioLevel) {
     return Math.min(Math.max(audioLevel, 0), 1);
 }
  * Checks whether a certain record should be included in the logged statistics.
  */
 function acceptStat(reportId, reportType, statName) {
-    if (reportType == "googCandidatePair" && statName == "googChannelId")
-        return false;
+    if (reportType == "googCandidatePair") {
+        if (statName == "googChannelId")
+            return false;
 
-    if (reportType == "ssrc") {
+    } else if (reportType == "ssrc") {
         if (statName == "googTrackId" ||
             statName == "transportId" ||
             statName == "ssrc")
  * Checks whether a certain record should be included in the logged statistics.
  */
 function acceptReport(id, type) {
+    if (type == "googComponent")
+        return false;
+
     if (id.substring(0, 15) == "googCertificate" ||
         id.substring(0, 9) == "googTrack" ||
         id.substring(0, 20) == "googLibjingleSession")
         return false;
 
-    if (type == "googComponent")
-        return false;
-
     return true;
 }
 
  * Peer statistics data holder.
  * @constructor
  */
-function PeerStats()
-{
+function PeerStats() {
     this.ssrc2Loss = {};
     this.ssrc2AudioLevel = {};
     this.ssrc2bitrate = {
 
 function ConferenceStats() {
 
-
     /**
      * The bandwidth
      * @type {{}}
      */
     this.packetLoss = null;
 
-
     /**
      * Array with the transport information.
      * @type {Array}
  * is done <tt>audioLevelsUpdateCallback</tt> is called with <tt>this</tt>
  * instance as an event source.
  *
- * @param peerconnection webRTC peer connection object.
- * @param interval stats refresh interval given in ms.
- * @param {function(StatsCollector)} audioLevelsUpdateCallback the callback
- * called on stats update.
- * @param config {object} supports the following properties - disableAudioLevels, disableStats, logStats
+ * @param peerconnection WebRTC PeerConnection object.
+ * @param audioLevelsInterval
+ * @param statsInterval stats refresh interval given in ms.
+ * @param eventEmitter
+ * @param config {object} supports the following properties: disableAudioLevels,
+ * disableStats, logStats
  * @constructor
  */
-function StatsCollector(peerconnection, audioLevelsInterval, statsInterval, eventEmitter, config)
-{
+function StatsCollector(
+        peerconnection,
+        audioLevelsInterval,
+        statsInterval,
+        eventEmitter,
+        config) {
+    // StatsCollector depends entirely on the format of the reports returned by
+    // RTCPeerConnection#getStats. Given that the value of
+    // RTCBrowserType#getBrowserType() is very unlikely to change at runtime, it
+    // makes sense to discover whether StatsCollector supports the executing
+    // browser as soon as possible. Otherwise, (1) getStatValue would have to
+    // needlessly check a "static" condition multiple times very very often and
+    // (2) the lack of support for the executing browser would be discovered and
+    // reported multiple times very very often too late in the execution in some
+    // totally unrelated callback.
+    /**
+     * The RTCBrowserType supported by this StatsCollector. In other words, the
+     * RTCBrowserType of the browser which initialized this StatsCollector
+     * instance.
+     * @private
+     */
+    this._browserType = RTCBrowserType.getBrowserType();
+    var keys = KEYS_BY_BROWSER_TYPE[this._browserType];
+    if (!keys)
+        throw "The browser type '" + this._browserType + "' isn't supported!";
+    /**
+     * The function which is to be used to retrieve the value associated in a
+     * report returned by RTCPeerConnection#getStats with a LibJitsiMeet
+     * browser-agnostic name/key.
+     * @function
+     * @private
+     */
+    this._getStatValue = this._defineGetStatValueMethod(keys);
+
     this.peerconnection = peerconnection;
     this.baselineAudioLevelsReport = null;
     this.currentAudioLevelsReport = null;
     /**
      * Stores the statistics which will be send to the focus to be logged.
      */
-    this.statsToBeLogged =
-    {
+    this.statsToBeLogged = {
         timestamps: [],
         stats: {}
     };
         this.audioLevelsIntervalId = null;
     }
 
-    if (this.statsIntervalId)
-    {
+    if (this.statsIntervalId) {
         clearInterval(this.statsIntervalId);
         this.statsIntervalId = null;
     }
 
-    if(this.gatherStatsIntervalId)
-    {
+    if (this.gatherStatsIntervalId) {
         clearInterval(this.gatherStatsIntervalId);
         this.gatherStatsIntervalId = null;
     }
  * Callback passed to <tt>getStats</tt> method.
  * @param error an error that occurred on <tt>getStats</tt> call.
  */
-StatsCollector.prototype.errorCallback = function (error)
-{
+StatsCollector.prototype.errorCallback = function (error) {
     logger.error("Get stats error", error);
     this.stop();
 };
 /**
  * Starts stats updates.
  */
-StatsCollector.prototype.start = function ()
-{
+StatsCollector.prototype.start = function () {
     var self = this;
     this.audioLevelsIntervalId = setInterval(
         function () {
         );
     }
 
-    // logging statistics does not support firefox
-    if (this.config.logStats && (browserSupported && !RTCBrowserType.isFirefox())) {
+    if (this.config.logStats
+            && browserSupported
+            // logging statistics does not support firefox
+            && this._browserType !== RTCBrowserType.RTC_BROWSER_FIREFOX) {
         this.gatherStatsIntervalId = setInterval(
             function () {
                 self.peerconnection.getStats(
    this.statsToBeLogged.timestamps = [];
 };
 
+/**
+ * Defines a function which (1) is to be used as a StatsCollector method and (2)
+ * gets the value from a specific report returned by RTCPeerConnection#getStats
+ * associated with a LibJitsiMeet browser-agnostic name.
+ *
+ * @param {Object.<string,string>} keys the map of LibJitsi browser-agnostic
+ * names to RTCPeerConnection#getStats browser-specific keys
+ */
+StatsCollector.prototype._defineGetStatValueMethod = function (keys) {
+    // Define the function which converts a LibJitsiMeet browser-asnostic name
+    // to a browser-specific key of a report returned by
+    // RTCPeerConnection#getStats.
+    var keyFromName = function (name) {
+        var key = keys[name];
+        if (key)
+            return key;
+        else
+            throw "The property '" + name + "' isn't supported!";
+    };
+
+    // Define the function which retrieves the value from a specific report
+    // returned by RTCPeerConnection#getStats associated with a given
+    // browser-specific key.
+    var itemStatByKey;
+    switch (this._browserType) {
+    case RTCBrowserType.RTC_BROWSER_CHROME:
+    case RTCBrowserType.RTC_BROWSER_OPERA:
+        // TODO What about other types of browser which are based on Chrome such
+        // as NW.js? Every time we want to support a new type browser we have to
+        // go and add more conditions (here and in multiple other places).
+        // Cannot we do a feature detection instead of a browser type check? For
+        // example, if item has a stat property of type function, then it's very
+        // likely that whoever defined it wanted you to call it in order to
+        // retrieve the value associated with a specific key.
+        itemStatByKey = function (item, key) { return item.stat(key) };
+        break;
+    default:
+        itemStatByKey = function (item, key) { return item[key] };
+    }
+
+    // Compose the 2 functions defined above to get a function which retrieves
+    // the value from a specific report returned by RTCPeerConnection#getStats
+    // associated with a specific LibJitsiMeet browser-agnostic name.
+    return function (item, name) {
+        return itemStatByKey(item, keyFromName(name))
+    };
+};
 
 /**
  * Stats processing logic.
         return;
     }
 
+    var getStatValue = this._getStatValue;
+
     for (var idx in this.currentStatsReport) {
         var now = this.currentStatsReport[idx];
         try {
-            if (getStatValue(now, 'receiveBandwidth') ||
-                getStatValue(now, 'sendBandwidth')) {
+            var receiveBandwidth = getStatValue(now, 'receiveBandwidth');
+            var sendBandwidth = getStatValue(now, 'sendBandwidth');
+            if (receiveBandwidth || sendBandwidth) {
                 this.conferenceStats.bandwidth = {
-                    "download": Math.round(
-                            (getStatValue(now, 'receiveBandwidth')) / 1000),
-                    "upload": Math.round(
-                            (getStatValue(now, 'sendBandwidth')) / 1000)
+                    "download": Math.round(receiveBandwidth / 1000),
+                    "upload": Math.round(sendBandwidth / 1000)
                 };
             }
         }
 
         if(now.type == 'googCandidatePair')
         {
-            var ip, type, localIP, active;
+            var ip, type, localip, active;
             try {
                 ip = getStatValue(now, 'remoteAddress');
                 type = getStatValue(now, "transportType");
-                localIP = getStatValue(now, "localAddress");
+                localip = getStatValue(now, "localAddress");
                 active = getStatValue(now, "activeConnection");
             }
             catch(e){/*not supported*/}
-            if(!ip || !type || !localIP || active != "true")
+            if(!ip || !type || !localip || active != "true")
                 continue;
-            var addressSaved = false;
-            for(var i = 0; i < this.conferenceStats.transport.length; i++)
-            {
-                if(this.conferenceStats.transport[i].ip == ip &&
-                    this.conferenceStats.transport[i].type == type &&
-                    this.conferenceStats.transport[i].localip == localIP)
-                {
-                    addressSaved = true;
-                }
+            // Save the address unless it has been saved already.
+            var conferenceStatsTransport = this.conferenceStats.transport;
+            if(!conferenceStatsTransport.some(function (t) { return (
+                        t.ip == ip && t.type == type && t.localip == localip
+                    )})) {
+                conferenceStatsTransport.push(
+                    {ip: ip, type: type, localip: localip});
             }
-            if(addressSaved)
-                continue;
-            this.conferenceStats.transport.push({localip: localIP, ip: ip, type: type});
             continue;
         }
 
-        if(now.type == "candidatepair")
-        {
+        if(now.type == "candidatepair") {
             if(now.state == "succeeded")
                 continue;
 
             var local = this.currentStatsReport[now.localCandidateId];
             var remote = this.currentStatsReport[now.remoteCandidateId];
-            this.conferenceStats.transport.push({localip: local.ipAddress + ":" + local.portNumber,
-                ip: remote.ipAddress + ":" + remote.portNumber, type: local.transport});
-
+            this.conferenceStats.transport.push({
+                ip: remote.ipAddress + ":" + remote.portNumber,
+                type: local.transport,
+                localip: local.ipAddress + ":" + local.portNumber
+            });
         }
 
         if (now.type != 'ssrc' && now.type != "outboundrtp" &&
         }
 
         var before = this.baselineStatsReport[idx];
+        var ssrc = getStatValue(now, 'ssrc');
         if (!before) {
-            logger.warn(getStatValue(now, 'ssrc') + ' not enough data');
+            logger.warn(ssrc + ' not enough data');
             continue;
         }
 
-        var ssrc = getStatValue(now, 'ssrc');
         if(!ssrc)
             continue;
 
-        var ssrcStats = this.ssrc2stats[ssrc];
-        if (!ssrcStats) {
-            ssrcStats = new PeerStats();
-            this.ssrc2stats[ssrc] = ssrcStats;
-        }
-
+        var ssrcStats
+          = this.ssrc2stats[ssrc] || (this.ssrc2stats[ssrc] = new PeerStats());
 
         var isDownloadStream = true;
         var key = 'packetsReceived';
             isDownloadStream: isDownloadStream
         });
 
-
         var bytesReceived = 0, bytesSent = 0;
-        if(getStatValue(now, "bytesReceived")) {
-            bytesReceived = getStatValue(now, "bytesReceived") -
-                getStatValue(before, "bytesReceived");
+        var nowBytesTransmitted = getStatValue(now, "bytesReceived");
+        if(nowBytesTransmitted) {
+            bytesReceived
+                = nowBytesTransmitted - getStatValue(before, "bytesReceived");
         }
-
-        if (getStatValue(now, "bytesSent")) {
-            bytesSent = getStatValue(now, "bytesSent") -
-                getStatValue(before, "bytesSent");
+        nowBytesTransmitted = getStatValue(now, "bytesSent");
+        if (nowBytesTransmitted) {
+            bytesSent = nowBytesTransmitted - getStatValue(before, "bytesSent");
         }
 
         var time = Math.round((now.timestamp - before.timestamp) / 1000);
 
         var resolution = {height: null, width: null};
         try {
-            if (getStatValue(now, "googFrameHeightReceived") &&
-                getStatValue(now, "googFrameWidthReceived")) {
-                resolution.height =
-                    getStatValue(now, "googFrameHeightReceived");
-                resolution.width = getStatValue(now, "googFrameWidthReceived");
+            var height, width;
+            if ((height = getStatValue(now, "googFrameHeightReceived")) &&
+                (width = getStatValue(now, "googFrameWidthReceived"))) {
+                resolution.height = height;
+                resolution.width = width;
             }
-            else if (getStatValue(now, "googFrameHeightSent") &&
-                getStatValue(now, "googFrameWidthSent")) {
-                resolution.height = getStatValue(now, "googFrameHeightSent");
-                resolution.width = getStatValue(now, "googFrameWidthSent");
+            else if ((height = getStatValue(now, "googFrameHeightSent")) &&
+                (width = getStatValue(now, "googFrameWidthSent"))) {
+                resolution.height = height;
+                resolution.width = width;
             }
         }
         catch(e){/*not supported*/}
         this
     );
 
-    this.conferenceStats.bitrate = {"upload": bitrateUpload, "download": bitrateDownload};
+    this.conferenceStats.bitrate
+      = {"upload": bitrateUpload, "download": bitrateDownload};
 
     this.conferenceStats.packetLoss = {
         total:
         upload:
             calculatePacketLoss(lostPackets.upload, totalPackets.upload)
     };
-    this.eventEmitter.emit(StatisticsEvents.CONNECTION_STATS,
-        {
+    this.eventEmitter.emit(StatisticsEvents.CONNECTION_STATS, {
             "bitrate": this.conferenceStats.bitrate,
             "packetLoss": this.conferenceStats.packetLoss,
             "bandwidth": this.conferenceStats.bandwidth,
             "transport": this.conferenceStats.transport
         });
     this.conferenceStats.transport = [];
-
 };
 
 /**
         return;
     }
 
+    var getStatValue = this._getStatValue;
+
     for (var idx in this.currentAudioLevelsReport) {
         var now = this.currentAudioLevelsReport[idx];
 
         }
 
         var before = this.baselineAudioLevelsReport[idx];
+        var ssrc = getStatValue(now, 'ssrc');
         if (!before) {
-            logger.warn(getStatValue(now, 'ssrc') + ' not enough data');
+            logger.warn(ssrc + ' not enough data');
             continue;
         }
 
-        var ssrc = getStatValue(now, 'ssrc');
         if (!ssrc) {
-            if((Date.now() - now.timestamp) < 3000)
+            if ((Date.now() - now.timestamp) < 3000)
                 logger.warn("No ssrc: ");
             continue;
         }
 
-        var ssrcStats = this.ssrc2stats[ssrc];
-        if (!ssrcStats) {
-            ssrcStats = new PeerStats();
-            this.ssrc2stats[ssrc] = ssrcStats;
-        }
+        var ssrcStats
+            = this.ssrc2stats[ssrc]
+                || (this.ssrc2stats[ssrc] = new PeerStats());
 
         // Audio level
-        var audioLevel = null;
-
         try {
-            audioLevel = getStatValue(now, 'audioInputLevel');
-            if (!audioLevel)
-                audioLevel = getStatValue(now, 'audioOutputLevel');
+            var audioLevel
+                = getStatValue(now, 'audioInputLevel')
+                    || getStatValue(now, 'audioOutputLevel');
         }
         catch(e) {/*not supported*/
             logger.warn("Audio Levels are not available in the statistics.");

modules/statistics/statistics.js

 /* global require */
 var LocalStats = require("./LocalStatsCollector.js");
+var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTPStats = require("./RTPStatsCollector.js");
 var EventEmitter = require("events");
 var StatisticsEvents = require("../../service/statistics/Events");
 var CallStats = require("./CallStats");
 var ScriptUtil = require('../util/ScriptUtil');
 
-// Since callstats.io is a third party, we cannot guarantee the quality of
-// their service. More specifically, their server may take noticeably long
-// time to respond. Consequently, it is in our best interest (in the sense
-// that the intergration of callstats.io is pretty important to us but not
-// enough to allow it to prevent people from joining a conference) to (1)
-// start downloading their API as soon as possible and (2) do the
-// downloading asynchronously.
+// Since callstats.io is a third party, we cannot guarantee the quality of their
+// service. More specifically, their server may take noticeably long time to
+// respond. Consequently, it is in our best interest (in the sense that the
+// intergration of callstats.io is pretty important to us but not enough to
+// allow it to prevent people from joining a conference) to (1) start
+// downloading their API as soon as possible and (2) do the downloading
+// asynchronously.
 function loadCallStatsAPI() {
     ScriptUtil.loadScript(
             'https://api.callstats.io/static/callstats.min.js',
     // have loaded by the time we needed it (i.e. CallStats.init is invoked).
 }
 
-
 /**
  * Log stats via the focus once every this many milliseconds.
  */
 var LOG_INTERVAL = 60000;
 
-var eventEmitter = new EventEmitter();
-
 function Statistics(xmpp, options) {
     this.rtpStats = null;
     this.eventEmitter = new EventEmitter();
     this.options = options || {};
     this.callStatsIntegrationEnabled
         = this.options.callStatsID && this.options.callStatsSecret
-        // Even though AppID and AppSecret may be specified, the integration of
-        // callstats.io may be disabled because of globally-disallowed requests
-        // to any third parties.
-        && (this.options.disableThirdPartyRequests !== true);
+            // Even though AppID and AppSecret may be specified, the integration
+            // of callstats.io may be disabled because of globally-disallowed
+            // requests to any third parties.
+            && (this.options.disableThirdPartyRequests !== true);
     if(this.callStatsIntegrationEnabled)
         loadCallStatsAPI();
     this.callStats = null;
 
     /**
-     * Send the stats already saved in rtpStats to be logged via
-     * the focus.
+     * Send the stats already saved in rtpStats to be logged via the focus.
      */
     this.logStatsIntervalId = null;
 }
 
     this.stopRemoteStats();
 
-    this.rtpStats = new RTPStats(peerconnection, 200, 2000, this.eventEmitter);
-    this.rtpStats.start();
-
-    this.logStatsIntervalId = setInterval(function () {
-        var stats = this.rtpStats.getCollectedStats();
-        if (this.xmpp.sendLogs(stats)) {
-            this.rtpStats.clearCollectedStats();
-        }
-    }.bind(this), LOG_INTERVAL);
+    try {
+        this.rtpStats
+            = new RTPStats(peerconnection, 200, 2000, this.eventEmitter);
+        this.rtpStats.start();
+    } catch (e) {
+        this.rtpStats = null;
+        logger.error('Failed to start collecting remote statistics: ' + e);
+    }
+    if (this.rtpStats) {
+        this.logStatsIntervalId = setInterval(function () {
+            var stats = this.rtpStats.getCollectedStats();
+            if (this.xmpp.sendLogs(stats)) {
+                this.rtpStats.clearCollectedStats();
+            }
+        }.bind(this), LOG_INTERVAL);
+    }
 };
 
 Statistics.localStats = [];
     localStats.start();
 };
 
-Statistics.prototype.addAudioLevelListener = function(listener)
-{
+Statistics.prototype.addAudioLevelListener = function(listener) {
     if(!Statistics.audioLevelsEnabled)
         return;
     this.eventEmitter.on(StatisticsEvents.AUDIO_LEVEL, listener);
 };
 
-Statistics.prototype.removeAudioLevelListener = function(listener)
-{
+Statistics.prototype.removeAudioLevelListener = function(listener) {
     if(!Statistics.audioLevelsEnabled)
         return;
     this.eventEmitter.removeListener(StatisticsEvents.AUDIO_LEVEL, listener);
         this.stopRemoteStats();
         if(this.eventEmitter)
             this.eventEmitter.removeAllListeners();
-
-        if(eventEmitter)
-            eventEmitter.removeAllListeners();
     }
 };
 
-
 Statistics.stopAllLocalStats = function () {
     if(!Statistics.audioLevelsEnabled)
         return;
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendIceConnectionFailedEvent = function (pc) {
-    if(this.callStatsIntegrationEnabled && this.callstats)
+    if(this.callstats)
         this.callstats.sendIceConnectionFailedEvent(pc, this.callstats);
 };
 
  * @param type {String} "audio"/"video"
  */
 Statistics.prototype.sendMuteEvent = function (muted, type) {
-    if(this.callStatsIntegrationEnabled)
+    if(this.callstats)
         CallStats.sendMuteEvent(muted, type, this.callstats);
 };
 
  * false for not stopping
  */
 Statistics.prototype.sendScreenSharingEvent = function (start) {
-    if(this.callStatsIntegrationEnabled)
+    if(this.callstats)
         CallStats.sendScreenSharingEvent(start, this.callstats);
 };
 
  * conference.
  */
 Statistics.prototype.sendDominantSpeakerEvent = function () {
-    if(this.callStatsIntegrationEnabled)
+    if(this.callstats)
         CallStats.sendDominantSpeakerEvent(this.callstats);
 };
 
  */
 Statistics.prototype.associateStreamWithVideoTag =
 function (ssrc, isLocal, usageLabel, containerId) {
-    if(this.callStatsIntegrationEnabled && this.callstats) {
+    if(this.callstats) {
         this.callstats.associateStreamWithVideoTag(
             ssrc, isLocal, usageLabel, containerId);
     }
  * @param {Error} e error to send
  */
 Statistics.prototype.sendGetUserMediaFailed = function (e) {
-    if(this.callStatsIntegrationEnabled)
+    if(this.callstats)
         CallStats.sendGetUserMediaFailed(e, this.callstats);
 };
 
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendCreateOfferFailed = function (e, pc) {
-    if(this.callStatsIntegrationEnabled)
+    if(this.callstats)
         CallStats.sendCreateOfferFailed(e, pc, this.callstats);
 };
 
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendCreateAnswerFailed = function (e, pc) {
-    if(this.callStatsIntegrationEnabled)
+    if(this.callstats)
         CallStats.sendCreateAnswerFailed(e, pc, this.callstats);
 };
 
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendSetLocalDescFailed = function (e, pc) {
-    if(this.callStatsIntegrationEnabled)
+    if(this.callstats)
         CallStats.sendSetLocalDescFailed(e, pc, this.callstats);
 };
 
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendSetRemoteDescFailed = function (e, pc) {
-    if(this.callStatsIntegrationEnabled)
+    if(this.callstats)
         CallStats.sendSetRemoteDescFailed(e, pc, this.callstats);
 };
 
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendAddIceCandidateFailed = function (e, pc) {
-    if(this.callStatsIntegrationEnabled)
+    if(this.callstats)
         CallStats.sendAddIceCandidateFailed(e, pc, this.callstats);
 };
 
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendUnhandledError = function (e) {
-    if(this.callStatsIntegrationEnabled)
+    if(this.callstats)
         CallStats.sendUnhandledError(e, this.callstats);
 };
 
 /**
  * Sends the given feedback through CallStats.
  *
- * @param overallFeedback an integer between 1 and 5 indicating the
- * user feedback
- * @param detailedFeedback detailed feedback from the user. Not yet used
+ * @param overall an integer between 1 and 5 indicating the user feedback
+ * @param detailed detailed feedback from the user. Not yet used
  */
-Statistics.prototype.sendFeedback =
-function(overallFeedback, detailedFeedback){
-    if(this.callStatsIntegrationEnabled && this.callstats)
-        this.callstats.sendFeedback(overallFeedback, detailedFeedback);
+Statistics.prototype.sendFeedback = function(overall, detailed) {
+    if(this.callstats)
+        this.callstats.sendFeedback(overall, detailed);
 };
 
 Statistics.LOCAL_JID = require("../../service/statistics/constants").LOCAL_JID;