Cast: Move retransmission to the 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 "media/cast/net/cast_transport_config.h"
 #include "media/cast/net/cast_transport_defines.h"
 #include "media/cast/net/udp_transport.h"
@@ skipping 93 matching lines @@
     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(cast_message_cb,
+      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));
   pacer_.RegisterAudioSsrc(config.ssrc);
   status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED);
 }
@@ skipping 10 matching lines @@
   }
 
   video_sender_.reset(new RtpSender(clock_, 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(cast_message_cb,
+      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));
   pacer_.RegisterVideoSsrc(config.ssrc);
   status_callback_.Run(TRANSPORT_VIDEO_INITIALIZED);
 }
@@ skipping 39 matching lines @@
         audio_sender_->send_packet_count(), audio_sender_->send_octet_count());
   } else if (video_sender_ && ssrc == video_sender_->ssrc()) {
     video_rtcp_session_->SendRtcpFromRtpSender(
         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::set<uint32>& frame_ids) {
+  if (audio_sender_ && ssrc == audio_sender_->ssrc()) {
+    audio_sender_->CancelSendingFrames(frame_ids);
+  } else if (video_sender_ && ssrc == video_sender_->ssrc()) {
+    video_sender_->CancelSendingFrames(frame_ids);
+  } else {
+    NOTREACHED() << "Invalid request for cancel sending.";
+  }
+}
+
+void CastTransportSenderImpl::ResendFrameForKickstart(uint32 ssrc,
+                                                      uint32 frame_id) {
+  if (audio_sender_ && ssrc == audio_sender_->ssrc()) {
+    DCHECK(audio_rtcp_session_);
+    audio_sender_->ResendFrameForKickstart(frame_id,
+                                           audio_rtcp_session_->rtt());
+  } else if (video_sender_ && ssrc == video_sender_->ssrc()) {
+    DCHECK(video_rtcp_session_);
+    video_sender_->ResendFrameForKickstart(frame_id,
+                                           video_rtcp_session_->rtt());
+  } else {
+    NOTREACHED() << "Invalid request for kickstart.";
+  }
+}
+
 void CastTransportSenderImpl::ResendPackets(
-    bool is_audio,
+    uint32 ssrc,
     const MissingFramesAndPacketsMap& missing_packets,
     bool cancel_rtx_if_not_in_list,
     base::TimeDelta dedupe_window) {
-  if (is_audio) {
-    DCHECK(audio_sender_) << "Audio sender uninitialized";
+  if (audio_sender_ && ssrc == audio_sender_->ssrc()) {
     audio_sender_->ResendPackets(missing_packets,
                                  cancel_rtx_if_not_in_list,
                                  dedupe_window);
-  } else {
-    DCHECK(video_sender_) << "Video sender uninitialized";
+  } else if (video_sender_ && ssrc == video_sender_->ssrc()) {
     video_sender_->ResendPackets(missing_packets,
                                  cancel_rtx_if_not_in_list,
                                  dedupe_window);
+  } else {
+    NOTREACHED() << "Invalid request for retransmission.";
   }
 }
 
 PacketReceiverCallback CastTransportSenderImpl::PacketReceiverForTesting() {
   return base::Bind(&CastTransportSenderImpl::OnReceivedPacket,
                     weak_factory_.GetWeakPtr());
 }
 
 void CastTransportSenderImpl::SendRawEvents() {
   DCHECK(event_subscriber_.get());
@@ skipping 56 matching lines @@
           break;
         default:
           VLOG(2) << "Received log message via RTCP that we did not expect: "
                   << static_cast<int>(event_it->type);
           break;
       }
     }
   }
 }
 
+void CastTransportSenderImpl::OnReceivedCastMessage(
+    uint32 ssrc,
+    const RtcpCastMessageCallback& cast_message_cb,
+    const RtcpCastMessage& cast_message) {
+  if (!cast_message_cb.is_null())
+    cast_message_cb.Run(cast_message);
+
+  if (cast_message.missing_frames_and_packets.empty())
+    return;
+
+  base::TimeDelta rtt;
+  if (video_sender_ && video_sender_->ssrc() == ssrc) {
+    rtt = video_rtcp_session_->rtt();
+  }
+
+  // This call does two things.
+  // 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,
+                rtt);
+}
+
 }  // namespace cast
 }  // namespace media