Add Cast PLI support on sender side.

chrome/renderer/media/cast_transport_sender_ipc.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 "chrome/renderer/media/cast_transport_sender_ipc.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/id_map.h"
@@ skipping 27 matching lines @@
 CastTransportSenderIPC::~CastTransportSenderIPC() {
   Send(new CastHostMsg_Delete(channel_id_));
   if (CastIPCDispatcher::Get()) {
     CastIPCDispatcher::Get()->RemoveSender(channel_id_);
   }
 }
 
 void CastTransportSenderIPC::InitializeAudio(
     const media::cast::CastTransportRtpConfig& config,
     const media::cast::RtcpCastMessageCallback& cast_message_cb,
-    const media::cast::RtcpRttCallback& rtt_cb) {
+    const media::cast::RtcpRttCallback& rtt_cb,
+    const media::cast::RtcpPliCallback& pli_cb) {
   clients_[config.ssrc].cast_message_cb = cast_message_cb;
   clients_[config.ssrc].rtt_cb = rtt_cb;
+  clients_[config.ssrc].pli_cb = pli_cb;
   Send(new CastHostMsg_InitializeAudio(channel_id_, config));
 }
 
 void CastTransportSenderIPC::InitializeVideo(
     const media::cast::CastTransportRtpConfig& config,
     const media::cast::RtcpCastMessageCallback& cast_message_cb,
-    const media::cast::RtcpRttCallback& rtt_cb) {
+    const media::cast::RtcpRttCallback& rtt_cb,
+    const media::cast::RtcpPliCallback& pli_cb) {
   clients_[config.ssrc].cast_message_cb = cast_message_cb;
   clients_[config.ssrc].rtt_cb = rtt_cb;
+  clients_[config.ssrc].pli_cb = pli_cb;
   Send(new CastHostMsg_InitializeVideo(channel_id_, config));
 }
 
 void CastTransportSenderIPC::InsertFrame(
     uint32_t ssrc,
     const media::cast::EncodedFrame& frame) {
   Send(new CastHostMsg_InsertFrame(channel_id_, ssrc, frame));
 }
 
 void CastTransportSenderIPC::SendSenderReport(
@@ skipping 23 matching lines @@
 
 void CastTransportSenderIPC::AddValidSsrc(uint32_t ssrc) {
   Send(new CastHostMsg_AddValidSsrc(channel_id_, ssrc));
 }
 
 void CastTransportSenderIPC::SendRtcpFromRtpReceiver(
     uint32_t ssrc,
     uint32_t sender_ssrc,
     const media::cast::RtcpTimeData& time_data,
     const media::cast::RtcpCastMessage* cast_message,
+    const media::cast::RtcpPliMessage* pli_message,
     base::TimeDelta target_delay,
     const media::cast::ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
     const media::cast::RtpReceiverStatistics* rtp_receiver_statistics) {
   // To avoid copies, we put pointers to objects we don't really
   // own into scoped pointers and then very carefully extract them again
   // before the scoped pointers go out of scope.
   media::cast::SendRtcpFromRtpReceiver_Params params;
   params.ssrc = ssrc;
   params.sender_ssrc = sender_ssrc;
   params.time_data = time_data;
   if (cast_message) {
     params.cast_message.reset(
         const_cast<media::cast::RtcpCastMessage*>(cast_message));
   }
+  if (pli_message) {
+    params.pli_message.reset(
+        const_cast<media::cast::RtcpPliMessage*>(pli_message));
+  }
   params.target_delay = target_delay;
   if (rtcp_events) {
     params.rtcp_events.reset(
         const_cast<media::cast::ReceiverRtcpEventSubscriber::RtcpEvents*>(
             rtcp_events));
   }
   if (rtp_receiver_statistics) {
     params.rtp_receiver_statistics.reset(
         const_cast<media::cast::RtpReceiverStatistics*>(
             rtp_receiver_statistics));
   }
   // Note, params contains scoped_ptr<>, but this still works because
   // CastHostMsg_SendRtcpFromRtpReceiver doesn't take ownership, it
   // serializes it and remember the serialized form instead.
   Send(new CastHostMsg_SendRtcpFromRtpReceiver(channel_id_, params));
 
   ignore_result(params.rtp_receiver_statistics.release());
   ignore_result(params.cast_message.release());
+  ignore_result(params.pli_message.release());
   ignore_result(params.rtcp_events.release());
 }
 
 
 void CastTransportSenderIPC::OnNotifyStatusChange(
     media::cast::CastTransportStatus status) {
   status_callback_.Run(status);
 }
 
 void CastTransportSenderIPC::OnRawEvents(
@@ skipping 30 matching lines @@
   ClientMap::iterator it = clients_.find(ssrc);
   if (it == clients_.end()) {
     LOG(ERROR) << "Received cast message from for unknown SSRC: " << ssrc;
     return;
   }
   if (it->second.cast_message_cb.is_null())
     return;
   it->second.cast_message_cb.Run(cast_message);
 }
 
+void CastTransportSenderIPC::OnReceivedPli(uint32_t ssrc) {
+  ClientMap::iterator it = clients_.find(ssrc);
+  if (it == clients_.end()) {
+    LOG(ERROR) << "Received picture loss indicator from for unknown SSRC: "
+               << ssrc;
+    return;
+  }
+  if (!it->second.pli_cb.is_null())
+    it->second.pli_cb.Run();
+}
+
 void CastTransportSenderIPC::OnReceivedPacket(
     const media::cast::Packet& packet) {
   if (!packet_callback_.is_null()) {
     // TODO(hubbe): Perhaps an non-ownership-transferring cb here?
     scoped_ptr<media::cast::Packet> packet_copy(
         new media::cast::Packet(packet));
     packet_callback_.Run(std::move(packet_copy));
   } else {
     DVLOG(1) << "CastIPCDispatcher::OnReceivedPacket no packet callback yet.";
   }
 }
 
 void CastTransportSenderIPC::Send(IPC::Message* message) {
   if (CastIPCDispatcher::Get()) {
     CastIPCDispatcher::Get()->Send(message);
   } else {
     delete message;
   }
 }