Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(39)

Side by Side Diff: media/cast/net/rtcp/rtcp_builder_unittest.cc

Issue 1709863002: Add Cast PLI support on sender side. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Rebased and addressed comments. Created 4 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698