Add Cast PLI support on sender side.

media/cast/net/rtcp/rtcp_builder_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 55 matching lines @@
   }
 
   static RtpTimeTicks test_rtp_timestamp() {
     return RtpTimeTicks().Expand(kRtpTimestamp);
   }
 
   PacketRef BuildRtcpFromReceiver(
       const RtcpReportBlock* report_block,
       const RtcpReceiverReferenceTimeReport* rrtr,
       const RtcpCastMessage* cast_message,
+      const RtcpPliMessage* pli_message,
       const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
       base::TimeDelta target_delay) {
     DCHECK(rtcp_builder_);
 
     rtcp_builder_->Start();
     if (report_block)
       rtcp_builder_->AddRR(report_block);
     if (rrtr)
       rtcp_builder_->AddRrtr(*rrtr);
     if (cast_message)
       rtcp_builder_->AddCast(*cast_message, target_delay);
+    if (pli_message)
+      rtcp_builder_->AddPli(*pli_message);
     if (rtcp_events)
       rtcp_builder_->AddReceiverLog(*rtcp_events);
     return rtcp_builder_->Finish();
   }
 
   scoped_ptr<RtcpBuilder> rtcp_builder_;
 
   DISALLOW_COPY_AND_ASSIGN(RtcpBuilderTest);
 };
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReport) {
   // Receiver report with report block.
   TestRtcpPacketBuilder p2;
   p2.AddRr(kSendingSsrc, 1);
   p2.AddRb(kMediaSsrc);
 
   RtcpReportBlock report_block = GetReportBlock();
 
-  ExpectPacketEQ(
-      p2.GetPacket(),
-      BuildRtcpFromReceiver(&report_block, NULL, NULL, NULL, kDefaultDelay));
+  ExpectPacketEQ(p2.GetPacket(),
+                 BuildRtcpFromReceiver(&report_block, nullptr, nullptr, nullptr,
+                                       nullptr, kDefaultDelay));
 }
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtr) {
   // Receiver report with report block.
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
   p.AddXrHeader(kSendingSsrc);
   p.AddXrRrtrBlock();
 
   RtcpReportBlock report_block = GetReportBlock();
 
   RtcpReceiverReferenceTimeReport rrtr;
   rrtr.ntp_seconds = kNtpHigh;
   rrtr.ntp_fraction = kNtpLow;
 
-  ExpectPacketEQ(
-      p.GetPacket(),
-      BuildRtcpFromReceiver(&report_block, &rrtr, NULL, NULL, kDefaultDelay));
+  ExpectPacketEQ(p.GetPacket(),
+                 BuildRtcpFromReceiver(&report_block, &rrtr, nullptr, nullptr,
+                                       nullptr, kDefaultDelay));
 }
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithCast) {
   // Receiver report with report block.
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
   p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
 
   RtcpReportBlock report_block = GetReportBlock();
 
   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;
 
   ExpectPacketEQ(p.GetPacket(),
-                 BuildRtcpFromReceiver(&report_block, NULL, &cast_message, NULL,
-                                       kDefaultDelay));
+                 BuildRtcpFromReceiver(&report_block, nullptr, &cast_message,
+                                       nullptr, nullptr, kDefaultDelay));
 }
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtraAndCastMessage) {
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
   p.AddXrHeader(kSendingSsrc);
   p.AddXrRrtrBlock();
   p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
 
   RtcpReportBlock report_block = GetReportBlock();
 
   RtcpReceiverReferenceTimeReport rrtr;
   rrtr.ntp_seconds = kNtpHigh;
   rrtr.ntp_fraction = kNtpLow;
 
   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;
 
   ExpectPacketEQ(p.GetPacket(),
                  BuildRtcpFromReceiver(&report_block, &rrtr, &cast_message,
-                                       NULL, kDefaultDelay));
+                                       nullptr, nullptr, kDefaultDelay));
 }
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
   static const uint32_t kTimeBaseMs = 12345678;
   static const uint32_t kTimeDelayMs = 10;
 
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
   p.AddXrHeader(kSendingSsrc);
@@ skipping 15 matching lines @@
   missing_packets.insert(kLostPacketId2);
   missing_packets.insert(kLostPacketId3);
   cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] =
       missing_packets;
 
   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
 
   ExpectPacketEQ(p.GetPacket(),
                  BuildRtcpFromReceiver(&report_block, &rrtr, &cast_message,
-                                       &rtcp_events, kDefaultDelay));
+                                       nullptr, &rtcp_events, kDefaultDelay));
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
   p.AddReceiverFrameLog(test_rtp_timestamp().lower_32_bits(), 2, kTimeBaseMs);
   p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
   p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs);
 
   FrameEvent frame_event;
   frame_event.rtp_timestamp = test_rtp_timestamp();
   frame_event.type = FRAME_ACK_SENT;
   frame_event.media_type = VIDEO_EVENT;
   frame_event.timestamp = testing_clock.NowTicks();
   event_subscriber.OnReceiveFrameEvent(frame_event);
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 
   PacketEvent packet_event;
   packet_event.rtp_timestamp = test_rtp_timestamp();
   packet_event.type = PACKET_RECEIVED;
   packet_event.media_type = VIDEO_EVENT;
   packet_event.timestamp = testing_clock.NowTicks();
   packet_event.packet_id = kLostPacketId1;
   event_subscriber.OnReceivePacketEvent(packet_event);
   event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
   EXPECT_EQ(2u, rtcp_events.size());
 
   ExpectPacketEQ(p.GetPacket(),
                  BuildRtcpFromReceiver(&report_block, &rrtr, &cast_message,
-                                       &rtcp_events, kDefaultDelay));
+                                       nullptr, &rtcp_events, kDefaultDelay));
 }
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOversizedFrameLog) {
   static const uint32_t kTimeBaseMs = 12345678;
   static const uint32_t kTimeDelayMs = 10;
 
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
 
@@ skipping 28 matching lines @@
     packet_event.timestamp = testing_clock.NowTicks();
     packet_event.packet_id = kLostPacketId1;
     event_subscriber.OnReceivePacketEvent(packet_event);
     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
   ExpectPacketEQ(p.GetPacket(),
-                 BuildRtcpFromReceiver(&report_block, NULL, NULL, &rtcp_events,
-                                       kDefaultDelay));
+                 BuildRtcpFromReceiver(&report_block, nullptr, nullptr, nullptr,
+                                       &rtcp_events, kDefaultDelay));
 }
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithTooManyLogFrames) {
   static const uint32_t kTimeBaseMs = 12345678;
   static const uint32_t kTimeDelayMs = 10;
 
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
 
@@ skipping 23 matching lines @@
     frame_event.media_type = VIDEO_EVENT;
     frame_event.timestamp = testing_clock.NowTicks();
     event_subscriber.OnReceiveFrameEvent(frame_event);
     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
   ExpectPacketEQ(p.GetPacket(),
-                 BuildRtcpFromReceiver(&report_block, NULL, NULL, &rtcp_events,
-                                       kDefaultDelay));
+                 BuildRtcpFromReceiver(&report_block, nullptr, nullptr, nullptr,
+                                       &rtcp_events, kDefaultDelay));
 }
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOldLogFrames) {
   static const uint32_t kTimeBaseMs = 12345678;
 
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
 
   RtcpReportBlock report_block = GetReportBlock();
@@ skipping 22 matching lines @@
     frame_event.timestamp = testing_clock.NowTicks();
     event_subscriber.OnReceiveFrameEvent(frame_event);
     testing_clock.Advance(
         base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
   ExpectPacketEQ(p.GetPacket(),
-                 BuildRtcpFromReceiver(&report_block, NULL, NULL, &rtcp_events,
-                                       kDefaultDelay));
+                 BuildRtcpFromReceiver(&report_block, nullptr, nullptr, nullptr,
+                                       &rtcp_events, kDefaultDelay));
 }
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReportRedundancy) {
   uint32_t time_base_ms = 12345678;
   int kTimeBetweenEventsMs = 10;
 
   RtcpReportBlock report_block = GetReportBlock();
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(time_base_ms));
@@ skipping 22 matching lines @@
     frame_event.rtp_timestamp = test_rtp_timestamp();
     frame_event.type = FRAME_ACK_SENT;
     frame_event.media_type = VIDEO_EVENT;
     frame_event.timestamp = testing_clock.NowTicks();
     event_subscriber.OnReceiveFrameEvent(frame_event);
 
     ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
     event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
     ExpectPacketEQ(p.GetPacket(),
-                   BuildRtcpFromReceiver(&report_block, NULL, NULL,
-                                         &rtcp_events, kDefaultDelay));
+                   BuildRtcpFromReceiver(&report_block, nullptr, nullptr,
+                                         nullptr, &rtcp_events, kDefaultDelay));
 
     testing_clock.Advance(
         base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs));
     time_base_ms += kTimeBetweenEventsMs;
   }
 }
 
 TEST_F(RtcpBuilderTest, RtcpSenderReport) {
   RtcpSenderInfo sender_info;
   sender_info.ntp_seconds = kNtpHigh;
   sender_info.ntp_fraction = kNtpLow;
   sender_info.rtp_timestamp = test_rtp_timestamp();
   sender_info.send_packet_count = kSendPacketCount;
   sender_info.send_octet_count = kSendOctetCount;
 
   // Sender report.
   TestRtcpPacketBuilder p;
   p.AddSr(kSendingSsrc, 0);
 
   ExpectPacketEQ(p.GetPacket(),
                  rtcp_builder_->BuildRtcpFromSender(sender_info));
 }
 
 }  // namespace cast
 }  // namespace media