zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2017 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
| 11 | #include <string> |
Mirko Bonadei | c61ce0d | 2017-11-21 17:04:20 +0100 | [diff] [blame] | 12 | #include <utility> |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 13 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 14 | #include "p2p/base/fakepackettransport.h" |
| 15 | #include "pc/rtptransport.h" |
| 16 | #include "pc/rtptransporttestutil.h" |
| 17 | #include "rtc_base/gunit.h" |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 18 | |
| 19 | namespace webrtc { |
| 20 | |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 21 | constexpr bool kMuxDisabled = false; |
| 22 | constexpr bool kMuxEnabled = true; |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 23 | constexpr uint16_t kLocalNetId = 1; |
| 24 | constexpr uint16_t kRemoteNetId = 2; |
| 25 | constexpr int kLastPacketId = 100; |
| 26 | constexpr int kTransportOverheadPerPacket = 28; // Ipv4(20) + UDP(8). |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 27 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 28 | TEST(RtpTransportTest, SetRtcpParametersCantDisableRtcpMux) { |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 29 | RtpTransport transport(kMuxDisabled); |
sprang | db2a9fc | 2017-08-09 06:42:32 -0700 | [diff] [blame] | 30 | RtpTransportParameters params; |
| 31 | transport.SetParameters(params); |
| 32 | params.rtcp.mux = false; |
| 33 | EXPECT_FALSE(transport.SetParameters(params).ok()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 34 | } |
| 35 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 36 | TEST(RtpTransportTest, SetRtcpParametersEmptyCnameUsesExisting) { |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 37 | static const char kName[] = "name"; |
| 38 | RtpTransport transport(kMuxDisabled); |
sprang | db2a9fc | 2017-08-09 06:42:32 -0700 | [diff] [blame] | 39 | RtpTransportParameters params_with_name; |
| 40 | params_with_name.rtcp.cname = kName; |
| 41 | transport.SetParameters(params_with_name); |
| 42 | EXPECT_EQ(transport.GetParameters().rtcp.cname, kName); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 43 | |
sprang | db2a9fc | 2017-08-09 06:42:32 -0700 | [diff] [blame] | 44 | RtpTransportParameters params_without_name; |
| 45 | transport.SetParameters(params_without_name); |
| 46 | EXPECT_EQ(transport.GetParameters().rtcp.cname, kName); |
| 47 | } |
| 48 | |
| 49 | TEST(RtpTransportTest, SetRtpTransportKeepAliveNotSupported) { |
| 50 | // Tests that we warn users that keep-alive isn't supported yet. |
| 51 | // TODO(sprang): Wire up keep-alive and remove this test. |
| 52 | RtpTransport transport(kMuxDisabled); |
| 53 | RtpTransportParameters params; |
| 54 | params.keepalive.timeout_interval_ms = 1; |
| 55 | auto result = transport.SetParameters(params); |
| 56 | EXPECT_FALSE(result.ok()); |
| 57 | EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, result.type()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 58 | } |
| 59 | |
| 60 | class SignalObserver : public sigslot::has_slots<> { |
| 61 | public: |
| 62 | explicit SignalObserver(RtpTransport* transport) { |
| 63 | transport->SignalReadyToSend.connect(this, &SignalObserver::OnReadyToSend); |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 64 | transport->SignalNetworkRouteChanged.connect( |
| 65 | this, &SignalObserver::OnNetworkRouteChanged); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 66 | } |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 67 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 68 | bool ready() const { return ready_; } |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 69 | void OnReadyToSend(bool ready) { ready_ = ready; } |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 70 | |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 71 | rtc::Optional<rtc::NetworkRoute> network_route() { return network_route_; } |
| 72 | void OnNetworkRouteChanged(rtc::Optional<rtc::NetworkRoute> network_route) { |
Mirko Bonadei | c61ce0d | 2017-11-21 17:04:20 +0100 | [diff] [blame] | 73 | network_route_ = std::move(network_route); |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 74 | } |
| 75 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 76 | private: |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 77 | bool ready_ = false; |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 78 | rtc::Optional<rtc::NetworkRoute> network_route_; |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 79 | }; |
| 80 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 81 | TEST(RtpTransportTest, SettingRtcpAndRtpSignalsReady) { |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 82 | RtpTransport transport(kMuxDisabled); |
| 83 | SignalObserver observer(&transport); |
| 84 | rtc::FakePacketTransport fake_rtcp("fake_rtcp"); |
| 85 | fake_rtcp.SetWritable(true); |
| 86 | rtc::FakePacketTransport fake_rtp("fake_rtp"); |
| 87 | fake_rtp.SetWritable(true); |
| 88 | |
| 89 | transport.SetRtcpPacketTransport(&fake_rtcp); // rtcp ready |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 90 | EXPECT_FALSE(observer.ready()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 91 | transport.SetRtpPacketTransport(&fake_rtp); // rtp ready |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 92 | EXPECT_TRUE(observer.ready()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 93 | } |
| 94 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 95 | TEST(RtpTransportTest, SettingRtpAndRtcpSignalsReady) { |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 96 | RtpTransport transport(kMuxDisabled); |
| 97 | SignalObserver observer(&transport); |
| 98 | rtc::FakePacketTransport fake_rtcp("fake_rtcp"); |
| 99 | fake_rtcp.SetWritable(true); |
| 100 | rtc::FakePacketTransport fake_rtp("fake_rtp"); |
| 101 | fake_rtp.SetWritable(true); |
| 102 | |
| 103 | transport.SetRtpPacketTransport(&fake_rtp); // rtp ready |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 104 | EXPECT_FALSE(observer.ready()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 105 | transport.SetRtcpPacketTransport(&fake_rtcp); // rtcp ready |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 106 | EXPECT_TRUE(observer.ready()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 107 | } |
| 108 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 109 | TEST(RtpTransportTest, SettingRtpWithRtcpMuxEnabledSignalsReady) { |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 110 | RtpTransport transport(kMuxEnabled); |
| 111 | SignalObserver observer(&transport); |
| 112 | rtc::FakePacketTransport fake_rtp("fake_rtp"); |
| 113 | fake_rtp.SetWritable(true); |
| 114 | |
| 115 | transport.SetRtpPacketTransport(&fake_rtp); // rtp ready |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 116 | EXPECT_TRUE(observer.ready()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 117 | } |
| 118 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 119 | TEST(RtpTransportTest, DisablingRtcpMuxSignalsNotReady) { |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 120 | RtpTransport transport(kMuxEnabled); |
| 121 | SignalObserver observer(&transport); |
| 122 | rtc::FakePacketTransport fake_rtp("fake_rtp"); |
| 123 | fake_rtp.SetWritable(true); |
| 124 | |
| 125 | transport.SetRtpPacketTransport(&fake_rtp); // rtp ready |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 126 | EXPECT_TRUE(observer.ready()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 127 | |
| 128 | transport.SetRtcpMuxEnabled(false); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 129 | EXPECT_FALSE(observer.ready()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 130 | } |
| 131 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 132 | TEST(RtpTransportTest, EnablingRtcpMuxSignalsReady) { |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 133 | RtpTransport transport(kMuxDisabled); |
| 134 | SignalObserver observer(&transport); |
| 135 | rtc::FakePacketTransport fake_rtp("fake_rtp"); |
| 136 | fake_rtp.SetWritable(true); |
| 137 | |
| 138 | transport.SetRtpPacketTransport(&fake_rtp); // rtp ready |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 139 | EXPECT_FALSE(observer.ready()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 140 | |
| 141 | transport.SetRtcpMuxEnabled(true); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 142 | EXPECT_TRUE(observer.ready()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 143 | } |
| 144 | |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 145 | // Tests the SignalNetworkRoute is fired when setting a packet transport. |
| 146 | TEST(RtpTransportTest, SetRtpTransportWithNetworkRouteChanged) { |
| 147 | RtpTransport transport(kMuxDisabled); |
| 148 | SignalObserver observer(&transport); |
| 149 | rtc::FakePacketTransport fake_rtp("fake_rtp"); |
| 150 | |
| 151 | EXPECT_FALSE(observer.network_route()); |
| 152 | |
| 153 | rtc::NetworkRoute network_route; |
| 154 | // Set a non-null RTP transport with a new network route. |
| 155 | network_route.connected = true; |
| 156 | network_route.local_network_id = kLocalNetId; |
| 157 | network_route.remote_network_id = kRemoteNetId; |
| 158 | network_route.last_sent_packet_id = kLastPacketId; |
| 159 | network_route.packet_overhead = kTransportOverheadPerPacket; |
| 160 | fake_rtp.SetNetworkRoute(rtc::Optional<rtc::NetworkRoute>(network_route)); |
| 161 | transport.SetRtpPacketTransport(&fake_rtp); |
| 162 | ASSERT_TRUE(observer.network_route()); |
| 163 | EXPECT_EQ(network_route, *(observer.network_route())); |
| 164 | EXPECT_EQ(kTransportOverheadPerPacket, |
| 165 | observer.network_route()->packet_overhead); |
| 166 | EXPECT_EQ(kLastPacketId, observer.network_route()->last_sent_packet_id); |
| 167 | |
| 168 | // Set a null RTP transport. |
| 169 | transport.SetRtpPacketTransport(nullptr); |
| 170 | EXPECT_FALSE(observer.network_route()); |
| 171 | } |
| 172 | |
| 173 | TEST(RtpTransportTest, SetRtcpTransportWithNetworkRouteChanged) { |
| 174 | RtpTransport transport(kMuxDisabled); |
| 175 | SignalObserver observer(&transport); |
| 176 | rtc::FakePacketTransport fake_rtcp("fake_rtcp"); |
| 177 | |
| 178 | EXPECT_FALSE(observer.network_route()); |
| 179 | |
| 180 | rtc::NetworkRoute network_route; |
| 181 | // Set a non-null RTCP transport with a new network route. |
| 182 | network_route.connected = true; |
| 183 | network_route.local_network_id = kLocalNetId; |
| 184 | network_route.remote_network_id = kRemoteNetId; |
| 185 | network_route.last_sent_packet_id = kLastPacketId; |
| 186 | network_route.packet_overhead = kTransportOverheadPerPacket; |
| 187 | fake_rtcp.SetNetworkRoute(rtc::Optional<rtc::NetworkRoute>(network_route)); |
| 188 | transport.SetRtcpPacketTransport(&fake_rtcp); |
| 189 | ASSERT_TRUE(observer.network_route()); |
| 190 | EXPECT_EQ(network_route, *(observer.network_route())); |
| 191 | EXPECT_EQ(kTransportOverheadPerPacket, |
| 192 | observer.network_route()->packet_overhead); |
| 193 | EXPECT_EQ(kLastPacketId, observer.network_route()->last_sent_packet_id); |
| 194 | |
| 195 | // Set a null RTCP transport. |
| 196 | transport.SetRtcpPacketTransport(nullptr); |
| 197 | EXPECT_FALSE(observer.network_route()); |
| 198 | } |
| 199 | |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 200 | class SignalCounter : public sigslot::has_slots<> { |
| 201 | public: |
| 202 | explicit SignalCounter(RtpTransport* transport) { |
| 203 | transport->SignalReadyToSend.connect(this, &SignalCounter::OnReadyToSend); |
| 204 | } |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 205 | int count() const { return count_; } |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 206 | void OnReadyToSend(bool ready) { ++count_; } |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 207 | |
| 208 | private: |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 209 | int count_ = 0; |
| 210 | }; |
| 211 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 212 | TEST(RtpTransportTest, ChangingReadyToSendStateOnlySignalsWhenChanged) { |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 213 | RtpTransport transport(kMuxEnabled); |
| 214 | SignalCounter observer(&transport); |
| 215 | rtc::FakePacketTransport fake_rtp("fake_rtp"); |
| 216 | fake_rtp.SetWritable(true); |
| 217 | |
| 218 | // State changes, so we should signal. |
| 219 | transport.SetRtpPacketTransport(&fake_rtp); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 220 | EXPECT_EQ(observer.count(), 1); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 221 | |
| 222 | // State does not change, so we should not signal. |
| 223 | transport.SetRtpPacketTransport(&fake_rtp); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 224 | EXPECT_EQ(observer.count(), 1); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 225 | |
| 226 | // State does not change, so we should not signal. |
| 227 | transport.SetRtcpMuxEnabled(true); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 228 | EXPECT_EQ(observer.count(), 1); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 229 | |
| 230 | // State changes, so we should signal. |
| 231 | transport.SetRtcpMuxEnabled(false); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 232 | EXPECT_EQ(observer.count(), 2); |
| 233 | } |
| 234 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 235 | // Test that SignalPacketReceived fires with rtcp=true when a RTCP packet is |
| 236 | // received. |
| 237 | TEST(RtpTransportTest, SignalDemuxedRtcp) { |
| 238 | RtpTransport transport(kMuxDisabled); |
| 239 | SignalPacketReceivedCounter observer(&transport); |
| 240 | rtc::FakePacketTransport fake_rtp("fake_rtp"); |
| 241 | fake_rtp.SetDestination(&fake_rtp, true); |
| 242 | transport.SetRtpPacketTransport(&fake_rtp); |
| 243 | |
| 244 | // An rtcp packet. |
| 245 | const char data[] = {0, 73, 0, 0}; |
| 246 | const int len = 4; |
| 247 | const rtc::PacketOptions options; |
| 248 | const int flags = 0; |
| 249 | fake_rtp.SendPacket(data, len, options, flags); |
| 250 | EXPECT_EQ(0, observer.rtp_count()); |
| 251 | EXPECT_EQ(1, observer.rtcp_count()); |
| 252 | } |
| 253 | |
| 254 | static const unsigned char kRtpData[] = {0x80, 0x11, 0, 0, 0, 0, |
| 255 | 0, 0, 0, 0, 0, 0}; |
| 256 | static const int kRtpLen = 12; |
| 257 | |
| 258 | // Test that SignalPacketReceived fires with rtcp=false when a RTP packet with a |
| 259 | // handled payload type is received. |
| 260 | TEST(RtpTransportTest, SignalHandledRtpPayloadType) { |
| 261 | RtpTransport transport(kMuxDisabled); |
| 262 | SignalPacketReceivedCounter observer(&transport); |
| 263 | rtc::FakePacketTransport fake_rtp("fake_rtp"); |
| 264 | fake_rtp.SetDestination(&fake_rtp, true); |
| 265 | transport.SetRtpPacketTransport(&fake_rtp); |
| 266 | transport.AddHandledPayloadType(0x11); |
| 267 | |
| 268 | // An rtp packet. |
| 269 | const rtc::PacketOptions options; |
| 270 | const int flags = 0; |
| 271 | rtc::Buffer rtp_data(kRtpData, kRtpLen); |
| 272 | fake_rtp.SendPacket(rtp_data.data<char>(), kRtpLen, options, flags); |
| 273 | EXPECT_EQ(1, observer.rtp_count()); |
| 274 | EXPECT_EQ(0, observer.rtcp_count()); |
| 275 | } |
| 276 | |
| 277 | // Test that SignalPacketReceived does not fire when a RTP packet with an |
| 278 | // unhandled payload type is received. |
| 279 | TEST(RtpTransportTest, DontSignalUnhandledRtpPayloadType) { |
| 280 | RtpTransport transport(kMuxDisabled); |
| 281 | SignalPacketReceivedCounter observer(&transport); |
| 282 | rtc::FakePacketTransport fake_rtp("fake_rtp"); |
| 283 | fake_rtp.SetDestination(&fake_rtp, true); |
| 284 | transport.SetRtpPacketTransport(&fake_rtp); |
| 285 | |
| 286 | const rtc::PacketOptions options; |
| 287 | const int flags = 0; |
| 288 | rtc::Buffer rtp_data(kRtpData, kRtpLen); |
| 289 | fake_rtp.SendPacket(rtp_data.data<char>(), kRtpLen, options, flags); |
| 290 | EXPECT_EQ(0, observer.rtp_count()); |
| 291 | EXPECT_EQ(0, observer.rtcp_count()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 292 | } |
| 293 | |
| 294 | } // namespace webrtc |