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 64 matching lines @@
 };
 
 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(),
-                 rtcp_builder_->BuildRtcpFromReceiver(&report_block, NULL, NULL,
-                                                      NULL, kDefaultDelay));
+  ExpectPacketEQ(p2.GetPacket(), rtcp_builder_->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(),
-                 rtcp_builder_->BuildRtcpFromReceiver(
-                     &report_block, &rrtr, NULL, NULL, kDefaultDelay));
+  ExpectPacketEQ(p.GetPacket(), rtcp_builder_->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(),
-                 rtcp_builder_->BuildRtcpFromReceiver(
-                     &report_block, NULL, &cast_message, NULL, kDefaultDelay));
+  ExpectPacketEQ(p.GetPacket(), rtcp_builder_->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(),
-                 rtcp_builder_->BuildRtcpFromReceiver(
-                     &report_block, &rrtr, &cast_message, NULL, kDefaultDelay));
+  ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver(
+                                    &report_block, &rrtr, &cast_message,
+                                    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(), rtcp_builder_->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(), rtcp_builder_->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 27 matching lines @@
     packet_event.media_type = VIDEO_EVENT;
     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(),
-                 rtcp_builder_->BuildRtcpFromReceiver(
-                     &report_block, NULL, NULL, &rtcp_events, kDefaultDelay));
+  ExpectPacketEQ(p.GetPacket(), rtcp_builder_->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 22 matching lines @@
     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));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
-  ExpectPacketEQ(p.GetPacket(),
-                 rtcp_builder_->BuildRtcpFromReceiver(
-                     &report_block, NULL, NULL, &rtcp_events, kDefaultDelay));
+  ExpectPacketEQ(p.GetPacket(), rtcp_builder_->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 21 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(kTimeBetweenEventsMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
-  ExpectPacketEQ(p.GetPacket(),
-                 rtcp_builder_->BuildRtcpFromReceiver(
-                     &report_block, NULL, NULL, &rtcp_events, kDefaultDelay));
+  ExpectPacketEQ(p.GetPacket(), rtcp_builder_->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 21 matching lines @@
     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);
 
     ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
     event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
-    ExpectPacketEQ(p.GetPacket(),
-                   rtcp_builder_->BuildRtcpFromReceiver(
-                       &report_block, NULL, NULL, &rtcp_events, kDefaultDelay));
+    ExpectPacketEQ(p.GetPacket(), rtcp_builder_->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