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 69 matching lines @@
       : sender_clock_(new base::SimpleTestTickClock()),
         receiver_clock_(new test::SkewedTickClock(sender_clock_.get())),
         sender_to_receiver_(sender_clock_.get()),
         receiver_to_sender_(sender_clock_.get()),
         rtcp_for_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(),
             &sender_to_receiver_,
             kSenderSsrc,
             kReceiverSsrc),
         rtcp_for_receiver_(receiver_clock_.get(),
                            &receiver_to_sender_,
                            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));
 
     sender_to_receiver_.set_rtcp_destination(&rtcp_for_receiver_);
     receiver_to_sender_.set_rtcp_destination(&rtcp_for_sender_);
   }
 
   ~RtcpTest() override {}
@@ skipping 18 matching lines @@
         RtcpReceiverEventLogMessage event_log;
         event_log.type = event_log_msg.type;
         event_log.event_timestamp = event_log_msg.event_timestamp;
         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);
       }
     }
   }
 
+  void OnReceivedPli() { received_pli_ = true; }
+
   scoped_ptr<base::SimpleTestTickClock> sender_clock_;
   scoped_ptr<test::SkewedTickClock> receiver_clock_;
   FakeRtcpTransport sender_to_receiver_;
   FakeRtcpTransport receiver_to_sender_;
   SenderRtcpSession rtcp_for_sender_;
   ReceiverRtcpSession rtcp_for_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 45 matching lines @@
     EXPECT_EQ(expected_rtt_according_to_sender,
               rtcp_for_sender_.current_round_trip_time());
 
     // Validate last reported callback value is same as that reported by method.
     EXPECT_EQ(current_round_trip_time_,
               rtcp_for_sender_.current_round_trip_time());
 
     // Receiver --> Sender
     RtpReceiverStatistics stats;
     rtcp_for_receiver_.SendRtcpReport(
-        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_for_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;
 
   rtcp_for_receiver_.SendRtcpReport(
-      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);
+  rtcp_for_receiver_.SendRtcpReport(
+      CreateRtcpTimeData(base::TimeTicks()), nullptr, &pli_message,
+      base::TimeDelta::FromMilliseconds(kTargetDelayMs), nullptr, nullptr);
+  EXPECT_TRUE(received_pli_);
+}
+
 TEST_F(RtcpTest, DropLateRtcpPacket) {
   RtcpCastMessage cast_message(kSenderSsrc);
   cast_message.ack_frame_id = 1;
   rtcp_for_receiver_.SendRtcpReport(
-      CreateRtcpTimeData(receiver_clock_->NowTicks()), &cast_message,
+      CreateRtcpTimeData(receiver_clock_->NowTicks()), &cast_message, 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;
   rtcp_for_receiver_.SendRtcpReport(
       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;
   rtcp_for_receiver_.SendRtcpReport(
       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));
 
   rtcp_for_receiver_.SendRtcpReport(
-      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