Add Cast PLI support on sender side.

media/cast/receiver/frame_receiver.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 "media/cast/receiver/frame_receiver.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/big_endian.h"
@@ skipping 177 matching lines @@
   ack_sent_event->timestamp = now;
   ack_sent_event->type = FRAME_ACK_SENT;
   ack_sent_event->media_type = event_media_type_;
   ack_sent_event->rtp_timestamp = rtp_timestamp;
   ack_sent_event->frame_id = cast_message.ack_frame_id;
   cast_environment_->logger()->DispatchFrameEvent(std::move(ack_sent_event));
 
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   event_subscriber_.GetRtcpEventsWithRedundancy(&rtcp_events);
   SendRtcpReport(rtcp_.local_ssrc(), rtcp_.remote_ssrc(),
-                 CreateRtcpTimeData(now), &cast_message, target_playout_delay_,
-                 &rtcp_events, NULL);
+                 CreateRtcpTimeData(now), &cast_message, nullptr,
+                 target_playout_delay_, &rtcp_events, nullptr);
 }
 
 void FrameReceiver::EmitAvailableEncodedFrames() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   while (!frame_request_queue_.empty()) {
     // Attempt to peek at the next completed frame from the |framer_|.
     // TODO(miu): We should only be peeking at the metadata, and not copying the
     // payload yet!  Or, at least, peek using a StringPiece instead of a copy.
     scoped_ptr<EncodedFrame> encoded_frame(
@@ skipping 132 matching lines @@
       base::Bind(&FrameReceiver::SendNextRtcpReport,
                  weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kRtcpReportIntervalMs));
 }
 
 void FrameReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   RtpReceiverStatistics stats = stats_.GetStatistics();
   SendRtcpReport(rtcp_.local_ssrc(), rtcp_.remote_ssrc(),
-                 CreateRtcpTimeData(now), NULL, base::TimeDelta(), NULL,
-                 &stats);
+                 CreateRtcpTimeData(now), nullptr, nullptr, base::TimeDelta(),
+                 nullptr, &stats);
   ScheduleNextRtcpReport();
 }
 
 void FrameReceiver::SendRtcpReport(
     uint32_t rtp_receiver_ssrc,
     uint32_t rtp_sender_ssrc,
     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) {
   transport_->InitializeRtpReceiverRtcpBuilder(rtp_receiver_ssrc, time_data);
   RtcpReportBlock report_block;
   if (rtp_receiver_statistics) {
     report_block.remote_ssrc = 0;  // Not needed to set send side.
     report_block.media_ssrc =
         rtp_sender_ssrc;  // SSRC of the RTP packet sender.
     report_block.fraction_lost = rtp_receiver_statistics->fraction_lost;
@@ skipping 12 matching lines @@
                              &delay_fraction);
       report_block.delay_since_last_sr =
           ConvertToNtpDiff(delay_seconds, delay_fraction);
     } else {
       report_block.delay_since_last_sr = 0;
     }
     transport_->AddRtpReceiverReport(report_block);
   }
   if (cast_message)
     transport_->AddCastFeedback(*cast_message, target_delay);
+  if (pli_message)
+    transport_->AddPli(*pli_message);
   if (rtcp_events)
     transport_->AddRtcpEvents(*rtcp_events);
   transport_->SendRtcpFromRtpReceiver();
 }
 
 }  // namespace cast
 }  // namespace media