Cast: Make receiver use cast_transport

media/cast/net/cast_transport_sender_impl.cc

Index: media/cast/net/cast_transport_sender_impl.cc
diff --git a/media/cast/net/cast_transport_sender_impl.cc b/media/cast/net/cast_transport_sender_impl.cc
index 390180f131e907a66dd80ce592b324ac5ea5af91..4ef3017e10f146c405c3f102a316eb8e0ca459a5 100644
--- a/media/cast/net/cast_transport_sender_impl.cc
+++ b/media/cast/net/cast_transport_sender_impl.cc
@@ -52,21 +52,25 @@ int32 GetTransportSendBufferSize(const base::DictionaryValue& options) {
 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));
 }
 
@@ -77,12 +81,14 @@ PacketReceiverCallback CastTransportSender::PacketReceiverForTesting() {
 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),
@@ -92,7 +98,7 @@ CastTransportSenderImpl::CastTransportSenderImpl(
               NULL :
               new UdpTransport(net_log,
                                transport_task_runner,
-                               net::IPEndPoint(),
+                               local_end_point,
                                remote_end_point,
                                GetTransportSendBufferSize(*options),
                                status_callback)),
@@ -109,6 +115,7 @@ CastTransportSenderImpl::CastTransportSenderImpl(
       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()) {
@@ -129,7 +136,7 @@ CastTransportSenderImpl::CastTransportSenderImpl(
     }
     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;
@@ -144,6 +151,9 @@ CastTransportSenderImpl::CastTransportSenderImpl(
 }
 
 CastTransportSenderImpl::~CastTransportSenderImpl() {
+  if (transport_) {
+    transport_->StopReceiving();
+  }
   if (event_subscriber_.get())
     logging_.RemoveRawEventSubscriber(event_subscriber_.get());
 }
@@ -183,6 +193,7 @@ void CastTransportSenderImpl::InitializeAudio(
                config.ssrc,
                config.feedback_ssrc));
   pacer_.RegisterAudioSsrc(config.ssrc);
+  AddValidSsrc(config.feedback_ssrc);
   status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED);
 }
 
@@ -216,6 +227,7 @@ void CastTransportSenderImpl::InitializeVideo(
                config.ssrc,
                config.feedback_ssrc));
   pacer_.RegisterVideoSsrc(config.ssrc);
+  AddValidSsrc(config.feedback_ssrc);
   status_callback_.Run(TRANSPORT_VIDEO_INITIALIZED);
 }
 
@@ -314,8 +326,9 @@ void CastTransportSenderImpl::ResendPackets(
 }
 
 PacketReceiverCallback CastTransportSenderImpl::PacketReceiverForTesting() {
-  return base::Bind(&CastTransportSenderImpl::OnReceivedPacket,
-                    weak_factory_.GetWeakPtr());
+  return base::Bind(
+      base::IgnoreResult(&CastTransportSenderImpl::OnReceivedPacket),
+      weak_factory_.GetWeakPtr());
 }
 
 void CastTransportSenderImpl::SendRawEvents() {
@@ -334,18 +347,35 @@ void CastTransportSenderImpl::SendRawEvents() {
       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(
@@ -422,5 +452,31 @@ void CastTransportSenderImpl::OnReceivedCastMessage(
                 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