cast: Split Rtcp into two for sender and receiver

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 <algorithm>
+#include <string>
+
 #include "base/single_thread_task_runner.h"
 #include "base/values.h"
 #include "media/cast/net/cast_transport_defines.h"
+#include "media/cast/net/rtcp/receiver_rtcp_session.h"
+#include "media/cast/net/rtcp/sender_rtcp_session.h"
 #include "media/cast/net/udp_transport.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 // See header file for what these mean.
 const char kOptionDscp[] = "DSCP";
 #if defined(OS_WIN)
 const char kOptionDisableNonBlockingIO[] = "disable_non_blocking_io";
 #endif
 const char kOptionPacerTargetBurstSize[] = "pacer_target_burst_size";
 const char kOptionPacerMaxBurstSize[] = "pacer_max_burst_size";
 const char kOptionSendBufferMinSize[] = "send_buffer_min_size";
 const char kOptionWifiDisableScan[] = "disable_wifi_scan";
 const char kOptionWifiMediaStreamingMode[] = "media_streaming_mode";
 
 int LookupOptionWithDefault(const base::DictionaryValue& options,
                             const std::string& path,
                             int default_value) {
   int ret;
   if (options.GetInteger(path, &ret)) {
     return ret;
   } else {
     return default_value;
   }
-};
+}
 
 int32 GetTransportSendBufferSize(const base::DictionaryValue& options) {
   // Socket send buffer size needs to be at least greater than one burst
   // size.
   int32 max_burst_size =
       LookupOptionWithDefault(options, kOptionPacerMaxBurstSize,
                               kMaxBurstSize) * kMaxIpPacketSize;
   int32 min_send_buffer_size =
       LookupOptionWithDefault(options, kOptionSendBufferMinSize, 0);
   return std::max(max_burst_size, min_send_buffer_size);
@@ skipping 126 matching lines @@
     // Audio packets have a higher priority.
     pacer_.RegisterAudioSsrc(config.ssrc);
     pacer_.RegisterPrioritySsrc(config.ssrc);
     status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED);
   } else {
     audio_sender_.reset();
     status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED);
     return;
   }
 
-  audio_rtcp_session_.reset(
-      new Rtcp(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));
+  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));
   pacer_.RegisterAudioSsrc(config.ssrc);
   AddValidSsrc(config.feedback_ssrc);
   status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED);
 }
 
 void CastTransportSenderImpl::InitializeVideo(
     const CastTransportRtpConfig& config,
     const RtcpCastMessageCallback& cast_message_cb,
     const RtcpRttCallback& rtt_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)) {
     status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED);
     return;
   }
 
   video_sender_.reset(new RtpSender(transport_task_runner_, &pacer_));
   if (!video_sender_->Initialize(config)) {
     video_sender_.reset();
     status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED);
     return;
   }
 
-  video_rtcp_session_.reset(
-      new Rtcp(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));
+  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));
   pacer_.RegisterVideoSsrc(config.ssrc);
   AddValidSsrc(config.feedback_ssrc);
   status_callback_.Run(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 22 matching lines @@
   } else {
     NOTREACHED() << "Invalid InsertFrame call.";
   }
 }
 
 void CastTransportSenderImpl::SendSenderReport(
     uint32 ssrc,
     base::TimeTicks current_time,
     RtpTimeTicks current_time_as_rtp_timestamp) {
   if (audio_sender_ && ssrc == audio_sender_->ssrc()) {
-    audio_rtcp_session_->SendRtcpFromRtpSender(
+    audio_rtcp_session_->SendRtcpReport(
         current_time, current_time_as_rtp_timestamp,
         audio_sender_->send_packet_count(), audio_sender_->send_octet_count());
   } else if (video_sender_ && ssrc == video_sender_->ssrc()) {
-    video_rtcp_session_->SendRtcpFromRtpSender(
+    video_rtcp_session_->SendRtcpReport(
         current_time, current_time_as_rtp_timestamp,
         video_sender_->send_packet_count(), video_sender_->send_octet_count());
   } else {
     NOTREACHED() << "Invalid request for sending RTCP packet.";
   }
 }
 
 void CastTransportSenderImpl::CancelSendingFrames(
     uint32 ssrc,
     const std::vector<uint32>& frame_ids) {
@@ skipping 64 matching lines @@
       FROM_HERE,
       base::Bind(&CastTransportSenderImpl::SendRawEvents,
                  weak_factory_.GetWeakPtr()),
       raw_events_callback_interval_);
 }
 
 bool CastTransportSenderImpl::OnReceivedPacket(scoped_ptr<Packet> packet) {
   const uint8_t* const data = &packet->front();
   const size_t length = packet->size();
   uint32 ssrc;
-  if (Rtcp::IsRtcpPacket(data, length)) {
-    ssrc = Rtcp::GetSsrcOfSender(data, length);
+  if (IsRtcpPacket(data, length)) {
+    ssrc = GetSsrcOfSender(data, length);
   } else if (!RtpParser::ParseSsrc(data, length, &ssrc)) {
     VLOG(1) << "Invalid RTP packet.";
     return false;
   }
   if (valid_ssrcs_.find(ssrc) == valid_ssrcs_.end()) {
     VLOG(1) << "Stale packet received.";
     return false;
   }
 
   if (audio_rtcp_session_ &&
@@ skipping 96 matching lines @@
 }
 
 void CastTransportSenderImpl::SendRtcpFromRtpReceiver(
     uint32 ssrc,
     uint32 sender_ssrc,
     const RtcpTimeData& time_data,
     const RtcpCastMessage* cast_message,
     base::TimeDelta target_delay,
     const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
     const RtpReceiverStatistics* rtp_receiver_statistics) {
-  const Rtcp rtcp(RtcpCastMessageCallback(),
-                  RtcpRttCallback(),
-                  RtcpLogMessageCallback(),
-                  clock_,
-                  &pacer_,
-                  ssrc,
-                  sender_ssrc);
-  rtcp.SendRtcpFromRtpReceiver(time_data,
-                               cast_message,
-                               target_delay,
-                               rtcp_events,
-                               rtp_receiver_statistics);
+  const ReceiverRtcpSession rtcp(clock_, &pacer_, ssrc, sender_ssrc);
+  rtcp.SendRtcpReport(time_data, cast_message, target_delay, rtcp_events,

[miu, 2015/12/12 00:53:25]

Huh.  Interesting that this was in the CastTransportSENDERImpl.  ;-)  Perhaps
add a TODO and file a crbug (with Cr=Internals-Cast label) to resolve this code
factoring issue?

[Irfan, 2015/12/12 01:07:37]

will do because this is indeed confusing code, but the "sender" in transport and
"receiver" on RTCP are different entities (The RTP receiver still uses cast
transport sender IPC essentially)

+                      rtp_receiver_statistics);
 }
 
 }  // namespace cast
 }  // namespace media