mediasoup 3.19.21 → 3.19.22

package/worker/include/RTC/SCTP/tx/RetransmissionQueue.hpp

@@ -0,0 +1,336 @@
+#ifndef MS_RTC_SCTP_RETRANSMISSION_QUEUE_HPP
+#define MS_RTC_SCTP_RETRANSMISSION_QUEUE_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/common/UnwrappedSequenceNumber.hpp"
+#include "RTC/SCTP/packet/Packet.hpp"
+#include "RTC/SCTP/packet/UserData.hpp"
+#include "RTC/SCTP/packet/chunks/ForwardTsnChunk.hpp"
+#include "RTC/SCTP/packet/chunks/IForwardTsnChunk.hpp"
+#include "RTC/SCTP/packet/chunks/SackChunk.hpp"
+#include "RTC/SCTP/public/AssociationListener.hpp"
+#include "RTC/SCTP/public/SctpOptions.hpp"
+#include "RTC/SCTP/tx/OutstandingData.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
+#include <vector>
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/**
+		 * The RetransmissionQueue manages all DATA/I-DATA chunks that are in-flight
+		 * and schedules them to be retransmitted if necessary. Chunks are
+		 * retransmitted when they have been lost for a number of consecutive SACKs,
+		 * or when the retransmission timer expires.
+		 *
+		 * As congestion control is tightly connected with the state of transmitted
+		 * packets, that's also managed here to limit the amount of data that is
+		 * in-flight (sent, but not yet acknowledged).
+		 */
+		class RetransmissionQueue
+		{
+		public:
+			class Listener
+			{
+			public:
+				virtual ~Listener() = default;
+
+			public:
+				virtual void OnRetransmissionQueueNewRttMs(uint64_t newRttMs)  = 0;
+				virtual void OnRetransmissionQueueClearRetransmissionCounter() = 0;
+			};
+
+		public:
+			using UnwrappedTsn = UnwrappedSequenceNumber<uint32_t>;
+
+		private:
+			enum class CongestionAlgorithmPhase : uint8_t
+			{
+				SLOW_START,
+				CONGESTION_AVOIDANCE,
+			};
+
+		public:
+			/**
+			 * Creates a RetransmissionQueue which will send data using
+			 * `localInitialTsn` as the first TSN to use for sent fragments. It will
+			 * poll data from `sendQueue`. When SACKs are received, it will estimate
+			 * the RTT and call `listener->OnRetransmissionQueueNewRttMs()`. When an
+			 * outstanding Chunk has been acked, it will call
+			 * `listener->OnRetransmissionQueueClearRetransmissionCounter() and will
+			 * also use `t3RtxTimer`, which is the SCTP retransmission timer to manage
+			 * retransmissions.
+			 */
+			RetransmissionQueue(
+			  Listener* listener,
+			  AssociationListener& associationListener,
+			  uint32_t localInitialTsn,
+			  uint32_t remoteAdvertisedReceiverWindowCredit,
+			  // TODO: SCTP: Implement
+			  // SendQueue& sendQueue,
+			  BackoffTimerHandleInterface* t3RtxTimer,
+			  const SctpOptions& sctpOptions,
+			  // TODO: SCTP: I don't like these defaults (true and false), let's be explicit.
+			  bool supportsPartialReliability,
+			  bool useMessageInterleaving);
+
+			~RetransmissionQueue();
+
+		public:
+			/**
+			 * Handles a received SACK. Returns true if the SACK was processed and
+			 * false if it was discarded due to received out-of-order and not relevant.
+			 */
+			bool HandleReceivedSackChunk(uint64_t nowMs, const SackChunk* receivedSackChunk);
+
+			/**
+			 * Handles an expired retransmission timer.
+			 */
+			void HandleT3RtxTimerExpiry();
+
+			bool HasDataToBeFastRetransmitted() const
+			{
+				return this->outstandingData.HasDataToBeFastRetransmitted();
+			}
+
+			/**
+			 * Returns a list of Chunks to "fast retransmit" that would fit in
+			 * `maxLength` (bytes). The current value of `cwnd` is ignored.
+			 */
+			std::vector<std::pair<uint32_t /*tsn*/, UserData>> GetChunksForFastRetransmit(size_t maxLength);
+
+			/**
+			 * Returns a list of Chunks to send that would fit in `maxLength`
+			 * (bytes). This may be further limited by the congestion control windows.
+			 * Note that `ShouldSendForwardTsn()` must be called prior to this method,
+			 * to abandon expired Chunks, as this method will not expire any Chunks.
+			 */
+			std::vector<std::pair<uint32_t /*tsn*/, UserData>> GetChunksToSend(
+			  uint64_t nowMs, size_t maxLength);
+
+			/**
+			 * Returns the next TSN that will be allocated for sent DATA Chunks.
+			 */
+			uint32_t GetNextTsn() const
+			{
+				return this->outstandingData.GetNextTsn().Wrap();
+			}
+
+			uint32_t GetLastAssignedTsn() const
+			{
+				return UnwrappedTsn::AddTo(this->outstandingData.GetNextTsn(), -1).Wrap();
+			}
+
+			/**
+			 * Returns the size of the congestion window, in bytes. This is the number
+			 * of bytes that may be in-flight.
+			 */
+			size_t GetCwnd() const
+			{
+				return this->cwnd;
+			}
+
+			/**
+			 * Overrides the current congestion window size.
+			 */
+			void SetCwnd(size_t cwnd)
+			{
+				this->cwnd = cwnd;
+			}
+
+			/**
+			 * Returns the current receiver window size.
+			 */
+			size_t GetRwnd() const
+			{
+				return this->rwnd;
+			}
+
+			size_t GetRtxPacketsCount() const
+			{
+				return this->rtxPacketsCount;
+			}
+
+			uint64_t GetRtxBytesCount() const
+			{
+				return this->rtxBytesCount;
+			}
+
+			/**
+			 * How many inflight bytes there are, as sent on the wire as packets.
+			 */
+			size_t GetUnackedPacketBytes() const
+			{
+				return this->outstandingData.GetUnackedPacketBytes();
+			}
+
+			/**
+			 * Returns the number of DATA/I-DATA chunks that are in-flight.
+			 */
+			size_t GetUnackedItems() const
+			{
+				return this->outstandingData.GetUnackedItems();
+			}
+
+			/**
+			 * Given the current time `nowMs`, it will evaluate if there are Chunks
+			 * that have expired and that need to be discarded. It returns true if a
+			 * FORWARD-TSN should be sent.
+			 */
+			bool ShouldSendForwardTsn(uint64_t nowMs);
+
+			/**
+			 * Creates a FORWARD-TSN Chunk and adds it to the given Packet.
+			 */
+			void CreateForwardTsn(Packet* packet) const
+			{
+				this->outstandingData.CreateForwardTsn(packet);
+			}
+
+			/**
+			 * Creates an I-FORWARD-TSN Chunk and adds it to the given Packet.
+			 */
+			void CreateIForwardTsn(Packet* packet) const
+			{
+				this->outstandingData.CreateIForwardTsn(packet);
+			}
+
+			/**
+			 * @see SendQueue for a longer description of these methods related
+			 * to stream resetting.
+			 */
+			void PrepareResetStream(uint16_t streamId);
+			bool HasStreamsReadyToBeReset() const;
+			std::vector<uint16_t /*streamId*/> BeginResetStreams();
+			void CommitResetStreams();
+			void RollbackResetStreams();
+
+#ifdef MS_TEST
+			/**
+			 * Returns the internal state of all queued Chunks.
+			 *
+			 * @remarks
+			 * - This is only used in tests.
+			 */
+			std::vector<std::pair<uint32_t /*tsn*/, OutstandingData::State>> GetChunkStatesForTesting() const
+			{
+				return this->outstandingData.GetChunkStatesForTesting();
+			}
+#endif
+
+		private:
+			/**
+			 * Returns how large a chunk will be, serialized, carrying the data.
+			 */
+			size_t GetSerializedChunkLength(const UserData& data) const;
+
+			/**
+			 * Indicates if the congestion control algorithm is in "fast recovery".
+			 */
+			bool IsInFastRecovery() const
+			{
+				return this->fastRecoveryExitTsn.has_value();
+			}
+
+			/**
+			 * Indicates if the provided SACK Chunk is valid given what has previously
+			 * been received. If it returns false, the SACK is most likely a duplicate
+			 * of something already seen, so this returning false doesn't necessarily
+			 * mean that the SACK is illegal.
+			 */
+			bool IsSackChunkValid(const SackChunk* sackChunk) const;
+
+			/**
+			 * When a SACK Chunk is received, this method will be called which may
+			 * call into the `RetransmissionTimeout` to update the RTO.
+			 */
+			void UpdateRttMs(uint64_t nowMs, UnwrappedTsn cumulativeTsnAck);
+
+			/**
+			 * If the congestion control is in "fast recovery mode", this may be
+			 * exited now.
+			 */
+			void MayExitFastRecovery(UnwrappedTsn cumulativeTsnAck);
+
+			/**
+			 * If Chunks have been ACKed, stop the retransmission timer.
+			 *
+			 * @remarks
+			 * - This method is NOT defined in dcsctp! See bug report:
+			 *   https://issues.webrtc.org/issues/505751236
+			 */
+			void StopT3RtxTimerOnIncreasedCumulativeTsnAck(UnwrappedTsn cumulativeTsnAck);
+
+			/**
+			 * Update the congestion control algorithm given as the cumulative ack TSN
+			 * value has increased, as reported in an incoming SACK Chunk.
+			 */
+			void HandleIncreasedCumulativeTsnAck(size_t unackedPacketBytes, size_t totalBytesAcked);
+
+			/**
+			 * Update the congestion control algorithm, given as packet loss has been
+			 * detected, as reported in an incoming SACK Chunk.
+			 */
+			void HandlePacketLoss(UnwrappedTsn highestTsnAcked);
+
+			/**
+			 * Update the view of the receiver window size.
+			 */
+			void UpdateReceiverWindow(uint32_t aRwnd);
+
+			/**
+			 * If there is data sent and not acked, ensure that the retransmission
+			 * timer is running.
+			 */
+			void StartT3RtxTimerIfOutstandingData();
+
+			/**
+			 * Returns the current congestion control algorithm phase.
+			 */
+			CongestionAlgorithmPhase GetCongestionAlgorithmPhase() const
+			{
+				return (this->cwnd <= this->ssthresh) ? CongestionAlgorithmPhase::SLOW_START
+				                                      : CongestionAlgorithmPhase::CONGESTION_AVOIDANCE;
+			}
+
+		private:
+			Listener* listener;
+			AssociationListener& associationListener;
+			const SctpOptions sctpOptions;
+			// If the peer supports RFC3758 "SCTP Partial Reliability Extension".
+			bool supportsPartialReliability;
+			// The length of the data chunk (DATA/I-DATA) header that is used.
+			const size_t dataChunkHeaderLength;
+			// The retransmission timer.
+			BackoffTimerHandleInterface* t3RtxTimer;
+			// Unwraps TSNs.
+			UnwrappedTsn::Unwrapper tsnUnwrapper;
+			// Congestion Window. Number of bytes that may be in-flight (sent, not
+			// acked).
+			size_t cwnd;
+			// Receive Window. Number of bytes available in the receiver's RX buffer.
+			size_t rwnd;
+			// Slow Start Threshold. See RFC 9260.
+			size_t ssthresh;
+			// Partial Bytes Acked. See RFC 9260.
+			size_t partialBytesAcked{ 0 };
+			// See `AssociationMetrics`.
+			size_t rtxPacketsCount{ 0 };
+			uint64_t rtxBytesCount{ 0 };
+			// If set, fast recovery is enabled until this TSN has been cumulative
+			// acked.
+			std::optional<UnwrappedTsn> fastRecoveryExitTsn{ std::nullopt };
+			// The send queue.
+			// TODO: SCTP: Implement.
+			// SendQueue& sendQueue;
+			// All the outstanding data Chunks that are in-flight and that have not
+			// been cumulative acked. Note that it also contains chunks that have been
+			// acked in gap-ack-blocks.
+			OutstandingData outstandingData;
+			// TODO: SCTP.
+		};
+	} // namespace SCTP
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SCTP/tx/RetransmissionTimeout.hpp

@@ -14,7 +14,7 @@ namespace RTC
 		 * as delayed ack.
 		 *
 		 * When a round-trip-time (RTT) is calculated (outside this class), the
-		 * `ObserveRtt()` method is called, which calculates the retransmission
+		 * `ObserveRttMs()` method is called, which calculates the retransmission
 		 * timeout (RTO) value. The RTO value will become larger if the RTT is high
 		 * and/or the RTT values are varying a lot, which is an indicator of a bad
 		 * connection.
@@ -30,9 +30,10 @@ namespace RTC
 			void Dump(int indentation = 0) const;
 
 			/**
-			 * 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.
 			 */
-			void ObserveRtt(uint64_t rtt);
+			void ObserveRttMs(uint64_t rttMs);
 
 			/**
 			 * Returns the Retransmission Timeout (RTO) value.
@@ -43,7 +44,7 @@ namespace RTC
 			}
 
 			/**
-			 * Returns the smoothed RTT value.
+			 * Returns the smoothed RTT value (ms)..
 			 */
 			uint64_t GetSrttMs() const
 			{

package/worker/include/RTC/Serializable.hpp

@@ -75,6 +75,14 @@ namespace RTC
 			return this->length;
 		}
 
+		/**
+		 * Current available length of the Serializable.
+		 */
+		virtual size_t GetAvailableLength() const final
+		{
+			return this->bufferLength - this->length;
+		}
+
 		/**
 		 * Serialize the Serializable into a new buffer. This method copies the
 		 * bytes of the internal buffer into the new buffer and makes `GetBuffer()`

package/worker/include/RTC/SimpleConsumer.hpp

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

package/worker/include/RTC/SimulcastConsumer.hpp

@@ -4,7 +4,6 @@
 #include "RTC/Consumer.hpp"
 #include "RTC/RTP/Codecs/PayloadDescriptorHandler.hpp"
 #include "RTC/SeqManager.hpp"
-#include "RTC/Shared.hpp"
 #include <map>
 
 namespace RTC
@@ -13,7 +12,7 @@ namespace RTC
 	{
 	public:
 		SimulcastConsumer(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  const std::string& producerId,
 		  RTC::Consumer::Listener* listener,

package/worker/include/RTC/SvcConsumer.hpp

@@ -4,7 +4,6 @@
 #include "RTC/Consumer.hpp"
 #include "RTC/RTP/Codecs/PayloadDescriptorHandler.hpp"
 #include "RTC/SeqManager.hpp"
-#include "RTC/Shared.hpp"
 #include <map>
 
 namespace RTC
@@ -13,7 +12,7 @@ namespace RTC
 	{
 	public:
 		SvcConsumer(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  const std::string& producerId,
 		  RTC::Consumer::Listener* listener,

package/worker/include/RTC/Transport.hpp

@@ -23,15 +23,15 @@
 #include "RTC/SCTP/public/Message.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
 // TODO: Remove once we only use built-in SCTP stack.
+#include "SharedInterface.hpp"
 #include "RTC/SctpAssociation.hpp"
 #include "RTC/SctpListener.hpp"
-#include "RTC/Shared.hpp"
 #ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
 #include "RTC/SenderBandwidthEstimator.hpp"
 #endif
 #include "RTC/TransportCongestionControlClient.hpp"
 #include "RTC/TransportCongestionControlServer.hpp"
-#include "handles/TimerHandle.hpp"
+#include "handles/TimerHandleInterface.hpp"
 #include <absl/container/flat_hash_map.h>
 #include <string>
 #include <vector>
@@ -52,7 +52,7 @@ namespace RTC
 #ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
 	                  public RTC::SenderBandwidthEstimator::Listener,
 #endif
-	                  public TimerHandle::Listener
+	                  public TimerHandleInterface::Listener
 	{
 	protected:
 		using onSendCallback   = const std::function<void(bool sent)>;
@@ -157,7 +157,7 @@ namespace RTC
 
 	public:
 		Transport(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  RTC::Transport::Listener* listener,
 		  const FBS::Transport::Options* options);
@@ -350,16 +350,16 @@ namespace RTC
 		  uint32_t previousAvailableBitrate) override;
 #endif
 
-		/* 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;
 
 	public:
 		// Passed by argument.
 		std::string id;
 
 	protected:
-		RTC::Shared* shared{ nullptr };
+		SharedInterface* shared{ nullptr };
 		size_t maxMessageSize{ 262144u };
 		// Allocated by this.
 		std::unique_ptr<RTC::SCTP::AssociationInterface> sctpAssociation{ nullptr };
@@ -376,7 +376,7 @@ namespace RTC
 		absl::flat_hash_map<std::string, RTC::DataConsumer*> mapDataConsumers;
 		absl::flat_hash_map<uint32_t, RTC::Consumer*> mapSsrcConsumer;
 		absl::flat_hash_map<uint32_t, RTC::Consumer*> mapRtxSsrcConsumer;
-		TimerHandle* rtcpTimer{ nullptr };
+		TimerHandleInterface* rtcpTimer{ nullptr };
 		std::shared_ptr<RTC::TransportCongestionControlClient> tccClient{ nullptr };
 		std::shared_ptr<RTC::TransportCongestionControlServer> tccServer{ nullptr };
 #ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR

package/worker/include/RTC/TransportCongestionControlClient.hpp

@@ -2,13 +2,14 @@
 #define MS_RTC_TRANSPORT_CONGESTION_CONTROL_CLIENT_HPP
 
 #include "common.hpp"
+#include "SharedInterface.hpp"
 #include "RTC/BweType.hpp"
 #include "RTC/RTCP/FeedbackRtpTransport.hpp"
 #include "RTC/RTCP/ReceiverReport.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/ProbationGenerator.hpp"
 #include "RTC/TrendCalculator.hpp"
-#include "handles/TimerHandle.hpp"
+#include "handles/TimerHandleInterface.hpp"
 #include <libwebrtc/api/transport/goog_cc_factory.h>
 #include <libwebrtc/api/transport/network_types.h>
 #include <libwebrtc/call/rtp_transport_controller_send.h>
@@ -21,7 +22,7 @@ namespace RTC
 
 	class TransportCongestionControlClient : public webrtc::PacketRouter,
 	                                         public webrtc::TargetTransferRateObserver,
-	                                         public TimerHandle::Listener
+	                                         public TimerHandleInterface::Listener
 	{
 	public:
 		struct Bitrates
@@ -54,6 +55,7 @@ namespace RTC
 	public:
 		TransportCongestionControlClient(
 		  RTC::TransportCongestionControlClient::Listener* listener,
+		  SharedInterface* shared,
 		  RTC::BweType bweType,
 		  uint32_t initialAvailableBitrate,
 		  uint32_t maxOutgoingBitrate,
@@ -104,18 +106,19 @@ namespace RTC
 		void SendPacket(RTC::RTP::Packet* packet, const webrtc::PacedPacketInfo& pacingInfo) override;
 		RTC::RTP::Packet* GeneratePadding(size_t size) override;
 
-		/* Pure virtual methods inherited from RTC::TimerHandle. */
+		/* Pure virtual methods inherited from RTC::TimerHandleInterface. */
 	public:
-		void OnTimer(TimerHandle* timer) override;
+		void OnTimer(TimerHandleInterface* timer) override;
 
 	private:
 		// Passed by argument.
 		Listener* listener{ nullptr };
+		SharedInterface* shared{ nullptr };
 		// Allocated by this.
 		webrtc::NetworkControllerFactoryInterface* controllerFactory{ nullptr };
 		webrtc::RtpTransportControllerSend* rtpTransportControllerSend{ nullptr };
 		RTC::RTP::ProbationGenerator* probationGenerator{ nullptr };
-		TimerHandle* processTimer{ nullptr };
+		TimerHandleInterface* processTimer{ nullptr };
 		// Others.
 		RTC::BweType bweType;
 		uint32_t initialAvailableBitrate{ 0u };

package/worker/include/RTC/TransportCongestionControlServer.hpp

@@ -2,19 +2,20 @@
 #define MS_RTC_TRANSPORT_CONGESTION_CONTROL_SERVER_HPP
 
 #include "common.hpp"
+#include "SharedInterface.hpp"
 #include "RTC/BweType.hpp"
 #include "RTC/RTCP/FeedbackRtpTransport.hpp"
 #include "RTC/RTCP/Packet.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/SeqManager.hpp"
-#include "handles/TimerHandle.hpp"
+#include "handles/TimerHandleInterface.hpp"
 #include <libwebrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h>
 #include <deque>
 
 namespace RTC
 {
 	class TransportCongestionControlServer : public webrtc::RemoteBitrateEstimator::Listener,
-	                                         public TimerHandle::Listener
+	                                         public TimerHandleInterface::Listener
 	{
 	public:
 		class Listener
@@ -30,6 +31,7 @@ namespace RTC
 	public:
 		TransportCongestionControlServer(
 		  RTC::TransportCongestionControlServer::Listener* listener,
+		  SharedInterface* shared,
 		  RTC::BweType bweType,
 		  size_t maxRtcpPacketLen);
 		~TransportCongestionControlServer() override;
@@ -72,15 +74,16 @@ namespace RTC
 		  const std::vector<uint32_t>& ssrcs,
 		  uint32_t availableBitrate) override;
 
-		/* 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 };
+		SharedInterface* shared{ nullptr };
 		// Allocated by this.
-		TimerHandle* transportCcFeedbackSendPeriodicTimer{ nullptr };
+		TimerHandleInterface* transportCcFeedbackSendPeriodicTimer{ nullptr };
 		std::unique_ptr<RTC::RTCP::FeedbackRtpTransportPacket> transportCcFeedbackPacket;
 		webrtc::RemoteBitrateEstimatorAbsSendTime* rembServer{ nullptr };
 		// Others.

package/worker/include/RTC/WebRtcServer.hpp

@@ -1,10 +1,10 @@
 #ifndef MS_RTC_WEBRTC_SERVER_HPP
 #define MS_RTC_WEBRTC_SERVER_HPP
 
+#include "SharedInterface.hpp"
 #include "Channel/ChannelRequest.hpp"
 #include "RTC/ICE/IceCandidate.hpp"
 #include "RTC/ICE/StunPacket.hpp"
-#include "RTC/Shared.hpp"
 #include "RTC/TcpConnection.hpp"
 #include "RTC/TcpServer.hpp"
 #include "RTC/TransportTuple.hpp"
@@ -52,7 +52,7 @@ namespace RTC
 
 	public:
 		WebRtcServer(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  const flatbuffers::Vector<flatbuffers::Offset<FBS::Transport::ListenInfo>>* listenInfos);
 		~WebRtcServer() override;
@@ -112,7 +112,7 @@ namespace RTC
 		// Passed by argument.
 		std::string id;
 		// Passed by argument.
-		RTC::Shared* shared{ nullptr };
+		SharedInterface* shared{ nullptr };
 		// Vector of UdpSockets and TcpServers in the user given order.
 		std::vector<UdpSocketOrTcpServer> udpSocketOrTcpServers;
 		// Set of WebRtcTransports.

package/worker/include/RTC/WebRtcTransport.hpp

@@ -1,11 +1,11 @@
 #ifndef MS_RTC_WEBRTC_TRANSPORT_HPP
 #define MS_RTC_WEBRTC_TRANSPORT_HPP
 
+#include "SharedInterface.hpp"
 #include "RTC/DtlsTransport.hpp"
 #include "RTC/ICE/IceCandidate.hpp"
 #include "RTC/ICE/IceServer.hpp"
 #include "RTC/ICE/StunPacket.hpp"
-#include "RTC/Shared.hpp"
 #include "RTC/SrtpSession.hpp"
 #include "RTC/TcpConnection.hpp"
 #include "RTC/TcpServer.hpp"
@@ -44,12 +44,12 @@ namespace RTC
 
 	public:
 		WebRtcTransport(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  RTC::Transport::Listener* listener,
 		  const FBS::WebRtcTransport::WebRtcTransportOptions* options);
 		WebRtcTransport(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  RTC::Transport::Listener* listener,
 		  WebRtcTransportListener* webRtcTransportListener,