Cast:Transport: Dividing A/V Initialization pipeline

media/cast/transport/cast_transport_sender_impl.cc

Index: media/cast/transport/cast_transport_sender_impl.cc
diff --git a/media/cast/transport/cast_transport_sender_impl.cc b/media/cast/transport/cast_transport_sender_impl.cc
index fd7139993c6fc0638e9c17cb02d17643e7b398f6..6df02c8278dd4f5f9359ab7cf27de74907a351b2 100644
--- a/media/cast/transport/cast_transport_sender_impl.cc
+++ b/media/cast/transport/cast_transport_sender_impl.cc
@@ -12,41 +12,63 @@ namespace media {
 namespace cast {
 namespace transport {
 
-CastTransportSender* CastTransportSender::CreateCastTransportSender(
+scoped_ptr<CastTransportSender> CastTransportSender::Create(
     base::TickClock* clock,
-    const CastTransportConfig& config,
+    const net::IPEndPoint& local_end_point,
+    const net::IPEndPoint& remote_end_point,
     const CastTransportStatusCallback& status_callback,
     const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) {
-  return new CastTransportSenderImpl(
-      clock, config, status_callback, transport_task_runner.get(), NULL);
+  return scoped_ptr<CastTransportSender>(
+      new CastTransportSenderImpl(clock,
+                                  local_end_point,
+                                  remote_end_point,
+                                  status_callback,
+                                  transport_task_runner.get(),
+                                  NULL));
 }
 
 CastTransportSenderImpl::CastTransportSenderImpl(
     base::TickClock* clock,
-    const CastTransportConfig& config,
+    const net::IPEndPoint& local_end_point,
+    const net::IPEndPoint& remote_end_point,
     const CastTransportStatusCallback& status_callback,
     const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner,
     PacketSender* external_transport)
-    : transport_(external_transport ? NULL
+    : clock_(clock),
+      status_callback_(status_callback),
+      transport_task_runner_(transport_task_runner),
+      transport_(external_transport ? NULL
                                     : new UdpTransport(transport_task_runner,
-                                                       config.local_endpoint,
-                                                       config.receiver_endpoint,
+                                                       local_end_point,
+                                                       remote_end_point,
                                                        status_callback)),
       pacer_(clock,
              external_transport ? external_transport : transport_.get(),
              transport_task_runner),
-      rtcp_builder_(&pacer_),
-      audio_sender_(config, clock, transport_task_runner, &pacer_),
-      video_sender_(config, clock, transport_task_runner, &pacer_) {
-  if (audio_sender_.initialized() && video_sender_.initialized()) {
-    status_callback.Run(TRANSPORT_INITIALIZED);
-  } else {
-    status_callback.Run(TRANSPORT_UNINITIALIZED);
-  }
-}
+      rtcp_builder_(&pacer_) {}
 
 CastTransportSenderImpl::~CastTransportSenderImpl() {}
 
+void CastTransportSenderImpl::InitializeAudio(
+    const CastTransportAudioConfig& config) {
+  audio_sender_.reset(new TransportAudioSender(
+      config, clock_, transport_task_runner_, &pacer_));
+  if (audio_sender_->initialized())
+    status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED);
+  else
+    status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED);
+}
+
+void CastTransportSenderImpl::InitializeVideo(
+    const CastTransportVideoConfig& config) {
+  video_sender_.reset(new TransportVideoSender(
+      config, clock_, transport_task_runner_, &pacer_));
+  if (video_sender_->initialized())
+    status_callback_.Run(TRANSPORT_VIDEO_INITIALIZED);
+  else
+    status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED);
+}
+
 void CastTransportSenderImpl::SetPacketReceiver(
     const PacketReceiverCallback& packet_receiver) {
   transport_->StartReceiving(packet_receiver);
@@ -55,13 +77,15 @@ void CastTransportSenderImpl::SetPacketReceiver(
 void CastTransportSenderImpl::InsertCodedAudioFrame(
     const EncodedAudioFrame* audio_frame,
     const base::TimeTicks& recorded_time) {
-  audio_sender_.InsertCodedAudioFrame(audio_frame, recorded_time);
+  DCHECK(audio_sender_) << "Audio sender uninitialized";
+  audio_sender_->InsertCodedAudioFrame(audio_frame, recorded_time);
 }
 
 void CastTransportSenderImpl::InsertCodedVideoFrame(
     const EncodedVideoFrame* video_frame,
     const base::TimeTicks& capture_time) {
-  video_sender_.InsertCodedVideoFrame(video_frame, capture_time);
+  DCHECK(video_sender_) << "Video sender uninitialized";
+  video_sender_->InsertCodedVideoFrame(video_frame, capture_time);
 }
 
 void CastTransportSenderImpl::SendRtcpFromRtpSender(
@@ -79,20 +103,24 @@ void CastTransportSenderImpl::ResendPackets(
     bool is_audio,
     const MissingFramesAndPacketsMap& missing_packets) {
   if (is_audio) {
-    audio_sender_.ResendPackets(missing_packets);
+    DCHECK(audio_sender_) << "Audio sender uninitialized";
+    audio_sender_->ResendPackets(missing_packets);
   } else {
-    video_sender_.ResendPackets(missing_packets);
+    DCHECK(video_sender_) << "Video sender uninitialized";
+    video_sender_->ResendPackets(missing_packets);
   }
 }
 
 void CastTransportSenderImpl::SubscribeAudioRtpStatsCallback(
     const CastTransportRtpStatistics& callback) {
-  audio_sender_.SubscribeAudioRtpStatsCallback(callback);
+  DCHECK(audio_sender_) << "Audio sender uninitialized";
+  audio_sender_->SubscribeAudioRtpStatsCallback(callback);
 }
 
 void CastTransportSenderImpl::SubscribeVideoRtpStatsCallback(
     const CastTransportRtpStatistics& callback) {
-  video_sender_.SubscribeVideoRtpStatsCallback(callback);
+  DCHECK(video_sender_) << "Audio sender uninitialized";
+  video_sender_->SubscribeVideoRtpStatsCallback(callback);
 }
 
 }  // namespace transport