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 75 matching lines @@
   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) {
+  RtcpCastMessage cast_message(kSenderSsrc);
+  cast_message.picture_loss_indicator = true;
+  rtcp_for_receiver_.SendRtcpReport(
+      CreateRtcpTimeData(base::TimeTicks()), &cast_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,
       base::TimeDelta::FromMilliseconds(kTargetDelayMs), nullptr, nullptr);
 
   // Send a packet with old timestamp
   RtcpCastMessage late_cast_message(kSenderSsrc);
   late_cast_message.ack_frame_id = 2;
@@ skipping 43 matching lines @@
   // 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