Cast: Restructure RTCP interface to better fit our usage.

media/cast/rtcp/rtcp_sender_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/memory/scoped_ptr.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/pacing/paced_sender.h"
 #include "media/cast/rtcp/rtcp_sender.h"
 #include "media/cast/rtcp/test_rtcp_packet_builder.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 59 matching lines @@
   sender_info.rtp_timestamp = kRtpTimestamp;
   sender_info.send_packet_count = kSendPacketCount;
   sender_info.send_octet_count = kSendOctetCount;
 
   // Sender report + c_name.
   TestRtcpPacketBuilder p;
   p.AddSr(kSendingSsrc, 0);
   p.AddSdesCname(kSendingSsrc, kCName);
   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 
-  rtcp_sender_->SendRtcp(RtcpSender::kRtcpSr,
-                         &sender_info,
-                         NULL,
-                         0,
-                         NULL,
-                         NULL,
-                         NULL);
+  rtcp_sender_->SendRtcpFromRtpSender(RtcpSender::kRtcpSr,
+                                      &sender_info,
+                                      NULL,
+                                      NULL);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, RtcpReceiverReport) {
   // Empty receiver report + c_name.
   TestRtcpPacketBuilder p1;
   p1.AddRr(kSendingSsrc, 0);
   p1.AddSdesCname(kSendingSsrc, kCName);
   test_transport_.SetExpectedRtcpPacket(p1.Packet(), p1.Length());
 
-  rtcp_sender_->SendRtcp(RtcpSender::kRtcpRr,
-                         NULL,
-                         NULL,
-                         0,
-                         NULL,
-                         NULL,
-                         NULL);
+  rtcp_sender_->SendRtcpFromRtpReceiver(RtcpSender::kRtcpRr,
+      NULL, NULL, NULL, NULL);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 
   // Receiver report with report block + c_name.
   TestRtcpPacketBuilder p2;
   p2.AddRr(kSendingSsrc, 1);
   p2.AddRb(kMediaSsrc);
   p2.AddSdesCname(kSendingSsrc, kCName);
   test_transport_.SetExpectedRtcpPacket(p2.Packet(), p2.Length());
 
   RtcpReportBlock report_block;
   // Initialize remote_ssrc to a "clearly illegal" value.
   report_block.remote_ssrc = 0xDEAD;
   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
   report_block.fraction_lost = kLoss >> 24;
   report_block.cumulative_lost = kLoss;  // 24 bits valid.
-  report_block.extended_high_sequence_number =
-      kExtendedMax;
-  report_block.jitter = kJitter;
+  report_block.extended_high_sequence_number = kExtendedMax;
+  report_block.jitter = kTestJitter;
   report_block.last_sr = kLastSr;
   report_block.delay_since_last_sr = kDelayLastSr;
 
-  rtcp_sender_->SendRtcp(RtcpSender::kRtcpRr,
-                         NULL,
-                         &report_block,
-                         0,
-                         NULL,
-                         NULL,
-                         NULL);
+  rtcp_sender_->SendRtcpFromRtpReceiver(RtcpSender::kRtcpRr, &report_block,
+                                        NULL, NULL, NULL);
 
   EXPECT_EQ(2, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, RtcpSenderReportWithDlrr) {
   RtcpSenderInfo sender_info;
   sender_info.ntp_seconds = kNtpHigh;
   sender_info.ntp_fraction = kNtpLow;
   sender_info.rtp_timestamp = kRtpTimestamp;
   sender_info.send_packet_count = kSendPacketCount;
   sender_info.send_octet_count = kSendOctetCount;
 
   // Sender report + c_name + dlrr.
   TestRtcpPacketBuilder p1;
   p1.AddSr(kSendingSsrc, 0);
   p1.AddSdesCname(kSendingSsrc, kCName);
   p1.AddXrHeader(kSendingSsrc);
   p1.AddXrDlrrBlock(kSendingSsrc);
   test_transport_.SetExpectedRtcpPacket(p1.Packet(), p1.Length());
 
   RtcpDlrrReportBlock dlrr_rb;
   dlrr_rb.last_rr = kLastRr;
   dlrr_rb.delay_since_last_rr = kDelayLastRr;
 
-  rtcp_sender_->SendRtcp(RtcpSender::kRtcpSr | RtcpSender::kRtcpDlrr,
-                         &sender_info,
-                         NULL,
-                         0,
-                         &dlrr_rb,
-                         NULL,
-                         NULL);
+  rtcp_sender_->SendRtcpFromRtpSender(
+      RtcpSender::kRtcpSr | RtcpSender::kRtcpDlrr,
+      &sender_info,
+      &dlrr_rb,
+      NULL);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtr) {
   // Receiver report with report block + c_name.
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
   p.AddSdesCname(kSendingSsrc, kCName);
   p.AddXrHeader(kSendingSsrc);
   p.AddXrRrtrBlock();
   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 
   RtcpReportBlock report_block;
   // Initialize remote_ssrc to a "clearly illegal" value.
   report_block.remote_ssrc = 0xDEAD;
   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
   report_block.fraction_lost = kLoss >> 24;
   report_block.cumulative_lost = kLoss;  // 24 bits valid.
   report_block.extended_high_sequence_number =
       kExtendedMax;
-  report_block.jitter = kJitter;
+  report_block.jitter = kTestJitter;
   report_block.last_sr = kLastSr;
   report_block.delay_since_last_sr = kDelayLastSr;
 
   RtcpReceiverReferenceTimeReport rrtr;
   rrtr.ntp_seconds = kNtpHigh;
   rrtr.ntp_fraction = kNtpLow;
 
-  rtcp_sender_->SendRtcp(RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr,
-                         NULL,
-                         &report_block,
-                         0,
-                         NULL,
-                         &rrtr,
-                         NULL);
+  rtcp_sender_->SendRtcpFromRtpReceiver(
+      RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr,
+      &report_block,
+      &rrtr,
+      NULL,
+      NULL);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, RtcpReceiverReportWithCast) {
   // Receiver report with report block + c_name.
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
   p.AddSdesCname(kSendingSsrc, kCName);
   p.AddCast(kSendingSsrc, kMediaSsrc);
   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 
   RtcpReportBlock report_block;
   // Initialize remote_ssrc to a "clearly illegal" value.
   report_block.remote_ssrc = 0xDEAD;
   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
   report_block.fraction_lost = kLoss >> 24;
   report_block.cumulative_lost = kLoss;  // 24 bits valid.
   report_block.extended_high_sequence_number = kExtendedMax;
-  report_block.jitter = kJitter;
+  report_block.jitter = kTestJitter;
   report_block.last_sr = kLastSr;
   report_block.delay_since_last_sr = kDelayLastSr;
 
   RtcpCastMessage cast_message(kMediaSsrc);
   cast_message.ack_frame_id_ = kAckFrameId;
   PacketIdSet missing_packets;
   cast_message.missing_frames_and_packets_[
       kLostFrameId] = missing_packets;
 
   missing_packets.insert(kLostPacketId1);
   missing_packets.insert(kLostPacketId2);
   missing_packets.insert(kLostPacketId3);
   cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] =
       missing_packets;
 
-  rtcp_sender_->SendRtcp(RtcpSender::kRtcpRr | RtcpSender::kRtcpCast,
-                         NULL,
-                         &report_block,
-                         0,
-                         NULL,
-                         NULL,
-                         &cast_message);
+  rtcp_sender_->SendRtcpFromRtpReceiver(
+      RtcpSender::kRtcpRr | RtcpSender::kRtcpCast,
+      &report_block,
+      NULL,
+      &cast_message,
+      NULL);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 }
-
-TEST_F(RtcpSenderTest, RtcpReceiverReportWithIntraFrameRequest) {
-  // Receiver report with report block + c_name.
-  TestRtcpPacketBuilder p;
-  p.AddRr(kSendingSsrc, 1);
-  p.AddRb(kMediaSsrc);
-  p.AddSdesCname(kSendingSsrc, kCName);
-  p.AddPli(kSendingSsrc, kMediaSsrc);
-  test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
-
-  RtcpReportBlock report_block;
-  // Initialize remote_ssrc to a "clearly illegal" value.
-  report_block.remote_ssrc = 0xDEAD;
-  report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
-  report_block.fraction_lost = kLoss >> 24;
-  report_block.cumulative_lost = kLoss;  // 24 bits valid.
-  report_block.extended_high_sequence_number =
-      kExtendedMax;
-  report_block.jitter = kJitter;
-  report_block.last_sr = kLastSr;
-  report_block.delay_since_last_sr = kDelayLastSr;
-
-  rtcp_sender_->SendRtcp(RtcpSender::kRtcpRr | RtcpSender::kRtcpPli,
-                         NULL,
-                         &report_block,
-                         kMediaSsrc,
-                         NULL,
-                         NULL,
-                         NULL);
-
-  EXPECT_EQ(1, test_transport_.packet_count());
-}
 
 }  // namespace cast
 }  // namespace media