feat: report avg RTT for P2P

modules/RTC/RTCBrowserType.js

         return !RTCBrowserType.isFirefox();
     },
 
+    /**
+     * Checks if the current browser reports round trip time statistics for
+     * the ICE candidate pair.
+     * @return {boolean}
+     */
+    supportsRTTStatistics() {
+        // Firefox does not seem to report RTT for ICE candidate pair:
+        // eslint-disable-next-line max-len
+        // https://www.w3.org/TR/webrtc-stats/#dom-rtcicecandidatepairstats-currentroundtriptime
+        // It does report mozRTT for RTP streams, but at the time of this
+        // writing it's value does not make sense most of the time
+        // (is reported as 1):
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=1241066
+        // For Chrome and others we rely on 'googRtt'.
+        return !RTCBrowserType.isFirefox();
+    },
+
     /**
      * Whether jitsi-meet supports simulcast on the current browser.
      * @returns {boolean}

modules/statistics/AvgRTPStatsReporter.js

          */
         this._avgRemoteFPS = new AverageStatReport('stat.avg.framerate.remote');
 
+        /**
+         * Average round trip time reported by the ICE candidate pair.
+         * FIXME currently reported only for P2P
+         * @type {AverageStatReport}
+         * @private
+         */
+        this._avgRTT = new AverageStatReport('stat.avg.rtt');
+
         /**
          * Average FPS for local video
          * @type {AverageStatReport}
         this._avgPacketLossTotal.addNext(packetLoss.total);
         this._avgCQ.addNext(data.connectionQuality);
 
+        if (RTCBrowserType.supportsRTTStatistics()) {
+            // FIXME implement JVB end-to-end RTT
+            if (isP2P && data.transport && data.transport.length) {
+                this._avgRTT.addNext(data.transport[0].rtt);
+            } else {
+                this._avgRTT.reset();
+            }
+        }
+
         if (frameRate) {
             this._avgRemoteFPS.addNext(
                 this._calculateAvgVideoFps(frameRate, false /* remote */));
             this._avgLocalFPS.report(isP2P);
             this._avgCQ.report(isP2P);
 
+            // FIXME implement JVB end-to-end RTT
+            if (isP2P && RTCBrowserType.supportsRTTStatistics()) {
+                this._avgRTT.report(isP2P);
+            }
+
             this._resetAvgStats();
         }
     }
         this._avgRemoteFPS.reset();
         this._avgLocalFPS.reset();
         this._avgCQ.reset();
+        this._avgRTT.reset();
         this._sampleIdx = 0;
     }
 

modules/statistics/RTPStatsCollector.js

     'googFrameRateReceived': 'googFrameRateReceived',
     'googFrameRateSent': 'googFrameRateSent',
     'audioInputLevel': 'audioInputLevel',
-    'audioOutputLevel': 'audioOutputLevel'
+    'audioOutputLevel': 'audioOutputLevel',
+    'currentRoundTripTime': 'googRtt'
 };
 KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_OPERA]
     = KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
         } catch (e) { /* not supported*/ }
 
         if (now.type === 'googCandidatePair') {
-            let active, ip, localip, type;
+            let active, ip, localip, rtt, type;
 
             try {
                 ip = getStatValue(now, 'remoteAddress');
                 type = getStatValue(now, 'transportType');
                 localip = getStatValue(now, 'localAddress');
                 active = getStatValue(now, 'activeConnection');
+                rtt = getNonNegativeStat(now, 'currentRoundTripTime');
             } catch (e) { /* not supported*/ }
             if (!ip || !type || !localip || active !== 'true') {
                 continue;
                     ip,
                     type,
                     localip,
-                    p2p: this.peerconnection.isP2P
+                    p2p: this.peerconnection.isP2P,
+                    rtt
                 });
             }
             continue;