Move RTP/RTCP demuxing logic from BaseChannel to RtpTransport.

webrtc/pc/rtptransport_unittest.cc

Index: webrtc/pc/rtptransport_unittest.cc
diff --git a/webrtc/pc/rtptransport_unittest.cc b/webrtc/pc/rtptransport_unittest.cc
index ba492517b511846e56912901e601b2bc35a81073..df84d471a7a284cdeef06ce9e8ead7acb98bad3d 100644
--- a/webrtc/pc/rtptransport_unittest.cc
+++ b/webrtc/pc/rtptransport_unittest.cc
@@ -16,12 +16,10 @@
 
 namespace webrtc {
 
-class RtpTransportTest : public testing::Test {};
-
 constexpr bool kMuxDisabled = false;
 constexpr bool kMuxEnabled = true;
 
-TEST_F(RtpTransportTest, SetRtcpParametersCantDisableRtcpMux) {
+TEST(RtpTransportTest, SetRtcpParametersCantDisableRtcpMux) {
   RtpTransport transport(kMuxDisabled);
   RtcpParameters params;
   transport.SetRtcpParameters(params);
@@ -29,7 +27,7 @@ TEST_F(RtpTransportTest, SetRtcpParametersCantDisableRtcpMux) {
   EXPECT_FALSE(transport.SetRtcpParameters(params).ok());
 }
 
-TEST_F(RtpTransportTest, SetRtcpParametersEmptyCnameUsesExisting) {
+TEST(RtpTransportTest, SetRtcpParametersEmptyCnameUsesExisting) {
   static const char kName[] = "name";
   RtpTransport transport(kMuxDisabled);
   RtcpParameters params_with_name;
@@ -47,11 +45,14 @@ class SignalObserver : public sigslot::has_slots<> {
   explicit SignalObserver(RtpTransport* transport) {
     transport->SignalReadyToSend.connect(this, &SignalObserver::OnReadyToSend);
   }
+  bool ready() const { return ready_; }
   void OnReadyToSend(bool ready) { ready_ = ready; }
+
+ private:
   bool ready_ = false;
 };
 
-TEST_F(RtpTransportTest, SettingRtcpAndRtpSignalsReady) {
+TEST(RtpTransportTest, SettingRtcpAndRtpSignalsReady) {
   RtpTransport transport(kMuxDisabled);
   SignalObserver observer(&transport);
   rtc::FakePacketTransport fake_rtcp("fake_rtcp");
@@ -60,12 +61,12 @@ TEST_F(RtpTransportTest, SettingRtcpAndRtpSignalsReady) {
   fake_rtp.SetWritable(true);
 
   transport.SetRtcpPacketTransport(&fake_rtcp);  // rtcp ready
-  EXPECT_FALSE(observer.ready_);
+  EXPECT_FALSE(observer.ready());
   transport.SetRtpPacketTransport(&fake_rtp);  // rtp ready
-  EXPECT_TRUE(observer.ready_);
+  EXPECT_TRUE(observer.ready());
 }
 
-TEST_F(RtpTransportTest, SettingRtpAndRtcpSignalsReady) {
+TEST(RtpTransportTest, SettingRtpAndRtcpSignalsReady) {
   RtpTransport transport(kMuxDisabled);
   SignalObserver observer(&transport);
   rtc::FakePacketTransport fake_rtcp("fake_rtcp");
@@ -74,45 +75,45 @@ TEST_F(RtpTransportTest, SettingRtpAndRtcpSignalsReady) {
   fake_rtp.SetWritable(true);
 
   transport.SetRtpPacketTransport(&fake_rtp);  // rtp ready
-  EXPECT_FALSE(observer.ready_);
+  EXPECT_FALSE(observer.ready());
   transport.SetRtcpPacketTransport(&fake_rtcp);  // rtcp ready
-  EXPECT_TRUE(observer.ready_);
+  EXPECT_TRUE(observer.ready());
 }
 
-TEST_F(RtpTransportTest, SettingRtpWithRtcpMuxEnabledSignalsReady) {
+TEST(RtpTransportTest, SettingRtpWithRtcpMuxEnabledSignalsReady) {
   RtpTransport transport(kMuxEnabled);
   SignalObserver observer(&transport);
   rtc::FakePacketTransport fake_rtp("fake_rtp");
   fake_rtp.SetWritable(true);
 
   transport.SetRtpPacketTransport(&fake_rtp);  // rtp ready
-  EXPECT_TRUE(observer.ready_);
+  EXPECT_TRUE(observer.ready());
 }
 
-TEST_F(RtpTransportTest, DisablingRtcpMuxSignalsNotReady) {
+TEST(RtpTransportTest, DisablingRtcpMuxSignalsNotReady) {
   RtpTransport transport(kMuxEnabled);
   SignalObserver observer(&transport);
   rtc::FakePacketTransport fake_rtp("fake_rtp");
   fake_rtp.SetWritable(true);
 
   transport.SetRtpPacketTransport(&fake_rtp);  // rtp ready
-  EXPECT_TRUE(observer.ready_);
+  EXPECT_TRUE(observer.ready());
 
   transport.SetRtcpMuxEnabled(false);
-  EXPECT_FALSE(observer.ready_);
+  EXPECT_FALSE(observer.ready());
 }
 
-TEST_F(RtpTransportTest, EnablingRtcpMuxSignalsReady) {
+TEST(RtpTransportTest, EnablingRtcpMuxSignalsReady) {
   RtpTransport transport(kMuxDisabled);
   SignalObserver observer(&transport);
   rtc::FakePacketTransport fake_rtp("fake_rtp");
   fake_rtp.SetWritable(true);
 
   transport.SetRtpPacketTransport(&fake_rtp);  // rtp ready
-  EXPECT_FALSE(observer.ready_);
+  EXPECT_FALSE(observer.ready());
 
   transport.SetRtcpMuxEnabled(true);
-  EXPECT_TRUE(observer.ready_);
+  EXPECT_TRUE(observer.ready());
 }
 
 class SignalCounter : public sigslot::has_slots<> {
@@ -120,11 +121,14 @@ class SignalCounter : public sigslot::has_slots<> {
   explicit SignalCounter(RtpTransport* transport) {
     transport->SignalReadyToSend.connect(this, &SignalCounter::OnReadyToSend);
   }
+  int count() const { return count_; }
   void OnReadyToSend(bool ready) { ++count_; }
+
+ private:
   int count_ = 0;
 };
 
-TEST_F(RtpTransportTest, ChangingReadyToSendStateOnlySignalsWhenChanged) {
+TEST(RtpTransportTest, ChangingReadyToSendStateOnlySignalsWhenChanged) {
   RtpTransport transport(kMuxEnabled);
   SignalCounter observer(&transport);
   rtc::FakePacketTransport fake_rtp("fake_rtp");
@@ -132,19 +136,101 @@ TEST_F(RtpTransportTest, ChangingReadyToSendStateOnlySignalsWhenChanged) {
 
   // State changes, so we should signal.
   transport.SetRtpPacketTransport(&fake_rtp);
-  EXPECT_EQ(observer.count_, 1);
+  EXPECT_EQ(observer.count(), 1);
 
   // State does not change, so we should not signal.
   transport.SetRtpPacketTransport(&fake_rtp);
-  EXPECT_EQ(observer.count_, 1);
+  EXPECT_EQ(observer.count(), 1);
 
   // State does not change, so we should not signal.
   transport.SetRtcpMuxEnabled(true);
-  EXPECT_EQ(observer.count_, 1);
+  EXPECT_EQ(observer.count(), 1);
 
   // State changes, so we should signal.
   transport.SetRtcpMuxEnabled(false);
-  EXPECT_EQ(observer.count_, 2);
+  EXPECT_EQ(observer.count(), 2);
+}
+
+class SignalPacketReceivedCounter : public sigslot::has_slots<> {
+ public:
+  explicit SignalPacketReceivedCounter(RtpTransport* transport) {
+    transport->SignalPacketReceived.connect(
+        this, &SignalPacketReceivedCounter::OnPacketReceived);
+  }
+  int rtcp_count() const { return rtcp_count_; }
+  int rtp_count() const { return rtp_count_; }
+
+ private:
+  void OnPacketReceived(bool rtcp,
+                        rtc::CopyOnWriteBuffer&,
+                        const rtc::PacketTime&) {
+    if (rtcp) {
+      ++rtcp_count_;
+    } else {
+      ++rtp_count_;
+    }
+  }
+  int rtcp_count_ = 0;
+  int rtp_count_ = 0;
+};
+
+// Test that SignalPacketReceived fires with rtcp=true when a RTCP packet is
+// received.
+TEST(RtpTransportTest, SignalDemuxedRtcp) {
+  RtpTransport transport(kMuxDisabled);
+  SignalPacketReceivedCounter observer(&transport);
+  rtc::FakePacketTransport fake_rtp("fake_rtp");
+  fake_rtp.SetDestination(&fake_rtp, true);
+  transport.SetRtpPacketTransport(&fake_rtp);
+
+  // An rtcp packet.
+  const char data[] = {0, 73, 0, 0};
+  const int len = 4;
+  const rtc::PacketOptions options;
+  const int flags = 0;
+  fake_rtp.SendPacket(data, len, options, flags);
+  EXPECT_EQ(0, observer.rtp_count());
+  EXPECT_EQ(1, observer.rtcp_count());
+}
+
+static const unsigned char kRtpData[] = {0x80, 0x11, 0, 0, 0, 0,
+                                         0,    0,    0, 0, 0, 0};
+static const int kRtpLen = 12;
+
+// Test that SignalPacketReceived fires with rtcp=false when a RTP packet with a
+// handled payload type is received.
+TEST(RtpTransportTest, SignalHandledRtpPayloadType) {
+  RtpTransport transport(kMuxDisabled);
+  SignalPacketReceivedCounter observer(&transport);
+  rtc::FakePacketTransport fake_rtp("fake_rtp");
+  fake_rtp.SetDestination(&fake_rtp, true);
+  transport.SetRtpPacketTransport(&fake_rtp);
+  transport.AddHandledPayloadType(0x11);
+
+  // An rtp packet.
+  const rtc::PacketOptions options;
+  const int flags = 0;
+  rtc::Buffer rtp_data(kRtpData, kRtpLen);
+  fake_rtp.SendPacket(rtp_data.data<char>(), kRtpLen, options, flags);
+  EXPECT_EQ(1, observer.rtp_count());
+  EXPECT_EQ(0, observer.rtcp_count());
+}
+
+// Test that SignalPacketReceived does not fire when a RTP packet with an
+// unhandled payload type is received.
+TEST(RtpTransportTest, DontSignalUnhandledRtpPayloadType) {
+  RtpTransport transport(kMuxDisabled);
+  SignalPacketReceivedCounter observer(&transport);
+  rtc::FakePacketTransport fake_rtp("fake_rtp");
+  fake_rtp.SetDestination(&fake_rtp, true);
+  transport.SetRtpPacketTransport(&fake_rtp);
+
+  const rtc::PacketOptions options;
+  const int flags = 0;
+  rtc::Buffer rtp_data(kRtpData, kRtpLen);
+  fake_rtp.SendPacket(rtp_data.data<char>(), kRtpLen, options, flags);
+  EXPECT_EQ(0, observer.rtp_count());
+  EXPECT_EQ(0, observer.rtcp_count());
 }
 
 }  // namespace webrtc