Replace BundleFilter with RtpDemuxer in RtpTransport.
BundleFilter is replaced by RtpDemuxer in RtpTransport for payload
type-based demuxing. RtpTransport will support MID-based demuxing later.
Each BaseChannel has its own RTP demuxing criteria and when connecting
to the RtpTransport, BaseChannel will register itself as a demuxer sink.
The inheritance model is changed. New inheritance chain:
DtlsSrtpTransport->SrtpTransport->RtpTranpsort
The JsepTransport2 is renamed to JsepTransport.
NOTE:
When RTCP packets are received, Call::DeliverRtcp will be called for
multiple times (webrtc:9035) which is an existing issue. With this CL,
it will become more of a problem and should be fixed.
Bug: webrtc:8587
Change-Id: Ibd880e7b744bd912336a691309950bc18e42cf62
Reviewed-on: https://webrtc-review.googlesource.com/65786
Commit-Queue: Zhi Huang <zhihuang@webrtc.org>
Reviewed-by: Taylor Brandstetter <deadbeef@webrtc.org>
Reviewed-by: Benjamin Wright <benwright@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22867}diff --git a/pc/srtptransport_unittest.cc b/pc/srtptransport_unittest.cc
index 30e30f6..5af45c8 100644
--- a/pc/srtptransport_unittest.cc
+++ b/pc/srtptransport_unittest.cc
@@ -42,8 +42,6 @@
protected:
SrtpTransportTest() {
bool rtcp_mux_enabled = true;
- auto rtp_transport1 = rtc::MakeUnique<RtpTransport>(rtcp_mux_enabled);
- auto rtp_transport2 = rtc::MakeUnique<RtpTransport>(rtcp_mux_enabled);
rtp_packet_transport1_ =
rtc::MakeUnique<rtc::FakePacketTransport>("fake_packet_transport1");
@@ -54,32 +52,32 @@
rtp_packet_transport1_->SetDestination(rtp_packet_transport2_.get(),
asymmetric);
- rtp_transport1->SetRtpPacketTransport(rtp_packet_transport1_.get());
- rtp_transport2->SetRtpPacketTransport(rtp_packet_transport2_.get());
+ srtp_transport1_ = rtc::MakeUnique<SrtpTransport>(rtcp_mux_enabled);
+ srtp_transport2_ = rtc::MakeUnique<SrtpTransport>(rtcp_mux_enabled);
- srtp_transport1_ =
- rtc::MakeUnique<SrtpTransport>(std::move(rtp_transport1));
- srtp_transport2_ =
- rtc::MakeUnique<SrtpTransport>(std::move(rtp_transport2));
+ srtp_transport1_->SetRtpPacketTransport(rtp_packet_transport1_.get());
+ srtp_transport2_->SetRtpPacketTransport(rtp_packet_transport2_.get());
- srtp_transport1_->SignalPacketReceived.connect(
- this, &SrtpTransportTest::OnPacketReceived1);
- srtp_transport2_->SignalPacketReceived.connect(
- this, &SrtpTransportTest::OnPacketReceived2);
+ srtp_transport1_->SignalRtcpPacketReceived.connect(
+ &rtp_sink1_, &TransportObserver::OnRtcpPacketReceived);
+ srtp_transport2_->SignalRtcpPacketReceived.connect(
+ &rtp_sink2_, &TransportObserver::OnRtcpPacketReceived);
+
+ RtpDemuxerCriteria demuxer_criteria;
+ // 0x00 is the payload type used in kPcmuFrame.
+ demuxer_criteria.payload_types = {0x00};
+
+ srtp_transport1_->RegisterRtpDemuxerSink(demuxer_criteria, &rtp_sink1_);
+ srtp_transport2_->RegisterRtpDemuxerSink(demuxer_criteria, &rtp_sink2_);
}
- void OnPacketReceived1(bool rtcp,
- rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketTime& packet_time) {
- RTC_LOG(LS_INFO) << "SrtpTransport1 Received a packet.";
- last_recv_packet1_ = *packet;
- }
-
- void OnPacketReceived2(bool rtcp,
- rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketTime& packet_time) {
- RTC_LOG(LS_INFO) << "SrtpTransport2 Received a packet.";
- last_recv_packet2_ = *packet;
+ ~SrtpTransportTest() {
+ if (srtp_transport1_) {
+ srtp_transport1_->UnregisterRtpDemuxerSink(&rtp_sink1_);
+ }
+ if (srtp_transport2_) {
+ srtp_transport2_->UnregisterRtpDemuxerSink(&rtp_sink2_);
+ }
}
// With external auth enabled, SRTP doesn't write the auth tag and
@@ -136,9 +134,9 @@
if (srtp_transport1_->IsExternalAuthActive()) {
TestRtpAuthParams(srtp_transport1_.get(), cipher_suite_name);
} else {
- ASSERT_TRUE(last_recv_packet2_.data());
- EXPECT_EQ(0,
- memcmp(last_recv_packet2_.data(), original_rtp_data, rtp_len));
+ ASSERT_TRUE(rtp_sink2_.last_recv_rtp_packet().data());
+ EXPECT_EQ(0, memcmp(rtp_sink2_.last_recv_rtp_packet().data(),
+ original_rtp_data, rtp_len));
// Get the encrypted packet from underneath packet transport and verify
// the data is actually encrypted.
auto fake_rtp_packet_transport = static_cast<rtc::FakePacketTransport*>(
@@ -153,9 +151,9 @@
if (srtp_transport2_->IsExternalAuthActive()) {
TestRtpAuthParams(srtp_transport2_.get(), cipher_suite_name);
} else {
- ASSERT_TRUE(last_recv_packet1_.data());
- EXPECT_EQ(0,
- memcmp(last_recv_packet1_.data(), original_rtp_data, rtp_len));
+ ASSERT_TRUE(rtp_sink1_.last_recv_rtp_packet().data());
+ EXPECT_EQ(0, memcmp(rtp_sink1_.last_recv_rtp_packet().data(),
+ original_rtp_data, rtp_len));
auto fake_rtp_packet_transport = static_cast<rtc::FakePacketTransport*>(
srtp_transport2_->rtp_packet_transport());
EXPECT_NE(0, memcmp(fake_rtp_packet_transport->last_sent_packet()->data(),
@@ -164,12 +162,12 @@
}
void TestSendRecvRtcpPacket(const std::string& cipher_suite_name) {
- size_t rtcp_len = sizeof(kRtcpReport);
+ size_t rtcp_len = sizeof(::kRtcpReport);
size_t packet_size =
rtcp_len + 4 + rtc::rtcp_auth_tag_len(cipher_suite_name);
rtc::Buffer rtcp_packet_buffer(packet_size);
char* rtcp_packet_data = rtcp_packet_buffer.data<char>();
- memcpy(rtcp_packet_data, kRtcpReport, rtcp_len);
+ memcpy(rtcp_packet_data, ::kRtcpReport, rtcp_len);
rtc::CopyOnWriteBuffer rtcp_packet1to2(rtcp_packet_data, rtcp_len,
packet_size);
@@ -181,8 +179,9 @@
// that the packet can be successfully received and decrypted.
ASSERT_TRUE(srtp_transport1_->SendRtcpPacket(&rtcp_packet1to2, options,
cricket::PF_SRTP_BYPASS));
- ASSERT_TRUE(last_recv_packet2_.data());
- EXPECT_EQ(0, memcmp(last_recv_packet2_.data(), rtcp_packet_data, rtcp_len));
+ ASSERT_TRUE(rtp_sink2_.last_recv_rtcp_packet().data());
+ EXPECT_EQ(0, memcmp(rtp_sink2_.last_recv_rtcp_packet().data(),
+ rtcp_packet_data, rtcp_len));
// Get the encrypted packet from underneath packet transport and verify the
// data is actually encrypted.
auto fake_rtp_packet_transport = static_cast<rtc::FakePacketTransport*>(
@@ -193,8 +192,9 @@
// Do the same thing in the opposite direction;
ASSERT_TRUE(srtp_transport2_->SendRtcpPacket(&rtcp_packet2to1, options,
cricket::PF_SRTP_BYPASS));
- ASSERT_TRUE(last_recv_packet1_.data());
- EXPECT_EQ(0, memcmp(last_recv_packet1_.data(), rtcp_packet_data, rtcp_len));
+ ASSERT_TRUE(rtp_sink1_.last_recv_rtcp_packet().data());
+ EXPECT_EQ(0, memcmp(rtp_sink1_.last_recv_rtcp_packet().data(),
+ rtcp_packet_data, rtcp_len));
fake_rtp_packet_transport = static_cast<rtc::FakePacketTransport*>(
srtp_transport2_->rtp_packet_transport());
EXPECT_NE(0, memcmp(fake_rtp_packet_transport->last_sent_packet()->data(),
@@ -261,8 +261,9 @@
// that the packet can be successfully received and decrypted.
ASSERT_TRUE(srtp_transport1_->SendRtpPacket(&rtp_packet1to2, options,
cricket::PF_SRTP_BYPASS));
- ASSERT_TRUE(last_recv_packet2_.data());
- EXPECT_EQ(0, memcmp(last_recv_packet2_.data(), original_rtp_data, rtp_len));
+ ASSERT_TRUE(rtp_sink2_.last_recv_rtp_packet().data());
+ EXPECT_EQ(0, memcmp(rtp_sink2_.last_recv_rtp_packet().data(),
+ original_rtp_data, rtp_len));
// Get the encrypted packet from underneath packet transport and verify the
// data and header extension are actually encrypted.
auto fake_rtp_packet_transport = static_cast<rtc::FakePacketTransport*>(
@@ -278,8 +279,9 @@
// Do the same thing in the opposite direction;
ASSERT_TRUE(srtp_transport2_->SendRtpPacket(&rtp_packet2to1, options,
cricket::PF_SRTP_BYPASS));
- ASSERT_TRUE(last_recv_packet1_.data());
- EXPECT_EQ(0, memcmp(last_recv_packet1_.data(), original_rtp_data, rtp_len));
+ ASSERT_TRUE(rtp_sink1_.last_recv_rtp_packet().data());
+ EXPECT_EQ(0, memcmp(rtp_sink1_.last_recv_rtp_packet().data(),
+ original_rtp_data, rtp_len));
fake_rtp_packet_transport = static_cast<rtc::FakePacketTransport*>(
srtp_transport2_->rtp_packet_transport());
EXPECT_NE(0, memcmp(fake_rtp_packet_transport->last_sent_packet()->data(),
@@ -322,8 +324,9 @@
std::unique_ptr<rtc::FakePacketTransport> rtp_packet_transport1_;
std::unique_ptr<rtc::FakePacketTransport> rtp_packet_transport2_;
- rtc::CopyOnWriteBuffer last_recv_packet1_;
- rtc::CopyOnWriteBuffer last_recv_packet2_;
+ TransportObserver rtp_sink1_;
+ TransportObserver rtp_sink2_;
+
int sequence_number_ = 0;
};