Cast: IPC glue between cast library transport and encoders.

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/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "chrome/renderer/media/cast_transport_sender_ipc.h"
 #include "content/public/renderer/p2p_socket_client.h"
 #include "content/public/renderer/render_thread.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_sender.h"
 #include "media/cast/logging/logging_defines.h"
 #include "media/cast/transport/cast_transport_config.h"
 #include "media/cast/transport/cast_transport_sender.h"
 
 using media::cast::AudioSenderConfig;
 using media::cast::CastEnvironment;
 using media::cast::CastSender;
 using media::cast::VideoSenderConfig;
 
-namespace {
-
-// This is a dummy class that does nothing. This is needed temporarily
-// to enable tests for cast.streaming extension APIs.
-// The real implementation of CastTransportSender is to use IPC to send
-// data to the browser process.
-// See crbug.com/327482 for more details.
-class DummyTransport : public media::cast::transport::CastTransportSender {
- public:
-  DummyTransport() {}
-  virtual ~DummyTransport() {}
-
-  // CastTransportSender implementations.
-  virtual void SetPacketReceiver(
-      const media::cast::transport::PacketReceiverCallback& packet_receiver)
-      OVERRIDE {}
-  virtual void InsertCodedAudioFrame(
-      const media::cast::transport::EncodedAudioFrame* audio_frame,
-      const base::TimeTicks& recorded_time) OVERRIDE {}
-  virtual void InsertCodedVideoFrame(
-      const media::cast::transport::EncodedVideoFrame* video_frame,
-      const base::TimeTicks& capture_time) OVERRIDE {}
-  virtual void SendRtcpFromRtpSender(
-      uint32 packet_type_flags,
-      const media::cast::transport::RtcpSenderInfo& sender_info,
-      const media::cast::transport::RtcpDlrrReportBlock& dlrr,
-      const media::cast::transport::RtcpSenderLogMessage& sender_log,
-      uint32 sending_ssrc,
-      const std::string& c_name) OVERRIDE {}
-  virtual void ResendPackets(
-      bool is_audio,
-      const media::cast::transport::MissingFramesAndPacketsMap& missing_packets)
-      OVERRIDE {}
-  virtual void RtpAudioStatistics(
-      const base::TimeTicks& now,
-      media::cast::transport::RtcpSenderInfo* sender_info) OVERRIDE {}
-  virtual void RtpVideoStatistics(
-      const base::TimeTicks& now,
-      media::cast::transport::RtcpSenderInfo* sender_info) OVERRIDE {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DummyTransport);
-};
-
-}  // namespace
-
 CastSessionDelegate::CastSessionDelegate()
     : audio_encode_thread_("CastAudioEncodeThread"),
       video_encode_thread_("CastVideoEncodeThread"),
       audio_configured_(false),
       video_configured_(false),
+      transport_configured_(false),
       io_message_loop_proxy_(
           content::RenderThread::Get()->GetIOMessageLoopProxy()) {
+  DCHECK(io_message_loop_proxy_.get());
 }
 
 CastSessionDelegate::~CastSessionDelegate() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 }
 
 void CastSessionDelegate::StartAudio(
     const AudioSenderConfig& config,
     const FrameInputAvailableCallback& callback) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   audio_configured_ = true;
   audio_config_ = config;
   frame_input_available_callbacks_.push_back(callback);
   StartSendingInternal();
 }
 
 void CastSessionDelegate::StartVideo(
     const VideoSenderConfig& config,
     const FrameInputAvailableCallback& callback) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   video_configured_ = true;
   video_config_ = config;
   frame_input_available_callbacks_.push_back(callback);
   StartSendingInternal();
 }
 
+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();
+}
+
+static void IgnoreStatusCB(
+    media::cast::transport::CastTransportStatus unused_status) {
+}
+
 // TODO(pwestin): This design does not work; as soon as audio or video is
 // initialized it will prevent the other from being enabled.
 void CastSessionDelegate::StartSendingInternal() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (cast_environment_)
     return;
 
-  if (!audio_configured_ || !video_configured_)
+  if (!audio_configured_ || !video_configured_ || !transport_configured_)

[mikhal1, 2014/02/05 21:09:43]

We must have the transport configured to be able to send packets and either
audio or video or both.

[hubbe, 2014/02/05 21:14:54]

Until Patrik's changes are checked in, the code only supports using audio *and*
video.

     return;
 
-  cast_transport_.reset(new DummyTransport());
+  media::cast::transport::CastTransportConfig config;
+
+  // TODO(hubbe): receiver_endpoint, local_endpoint
+  config.local_endpoint = local_endpoint_;
+  config.receiver_endpoint = remote_endpoint_;
+  config.audio_ssrc = audio_config_.sender_ssrc;
+  config.video_ssrc = video_config_.sender_ssrc;
+  config.audio_codec = audio_config_.codec;
+  config.video_codec = video_config_.codec;
+  config.audio_rtp_config = audio_config_.rtp_config;
+  config.video_rtp_config = video_config_.rtp_config;
+  config.audio_frequency = audio_config_.frequency;
+  config.audio_channels = audio_config_.channels;
+  // TODO(Hubbe): aes_key, aes_iv_mask
+
+  cast_transport_.reset(new cast::CastTransportSenderIPC(
+      config,
+      base::Bind(&IgnoreStatusCB)));
   audio_encode_thread_.Start();
   video_encode_thread_.Start();
 
   // CastSender uses the renderer's IO thread as the main thread. This reduces
   // thread hopping for incoming video frames and outgoing network packets.
   // There's no need to decode so no thread assigned for decoding.
   // Get default logging: All disabled.
   cast_environment_ = new CastEnvironment(
       scoped_ptr<base::TickClock>(new base::DefaultTickClock()).Pass(),
       base::MessageLoopProxy::current(),
       audio_encode_thread_.message_loop_proxy(),
       NULL,
       video_encode_thread_.message_loop_proxy(),
       NULL,
       base::MessageLoopProxy::current(),
       media::cast::GetDefaultCastSenderLoggingConfig());
 
   cast_sender_.reset(CastSender::CreateCastSender(
       cast_environment_,
       audio_config_,
       video_config_,
       NULL,  // GPU.
       base::Bind(&CastSessionDelegate::InitializationResult,
           base::Unretained(this)),
       cast_transport_.get()));
+  cast_transport_->SetPacketReceiver(cast_sender_->packet_receiver());
 }
 
 void CastSessionDelegate::InitializationResult(
     media::cast::CastInitializationStatus result) {
   DCHECK(cast_sender_);
 
   // TODO(pwestin): handle the error codes.
 
   for (size_t i = 0; i < frame_input_available_callbacks_.size(); ++i) {
     frame_input_available_callbacks_[i].Run(
         cast_sender_->frame_input());
   }
   frame_input_available_callbacks_.clear();
 }