mediasoup 3.26.0 → 3.27.0

package/worker/meson.build

@@ -26,20 +26,6 @@ if host_machine.system() == 'windows'
   ]
 endif
 
-if get_option('ms_build_tests')
-  cpp_args += [
-    '-DMS_TEST',
-    '-DMS_LOG_STD'
-  ]
-endif
-
-if get_option('ms_build_fuzzer')
-  cpp_args += [
-    '-DMS_FUZZER',
-    '-DMS_LOG_STD'
-  ]
-endif
-
 if get_option('ms_log_trace')
   cpp_args += [
     '-DMS_LOG_TRACE',
@@ -70,6 +56,26 @@ if get_option('ms_dump_rtp_shared_packet_memory_usage')
   ]
 endif
 
+if get_option('ms_build_tests')
+  cpp_args += [
+    '-DMS_TEST',
+    '-DMS_LOG_STD',
+  ]
+endif
+
+if get_option('ms_build_fuzzer')
+  cpp_args += [
+    '-DMS_FUZZER',
+    '-DMS_LOG_STD',
+  ]
+endif
+
+if get_option('ms_use_builtin_bwe')
+  cpp_args += [
+    '-DMS_USE_BUILTIN_BWE',
+  ]
+endif
+
 cpp = meson.get_compiler('cpp')
 
 # This is a workaround to define FLATBUFFERS_LOCALE_INDEPENDENT=0 outside
@@ -86,7 +92,6 @@ common_sources = [
   'src/lib.cpp',
   'src/DepLibSRTP.cpp',
   'src/DepLibUV.cpp',
-  'src/DepLibWebRTC.cpp',
   'src/DepOpenSSL.cpp',
   'src/Logger.cpp',
   'src/MediaSoupErrors.cpp',
@@ -131,7 +136,6 @@ common_sources = [
   'src/RTC/RtpListener.cpp',
   'src/RTC/RtpObserver.cpp',
   'src/RTC/SctpListener.cpp',
-  'src/RTC/SenderBandwidthEstimator.cpp',
   'src/RTC/SeqManager.cpp',
   'src/RTC/Serializable.cpp',
   'src/RTC/PipeProducerStreamManager.cpp',
@@ -143,8 +147,6 @@ common_sources = [
   'src/RTC/TcpConnection.cpp',
   'src/RTC/TcpServer.cpp',
   'src/RTC/Transport.cpp',
-  'src/RTC/TransportCongestionControlClient.cpp',
-  'src/RTC/TransportCongestionControlServer.cpp',
   'src/RTC/TransportTuple.cpp',
   'src/RTC/TrendCalculator.cpp',
   'src/RTC/UdpSocket.cpp',
@@ -161,6 +163,15 @@ common_sources = [
   'src/RTC/RtpDictionaries/RtpParameters.cpp',
   'src/RTC/RtpDictionaries/RtpRtxParameters.cpp',
   'src/RTC/SctpDictionaries/SctpStreamParameters.cpp',
+  'src/RTC/BWE/AimdRateControl.cpp',
+  'src/RTC/BWE/BweTypes.cpp',
+  'src/RTC/BWE/DelayBasedBwe.cpp',
+  'src/RTC/BWE/FeedbackAdapter.cpp',
+  'src/RTC/BWE/InterArrivalDelta.cpp',
+  'src/RTC/BWE/LinkCapacityEstimator.cpp',
+  'src/RTC/BWE/RobustThroughputEstimator.cpp',
+  'src/RTC/BWE/SendPacketHistory.cpp',
+  'src/RTC/BWE/TrendlineEstimator.cpp',
   'src/RTC/ICE/IceCandidate.cpp',
   'src/RTC/ICE/IceServer.cpp',
   'src/RTC/ICE/StunPacket.cpp',
@@ -287,6 +298,16 @@ common_sources = [
   'src/RTC/SCTP/public/Message.cpp',
 ]
 
+# The deps/libwebrtc bandwidth estimation is only built when the built-in one is
+# not used.
+if not get_option('ms_use_builtin_bwe')
+  common_sources += [
+    'src/DepLibWebRTC.cpp',
+    'src/RTC/TransportCongestionControlClient.cpp',
+    'src/RTC/TransportCongestionControlServer.cpp',
+  ]
+endif
+
 libuv_proj = subproject(
   'libuv',
   default_options: [
@@ -313,14 +334,6 @@ libsrtp3_proj = subproject(
   ],
 )
 
-abseil_cpp_proj = subproject(
-  'abseil-cpp',
-  default_options: [
-    'warning_level=0',
-    'cpp_std=c++17',
-  ],
-)
-
 ankerl_unordered_dense_dep = dependency('unordered_dense')
 
 flatbuffers_proj = subproject(
@@ -333,20 +346,13 @@ flatbuffers_proj = subproject(
 # flatbuffers schemas subdirectory.
 subdir('fbs')
 
-# Add current build directory so libwebrtc has access to FBS folder.
-libwebrtc_include_directories = include_directories('include', 'fbs')
-
-subdir('deps/libwebrtc')
-
 dependencies = [
   libuv_proj.get_variable('libuv_dep'),
   openssl_proj.get_variable('openssl_dep'),
   libsrtp3_proj.get_variable('libsrtp3_dep'),
-  abseil_cpp_proj.get_variable('absl_container_dep'),
   ankerl_unordered_dense_dep,
   flatbuffers_proj.get_variable('flatbuffers_dep'),
   flatbuffers_generator_dep,
-  libwebrtc_dep,
 ]
 
 link_whole = [
@@ -354,11 +360,34 @@ link_whole = [
   openssl_proj.get_variable('libcrypto_lib'),
   openssl_proj.get_variable('libssl_lib'),
   libsrtp3_proj.get_variable('libsrtp3'),
-  abseil_cpp_proj.get_variable('absl_container_lib'),
   flatbuffers_proj.get_variable('flatbuffers_lib'),
-  libwebrtc,
 ]
 
+if not get_option('ms_use_builtin_bwe')
+  # NOTE: abseil-cpp is in the tree only because deps/libwebrtc needs it.
+  abseil_cpp_proj = subproject(
+    'abseil-cpp',
+    default_options: [
+      'warning_level=0',
+      'cpp_std=c++17',
+    ],
+  )
+
+  # Add current build directory so libwebrtc has access to FBS folder.
+  libwebrtc_include_directories = include_directories('include', 'fbs')
+
+  subdir('deps/libwebrtc')
+
+  dependencies += [
+    abseil_cpp_proj.get_variable('absl_container_dep'),
+    libwebrtc_dep,
+  ]
+  link_whole += [
+    abseil_cpp_proj.get_variable('absl_container_lib'),
+    libwebrtc,
+  ]
+endif
+
 if host_machine.system() == 'windows'
   wingetopt_proj = subproject(
     'wingetopt',
@@ -415,6 +444,7 @@ executable(
 mock_sources = [
   'mocks/src/MockShared.cpp',
   'mocks/src/handles/MockBackoffTimerHandle.cpp',
+  'mocks/src/handles/MockTimerHandle.cpp',
   'mocks/src/Channel/MockChannelMessageRegistrator.cpp',
   'mocks/src/RTC/SCTP/association/MockTransmissionControlBlockContext.cpp',
 ]
@@ -422,6 +452,7 @@ mock_sources = [
 test_sources = [
   'test/src/tests.cpp',
   'test/src/testHelpers.cpp',
+  'test/src/TestDepLibUV.cpp',
   'test/src/RTC/TestConsumer.cpp',
   'test/src/RTC/TestPipeProducerStreamManager.cpp',
   'test/src/RTC/TestSimpleProducerStreamManager.cpp',
@@ -436,9 +467,17 @@ test_sources = [
   'test/src/RTC/TestRtpEncodingParameters.cpp',
   'test/src/RTC/TestSeqManager.cpp',
   'test/src/RTC/TestSubchannelsCodec.cpp',
-  'test/src/RTC/TestTransportCongestionControlServer.cpp',
   'test/src/RTC/TestTransportTuple.cpp',
   'test/src/RTC/TestTrendCalculator.cpp',
+  'test/src/RTC/BWE/helpers/LinkSimulator.cpp',
+  'test/src/RTC/BWE/TestAimdRateControl.cpp',
+  'test/src/RTC/BWE/TestDelayBasedBwe.cpp',
+  'test/src/RTC/BWE/TestFeedbackAdapter.cpp',
+  'test/src/RTC/BWE/TestInterArrivalDelta.cpp',
+  'test/src/RTC/BWE/TestLinkCapacityEstimator.cpp',
+  'test/src/RTC/BWE/TestRobustThroughputEstimator.cpp',
+  'test/src/RTC/BWE/TestSendPacketHistory.cpp',
+  'test/src/RTC/BWE/TestTrendlineEstimator.cpp',
   'test/src/RTC/ICE/iceCommon.cpp',
   'test/src/RTC/ICE/TestStunPacket.cpp',
   'test/src/RTC/RTP/rtpCommon.cpp',
@@ -558,6 +597,12 @@ test_sources = [
   'test/src/Utils/TestUnwrappedSequenceNumber.cpp',
 ]
 
+if not get_option('ms_use_builtin_bwe')
+  test_sources += [
+    'test/src/RTC/TestTransportCongestionControlServer.cpp',
+  ]
+endif
+
 mediasoup_worker_test = executable(
   'mediasoup-worker-test',
   build_by_default: false,

package/worker/meson_options.txt

@@ -5,3 +5,4 @@ option('ms_dump_rtp_payload_descriptor', type: 'boolean', value: false, descript
 option('ms_dump_rtp_shared_packet_memory_usage', type: 'boolean', value: false, description: 'prints information about total memory allocated by RTC::RTP::SharedPacket instances')
 option('ms_build_tests', type: 'boolean', value: false, description: 'Must be enabled when building mediasoup worker tests')
 option('ms_build_fuzzer', type: 'boolean', value: false, description: 'Must be enabled when building mediasoup worker fuzzer')
+option('ms_use_builtin_bwe', type: 'boolean', value: false, description: 'Use the new built-in bandwidth estimation module')

package/worker/mocks/include/MockShared.hpp

@@ -6,6 +6,7 @@
 #include "SharedInterface.hpp"
 #include "mocks/include/Channel/MockChannelMessageRegistrator.hpp"
 #include "mocks/include/handles/MockBackoffTimerHandle.hpp"
+#include "mocks/include/handles/MockTimerHandle.hpp"
 #include <map>
 #include <string>
 #include <string_view>
@@ -15,7 +16,7 @@ namespace mocks
 	class MockShared : public SharedInterface
 	{
 	public:
-		explicit MockShared(std::function<uint64_t()> getTimeMs);
+		explicit MockShared(std::function<int64_t()> getTimeUs);
 
 		~MockShared() override = default;
 
@@ -30,45 +31,44 @@ namespace mocks
 			return this->channelNotifier.get();
 		}
 
-		TimerHandleInterface* CreateTimer(TimerHandleInterface::Listener* listener) override;
+		TimerHandleInterface* CreateTimer(TimerHandleInterface::Listener* listener, std::string label) override;
 
 		BackoffTimerHandleInterface* CreateBackoffTimer(
 		  const BackoffTimerHandleInterface::BackoffTimerHandleOptions& options) override;
 
-		uint64_t GetTimeMs() override
+		int64_t GetTimeMs() override
 		{
-			return this->getTimeMs();
+			return GetTimeUs() / 1000;
 		}
 
-		uint64_t GetTimeUs() override
+		int64_t GetTimeUs() override
 		{
-			return GetTimeMs() * 1000;
-		}
-
-		uint64_t GetTimeNs() override
-		{
-			return GetTimeMs() * 1000 * 1000;
-		}
-
-		int64_t GetTimeMsInt64() override
-		{
-			return static_cast<int64_t>(GetTimeMs());
-		}
-
-		int64_t GetTimeUsInt64() override
-		{
-			return static_cast<int64_t>(GetTimeUs());
+			return this->getTimeUs();
 		}
 
 		// NOTE: The NTP epoch is made to be the very clock given by argument, so that tests
 		// can reason about a single set of values.
-		uint64_t GetNtpOffsetMs() override
+		int64_t GetNtpOffsetUs() override
 		{
 			return 0;
 		}
 
 		// Methods for testing.
 	public:
+		MockTimerHandle* GetTimer(const std::string_view label) const
+		{
+			const auto it = this->timers.find(std::string(label));
+
+			if (it != this->timers.end())
+			{
+				return it->second;
+			}
+			else
+			{
+				return nullptr;
+			}
+		}
+
 		MockBackoffTimerHandle* GetBackoffTimer(const std::string_view label) const
 		{
 			const auto it = this->backoffTimers.find(std::string(label));
@@ -85,11 +85,12 @@ namespace mocks
 
 	private:
 		// Given by argument.
-		const std::function<uint64_t()> getTimeMs;
+		const std::function<int64_t()> getTimeUs;
 		// Others.
 		std::unique_ptr<::Channel::ChannelSocket> channelSocket;
 		std::unique_ptr<mocks::Channel::MockChannelMessageRegistrator> channelMessageRegistrator;
 		std::unique_ptr<::Channel::ChannelNotifier> channelNotifier;
+		std::map<std::string /*label*/, MockTimerHandle* /*timer*/> timers;
 		std::map<std::string /*label*/, MockBackoffTimerHandle* /*backoffTimer*/> backoffTimers;
 	};
 } // namespace mocks

package/worker/mocks/include/RTC/SCTP/association/MockTransmissionControlBlockContext.hpp

@@ -21,7 +21,7 @@ namespace mocks
 			  : public ::RTC::SCTP::TransmissionControlBlockContextInterface
 			{
 			public:
-				using GetCurrentRtoMsAction = std::function<uint64_t()>;
+				using GetCurrentRtoUsAction = std::function<int64_t()>;
 
 			public:
 				explicit MockTransmissionControlBlockContext(
@@ -49,18 +49,19 @@ namespace mocks
 					return 0;
 				}
 
-				void ObserveRttMs(uint64_t rttMs) override
+				void ObserveRttUs(int64_t rttUs) override
 				{
-					this->observeRttMsCallCount++;
+					this->observeRttUsCallCount++;
+					this->observeRttUsCalledWith = rttUs;
 				}
 
-				uint64_t GetCurrentRtoMs() const override
+				int64_t GetCurrentRtoUs() const override
 				{
-					if (!this->getCurrentRtoMsOnceActions.empty())
+					if (!this->getCurrentRtoUsOnceActions.empty())
 					{
-						auto action = std::move(this->getCurrentRtoMsOnceActions.front());
+						auto action = std::move(this->getCurrentRtoUsOnceActions.front());
 
-						this->getCurrentRtoMsOnceActions.pop();
+						this->getCurrentRtoUsOnceActions.pop();
 
 						return action();
 					}
@@ -101,12 +102,19 @@ namespace mocks
 
 				/**
 				 * @remarks
-				 * - Must be called before expecting calls to `ObserveRttMs()`.
+				 * - Must be called before expecting calls to `ObserveRttUs()`.
 				 */
-				MockTransmissionControlBlockContext& ExpectObserveRttMsCalledTimes(size_t times)
+				MockTransmissionControlBlockContext& ExpectObserveRttUsCalledTimes(size_t times)
 				{
-					this->observeRttMsCallCount         = 0;
-					this->expectedObserveRttMsCallCount = times;
+					this->observeRttUsCallCount         = 0;
+					this->expectedObserveRttUsCallCount = times;
+
+					return *this;
+				}
+
+				MockTransmissionControlBlockContext& ExpectObserveRttUsCalledWith(int64_t rttUs)
+				{
+					this->expectedObserveRttUsCalledWith = rttUs;
 
 					return *this;
 				}
@@ -123,9 +131,9 @@ namespace mocks
 					return *this;
 				}
 
-				MockTransmissionControlBlockContext& WillGetCurrentRtoMsOnce(GetCurrentRtoMsAction action)
+				MockTransmissionControlBlockContext& WillGetCurrentRtoUsOnce(GetCurrentRtoUsAction action)
 				{
-					this->getCurrentRtoMsOnceActions.push(std::move(action));
+					this->getCurrentRtoUsOnceActions.push(std::move(action));
 
 					return *this;
 				}
@@ -133,13 +141,27 @@ namespace mocks
 				mocks::VerificationResult VerifyExpectations() const
 				{
 					if (
-					  this->expectedObserveRttMsCallCount.has_value() &&
-					  this->observeRttMsCallCount != this->expectedObserveRttMsCallCount.value())
+					  this->expectedObserveRttUsCallCount.has_value() &&
+					  this->observeRttUsCallCount != this->expectedObserveRttUsCallCount.value())
+					{
+						return { .ok           = false,
+						         .errorMessage = "ObserveRttUs() call count mismatch [expected:" +
+							                       std::to_string(this->expectedObserveRttUsCallCount.value()) +
+							                       ", got:" + std::to_string(this->observeRttUsCallCount) + "]" };
+					}
+
+					if (
+					  this->expectedObserveRttUsCalledWith.has_value() &&
+					  this->observeRttUsCalledWith != this->expectedObserveRttUsCalledWith)
 					{
 						return { .ok           = false,
-							       .errorMessage = "ObserveRttMs() call count mismatch [expected:" +
-							                       std::to_string(this->expectedObserveRttMsCallCount.value()) +
-							                       ", got:" + std::to_string(this->observeRttMsCallCount) + "]" };
+						         .errorMessage = "ObserveRttUs() call mismatch [expected:" +
+							                       std::to_string(this->expectedObserveRttUsCalledWith.value()) +
+							                       ", got:" +
+							                       (this->observeRttUsCalledWith.has_value()
+							                          ? std::to_string(this->observeRttUsCalledWith.value())
+							                          : "none") +
+							                       "]" };
 					}
 
 					if (
@@ -148,10 +170,10 @@ namespace mocks
 					    this->expectedIncrementTxErrorCounterCallCount.value())
 					{
 						return { .ok = false,
-							       .errorMessage =
-							         "IncrementTxErrorCounter() call count mismatch [expected:" +
-							         std::to_string(this->expectedIncrementTxErrorCounterCallCount.value()) +
-							         ", got:" + std::to_string(this->incrementTxErrorCounterCallCount) + "]" };
+						         .errorMessage =
+						           "IncrementTxErrorCounter() call count mismatch [expected:" +
+						           std::to_string(this->expectedIncrementTxErrorCounterCallCount.value()) +
+						           ", got:" + std::to_string(this->incrementTxErrorCounterCallCount) + "]" };
 					}
 
 					return { .ok = true, .errorMessage = "" };
@@ -162,12 +184,14 @@ namespace mocks
 				::RTC::SCTP::AssociationListenerInterface& associationListener;
 				const ::RTC::SCTP::SctpOptions sctpOptions;
 
-				// ObserveRttMs().
-				size_t observeRttMsCallCount{ 0 };
-				std::optional<size_t> expectedObserveRttMsCallCount;
+				// ObserveRttUs().
+				size_t observeRttUsCallCount{ 0 };
+				std::optional<size_t> expectedObserveRttUsCallCount;
+				std::optional<int64_t> observeRttUsCalledWith;
+				std::optional<int64_t> expectedObserveRttUsCalledWith;
 
-				// GetCurrentRtoMs().
-				mutable std::queue<GetCurrentRtoMsAction> getCurrentRtoMsOnceActions;
+				// GetCurrentRtoUs().
+				mutable std::queue<GetCurrentRtoUsAction> getCurrentRtoUsOnceActions;
 
 				// IncrementTxErrorCounter().
 				size_t incrementTxErrorCounterCallCount{ 0 };

package/worker/mocks/include/RTC/SCTP/tx/MockSendQueue.hpp

@@ -18,7 +18,7 @@ namespace mocks
 			{
 			public:
 				using ProduceAction =
-				  std::function<std::optional<DataToSend>(uint64_t /*nowMs*/, size_t /*maxLength*/)>;
+				  std::function<std::optional<DataToSend>(int64_t /*nowUs*/, size_t /*maxLength*/)>;
 
 				struct DiscardExpectation
 				{
@@ -40,7 +40,7 @@ namespace mocks
 					this->messageInterleavingCalledWith = enabled;
 				}
 
-				std::optional<DataToSend> Produce(uint64_t nowMs, size_t maxLength) override
+				std::optional<DataToSend> Produce(int64_t nowUs, size_t maxLength) override
 				{
 					this->produceCallCount++;
 
@@ -50,11 +50,11 @@ namespace mocks
 
 						this->produceOnceActions.pop();
 
-						return action(nowMs, maxLength);
+						return action(nowUs, maxLength);
 					}
 					else if (this->produceRepeatedlyAction)
 					{
-						return this->produceRepeatedlyAction(nowMs, maxLength);
+						return this->produceRepeatedlyAction(nowUs, maxLength);
 					}
 					else
 					{
@@ -202,10 +202,10 @@ namespace mocks
 					  this->messageInterleavingCalledWith != this->expectedMessageInterleavingCalledWith.value())
 					{
 						return { .ok = false,
-							       .errorMessage =
-							         std::string("EnableMessageInterleaving() call mismatch [expected:") +
-							         (this->expectedMessageInterleavingCalledWith.value() ? "true" : "false") +
-							         ", got:" + (this->messageInterleavingCalledWith ? "true" : "false") + "]" };
+						         .errorMessage =
+						           std::string("EnableMessageInterleaving() call mismatch [expected:") +
+						           (this->expectedMessageInterleavingCalledWith.value() ? "true" : "false") +
+						           ", got:" + (this->messageInterleavingCalledWith ? "true" : "false") + "]" };
 					}
 
 					if (
@@ -213,7 +213,7 @@ namespace mocks
 					  this->produceCallCount != this->expectedProduceCallCount.value())
 					{
 						return { .ok           = false,
-							       .errorMessage = "Produce() call count mismatch [expected:" +
+						         .errorMessage = "Produce() call count mismatch [expected:" +
 							                       std::to_string(this->expectedProduceCallCount.value()) +
 							                       ", got:" + std::to_string(this->produceCallCount) + "]" };
 					}
@@ -223,7 +223,7 @@ namespace mocks
 					  this->discardCallCount != this->expectedDiscardCallCount.value())
 					{
 						return { .ok           = false,
-							       .errorMessage = "Discard() call count mismatch [expected:" +
+						         .errorMessage = "Discard() call count mismatch [expected:" +
 							                       std::to_string(this->expectedDiscardCallCount.value()) +
 							                       ", got:" + std::to_string(this->discardCallCount) + "]" };
 					}
@@ -231,7 +231,7 @@ namespace mocks
 					if (!this->discardExpectations.empty())
 					{
 						return { .ok           = false,
-							       .errorMessage = "Discard() has " +
+						         .errorMessage = "Discard() has " +
 							                       std::to_string(this->discardExpectations.size()) +
 							                       " unconsumed expectation(s)" };
 					}

package/worker/mocks/include/handles/MockBackoffTimerHandle.hpp

@@ -18,7 +18,7 @@ namespace mocks
 	private:
 		explicit MockBackoffTimerHandle(
 		  BackoffTimerHandleOptions options,
-		  std::function<uint64_t()> getTimeMs,
+		  std::function<int64_t()> getTimeMs,
 		  std::function<void()> onDelete);
 
 	public:
@@ -49,7 +49,7 @@ namespace mocks
 			// NOTE: Reset the expiration count, just like the real BackoffTimerHandle
 			// does.
 			this->expirationCount = 0;
-			this->expiresAtMs     = std::numeric_limits<uint64_t>::max();
+			this->expiresAtMs     = std::numeric_limits<int64_t>::max();
 		}
 
 		/**
@@ -60,7 +60,7 @@ namespace mocks
 		 *   during construction bypasses virtual dispatch
 		 *   [clang-analyzer-optin.cplusplus.VirtualCall]"
 		 */
-		void SetBaseTimeoutMs(uint64_t baseTimeoutMs) override;
+		void SetBaseTimeoutMs(int64_t baseTimeoutMs) override;
 
 		bool IsRunning() const override
 		{
@@ -84,7 +84,7 @@ namespace mocks
 
 		// Methods for testing.
 	public:
-		uint64_t GetExpiresAtMs() const
+		int64_t GetExpiresAtMs() const
 		{
 			return this->expiresAtMs;
 		}
@@ -104,7 +104,7 @@ namespace mocks
 		}
 
 	private:
-		uint64_t ComputeNextTimeoutMs() const
+		int64_t ComputeNextTimeoutMs() const
 		{
 			auto expirationCount = this->expirationCount;
 
@@ -130,7 +130,7 @@ namespace mocks
 						}
 					}
 
-					return std::min<uint64_t>(timeoutMs, BackoffTimerHandleInterface::MaxTimeoutMs);
+					return std::min<int64_t>(timeoutMs, BackoffTimerHandleInterface::MaxTimeoutMs);
 				}
 
 					NO_DEFAULT_GCC();
@@ -143,16 +143,16 @@ namespace mocks
 		// Passed by argument.
 		BackoffTimerHandleInterface::Listener* listener{ nullptr };
 		const std::string label;
-		uint64_t baseTimeoutMs;
+		int64_t baseTimeoutMs;
 		BackoffAlgorithm backoffAlgorithm;
-		std::optional<uint64_t> maxBackoffTimeoutMs;
+		std::optional<int64_t> maxBackoffTimeoutMs;
 		std::optional<size_t> maxRestarts;
-		std::function<uint64_t()> getTimeMs;
+		std::function<int64_t()> getTimeMs;
 		const std::function<void()> onDelete;
 		// Others.
 		bool running{ false };
 		size_t expirationCount{ 0 };
-		uint64_t expiresAtMs{ std::numeric_limits<uint64_t>::max() };
+		int64_t expiresAtMs{ std::numeric_limits<int64_t>::max() };
 	};
 } // namespace mocks