Cast:Transport: Dividing A/V Initialization pipeline

chrome/renderer/media/cast_session_delegate.cc

 // Copyright 2013 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 "chrome/renderer/media/cast_session_delegate.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "chrome/renderer/media/cast_threads.h"
@@ skipping 27 matching lines @@
 
 // Allow about 9MB for audio event logs. Assume serialized log data for
 // each frame will take up to 75 bytes.
 const int kMaxAudioEventEntries = kMaxSerializedBytes / 75;
 
 }  // namespace
 
 CastSessionDelegate::CastSessionDelegate()
     : transport_configured_(false),
       io_message_loop_proxy_(
-          content::RenderThread::Get()->GetIOMessageLoopProxy()) {
+          content::RenderThread::Get()->GetIOMessageLoopProxy()),
+      weak_factory_(this) {
   DCHECK(io_message_loop_proxy_);
 }
 
 CastSessionDelegate::~CastSessionDelegate() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (audio_event_subscriber_.get()) {
     cast_environment_->Logging()->RemoveRawEventSubscriber(
         audio_event_subscriber_.get());
   }
@@ skipping 35 matching lines @@
 void CastSessionDelegate::StartVideo(
     const VideoSenderConfig& config,
     const FrameInputAvailableCallback& callback) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   audio_frame_input_available_callback_ = callback;
 
   video_config_.reset(new VideoSenderConfig(config));
   StartSendingInternal();
 }
 
-void CastSessionDelegate::StartUDP(
-    const net::IPEndPoint& local_endpoint,
-    const net::IPEndPoint& remote_endpoint) {
+void CastSessionDelegate::StartUDP(const net::IPEndPoint& local_endpoint,
+                                   const net::IPEndPoint& remote_endpoint) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   transport_configured_ = true;
   local_endpoint_ = local_endpoint;
   remote_endpoint_ = remote_endpoint;
   StartSendingInternal();
 }
 
 void CastSessionDelegate::ToggleLogging(bool is_audio,
                                         bool enable) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
@@ skipping 30 matching lines @@
   }
 }
 
 void CastSessionDelegate::GetEventLogsAndReset(
     bool is_audio, const EventLogsCallback& callback) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   media::cast::EncodingEventSubscriber* subscriber = is_audio ?
       audio_event_subscriber_.get() : video_event_subscriber_.get();
   if (!subscriber) {
-    VLOG(2) << "Logging is currently disabled.";
     callback.Run(make_scoped_ptr(new std::string).Pass());
     return;
   }
 
   media::cast::FrameEventMap frame_events;
   media::cast::PacketEventMap packet_events;
   media::cast::RtpTimestamp rtp_timestamp;
 
   subscriber->GetEventsAndReset(&frame_events, &packet_events, &rtp_timestamp);
 
@@ skipping 26 matching lines @@
   // No transport, wait.
   if (!transport_configured_)
     return;
 
   // No audio or video, wait.
   if (!audio_config_ || !video_config_)
     return;
 
   Initialize();
 
-  media::cast::transport::CastTransportConfig config;
+  // Rationale for using unretained: The callback cannot be called after the
+  // destruction of CastTransportSenderIPC, and they both share the same thread.
+  cast_transport_.reset(new CastTransportSenderIPC(
+      local_endpoint_,
+      remote_endpoint_,
+      base::Bind(&CastSessionDelegate::StatusNotificationCB,
+                 base::Unretained(this))));
 
   // TODO(hubbe): set config.aes_key and config.aes_iv_mask.
-  config.local_endpoint = local_endpoint_;
-  config.receiver_endpoint = remote_endpoint_;
   if (audio_config_) {
-    config.audio_ssrc = audio_config_->sender_ssrc;
-    config.audio_codec = audio_config_->codec;
-    config.audio_rtp_config = audio_config_->rtp_config;
-    config.audio_frequency = audio_config_->frequency;
-    config.audio_channels = audio_config_->channels;
+    media::cast::transport::CastTransportAudioConfig config;
+    config.base.ssrc = audio_config_->sender_ssrc;
+    config.codec = audio_config_->codec;
+    config.base.rtp_config = audio_config_->rtp_config;
+    config.frequency = audio_config_->frequency;
+    config.channels = audio_config_->channels;
+    cast_transport_->InitializeAudio(config);
   }
   if (video_config_) {
-    config.video_ssrc = video_config_->sender_ssrc;
-    config.video_codec = video_config_->codec;
-    config.video_rtp_config = video_config_->rtp_config;
+    media::cast::transport::CastTransportVideoConfig config;
+    config.base.ssrc = video_config_->sender_ssrc;
+    config.codec = video_config_->codec;
+    config.base.rtp_config = video_config_->rtp_config;
+    cast_transport_->InitializeVideo(config);
   }
 
-  cast_transport_.reset(new CastTransportSenderIPC(
-      config,
-      base::Bind(&CastSessionDelegate::StatusNotificationCB,
-                 base::Unretained(this))));
-
   cast_sender_.reset(CastSender::CreateCastSender(
       cast_environment_,
       audio_config_.get(),
       video_config_.get(),
       NULL,  // GPU.
       base::Bind(&CastSessionDelegate::InitializationResult,
-                 base::Unretained(this)),
+                 weak_factory_.GetWeakPtr()),
       cast_transport_.get()));
   cast_transport_->SetPacketReceiver(cast_sender_->packet_receiver());
 }
 
 void CastSessionDelegate::InitializationResult(
     media::cast::CastInitializationStatus result) const {
   DCHECK(cast_sender_);
 
   // TODO(pwestin): handle the error codes.
   if (result == media::cast::STATUS_INITIALIZED) {
     if (!audio_frame_input_available_callback_.is_null()) {
       audio_frame_input_available_callback_.Run(cast_sender_->frame_input());
     }
     if (!video_frame_input_available_callback_.is_null()) {
       video_frame_input_available_callback_.Run(cast_sender_->frame_input());
     }
   }
 }