OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <stddef.h> | 5 #include <stddef.h> |
6 #include <stdint.h> | 6 #include <stdint.h> |
7 | 7 |
8 #include "base/macros.h" | 8 #include "base/macros.h" |
9 #include "base/memory/scoped_ptr.h" | 9 #include "base/memory/scoped_ptr.h" |
10 #include "base/test/simple_test_tick_clock.h" | 10 #include "base/test/simple_test_tick_clock.h" |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
75 }; | 75 }; |
76 | 76 |
77 TEST_F(RtcpBuilderTest, RtcpReceiverReport) { | 77 TEST_F(RtcpBuilderTest, RtcpReceiverReport) { |
78 // Receiver report with report block. | 78 // Receiver report with report block. |
79 TestRtcpPacketBuilder p2; | 79 TestRtcpPacketBuilder p2; |
80 p2.AddRr(kSendingSsrc, 1); | 80 p2.AddRr(kSendingSsrc, 1); |
81 p2.AddRb(kMediaSsrc); | 81 p2.AddRb(kMediaSsrc); |
82 | 82 |
83 RtcpReportBlock report_block = GetReportBlock(); | 83 RtcpReportBlock report_block = GetReportBlock(); |
84 | 84 |
85 ExpectPacketEQ(p2.GetPacket(), | 85 ExpectPacketEQ(p2.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver( |
86 rtcp_builder_->BuildRtcpFromReceiver(&report_block, NULL, NULL, | 86 &report_block, nullptr, nullptr, nullptr, |
87 NULL, kDefaultDelay)); | 87 nullptr, kDefaultDelay)); |
88 } | 88 } |
89 | 89 |
90 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtr) { | 90 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtr) { |
91 // Receiver report with report block. | 91 // Receiver report with report block. |
92 TestRtcpPacketBuilder p; | 92 TestRtcpPacketBuilder p; |
93 p.AddRr(kSendingSsrc, 1); | 93 p.AddRr(kSendingSsrc, 1); |
94 p.AddRb(kMediaSsrc); | 94 p.AddRb(kMediaSsrc); |
95 p.AddXrHeader(kSendingSsrc); | 95 p.AddXrHeader(kSendingSsrc); |
96 p.AddXrRrtrBlock(); | 96 p.AddXrRrtrBlock(); |
97 | 97 |
98 RtcpReportBlock report_block = GetReportBlock(); | 98 RtcpReportBlock report_block = GetReportBlock(); |
99 | 99 |
100 RtcpReceiverReferenceTimeReport rrtr; | 100 RtcpReceiverReferenceTimeReport rrtr; |
101 rrtr.ntp_seconds = kNtpHigh; | 101 rrtr.ntp_seconds = kNtpHigh; |
102 rrtr.ntp_fraction = kNtpLow; | 102 rrtr.ntp_fraction = kNtpLow; |
103 | 103 |
104 ExpectPacketEQ(p.GetPacket(), | 104 ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver( |
105 rtcp_builder_->BuildRtcpFromReceiver( | 105 &report_block, &rrtr, nullptr, nullptr, |
106 &report_block, &rrtr, NULL, NULL, kDefaultDelay)); | 106 nullptr, kDefaultDelay)); |
107 } | 107 } |
108 | 108 |
109 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithCast) { | 109 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithCast) { |
110 // Receiver report with report block. | 110 // Receiver report with report block. |
111 TestRtcpPacketBuilder p; | 111 TestRtcpPacketBuilder p; |
112 p.AddRr(kSendingSsrc, 1); | 112 p.AddRr(kSendingSsrc, 1); |
113 p.AddRb(kMediaSsrc); | 113 p.AddRb(kMediaSsrc); |
114 p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay); | 114 p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay); |
115 | 115 |
116 RtcpReportBlock report_block = GetReportBlock(); | 116 RtcpReportBlock report_block = GetReportBlock(); |
117 | 117 |
118 RtcpCastMessage cast_message(kMediaSsrc); | 118 RtcpCastMessage cast_message(kMediaSsrc); |
119 cast_message.ack_frame_id = kAckFrameId; | 119 cast_message.ack_frame_id = kAckFrameId; |
120 PacketIdSet missing_packets; | 120 PacketIdSet missing_packets; |
121 cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets; | 121 cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets; |
122 | 122 |
123 missing_packets.insert(kLostPacketId1); | 123 missing_packets.insert(kLostPacketId1); |
124 missing_packets.insert(kLostPacketId2); | 124 missing_packets.insert(kLostPacketId2); |
125 missing_packets.insert(kLostPacketId3); | 125 missing_packets.insert(kLostPacketId3); |
126 cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] = | 126 cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] = |
127 missing_packets; | 127 missing_packets; |
128 | 128 |
129 ExpectPacketEQ(p.GetPacket(), | 129 ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver( |
130 rtcp_builder_->BuildRtcpFromReceiver( | 130 &report_block, nullptr, &cast_message, |
131 &report_block, NULL, &cast_message, NULL, kDefaultDelay)); | 131 nullptr, nullptr, kDefaultDelay)); |
132 } | 132 } |
133 | 133 |
134 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtraAndCastMessage) { | 134 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtraAndCastMessage) { |
135 TestRtcpPacketBuilder p; | 135 TestRtcpPacketBuilder p; |
136 p.AddRr(kSendingSsrc, 1); | 136 p.AddRr(kSendingSsrc, 1); |
137 p.AddRb(kMediaSsrc); | 137 p.AddRb(kMediaSsrc); |
138 p.AddXrHeader(kSendingSsrc); | 138 p.AddXrHeader(kSendingSsrc); |
139 p.AddXrRrtrBlock(); | 139 p.AddXrRrtrBlock(); |
140 p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay); | 140 p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay); |
141 | 141 |
142 RtcpReportBlock report_block = GetReportBlock(); | 142 RtcpReportBlock report_block = GetReportBlock(); |
143 | 143 |
144 RtcpReceiverReferenceTimeReport rrtr; | 144 RtcpReceiverReferenceTimeReport rrtr; |
145 rrtr.ntp_seconds = kNtpHigh; | 145 rrtr.ntp_seconds = kNtpHigh; |
146 rrtr.ntp_fraction = kNtpLow; | 146 rrtr.ntp_fraction = kNtpLow; |
147 | 147 |
148 RtcpCastMessage cast_message(kMediaSsrc); | 148 RtcpCastMessage cast_message(kMediaSsrc); |
149 cast_message.ack_frame_id = kAckFrameId; | 149 cast_message.ack_frame_id = kAckFrameId; |
150 PacketIdSet missing_packets; | 150 PacketIdSet missing_packets; |
151 cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets; | 151 cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets; |
152 | 152 |
153 missing_packets.insert(kLostPacketId1); | 153 missing_packets.insert(kLostPacketId1); |
154 missing_packets.insert(kLostPacketId2); | 154 missing_packets.insert(kLostPacketId2); |
155 missing_packets.insert(kLostPacketId3); | 155 missing_packets.insert(kLostPacketId3); |
156 cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] = | 156 cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] = |
157 missing_packets; | 157 missing_packets; |
158 | 158 |
159 ExpectPacketEQ(p.GetPacket(), | 159 ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver( |
160 rtcp_builder_->BuildRtcpFromReceiver( | 160 &report_block, &rrtr, &cast_message, |
161 &report_block, &rrtr, &cast_message, NULL, kDefaultDelay)); | 161 nullptr, nullptr, kDefaultDelay)); |
162 } | 162 } |
163 | 163 |
164 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) { | 164 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) { |
165 static const uint32_t kTimeBaseMs = 12345678; | 165 static const uint32_t kTimeBaseMs = 12345678; |
166 static const uint32_t kTimeDelayMs = 10; | 166 static const uint32_t kTimeDelayMs = 10; |
167 | 167 |
168 TestRtcpPacketBuilder p; | 168 TestRtcpPacketBuilder p; |
169 p.AddRr(kSendingSsrc, 1); | 169 p.AddRr(kSendingSsrc, 1); |
170 p.AddRb(kMediaSsrc); | 170 p.AddRb(kMediaSsrc); |
171 p.AddXrHeader(kSendingSsrc); | 171 p.AddXrHeader(kSendingSsrc); |
(...skipping 15 matching lines...) Expand all Loading... |
187 missing_packets.insert(kLostPacketId2); | 187 missing_packets.insert(kLostPacketId2); |
188 missing_packets.insert(kLostPacketId3); | 188 missing_packets.insert(kLostPacketId3); |
189 cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] = | 189 cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] = |
190 missing_packets; | 190 missing_packets; |
191 | 191 |
192 ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); | 192 ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); |
193 ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events; | 193 ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events; |
194 | 194 |
195 ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver( | 195 ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver( |
196 &report_block, &rrtr, &cast_message, | 196 &report_block, &rrtr, &cast_message, |
197 &rtcp_events, kDefaultDelay)); | 197 nullptr, &rtcp_events, kDefaultDelay)); |
198 | 198 |
199 base::SimpleTestTickClock testing_clock; | 199 base::SimpleTestTickClock testing_clock; |
200 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); | 200 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); |
201 | 201 |
202 p.AddReceiverLog(kSendingSsrc); | 202 p.AddReceiverLog(kSendingSsrc); |
203 p.AddReceiverFrameLog(test_rtp_timestamp().lower_32_bits(), 2, kTimeBaseMs); | 203 p.AddReceiverFrameLog(test_rtp_timestamp().lower_32_bits(), 2, kTimeBaseMs); |
204 p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); | 204 p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); |
205 p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs); | 205 p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs); |
206 | 206 |
207 FrameEvent frame_event; | 207 FrameEvent frame_event; |
208 frame_event.rtp_timestamp = test_rtp_timestamp(); | 208 frame_event.rtp_timestamp = test_rtp_timestamp(); |
209 frame_event.type = FRAME_ACK_SENT; | 209 frame_event.type = FRAME_ACK_SENT; |
210 frame_event.media_type = VIDEO_EVENT; | 210 frame_event.media_type = VIDEO_EVENT; |
211 frame_event.timestamp = testing_clock.NowTicks(); | 211 frame_event.timestamp = testing_clock.NowTicks(); |
212 event_subscriber.OnReceiveFrameEvent(frame_event); | 212 event_subscriber.OnReceiveFrameEvent(frame_event); |
213 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); | 213 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); |
214 | 214 |
215 PacketEvent packet_event; | 215 PacketEvent packet_event; |
216 packet_event.rtp_timestamp = test_rtp_timestamp(); | 216 packet_event.rtp_timestamp = test_rtp_timestamp(); |
217 packet_event.type = PACKET_RECEIVED; | 217 packet_event.type = PACKET_RECEIVED; |
218 packet_event.media_type = VIDEO_EVENT; | 218 packet_event.media_type = VIDEO_EVENT; |
219 packet_event.timestamp = testing_clock.NowTicks(); | 219 packet_event.timestamp = testing_clock.NowTicks(); |
220 packet_event.packet_id = kLostPacketId1; | 220 packet_event.packet_id = kLostPacketId1; |
221 event_subscriber.OnReceivePacketEvent(packet_event); | 221 event_subscriber.OnReceivePacketEvent(packet_event); |
222 event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events); | 222 event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events); |
223 EXPECT_EQ(2u, rtcp_events.size()); | 223 EXPECT_EQ(2u, rtcp_events.size()); |
224 | 224 |
225 ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver( | 225 ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver( |
226 &report_block, &rrtr, &cast_message, | 226 &report_block, &rrtr, &cast_message, |
227 &rtcp_events, kDefaultDelay)); | 227 nullptr, &rtcp_events, kDefaultDelay)); |
228 } | 228 } |
229 | 229 |
230 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOversizedFrameLog) { | 230 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOversizedFrameLog) { |
231 static const uint32_t kTimeBaseMs = 12345678; | 231 static const uint32_t kTimeBaseMs = 12345678; |
232 static const uint32_t kTimeDelayMs = 10; | 232 static const uint32_t kTimeDelayMs = 10; |
233 | 233 |
234 TestRtcpPacketBuilder p; | 234 TestRtcpPacketBuilder p; |
235 p.AddRr(kSendingSsrc, 1); | 235 p.AddRr(kSendingSsrc, 1); |
236 p.AddRb(kMediaSsrc); | 236 p.AddRb(kMediaSsrc); |
237 | 237 |
(...skipping 27 matching lines...) Expand all Loading... |
265 packet_event.media_type = VIDEO_EVENT; | 265 packet_event.media_type = VIDEO_EVENT; |
266 packet_event.timestamp = testing_clock.NowTicks(); | 266 packet_event.timestamp = testing_clock.NowTicks(); |
267 packet_event.packet_id = kLostPacketId1; | 267 packet_event.packet_id = kLostPacketId1; |
268 event_subscriber.OnReceivePacketEvent(packet_event); | 268 event_subscriber.OnReceivePacketEvent(packet_event); |
269 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); | 269 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); |
270 } | 270 } |
271 | 271 |
272 ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events; | 272 ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events; |
273 event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events); | 273 event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events); |
274 | 274 |
275 ExpectPacketEQ(p.GetPacket(), | 275 ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver( |
276 rtcp_builder_->BuildRtcpFromReceiver( | 276 &report_block, nullptr, nullptr, nullptr, |
277 &report_block, NULL, NULL, &rtcp_events, kDefaultDelay)); | 277 &rtcp_events, kDefaultDelay)); |
278 } | 278 } |
279 | 279 |
280 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithTooManyLogFrames) { | 280 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithTooManyLogFrames) { |
281 static const uint32_t kTimeBaseMs = 12345678; | 281 static const uint32_t kTimeBaseMs = 12345678; |
282 static const uint32_t kTimeDelayMs = 10; | 282 static const uint32_t kTimeDelayMs = 10; |
283 | 283 |
284 TestRtcpPacketBuilder p; | 284 TestRtcpPacketBuilder p; |
285 p.AddRr(kSendingSsrc, 1); | 285 p.AddRr(kSendingSsrc, 1); |
286 p.AddRb(kMediaSsrc); | 286 p.AddRb(kMediaSsrc); |
287 | 287 |
(...skipping 22 matching lines...) Expand all Loading... |
310 frame_event.type = FRAME_ACK_SENT; | 310 frame_event.type = FRAME_ACK_SENT; |
311 frame_event.media_type = VIDEO_EVENT; | 311 frame_event.media_type = VIDEO_EVENT; |
312 frame_event.timestamp = testing_clock.NowTicks(); | 312 frame_event.timestamp = testing_clock.NowTicks(); |
313 event_subscriber.OnReceiveFrameEvent(frame_event); | 313 event_subscriber.OnReceiveFrameEvent(frame_event); |
314 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); | 314 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); |
315 } | 315 } |
316 | 316 |
317 ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events; | 317 ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events; |
318 event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events); | 318 event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events); |
319 | 319 |
320 ExpectPacketEQ(p.GetPacket(), | 320 ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver( |
321 rtcp_builder_->BuildRtcpFromReceiver( | 321 &report_block, nullptr, nullptr, nullptr, |
322 &report_block, NULL, NULL, &rtcp_events, kDefaultDelay)); | 322 &rtcp_events, kDefaultDelay)); |
323 } | 323 } |
324 | 324 |
325 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOldLogFrames) { | 325 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOldLogFrames) { |
326 static const uint32_t kTimeBaseMs = 12345678; | 326 static const uint32_t kTimeBaseMs = 12345678; |
327 | 327 |
328 TestRtcpPacketBuilder p; | 328 TestRtcpPacketBuilder p; |
329 p.AddRr(kSendingSsrc, 1); | 329 p.AddRr(kSendingSsrc, 1); |
330 p.AddRb(kMediaSsrc); | 330 p.AddRb(kMediaSsrc); |
331 | 331 |
332 RtcpReportBlock report_block = GetReportBlock(); | 332 RtcpReportBlock report_block = GetReportBlock(); |
(...skipping 21 matching lines...) Expand all Loading... |
354 frame_event.media_type = VIDEO_EVENT; | 354 frame_event.media_type = VIDEO_EVENT; |
355 frame_event.timestamp = testing_clock.NowTicks(); | 355 frame_event.timestamp = testing_clock.NowTicks(); |
356 event_subscriber.OnReceiveFrameEvent(frame_event); | 356 event_subscriber.OnReceiveFrameEvent(frame_event); |
357 testing_clock.Advance( | 357 testing_clock.Advance( |
358 base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs)); | 358 base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs)); |
359 } | 359 } |
360 | 360 |
361 ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events; | 361 ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events; |
362 event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events); | 362 event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events); |
363 | 363 |
364 ExpectPacketEQ(p.GetPacket(), | 364 ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver( |
365 rtcp_builder_->BuildRtcpFromReceiver( | 365 &report_block, nullptr, nullptr, nullptr, |
366 &report_block, NULL, NULL, &rtcp_events, kDefaultDelay)); | 366 &rtcp_events, kDefaultDelay)); |
367 } | 367 } |
368 | 368 |
369 TEST_F(RtcpBuilderTest, RtcpReceiverReportRedundancy) { | 369 TEST_F(RtcpBuilderTest, RtcpReceiverReportRedundancy) { |
370 uint32_t time_base_ms = 12345678; | 370 uint32_t time_base_ms = 12345678; |
371 int kTimeBetweenEventsMs = 10; | 371 int kTimeBetweenEventsMs = 10; |
372 | 372 |
373 RtcpReportBlock report_block = GetReportBlock(); | 373 RtcpReportBlock report_block = GetReportBlock(); |
374 | 374 |
375 base::SimpleTestTickClock testing_clock; | 375 base::SimpleTestTickClock testing_clock; |
376 testing_clock.Advance(base::TimeDelta::FromMilliseconds(time_base_ms)); | 376 testing_clock.Advance(base::TimeDelta::FromMilliseconds(time_base_ms)); |
(...skipping 21 matching lines...) Expand all Loading... |
398 FrameEvent frame_event; | 398 FrameEvent frame_event; |
399 frame_event.rtp_timestamp = test_rtp_timestamp(); | 399 frame_event.rtp_timestamp = test_rtp_timestamp(); |
400 frame_event.type = FRAME_ACK_SENT; | 400 frame_event.type = FRAME_ACK_SENT; |
401 frame_event.media_type = VIDEO_EVENT; | 401 frame_event.media_type = VIDEO_EVENT; |
402 frame_event.timestamp = testing_clock.NowTicks(); | 402 frame_event.timestamp = testing_clock.NowTicks(); |
403 event_subscriber.OnReceiveFrameEvent(frame_event); | 403 event_subscriber.OnReceiveFrameEvent(frame_event); |
404 | 404 |
405 ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events; | 405 ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events; |
406 event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events); | 406 event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events); |
407 | 407 |
408 ExpectPacketEQ(p.GetPacket(), | 408 ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver( |
409 rtcp_builder_->BuildRtcpFromReceiver( | 409 &report_block, nullptr, nullptr, nullptr, |
410 &report_block, NULL, NULL, &rtcp_events, kDefaultDelay)); | 410 &rtcp_events, kDefaultDelay)); |
411 | 411 |
412 testing_clock.Advance( | 412 testing_clock.Advance( |
413 base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs)); | 413 base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs)); |
414 time_base_ms += kTimeBetweenEventsMs; | 414 time_base_ms += kTimeBetweenEventsMs; |
415 } | 415 } |
416 } | 416 } |
417 | 417 |
418 TEST_F(RtcpBuilderTest, RtcpSenderReport) { | 418 TEST_F(RtcpBuilderTest, RtcpSenderReport) { |
419 RtcpSenderInfo sender_info; | 419 RtcpSenderInfo sender_info; |
420 sender_info.ntp_seconds = kNtpHigh; | 420 sender_info.ntp_seconds = kNtpHigh; |
421 sender_info.ntp_fraction = kNtpLow; | 421 sender_info.ntp_fraction = kNtpLow; |
422 sender_info.rtp_timestamp = test_rtp_timestamp(); | 422 sender_info.rtp_timestamp = test_rtp_timestamp(); |
423 sender_info.send_packet_count = kSendPacketCount; | 423 sender_info.send_packet_count = kSendPacketCount; |
424 sender_info.send_octet_count = kSendOctetCount; | 424 sender_info.send_octet_count = kSendOctetCount; |
425 | 425 |
426 // Sender report. | 426 // Sender report. |
427 TestRtcpPacketBuilder p; | 427 TestRtcpPacketBuilder p; |
428 p.AddSr(kSendingSsrc, 0); | 428 p.AddSr(kSendingSsrc, 0); |
429 | 429 |
430 ExpectPacketEQ(p.GetPacket(), | 430 ExpectPacketEQ(p.GetPacket(), |
431 rtcp_builder_->BuildRtcpFromSender(sender_info)); | 431 rtcp_builder_->BuildRtcpFromSender(sender_info)); |
432 } | 432 } |
433 | 433 |
434 } // namespace cast | 434 } // namespace cast |
435 } // namespace media | 435 } // namespace media |
OLD | NEW |