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 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(

[dcheng, 2016/03/01 23:44:12]

Maybe the parameters shouldn't be const?

[xjz, 2016/03/02 04:24:17]

The const_cast is used here only for the purpose to set the scoped ptrs in
|params|. The content will not be modified. 

[dcheng, 2016/03/02 07:41:24]

But what's the point of making it const? Either the scoped_ptr<> itself should
contain a const pointer (rare) or the parameters should just be non-const.
const_cast<> is usually a sign to the reader that they have to pay more
attention because something tricky is happening. Using it like this just adds
noise to the signal.

[xjz, 2016/03/16 00:25:50]

Not applicable.

+        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.

[dcheng, 2016/03/01 23:44:12]

... so who frees this memory?

[xjz, 2016/03/02 04:24:17]

It will be released below (line 146).

[dcheng, 2016/03/02 07:41:24]

Reading the code, I understand how it works now: on the sending side, they are
unowned pointers but we stick them into a scoped_ptr anyway… and on the
receiving side, they need to be owned. But this is really weird and not a good
way to use scoped_ptr.

However, this is complex and hard to understand. Instead of having one uber
message with optional fields, can we just split this up into different IPC
messages?

In addition, once it's split up into different messages, there's no need to
worry about copies: IPCs bind to the arguments as const T&, and it makes no copy
before serializing arguments into the wire format.

[xjz, 2016/03/16 00:25:50]

Not applicable after refactor.

   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;
   }
 }