Add Cast PLI support on sender side.

media/cast/net/rtcp/rtcp_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 <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 70 matching lines @@
       : sender_clock_(new base::SimpleTestTickClock()),
         receiver_clock_(new test::SkewedTickClock(sender_clock_.get())),
         rtp_sender_pacer_(sender_clock_.get()),
         rtp_receiver_pacer_(sender_clock_.get()),
         rtcp_at_rtp_sender_(
             base::Bind(&RtcpTest::OnReceivedCastFeedback,
                        base::Unretained(this)),
             base::Bind(&RtcpTest::OnMeasuredRoundTripTime,
                        base::Unretained(this)),
             base::Bind(&RtcpTest::OnReceivedLogs, base::Unretained(this)),
+            base::Bind(&RtcpTest::OnReceivedPli, base::Unretained(this)),
             sender_clock_.get(),
             &rtp_sender_pacer_,
             kSenderSsrc,
             kReceiverSsrc),
         rtcp_at_rtp_receiver_(receiver_clock_.get(),
                               kReceiverSsrc,
-                              kSenderSsrc) {
+                              kSenderSsrc),
+        received_pli_(false) {
     sender_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
     receiver_clock_->SetSkew(
         1.0,  // No skew.
         base::TimeDelta::FromSeconds(kInitialReceiverClockOffsetSeconds));
 
     rtp_sender_pacer_.set_rtcp_destination(&rtcp_at_rtp_receiver_);
     rtp_receiver_pacer_.set_rtcp_destination(&rtcp_at_rtp_sender_);
   }
 
   ~RtcpTest() override {}
@@ skipping 21 matching lines @@
         event_log.delay_delta = event_log_msg.delay_delta;
         event_log.packet_id = event_log_msg.packet_id;
         last_logs_.back().event_log_messages_.push_back(event_log);
       }
     }
   }
 
   PacketRef BuildRtcpPacketFromRtpReceiver(
       const RtcpTimeData& time_data,
       const RtcpCastMessage* cast_message,
+      const RtcpPliMessage* pli_message,
       base::TimeDelta target_delay,
       const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
       const RtpReceiverStatistics* rtp_receiver_statistics) {
     RtcpBuilder builder(rtcp_at_rtp_receiver_.local_ssrc());
     builder.Start();
     RtcpReceiverReferenceTimeReport rrtr;
     rrtr.ntp_seconds = time_data.ntp_seconds;
     rrtr.ntp_fraction = time_data.ntp_fraction;
     builder.AddRrtr(rrtr);
     RtcpReportBlock report_block;
@@ skipping 16 matching lines @@
                                &delay_fraction);
         report_block.delay_since_last_sr =
             ConvertToNtpDiff(delay_seconds, delay_fraction);
       } else {
         report_block.delay_since_last_sr = 0;
       }
       builder.AddRR(&report_block);
     }
     if (cast_message)
       builder.AddCast(*cast_message, target_delay);
+    if (pli_message)
+      builder.AddPli(*pli_message);
     if (rtcp_events)
       builder.AddReceiverLog(*rtcp_events);
     return builder.Finish();
   }
 
+  void OnReceivedPli() { received_pli_ = true; }
+
   scoped_ptr<base::SimpleTestTickClock> sender_clock_;
   scoped_ptr<test::SkewedTickClock> receiver_clock_;
   FakeRtcpTransport rtp_sender_pacer_;
   FakeRtcpTransport rtp_receiver_pacer_;
   SenderRtcpSession rtcp_at_rtp_sender_;
   ReceiverRtcpSession rtcp_at_rtp_receiver_;
 
   base::TimeDelta current_round_trip_time_;
   RtcpCastMessage last_cast_message_;
   RtcpReceiverLogMessage last_logs_;
+  bool received_pli_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RtcpTest);
 };
 
 TEST_F(RtcpTest, LipSyncGleanedFromSenderReport) {
   // Initially, expect no lip-sync info receiver-side without having first
   // received a RTCP packet.
   base::TimeTicks reference_time;
   RtpTimeTicks rtp_timestamp;
@@ skipping 47 matching lines @@
 
     // Validate last reported callback value is same as that reported by method.
     EXPECT_EQ(current_round_trip_time_,
               rtcp_at_rtp_sender_.current_round_trip_time());
 
     // Receiver --> Sender
     RtpReceiverStatistics stats;
     rtp_receiver_pacer_.SendRtcpPacket(
         rtcp_at_rtp_receiver_.local_ssrc(),
         BuildRtcpPacketFromRtpReceiver(
-            CreateRtcpTimeData(receiver_clock_->NowTicks()), nullptr,
+            CreateRtcpTimeData(receiver_clock_->NowTicks()), nullptr, nullptr,
             base::TimeDelta(), nullptr, &stats));
     expected_rtt_according_to_sender = one_way_trip_time * 2;
     EXPECT_EQ(expected_rtt_according_to_sender,
               rtcp_at_rtp_sender_.current_round_trip_time());
   }
 }
 
 TEST_F(RtcpTest, ReportCastFeedback) {
   RtcpCastMessage cast_message(kSenderSsrc);
   cast_message.ack_frame_id = 5;
   PacketIdSet missing_packets1 = {3, 4};
   cast_message.missing_frames_and_packets[1] = missing_packets1;
   PacketIdSet missing_packets2 = {5, 6};
   cast_message.missing_frames_and_packets[2] = missing_packets2;
 
   rtp_receiver_pacer_.SendRtcpPacket(
       rtcp_at_rtp_receiver_.local_ssrc(),
       BuildRtcpPacketFromRtpReceiver(
-          CreateRtcpTimeData(base::TimeTicks()), &cast_message,
+          CreateRtcpTimeData(base::TimeTicks()), &cast_message, nullptr,
           base::TimeDelta::FromMilliseconds(kTargetDelayMs), nullptr, nullptr));
 
   EXPECT_EQ(last_cast_message_.ack_frame_id, cast_message.ack_frame_id);
   EXPECT_EQ(last_cast_message_.target_delay_ms, kTargetDelayMs);
   EXPECT_EQ(last_cast_message_.missing_frames_and_packets.size(),
             cast_message.missing_frames_and_packets.size());
   EXPECT_TRUE(
       std::equal(cast_message.missing_frames_and_packets.begin(),
                  cast_message.missing_frames_and_packets.end(),
                  last_cast_message_.missing_frames_and_packets.begin()));
 }
 
+TEST_F(RtcpTest, ReportPli) {
+  RtcpPliMessage pli_message(kSenderSsrc);
+  rtp_receiver_pacer_.SendRtcpPacket(
+      rtcp_at_rtp_receiver_.local_ssrc(),
+      BuildRtcpPacketFromRtpReceiver(CreateRtcpTimeData(base::TimeTicks()),
+                                     nullptr, &pli_message, base::TimeDelta(),
+                                     nullptr, nullptr));
+  EXPECT_TRUE(received_pli_);
+}
+
 TEST_F(RtcpTest, DropLateRtcpPacket) {
   RtcpCastMessage cast_message(kSenderSsrc);
   cast_message.ack_frame_id = 1;
   rtp_receiver_pacer_.SendRtcpPacket(
       rtcp_at_rtp_receiver_.local_ssrc(),
       BuildRtcpPacketFromRtpReceiver(
           CreateRtcpTimeData(receiver_clock_->NowTicks()), &cast_message,
-          base::TimeDelta::FromMilliseconds(kTargetDelayMs), nullptr, nullptr));
+          nullptr, base::TimeDelta::FromMilliseconds(kTargetDelayMs), nullptr,
+          nullptr));
 
   // Send a packet with old timestamp
   RtcpCastMessage late_cast_message(kSenderSsrc);
   late_cast_message.ack_frame_id = 2;
   rtp_receiver_pacer_.SendRtcpPacket(
       rtcp_at_rtp_receiver_.local_ssrc(),
       BuildRtcpPacketFromRtpReceiver(
           CreateRtcpTimeData(receiver_clock_->NowTicks() -
                              base::TimeDelta::FromSeconds(10)),
-          &late_cast_message, base::TimeDelta(), nullptr, nullptr));
+          &late_cast_message, nullptr, base::TimeDelta(), nullptr, nullptr));
 
   // Validate data from second packet is dropped.
   EXPECT_EQ(last_cast_message_.ack_frame_id, cast_message.ack_frame_id);
   EXPECT_EQ(last_cast_message_.target_delay_ms, kTargetDelayMs);
 
   // Re-send with fresh timestamp
   late_cast_message.ack_frame_id = 2;
   rtp_receiver_pacer_.SendRtcpPacket(
       rtcp_at_rtp_receiver_.local_ssrc(),
       BuildRtcpPacketFromRtpReceiver(
           CreateRtcpTimeData(receiver_clock_->NowTicks()), &late_cast_message,
-          base::TimeDelta(), nullptr, nullptr));
+          nullptr, base::TimeDelta(), nullptr, nullptr));
   EXPECT_EQ(last_cast_message_.ack_frame_id, late_cast_message.ack_frame_id);
   EXPECT_EQ(last_cast_message_.target_delay_ms, 0);
 }
 
 TEST_F(RtcpTest, ReportReceiverEvents) {
   const RtpTimeTicks kRtpTimeStamp =
       media::cast::RtpTimeTicks().Expand(UINT32_C(100));
   const base::TimeTicks kEventTimestamp = receiver_clock_->NowTicks();
   const base::TimeDelta kDelayDelta = base::TimeDelta::FromMilliseconds(100);
 
   RtcpEvent event;
   event.type = FRAME_ACK_SENT;
   event.timestamp = kEventTimestamp;
   event.delay_delta = kDelayDelta;
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   rtcp_events.push_back(std::make_pair(kRtpTimeStamp, event));
 
   rtp_receiver_pacer_.SendRtcpPacket(
       rtcp_at_rtp_receiver_.local_ssrc(),
       BuildRtcpPacketFromRtpReceiver(
-          CreateRtcpTimeData(receiver_clock_->NowTicks()), nullptr,
+          CreateRtcpTimeData(receiver_clock_->NowTicks()), nullptr, nullptr,
           base::TimeDelta(), &rtcp_events, nullptr));
 
   ASSERT_EQ(1UL, last_logs_.size());
   RtcpReceiverFrameLogMessage frame_log = last_logs_.front();
   EXPECT_EQ(frame_log.rtp_timestamp_, kRtpTimeStamp);
 
   ASSERT_EQ(1UL, frame_log.event_log_messages_.size());
   RtcpReceiverEventLogMessage log_msg = frame_log.event_log_messages_.back();
   EXPECT_EQ(log_msg.type, event.type);
   EXPECT_EQ(log_msg.delay_delta, event.delay_delta);
   // Only 24 bits of event timestamp sent on wire.
   uint32_t event_ts =
       (event.timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff;
   uint32_t log_msg_ts =
       (log_msg.event_timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff;
   EXPECT_EQ(log_msg_ts, event_ts);
 }
 
 }  // namespace cast
 }  // namespace media