Cast: Basic cast_receiver API for chrome.

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/callback_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 13 matching lines @@
 #include "media/cast/net/cast_transport_sender.h"
 
 using media::cast::AudioSenderConfig;
 using media::cast::CastEnvironment;
 using media::cast::CastSender;
 using media::cast::VideoSenderConfig;
 
 static base::LazyInstance<CastThreads> g_cast_threads =
     LAZY_INSTANCE_INITIALIZER;
 
-CastSessionDelegate::CastSessionDelegate()
+CastSessionDelegateBase::CastSessionDelegateBase()
     : io_message_loop_proxy_(
           content::RenderThread::Get()->GetIOMessageLoopProxy()),
       weak_factory_(this) {
   DCHECK(io_message_loop_proxy_.get());
 }
 
+CastSessionDelegateBase::~CastSessionDelegateBase() {
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+}
+
+void CastSessionDelegateBase::StartUDP(
+    const net::IPEndPoint& local_endpoint,
+    const net::IPEndPoint& remote_endpoint,
+    scoped_ptr<base::DictionaryValue> options) {
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+
+  // CastSender uses the renderer's IO thread as the main thread. This reduces
+  // thread hopping for incoming video frames and outgoing network packets.
+  cast_environment_ = new CastEnvironment(

[miu, 2015/02/11 02:52:50]

This is a little weird.  I would expect the CastEnvironment to be initialized in
the ctor initializor list, rather than when StartUDP is called.

[hubbe, 2015/02/11 22:38:17]

This is simply replicating existing (but perhaps somewhat odd) behavior.  I can
leave a TODO to clean it up later.

+      scoped_ptr<base::TickClock>(new base::DefaultTickClock()).Pass(),
+      base::MessageLoopProxy::current(),
+      g_cast_threads.Get().GetAudioEncodeMessageLoopProxy(),
+      g_cast_threads.Get().GetVideoEncodeMessageLoopProxy());
+
+  // 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,
+      options.Pass(),
+      media::cast::PacketReceiverCallback(),
+      base::Bind(&CastSessionDelegateBase::StatusNotificationCB,
+                 base::Unretained(this)),
+      base::Bind(&CastSessionDelegateBase::LogRawEvents,
+                 base::Unretained(this))));
+}
+
+void CastSessionDelegateBase::StatusNotificationCB(
+    media::cast::CastTransportStatus unused_status) {
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  // TODO(hubbe): Call javascript UDPTransport error function.
+}
+
+CastSessionDelegate::CastSessionDelegate()
+    : weak_factory_(this) {
+  DCHECK(io_message_loop_proxy_.get());
+}
+
 CastSessionDelegate::~CastSessionDelegate() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 }
 
 void CastSessionDelegate::StartAudio(
     const AudioSenderConfig& config,
     const AudioFrameInputAvailableCallback& callback,
     const ErrorCallback& error_callback) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
@@ skipping 26 matching lines @@
   video_frame_input_available_callback_ = callback;
 
   cast_sender_->InitializeVideo(
       config,
       base::Bind(&CastSessionDelegate::OnOperationalStatusChange,
                  weak_factory_.GetWeakPtr(), false, error_callback),
       create_vea_cb,
       create_video_encode_mem_cb);
 }
 
-void CastSessionDelegate::StartUDP(const net::IPEndPoint& remote_endpoint,
-                                   scoped_ptr<base::DictionaryValue> options) {
+
+void CastSessionDelegate::StartUDP(
+    const net::IPEndPoint& local_endpoint,
+    const net::IPEndPoint& remote_endpoint,
+    scoped_ptr<base::DictionaryValue> options) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
-
-  // CastSender uses the renderer's IO thread as the main thread. This reduces
-  // thread hopping for incoming video frames and outgoing network packets.
-  cast_environment_ = new CastEnvironment(
-      scoped_ptr<base::TickClock>(new base::DefaultTickClock()).Pass(),
-      base::MessageLoopProxy::current(),
-      g_cast_threads.Get().GetAudioEncodeMessageLoopProxy(),
-      g_cast_threads.Get().GetVideoEncodeMessageLoopProxy());
-
+  CastSessionDelegateBase::StartUDP(local_endpoint,
+                                    remote_endpoint,
+                                    options.Pass());
   event_subscribers_.reset(
       new media::cast::RawEventSubscriberBundle(cast_environment_));
 
-  // 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(
-      net::IPEndPoint(),
-      remote_endpoint,
-      options.Pass(),
-      media::cast::PacketReceiverCallback(),
-      base::Bind(&CastSessionDelegate::StatusNotificationCB,
-                 base::Unretained(this)),
-      base::Bind(&CastSessionDelegate::LogRawEvents, base::Unretained(this))));
-
   cast_sender_ = CastSender::Create(cast_environment_, cast_transport_.get());
 }
 
 void CastSessionDelegate::ToggleLogging(bool is_audio, bool enable) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   if (!event_subscribers_.get())
     return;
 
   if (enable)
     event_subscribers_->AddEventSubscribers(is_audio);
@@ skipping 72 matching lines @@
     callback.Run(make_scoped_ptr(new base::DictionaryValue).Pass());
     return;
   }
 
   scoped_ptr<base::DictionaryValue> stats = subscriber->GetStats();
   subscriber->Reset();
 
   callback.Run(stats.Pass());
 }
 
-void CastSessionDelegate::StatusNotificationCB(
-    media::cast::CastTransportStatus unused_status) {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
-  // TODO(hubbe): Call javascript UDPTransport error function.
-}
-
 void CastSessionDelegate::OnOperationalStatusChange(
     bool is_for_audio,
     const ErrorCallback& error_callback,
     media::cast::OperationalStatus status) {
   DCHECK(cast_sender_);
 
   switch (status) {
     case media::cast::STATUS_UNINITIALIZED:
     case media::cast::STATUS_CODEC_REINIT_PENDING:
       // Not an error.
@@ skipping 69 matching lines @@
     } else {
       cast_environment_->Logging()->InsertFrameEvent(
           it->timestamp,
           it->type,
           it->media_type,
           it->rtp_timestamp,
           it->frame_id);
     }
   }
 }