Cast: Refactor RTCP handling

chrome/browser/media/cast_transport_host_filter.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/browser/media/cast_transport_host_filter.h"
 
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "media/cast/net/cast_transport_sender.h"
 
@@ skipping 15 matching lines @@
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(CastTransportHostFilter, message)
     IPC_MESSAGE_HANDLER(CastHostMsg_New, OnNew)
     IPC_MESSAGE_HANDLER(CastHostMsg_Delete, OnDelete)
     IPC_MESSAGE_HANDLER(CastHostMsg_InitializeAudio, OnInitializeAudio)
     IPC_MESSAGE_HANDLER(CastHostMsg_InitializeVideo, OnInitializeVideo)
     IPC_MESSAGE_HANDLER(CastHostMsg_InsertCodedAudioFrame,
                         OnInsertCodedAudioFrame)
     IPC_MESSAGE_HANDLER(CastHostMsg_InsertCodedVideoFrame,
                         OnInsertCodedVideoFrame)
-    IPC_MESSAGE_HANDLER(CastHostMsg_SendRtcpFromRtpSender,
-                        OnSendRtcpFromRtpSender)
+    IPC_MESSAGE_HANDLER(CastHostMsg_SendSenderReport,
+                        OnSendSenderReport)
     IPC_MESSAGE_HANDLER(CastHostMsg_ResendPackets,
                         OnResendPackets)
     IPC_MESSAGE_UNHANDLED(handled = false);
   IPC_END_MESSAGE_MAP();
   return handled;
 }
 
 void CastTransportHostFilter::NotifyStatusChange(
     int32 channel_id,
     media::cast::CastTransportStatus status) {
   Send(new CastMsg_NotifyStatusChange(channel_id, status));
 }
 
-void CastTransportHostFilter::ReceivedPacket(
-    int32 channel_id,
-    scoped_ptr<media::cast::Packet> packet) {
-  Send(new CastMsg_ReceivedPacket(channel_id, *packet));
-}
-
 void CastTransportHostFilter::RawEvents(
     int32 channel_id,
-    const std::vector<media::cast::PacketEvent>& packet_events) {
+    const std::vector<media::cast::PacketEvent>& packet_events,
+    const std::vector<media::cast::FrameEvent>& frame_events) {
   if (!packet_events.empty())
-    Send(new CastMsg_RawEvents(channel_id, packet_events));
+    Send(new CastMsg_RawEvents(channel_id,
+                               packet_events,
+                               frame_events));
+}
+
+void CastTransportHostFilter::Rtt(int32 channel_id,
+                                  uint32 ssrc,
+                                  base::TimeDelta rtt,
+                                  base::TimeDelta avg_rtt,
+                                  base::TimeDelta min_rtt,
+                                  base::TimeDelta max_rtt) {
+  media::cast::RtcpRttReport report;
+  report.rtt = rtt;
+  report.avg_rtt = avg_rtt;
+  report.min_rtt = min_rtt;
+  report.max_rtt = max_rtt;
+  Send(new CastMsg_Rtt(channel_id, ssrc, report));
+}
+
+void CastTransportHostFilter::CastMessage(
+    int32 channel_id,
+    uint32 ssrc,
+    const media::cast::RtcpCastMessage& cast_message) {
+  Send(new CastMsg_RtcpCastMessage(channel_id, ssrc, cast_message));
 }
 
 void CastTransportHostFilter::OnNew(
     int32 channel_id,
     const net::IPEndPoint& remote_end_point) {
   if (id_map_.Lookup(channel_id)) {
     id_map_.Remove(channel_id);
   }
 
   scoped_ptr<media::cast::CastTransportSender> sender =
       media::cast::CastTransportSender::Create(
           g_browser_process->net_log(),
           &clock_,
           remote_end_point,
           base::Bind(&CastTransportHostFilter::NotifyStatusChange,
                      base::Unretained(this),
                      channel_id),
           base::Bind(&CastTransportHostFilter::RawEvents,
                      base::Unretained(this),
                      channel_id),
           base::TimeDelta::FromSeconds(kSendRawEventsIntervalSecs),
           base::MessageLoopProxy::current());
-
-  sender->SetPacketReceiver(base::Bind(&CastTransportHostFilter::ReceivedPacket,
-                                       base::Unretained(this),
-                                       channel_id));
-
   id_map_.AddWithID(sender.release(), channel_id);
 }
 
 void CastTransportHostFilter::OnDelete(int32 channel_id) {
   media::cast::CastTransportSender* sender =
       id_map_.Lookup(channel_id);
   if (sender) {
     id_map_.Remove(channel_id);
   } else {
     DVLOG(1) << "CastTransportHostFilter::Delete called "
              << "on non-existing channel";
   }
 }
 
 void CastTransportHostFilter::OnInitializeAudio(
     int32 channel_id,
     const media::cast::CastTransportRtpConfig& config) {
   media::cast::CastTransportSender* sender =
       id_map_.Lookup(channel_id);
   if (sender) {
-    sender->InitializeAudio(config);
+    sender->InitializeAudio(
+        config,
+        base::Bind(&CastTransportHostFilter::CastMessage,

[miu, 2014/07/18 00:06:22]

The base::Unretained() makes me nervous.  Can you write a quick comment about
why this is safe?

[Alpha Left Google, 2014/07/18 01:14:30]

Changed it to WeakPtr.

+                   base::Unretained(this),
+                   channel_id, config.ssrc),
+        base::Bind(&CastTransportHostFilter::Rtt,
+                   base::Unretained(this),
+                   channel_id, config.ssrc));
   } else {
     DVLOG(1)
         << "CastTransportHostFilter::OnInitializeAudio on non-existing channel";
   }
 }
 
 void CastTransportHostFilter::OnInitializeVideo(
     int32 channel_id,
     const media::cast::CastTransportRtpConfig& config) {
   media::cast::CastTransportSender* sender =
       id_map_.Lookup(channel_id);
   if (sender) {
-    sender->InitializeVideo(config);
+    sender->InitializeVideo(
+        config,
+        base::Bind(&CastTransportHostFilter::CastMessage,
+                   base::Unretained(this),
+                   channel_id, config.ssrc),
+        base::Bind(&CastTransportHostFilter::Rtt,
+                   base::Unretained(this),
+                   channel_id, config.ssrc));
   } else {
     DVLOG(1)
         << "CastTransportHostFilter::OnInitializeVideo on non-existing channel";
   }
 }
 
 void CastTransportHostFilter::OnInsertCodedAudioFrame(
     int32 channel_id,
     const media::cast::EncodedFrame& audio_frame) {
   media::cast::CastTransportSender* sender =
@@ skipping 14 matching lines @@
       id_map_.Lookup(channel_id);
   if (sender) {
     sender->InsertCodedVideoFrame(video_frame);
   } else {
     DVLOG(1)
         << "CastTransportHostFilter::OnInsertCodedVideoFrame "
         << "on non-existing channel";
   }
 }
 
-void CastTransportHostFilter::OnSendRtcpFromRtpSender(
+void CastTransportHostFilter::OnSendSenderReport(
     int32 channel_id,
-    const media::cast::SendRtcpFromRtpSenderData& data,
-    const media::cast::RtcpDlrrReportBlock& dlrr) {
+    uint32 ssrc,
+    base::TimeTicks current_time,
+    uint32 current_time_as_rtp_timestamp) {
   media::cast::CastTransportSender* sender =
       id_map_.Lookup(channel_id);
   if (sender) {
-    sender->SendRtcpFromRtpSender(data.packet_type_flags,
-                                  data.ntp_seconds,
-                                  data.ntp_fraction,
-                                  data.rtp_timestamp,
-                                  dlrr,
-                                  data.sending_ssrc,
-                                  data.c_name);
+    sender->SendSenderReport(ssrc,
+                             current_time,
+                             current_time_as_rtp_timestamp);
   } else {
     DVLOG(1)
-        << "CastTransportHostFilter::OnSendRtcpFromRtpSender "
+        << "CastTransportHostFilter::OnSendSenderReport "
         << "on non-existing channel";
   }
 }
 
 void CastTransportHostFilter::OnResendPackets(
     int32 channel_id,
     bool is_audio,
     const media::cast::MissingFramesAndPacketsMap& missing_packets,
     bool cancel_rtx_if_not_in_list,
     base::TimeDelta dedupe_window) {
   media::cast::CastTransportSender* sender =
       id_map_.Lookup(channel_id);
   if (sender) {
     sender->ResendPackets(
         is_audio, missing_packets, cancel_rtx_if_not_in_list, dedupe_window);
   } else {
     DVLOG(1)
         << "CastTransportHostFilter::OnResendPackets on non-existing channel";
   }
 }
 
 }  // namespace cast