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 29 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 34 matching lines @@
       channel_id_, rtp_receiver_ssrc, time_data));
 }
 
 void CastTransportSenderIPC::AddCastFeedback(
     const media::cast::RtcpCastMessage& cast_message,
     base::TimeDelta target_delay) {
   Send(
       new CastHostMsg_AddCastFeedback(channel_id_, cast_message, target_delay));
 }
 
+void CastTransportSenderIPC::AddPli(
+    const media::cast::RtcpPliMessage& pli_message) {
+  Send(new CastHostMsg_AddPli(channel_id_, pli_message));
+}
+
 void CastTransportSenderIPC::AddRtcpEvents(
     const media::cast::ReceiverRtcpEventSubscriber::RtcpEvents& rtcp_events) {
   Send(new CastHostMsg_AddRtcpEvents(channel_id_, rtcp_events));
 }
 
 void CastTransportSenderIPC::AddRtpReceiverReport(
     const media::cast::RtcpReportBlock& rtp_receiver_report_block) {
   Send(new CastHostMsg_AddRtpReceiverReport(channel_id_,
                                             rtp_receiver_report_block));
 }
@@ skipping 18 matching lines @@
   taken_frame_events->swap(
       const_cast<std::vector<media::cast::FrameEvent>&>(frame_events));
   scoped_ptr<std::vector<media::cast::PacketEvent>> taken_packet_events(
       new std::vector<media::cast::PacketEvent>());
   taken_packet_events->swap(
       const_cast<std::vector<media::cast::PacketEvent>&>(packet_events));
   raw_events_callback_.Run(std::move(taken_frame_events),
                            std::move(taken_packet_events));
 }
 
-void CastTransportSenderIPC::OnRtt(uint32_t ssrc, base::TimeDelta rtt) {
-  ClientMap::iterator it = clients_.find(ssrc);
+void CastTransportSenderIPC::OnRtt(uint32_t rtp_sender_ssrc,
+                                   base::TimeDelta rtt) {
+  ClientMap::iterator it = clients_.find(rtp_sender_ssrc);
   if (it == clients_.end()) {
-    LOG(ERROR) << "Received RTT report from for unknown SSRC: " << ssrc;
+    LOG(ERROR) << "Received RTT report for unknown SSRC: " << rtp_sender_ssrc;
     return;
   }
   if (!it->second.rtt_cb.is_null())
     it->second.rtt_cb.Run(rtt);
 }
 
 void CastTransportSenderIPC::OnRtcpCastMessage(
-    uint32_t ssrc,
+    uint32_t rtp_sender_ssrc,
     const media::cast::RtcpCastMessage& cast_message) {
-  ClientMap::iterator it = clients_.find(ssrc);
+  ClientMap::iterator it = clients_.find(rtp_sender_ssrc);
   if (it == clients_.end()) {
-    LOG(ERROR) << "Received cast message from for unknown SSRC: " << ssrc;
+    LOG(ERROR) << "Received cast message for unknown SSRC: " << rtp_sender_ssrc;
     return;
   }
   if (it->second.cast_message_cb.is_null())
     return;
   it->second.cast_message_cb.Run(cast_message);
 }
 
+void CastTransportSenderIPC::OnReceivedPli(uint32_t rtp_sender_ssrc) {
+  ClientMap::iterator it = clients_.find(rtp_sender_ssrc);
+  if (it == clients_.end()) {
+    LOG(ERROR) << "Received picture loss indicator for unknown SSRC: "
+               << rtp_sender_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;
   }
 }