OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include <list> | 11 #include <list> |
12 #include <memory> | 12 #include <memory> |
13 | 13 |
14 #include "webrtc/base/checks.h" | 14 #include "webrtc/base/checks.h" |
15 #include "webrtc/modules/pacing/packet_router.h" | 15 #include "webrtc/modules/pacing/packet_router.h" |
16 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" | 16 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" |
17 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" | 17 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" |
18 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" | 18 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" |
19 #include "webrtc/test/gmock.h" | 19 #include "webrtc/test/gmock.h" |
20 #include "webrtc/test/gtest.h" | 20 #include "webrtc/test/gtest.h" |
21 | 21 |
22 using ::testing::_; | 22 using ::testing::_; |
23 using ::testing::AnyNumber; | 23 using ::testing::AnyNumber; |
| 24 using ::testing::Field; |
24 using ::testing::NiceMock; | 25 using ::testing::NiceMock; |
25 using ::testing::Return; | 26 using ::testing::Return; |
26 | 27 |
27 namespace webrtc { | 28 namespace webrtc { |
28 | 29 |
29 class PacketRouterTest : public ::testing::Test { | 30 class PacketRouterTest : public ::testing::Test { |
30 public: | 31 public: |
31 PacketRouterTest() : packet_router_(new PacketRouter()) {} | 32 PacketRouterTest() : packet_router_(new PacketRouter()) {} |
32 protected: | 33 protected: |
| 34 static const int kProbeMinProbes = 5; |
| 35 static const int kProbeMinBytes = 1000; |
33 const std::unique_ptr<PacketRouter> packet_router_; | 36 const std::unique_ptr<PacketRouter> packet_router_; |
34 }; | 37 }; |
35 | 38 |
36 TEST_F(PacketRouterTest, TimeToSendPacket) { | 39 TEST_F(PacketRouterTest, TimeToSendPacket) { |
37 MockRtpRtcp rtp_1; | 40 MockRtpRtcp rtp_1; |
38 MockRtpRtcp rtp_2; | 41 MockRtpRtcp rtp_2; |
39 packet_router_->AddRtpModule(&rtp_1); | 42 packet_router_->AddRtpModule(&rtp_1); |
40 packet_router_->AddRtpModule(&rtp_2); | 43 packet_router_->AddRtpModule(&rtp_2); |
41 | 44 |
42 const uint16_t kSsrc1 = 1234; | 45 const uint16_t kSsrc1 = 1234; |
43 uint16_t sequence_number = 17; | 46 uint16_t sequence_number = 17; |
44 uint64_t timestamp = 7890; | 47 uint64_t timestamp = 7890; |
45 bool retransmission = false; | 48 bool retransmission = false; |
46 | 49 |
47 // Send on the first module by letting rtp_1 be sending with correct ssrc. | 50 // Send on the first module by letting rtp_1 be sending with correct ssrc. |
48 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); | 51 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); |
49 EXPECT_CALL(rtp_1, SSRC()).Times(1).WillOnce(Return(kSsrc1)); | 52 EXPECT_CALL(rtp_1, SSRC()).Times(1).WillOnce(Return(kSsrc1)); |
50 EXPECT_CALL(rtp_1, TimeToSendPacket(kSsrc1, sequence_number, timestamp, | 53 EXPECT_CALL(rtp_1, TimeToSendPacket( |
51 retransmission, 1)) | 54 kSsrc1, sequence_number, timestamp, retransmission, |
| 55 Field(&PacedPacketInfo::probe_cluster_id, 1))) |
52 .Times(1) | 56 .Times(1) |
53 .WillOnce(Return(true)); | 57 .WillOnce(Return(true)); |
54 EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0); | 58 EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0); |
55 EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number, | 59 EXPECT_TRUE(packet_router_->TimeToSendPacket( |
56 timestamp, retransmission, 1)); | 60 kSsrc1, sequence_number, timestamp, retransmission, |
| 61 PacedPacketInfo(1, kProbeMinProbes, kProbeMinBytes))); |
57 | 62 |
58 // Send on the second module by letting rtp_2 be sending, but not rtp_1. | 63 // Send on the second module by letting rtp_2 be sending, but not rtp_1. |
59 ++sequence_number; | 64 ++sequence_number; |
60 timestamp += 30; | 65 timestamp += 30; |
61 retransmission = true; | 66 retransmission = true; |
62 const uint16_t kSsrc2 = 4567; | 67 const uint16_t kSsrc2 = 4567; |
63 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); | 68 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); |
64 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); | 69 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); |
65 EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2)); | 70 EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2)); |
66 EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0); | 71 EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0); |
67 EXPECT_CALL(rtp_2, TimeToSendPacket(kSsrc2, sequence_number, timestamp, | 72 EXPECT_CALL(rtp_2, TimeToSendPacket( |
68 retransmission, 2)) | 73 kSsrc2, sequence_number, timestamp, retransmission, |
| 74 Field(&PacedPacketInfo::probe_cluster_id, 2))) |
69 .Times(1) | 75 .Times(1) |
70 .WillOnce(Return(true)); | 76 .WillOnce(Return(true)); |
71 EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc2, sequence_number, | 77 EXPECT_TRUE(packet_router_->TimeToSendPacket( |
72 timestamp, retransmission, 2)); | 78 kSsrc2, sequence_number, timestamp, retransmission, |
| 79 PacedPacketInfo(2, kProbeMinProbes, kProbeMinBytes))); |
73 | 80 |
74 // No module is sending, hence no packet should be sent. | 81 // No module is sending, hence no packet should be sent. |
75 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); | 82 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); |
76 EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0); | 83 EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0); |
77 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false)); | 84 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false)); |
78 EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0); | 85 EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0); |
79 EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number, | 86 EXPECT_TRUE(packet_router_->TimeToSendPacket( |
80 timestamp, retransmission, 1)); | 87 kSsrc1, sequence_number, timestamp, retransmission, |
| 88 PacedPacketInfo(1, kProbeMinProbes, kProbeMinBytes))); |
81 | 89 |
82 // Add a packet with incorrect ssrc and test it's dropped in the router. | 90 // Add a packet with incorrect ssrc and test it's dropped in the router. |
83 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); | 91 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); |
84 EXPECT_CALL(rtp_1, SSRC()).Times(1).WillOnce(Return(kSsrc1)); | 92 EXPECT_CALL(rtp_1, SSRC()).Times(1).WillOnce(Return(kSsrc1)); |
85 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); | 93 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); |
86 EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2)); | 94 EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2)); |
87 EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0); | 95 EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0); |
88 EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0); | 96 EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0); |
89 EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1 + kSsrc2, sequence_number, | 97 EXPECT_TRUE(packet_router_->TimeToSendPacket( |
90 timestamp, retransmission, 1)); | 98 kSsrc1 + kSsrc2, sequence_number, timestamp, retransmission, |
| 99 PacedPacketInfo(1, kProbeMinProbes, kProbeMinBytes))); |
91 | 100 |
92 packet_router_->RemoveRtpModule(&rtp_1); | 101 packet_router_->RemoveRtpModule(&rtp_1); |
93 | 102 |
94 // rtp_1 has been removed, try sending a packet on that ssrc and make sure | 103 // rtp_1 has been removed, try sending a packet on that ssrc and make sure |
95 // it is dropped as expected by not expecting any calls to rtp_1. | 104 // it is dropped as expected by not expecting any calls to rtp_1. |
96 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); | 105 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); |
97 EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2)); | 106 EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2)); |
98 EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0); | 107 EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0); |
99 EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number, | 108 EXPECT_TRUE(packet_router_->TimeToSendPacket( |
100 timestamp, retransmission, | 109 kSsrc1, sequence_number, timestamp, retransmission, |
101 PacketInfo::kNotAProbe)); | 110 PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes, |
| 111 kProbeMinBytes))); |
102 | 112 |
103 packet_router_->RemoveRtpModule(&rtp_2); | 113 packet_router_->RemoveRtpModule(&rtp_2); |
104 } | 114 } |
105 | 115 |
106 TEST_F(PacketRouterTest, TimeToSendPadding) { | 116 TEST_F(PacketRouterTest, TimeToSendPadding) { |
107 const uint16_t kSsrc1 = 1234; | 117 const uint16_t kSsrc1 = 1234; |
108 const uint16_t kSsrc2 = 4567; | 118 const uint16_t kSsrc2 = 4567; |
109 | 119 |
110 MockRtpRtcp rtp_1; | 120 MockRtpRtcp rtp_1; |
111 EXPECT_CALL(rtp_1, RtxSendStatus()).WillOnce(Return(kRtxOff)); | 121 EXPECT_CALL(rtp_1, RtxSendStatus()).WillOnce(Return(kRtxOff)); |
112 EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1)); | 122 EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1)); |
113 MockRtpRtcp rtp_2; | 123 MockRtpRtcp rtp_2; |
114 // rtp_2 will be prioritized for padding. | 124 // rtp_2 will be prioritized for padding. |
115 EXPECT_CALL(rtp_2, RtxSendStatus()).WillOnce(Return(kRtxRedundantPayloads)); | 125 EXPECT_CALL(rtp_2, RtxSendStatus()).WillOnce(Return(kRtxRedundantPayloads)); |
116 EXPECT_CALL(rtp_2, SSRC()).WillRepeatedly(Return(kSsrc2)); | 126 EXPECT_CALL(rtp_2, SSRC()).WillRepeatedly(Return(kSsrc2)); |
117 packet_router_->AddRtpModule(&rtp_1); | 127 packet_router_->AddRtpModule(&rtp_1); |
118 packet_router_->AddRtpModule(&rtp_2); | 128 packet_router_->AddRtpModule(&rtp_2); |
119 | 129 |
120 // Default configuration, sending padding on all modules sending media, | 130 // Default configuration, sending padding on all modules sending media, |
121 // ordered by priority (based on rtx mode). | 131 // ordered by priority (based on rtx mode). |
122 const size_t requested_padding_bytes = 1000; | 132 const size_t requested_padding_bytes = 1000; |
123 const size_t sent_padding_bytes = 890; | 133 const size_t sent_padding_bytes = 890; |
124 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); | 134 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); |
125 EXPECT_CALL(rtp_2, HasBweExtensions()).Times(1).WillOnce(Return(true)); | 135 EXPECT_CALL(rtp_2, HasBweExtensions()).Times(1).WillOnce(Return(true)); |
126 EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes, 111)) | 136 EXPECT_CALL(rtp_2, |
| 137 TimeToSendPadding(requested_padding_bytes, |
| 138 Field(&PacedPacketInfo::probe_cluster_id, 111))) |
127 .Times(1) | 139 .Times(1) |
128 .WillOnce(Return(sent_padding_bytes)); | 140 .WillOnce(Return(sent_padding_bytes)); |
129 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); | 141 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); |
130 EXPECT_CALL(rtp_1, HasBweExtensions()).Times(1).WillOnce(Return(true)); | 142 EXPECT_CALL(rtp_1, HasBweExtensions()).Times(1).WillOnce(Return(true)); |
131 EXPECT_CALL(rtp_1, TimeToSendPadding( | 143 EXPECT_CALL(rtp_1, |
132 requested_padding_bytes - sent_padding_bytes, 111)) | 144 TimeToSendPadding(requested_padding_bytes - sent_padding_bytes, |
| 145 Field(&PacedPacketInfo::probe_cluster_id, 111))) |
133 .Times(1) | 146 .Times(1) |
134 .WillOnce(Return(requested_padding_bytes - sent_padding_bytes)); | 147 .WillOnce(Return(requested_padding_bytes - sent_padding_bytes)); |
135 EXPECT_EQ(requested_padding_bytes, | 148 EXPECT_EQ(requested_padding_bytes, |
136 packet_router_->TimeToSendPadding(requested_padding_bytes, 111)); | 149 packet_router_->TimeToSendPadding( |
| 150 requested_padding_bytes, |
| 151 PacedPacketInfo(111, kProbeMinBytes, kProbeMinBytes))); |
137 | 152 |
138 // Let only the lower priority module be sending and verify the padding | 153 // Let only the lower priority module be sending and verify the padding |
139 // request is routed there. | 154 // request is routed there. |
140 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false)); | 155 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false)); |
141 EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes, _)).Times(0); | 156 EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes, _)).Times(0); |
142 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); | 157 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); |
143 EXPECT_CALL(rtp_1, HasBweExtensions()).Times(1).WillOnce(Return(true)); | 158 EXPECT_CALL(rtp_1, HasBweExtensions()).Times(1).WillOnce(Return(true)); |
144 EXPECT_CALL(rtp_1, TimeToSendPadding(_, _)) | 159 EXPECT_CALL(rtp_1, TimeToSendPadding(_, _)) |
145 .Times(1) | 160 .Times(1) |
146 .WillOnce(Return(sent_padding_bytes)); | 161 .WillOnce(Return(sent_padding_bytes)); |
147 EXPECT_EQ(sent_padding_bytes, | 162 EXPECT_EQ(sent_padding_bytes, |
148 packet_router_->TimeToSendPadding(requested_padding_bytes, | 163 packet_router_->TimeToSendPadding( |
149 PacketInfo::kNotAProbe)); | 164 requested_padding_bytes, |
| 165 PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes, |
| 166 kProbeMinBytes))); |
150 | 167 |
151 // No sending module at all. | 168 // No sending module at all. |
152 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); | 169 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); |
153 EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes, _)).Times(0); | 170 EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes, _)).Times(0); |
154 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false)); | 171 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false)); |
155 EXPECT_CALL(rtp_2, TimeToSendPadding(_, _)).Times(0); | 172 EXPECT_CALL(rtp_2, TimeToSendPadding(_, _)).Times(0); |
156 EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes, | 173 EXPECT_EQ(0u, |
157 PacketInfo::kNotAProbe)); | 174 packet_router_->TimeToSendPadding( |
| 175 requested_padding_bytes, |
| 176 PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes, |
| 177 kProbeMinBytes))); |
158 | 178 |
159 // Only one module has BWE extensions. | 179 // Only one module has BWE extensions. |
160 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); | 180 EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); |
161 EXPECT_CALL(rtp_1, HasBweExtensions()).Times(1).WillOnce(Return(false)); | 181 EXPECT_CALL(rtp_1, HasBweExtensions()).Times(1).WillOnce(Return(false)); |
162 EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes, _)).Times(0); | 182 EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes, _)).Times(0); |
163 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); | 183 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); |
164 EXPECT_CALL(rtp_2, HasBweExtensions()).Times(1).WillOnce(Return(true)); | 184 EXPECT_CALL(rtp_2, HasBweExtensions()).Times(1).WillOnce(Return(true)); |
165 EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes, _)) | 185 EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes, _)) |
166 .Times(1) | 186 .Times(1) |
167 .WillOnce(Return(sent_padding_bytes)); | 187 .WillOnce(Return(sent_padding_bytes)); |
168 EXPECT_EQ(sent_padding_bytes, | 188 EXPECT_EQ(sent_padding_bytes, |
169 packet_router_->TimeToSendPadding(requested_padding_bytes, | 189 packet_router_->TimeToSendPadding( |
170 PacketInfo::kNotAProbe)); | 190 requested_padding_bytes, |
| 191 PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes, |
| 192 kProbeMinBytes))); |
171 | 193 |
172 packet_router_->RemoveRtpModule(&rtp_1); | 194 packet_router_->RemoveRtpModule(&rtp_1); |
173 | 195 |
174 // rtp_1 has been removed, try sending padding and make sure rtp_1 isn't asked | 196 // rtp_1 has been removed, try sending padding and make sure rtp_1 isn't asked |
175 // to send by not expecting any calls. Instead verify rtp_2 is called. | 197 // to send by not expecting any calls. Instead verify rtp_2 is called. |
176 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); | 198 EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); |
177 EXPECT_CALL(rtp_2, HasBweExtensions()).Times(1).WillOnce(Return(true)); | 199 EXPECT_CALL(rtp_2, HasBweExtensions()).Times(1).WillOnce(Return(true)); |
178 EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes, _)).Times(1); | 200 EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes, _)).Times(1); |
179 EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes, | 201 EXPECT_EQ(0u, |
180 PacketInfo::kNotAProbe)); | 202 packet_router_->TimeToSendPadding( |
| 203 requested_padding_bytes, |
| 204 PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes, |
| 205 kProbeMinBytes))); |
181 | 206 |
182 packet_router_->RemoveRtpModule(&rtp_2); | 207 packet_router_->RemoveRtpModule(&rtp_2); |
183 } | 208 } |
184 | 209 |
185 TEST_F(PacketRouterTest, SenderOnlyFunctionsRespectSendingMedia) { | 210 TEST_F(PacketRouterTest, SenderOnlyFunctionsRespectSendingMedia) { |
186 MockRtpRtcp rtp; | 211 MockRtpRtcp rtp; |
187 packet_router_->AddRtpModule(&rtp); | 212 packet_router_->AddRtpModule(&rtp); |
188 static const uint16_t kSsrc = 1234; | 213 static const uint16_t kSsrc = 1234; |
189 EXPECT_CALL(rtp, SSRC()).WillRepeatedly(Return(kSsrc)); | 214 EXPECT_CALL(rtp, SSRC()).WillRepeatedly(Return(kSsrc)); |
190 EXPECT_CALL(rtp, SendingMedia()).WillRepeatedly(Return(false)); | 215 EXPECT_CALL(rtp, SendingMedia()).WillRepeatedly(Return(false)); |
191 | 216 |
192 // Verify that TimeToSendPacket does not end up in a receiver. | 217 // Verify that TimeToSendPacket does not end up in a receiver. |
193 EXPECT_CALL(rtp, TimeToSendPacket(_, _, _, _, _)).Times(0); | 218 EXPECT_CALL(rtp, TimeToSendPacket(_, _, _, _, _)).Times(0); |
194 EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc, 1, 1, false, | 219 EXPECT_TRUE(packet_router_->TimeToSendPacket( |
195 PacketInfo::kNotAProbe)); | 220 kSsrc, 1, 1, false, PacedPacketInfo(PacedPacketInfo::kNotAProbe, |
| 221 kProbeMinBytes, kProbeMinBytes))); |
196 // Verify that TimeToSendPadding does not end up in a receiver. | 222 // Verify that TimeToSendPadding does not end up in a receiver. |
197 EXPECT_CALL(rtp, TimeToSendPadding(_, _)).Times(0); | 223 EXPECT_CALL(rtp, TimeToSendPadding(_, _)).Times(0); |
198 EXPECT_EQ(0u, packet_router_->TimeToSendPadding(200, PacketInfo::kNotAProbe)); | 224 EXPECT_EQ(0u, |
| 225 packet_router_->TimeToSendPadding( |
| 226 200, PacedPacketInfo(PacedPacketInfo::kNotAProbe, |
| 227 kProbeMinBytes, kProbeMinBytes))); |
199 | 228 |
200 packet_router_->RemoveRtpModule(&rtp); | 229 packet_router_->RemoveRtpModule(&rtp); |
201 } | 230 } |
202 | 231 |
203 TEST_F(PacketRouterTest, AllocateSequenceNumbers) { | 232 TEST_F(PacketRouterTest, AllocateSequenceNumbers) { |
204 const uint16_t kStartSeq = 0xFFF0; | 233 const uint16_t kStartSeq = 0xFFF0; |
205 const size_t kNumPackets = 32; | 234 const size_t kNumPackets = 32; |
206 | 235 |
207 packet_router_->SetTransportWideSequenceNumber(kStartSeq - 1); | 236 packet_router_->SetTransportWideSequenceNumber(kStartSeq - 1); |
208 | 237 |
(...skipping 12 matching lines...) Expand all Loading... |
221 | 250 |
222 rtcp::TransportFeedback feedback; | 251 rtcp::TransportFeedback feedback; |
223 EXPECT_CALL(rtp_1, SendFeedbackPacket(_)).Times(1); | 252 EXPECT_CALL(rtp_1, SendFeedbackPacket(_)).Times(1); |
224 packet_router_->SendFeedback(&feedback); | 253 packet_router_->SendFeedback(&feedback); |
225 packet_router_->RemoveRtpModule(&rtp_1); | 254 packet_router_->RemoveRtpModule(&rtp_1); |
226 EXPECT_CALL(rtp_2, SendFeedbackPacket(_)).Times(1); | 255 EXPECT_CALL(rtp_2, SendFeedbackPacket(_)).Times(1); |
227 packet_router_->SendFeedback(&feedback); | 256 packet_router_->SendFeedback(&feedback); |
228 packet_router_->RemoveRtpModule(&rtp_2); | 257 packet_router_->RemoveRtpModule(&rtp_2); |
229 } | 258 } |
230 } // namespace webrtc | 259 } // namespace webrtc |
OLD | NEW |