mediasoup 3.19.21 → 3.19.22

package/worker/test/src/RTC/SCTP/tx/TestRetransmissionTimeout.cpp

@@ -34,15 +34,15 @@ SCENARIO("SCTP RetransmissionTimeout", "[sctp][retransmissiontimeout]")
 	{
 		RTC::SCTP::RetransmissionTimeout rto(makeSctpOptions());
 
-		rto.ObserveRtt(MaxRttMs + 100);
+		rto.ObserveRttMs(MaxRttMs + 100);
 
 		REQUIRE(rto.GetRtoMs() == InitialRtoMs);
 
-		rto.ObserveRtt(124);
+		rto.ObserveRttMs(124);
 
 		REQUIRE(rto.GetRtoMs() == 372);
 
-		rto.ObserveRtt(MaxRttMs + 100);
+		rto.ObserveRttMs(MaxRttMs + 100);
 
 		REQUIRE(rto.GetRtoMs() == 372);
 	}
@@ -53,7 +53,7 @@ SCENARIO("SCTP RetransmissionTimeout", "[sctp][retransmissiontimeout]")
 
 		for (int i{ 0 }; i < 1000; ++i)
 		{
-			rto.ObserveRtt(1);
+			rto.ObserveRttMs(1);
 		}
 
 		REQUIRE(rto.GetRtoMs() <= MinRtoMs);
@@ -65,9 +65,9 @@ SCENARIO("SCTP RetransmissionTimeout", "[sctp][retransmissiontimeout]")
 
 		for (int i{ 0 }; i < 1000; ++i)
 		{
-			rto.ObserveRtt(MaxRttMs - 1);
+			rto.ObserveRttMs(MaxRttMs - 1);
 			// Adding jitter, which would make it RTO be well above RTT.
-			rto.ObserveRtt(MaxRttMs - 100);
+			rto.ObserveRttMs(MaxRttMs - 100);
 		}
 
 		REQUIRE(rto.GetRtoMs() >= MaxRtoMs);
@@ -77,26 +77,26 @@ SCENARIO("SCTP RetransmissionTimeout", "[sctp][retransmissiontimeout]")
 	{
 		RTC::SCTP::RetransmissionTimeout rto(makeSctpOptions());
 
-		rto.ObserveRtt(124);
+		rto.ObserveRttMs(124);
 
 		REQUIRE(rto.GetRtoMs() == 372);
 
-		rto.ObserveRtt(128);
+		rto.ObserveRttMs(128);
 
 		REQUIRE(rto.GetRtoMs() == 315);
 
-		rto.ObserveRtt(123);
+		rto.ObserveRttMs(123);
 
 		REQUIRE(rto.GetRtoMs() == 268);
 
-		rto.ObserveRtt(125);
+		rto.ObserveRttMs(125);
 
 		// NOTE: This should be 234 (as per same test in libwebrtc) but we are not
 		// that precise.
 		// REQUIRE(rto.GetRtoMs() == 234);
 		REQUIRE(rto.GetRtoMs() == 233);
 
-		rto.ObserveRtt(127);
+		rto.ObserveRttMs(127);
 
 		// NOTE: This should be 235 (as per same test in libwebrtc) but we are not
 		// that precise.
@@ -108,23 +108,23 @@ SCENARIO("SCTP RetransmissionTimeout", "[sctp][retransmissiontimeout]")
 	{
 		RTC::SCTP::RetransmissionTimeout rto(makeSctpOptions());
 
-		rto.ObserveRtt(124);
+		rto.ObserveRttMs(124);
 
 		REQUIRE(rto.GetRtoMs() == 372);
 
-		rto.ObserveRtt(402);
+		rto.ObserveRttMs(402);
 
 		REQUIRE(rto.GetRtoMs() == 623);
 
-		rto.ObserveRtt(728);
+		rto.ObserveRttMs(728);
 
 		REQUIRE(rto.GetRtoMs() == 800);
 
-		rto.ObserveRtt(89);
+		rto.ObserveRttMs(89);
 
 		REQUIRE(rto.GetRtoMs() == 800);
 
-		rto.ObserveRtt(126);
+		rto.ObserveRttMs(126);
 
 		REQUIRE(rto.GetRtoMs() == 800);
 	}
@@ -133,47 +133,47 @@ SCENARIO("SCTP RetransmissionTimeout", "[sctp][retransmissiontimeout]")
 	{
 		RTC::SCTP::RetransmissionTimeout rto(makeSctpOptions());
 
-		rto.ObserveRtt(124);
-		rto.ObserveRtt(402);
-		rto.ObserveRtt(728);
-		rto.ObserveRtt(89);
-		rto.ObserveRtt(126);
+		rto.ObserveRttMs(124);
+		rto.ObserveRttMs(402);
+		rto.ObserveRttMs(728);
+		rto.ObserveRttMs(89);
+		rto.ObserveRttMs(126);
 
 		REQUIRE(rto.GetRtoMs() == 800);
 
-		rto.ObserveRtt(124);
+		rto.ObserveRttMs(124);
 
 		REQUIRE(rto.GetRtoMs() == 800);
 
-		rto.ObserveRtt(122);
+		rto.ObserveRttMs(122);
 
 		REQUIRE(rto.GetRtoMs() == 709);
 
-		rto.ObserveRtt(123);
+		rto.ObserveRttMs(123);
 
 		REQUIRE(rto.GetRtoMs() == 630);
 
-		rto.ObserveRtt(124);
+		rto.ObserveRttMs(124);
 
 		REQUIRE(rto.GetRtoMs() == 562);
 
-		rto.ObserveRtt(122);
+		rto.ObserveRttMs(122);
 
 		REQUIRE(rto.GetRtoMs() == 505);
 
-		rto.ObserveRtt(124);
+		rto.ObserveRttMs(124);
 
 		REQUIRE(rto.GetRtoMs() == 454);
 
-		rto.ObserveRtt(124);
+		rto.ObserveRttMs(124);
 
 		REQUIRE(rto.GetRtoMs() == 410);
 
-		rto.ObserveRtt(124);
+		rto.ObserveRttMs(124);
 
 		REQUIRE(rto.GetRtoMs() == 372);
 
-		rto.ObserveRtt(124);
+		rto.ObserveRttMs(124);
 
 		REQUIRE(rto.GetRtoMs() == 340);
 	}
@@ -190,7 +190,7 @@ SCENARIO("SCTP RetransmissionTimeout", "[sctp][retransmissiontimeout]")
 
 		for (int i{ 0 }; i < 1000; ++i)
 		{
-			rto.ObserveRtt(124);
+			rto.ObserveRttMs(124);
 		}
 
 		// NOTE: This should be 234 (as per same test in libwebrtc) but we are not
@@ -209,7 +209,7 @@ SCENARIO("SCTP RetransmissionTimeout", "[sctp][retransmissiontimeout]")
 
 		for (int i{ 0 }; i < 1000; ++i)
 		{
-			rto.ObserveRtt(124);
+			rto.ObserveRttMs(124);
 		}
 
 		REQUIRE(rto.GetRtoMs() == 184);
@@ -225,7 +225,7 @@ SCENARIO("SCTP RetransmissionTimeout", "[sctp][retransmissiontimeout]")
 
 		for (int i{ 0 }; i < 1000; ++i)
 		{
-			rto.ObserveRtt(124);
+			rto.ObserveRttMs(124);
 		}
 
 		REQUIRE(rto.GetRtoMs() == 284);

package/worker/test/src/RTC/TestKeyFrameRequestManager.cpp

@@ -1,7 +1,9 @@
 #include "common.hpp"
 #include "DepLibUV.hpp"
+#include "mocks/include/MockShared.hpp"
 #include "RTC/KeyFrameRequestManager.hpp"
 #include <catch2/catch_test_macros.hpp>
+#include <memory>
 
 SCENARIO("KeyFrameRequestManager", "[rtp][keyframe]")
 {
@@ -22,12 +24,14 @@ SCENARIO("KeyFrameRequestManager", "[rtp][keyframe]")
 		size_t onKeyFrameNeededTimesCalled{ 0 };
 	};
 
-	static TestKeyFrameRequestManagerListener listener;
+	TestKeyFrameRequestManagerListener listener;
+	mocks::MockShared shared;
 
 	SECTION("key frame requested once, not received on time")
 	{
 		listener.Reset();
-		RTC::KeyFrameRequestManager keyFrameRequestManager(&listener, 1000);
+		RTC::KeyFrameRequestManager keyFrameRequestManager(
+		  std::addressof(listener), std::addressof(shared), 1000);
 
 		keyFrameRequestManager.KeyFrameNeeded(1111);
 
@@ -40,7 +44,8 @@ SCENARIO("KeyFrameRequestManager", "[rtp][keyframe]")
 	SECTION("key frame requested many times, not received on time")
 	{
 		listener.Reset();
-		RTC::KeyFrameRequestManager keyFrameRequestManager(&listener, 500);
+		RTC::KeyFrameRequestManager keyFrameRequestManager(
+		  std::addressof(listener), std::addressof(shared), 500);
 
 		keyFrameRequestManager.KeyFrameNeeded(1111);
 		keyFrameRequestManager.KeyFrameNeeded(1111);
@@ -56,7 +61,8 @@ SCENARIO("KeyFrameRequestManager", "[rtp][keyframe]")
 	SECTION("key frame is received on time")
 	{
 		listener.Reset();
-		RTC::KeyFrameRequestManager keyFrameRequestManager(&listener, 500);
+		RTC::KeyFrameRequestManager keyFrameRequestManager(
+		  std::addressof(listener), std::addressof(shared), 500);
 
 		keyFrameRequestManager.KeyFrameNeeded(1111);
 		keyFrameRequestManager.KeyFrameReceived(1111);
@@ -70,7 +76,8 @@ SCENARIO("KeyFrameRequestManager", "[rtp][keyframe]")
 	SECTION("key frame is forced, no received on time")
 	{
 		listener.Reset();
-		RTC::KeyFrameRequestManager keyFrameRequestManager(&listener, 500);
+		RTC::KeyFrameRequestManager keyFrameRequestManager(
+		  std::addressof(listener), std::addressof(shared), 500);
 
 		keyFrameRequestManager.KeyFrameNeeded(1111);
 		keyFrameRequestManager.ForceKeyFrameNeeded(1111);
@@ -84,7 +91,8 @@ SCENARIO("KeyFrameRequestManager", "[rtp][keyframe]")
 	SECTION("key frame is forced, received on time")
 	{
 		listener.Reset();
-		RTC::KeyFrameRequestManager keyFrameRequestManager(&listener, 500);
+		RTC::KeyFrameRequestManager keyFrameRequestManager(
+		  std::addressof(listener), std::addressof(shared), 500);
 
 		keyFrameRequestManager.KeyFrameNeeded(1111);
 		keyFrameRequestManager.ForceKeyFrameNeeded(1111);

package/worker/test/src/RTC/TestNackGenerator.cpp

@@ -1,5 +1,6 @@
 #include "common.hpp"
 #include "DepLibUV.hpp"
+#include "mocks/include/MockShared.hpp"
 #include "RTC/NackGenerator.hpp"
 #include "RTC/RTP/Codecs/PayloadDescriptorHandler.hpp"
 #include "RTC/RTP/Packet.hpp"
@@ -126,11 +127,14 @@ SCENARIO("NACK generator", "[rtp][rtcp][nack]")
 		bool keyFrameRequiredTriggered{ false };
 	};
 
+	mocks::MockShared shared;
+
 	auto validate =
-	  [](std::unique_ptr<RTC::RTP::Packet>& packet, std::vector<TestNackGeneratorInput>& inputs)
+	  [&shared](std::unique_ptr<RTC::RTP::Packet>& packet, std::vector<TestNackGeneratorInput>& inputs)
 	{
 		TestNackGeneratorListener listener;
-		auto nackGenerator = RTC::NackGenerator(&listener, SendNackDelay);
+		auto nackGenerator =
+		  RTC::NackGenerator(std::addressof(listener), std::addressof(shared), SendNackDelay);
 
 		for (auto input : inputs)
 		{

package/worker/test/src/RTC/TestSimpleConsumer.cpp

@@ -1,6 +1,5 @@
 #include "flatbuffers/buffer.h"
-#include "Channel/ChannelNotifier.hpp"
-#include "Channel/ChannelSocket.hpp"
+#include "mocks/include/MockShared.hpp"
 #include "FBS/rtpParameters.h"
 #include "FBS/transport.h"
 #include "RTC/RTP/Packet.hpp"
@@ -8,18 +7,14 @@
 #include "RTC/RTP/RtpStreamRecv.hpp"
 #include "RTC/RTP/SharedPacket.hpp"
 #include "RTC/RtpDictionaries.hpp"
-#include "RTC/Shared.hpp"
 #include "RTC/SimpleConsumer.hpp"
 #include <catch2/catch_test_macros.hpp>
 
 namespace
 {
 	// NOLINTBEGIN(readability-identifier-naming)
-	const uint8_t payloadType       = 111;
-	auto* channelMessageRegistrator = new ChannelMessageRegistrator();
-	auto* channelSocket             = new Channel::ChannelSocket();
-	auto* channelNotifier           = new Channel::ChannelNotifier(channelSocket);
-	auto shared                     = RTC::Shared(channelMessageRegistrator, channelNotifier);
+	const uint8_t payloadType = 111;
+	mocks::MockShared shared;
 	// NOLINTEND(readability-identifier-naming)
 
 	class RtpStreamRecvListener : public RTC::RTP::RtpStreamRecv::Listener
@@ -142,7 +137,7 @@ namespace
 		const auto* consumeRequest = flatbuffers::GetRoot<FBS::Transport::ConsumeRequest>(buf);
 
 		return std::make_unique<RTC::SimpleConsumer>(
-		  &shared,
+		  std::addressof(shared),
 		  consumeRequest->consumerId()->str(),
 		  consumeRequest->producerId()->str(),
 		  listener,
@@ -154,7 +149,8 @@ namespace
 		RtpStreamRecvListener streamRecvListener;
 		RTC::RTP::RtpStream::Params params;
 
-		return std::make_unique<RTC::RTP::RtpStreamRecv>(&streamRecvListener, params, 0u, false);
+		return std::make_unique<RTC::RTP::RtpStreamRecv>(
+		  &streamRecvListener, std::addressof(shared), params, 0u, false);
 	}
 
 	/**

package/worker/test/src/RTC/TestTransportCongestionControlServer.cpp

@@ -1,5 +1,6 @@
 #include "common.hpp"
 #include "DepLibUV.hpp"
+#include "mocks/include/MockShared.hpp"
 #include "RTC/Consts.hpp"
 #include "RTC/RTP/HeaderExtensionIds.hpp"
 #include "RTC/RTP/Packet.hpp"
@@ -77,6 +78,8 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 		TestResults results;
 	};
 
+	mocks::MockShared shared;
+
 	// clang-format off
 	alignas(4) uint8_t buffer[] =
 	{
@@ -89,11 +92,15 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 	// clang-format on
 
 	auto validate =
-	  [&buffer](std::vector<TestTransportCongestionControlServerInput>& inputs, TestResults& results)
+	  [&buffer,
+	   &shared](std::vector<TestTransportCongestionControlServerInput>& inputs, TestResults& results)
 	{
 		TestTransportCongestionControlServerListener listener;
 		auto tccServer = RTC::TransportCongestionControlServer(
-		  &listener, RTC::BweType::TRANSPORT_CC, RTC::Consts::MtuSize);
+		  std::addressof(listener),
+		  std::addressof(shared),
+		  RTC::BweType::TRANSPORT_CC,
+		  RTC::Consts::MtuSize);
 
 		tccServer.SetMaxIncomingBitrate(150000);
 		tccServer.TransportConnected();

package/worker/test/src/Utils/TestByte.cpp

@@ -335,6 +335,104 @@ SCENARIO("Utils::Byte", "[utils][byte]")
 #endif
 	}
 
+	SECTION("PadDownTo4Bytes()")
+	{
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint8_t{ 0u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint8_t{ 1u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint8_t{ 2u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint8_t{ 3u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint8_t{ 4u }) == 4u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint8_t{ 5u }) == 4u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint8_t{ 8u }) == 8u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint8_t{ 9u }) == 8u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint8_t{ 15u }) == 12u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint8_t{ 252u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint8_t{ 254u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint8_t{ 255u }) == 252u);
+
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 0u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 1u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 2u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 3u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 4u }) == 4u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 5u }) == 4u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 8u }) == 8u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 9u }) == 8u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 15u }) == 12u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 252u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 254u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 255u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 256u }) == 256u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 65532u }) == 65532u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint16_t{ 65535u }) == 65532u);
+
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 0u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 1u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 2u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 3u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 4u }) == 4u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 5u }) == 4u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 8u }) == 8u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 9u }) == 8u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 15u }) == 12u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 252u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 254u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 255u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 256u }) == 256u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 65532u }) == 65532u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 65535u }) == 65532u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 4294967288u }) == 4294967288u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 4294967292u }) == 4294967292u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint32_t{ 4294967295u }) == 4294967292u);
+
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 0u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 1u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 2u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 3u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 4u }) == 4u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 5u }) == 4u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 8u }) == 8u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 9u }) == 8u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 15u }) == 12u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 252u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 254u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 255u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 256u }) == 256u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 65532u }) == 65532u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 65535u }) == 65532u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 4294967288u }) == 4294967288u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 4294967292u }) == 4294967292u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 4294967295u }) == 4294967292u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 18446744073709551608u }) == 18446744073709551608u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 18446744073709551612u }) == 18446744073709551612u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(uint64_t{ 18446744073709551615u }) == 18446744073709551612u);
+
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 0u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 1u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 2u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 3u }) == 0u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 4u }) == 4u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 5u }) == 4u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 8u }) == 8u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 9u }) == 8u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 15u }) == 12u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 252u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 254u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 255u }) == 252u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 256u }) == 256u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 65532u }) == 65532u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 65535u }) == 65532u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 4294967288u }) == 4294967288u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 4294967292u }) == 4294967292u);
+
+// Check if size_t in current host is 64 bits. Otherwise the test would fail.
+#if SIZE_MAX == 0xFFFFFFFFFFFFFFFFu
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 18446744073709551608u }) == 18446744073709551608u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 18446744073709551612u }) == 18446744073709551612u);
+		REQUIRE(Utils::Byte::PadDownTo4Bytes(size_t{ 18446744073709551615u }) == 18446744073709551612u);
+#endif
+	}
+
 	SECTION("PadTo8Bytes()")
 	{
 		REQUIRE(Utils::Byte::PadTo8Bytes(uint8_t{ 0u }) == 0u);

package/worker/include/ChannelMessageRegistrator.hpp

@@ -1,30 +0,0 @@
-#ifndef MS_CHANNEL_MESSAGE_REGISTRATOR_HPP
-#define MS_CHANNEL_MESSAGE_REGISTRATOR_HPP
-
-#include "Channel/ChannelSocket.hpp"
-#include <absl/container/flat_hash_map.h>
-#include <string>
-
-class ChannelMessageRegistrator
-{
-public:
-	explicit ChannelMessageRegistrator();
-	~ChannelMessageRegistrator();
-
-public:
-	flatbuffers::Offset<FBS::Worker::ChannelMessageHandlers> FillBuffer(
-	  flatbuffers::FlatBufferBuilder& builder);
-	void RegisterHandler(
-	  const std::string& id,
-	  Channel::ChannelSocket::RequestHandler* channelRequestHandler,
-	  Channel::ChannelSocket::NotificationHandler* channelNotificationHandler);
-	void UnregisterHandler(const std::string& id);
-	Channel::ChannelSocket::RequestHandler* GetChannelRequestHandler(const std::string& id);
-	Channel::ChannelSocket::NotificationHandler* GetChannelNotificationHandler(const std::string& id);
-
-private:
-	absl::flat_hash_map<std::string, Channel::ChannelSocket::RequestHandler*> mapChannelRequestHandlers;
-	absl::flat_hash_map<std::string, Channel::ChannelSocket::NotificationHandler*> mapChannelNotificationHandlers;
-};
-
-#endif

package/worker/include/RTC/Shared.hpp

@@ -1,23 +0,0 @@
-#ifndef MS_RTC_SHARED_HPP
-#define MS_RTC_SHARED_HPP
-
-#include "ChannelMessageRegistrator.hpp"
-#include "Channel/ChannelNotifier.hpp"
-
-namespace RTC
-{
-	class Shared
-	{
-	public:
-		explicit Shared(
-		  ChannelMessageRegistrator* channelMessageRegistrator,
-		  Channel::ChannelNotifier* channelNotifier);
-		~Shared();
-
-	public:
-		ChannelMessageRegistrator* channelMessageRegistrator{ nullptr };
-		Channel::ChannelNotifier* channelNotifier{ nullptr };
-	};
-} // namespace RTC
-
-#endif

package/worker/src/ChannelMessageRegistrator.cpp

@@ -1,119 +0,0 @@
-#define MS_CLASS "ChannelMessageRegistrator"
-// #define MS_LOG_DEV_LEVEL 3
-
-#include "ChannelMessageRegistrator.hpp"
-#include "Logger.hpp"
-#include "MediaSoupErrors.hpp"
-
-ChannelMessageRegistrator::ChannelMessageRegistrator()
-{
-	MS_TRACE();
-}
-
-ChannelMessageRegistrator::~ChannelMessageRegistrator()
-{
-	MS_TRACE();
-
-	this->mapChannelRequestHandlers.clear();
-	this->mapChannelNotificationHandlers.clear();
-}
-
-flatbuffers::Offset<FBS::Worker::ChannelMessageHandlers> ChannelMessageRegistrator::FillBuffer(
-  flatbuffers::FlatBufferBuilder& builder)
-{
-	// Add channelRequestHandlerIds.
-	std::vector<flatbuffers::Offset<flatbuffers::String>> channelRequestHandlerIds;
-	for (const auto& kv : this->mapChannelRequestHandlers)
-	{
-		const auto& handlerId = kv.first;
-
-		channelRequestHandlerIds.push_back(builder.CreateString(handlerId));
-	}
-
-	// Add channelNotificationHandlerIds.
-	std::vector<flatbuffers::Offset<flatbuffers::String>> channelNotificationHandlerIds;
-	for (const auto& kv : this->mapChannelNotificationHandlers)
-	{
-		const auto& handlerId = kv.first;
-
-		channelNotificationHandlerIds.push_back(builder.CreateString(handlerId));
-	}
-
-	return FBS::Worker::CreateChannelMessageHandlersDirect(
-	  builder, &channelRequestHandlerIds, &channelNotificationHandlerIds);
-}
-
-void ChannelMessageRegistrator::RegisterHandler(
-  const std::string& id,
-  Channel::ChannelSocket::RequestHandler* channelRequestHandler,
-  Channel::ChannelSocket::NotificationHandler* channelNotificationHandler)
-{
-	MS_TRACE();
-
-	if (channelRequestHandler != nullptr)
-	{
-		if (this->mapChannelRequestHandlers.find(id) != this->mapChannelRequestHandlers.end())
-		{
-			MS_THROW_ERROR("Channel request handler with ID %s already exists", id.c_str());
-		}
-
-		this->mapChannelRequestHandlers[id] = channelRequestHandler;
-	}
-
-	if (channelNotificationHandler != nullptr)
-	{
-		if (this->mapChannelNotificationHandlers.find(id) != this->mapChannelNotificationHandlers.end())
-		{
-			if (channelRequestHandler != nullptr)
-			{
-				this->mapChannelRequestHandlers.erase(id);
-			}
-
-			MS_THROW_ERROR("Channel notification handler with ID %s already exists", id.c_str());
-		}
-
-		this->mapChannelNotificationHandlers[id] = channelNotificationHandler;
-	}
-}
-
-void ChannelMessageRegistrator::UnregisterHandler(const std::string& id)
-{
-	MS_TRACE();
-
-	this->mapChannelRequestHandlers.erase(id);
-	this->mapChannelNotificationHandlers.erase(id);
-}
-
-Channel::ChannelSocket::RequestHandler* ChannelMessageRegistrator::GetChannelRequestHandler(
-  const std::string& id)
-{
-	MS_TRACE();
-
-	auto it = this->mapChannelRequestHandlers.find(id);
-
-	if (it != this->mapChannelRequestHandlers.end())
-	{
-		return it->second;
-	}
-	else
-	{
-		return nullptr;
-	}
-}
-
-Channel::ChannelSocket::NotificationHandler* ChannelMessageRegistrator::GetChannelNotificationHandler(
-  const std::string& id)
-{
-	MS_TRACE();
-
-	auto it = this->mapChannelNotificationHandlers.find(id);
-
-	if (it != this->mapChannelNotificationHandlers.end())
-	{
-		return it->second;
-	}
-	else
-	{
-		return nullptr;
-	}
-}

package/worker/src/RTC/Shared.cpp

@@ -1,23 +0,0 @@
-#define MS_CLASS "Shared"
-// #define MS_LOG_DEV_LEVEL 3
-
-#include "RTC/Shared.hpp"
-#include "Logger.hpp"
-
-namespace RTC
-{
-	Shared::Shared(
-	  ChannelMessageRegistrator* channelMessageRegistrator, Channel::ChannelNotifier* channelNotifier)
-	  : channelMessageRegistrator(channelMessageRegistrator), channelNotifier(channelNotifier)
-	{
-		MS_TRACE();
-	}
-
-	Shared::~Shared()
-	{
-		MS_TRACE();
-
-		delete this->channelMessageRegistrator;
-		delete this->channelNotifier;
-	}
-} // namespace RTC