RTCRtpSynchronizationSource.timestamp should use wall time, not monotonic time

Ahmad-S792 · Ahmad Saleem · commit ade17394d9f3 · 2026-02-09T01:22:11.000-08:00
https://bugs.webkit.org/show_bug.cgi?id=307036 rdar://169679084 Reviewed by Youenn Fablet. This patch aligns WebKit with Gecko / Firefox and Blink / Chromium. The timestamp field in RTCRtpSynchronizationSource and RTCRtpContributingSource was using libwebrtc's monotonic timestamp directly, but the WebRTC spec requires DOMHighResTimeStamp which is relative to the Unix epoch (wall time). This caused test failures where timestamps were not comparable to performance.timeOrigin + performance.now(). Fix by converting from libwebrtc's monotonic time to wall time using the offset between webrtc::TimeMillis() and WallTime::now(). The offset is computed once per LibWebRTCRtpReceiverBackend instance and cached to avoid repeated calculations. * Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCRtpReceiverBackend.cpp: (WebCore::LibWebRTCRtpReceiverBackend::webrtcToWallTimeOffset const): (WebCore::fillRTCRtpContributingSource): (WebCore::toRTCRtpContributingSource): (WebCore::toRTCRtpSynchronizationSource): (WebCore::LibWebRTCRtpReceiverBackend::getContributingSources const): (WebCore::LibWebRTCRtpReceiverBackend::getSynchronizationSources const): * Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCRtpReceiverBackend.h: * LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCRtpReceiver-getSynchronizationSources.https-expected.txt: Progressions Canonical link: https://commits.webkit.org/307063@main
diff --git a/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCRtpReceiver-getSynchronizationSources.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCRtpReceiver-getSynchronizationSources.https-expected.txt
@@ -3,13 +3,13 @@ PASS [audio] getSynchronizationSources() eventually returns a non-empty list
 PASS [audio] RTCRtpSynchronizationSource.timestamp is a number
 PASS [audio] RTCRtpSynchronizationSource.rtpTimestamp is a number [0, 2^32-1]
 PASS [audio] getSynchronizationSources() does not contain SSRCs older than 10 seconds
-FAIL [audio] RTCRtpSynchronizationSource.timestamp is comparable to performance.timeOrigin + performance.now() assert_true: expected true got false
+PASS [audio] RTCRtpSynchronizationSource.timestamp is comparable to performance.timeOrigin + performance.now()
 PASS [audio] RTCRtpSynchronizationSource.source is a number
 PASS [video] getSynchronizationSources() eventually returns a non-empty list
 PASS [video] RTCRtpSynchronizationSource.timestamp is a number
 PASS [video] RTCRtpSynchronizationSource.rtpTimestamp is a number [0, 2^32-1]
 PASS [video] getSynchronizationSources() does not contain SSRCs older than 10 seconds
-FAIL [video] RTCRtpSynchronizationSource.timestamp is comparable to performance.timeOrigin + performance.now() assert_true: expected true got false
+PASS [video] RTCRtpSynchronizationSource.timestamp is comparable to performance.timeOrigin + performance.now()
 PASS [video] RTCRtpSynchronizationSource.source is a number
 PASS [audio-only] RTCRtpSynchronizationSource.audioLevel is a number [0, 1]
 
diff --git a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCRtpReceiverBackend.cpp b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCRtpReceiverBackend.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2018-2026 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -39,7 +39,9 @@
 #include "RealtimeIncomingAudioSource.h"
 #include "RealtimeIncomingVideoSource.h"
 #include "Settings.h"
+#include <wtf/MonotonicTime.h>
 #include <wtf/TZoneMallocInlines.h>
+#include <wtf/WallTime.h>
 
 namespace WebCore {
 
@@ -57,45 +59,57 @@ RTCRtpParameters LibWebRTCRtpReceiverBackend::getParameters()
     return toRTCRtpParameters(m_rtcReceiver->GetParameters());
 }
 
-static inline void fillRTCRtpContributingSource(RTCRtpContributingSource& source, const webrtc::RtpSource& rtcSource)
+double LibWebRTCRtpReceiverBackend::webrtcToWallTimeOffset() const
 {
-    source.timestamp = rtcSource.timestamp().ms();
+    if (!m_webrtcToWallTimeOffset) {
+        auto currentWebRTCTime = webrtc::TimeMillis();
+        auto currentWallTime = WallTime::now();
+        m_webrtcToWallTimeOffset = currentWallTime.secondsSinceEpoch().milliseconds() - currentWebRTCTime;
+    }
+    return *m_webrtcToWallTimeOffset;
+}
+
+static inline void fillRTCRtpContributingSource(RTCRtpContributingSource& source, const webrtc::RtpSource& rtcSource, double webrtcToWallTimeOffset)
+{
+    source.timestamp = rtcSource.timestamp().ms() + webrtcToWallTimeOffset;
     source.rtpTimestamp = rtcSource.rtp_timestamp();
     source.source = rtcSource.source_id();
     if (rtcSource.audio_level())
         source.audioLevel = (*rtcSource.audio_level() == 127) ? 0 : pow(10, -*rtcSource.audio_level() / 20);
 }
 
-static inline RTCRtpContributingSource toRTCRtpContributingSource(const webrtc::RtpSource& rtcSource)
+static inline RTCRtpContributingSource toRTCRtpContributingSource(const webrtc::RtpSource& rtcSource, double webrtcToWallTimeOffset)
 {
     RTCRtpContributingSource source;
-    fillRTCRtpContributingSource(source, rtcSource);
+    fillRTCRtpContributingSource(source, rtcSource, webrtcToWallTimeOffset);
     return source;
 }
 
-static inline RTCRtpSynchronizationSource toRTCRtpSynchronizationSource(const webrtc::RtpSource& rtcSource)
+static inline RTCRtpSynchronizationSource toRTCRtpSynchronizationSource(const webrtc::RtpSource& rtcSource, double webrtcToWallTimeOffset)
 {
     RTCRtpSynchronizationSource source;
-    fillRTCRtpContributingSource(source, rtcSource);
+    fillRTCRtpContributingSource(source, rtcSource, webrtcToWallTimeOffset);
     return source;
 }
 
 Vector<RTCRtpContributingSource> LibWebRTCRtpReceiverBackend::getContributingSources() const
 {
     Vector<RTCRtpContributingSource> sources;
+    auto offset = webrtcToWallTimeOffset();
     for (auto& rtcSource : m_rtcReceiver->GetSources()) {
         if (rtcSource.source_type() == webrtc::RtpSourceType::CSRC)
-            sources.append(toRTCRtpContributingSource(rtcSource));
+            sources.append(toRTCRtpContributingSource(rtcSource, offset));
     }
     return sources;
 }
 
 Vector<RTCRtpSynchronizationSource> LibWebRTCRtpReceiverBackend::getSynchronizationSources() const
 {
     Vector<RTCRtpSynchronizationSource> sources;
+    auto offset = webrtcToWallTimeOffset();
     for (auto& rtcSource : m_rtcReceiver->GetSources()) {
         if (rtcSource.source_type() == webrtc::RtpSourceType::SSRC)
-            sources.append(toRTCRtpSynchronizationSource(rtcSource));
+            sources.append(toRTCRtpSynchronizationSource(rtcSource, offset));
     }
     return sources;
 }
diff --git a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCRtpReceiverBackend.h b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCRtpReceiverBackend.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2018-2026 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -55,8 +55,11 @@ class LibWebRTCRtpReceiverBackend final : public RTCRtpReceiverBackend {
     Ref<RTCRtpTransformBackend> rtcRtpTransformBackend() final;
     std::unique_ptr<RTCDtlsTransportBackend> dtlsTransportBackend() final;
 
+    double webrtcToWallTimeOffset() const;
+
     const Ref<webrtc::RtpReceiverInterface> m_rtcReceiver;
     const RefPtr<RTCRtpTransformBackend> m_transformBackend;
+    mutable std::optional<double> m_webrtcToWallTimeOffset;
 };
 
 } // namespace WebCore

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2018 Apple Inc. All rights reserved.`
	`2`	`+ * Copyright (C) 2018-2026 Apple Inc. All rights reserved.`
`3`	`3`	`*`
`4`	`4`	`* Redistribution and use in source and binary forms, with or without`
`5`	`5`	`* modification, are permitted provided that the following conditions`
`@@ -39,7 +39,9 @@`
`39`	`39`	`#include "RealtimeIncomingAudioSource.h"`
`40`	`40`	`#include "RealtimeIncomingVideoSource.h"`
`41`	`41`	`#include "Settings.h"`
	`42`	`+#include <wtf/MonotonicTime.h>`
`42`	`43`	`#include <wtf/TZoneMallocInlines.h>`
	`44`	`+#include <wtf/WallTime.h>`
`43`	`45`
`44`	`46`	`namespace WebCore {`
`45`	`47`
`@@ -57,45 +59,57 @@ RTCRtpParameters LibWebRTCRtpReceiverBackend::getParameters()`
`57`	`59`	`return toRTCRtpParameters(m_rtcReceiver->GetParameters());`
`58`	`60`	`}`
`59`	`61`
`60`		`-static inline void fillRTCRtpContributingSource(RTCRtpContributingSource& source, const webrtc::RtpSource& rtcSource)`
	`62`	`+double LibWebRTCRtpReceiverBackend::webrtcToWallTimeOffset() const`
`61`	`63`	`{`
`62`		`- source.timestamp = rtcSource.timestamp().ms();`
	`64`	`+ if (!m_webrtcToWallTimeOffset) {`
	`65`	`+ auto currentWebRTCTime = webrtc::TimeMillis();`
	`66`	`+ auto currentWallTime = WallTime::now();`
	`67`	`+ m_webrtcToWallTimeOffset = currentWallTime.secondsSinceEpoch().milliseconds() - currentWebRTCTime;`
	`68`	`+ }`
	`69`	`+ return *m_webrtcToWallTimeOffset;`
	`70`	`+}`
	`71`	`+`
	`72`	`+static inline void fillRTCRtpContributingSource(RTCRtpContributingSource& source, const webrtc::RtpSource& rtcSource, double webrtcToWallTimeOffset)`
	`73`	`+{`
	`74`	`+ source.timestamp = rtcSource.timestamp().ms() + webrtcToWallTimeOffset;`
`63`	`75`	`source.rtpTimestamp = rtcSource.rtp_timestamp();`
`64`	`76`	`source.source = rtcSource.source_id();`
`65`	`77`	`if (rtcSource.audio_level())`
`66`	`78`	`source.audioLevel = (rtcSource.audio_level() == 127) ? 0 : pow(10, -rtcSource.audio_level() / 20);`
`67`	`79`	`}`
`68`	`80`
`69`		`-static inline RTCRtpContributingSource toRTCRtpContributingSource(const webrtc::RtpSource& rtcSource)`
	`81`	`+static inline RTCRtpContributingSource toRTCRtpContributingSource(const webrtc::RtpSource& rtcSource, double webrtcToWallTimeOffset)`
`70`	`82`	`{`
`71`	`83`	`RTCRtpContributingSource source;`
`72`		`- fillRTCRtpContributingSource(source, rtcSource);`
	`84`	`+ fillRTCRtpContributingSource(source, rtcSource, webrtcToWallTimeOffset);`
`73`	`85`	`return source;`
`74`	`86`	`}`
`75`	`87`
`76`		`-static inline RTCRtpSynchronizationSource toRTCRtpSynchronizationSource(const webrtc::RtpSource& rtcSource)`
	`88`	`+static inline RTCRtpSynchronizationSource toRTCRtpSynchronizationSource(const webrtc::RtpSource& rtcSource, double webrtcToWallTimeOffset)`
`77`	`89`	`{`
`78`	`90`	`RTCRtpSynchronizationSource source;`
`79`		`- fillRTCRtpContributingSource(source, rtcSource);`
	`91`	`+ fillRTCRtpContributingSource(source, rtcSource, webrtcToWallTimeOffset);`
`80`	`92`	`return source;`
`81`	`93`	`}`
`82`	`94`
`83`	`95`	`Vector<RTCRtpContributingSource> LibWebRTCRtpReceiverBackend::getContributingSources() const`
`84`	`96`	`{`
`85`	`97`	`Vector<RTCRtpContributingSource> sources;`
	`98`	`+ auto offset = webrtcToWallTimeOffset();`
`86`	`99`	`for (auto& rtcSource : m_rtcReceiver->GetSources()) {`
`87`	`100`	`if (rtcSource.source_type() == webrtc::RtpSourceType::CSRC)`
`88`		`- sources.append(toRTCRtpContributingSource(rtcSource));`
	`101`	`+ sources.append(toRTCRtpContributingSource(rtcSource, offset));`
`89`	`102`	`}`
`90`	`103`	`return sources;`
`91`	`104`	`}`
`92`	`105`
`93`	`106`	`Vector<RTCRtpSynchronizationSource> LibWebRTCRtpReceiverBackend::getSynchronizationSources() const`
`94`	`107`	`{`
`95`	`108`	`Vector<RTCRtpSynchronizationSource> sources;`
	`109`	`+ auto offset = webrtcToWallTimeOffset();`
`96`	`110`	`for (auto& rtcSource : m_rtcReceiver->GetSources()) {`
`97`	`111`	`if (rtcSource.source_type() == webrtc::RtpSourceType::SSRC)`
`98`		`- sources.append(toRTCRtpSynchronizationSource(rtcSource));`
	`112`	`+ sources.append(toRTCRtpSynchronizationSource(rtcSource, offset));`
`99`	`113`	`}`
`100`	`114`	`return sources;`
`101`	`115`	`}`