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 <stdint.h> | 5 #include <stdint.h> |
6 | 6 |
7 #include <vector> | 7 #include <vector> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/memory/scoped_ptr.h" | 10 #include "base/memory/scoped_ptr.h" |
11 #include "base/test/simple_test_tick_clock.h" | 11 #include "base/test/simple_test_tick_clock.h" |
12 #include "media/base/video_frame.h" | 12 #include "media/base/video_frame.h" |
13 #include "media/cast/cast_environment.h" | 13 #include "media/cast/cast_environment.h" |
14 #include "media/cast/logging/simple_event_subscriber.h" | 14 #include "media/cast/logging/simple_event_subscriber.h" |
15 #include "media/cast/net/cast_transport_config.h" | 15 #include "media/cast/net/cast_transport_config.h" |
16 #include "media/cast/net/cast_transport_sender_impl.h" | 16 #include "media/cast/net/cast_transport_sender_impl.h" |
17 #include "media/cast/net/pacing/paced_sender.h" | 17 #include "media/cast/net/pacing/paced_sender.h" |
| 18 #include "media/cast/net/rtcp/rtcp_receiver.h" |
18 #include "media/cast/sender/video_sender.h" | 19 #include "media/cast/sender/video_sender.h" |
19 #include "media/cast/test/fake_single_thread_task_runner.h" | 20 #include "media/cast/test/fake_single_thread_task_runner.h" |
20 #include "media/cast/test/fake_video_encode_accelerator.h" | 21 #include "media/cast/test/fake_video_encode_accelerator.h" |
21 #include "media/cast/test/utility/default_config.h" | 22 #include "media/cast/test/utility/default_config.h" |
22 #include "media/cast/test/utility/video_utility.h" | 23 #include "media/cast/test/utility/video_utility.h" |
23 #include "testing/gmock/include/gmock/gmock.h" | 24 #include "testing/gmock/include/gmock/gmock.h" |
24 #include "testing/gtest/include/gtest/gtest.h" | 25 #include "testing/gtest/include/gtest/gtest.h" |
25 | 26 |
26 namespace media { | 27 namespace media { |
27 namespace cast { | 28 namespace cast { |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
59 paused_(false) {} | 60 paused_(false) {} |
60 | 61 |
61 // A singular packet implies a RTCP packet. | 62 // A singular packet implies a RTCP packet. |
62 virtual bool SendPacket(PacketRef packet, | 63 virtual bool SendPacket(PacketRef packet, |
63 const base::Closure& cb) OVERRIDE { | 64 const base::Closure& cb) OVERRIDE { |
64 if (paused_) { | 65 if (paused_) { |
65 stored_packet_ = packet; | 66 stored_packet_ = packet; |
66 callback_ = cb; | 67 callback_ = cb; |
67 return false; | 68 return false; |
68 } | 69 } |
69 if (Rtcp::IsRtcpPacket(&packet->data[0], packet->data.size())) { | 70 if (RtcpReceiver::IsRtcpPacket(&packet->data[0], packet->data.size())) { |
70 ++number_of_rtcp_packets_; | 71 ++number_of_rtcp_packets_; |
71 } else { | 72 } else { |
72 // Check that at least one RTCP packet was sent before the first RTP | 73 // Check that at least one RTCP packet was sent before the first RTP |
73 // packet. This confirms that the receiver will have the necessary lip | 74 // packet. This confirms that the receiver will have the necessary lip |
74 // sync info before it has to calculate the playout time of the first | 75 // sync info before it has to calculate the playout time of the first |
75 // frame. | 76 // frame. |
76 if (number_of_rtp_packets_ == 0) | 77 if (number_of_rtp_packets_ == 0) |
77 EXPECT_LE(1, number_of_rtcp_packets_); | 78 EXPECT_LE(1, number_of_rtcp_packets_); |
78 ++number_of_rtp_packets_; | 79 ++number_of_rtp_packets_; |
79 } | 80 } |
(...skipping 185 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
265 | 266 |
266 // Make sure that we send at least one RTCP packet. | 267 // Make sure that we send at least one RTCP packet. |
267 base::TimeDelta max_rtcp_timeout = | 268 base::TimeDelta max_rtcp_timeout = |
268 base::TimeDelta::FromMilliseconds(1 + kDefaultRtcpIntervalMs * 3 / 2); | 269 base::TimeDelta::FromMilliseconds(1 + kDefaultRtcpIntervalMs * 3 / 2); |
269 | 270 |
270 RunTasks(max_rtcp_timeout.InMilliseconds()); | 271 RunTasks(max_rtcp_timeout.InMilliseconds()); |
271 EXPECT_LE(1, transport_.number_of_rtp_packets()); | 272 EXPECT_LE(1, transport_.number_of_rtp_packets()); |
272 EXPECT_LE(1, transport_.number_of_rtcp_packets()); | 273 EXPECT_LE(1, transport_.number_of_rtcp_packets()); |
273 // Build Cast msg and expect RTCP packet. | 274 // Build Cast msg and expect RTCP packet. |
274 RtcpCastMessage cast_feedback(1); | 275 RtcpCastMessage cast_feedback(1); |
275 cast_feedback.media_ssrc_ = 2; | 276 cast_feedback.media_ssrc = 2; |
276 cast_feedback.ack_frame_id_ = 0; | 277 cast_feedback.ack_frame_id = 0; |
277 video_sender_->OnReceivedCastFeedback(cast_feedback); | 278 video_sender_->OnReceivedCastFeedback(cast_feedback); |
278 RunTasks(max_rtcp_timeout.InMilliseconds()); | 279 RunTasks(max_rtcp_timeout.InMilliseconds()); |
279 EXPECT_LE(1, transport_.number_of_rtcp_packets()); | 280 EXPECT_LE(1, transport_.number_of_rtcp_packets()); |
280 } | 281 } |
281 | 282 |
282 TEST_F(VideoSenderTest, ResendTimer) { | 283 TEST_F(VideoSenderTest, ResendTimer) { |
283 InitEncoder(false); | 284 InitEncoder(false); |
284 | 285 |
285 scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame(); | 286 scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame(); |
286 | 287 |
287 const base::TimeTicks capture_time = testing_clock_->NowTicks(); | 288 const base::TimeTicks capture_time = testing_clock_->NowTicks(); |
288 video_sender_->InsertRawVideoFrame(video_frame, capture_time); | 289 video_sender_->InsertRawVideoFrame(video_frame, capture_time); |
289 | 290 |
290 // ACK the key frame. | 291 // ACK the key frame. |
291 RtcpCastMessage cast_feedback(1); | 292 RtcpCastMessage cast_feedback(1); |
292 cast_feedback.media_ssrc_ = 2; | 293 cast_feedback.media_ssrc = 2; |
293 cast_feedback.ack_frame_id_ = 0; | 294 cast_feedback.ack_frame_id = 0; |
294 video_sender_->OnReceivedCastFeedback(cast_feedback); | 295 video_sender_->OnReceivedCastFeedback(cast_feedback); |
295 | 296 |
296 video_frame = GetNewVideoFrame(); | 297 video_frame = GetNewVideoFrame(); |
297 video_sender_->InsertRawVideoFrame(video_frame, capture_time); | 298 video_sender_->InsertRawVideoFrame(video_frame, capture_time); |
298 | 299 |
299 base::TimeDelta max_resend_timeout = | 300 base::TimeDelta max_resend_timeout = |
300 base::TimeDelta::FromMilliseconds(1 + kDefaultRtpMaxDelayMs); | 301 base::TimeDelta::FromMilliseconds(1 + kDefaultRtpMaxDelayMs); |
301 | 302 |
302 // Make sure that we do a re-send. | 303 // Make sure that we do a re-send. |
303 RunTasks(max_resend_timeout.InMilliseconds()); | 304 RunTasks(max_resend_timeout.InMilliseconds()); |
(...skipping 13 matching lines...) Expand all Loading... |
317 scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame(); | 318 scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame(); |
318 | 319 |
319 const base::TimeTicks capture_time = testing_clock_->NowTicks(); | 320 const base::TimeTicks capture_time = testing_clock_->NowTicks(); |
320 video_sender_->InsertRawVideoFrame(video_frame, capture_time); | 321 video_sender_->InsertRawVideoFrame(video_frame, capture_time); |
321 RunTasks(33); | 322 RunTasks(33); |
322 } | 323 } |
323 | 324 |
324 task_runner_->RunTasks(); | 325 task_runner_->RunTasks(); |
325 | 326 |
326 RtcpCastMessage cast_feedback(1); | 327 RtcpCastMessage cast_feedback(1); |
327 cast_feedback.ack_frame_id_ = num_frames - 1; | 328 cast_feedback.ack_frame_id = num_frames - 1; |
328 | 329 |
329 video_sender_->OnReceivedCastFeedback(cast_feedback); | 330 video_sender_->OnReceivedCastFeedback(cast_feedback); |
330 | 331 |
331 std::vector<FrameEvent> frame_events; | 332 std::vector<FrameEvent> frame_events; |
332 event_subscriber.GetFrameEventsAndReset(&frame_events); | 333 event_subscriber.GetFrameEventsAndReset(&frame_events); |
333 | 334 |
334 ASSERT_TRUE(!frame_events.empty()); | 335 ASSERT_TRUE(!frame_events.empty()); |
335 EXPECT_EQ(FRAME_ACK_RECEIVED, frame_events.rbegin()->type); | 336 EXPECT_EQ(FRAME_ACK_RECEIVED, frame_events.rbegin()->type); |
336 EXPECT_EQ(VIDEO_EVENT, frame_events.rbegin()->media_type); | 337 EXPECT_EQ(VIDEO_EVENT, frame_events.rbegin()->media_type); |
337 EXPECT_EQ(num_frames - 1u, frame_events.rbegin()->frame_id); | 338 EXPECT_EQ(num_frames - 1u, frame_events.rbegin()->frame_id); |
(...skipping 25 matching lines...) Expand all Loading... |
363 RunTasks(33); | 364 RunTasks(33); |
364 } | 365 } |
365 | 366 |
366 // We expect a frame to be retransmitted because of duplicated ACKs. | 367 // We expect a frame to be retransmitted because of duplicated ACKs. |
367 // Only one packet of the frame is re-transmitted. | 368 // Only one packet of the frame is re-transmitted. |
368 EXPECT_EQ(number_of_packets_sent + 1, | 369 EXPECT_EQ(number_of_packets_sent + 1, |
369 transport_.number_of_rtp_packets()); | 370 transport_.number_of_rtp_packets()); |
370 | 371 |
371 // Start acking and make sure we're back to steady-state. | 372 // Start acking and make sure we're back to steady-state. |
372 RtcpCastMessage cast_feedback(1); | 373 RtcpCastMessage cast_feedback(1); |
373 cast_feedback.media_ssrc_ = 2; | 374 cast_feedback.media_ssrc = 2; |
374 cast_feedback.ack_frame_id_ = 0; | 375 cast_feedback.ack_frame_id = 0; |
375 video_sender_->OnReceivedCastFeedback(cast_feedback); | 376 video_sender_->OnReceivedCastFeedback(cast_feedback); |
376 EXPECT_LE( | 377 EXPECT_LE( |
377 4, | 378 4, |
378 transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets()); | 379 transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets()); |
379 | 380 |
380 // Empty the pipeline. | 381 // Empty the pipeline. |
381 RunTasks(100); | 382 RunTasks(100); |
382 // Should have sent at least 7 packets. | 383 // Should have sent at least 7 packets. |
383 EXPECT_LE( | 384 EXPECT_LE( |
384 7, | 385 7, |
385 transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets()); | 386 transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets()); |
386 } | 387 } |
387 | 388 |
388 TEST_F(VideoSenderTest, DuplicateAckRetransmit) { | 389 TEST_F(VideoSenderTest, DuplicateAckRetransmit) { |
389 InitEncoder(false); | 390 InitEncoder(false); |
390 scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame(); | 391 scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame(); |
391 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); | 392 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); |
392 RunTasks(33); | 393 RunTasks(33); |
393 RtcpCastMessage cast_feedback(1); | 394 RtcpCastMessage cast_feedback(1); |
394 cast_feedback.media_ssrc_ = 2; | 395 cast_feedback.media_ssrc = 2; |
395 cast_feedback.ack_frame_id_ = 0; | 396 cast_feedback.ack_frame_id = 0; |
396 | 397 |
397 // Send 3 more frames but don't ACK. | 398 // Send 3 more frames but don't ACK. |
398 for (int i = 0; i < 3; ++i) { | 399 for (int i = 0; i < 3; ++i) { |
399 scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame(); | 400 scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame(); |
400 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); | 401 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); |
401 RunTasks(33); | 402 RunTasks(33); |
402 } | 403 } |
403 const int number_of_packets_sent = transport_.number_of_rtp_packets(); | 404 const int number_of_packets_sent = transport_.number_of_rtp_packets(); |
404 | 405 |
405 // Send duplicated ACKs and mix some invalid NACKs. | 406 // Send duplicated ACKs and mix some invalid NACKs. |
406 for (int i = 0; i < 10; ++i) { | 407 for (int i = 0; i < 10; ++i) { |
407 RtcpCastMessage ack_feedback(1); | 408 RtcpCastMessage ack_feedback(1); |
408 ack_feedback.media_ssrc_ = 2; | 409 ack_feedback.media_ssrc = 2; |
409 ack_feedback.ack_frame_id_ = 0; | 410 ack_feedback.ack_frame_id = 0; |
410 RtcpCastMessage nack_feedback(1); | 411 RtcpCastMessage nack_feedback(1); |
411 nack_feedback.media_ssrc_ = 2; | 412 nack_feedback.media_ssrc = 2; |
412 nack_feedback.missing_frames_and_packets_[255] = PacketIdSet(); | 413 nack_feedback.missing_frames_and_packets[255] = PacketIdSet(); |
413 video_sender_->OnReceivedCastFeedback(ack_feedback); | 414 video_sender_->OnReceivedCastFeedback(ack_feedback); |
414 video_sender_->OnReceivedCastFeedback(nack_feedback); | 415 video_sender_->OnReceivedCastFeedback(nack_feedback); |
415 } | 416 } |
416 EXPECT_EQ(number_of_packets_sent, transport_.number_of_rtp_packets()); | 417 EXPECT_EQ(number_of_packets_sent, transport_.number_of_rtp_packets()); |
417 | 418 |
418 // Re-transmit one packet because of duplicated ACKs. | 419 // Re-transmit one packet because of duplicated ACKs. |
419 for (int i = 0; i < 3; ++i) { | 420 for (int i = 0; i < 3; ++i) { |
420 RtcpCastMessage ack_feedback(1); | 421 RtcpCastMessage ack_feedback(1); |
421 ack_feedback.media_ssrc_ = 2; | 422 ack_feedback.media_ssrc = 2; |
422 ack_feedback.ack_frame_id_ = 0; | 423 ack_feedback.ack_frame_id = 0; |
423 video_sender_->OnReceivedCastFeedback(ack_feedback); | 424 video_sender_->OnReceivedCastFeedback(ack_feedback); |
424 } | 425 } |
425 EXPECT_EQ(number_of_packets_sent + 1, transport_.number_of_rtp_packets()); | 426 EXPECT_EQ(number_of_packets_sent + 1, transport_.number_of_rtp_packets()); |
426 } | 427 } |
427 | 428 |
428 TEST_F(VideoSenderTest, DuplicateAckRetransmitDoesNotCancelRetransmits) { | 429 TEST_F(VideoSenderTest, DuplicateAckRetransmitDoesNotCancelRetransmits) { |
429 InitEncoder(false); | 430 InitEncoder(false); |
430 scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame(); | 431 scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame(); |
431 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); | 432 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); |
432 RunTasks(33); | 433 RunTasks(33); |
433 RtcpCastMessage cast_feedback(1); | 434 RtcpCastMessage cast_feedback(1); |
434 cast_feedback.media_ssrc_ = 2; | 435 cast_feedback.media_ssrc = 2; |
435 cast_feedback.ack_frame_id_ = 0; | 436 cast_feedback.ack_frame_id = 0; |
436 | 437 |
437 // Send 2 more frames but don't ACK. | 438 // Send 2 more frames but don't ACK. |
438 for (int i = 0; i < 2; ++i) { | 439 for (int i = 0; i < 2; ++i) { |
439 scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame(); | 440 scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame(); |
440 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); | 441 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); |
441 RunTasks(33); | 442 RunTasks(33); |
442 } | 443 } |
443 // Pause the transport | 444 // Pause the transport |
444 transport_.SetPause(true); | 445 transport_.SetPause(true); |
445 | 446 |
446 // Insert one more video frame. | 447 // Insert one more video frame. |
447 video_frame = GetLargeNewVideoFrame(); | 448 video_frame = GetLargeNewVideoFrame(); |
448 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); | 449 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); |
449 RunTasks(33); | 450 RunTasks(33); |
450 | 451 |
451 const int number_of_packets_sent = transport_.number_of_rtp_packets(); | 452 const int number_of_packets_sent = transport_.number_of_rtp_packets(); |
452 | 453 |
453 // Send duplicated ACKs and mix some invalid NACKs. | 454 // Send duplicated ACKs and mix some invalid NACKs. |
454 for (int i = 0; i < 10; ++i) { | 455 for (int i = 0; i < 10; ++i) { |
455 RtcpCastMessage ack_feedback(1); | 456 RtcpCastMessage ack_feedback(1); |
456 ack_feedback.media_ssrc_ = 2; | 457 ack_feedback.media_ssrc = 2; |
457 ack_feedback.ack_frame_id_ = 0; | 458 ack_feedback.ack_frame_id = 0; |
458 RtcpCastMessage nack_feedback(1); | 459 RtcpCastMessage nack_feedback(1); |
459 nack_feedback.media_ssrc_ = 2; | 460 nack_feedback.media_ssrc = 2; |
460 nack_feedback.missing_frames_and_packets_[255] = PacketIdSet(); | 461 nack_feedback.missing_frames_and_packets[255] = PacketIdSet(); |
461 video_sender_->OnReceivedCastFeedback(ack_feedback); | 462 video_sender_->OnReceivedCastFeedback(ack_feedback); |
462 video_sender_->OnReceivedCastFeedback(nack_feedback); | 463 video_sender_->OnReceivedCastFeedback(nack_feedback); |
463 } | 464 } |
464 EXPECT_EQ(number_of_packets_sent, transport_.number_of_rtp_packets()); | 465 EXPECT_EQ(number_of_packets_sent, transport_.number_of_rtp_packets()); |
465 | 466 |
466 // Re-transmit one packet because of duplicated ACKs. | 467 // Re-transmit one packet because of duplicated ACKs. |
467 for (int i = 0; i < 3; ++i) { | 468 for (int i = 0; i < 3; ++i) { |
468 RtcpCastMessage ack_feedback(1); | 469 RtcpCastMessage ack_feedback(1); |
469 ack_feedback.media_ssrc_ = 2; | 470 ack_feedback.media_ssrc = 2; |
470 ack_feedback.ack_frame_id_ = 0; | 471 ack_feedback.ack_frame_id = 0; |
471 video_sender_->OnReceivedCastFeedback(ack_feedback); | 472 video_sender_->OnReceivedCastFeedback(ack_feedback); |
472 } | 473 } |
473 | 474 |
474 transport_.SetPause(false); | 475 transport_.SetPause(false); |
475 RunTasks(100); | 476 RunTasks(100); |
476 EXPECT_LT(number_of_packets_sent + 1, transport_.number_of_rtp_packets()); | 477 EXPECT_LT(number_of_packets_sent + 1, transport_.number_of_rtp_packets()); |
477 } | 478 } |
478 | 479 |
479 TEST_F(VideoSenderTest, AcksCancelRetransmits) { | 480 TEST_F(VideoSenderTest, AcksCancelRetransmits) { |
480 InitEncoder(false); | 481 InitEncoder(false); |
481 transport_.SetPause(true); | 482 transport_.SetPause(true); |
482 scoped_refptr<media::VideoFrame> video_frame = GetLargeNewVideoFrame(); | 483 scoped_refptr<media::VideoFrame> video_frame = GetLargeNewVideoFrame(); |
483 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); | 484 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); |
484 RunTasks(33); | 485 RunTasks(33); |
485 | 486 |
486 // Frame should be in buffer, waiting. Now let's ack it. | 487 // Frame should be in buffer, waiting. Now let's ack it. |
487 RtcpCastMessage cast_feedback(1); | 488 RtcpCastMessage cast_feedback(1); |
488 cast_feedback.media_ssrc_ = 2; | 489 cast_feedback.media_ssrc = 2; |
489 cast_feedback.ack_frame_id_ = 0; | 490 cast_feedback.ack_frame_id = 0; |
490 video_sender_->OnReceivedCastFeedback(cast_feedback); | 491 video_sender_->OnReceivedCastFeedback(cast_feedback); |
491 | 492 |
492 transport_.SetPause(false); | 493 transport_.SetPause(false); |
493 RunTasks(33); | 494 RunTasks(33); |
494 EXPECT_EQ(0, transport_.number_of_rtp_packets()); | 495 EXPECT_EQ(0, transport_.number_of_rtp_packets()); |
495 } | 496 } |
496 | 497 |
497 TEST_F(VideoSenderTest, NAcksCancelRetransmits) { | 498 TEST_F(VideoSenderTest, NAcksCancelRetransmits) { |
498 InitEncoder(false); | 499 InitEncoder(false); |
499 transport_.SetPause(true); | 500 transport_.SetPause(true); |
500 // Send two video frames. | 501 // Send two video frames. |
501 scoped_refptr<media::VideoFrame> video_frame = GetLargeNewVideoFrame(); | 502 scoped_refptr<media::VideoFrame> video_frame = GetLargeNewVideoFrame(); |
502 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); | 503 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); |
503 RunTasks(33); | 504 RunTasks(33); |
504 video_frame = GetLargeNewVideoFrame(); | 505 video_frame = GetLargeNewVideoFrame(); |
505 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); | 506 video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks()); |
506 RunTasks(33); | 507 RunTasks(33); |
507 | 508 |
508 // Frames should be in buffer, waiting. Now let's ack the first one and nack | 509 // Frames should be in buffer, waiting. Now let's ack the first one and nack |
509 // one packet in the second one. | 510 // one packet in the second one. |
510 RtcpCastMessage cast_feedback(1); | 511 RtcpCastMessage cast_feedback(1); |
511 cast_feedback.media_ssrc_ = 2; | 512 cast_feedback.media_ssrc = 2; |
512 cast_feedback.ack_frame_id_ = 0; | 513 cast_feedback.ack_frame_id = 0; |
513 PacketIdSet missing_packets; | 514 PacketIdSet missing_packets; |
514 missing_packets.insert(0); | 515 missing_packets.insert(0); |
515 cast_feedback.missing_frames_and_packets_[1] = missing_packets; | 516 cast_feedback.missing_frames_and_packets[1] = missing_packets; |
516 video_sender_->OnReceivedCastFeedback(cast_feedback); | 517 video_sender_->OnReceivedCastFeedback(cast_feedback); |
517 | 518 |
518 transport_.SetPause(false); | 519 transport_.SetPause(false); |
519 RunTasks(33); | 520 RunTasks(33); |
520 // Only one packet should be retransmitted. | 521 // Only one packet should be retransmitted. |
521 EXPECT_EQ(1, transport_.number_of_rtp_packets()); | 522 EXPECT_EQ(1, transport_.number_of_rtp_packets()); |
522 } | 523 } |
523 | 524 |
524 } // namespace cast | 525 } // namespace cast |
525 } // namespace media | 526 } // namespace media |
OLD | NEW |