mediasoup 3.19.21 → 3.19.22

package/worker/include/RTC/NackGenerator.hpp

@@ -2,16 +2,17 @@
 #define MS_RTC_NACK_GENERATOR_HPP
 
 #include "common.hpp"
+#include "SharedInterface.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/SeqManager.hpp"
-#include "handles/TimerHandle.hpp"
+#include "handles/TimerHandleInterface.hpp"
 #include <map>
 #include <set>
 #include <vector>
 
 namespace RTC
 {
-	class NackGenerator : public TimerHandle::Listener
+	class NackGenerator : public TimerHandleInterface::Listener
 	{
 	public:
 		class Listener
@@ -47,7 +48,7 @@ namespace RTC
 		};
 
 	public:
-		explicit NackGenerator(Listener* listener, unsigned int sendNackDelayMs);
+		explicit NackGenerator(Listener* listener, SharedInterface* shared, unsigned int sendNackDelayMs);
 		~NackGenerator() override;
 
 		bool ReceivePacket(const RTC::RTP::Packet* packet, bool isRecovered);
@@ -67,16 +68,16 @@ namespace RTC
 		std::vector<uint16_t> GetNackBatch(NackFilter filter);
 		void MayRunTimer() const;
 
-		/* Pure virtual methods inherited from TimerHandle::Listener. */
+		/* Pure virtual methods inherited from TimerHandleInterface::Listener. */
 	public:
-		void OnTimer(TimerHandle* timer) override;
+		void OnTimer(TimerHandleInterface* timer) override;
 
 	private:
 		// Passed by argument.
 		Listener* listener{ nullptr };
 		unsigned int sendNackDelayMs{ 0u };
 		// Allocated by this.
-		TimerHandle* timer{ nullptr };
+		TimerHandleInterface* timer{ nullptr };
 		// Others.
 		std::map<uint16_t, NackInfo, RTC::SeqManager<uint16_t>::SeqLowerThan> nackList;
 		std::set<uint16_t, RTC::SeqManager<uint16_t>::SeqLowerThan> keyFrameList;

package/worker/include/RTC/PipeConsumer.hpp

@@ -3,7 +3,6 @@
 
 #include "RTC/Consumer.hpp"
 #include "RTC/SeqManager.hpp"
-#include "RTC/Shared.hpp"
 #include <map>
 
 namespace RTC
@@ -19,7 +18,7 @@ namespace RTC
 
 	public:
 		PipeConsumer(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  const std::string& producerId,
 		  RTC::Consumer::Listener* listener,

package/worker/include/RTC/PipeTransport.hpp

@@ -1,8 +1,8 @@
 #ifndef MS_RTC_PIPE_TRANSPORT_HPP
 #define MS_RTC_PIPE_TRANSPORT_HPP
 
+#include "SharedInterface.hpp"
 #include "FBS/pipeTransport.h"
-#include "RTC/Shared.hpp"
 #include "RTC/SrtpSession.hpp"
 #include "RTC/Transport.hpp"
 #include "RTC/TransportTuple.hpp"
@@ -19,7 +19,7 @@ namespace RTC
 
 	public:
 		PipeTransport(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  RTC::Transport::Listener* listener,
 		  const FBS::PipeTransport::PipeTransportOptions* options);

package/worker/include/RTC/PlainTransport.hpp

@@ -1,8 +1,8 @@
 #ifndef MS_RTC_PLAIN_TRANSPORT_HPP
 #define MS_RTC_PLAIN_TRANSPORT_HPP
 
+#include "SharedInterface.hpp"
 #include "FBS/plainTransport.h"
-#include "RTC/Shared.hpp"
 #include "RTC/SrtpSession.hpp"
 #include "RTC/Transport.hpp"
 #include "RTC/TransportTuple.hpp"
@@ -15,7 +15,7 @@ namespace RTC
 	{
 	public:
 		PlainTransport(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  RTC::Transport::Listener* listener,
 		  const FBS::PlainTransport::PlainTransportOptions* options);

package/worker/include/RTC/Producer.hpp

@@ -2,6 +2,7 @@
 #define MS_RTC_PRODUCER_HPP
 
 #include "common.hpp"
+#include "SharedInterface.hpp"
 #include "Channel/ChannelRequest.hpp"
 #include "Channel/ChannelSocket.hpp"
 #include "RTC/KeyFrameRequestManager.hpp"
@@ -13,7 +14,6 @@
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/RtpStreamRecv.hpp"
 #include "RTC/RtpDictionaries.hpp"
-#include "RTC/Shared.hpp"
 #include <string>
 #include <vector>
 
@@ -94,7 +94,7 @@ namespace RTC
 
 	public:
 		Producer(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  RTC::Producer::Listener* listener,
 		  const FBS::Transport::ProduceRequest* data);
@@ -179,7 +179,7 @@ namespace RTC
 
 	private:
 		// Passed by argument.
-		RTC::Shared* shared{ nullptr };
+		SharedInterface* shared{ nullptr };
 		RTC::Producer::Listener* listener{ nullptr };
 		// Allocated by this.
 		absl::flat_hash_map<uint32_t, RTC::RTP::RtpStreamRecv*> mapSsrcRtpStream;

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

@@ -3,6 +3,7 @@
 
 #include "common.hpp"
 #include "DepLibUV.hpp"
+#include "SharedInterface.hpp"
 #include "FBS/rtpStream.h"
 #include "RTC/RTCP/FeedbackPsFir.hpp"           // IWYU pragma: export
 #include "RTC/RTCP/FeedbackPsPli.hpp"           // IWYU pragma: export
@@ -61,7 +62,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;
@@ -185,6 +190,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

@@ -5,7 +5,7 @@
 #include "RTC/RTCP/XrDelaySinceLastRr.hpp"
 #include "RTC/RTP/RtpStream.hpp"
 #include "RTC/RateCalculator.hpp"
-#include "handles/TimerHandle.hpp"
+#include "handles/TimerHandleInterface.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
@@ -46,6 +46,7 @@ namespace RTC
 		public:
 			RtpStreamRecv(
 			  RTP::RtpStreamRecv::Listener* listener,
+			  SharedInterface* shared,
 			  RTP::RtpStream::Params& params,
 			  unsigned int sendNackDelayMs,
 			  bool useRtpInactivityCheck);
@@ -92,9 +93,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 +125,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/Router.hpp

@@ -2,6 +2,7 @@
 #define MS_RTC_ROUTER_HPP
 
 #include "common.hpp"
+#include "SharedInterface.hpp"
 #include "Channel/ChannelRequest.hpp"
 #include "RTC/Consumer.hpp"
 #include "RTC/DataConsumer.hpp"
@@ -10,7 +11,6 @@
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/RtpStreamRecv.hpp"
 #include "RTC/RtpObserver.hpp"
-#include "RTC/Shared.hpp"
 #include "RTC/Transport.hpp"
 #include "RTC/WebRtcServer.hpp"
 #include <absl/container/flat_hash_map.h>
@@ -36,7 +36,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:
@@ -120,7 +120,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

@@ -1,9 +1,9 @@
 #ifndef MS_RTC_RTP_OBSERVER_HPP
 #define MS_RTC_RTP_OBSERVER_HPP
 
+#include "SharedInterface.hpp"
 #include "RTC/Producer.hpp"
 #include "RTC/RTP/Packet.hpp"
-#include "RTC/Shared.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/TODO_SCTP.md

@@ -2,6 +2,14 @@
 
 ## Related to mediasoup SCTP implementation
 
+- `DataChunk`, IDataChunk`and`AnyDataChunk`: Add `SetUserData(UserData)`.
+
+- Remove all default values of class memners in .hpp of all classes in case the constructor must give them initial value.
+
+- Lot of stuff missing in `TransmissionControlBock` class and I forgot to add "TODO: SCTP" in them.
+
+- dcsctp uses µs (webrtc::Timestamp::Micros()) internally, while mediasoup uses ms (`DepLibUV::GetTimeMs()`). When porting dcsctp timeout/duration logic, make sure to convert accordingly. Do not mix units in the same field.
+
 - `Association`: When transitioning to CLOSED (due to failure while connecting or closure) we should emit a new event "stcpclosed" in all `DataProducers/Consumers`.
 
 - When receiving SCTP RE-CONFIG, we should emit "streamclosed" in those `DataProducers/DataConsumers` whose stream ID have been closed.
@@ -19,6 +27,10 @@
   - We must also remove `device.sctpCapabilities` getter from mediasoup-client because anyway we are making up those values!
   - Also must update the website documentation.
 
+- Replicate `retransmission_queue_test.cc` of dcsctp.
+
+- When we invoke `close()` on a `DataProducer/Consumer` in server, we must end calling `sctpAssociation->ResetStream([streamId])` so it sends `ReConfig` to peer.
+
 - In `transport.dump()` (maybe also in `getStats()`) we must properly obtain `OS` and `MIS` according to the number of SCTP streams negotiated via INIT + INIT_ACK. And if SCTP is not yet established, then... not sure.
   - In `Association::FillBuffer()` we should not pass `this->sctpOptions.negotiatedMaxOutboundStreams/negotiatedMaxInboundStreams` but the current values.
 
@@ -34,10 +46,10 @@
 
 - Look for "TODO: SCTP" everywhere.
 
-- Test Chrome with I-DATA (message interleaving):
-
-  ```
-  open -a "Google Chrome Canary" \
-    --args \
-    --force-fieldtrials="WebRTC-DataChannelMessageInterleaving/Enabled/"
+- Test Chrome/Canary with I-DATA (message interleaving):
+  ```bash
+  /Applications/Google\ Chrome\ Canary.app/Contents/MacOS/Google\ Chrome\ Canary \
+    --force-fieldtrials="WebRTC-DataChannelMessageInterleaving/Enabled/" \
+    --enable-logging=stderr \
+    --v=1 \
   ```

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

@@ -2,6 +2,7 @@
 #define MS_RTC_SCTP_ASSOCIATION_HPP
 
 #include "common.hpp"
+#include "SharedInterface.hpp"
 #include "RTC/SCTP/association/AssociationListenerDeferrer.hpp"
 #include "RTC/SCTP/association/NegotiatedCapabilities.hpp"
 #include "RTC/SCTP/association/PacketSender.hpp"
@@ -36,7 +37,7 @@
 #include "RTC/SCTP/public/Message.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
-#include "handles/BackoffTimerHandle.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
 #include <FBS/sctpParameters.h>
 #include <span>
 #include <string_view>
@@ -51,7 +52,7 @@ namespace RTC
 		 */
 		class Association : public AssociationInterface,
 		                    public PacketSender::Listener,
-		                    public BackoffTimerHandle::Listener
+		                    public BackoffTimerHandleInterface::Listener
 		{
 		public:
 			/**
@@ -166,7 +167,8 @@ namespace RTC
 			};
 
 		public:
-			explicit Association(const SctpOptions& sctpOptions, AssociationListener* listener);
+			explicit Association(
+			  const SctpOptions& sctpOptions, AssociationListener* listener, SharedInterface* shared);
 
 			~Association() override;
 
@@ -460,9 +462,9 @@ namespace RTC
 		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 OnTimer(BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
 			// SCTP options given in the constructor.
@@ -470,6 +472,7 @@ namespace RTC
 			// Listener. It's not an `AssociationListener` but an
 			// `AssociationListenerDeferrer` which inherits from `AssociationListener`.
 			AssociationListenerDeferrer listener;
+			SharedInterface* shared;
 			// SCTP association internal state.
 			State state{ State::NEW };
 			// Packet sender.
@@ -487,11 +490,11 @@ namespace RTC
 			// Private metrics.
 			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;
 		};
 	} // namespace SCTP
 } // namespace RTC

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

@@ -2,12 +2,13 @@
 #define MS_RTC_SCTP_HEARTBEAT_HANDLER_HPP
 
 #include "common.hpp"
+#include "SharedInterface.hpp"
 #include "RTC/SCTP/association/TCBContext.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/SctpOptions.hpp"
-#include "handles/BackoffTimerHandle.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
 
 namespace RTC
 {
@@ -21,12 +22,13 @@ 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,
 			  const SctpOptions& sctpOptions,
+			  SharedInterface* shared,
 			  TCBContext* tcbContext);
 
 			~HeartbeatHandler() override;
@@ -55,21 +57,22 @@ 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 OnTimer(BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
 			AssociationListener& associationListener;
 			const SctpOptions sctpOptions;
+			SharedInterface* shared;
 			TCBContext* tcbContext{ nullptr };
 			// The time for a connection to be idle before a heartbeat is sent.
 			const uint64_t intervalDurationMs{ 0 };
 			// 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 std::unique_ptr<BackoffTimerHandleInterface> intervalTimer;
+			const std::unique_ptr<BackoffTimerHandleInterface> timeoutTimer;
 		};
 	} // namespace SCTP
 } // namespace RTC

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

@@ -2,6 +2,7 @@
 #define MS_RTC_SCTP_STREAM_RESET_HANDLER_HPP
 
 #include "common.hpp"
+#include "SharedInterface.hpp"
 #include "RTC/SCTP/association/TCBContext.hpp"
 #include "RTC/SCTP/common/UnwrappedSequenceNumber.hpp"
 #include "RTC/SCTP/packet/Packet.hpp"
@@ -10,7 +11,8 @@
 #include "RTC/SCTP/packet/parameters/OutgoingSsnResetRequestParameter.hpp"
 #include "RTC/SCTP/packet/parameters/ReconfigurationResponseParameter.hpp"
 #include "RTC/SCTP/public/AssociationListener.hpp"
-#include "handles/BackoffTimerHandle.hpp"
+#include "RTC/SCTP/tx/RetransmissionQueue.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
 #include <span>
 #include <vector>
 
@@ -49,7 +51,7 @@ namespace RTC
 		 * not-yet-sent messages will be discarded, but that may change in the future.
 		 * RFC8831 allows both behaviors.
 		 */
-		class StreamResetHandler : public TCBContext, public BackoffTimerHandle::Listener
+		class StreamResetHandler : public BackoffTimerHandleInterface::Listener
 		{
 		private:
 			enum class ReqSeqNbrValidationResult : uint8_t
@@ -164,12 +166,13 @@ namespace RTC
 
 		public:
 			StreamResetHandler(
-			  AssociationListener& associationListener, TCBContext* tcbContext
+			  AssociationListener& associationListener,
+			  SharedInterface* shared,
+			  TCBContext* tcbContext,
 			  // TODO: SCTP: Implement
 			  // DataTracker* dataTracker,
 			  // ReassemblyQueue* reassemblyQueue,
-			  // RetransmissionQueue* retransmissionQueue
-			);
+			  RetransmissionQueue* retransmissionQueue);
 
 			~StreamResetHandler() override;
 
@@ -183,6 +186,23 @@ namespace RTC
 			 */
 			void ResetStreams(std::span<const uint16_t> outgoingStreamIds);
 
+			/**
+			 * Whether a Reset Streams request should be send. Will return `false` if
+			 * there is no need to create a request (no streams to reset) or if there
+			 * already is an ongoing stream reset request that hasn't completed yet.
+			 */
+			bool ShouldCreateStreamResetRequest() const;
+
+			/**
+			 * Creates a Reset Streams request that must be sent if returned. Will
+			 * start the reconfig timer.
+			 *
+			 * @remarks
+			 * - The caller must check `ShouldCreateStreamResetRequest()` first and
+			 *   only invoke this method if the former returns `true`.
+			 */
+			void CreateStreamResetRequest(Packet* packet);
+
 			/**
 			 * Called when handling and incoming RE-CONFIG chunk. Processes a stream
 			 * reconfiguration chunk and may send a RE-CONFIG back to the peer with
@@ -197,18 +217,10 @@ namespace RTC
 			bool ValidateReceivedReConfigChunk(const ReConfigChunk* receivedReConfigChunk);
 
 			/**
-			 * Creates a Reset Streams request that must be sent if returned. Will
-			 * start the reconfig timer. Will return `nullptr` if there is no need
-			 * to create a request (no streams to reset) or if there already is an
-			 * ongoing stream reset request that hasn't completed yet.
-			 */
-			ReConfigChunk* CreateStreamResetRequest();
-
-			/**
-			 * Creates the actual RE-CONFIG chunk. A request (which set
-			 * `currentRequest`) must have been created prior.
+			 * Adds the actual RE-CONFIG chunk to the given Packet. A request (which
+			 * set `this->currentRequest`) must have been created prior.
 			 */
-			ReConfigChunk* CreateReconfigChunk();
+			void CreateReConfigChunk(Packet* packet);
 
 			/**
 			 * Called to validate the `reqSeqNbr`, that it's the next in sequence.
@@ -244,19 +256,21 @@ namespace RTC
 
 			void OnReConfigTimer(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 OnTimer(BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
 			AssociationListener& associationListener;
-			TCBContext* tcbContext{ nullptr };
+			SharedInterface* shared;
+			TCBContext* tcbContext;
+			// TODO: SCTP: Implement
+			// DataTracker* dataTracker;,
 			// TODO: SCTP: Implement
-			// DataTracker* dataTracker{ nullptr };,
-			// ReassemblyQueue* reassemblyQueue{ nullptr };,
-			// RetransmissionQueue* retransmissionQueue{ nullptr };
+			// ReassemblyQueue* reassemblyQueue;,
+			RetransmissionQueue* retransmissionQueue;
 			UnwrappedReConfigRequestSn::Unwrapper incomingReConfigRequestSnUnwrapper;
-			const std::unique_ptr<BackoffTimerHandle> reConfigTimer;
+			const std::unique_ptr<BackoffTimerHandleInterface> reConfigTimer;
 			// The next sequence number for outgoing stream requests.
 			uint32_t nextOutgoingReqSeqNbr{ 0 };
 			// The current stream request operation.

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

@@ -32,9 +32,10 @@ namespace RTC
 			virtual uint32_t GetRemoteInitialTsn() const = 0;
 
 			/**
-			 * To be called when a RTT has been measured, to update the RTO value.
+			 * To be called when a RTT (ms) has been measured, to update the RTO
+			 * value.
 			 */
-			virtual void ObserveRtt(uint64_t rtt) = 0;
+			virtual void ObserveRttMs(uint64_t rttMs) = 0;
 
 			/**
 			 * Returns the Retransmission Timeout (RTO) value.