Add Cast PLI support on sender side.

media/cast/net/cast_transport_sender_impl.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/net/cast_transport_sender_impl.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <string>
 #include <utility>
@@ skipping 79 matching lines @@
       &CastTransportSenderImpl::OnReceivedPacket, base::Unretained(this)));
 }
 
 CastTransportSenderImpl::~CastTransportSenderImpl() {
   transport_->StopReceiving();
 }
 
 void CastTransportSenderImpl::InitializeAudio(
     const CastTransportRtpConfig& config,
     const RtcpCastMessageCallback& cast_message_cb,
-    const RtcpRttCallback& rtt_cb) {
+    const RtcpRttCallback& rtt_cb,
+    const RtcpPliCallback& pli_cb) {
   LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty())
       << "Unsafe to send audio with encryption DISABLED.";
   if (!audio_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) {
     transport_client_->OnStatusChanged(TRANSPORT_AUDIO_UNINITIALIZED);
     return;
   }
 
   audio_sender_.reset(new RtpSender(transport_task_runner_, &pacer_));
   if (audio_sender_->Initialize(config)) {
     // Audio packets have a higher priority.
     pacer_.RegisterAudioSsrc(config.ssrc);
     pacer_.RegisterPrioritySsrc(config.ssrc);
     transport_client_->OnStatusChanged(TRANSPORT_AUDIO_INITIALIZED);
   } else {
     audio_sender_.reset();
     transport_client_->OnStatusChanged(TRANSPORT_AUDIO_UNINITIALIZED);
     return;
   }
 
   audio_rtcp_session_.reset(new SenderRtcpSession(
       base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage,
                  weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb),
       rtt_cb, base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage,
                          weak_factory_.GetWeakPtr(), AUDIO_EVENT),
-      clock_, &pacer_, config.ssrc, config.feedback_ssrc));
+      pli_cb, clock_, &pacer_, config.ssrc, config.feedback_ssrc));
   pacer_.RegisterAudioSsrc(config.ssrc);
   valid_sender_ssrcs_.insert(config.feedback_ssrc);
   transport_client_->OnStatusChanged(TRANSPORT_AUDIO_INITIALIZED);
 }
 
 void CastTransportSenderImpl::InitializeVideo(
     const CastTransportRtpConfig& config,
     const RtcpCastMessageCallback& cast_message_cb,
-    const RtcpRttCallback& rtt_cb) {
+    const RtcpRttCallback& rtt_cb,
+    const RtcpPliCallback& pli_cb) {
   LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty())
       << "Unsafe to send video with encryption DISABLED.";
   if (!video_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) {
     transport_client_->OnStatusChanged(TRANSPORT_VIDEO_UNINITIALIZED);
     return;
   }
 
   video_sender_.reset(new RtpSender(transport_task_runner_, &pacer_));
   if (!video_sender_->Initialize(config)) {
     video_sender_.reset();
     transport_client_->OnStatusChanged(TRANSPORT_VIDEO_UNINITIALIZED);
     return;
   }
 
   video_rtcp_session_.reset(new SenderRtcpSession(
       base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage,
                  weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb),
       rtt_cb, base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage,
                          weak_factory_.GetWeakPtr(), VIDEO_EVENT),
-      clock_, &pacer_, config.ssrc, config.feedback_ssrc));
+      pli_cb, clock_, &pacer_, config.ssrc, config.feedback_ssrc));
   pacer_.RegisterVideoSsrc(config.ssrc);
   valid_sender_ssrcs_.insert(config.feedback_ssrc);
   transport_client_->OnStatusChanged(TRANSPORT_VIDEO_INITIALIZED);
 }
 
 namespace {
 void EncryptAndSendFrame(const EncodedFrame& frame,
                          TransportEncryptionHandler* encryptor,
                          RtpSender* sender) {
   // TODO(miu): We probably shouldn't attempt to send an empty frame, but this
@@ skipping 277 matching lines @@
     const RtcpCastMessage& cast_message,
     base::TimeDelta target_delay) {
   if (!rtcp_builder_at_rtp_receiver_) {
     VLOG(1) << "rtcp_builder_at_rtp_receiver_ is not initialized before "
                "calling CastTransportSenderImpl::AddCastFeedback.";
     return;
   }
   rtcp_builder_at_rtp_receiver_->AddCast(cast_message, target_delay);
 }
 
+void CastTransportSenderImpl::AddPli(const RtcpPliMessage& pli_message) {
+  if (!rtcp_builder_at_rtp_receiver_) {
+    VLOG(1) << "rtcp_builder_at_rtp_receiver_ is not initialized before "
+               "calling CastTransportSenderImpl::AddPli.";
+    return;
+  }
+  rtcp_builder_at_rtp_receiver_->AddPli(pli_message);
+}
+
 void CastTransportSenderImpl::AddRtcpEvents(
     const ReceiverRtcpEventSubscriber::RtcpEvents& rtcp_events) {
   if (!rtcp_builder_at_rtp_receiver_) {
     VLOG(1) << "rtcp_builder_at_rtp_receiver_ is not initialized before "
                "calling CastTransportSenderImpl::AddRtcpEvents.";
     return;
   }
   rtcp_builder_at_rtp_receiver_->AddReceiverLog(rtcp_events);
 }
 
@@ skipping 13 matching lines @@
                "calling CastTransportSenderImpl::SendRtcpFromRtpReceiver.";
     return;
   }
   pacer_.SendRtcpPacket(rtcp_builder_at_rtp_receiver_->local_ssrc(),
                         rtcp_builder_at_rtp_receiver_->Finish());
   rtcp_builder_at_rtp_receiver_.reset();
 }
 
 }  // namespace cast
 }  // namespace media