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 4eed746297e42b9e5fba1612b6fcacb64d87d2ab..22865f8ac4a598ff0dd2e39bcabdefe570d5d5fb 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 =
@@ -133,7 +133,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));
 }
@@ -142,64 +142,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));
 
@@ -207,7 +207,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());
@@ -217,10 +217,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());
 
@@ -228,7 +228,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);
@@ -236,20 +236,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.
@@ -258,25 +258,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);
@@ -284,43 +284,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);
@@ -328,19 +328,41 @@ TEST_F(RtcpParserTest, InjectReceiverReportPacketWithCastFeedback) {
 
 TEST_F(RtcpParserTest, ExtendedCastFeedbackDoesNotBreakParsing) {
   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);
   builder.AddCst2(std::vector<uint32_t>{kAckFrameId + 2, kAckFrameId + 3});
 
   // Parse should succeed with the added CST2 section in the feedback, even
   // though we don't currently parse it directly.
-  RtcpParser parser(kSourceSsrc, kSenderSsrc);
+  RtcpParser parser(kLocalSsrc, kRemoteSsrc);
   EXPECT_TRUE(parser.Parse(builder.Reader()));
   ExpectLastReport(parser);
   ExpectCastFeedback(parser);
 }
 
+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;
@@ -371,15 +393,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);
 }
@@ -406,16 +428,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);
 }