fix(stats): Return promise for getStats.

Switch to returning a Promise for getStats. Reset frame rate stat to 0 when video is suspended as a result of endpoint falling out of last-n.

modules/RTC/TraceablePeerConnection.js

 
     if (this.maxstats) {
         this.statsinterval = window.setInterval(() => {
-            this.getStats(stats => {
-                if (stats.result
-                    && typeof stats.result === 'function') {
+            this.getStats().then(stats => {
+                if (typeof stats?.result === 'function') {
                     const results = stats.result();
 
                     for (let i = 0; i < results.length; ++i) {
 /**
  * Obtains call-related stats from the peer connection.
  *
- * @param {Function} callback - The function to invoke after successfully obtaining stats.
- * @param {Function} errback - The function to invoke after failing to obtain stats.
- * @returns {void}
+ * @returns {Promise<Object>} Promise which resolves with data providing statistics about
+ * the peerconnection.
  */
-TraceablePeerConnection.prototype.getStats = function(callback, errback) {
-    // eslint-disable-next-line no-empty-function
-    this.peerconnection.getStats().then(callback, errback || (() => {}));
+TraceablePeerConnection.prototype.getStats = function() {
+    return this.peerconnection.getStats();
 };
 
 /**

modules/statistics/RTPStatsCollector.js

                     }
                 } else {
                     // Interval updates
-                    this.peerconnection.getStats(
-                        report => {
-                            let results = null;
-
-                            if (!report || !report.result
-                                || typeof report.result !== 'function') {
-                                results = report;
-                            } else {
-                                results = report.result();
-                            }
-                            this.currentAudioLevelsReport = results;
+                    this.peerconnection.getStats()
+                        .then(report => {
+                            this.currentAudioLevelsReport = typeof report?.result === 'function'
+                                ? report.result()
+                                : report;
                             this.processAudioLevelReport();
                             this.baselineAudioLevelsReport = this.currentAudioLevelsReport;
-                        },
-                        error => this.errorCallback(error)
-                    );
+                        })
+                        .catch(error => this.errorCallback(error));
                 }
             },
             this.audioLevelsIntervalMilis
 
     const processStats = () => {
         // Interval updates
-        this.peerconnection.getStats(
-            report => {
-                let results = null;
-
-                if (!report || !report.result
-                    || typeof report.result !== 'function') {
-                    // firefox
-                    results = report;
-                } else {
-                    // chrome
-                    results = report.result();
-                }
+        this.peerconnection.getStats()
+            .then(report => {
+                this.currentStatsReport = typeof report?.result === 'function'
+                    ? report.result()
+                    : report;
 
-                this.currentStatsReport = results;
                 try {
                     this.processStatsReport();
                 } catch (error) {
                     logger.error('Processing of RTP stats failed:', error);
                 }
                 this.previousStatsReport = this.currentStatsReport;
-            },
-            error => this.errorCallback(error)
-        );
+            })
+            .catch(error => this.errorCallback(error));
     };
 
     processStats();
             // Get the number of simulcast streams currently enabled from TPC.
             const numberOfActiveStreams = this.peerconnection.getActiveSimulcastStreams();
 
-            ssrcStats.setFramerate(Math.round((frameRate / numberOfActiveStreams) || 0));
+            // Reset frame rate to 0 when video is suspended as a result of endpoint falling out of last-n.
+            frameRate = numberOfActiveStreams ? Math.round(frameRate / numberOfActiveStreams) : 0;
+            ssrcStats.setFramerate(frameRate);
         }
     });