Cast: Make receiver use cast_transport

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 "base/single_thread_task_runner.h"
 #include "base/values.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/net/cast_transport_defines.h"
@@ skipping 34 matching lines @@
   int32 min_send_buffer_size =
       LookupOptionWithDefault(options, kOptionSendBufferMinSize, 0);
   return std::max(max_burst_size, min_send_buffer_size);
 }
 
 }  // namespace
 
 scoped_ptr<CastTransportSender> CastTransportSender::Create(
     net::NetLog* net_log,
     base::TickClock* clock,
+    const net::IPEndPoint& local_end_point,
     const net::IPEndPoint& remote_end_point,
     scoped_ptr<base::DictionaryValue> options,
     const CastTransportStatusCallback& status_callback,
     const BulkRawEventsCallback& raw_events_callback,
     base::TimeDelta raw_events_callback_interval,
+    const PacketReceiverCallback& packet_callback,
     const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) {
   return scoped_ptr<CastTransportSender>(
       new CastTransportSenderImpl(net_log,
                                   clock,
+                                  local_end_point,
                                   remote_end_point,
                                   options.Pass(),
                                   status_callback,
                                   raw_events_callback,
                                   raw_events_callback_interval,
                                   transport_task_runner.get(),
+                                  packet_callback,
                                   NULL));
 }
 
 PacketReceiverCallback CastTransportSender::PacketReceiverForTesting() {
   return PacketReceiverCallback();
 }
 
 CastTransportSenderImpl::CastTransportSenderImpl(
     net::NetLog* net_log,
     base::TickClock* clock,
+    const net::IPEndPoint& local_end_point,
     const net::IPEndPoint& remote_end_point,
     scoped_ptr<base::DictionaryValue> options,
     const CastTransportStatusCallback& status_callback,
     const BulkRawEventsCallback& raw_events_callback,
     base::TimeDelta raw_events_callback_interval,
     const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner,
+    const PacketReceiverCallback& packet_callback,
     PacketSender* external_transport)
     : clock_(clock),
       status_callback_(status_callback),
       transport_task_runner_(transport_task_runner),
       transport_(
           external_transport ?
               NULL :
               new UdpTransport(net_log,
                                transport_task_runner,
-                               net::IPEndPoint(),
+                               local_end_point,
                                remote_end_point,
                                GetTransportSendBufferSize(*options),
                                status_callback)),
       pacer_(LookupOptionWithDefault(*options,
                                      kOptionPacerTargetBurstSize,
                                      kTargetBurstSize),
              LookupOptionWithDefault(*options,
                                      kOptionPacerMaxBurstSize,
                                      kMaxBurstSize),
              clock,
              &logging_,
              external_transport ? external_transport : transport_.get(),
              transport_task_runner),
       raw_events_callback_(raw_events_callback),
       raw_events_callback_interval_(raw_events_callback_interval),
       last_byte_acked_for_audio_(0),
+      packet_callback_(packet_callback),
       weak_factory_(this) {
   DCHECK(clock_);
   if (!raw_events_callback_.is_null()) {
     DCHECK(raw_events_callback_interval > base::TimeDelta());
     event_subscriber_.reset(new SimpleEventSubscriber);
     logging_.AddRawEventSubscriber(event_subscriber_.get());
     transport_task_runner->PostDelayedTask(
         FROM_HERE,
         base::Bind(&CastTransportSenderImpl::SendRawEvents,
                    weak_factory_.GetWeakPtr()),
         raw_events_callback_interval);
   }
   if (transport_) {
     if (options->HasKey(kOptionDscp)) {
       // The default DSCP value for cast is AF41. Which gives it a higher
       // priority over other traffic.
       transport_->SetDscp(net::DSCP_AF41);
     }
     transport_->StartReceiving(
         base::Bind(&CastTransportSenderImpl::OnReceivedPacket,
-                   weak_factory_.GetWeakPtr()));
+                   base::Unretained(this)));
     int wifi_options = 0;
     if (options->HasKey(kOptionWifiDisableScan)) {
       wifi_options |= net::WIFI_OPTIONS_DISABLE_SCAN;
     }
     if (options->HasKey(kOptionWifiMediaStreamingMode)) {
       wifi_options |= net::WIFI_OPTIONS_MEDIA_STREAMING_MODE;
     }
     if (wifi_options) {
       wifi_options_autoreset_ = net::SetWifiOptions(wifi_options);
     }
   }
 }
 
 CastTransportSenderImpl::~CastTransportSenderImpl() {
+  if (transport_) {
+    transport_->StopReceiving();
+  }
   if (event_subscriber_.get())
     logging_.RemoveRawEventSubscriber(event_subscriber_.get());
 }
 
 void CastTransportSenderImpl::InitializeAudio(
     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 audio with encryption DISABLED.";
@@ skipping 19 matching lines @@
                           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)) {
@@ skipping 13 matching lines @@
                           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) {
   if (encryptor->is_activated()) {
     EncodedFrame encrypted_frame;
     frame.CopyMetadataTo(&encrypted_frame);
@@ skipping 78 matching lines @@
   } else if (video_sender_ && ssrc == video_sender_->ssrc()) {
     video_sender_->ResendPackets(missing_packets,
                                  cancel_rtx_if_not_in_list,
                                  dedup_info);
   } else {
     NOTREACHED() << "Invalid request for retransmission.";
   }
 }
 
 PacketReceiverCallback CastTransportSenderImpl::PacketReceiverForTesting() {
-  return base::Bind(&CastTransportSenderImpl::OnReceivedPacket,
-                    weak_factory_.GetWeakPtr());
+  return base::Bind(
+      base::IgnoreResult(&CastTransportSenderImpl::OnReceivedPacket),
+      weak_factory_.GetWeakPtr());
 }
 
 void CastTransportSenderImpl::SendRawEvents() {
   DCHECK(event_subscriber_.get());
   DCHECK(!raw_events_callback_.is_null());
   std::vector<PacketEvent> packet_events;
   std::vector<FrameEvent> frame_events;
   event_subscriber_->GetPacketEventsAndReset(&packet_events);
   event_subscriber_->GetFrameEventsAndReset(&frame_events);
   raw_events_callback_.Run(packet_events, frame_events);
 
   transport_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&CastTransportSenderImpl::SendRawEvents,
                  weak_factory_.GetWeakPtr()),
       raw_events_callback_interval_);
 }
 
-void CastTransportSenderImpl::OnReceivedPacket(scoped_ptr<Packet> packet) {
+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);
+  } 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_ &&
-      audio_rtcp_session_->IncomingRtcpPacket(&packet->front(),
-                                              packet->size())) {
-    return;
+      audio_rtcp_session_->IncomingRtcpPacket(data, length)) {
+    return true;
   }
   if (video_rtcp_session_ &&
-      video_rtcp_session_->IncomingRtcpPacket(&packet->front(),
-                                              packet->size())) {
-    return;
+      video_rtcp_session_->IncomingRtcpPacket(data, length)) {
+    return true;
   }
-  VLOG(1) << "Stale packet received.";
+  if (packet_callback_.is_null()) {
+    VLOG(1) << "Stale packet received.";
+    return false;
+  }
+  packet_callback_.Run(packet.Pass());
+  return true;
 }
 
 void CastTransportSenderImpl::OnReceivedLogMessage(
     EventMediaType media_type,
     const RtcpReceiverLogMessage& log) {
   // Add received log messages into our log system.
   RtcpReceiverLogMessage::const_iterator it = log.begin();
   for (; it != log.end(); ++it) {
     uint32 rtp_timestamp = it->rtp_timestamp_;
 
@@ skipping 56 matching lines @@
   // 1. Specifies that retransmissions for packets not listed in the set are
   //    cancelled.
   // 2. Specifies a deduplication window. For video this would be the most
   //    recent RTT. For audio there is no deduplication.
   ResendPackets(ssrc,
                 cast_message.missing_frames_and_packets,
                 true,
                 dedup_info);
 }
 
+void CastTransportSenderImpl::AddValidSsrc(uint32 ssrc) {
+  valid_ssrcs_.insert(ssrc);
+}
+
+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);
+}
+
 }  // namespace cast
 }  // namespace media