Add Cast PLI support on sender side.

media/cast/net/rtcp/rtcp_utility_unittest.cc

Index: media/cast/net/rtcp/rtcp_utility_unittest.cc
diff --git a/media/cast/net/rtcp/rtcp_utility_unittest.cc b/media/cast/net/rtcp/rtcp_utility_unittest.cc
index 3630d68cf745ab2b0defbdb625fd525a67a39424..630c5f5e979233ce4f14f6ece3415072b044bbef 100644
--- a/media/cast/net/rtcp/rtcp_utility_unittest.cc
+++ b/media/cast/net/rtcp/rtcp_utility_unittest.cc
@@ -17,8 +17,8 @@
 namespace media {
 namespace cast {
 
-static const uint32_t kSenderSsrc = 0x10203;
-static const uint32_t kSourceSsrc = 0x40506;
+static const uint32_t kRemoteSsrc = 0x10203;
+static const uint32_t kLocalSsrc = 0x40506;
 static const uint32_t kUnknownSsrc = 0xDEAD;
 static const base::TimeDelta kTargetDelay =
     base::TimeDelta::FromMilliseconds(100);
@@ -57,14 +57,14 @@ class RtcpParserTest : public ::testing::Test {
 
   void ExpectReceiverReference(const RtcpParser& parser) {
     EXPECT_TRUE(parser.has_receiver_reference_time_report());
-    EXPECT_EQ(kSenderSsrc, parser.receiver_reference_time_report().remote_ssrc);
+    EXPECT_EQ(kRemoteSsrc, parser.receiver_reference_time_report().remote_ssrc);
     EXPECT_EQ(kNtpHigh, parser.receiver_reference_time_report().ntp_seconds);
     EXPECT_EQ(kNtpLow, parser.receiver_reference_time_report().ntp_fraction);
   }
 
   void ExpectCastFeedback(const RtcpParser& parser) {
     EXPECT_TRUE(parser.has_cast_message());
-    EXPECT_EQ(kSenderSsrc, parser.cast_message().media_ssrc);
+    EXPECT_EQ(kRemoteSsrc, parser.cast_message().remote_ssrc);
     EXPECT_EQ(kAckFrameId, parser.cast_message().ack_frame_id);
 
     MissingFramesAndPacketsMap::const_iterator frame_it =
@@ -145,7 +145,7 @@ class RtcpParserTest : public ::testing::Test {
 
 TEST_F(RtcpParserTest, BrokenPacketIsIgnored) {
   const char bad_packet[] = {0, 0, 0, 0};
-  RtcpParser parser(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser(kLocalSsrc, kRemoteSsrc);
   base::BigEndianReader reader(bad_packet, sizeof(bad_packet));
   EXPECT_FALSE(parser.Parse(&reader));
 }
@@ -154,64 +154,64 @@ TEST_F(RtcpParserTest, UnknownBlockIgnored) {
   // Only unknown data, nothing happens.
   TestRtcpPacketBuilder p;
   p.AddUnknownBlock();
-  RtcpParser parser1(kSourceSsrc, 0);
+  RtcpParser parser1(kLocalSsrc, 0);
   EXPECT_TRUE(parser1.Parse(p.Reader()));
   EXPECT_FALSE(HasAnything(parser1));
 
   // Add valid sender report *after* unknown data - should work fine.
-  p.AddSr(kSenderSsrc, 0);
-  RtcpParser parser2(kSourceSsrc, kSenderSsrc);
+  p.AddSr(kRemoteSsrc, 0);
+  RtcpParser parser2(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser2.Parse(p.Reader()));
   ExpectSenderInfo(parser2);
 }
 
 TEST_F(RtcpParserTest, InjectSenderReportPacket) {
   TestRtcpPacketBuilder p;
-  p.AddSr(kSenderSsrc, 0);
+  p.AddSr(kRemoteSsrc, 0);
 
   // Expected to be ignored since the sender ssrc does not match our
   // remote ssrc.
-  RtcpParser parser1(kSourceSsrc, 0);
+  RtcpParser parser1(kLocalSsrc, 0);
   EXPECT_TRUE(parser1.Parse(p.Reader()));
   EXPECT_FALSE(HasAnything(parser1));
 
   // Expected to be pass through since the sender ssrc match our remote ssrc.
-  RtcpParser parser2(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser2(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser2.Parse(p.Reader()));
   ExpectSenderInfo(parser2);
 }
 
 TEST_F(RtcpParserTest, InjectReceiveReportPacket) {
   TestRtcpPacketBuilder p1;
-  p1.AddRr(kSenderSsrc, 1);
+  p1.AddRr(kRemoteSsrc, 1);
   p1.AddRb(kUnknownSsrc);
 
   // Expected to be ignored since the source ssrc does not match our
   // local ssrc.
-  RtcpParser parser1(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser1(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser1.Parse(p1.Reader()));
   EXPECT_FALSE(HasAnything(parser1));
 
   TestRtcpPacketBuilder p2;
-  p2.AddRr(kSenderSsrc, 1);
-  p2.AddRb(kSourceSsrc);
+  p2.AddRr(kRemoteSsrc, 1);
+  p2.AddRb(kLocalSsrc);
 
   // Expected to be pass through since the sender ssrc match our local ssrc.
-  RtcpParser parser2(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser2(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser2.Parse(p2.Reader()));
   ExpectLastReport(parser2);
 }
 
 TEST_F(RtcpParserTest, InjectSenderReportWithReportBlockPacket) {
   TestRtcpPacketBuilder p1;
-  p1.AddSr(kSenderSsrc, 1);
+  p1.AddSr(kRemoteSsrc, 1);
   p1.AddRb(kUnknownSsrc);
 
   // Sender report expected to be ignored since the sender ssrc does not match
   // our remote ssrc.
   // Report block expected to be ignored since the source ssrc does not match
   // our local ssrc.
-  RtcpParser parser1(kSourceSsrc, 0);
+  RtcpParser parser1(kLocalSsrc, 0);
   EXPECT_TRUE(parser1.Parse(p1.Reader()));
   EXPECT_FALSE(HasAnything(parser1));
 
@@ -219,7 +219,7 @@ TEST_F(RtcpParserTest, InjectSenderReportWithReportBlockPacket) {
   // remote ssrc.
   // Report block expected to be ignored since the source ssrc does not match
   // our local ssrc.
-  RtcpParser parser2(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser2(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser2.Parse(p1.Reader()));
   ExpectSenderInfo(parser2);
   EXPECT_FALSE(parser2.has_last_report());
@@ -229,10 +229,10 @@ TEST_F(RtcpParserTest, InjectSenderReportWithReportBlockPacket) {
   // Report block expected to be ignored too since it's a part of the
   // sender report.
   TestRtcpPacketBuilder p2;
-  p2.AddSr(kSenderSsrc, 1);
-  p2.AddRb(kSourceSsrc);
+  p2.AddSr(kRemoteSsrc, 1);
+  p2.AddRb(kLocalSsrc);
 
-  RtcpParser parser3(kSourceSsrc, 0);
+  RtcpParser parser3(kLocalSsrc, 0);
   EXPECT_TRUE(parser3.Parse(p2.Reader()));
   EXPECT_FALSE(parser3.has_last_report());
 
@@ -240,7 +240,7 @@ TEST_F(RtcpParserTest, InjectSenderReportWithReportBlockPacket) {
   // remote ssrc.
   // Report block expected to be pass through since the sender ssrc match
   // our local ssrc.
-  RtcpParser parser4(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser4(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser4.Parse(p2.Reader()));
   ExpectSenderInfo(parser4);
   ExpectLastReport(parser4);
@@ -248,20 +248,20 @@ TEST_F(RtcpParserTest, InjectSenderReportWithReportBlockPacket) {
 
 TEST_F(RtcpParserTest, InjectSenderReportPacketWithDlrr) {
   TestRtcpPacketBuilder p;
-  p.AddSr(kSenderSsrc, 0);
-  p.AddXrHeader(kSenderSsrc);
+  p.AddSr(kRemoteSsrc, 0);
+  p.AddXrHeader(kRemoteSsrc);
   p.AddXrUnknownBlock();
-  p.AddXrExtendedDlrrBlock(kSenderSsrc);
+  p.AddXrExtendedDlrrBlock(kRemoteSsrc);
   p.AddXrUnknownBlock();
 
   // Expected to be ignored since the source ssrc does not match our
   // local ssrc.
-  RtcpParser parser1(kSourceSsrc, 0);
+  RtcpParser parser1(kLocalSsrc, 0);
   EXPECT_TRUE(parser1.Parse(p.Reader()));
   EXPECT_FALSE(HasAnything(parser1));
 
   // Expected to be pass through since the sender ssrc match our local ssrc.
-  RtcpParser parser2(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser2(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser2.Parse(p.Reader()));
   ExpectSenderInfo(parser2);
   // DLRRs are ignored.
@@ -270,25 +270,25 @@ TEST_F(RtcpParserTest, InjectSenderReportPacketWithDlrr) {
 
 TEST_F(RtcpParserTest, InjectReceiverReportPacketWithRrtr) {
   TestRtcpPacketBuilder p1;
-  p1.AddRr(kSenderSsrc, 1);
+  p1.AddRr(kRemoteSsrc, 1);
   p1.AddRb(kUnknownSsrc);
-  p1.AddXrHeader(kSenderSsrc);
+  p1.AddXrHeader(kRemoteSsrc);
   p1.AddXrRrtrBlock();
 
   // Expected to be ignored since the source ssrc does not match our
   // local ssrc.
-  RtcpParser parser1(kSourceSsrc, 0);
+  RtcpParser parser1(kLocalSsrc, 0);
   EXPECT_TRUE(parser1.Parse(p1.Reader()));
   EXPECT_FALSE(HasAnything(parser1));
 
   TestRtcpPacketBuilder p2;
-  p2.AddRr(kSenderSsrc, 1);
-  p2.AddRb(kSourceSsrc);
-  p2.AddXrHeader(kSenderSsrc);
+  p2.AddRr(kRemoteSsrc, 1);
+  p2.AddRb(kLocalSsrc);
+  p2.AddXrHeader(kRemoteSsrc);
   p2.AddXrRrtrBlock();
 
   // Expected to be pass through since the sender ssrc match our local ssrc.
-  RtcpParser parser2(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser2(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser2.Parse(p2.Reader()));
   ExpectLastReport(parser2);
   ExpectReceiverReference(parser2);
@@ -296,43 +296,43 @@ TEST_F(RtcpParserTest, InjectReceiverReportPacketWithRrtr) {
 
 TEST_F(RtcpParserTest, InjectReceiverReportPacketWithIntraFrameRequest) {
   TestRtcpPacketBuilder p1;
-  p1.AddRr(kSenderSsrc, 1);
+  p1.AddRr(kRemoteSsrc, 1);
   p1.AddRb(kUnknownSsrc);
 
   // Expected to be ignored since the source ssrc does not match our
   // local ssrc.
-  RtcpParser parser1(kSourceSsrc, 0);
+  RtcpParser parser1(kLocalSsrc, 0);
   EXPECT_TRUE(parser1.Parse(p1.Reader()));
   EXPECT_FALSE(HasAnything(parser1));
 
   TestRtcpPacketBuilder p2;
-  p2.AddRr(kSenderSsrc, 1);
-  p2.AddRb(kSourceSsrc);
+  p2.AddRr(kRemoteSsrc, 1);
+  p2.AddRb(kLocalSsrc);
 
-  RtcpParser parser2(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser2(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser2.Parse(p2.Reader()));
   ExpectLastReport(parser2);
 }
 
 TEST_F(RtcpParserTest, InjectReceiverReportPacketWithCastFeedback) {
   TestRtcpPacketBuilder p1;
-  p1.AddRr(kSenderSsrc, 1);
+  p1.AddRr(kRemoteSsrc, 1);
   p1.AddRb(kUnknownSsrc);
-  p1.AddCast(kSenderSsrc, kUnknownSsrc, kTargetDelay);
+  p1.AddCast(kRemoteSsrc, kUnknownSsrc, kTargetDelay);
 
   // Expected to be ignored since the source ssrc does not match our
   // local ssrc.
-  RtcpParser parser1(kSourceSsrc, 0);
+  RtcpParser parser1(kLocalSsrc, 0);
   EXPECT_TRUE(parser1.Parse(p1.Reader()));
   EXPECT_FALSE(HasAnything(parser1));
 
   TestRtcpPacketBuilder p2;
-  p2.AddRr(kSenderSsrc, 1);
-  p2.AddRb(kSourceSsrc);
-  p2.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay);
+  p2.AddRr(kRemoteSsrc, 1);
+  p2.AddRb(kLocalSsrc);
+  p2.AddCast(kRemoteSsrc, kLocalSsrc, kTargetDelay);
 
   // Expected to be pass through since the sender ssrc match our local ssrc.
-  RtcpParser parser2(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser2(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser2.Parse(p2.Reader()));
   ExpectLastReport(parser2);
   ExpectCastFeedback(parser2);
@@ -341,12 +341,12 @@ TEST_F(RtcpParserTest, InjectReceiverReportPacketWithCastFeedback) {
 TEST_F(RtcpParserTest, ExtendedCastFeedbackParsing) {
   // Empty ACK field.
   TestRtcpPacketBuilder builder;
-  builder.AddRr(kSenderSsrc, 1);
-  builder.AddRb(kSourceSsrc);
-  builder.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay);
+  builder.AddRr(kRemoteSsrc, 1);
+  builder.AddRb(kLocalSsrc);
+  builder.AddCast(kRemoteSsrc, kLocalSsrc, kTargetDelay);
   std::vector<uint32_t> receiving_frames;
   builder.AddCst2(receiving_frames);
-  RtcpParser parser(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser.Parse(builder.Reader()));
   ExpectLastReport(parser);
   ExpectCastFeedback(parser);
@@ -354,13 +354,13 @@ TEST_F(RtcpParserTest, ExtendedCastFeedbackParsing) {
 
   // One ACK bitmask.
   TestRtcpPacketBuilder builder2;
-  builder2.AddRr(kSenderSsrc, 1);
-  builder2.AddRb(kSourceSsrc);
-  builder2.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay);
+  builder2.AddRr(kRemoteSsrc, 1);
+  builder2.AddRb(kLocalSsrc);
+  builder2.AddCast(kRemoteSsrc, kLocalSsrc, kTargetDelay);
   receiving_frames.push_back(kAckFrameId + 2);
   receiving_frames.push_back(kAckFrameId + 3);
   builder2.AddCst2(receiving_frames);
-  RtcpParser parser2(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser2(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser2.Parse(builder2.Reader()));
   ExpectLastReport(parser2);
   ExpectCastFeedback(parser2);
@@ -368,14 +368,14 @@ TEST_F(RtcpParserTest, ExtendedCastFeedbackParsing) {
 
   // Mutiple ACK bitmasks.
   TestRtcpPacketBuilder builder3;
-  builder3.AddRr(kSenderSsrc, 1);
-  builder3.AddRb(kSourceSsrc);
-  builder3.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay);
+  builder3.AddRr(kRemoteSsrc, 1);
+  builder3.AddRb(kLocalSsrc);
+  builder3.AddCast(kRemoteSsrc, kLocalSsrc, kTargetDelay);
   receiving_frames.clear();
   for (size_t i = 0; i < 15; ++i)
     receiving_frames.push_back(kAckFrameId + 2 + i * 10);
   builder3.AddCst2(receiving_frames);
-  RtcpParser parser3(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser3(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser3.Parse(builder3.Reader()));
   ExpectLastReport(parser3);
   ExpectCastFeedback(parser3);
@@ -383,11 +383,11 @@ TEST_F(RtcpParserTest, ExtendedCastFeedbackParsing) {
 
   // Expected to be ignored if there is error in the extended ACK message.
   TestRtcpPacketBuilder builder4;
-  builder4.AddRr(kSenderSsrc, 1);
-  builder4.AddRb(kSourceSsrc);
-  builder4.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay);
+  builder4.AddRr(kRemoteSsrc, 1);
+  builder4.AddRb(kLocalSsrc);
+  builder4.AddCast(kRemoteSsrc, kLocalSsrc, kTargetDelay);
   builder4.AddErrorCst2();
-  RtcpParser parser4(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser4(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser4.Parse(builder4.Reader()));
   ExpectLastReport(parser4);
   ExpectCastFeedback(parser4);
@@ -395,16 +395,38 @@ TEST_F(RtcpParserTest, ExtendedCastFeedbackParsing) {
 
   // Expected to be ignored if there is only "CST2" identifier.
   TestRtcpPacketBuilder builder5;
-  builder5.AddRr(kSenderSsrc, 1);
-  builder5.AddRb(kSourceSsrc);
+  builder5.AddRr(kRemoteSsrc, 1);
+  builder5.AddRb(kLocalSsrc);
   receiving_frames.clear();
   builder5.AddCst2(receiving_frames);
-  RtcpParser parser5(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser5(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser5.Parse(builder5.Reader()));
   ExpectLastReport(parser5);
   EXPECT_FALSE(parser5.has_cst2_message());
 }
 
+TEST_F(RtcpParserTest, InjectReceiverReportPli) {
+  // Expect to be ignored since the sender ssrc does not match.
+  TestRtcpPacketBuilder builder1;
+  builder1.AddPli(kUnknownSsrc, kLocalSsrc);
+  RtcpParser parser1(kLocalSsrc, kRemoteSsrc);
+  EXPECT_TRUE(parser1.Parse(builder1.Reader()));
+  EXPECT_FALSE(parser1.has_picture_loss_indicator());
+
+  // Expect to be ignored since the receiver ssrc does not match.
+  TestRtcpPacketBuilder builder2;
+  builder2.AddPli(kRemoteSsrc, kUnknownSsrc);
+  RtcpParser parser2(kLocalSsrc, kRemoteSsrc);
+  EXPECT_TRUE(parser2.Parse(builder2.Reader()));
+  EXPECT_FALSE(parser2.has_picture_loss_indicator());
+
+  TestRtcpPacketBuilder builder3;
+  builder3.AddPli(kRemoteSsrc, kLocalSsrc);
+  RtcpParser parser3(kLocalSsrc, kRemoteSsrc);
+  EXPECT_TRUE(parser3.Parse(builder3.Reader()));
+  EXPECT_TRUE(parser3.has_picture_loss_indicator());
+}
+
 TEST_F(RtcpParserTest, InjectReceiverReportWithReceiverLogVerificationBase) {
   static const uint32_t kTimeBaseMs = 12345678;
   static const uint32_t kTimeDelayMs = 10;
@@ -435,15 +457,15 @@ TEST_F(RtcpParserTest, InjectReceiverReportWithReceiverLogVerificationBase) {
   receiver_log.push_back(frame_log);
 
   TestRtcpPacketBuilder p;
-  p.AddRr(kSenderSsrc, 1);
-  p.AddRb(kSourceSsrc);
-  p.AddReceiverLog(kSenderSsrc);
+  p.AddRr(kRemoteSsrc, 1);
+  p.AddRb(kLocalSsrc);
+  p.AddReceiverLog(kRemoteSsrc);
   p.AddReceiverFrameLog(kRtpTimestamp, 3, kTimeBaseMs);
   p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0);
   p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs);
   p.AddReceiverEventLog(kLostPacketId2, PACKET_RECEIVED, kTimeDelayMs);
 
-  RtcpParser parser(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser.Parse(p.Reader()));
   ExpectReceiverLog(parser, receiver_log);
 }
@@ -470,16 +492,16 @@ TEST_F(RtcpParserTest, InjectReceiverReportWithReceiverLogVerificationMulti) {
   }
 
   TestRtcpPacketBuilder p;
-  p.AddRr(kSenderSsrc, 1);
-  p.AddRb(kSourceSsrc);
-  p.AddReceiverLog(kSenderSsrc);
+  p.AddRr(kRemoteSsrc, 1);
+  p.AddRb(kLocalSsrc);
+  p.AddReceiverLog(kRemoteSsrc);
   for (int i = 0; i < 100; ++i) {
     p.AddReceiverFrameLog(kRtpTimestamp, 1, kTimeBaseMs + i * kTimeDelayMs);
     const int delay = (i - 50) * kDelayDeltaMs;
     p.AddReceiverEventLog(static_cast<uint16_t>(delay), FRAME_ACK_SENT, 0);
   }
 
-  RtcpParser parser(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser.Parse(p.Reader()));
   ExpectReceiverLog(parser, receiver_log);
 }