Cast: Javascript bindings for cast receiver

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 27 matching lines @@
   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) {
+    scoped_ptr<base::DictionaryValue> options,
+    const ErrorCallback& error_callback) {
   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.
   // TODO(hubbe): Create cast environment in ctor instead.
   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());
 
   // 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(),
       base::Bind(&CastSessionDelegateBase::ReceivePacket,
                  base::Unretained(this)),
       base::Bind(&CastSessionDelegateBase::StatusNotificationCB,
-                 base::Unretained(this)),
+                 base::Unretained(this), error_callback),
       base::Bind(&CastSessionDelegateBase::LogRawEvents,
                  base::Unretained(this))));
 }
 
 void CastSessionDelegateBase::StatusNotificationCB(
-    media::cast::CastTransportStatus unused_status) {
+    const ErrorCallback& error_callback,
+    media::cast::CastTransportStatus status) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
-  // TODO(hubbe): Call javascript UDPTransport error function.
+  std::string error_message;
+
+  switch (status) {
+    case media::cast::TRANSPORT_AUDIO_UNINITIALIZED:
+    case media::cast::TRANSPORT_VIDEO_UNINITIALIZED:
+    case media::cast::TRANSPORT_AUDIO_INITIALIZED:
+    case media::cast::TRANSPORT_VIDEO_INITIALIZED:
+      return; // Not errors, do nothing.
+    case media::cast::TRANSPORT_INVALID_CRYPTO_CONFIG:
+      error_callback.Run("Invalid encrypt/decrypt configuration.");
+      break;
+    case media::cast::TRANSPORT_SOCKET_ERROR:
+      error_callback.Run("Socket error.");
+      break;
+  }
 }
 
 CastSessionDelegate::CastSessionDelegate()
     : weak_factory_(this) {
   DCHECK(io_message_loop_proxy_.get());
 }
 
 CastSessionDelegate::~CastSessionDelegate() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 }
@@ skipping 37 matching lines @@
       base::Bind(&CastSessionDelegate::OnOperationalStatusChange,
                  weak_factory_.GetWeakPtr(), false, error_callback),
       create_vea_cb,
       create_video_encode_mem_cb);
 }
 
 
 void CastSessionDelegate::StartUDP(
     const net::IPEndPoint& local_endpoint,
     const net::IPEndPoint& remote_endpoint,
-    scoped_ptr<base::DictionaryValue> options) {
+    scoped_ptr<base::DictionaryValue> options,
+    const ErrorCallback& error_callback) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   CastSessionDelegateBase::StartUDP(local_endpoint,
                                     remote_endpoint,
-                                    options.Pass());
+                                    options.Pass(),
+                                    error_callback);
   event_subscribers_.reset(
       new media::cast::RawEventSubscriberBundle(cast_environment_));
 
   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;
@@ skipping 169 matching lines @@
     } else {
       cast_environment_->Logging()->InsertFrameEvent(
           it->timestamp,
           it->type,
           it->media_type,
           it->rtp_timestamp,
           it->frame_id);
     }
   }
 }