mediasoup 3.19.21 → 3.20.0

package/worker/include/RTC/RTP/RtpStream.hpp

@@ -2,20 +2,20 @@
 #define MS_RTC_RTP_RTP_STREAM_HPP
 
 #include "common.hpp"
-#include "DepLibUV.hpp"
 #include "FBS/rtpStream.h"
-#include "RTC/RTCP/FeedbackPsFir.hpp"           // IWYU pragma: export
-#include "RTC/RTCP/FeedbackPsPli.hpp"           // IWYU pragma: export
-#include "RTC/RTCP/FeedbackRtpNack.hpp"         // IWYU pragma: export
-#include "RTC/RTCP/Packet.hpp"                  // IWYU pragma: export
-#include "RTC/RTCP/ReceiverReport.hpp"          // IWYU pragma: export
-#include "RTC/RTCP/Sdes.hpp"                    // IWYU pragma: export
-#include "RTC/RTCP/SenderReport.hpp"            // IWYU pragma: export
-#include "RTC/RTCP/XrDelaySinceLastRr.hpp"      // IWYU pragma: export
-#include "RTC/RTCP/XrReceiverReferenceTime.hpp" // IWYU pragma: export
+#include "RTC/RTCP/FeedbackPsFir.hpp"
+#include "RTC/RTCP/FeedbackPsPli.hpp"
+#include "RTC/RTCP/FeedbackRtpNack.hpp"
+#include "RTC/RTCP/Packet.hpp"
+#include "RTC/RTCP/ReceiverReport.hpp"
+#include "RTC/RTCP/Sdes.hpp"
+#include "RTC/RTCP/SenderReport.hpp"
+#include "RTC/RTCP/XrDelaySinceLastRr.hpp"
+#include "RTC/RTCP/XrReceiverReferenceTime.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/RtxStream.hpp"
 #include "RTC/RtpDictionaries.hpp"
+#include "SharedInterface.hpp"
 #include <string>
 #include <vector>
 
@@ -61,7 +61,11 @@ namespace RTC
 			};
 
 		public:
-			RtpStream(RTP::RtpStream::Listener* listener, RTP::RtpStream::Params& params, uint8_t initialScore);
+			RtpStream(
+			  RTP::RtpStream::Listener* listener,
+			  SharedInterface* shared,
+			  RTP::RtpStream::Params& params,
+			  uint8_t initialScore);
 			virtual ~RtpStream();
 
 			flatbuffers::Offset<FBS::RtpStream::Dump> FillBuffer(flatbuffers::FlatBufferBuilder& builder) const;
@@ -162,7 +166,7 @@ namespace RTC
 			}
 			uint64_t GetActiveMs() const
 			{
-				return DepLibUV::GetTimeMs() - this->activeSinceMs;
+				return this->shared->GetTimeMs() - this->activeSinceMs;
 			}
 
 		protected:
@@ -185,6 +189,7 @@ namespace RTC
 		protected:
 			// Given as argument.
 			RTP::RtpStream::Listener* listener{ nullptr };
+			SharedInterface* shared{ nullptr };
 			Params params;
 			// Others.
 			//   https://tools.ietf.org/html/rfc3550#appendix-A.1 stuff.

package/worker/include/RTC/RTP/RtpStreamRecv.hpp

@@ -1,11 +1,11 @@
 #ifndef MS_RTC_RTP_RTP_STREAM_RECV_HPP
 #define MS_RTC_RTP_RTP_STREAM_RECV_HPP
 
+#include "handles/TimerHandleInterface.hpp"
 #include "RTC/NackGenerator.hpp"
 #include "RTC/RTCP/XrDelaySinceLastRr.hpp"
 #include "RTC/RTP/RtpStream.hpp"
 #include "RTC/RateCalculator.hpp"
-#include "handles/TimerHandle.hpp"
 #include <vector>
 
 namespace RTC
@@ -14,7 +14,7 @@ namespace RTC
 	{
 		class RtpStreamRecv : public RTP::RtpStream,
 		                      public RTC::NackGenerator::Listener,
-		                      public TimerHandle::Listener
+		                      public TimerHandleInterface::Listener
 		{
 		public:
 			class Listener : public RTP::RtpStream::Listener
@@ -30,7 +30,8 @@ namespace RTC
 			class TransmissionCounter
 			{
 			public:
-				TransmissionCounter(uint8_t spatialLayers, uint8_t temporalLayers, size_t windowSize);
+				TransmissionCounter(
+				  SharedInterface* shared, uint8_t spatialLayers, uint8_t temporalLayers, size_t windowSize);
 				void Update(const RTP::Packet* packet);
 				uint32_t GetBitrate(uint64_t nowMs);
 				uint32_t GetBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer);
@@ -46,6 +47,7 @@ namespace RTC
 		public:
 			RtpStreamRecv(
 			  RTP::RtpStreamRecv::Listener* listener,
+			  SharedInterface* shared,
 			  RTP::RtpStream::Params& params,
 			  unsigned int sendNackDelayMs,
 			  bool useRtpInactivityCheck);
@@ -92,9 +94,9 @@ namespace RTC
 		public:
 			void UserOnSequenceNumberReset() override;
 
-			/* Pure virtual methods inherited from TimerHandle. */
+			/* Pure virtual methods inherited from TimerHandleInterface. */
 		protected:
-			void OnTimer(TimerHandle* timer) override;
+			void OnTimer(TimerHandleInterface* timer) override;
 
 			/* Pure virtual methods inherited from RTC::NackGenerator. */
 		protected:
@@ -124,7 +126,7 @@ namespace RTC
 			uint8_t firSeqNumber{ 0u };
 			int32_t reportedPacketsLost{ 0 };
 			std::unique_ptr<RTC::NackGenerator> nackGenerator;
-			TimerHandle* inactivityCheckPeriodicTimer{ nullptr };
+			TimerHandleInterface* inactivityCheckPeriodicTimer{ nullptr };
 			bool inactive{ false };
 			// Valid media + valid RTX.
 			TransmissionCounter transmissionCounter;

package/worker/include/RTC/RTP/RtpStreamSend.hpp

@@ -36,7 +36,10 @@ namespace RTC
 
 		public:
 			RtpStreamSend(
-			  RTP::RtpStreamSend::Listener* listener, RTP::RtpStream::Params& params, std::string& mid);
+			  RTP::RtpStreamSend::Listener* listener,
+			  SharedInterface* shared,
+			  RTP::RtpStream::Params& params,
+			  std::string& mid);
 			~RtpStreamSend() override;
 
 			flatbuffers::Offset<FBS::RtpStream::Stats> FillBufferStats(

package/worker/include/RTC/RTP/RtxStream.hpp

@@ -7,6 +7,7 @@
 #include "RTC/RTCP/SenderReport.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RtpDictionaries.hpp"
+#include "SharedInterface.hpp"
 #include <string>
 
 namespace RTC
@@ -30,7 +31,7 @@ namespace RTC
 			};
 
 		public:
-			explicit RtxStream(RTP::RtxStream::Params& params);
+			explicit RtxStream(SharedInterface* shared, RTP::RtxStream::Params& params);
 			virtual ~RtxStream();
 
 			flatbuffers::Offset<FBS::RtxStream::RtxDump> FillBuffer(
@@ -87,6 +88,7 @@ namespace RTC
 
 		protected:
 			// Given as argument.
+			SharedInterface* shared{ nullptr };
 			Params params;
 			// Others.
 			//   https://tools.ietf.org/html/rfc3550#appendix-A.1 stuff.

package/worker/include/RTC/RTP/SharedPacket.hpp

@@ -12,7 +12,7 @@ namespace RTC
 		{
 		public:
 #ifdef MS_DUMP_RTP_SHARED_PACKET_MEMORY_USAGE
-			thread_local static uint64_t allocatedMemory;
+			static thread_local uint64_t allocatedMemory;
 #endif
 
 		public:

package/worker/include/RTC/RateCalculator.hpp

@@ -3,6 +3,7 @@
 
 #include "common.hpp"
 #include "RTC/RTP/Packet.hpp"
+#include "SharedInterface.hpp"
 #include <vector>
 
 namespace RTC
@@ -75,8 +76,9 @@ namespace RTC
 	class RtpDataCounter
 	{
 	public:
-		explicit RtpDataCounter(bool ignorePaddingOnlyPackets, size_t windowSizeMs = 2500)
-		  : ignorePaddingOnlyPackets(ignorePaddingOnlyPackets), rate(windowSizeMs)
+		explicit RtpDataCounter(
+		  SharedInterface* shared, bool ignorePaddingOnlyPackets, size_t windowSizeMs = 2500)
+		  : shared(shared), ignorePaddingOnlyPackets(ignorePaddingOnlyPackets), rate(windowSizeMs)
 		{
 		}
 
@@ -99,6 +101,7 @@ namespace RTC
 		}
 
 	private:
+		SharedInterface* shared{ nullptr };
 		// Whether the size of padding only RTP packets should not be taken into
 		// account
 		bool ignorePaddingOnlyPackets{ false };

package/worker/include/RTC/Router.hpp

@@ -10,9 +10,10 @@
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/RtpStreamRecv.hpp"
 #include "RTC/RtpObserver.hpp"
-#include "RTC/Shared.hpp"
+#include "RTC/SCTP/public/Message.hpp"
 #include "RTC/Transport.hpp"
 #include "RTC/WebRtcServer.hpp"
+#include "SharedInterface.hpp"
 #include <absl/container/flat_hash_map.h>
 #include <absl/container/flat_hash_set.h>
 #include <string>
@@ -36,7 +37,7 @@ namespace RTC
 		};
 
 	public:
-		explicit Router(RTC::Shared* shared, const std::string& id, Listener* listener);
+		explicit Router(SharedInterface* shared, const std::string& id, Listener* listener);
 		~Router() override;
 
 	public:
@@ -48,8 +49,8 @@ namespace RTC
 		void HandleRequest(Channel::ChannelRequest* request) override;
 
 	private:
-		RTC::Transport* GetTransportById(const std::string& transportId) const;
-		RTC::RtpObserver* GetRtpObserverById(const std::string& rtpObserverId) const;
+		RTC::Transport* AssertAndGetTransportById(const std::string& transportId) const;
+		RTC::RtpObserver* AssertAndGetRtpObserverById(const std::string& rtpObserverId) const;
 		void CheckNoTransport(const std::string& transportId) const;
 		void CheckNoRtpObserver(const std::string& rtpObserverId) const;
 
@@ -96,9 +97,7 @@ namespace RTC
 		void OnTransportDataProducerMessageReceived(
 		  RTC::Transport* transport,
 		  RTC::DataProducer* dataProducer,
-		  const uint8_t* msg,
-		  size_t len,
-		  uint32_t ppid,
+		  RTC::SCTP::Message message,
 		  std::vector<uint16_t>& subchannels,
 		  std::optional<uint16_t> requiredSubchannel) override;
 		void OnTransportNewDataConsumer(
@@ -120,7 +119,7 @@ namespace RTC
 
 	private:
 		// Passed by argument.
-		RTC::Shared* shared{ nullptr };
+		SharedInterface* shared{ nullptr };
 		Listener* listener{ nullptr };
 		// Allocated by this.
 		absl::flat_hash_map<std::string, RTC::Transport*> mapTransports;

package/worker/include/RTC/RtpObserver.hpp

@@ -3,7 +3,7 @@
 
 #include "RTC/Producer.hpp"
 #include "RTC/RTP/Packet.hpp"
-#include "RTC/Shared.hpp"
+#include "SharedInterface.hpp"
 #include <string>
 
 namespace RTC
@@ -25,7 +25,7 @@ namespace RTC
 		};
 
 	public:
-		RtpObserver(RTC::Shared* shared, const std::string& id, RTC::RtpObserver::Listener* listener);
+		RtpObserver(SharedInterface* shared, const std::string& id, RTC::RtpObserver::Listener* listener);
 		~RtpObserver() override;
 
 	public:
@@ -55,7 +55,7 @@ namespace RTC
 
 	protected:
 		// Passed by argument.
-		RTC::Shared* shared{ nullptr };
+		SharedInterface* shared{ nullptr };
 
 	private:
 		// Passed by argument.

package/worker/include/RTC/SCTP/association/Association.hpp

@@ -2,6 +2,7 @@
 #define MS_RTC_SCTP_ASSOCIATION_HPP
 
 #include "common.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
 #include "RTC/SCTP/association/AssociationListenerDeferrer.hpp"
 #include "RTC/SCTP/association/NegotiatedCapabilities.hpp"
 #include "RTC/SCTP/association/PacketSender.hpp"
@@ -31,12 +32,13 @@
 #include "RTC/SCTP/packet/chunks/ShutdownCompleteChunk.hpp"
 #include "RTC/SCTP/packet/chunks/UnknownChunk.hpp"
 #include "RTC/SCTP/public/AssociationInterface.hpp"
-#include "RTC/SCTP/public/AssociationListener.hpp"
+#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
 #include "RTC/SCTP/public/AssociationMetrics.hpp"
 #include "RTC/SCTP/public/Message.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
-#include "handles/BackoffTimerHandle.hpp"
+#include "RTC/SCTP/tx/RoundRobinSendQueue.hpp"
+#include "SharedInterface.hpp"
 #include <FBS/sctpParameters.h>
 #include <span>
 #include <string_view>
@@ -51,7 +53,7 @@ namespace RTC
 		 */
 		class Association : public AssociationInterface,
 		                    public PacketSender::Listener,
-		                    public BackoffTimerHandle::Listener
+		                    public BackoffTimerHandleInterface::Listener
 		{
 		public:
 			/**
@@ -166,7 +168,11 @@ namespace RTC
 			};
 
 		public:
-			explicit Association(const SctpOptions& sctpOptions, AssociationListener* listener);
+			explicit Association(
+			  const SctpOptions& sctpOptions,
+			  AssociationListenerInterface* listener,
+			  SharedInterface* shared,
+			  bool isDataChannel);
 
 			~Association() override;
 
@@ -220,7 +226,7 @@ namespace RTC
 			 * Retrieves the latest metrics. If the Association is not fully connected,
 			 * `std::nullopt` will be returned.
 			 */
-			std::optional<AssociationMetrics> GetMetrics() const override;
+			std::optional<AssociationMetrics> MakeMetrics() const override;
 
 			/**
 			 * Returns the currently set priority for an outgoing stream. The initial
@@ -240,6 +246,12 @@ namespace RTC
 			 */
 			void SetMaxSendMessageSize(size_t maxMessageSize) override;
 
+			/**
+			 * Returns the number of bytes of data currently queued to be sent in
+			 * total.
+			 */
+			size_t GetTotalBufferedAmount() const override;
+
 			/**
 			 * Returns the number of bytes of data currently queued to be sent on a
 			 * given stream.
@@ -257,7 +269,7 @@ namespace RTC
 			 * considered "low" for a given stream, which will trigger
 			 * `OnAssociationStreamBufferedAmountLow()` event. The default value is 0.
 			 */
-			void SetBufferedAmountLowThreshold(uint16_t streamId, size_t bytes) override;
+			void SetStreamBufferedAmountLowThreshold(uint16_t streamId, size_t bytes) override;
 
 			/**
 			 * Resetting streams is an asynchronous operation and the results will be
@@ -320,6 +332,23 @@ namespace RTC
 			 */
 			void ReceiveSctpData(const uint8_t* data, size_t len) override;
 
+			/**
+			 * Get negotiated max outbound streams. Returns 0 if the association is
+			 * not yet connected.
+			 */
+			uint16_t GetNegotiatedMaxOutboundStreams() const override;
+
+			/**
+			 * Get negotiated max inbound streams. Returns 0 if the association is
+			 * not yet connected.
+			 */
+			uint16_t GetNegotiatedMaxInboundStreams() const override;
+
+			bool IsDataChannel() const override
+			{
+				return this->isDataChannel;
+			}
+
 		private:
 			void InternalClose(Types::ErrorKind errorKind, const std::string_view& message);
 
@@ -369,7 +398,7 @@ namespace RTC
 			 */
 			void MayDeliverMessages();
 
-			Types::SendMessageStatus InternalSendMessage(
+			Types::SendMessageStatus InternalSendMessageCheck(
 			  const Message& message, const SendMessageOptions& sendMessageOptions);
 
 			bool ValidateReceivedPacket(const Packet* receivedPacket);
@@ -454,30 +483,31 @@ namespace RTC
 
 			void AssertHasTcb() const;
 
-			void AssertStateIsConsistent() const;
+			void AssertIsConsistent() const;
 
 			/* Pure virtual methods inherited from PacketSender::Listener. */
 		public:
 			void OnPacketSenderPacketSent(PacketSender* packetSender, const Packet* packet, bool sent) override;
 
-			/* Pure virtual methods inherited from BackoffTimerHandle::Listener. */
+			/* Pure virtual methods inherited from BackoffTimerHandleInterface::Listener. */
 		public:
-			void OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
+			void OnBackoffTimer(
+			  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
 			// SCTP options given in the constructor.
 			SctpOptions sctpOptions;
-			// Listener. It's not an `AssociationListener` but an
-			// `AssociationListenerDeferrer` which inherits from `AssociationListener`.
-			AssociationListenerDeferrer listener;
+			// Listener. It's a `AssociationListenerDeferrer` which implements
+			// `AssociationListenerInterface`.
+			AssociationListenerDeferrer associationListenerDeferrer;
+			SharedInterface* shared;
 			// SCTP association internal state.
 			State state{ State::NEW };
 			// Packet sender.
 			PacketSender packetSender;
 			// The actual send queue implementation. As data can be sent before the
 			// connection is established, this component is not in the TCB.
-			// TODO: Implement this class.
-			// RRSendQueue sendQueue;
+			RoundRobinSendQueue sendQueue;
 			// To keep settings between sending of INIT Chunk and establishment of
 			// the connection.
 			PreTransmissionControlBlock preTcb;
@@ -485,13 +515,17 @@ namespace RTC
 			// is created.
 			std::unique_ptr<TransmissionControlBlock> tcb;
 			// Private metrics.
-			AssociationPrivateMetrics privateMetrics{};
+			AssociationPrivateMetrics privateMetrics;
 			// T1-init timer.
-			const std::unique_ptr<BackoffTimerHandle> t1InitTimer;
+			const std::unique_ptr<BackoffTimerHandleInterface> t1InitTimer;
 			// T1-cookie timer.
-			const std::unique_ptr<BackoffTimerHandle> t1CookieTimer;
+			const std::unique_ptr<BackoffTimerHandleInterface> t1CookieTimer;
 			// T2-shutdown timer.
-			const std::unique_ptr<BackoffTimerHandle> t2ShutdownTimer;
+			const std::unique_ptr<BackoffTimerHandleInterface> t2ShutdownTimer;
+			// Max SCTP Packet length.
+			const size_t maxPacketLength;
+			// Whether this is DataChannel based SCTP.
+			bool isDataChannel;
 		};
 	} // namespace SCTP
 } // namespace RTC

package/worker/include/RTC/SCTP/association/AssociationListenerDeferrer.hpp

@@ -2,7 +2,7 @@
 #define MS_RTC_SCTP_ASSOCIATION_LISTENER_DEFERRED_HPP
 
 #include "common.hpp"
-#include "RTC/SCTP/public/AssociationListener.hpp"
+#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
 #include "RTC/SCTP/public/Message.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
 #include <span>
@@ -15,7 +15,7 @@ namespace RTC
 {
 	namespace SCTP
 	{
-		class AssociationListenerDeferrer : public AssociationListener
+		class AssociationListenerDeferrer : public AssociationListenerInterface
 		{
 		public:
 			class ScopedDeferrer
@@ -46,10 +46,10 @@ namespace RTC
 			// variant can hold all cases of stored data.
 			using CallbackData = std::variant<std::monostate, Message, Error, StreamReset, uint16_t>;
 
-			using Callback = std::function<void(CallbackData, AssociationListener*)>;
+			using Callback = std::function<void(CallbackData, AssociationListenerInterface*)>;
 
 		public:
-			explicit AssociationListenerDeferrer(AssociationListener* innerListener);
+			explicit AssociationListenerDeferrer(AssociationListenerInterface* innerListener);
 
 		private:
 			void SetReady();
@@ -57,7 +57,7 @@ namespace RTC
 			void TriggerDeferredCallbacks();
 
 		public:
-			/* Pure virtual methods inherited from RTC::STCP::AssociationListener. */
+			/* Pure virtual methods inherited from RTC::STCP::AssociationListenerInterface. */
 			bool OnAssociationSendData(const uint8_t* data, size_t len) override;
 
 			void OnAssociationConnecting() override;
@@ -87,8 +87,16 @@ namespace RTC
 
 			bool OnAssociationIsTransportReadyForSctp() override;
 
+			void OnAssociationLifecycleMessageFullySent(uint64_t lifecycleId) override;
+
+			void OnAssociationLifecycleMessageExpired(uint64_t lifecycleId, bool maybeDelivered) override;
+
+			void OnAssociationLifecycleMessageDelivered(uint64_t lifecycleId) override;
+
+			void OnAssociationLifecycleMessageEnd(uint64_t lifecycleId) override;
+
 		private:
-			AssociationListener* innerListener;
+			AssociationListenerInterface* innerListener;
 			bool ready{ false };
 			std::vector<std::pair<Callback, CallbackData>> deferredCallbacks;
 		};

package/worker/include/RTC/SCTP/association/HeartbeatHandler.hpp

@@ -2,12 +2,13 @@
 #define MS_RTC_SCTP_HEARTBEAT_HANDLER_HPP
 
 #include "common.hpp"
-#include "RTC/SCTP/association/TCBContext.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
+#include "RTC/SCTP/association/TransmissionControlBlockContextInterface.hpp"
 #include "RTC/SCTP/packet/chunks/HeartbeatAckChunk.hpp"
 #include "RTC/SCTP/packet/chunks/HeartbeatRequestChunk.hpp"
-#include "RTC/SCTP/public/AssociationListener.hpp"
+#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
-#include "handles/BackoffTimerHandle.hpp"
+#include "SharedInterface.hpp"
 
 namespace RTC
 {
@@ -21,13 +22,14 @@ namespace RTC
 		 * still healthy and to measure the RTT. If a number of heartbeats time out,
 		 * the connection will eventually be closed.
 		 */
-		class HeartbeatHandler : public BackoffTimerHandle::Listener
+		class HeartbeatHandler : public BackoffTimerHandleInterface::Listener
 		{
 		public:
 			HeartbeatHandler(
-			  AssociationListener& associationListener,
+			  AssociationListenerInterface& associationListener,
 			  const SctpOptions& sctpOptions,
-			  TCBContext* tcbContext);
+			  SharedInterface* shared,
+			  TransmissionControlBlockContextInterface* tcbContext);
 
 			~HeartbeatHandler() override;
 
@@ -55,21 +57,23 @@ namespace RTC
 
 			void OnTimeoutTimer(uint64_t& baseTimeoutMs, bool& stop);
 
-			/* Pure virtual methods inherited from BackoffTimerHandle::Listener. */
+			/* Pure virtual methods inherited from BackoffTimerHandleInterface::Listener. */
 		public:
-			void OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
+			void OnBackoffTimer(
+			  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
-			AssociationListener& associationListener;
+			AssociationListenerInterface& associationListener;
 			const SctpOptions sctpOptions;
-			TCBContext* tcbContext{ nullptr };
+			SharedInterface* shared;
+			TransmissionControlBlockContextInterface* tcbContext;
 			// The time for a connection to be idle before a heartbeat is sent.
-			const uint64_t intervalDurationMs{ 0 };
+			const uint64_t intervalDurationMs;
 			// Adding RTT to the duration will add some jitter, which is good in
 			// production, but less good in unit tests, which is why it can be disabled.
-			const bool intervalDurationShouldIncludeRtt{ false };
-			const std::unique_ptr<BackoffTimerHandle> intervalTimer;
-			const std::unique_ptr<BackoffTimerHandle> timeoutTimer;
+			const bool intervalDurationShouldIncludeRtt;
+			const std::unique_ptr<BackoffTimerHandleInterface> intervalTimer;
+			const std::unique_ptr<BackoffTimerHandleInterface> timeoutTimer;
 		};
 	} // namespace SCTP
 } // namespace RTC

package/worker/include/RTC/SCTP/association/PacketSender.hpp

@@ -3,7 +3,7 @@
 
 #include "common.hpp"
 #include "RTC/SCTP/packet/Packet.hpp"
-#include "RTC/SCTP/public/AssociationListener.hpp"
+#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
 
 namespace RTC
 {
@@ -23,7 +23,7 @@ namespace RTC
 			};
 
 		public:
-			PacketSender(Listener* listener, AssociationListener& associationListener);
+			PacketSender(Listener* listener, AssociationListenerInterface& associationListener);
 
 			~PacketSender();
 
@@ -43,7 +43,7 @@ namespace RTC
 
 		private:
 			Listener* listener;
-			AssociationListener& associationListener;
+			AssociationListenerInterface& associationListener;
 		};
 	} // namespace SCTP
 } // namespace RTC

package/worker/include/RTC/SCTP/association/StateCookie.hpp

@@ -2,10 +2,10 @@
 #define MS_RTC_SCTP_STATE_COOKIE_HPP
 
 #include "common.hpp"
-#include "Utils.hpp"
 #include "RTC/SCTP/association/NegotiatedCapabilities.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
 #include "RTC/Serializable.hpp"
+#include "Utils.hpp"
 #include <string_view>
 
 namespace RTC