Refactor optional pointer to pointer

include/rtc/h264rtppacketizer.hpp

@@ -55,7 +55,7 @@ public:
 	H264RtpPacketizer(std::shared_ptr<RtpPacketizationConfig> rtpConfig,
 					  uint16_t maximumFragmentSize = NalUnits::defaultMaximumFragmentSize);
 
-	ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) override;
+	ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, message_ptr control) override;
 private:
 	const Separator separator;
 };

include/rtc/mediachainablehandler.hpp

@@ -30,11 +30,11 @@ class RTC_CPP_EXPORT MediaChainableHandler : public MediaHandler {
 	std::shared_ptr<MediaHandlerElement> leaf;
 	std::mutex inoutMutex;
 
-	std::optional<message_ptr> handleIncomingBinary(message_ptr);
-	std::optional<message_ptr> handleIncomingControl(message_ptr);
-	std::optional<message_ptr> handleOutgoingBinary(message_ptr);
-	std::optional<message_ptr> handleOutgoingControl(message_ptr);
-	bool sendProduct(ChainedOutgoingResponseProduct product);
+	message_ptr handleIncomingBinary(message_ptr);
+	message_ptr handleIncomingControl(message_ptr);
+	message_ptr handleOutgoingBinary(message_ptr);
+	message_ptr handleOutgoingControl(message_ptr);
+	bool sendProduct(ChainedOutgoingProduct product);
 public:
 	MediaChainableHandler(std::shared_ptr<MediaHandlerRootElement> root);
 	~MediaChainableHandler();

include/rtc/mediahandlerelement.hpp

@@ -33,38 +33,31 @@ RTC_CPP_EXPORT ChainedMessagesProduct make_chained_messages_product(message_ptr
 
 /// Ougoing messages
 struct RTC_CPP_EXPORT ChainedOutgoingProduct {
-	ChainedOutgoingProduct(ChainedMessagesProduct messages, std::optional<message_ptr> control = nullopt);
+	ChainedOutgoingProduct(ChainedMessagesProduct messages = nullptr, message_ptr control = nullptr);
 	const ChainedMessagesProduct messages;
-	const std::optional<message_ptr> control;
-};
-
-/// Ougoing response to incoming messages
-struct RTC_CPP_EXPORT ChainedOutgoingResponseProduct {
-	ChainedOutgoingResponseProduct(std::optional<ChainedMessagesProduct> messages = nullopt, std::optional<message_ptr> control = nullopt);
-	const std::optional<ChainedMessagesProduct> messages;
-	const std::optional<message_ptr> control;
+	const message_ptr control;
 };
 
 /// Incoming messages with response
 struct RTC_CPP_EXPORT ChainedIncomingProduct {
-	ChainedIncomingProduct(std::optional<ChainedMessagesProduct> incoming = nullopt, std::optional<ChainedMessagesProduct> outgoing = nullopt);
-	const std::optional<ChainedMessagesProduct> incoming;
-	const std::optional<ChainedOutgoingResponseProduct> outgoing;
+	ChainedIncomingProduct(ChainedMessagesProduct incoming = nullptr, ChainedMessagesProduct outgoing = nullptr);
+	const ChainedMessagesProduct incoming;
+	const ChainedOutgoingProduct outgoing;
 };
 
 /// Incoming control messages with response
 struct RTC_CPP_EXPORT ChainedIncomingControlProduct {
-	ChainedIncomingControlProduct(message_ptr incoming, std::optional<ChainedOutgoingResponseProduct> outgoing = nullopt);
-	const std::optional<message_ptr> incoming;
-	const std::optional<ChainedOutgoingResponseProduct> outgoing;
+	ChainedIncomingControlProduct(message_ptr incoming, std::optional<ChainedOutgoingProduct> outgoing = nullopt);
+	const message_ptr incoming;
+	const std::optional<ChainedOutgoingProduct> outgoing;
 };
 
 /// Chainable handler
 class RTC_CPP_EXPORT MediaHandlerElement: public std::enable_shared_from_this<MediaHandlerElement> {
-	std::optional<std::shared_ptr<MediaHandlerElement>> upstream = nullopt;
-	std::optional<std::shared_ptr<MediaHandlerElement>> downstream = nullopt;
+	std::shared_ptr<MediaHandlerElement> upstream = nullptr;
+	std::shared_ptr<MediaHandlerElement> downstream = nullptr;
 
-	void prepareAndSendResponse(std::optional<ChainedOutgoingResponseProduct> outgoing, std::function<bool (ChainedOutgoingResponseProduct)> send);
+	void prepareAndSendResponse(std::optional<ChainedOutgoingProduct> outgoing, std::function<bool (ChainedOutgoingProduct)> send);
 
 	void removeFromChain();
 public:
@@ -73,12 +66,12 @@ public:
 	/// Creates response to incoming message
 	/// @param messages Current repsonse
 	/// @returns New response
-	std::optional<ChainedOutgoingResponseProduct> processOutgoingResponse(ChainedOutgoingResponseProduct messages);
+	std::optional<ChainedOutgoingProduct> processOutgoingResponse(ChainedOutgoingProduct messages);
 
 	// Process incoming and ougoing messages
-	std::optional<message_ptr> formIncomingControlMessage(message_ptr message, std::function<bool (ChainedOutgoingResponseProduct)> send);
-	std::optional<ChainedMessagesProduct> formIncomingBinaryMessage(ChainedMessagesProduct messages, std::function<bool (ChainedOutgoingResponseProduct)> send);
-	std::optional<message_ptr> formOutgoingControlMessage(message_ptr message);
+	message_ptr formIncomingControlMessage(message_ptr message, std::function<bool (ChainedOutgoingProduct)> send);
+	ChainedMessagesProduct formIncomingBinaryMessage(ChainedMessagesProduct messages, std::function<bool (ChainedOutgoingProduct)> send);
+	message_ptr formOutgoingControlMessage(message_ptr message);
 	std::optional<ChainedOutgoingProduct> formOutgoingBinaryMessage(ChainedOutgoingProduct product);
 
 	/// Process current control message
@@ -100,7 +93,7 @@ public:
 	/// @param messages current message
 	/// @param control current control message
 	/// @returns Modified binary message and control message
-	virtual ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control);
+	virtual ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, message_ptr control);
 
 	/// Set given element as upstream to this
 	/// @param upstream Upstream element

include/rtc/opusrtppacketizer.hpp

@@ -48,7 +48,7 @@ public:
 	/// @param messages opus samples
 	/// @param control RTCP
 	/// @returns RTP packets and unchanged `control`
-	ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) override;
+	ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, message_ptr control) override;
 };
 
 } // namespace rtc

include/rtc/rtcpnackresponder.hpp

@@ -84,7 +84,7 @@ public:
 	/// @param messages RTP packets
 	/// @param control RTCP
 	/// @returns Unchanged RTP and RTCP
-	ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) override;
+	ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, message_ptr control) override;
 };
 
 } // namespace rtc

include/rtc/rtcpsrreporter.hpp

@@ -50,7 +50,7 @@ public:
 
 	RtcpSrReporter(std::shared_ptr<RtpPacketizationConfig> rtpConfig);
 
-	ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) override;
+	ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, message_ptr control) override;
 
 	/// Set `needsToReport` flag. Sender report will be sent before next RTP packet with same
 	/// timestamp.

src/h264rtppacketizer.cpp

@@ -139,13 +139,13 @@ H264RtpPacketizer::H264RtpPacketizer(H264RtpPacketizer::Separator separator, std
 									 uint16_t maximumFragmentSize)
 : RtpPacketizer(rtpConfig), MediaHandlerRootElement(), maximumFragmentSize(maximumFragmentSize), separator(separator) {}
 
-ChainedOutgoingProduct H264RtpPacketizer::processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
+ChainedOutgoingProduct H264RtpPacketizer::processOutgoingBinaryMessage(ChainedMessagesProduct messages, message_ptr control) {
 	ChainedMessagesProduct packets = std::make_shared<std::vector<binary_ptr>>();
 	for (auto message: *messages) {
 		auto nalus = splitMessage(message);
 		auto fragments = nalus->generateFragments(maximumFragmentSize);
 		if (fragments.size() == 0) {
-			return ChainedOutgoingProduct({});
+			return ChainedOutgoingProduct();
 		}
 		unsigned i = 0;
 		for (; i < fragments.size() - 1; i++) {

src/mediachainablehandler.cpp

@@ -27,17 +27,18 @@ MediaChainableHandler::~MediaChainableHandler() {
 	leaf->recursiveRemoveChain();
 }
 
-bool MediaChainableHandler::sendProduct(ChainedOutgoingResponseProduct product) {
+bool MediaChainableHandler::sendProduct(ChainedOutgoingProduct product) {
 	bool result = true;
-	if (product.control.has_value()) {
-		auto sendResult = send(product.control.value());
+	if (product.control) {
+		assert(product.control->type == Message::Control);
+		auto sendResult = send(product.control);
 		if(!sendResult) {
 			LOG_DEBUG << "Failed to send control message";
 		}
 		result = result && sendResult;
 	}
-	if (product.messages.has_value()) {
-		auto messages = product.messages.value();
+	if (product.messages) {
+		auto messages = product.messages;
 		for (unsigned i = 0; i < messages->size(); i++) {
 			auto message = messages->at(i);
 			if (!message) {
@@ -53,46 +54,46 @@ bool MediaChainableHandler::sendProduct(ChainedOutgoingResponseProduct product)
 	return result;
 }
 
-std::optional<message_ptr> MediaChainableHandler::handleIncomingBinary(message_ptr msg) {
+message_ptr MediaChainableHandler::handleIncomingBinary(message_ptr msg) {
 	assert(msg->type == Message::Binary);
 	auto messages = root->split(msg);
-	auto incoming = leaf->formIncomingBinaryMessage(messages, [this](ChainedOutgoingResponseProduct outgoing) {
+	auto incoming = leaf->formIncomingBinaryMessage(messages, [this](ChainedOutgoingProduct outgoing) {
 		return sendProduct(outgoing);
 	});
-	if (incoming.has_value()) {
-		return root->reduce(incoming.value());
+	if (incoming) {
+		return root->reduce(incoming);
 	} else {
-		return nullopt;
+		return nullptr;
 	}
 }
 
-std::optional<message_ptr> MediaChainableHandler::handleIncomingControl(message_ptr msg) {
+message_ptr MediaChainableHandler::handleIncomingControl(message_ptr msg) {
 	assert(msg->type == Message::Control);
-	auto incoming = leaf->formIncomingControlMessage(msg, [this](ChainedOutgoingResponseProduct outgoing) {
+	auto incoming = leaf->formIncomingControlMessage(msg, [this](ChainedOutgoingProduct outgoing) {
 		return sendProduct(outgoing);
 	});
-	assert(!incoming.has_value() || incoming.value()->type == Message::Control);
+	assert(!incoming || incoming->type == Message::Control);
 	return incoming;
 }
 
-std::optional<message_ptr> MediaChainableHandler::handleOutgoingBinary(message_ptr msg) {
+message_ptr MediaChainableHandler::handleOutgoingBinary(message_ptr msg) {
 	assert(msg->type == Message::Binary);
 	auto messages = make_chained_messages_product(msg);
 	auto optOutgoing = root->formOutgoingBinaryMessage(ChainedOutgoingProduct(messages));
 	if (!optOutgoing.has_value()) {
 		LOG_ERROR << "Generating outgoing message failed";
-		return nullopt;
+		return nullptr;
 	}
 	auto outgoing = optOutgoing.value();
-	if (outgoing.control.has_value()) {
-		if(!send(outgoing.control.value())) {
+	if (outgoing.control) {
+		if(!send(outgoing.control)) {
 			LOG_DEBUG << "Failed to send control message";
 		}
 	}
 	auto lastMessage = outgoing.messages->back();
 	if (!lastMessage) {
 		LOG_DEBUG << "Invalid message to send";
-		return nullopt;
+		return nullptr;
 	}
 	for (unsigned i = 0; i < outgoing.messages->size() - 1; i++) {
 		auto message = outgoing.messages->at(i);
@@ -106,15 +107,15 @@ std::optional<message_ptr> MediaChainableHandler::handleOutgoingBinary(message_p
 	return make_message(*lastMessage);
 }
 
-std::optional<message_ptr> MediaChainableHandler::handleOutgoingControl(message_ptr msg) {
+message_ptr MediaChainableHandler::handleOutgoingControl(message_ptr msg) {
 	assert(msg->type == Message::Control);
-	auto optOutgoing = root->formOutgoingControlMessage(msg);
-	assert(!optOutgoing.has_value() || optOutgoing.value()->type == Message::Control);
-	if (!optOutgoing.has_value()) {
+	auto outgoing = root->formOutgoingControlMessage(msg);
+	assert(!outgoing || outgoing->type == Message::Control);
+	if (!outgoing) {
 		LOG_ERROR << "Generating outgoing control message failed";
-		return nullopt;
+		return nullptr;
 	}
-	return optOutgoing.value();
+	return outgoing;
 }
 
 message_ptr MediaChainableHandler::outgoing(message_ptr ptr) {
@@ -125,9 +126,9 @@ message_ptr MediaChainableHandler::outgoing(message_ptr ptr) {
 	}
 	std::lock_guard<std::mutex> guard(inoutMutex);
 	if (ptr->type == Message::Binary) {
-		return handleOutgoingBinary(ptr).value_or(nullptr);
+		return handleOutgoingBinary(ptr);
 	} else if (ptr->type == Message::Control) {
-		return handleOutgoingControl(ptr).value_or(nullptr);
+		return handleOutgoingControl(ptr);
 	}
 	return ptr;
 }
@@ -139,9 +140,9 @@ message_ptr MediaChainableHandler::incoming(message_ptr ptr) {
 	}
 	std::lock_guard<std::mutex> guard(inoutMutex);
 	if (ptr->type == Message::Binary) {
-		return handleIncomingBinary(ptr).value_or(nullptr);
+		return handleIncomingBinary(ptr);
 	} else if (ptr->type == Message::Control) {
-		return handleIncomingControl(ptr).value_or(nullptr);
+		return handleIncomingControl(ptr);
 	}
 	return ptr;
 }

src/mediahandlerelement.cpp

@@ -30,61 +30,57 @@ ChainedMessagesProduct make_chained_messages_product(message_ptr msg) {
 	return std::make_shared<std::vector<binary_ptr>>(msgs);
 }
 
-ChainedOutgoingProduct::ChainedOutgoingProduct(ChainedMessagesProduct messages, std::optional<message_ptr> control)
+ChainedOutgoingProduct::ChainedOutgoingProduct(ChainedMessagesProduct messages, message_ptr control)
 : messages(messages), control(control) { }
 
-ChainedOutgoingResponseProduct::ChainedOutgoingResponseProduct(std::optional<ChainedMessagesProduct> messages, std::optional<message_ptr> control)
-: messages(messages), control(control) { }
-
-ChainedIncomingProduct::ChainedIncomingProduct(std::optional<ChainedMessagesProduct> incoming, std::optional<ChainedMessagesProduct> outgoing)
+ChainedIncomingProduct::ChainedIncomingProduct(ChainedMessagesProduct incoming, ChainedMessagesProduct outgoing)
 : incoming(incoming), outgoing(outgoing) { }
 
-ChainedIncomingControlProduct::ChainedIncomingControlProduct(message_ptr incoming, std::optional<ChainedOutgoingResponseProduct> outgoing)
+ChainedIncomingControlProduct::ChainedIncomingControlProduct(message_ptr incoming, std::optional<ChainedOutgoingProduct> outgoing)
 : incoming(incoming), outgoing(outgoing) { }
 
 MediaHandlerElement::MediaHandlerElement() { }
 
 void MediaHandlerElement::removeFromChain() {
-	if (upstream.has_value()) {
-		upstream.value()->downstream = downstream;
+	if (upstream) {
+		upstream->downstream = downstream;
 	}
-	if (downstream.has_value()) {
-		downstream.value()->upstream = upstream;
+	if (downstream) {
+		downstream->upstream = upstream;
 	}
-	upstream = nullopt;
-	downstream = nullopt;
+	upstream = nullptr;
+	downstream = nullptr;
 }
 
 void MediaHandlerElement::recursiveRemoveChain() {
-	if (downstream.has_value()) {
+	if (downstream) {
 		// `recursiveRemoveChain` removes last strong reference to downstream element
 		// we need to keep strong reference to prevent deallocation of downstream element
 		// during `recursiveRemoveChain`
 		auto strongDownstreamPtr = downstream;
-		downstream.value()->recursiveRemoveChain();
+		downstream->recursiveRemoveChain();
 	}
 	removeFromChain();
 }
 
-std::optional<ChainedOutgoingResponseProduct> MediaHandlerElement::processOutgoingResponse(ChainedOutgoingResponseProduct messages) {
-	if (messages.messages.has_value()) {
-		if (upstream.has_value()) {
-			auto msgs = upstream.value()->formOutgoingBinaryMessage(ChainedOutgoingProduct(messages.messages.value(), messages.control));
+std::optional<ChainedOutgoingProduct> MediaHandlerElement::processOutgoingResponse(ChainedOutgoingProduct messages) {
+	if (messages.messages) {
+		if (upstream) {
+			auto msgs = upstream->formOutgoingBinaryMessage(ChainedOutgoingProduct(messages.messages, messages.control));
 			if (msgs.has_value()) {
-				auto messages = msgs.value();
-				return ChainedOutgoingResponseProduct(std::make_optional(messages.messages), messages.control);
+				return msgs.value();
 			} else {
-				LOG_ERROR << "Generating outgoing control message failed";
+				LOG_ERROR << "Generating outgoing message failed";
 				return nullopt;
 			}
 		} else {
 			return messages;
 		}
-	} else if (messages.control.has_value()) {
-		if (upstream.has_value()) {
-			auto control = upstream.value()->formOutgoingControlMessage(messages.control.value());
-			if (control.has_value()) {
-				return ChainedOutgoingResponseProduct(nullopt, control.value());
+	} else if (messages.control) {
+		if (upstream) {
+			auto control = upstream->formOutgoingControlMessage(messages.control);
+			if (control) {
+				return ChainedOutgoingProduct(nullptr, control);
 			} else {
 				LOG_ERROR << "Generating outgoing control message failed";
 				return nullopt;
@@ -93,11 +89,11 @@ std::optional<ChainedOutgoingResponseProduct> MediaHandlerElement::processOutgoi
 			return messages;
 		}
 	} else {
-		return ChainedOutgoingResponseProduct();
+		return ChainedOutgoingProduct();
 	}
 }
 
-void MediaHandlerElement::prepareAndSendResponse(std::optional<ChainedOutgoingResponseProduct> outgoing, std::function<bool (ChainedOutgoingResponseProduct)> send) {
+void MediaHandlerElement::prepareAndSendResponse(std::optional<ChainedOutgoingProduct> outgoing, std::function<bool (ChainedOutgoingProduct)> send) {
 	if (outgoing.has_value()) {
 		auto message = outgoing.value();
 		auto response = processOutgoingResponse(message);
@@ -111,56 +107,46 @@ void MediaHandlerElement::prepareAndSendResponse(std::optional<ChainedOutgoingRe
 	}
 }
 
-std::optional<message_ptr> MediaHandlerElement::formIncomingControlMessage(message_ptr message, std::function<bool (ChainedOutgoingResponseProduct)> send) {
+message_ptr MediaHandlerElement::formIncomingControlMessage(message_ptr message, std::function<bool (ChainedOutgoingProduct)> send) {
 	assert(message);
 	auto product = processIncomingControlMessage(message);
 	prepareAndSendResponse(product.outgoing, send);
-	if (product.incoming.has_value()) {
-		if (downstream.has_value()) {
-			if (product.incoming.value()) {
-				return downstream.value()->formIncomingControlMessage(product.incoming.value(), send);
-			} else {
-				LOG_DEBUG << "Failed to generate incoming message";
-				return nullopt;
-			}
+	if (product.incoming) {
+		if (downstream) {
+			return downstream->formIncomingControlMessage(product.incoming, send);
 		} else {
 			return product.incoming;
 		}
 	} else {
-		return product.incoming;
+		return nullptr;
 	}
 }
 
-std::optional<ChainedMessagesProduct> MediaHandlerElement::formIncomingBinaryMessage(ChainedMessagesProduct messages, std::function<bool (ChainedOutgoingResponseProduct)> send) {
+ChainedMessagesProduct MediaHandlerElement::formIncomingBinaryMessage(ChainedMessagesProduct messages, std::function<bool (ChainedOutgoingProduct)> send) {
 	assert(messages && !messages->empty());
 	auto product = processIncomingBinaryMessage(messages);
 	prepareAndSendResponse(product.outgoing, send);
-	if (product.incoming.has_value()) {
-		if (downstream.has_value()) {
-			if (product.incoming.value()) {
-				return downstream.value()->formIncomingBinaryMessage(product.incoming.value(), send);
-			} else {
-				LOG_ERROR << "Failed to generate incoming message";
-				return nullopt;
-			}
+	if (product.incoming) {
+		if (downstream) {
+			return downstream->formIncomingBinaryMessage(product.incoming, send);
 		} else {
 			return product.incoming;
 		}
 	} else {
-		return product.incoming;
+		return nullptr;
 	}
 }
 
-std::optional<message_ptr> MediaHandlerElement::formOutgoingControlMessage(message_ptr message) {
+message_ptr MediaHandlerElement::formOutgoingControlMessage(message_ptr message) {
 	assert(message);
 	auto newMessage = processOutgoingControlMessage(message);
 	assert(newMessage);
 	if(!newMessage) {
 		LOG_ERROR << "Failed to generate outgoing message";
-		return nullopt;
+		return nullptr;
 	}
-	if (upstream.has_value()) {
-		return upstream.value()->formOutgoingControlMessage(newMessage);
+	if (upstream) {
+		return upstream->formOutgoingControlMessage(newMessage);
 	} else {
 		return newMessage;
 	}
@@ -169,23 +155,18 @@ std::optional<message_ptr> MediaHandlerElement::formOutgoingControlMessage(messa
 std::optional<ChainedOutgoingProduct> MediaHandlerElement::formOutgoingBinaryMessage(ChainedOutgoingProduct product) {
 	assert(product.messages && !product.messages->empty());
 	auto newProduct = processOutgoingBinaryMessage(product.messages, product.control);
-	assert(!product.control.has_value() || newProduct.control.has_value());
-	assert(!newProduct.control.has_value() || newProduct.control.value());
+	assert(!product.control || newProduct.control);
 	assert(newProduct.messages && !newProduct.messages->empty());
-	if (product.control.has_value() && !newProduct.control.has_value()) {
+	if (product.control && !newProduct.control) {
 		LOG_ERROR << "Outgoing message must not remove control message";
 		return nullopt;
 	}
-	if (newProduct.control.has_value() && !newProduct.control.value()) {
-		LOG_ERROR << "Failed to generate control message";
-		return nullopt;
-	}
 	if (!newProduct.messages || newProduct.messages->empty()) {
 		LOG_ERROR << "Failed to generate message";
 		return nullopt;
 	}
-	if (upstream.has_value()) {
-		return upstream.value()->formOutgoingBinaryMessage(newProduct);
+	if (upstream) {
+		return upstream->formOutgoingBinaryMessage(newProduct);
 	} else {
 		return newProduct;
 	}
@@ -203,13 +184,13 @@ ChainedIncomingProduct MediaHandlerElement::processIncomingBinaryMessage(Chained
 	return {messages};
 }
 
-ChainedOutgoingProduct MediaHandlerElement::processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
+ChainedOutgoingProduct MediaHandlerElement::processOutgoingBinaryMessage(ChainedMessagesProduct messages, message_ptr control) {
 	return {messages, control};
 }
 
 std::shared_ptr<MediaHandlerElement> MediaHandlerElement::chainWith(std::shared_ptr<MediaHandlerElement> upstream) {
-	assert(this->upstream == nullopt);
-	assert(upstream->downstream == nullopt);
+	assert(this->upstream == nullptr);
+	assert(upstream->downstream == nullptr);
 	this->upstream = upstream;
 	upstream->downstream = shared_from_this();
 	return upstream;

src/opusrtppacketizer.cpp

@@ -30,7 +30,7 @@ binary_ptr OpusRtpPacketizer::packetize(binary_ptr payload, bool setMark) {
 	return RtpPacketizer::packetize(payload, false);
 }
 
-ChainedOutgoingProduct OpusRtpPacketizer::processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
+ChainedOutgoingProduct OpusRtpPacketizer::processOutgoingBinaryMessage(ChainedMessagesProduct messages, message_ptr control) {
 	ChainedMessagesProduct packets = make_chained_messages_product();
 	packets->reserve(messages->size());
 	for (auto message: *messages) {

src/rtcpnackresponder.cpp

@@ -69,7 +69,7 @@ RtcpNackResponder::RtcpNackResponder(unsigned maxStoredPacketCount)
 : MediaHandlerElement(), storage(std::make_shared<Storage>(maxStoredPacketCount)) { }
 
 ChainedIncomingControlProduct RtcpNackResponder::processIncomingControlMessage(message_ptr message) {
-	std::optional<ChainedOutgoingResponseProduct> optPackets = ChainedOutgoingResponseProduct();
+	std::optional<ChainedOutgoingProduct> optPackets = ChainedOutgoingProduct(nullptr);
 	auto packets = make_chained_messages_product();
 
 	unsigned int i = 0;
@@ -100,13 +100,13 @@ ChainedIncomingControlProduct RtcpNackResponder::processIncomingControlMessage(m
 	}
 
 	if (!packets->empty()) {
-		return {message, ChainedOutgoingResponseProduct(packets)};
+		return {message, ChainedOutgoingProduct(packets)};
 	} else {
 		return {message, nullopt};
 	}
 }
 
-ChainedOutgoingProduct RtcpNackResponder::processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
+ChainedOutgoingProduct RtcpNackResponder::processOutgoingBinaryMessage(ChainedMessagesProduct messages, message_ptr control) {
 	for (auto message: *messages) {
 		storage->store(message);
 	}

src/rtcpsrreporter.cpp

@@ -21,13 +21,12 @@
 
 namespace rtc {
 
-ChainedOutgoingProduct RtcpSrReporter::processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
+ChainedOutgoingProduct RtcpSrReporter::processOutgoingBinaryMessage(ChainedMessagesProduct messages, message_ptr control) {
 	if (needsToReport) {
 		auto timestamp = rtpConfig->timestamp;
 		auto sr = getSenderReport(timestamp);
-		if (control.has_value()) {
-			auto rtcp = control.value();
-			rtcp->insert(rtcp->end(), sr->begin(), sr->end());
+		if (control) {
+			control->insert(control->end(), sr->begin(), sr->end());
 		} else {
 			control = sr;
 		}