Cast: Flow hw encoder initialization error to extensions API

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/common/chrome_version_info.h"
@@ skipping 11 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;
 
+namespace {
+
+std::string CastErrorToString(media::cast::CastInitializationStatus status) {
+  switch (status) {
+    case media::cast::STATUS_INVALID_CAST_ENVIRONMENT:
+      return "Invalid cast environment.";
+    case media::cast::STATUS_INVALID_CRYPTO_CONFIGURATION:
+      return "Invalid encryption keys.";
+    case media::cast::STATUS_UNSUPPORTED_AUDIO_CODEC:
+      return "Audio codec not supported.";
+    case media::cast::STATUS_UNSUPPORTED_VIDEO_CODEC:
+      return "Video codec not supported.";
+    case media::cast::STATUS_INVALID_AUDIO_CONFIGURATION:
+      return "Invalid audio configuration.";
+    case media::cast::STATUS_INVALID_VIDEO_CONFIGURATION:
+      return "Invalid video configuration.";
+    case media::cast::STATUS_HW_VIDEO_ENCODER_NOT_SUPPORTED:
+      return "Hardware video encoder not supported.";
+    default:

[hubbe, 2014/09/09 00:25:45]

Remove the default so that we get a compile error if we don't cover all cases.

[Alpha Left Google, 2014/09/09 00:37:11]

Done.

+      NOTREACHED() << "Not an error.";
+      return "";
+  }
+}
+
+}  // namespace
+
 CastSessionDelegate::CastSessionDelegate()
     : io_message_loop_proxy_(
           content::RenderThread::Get()->GetIOMessageLoopProxy()),
       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());
 
   if (!cast_transport_ || !cast_sender_) {
     error_callback.Run("Destination not set.");
     return;
   }
 
   audio_frame_input_available_callback_ = callback;
   cast_sender_->InitializeAudio(
       config,
       base::Bind(&CastSessionDelegate::InitializationResultCB,
-                 weak_factory_.GetWeakPtr()));
+                 weak_factory_.GetWeakPtr(), error_callback));
 }
 
 void CastSessionDelegate::StartVideo(
     const VideoSenderConfig& config,
     const VideoFrameInputAvailableCallback& callback,
     const ErrorCallback& error_callback,
     const media::cast::CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const media::cast::CreateVideoEncodeMemoryCallback&
         create_video_encode_mem_cb) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (!cast_transport_ || !cast_sender_) {
     error_callback.Run("Destination not set.");
     return;
   }
 
   video_frame_input_available_callback_ = callback;
 
   cast_sender_->InitializeVideo(
       config,
       base::Bind(&CastSessionDelegate::InitializationResultCB,
-                 weak_factory_.GetWeakPtr()),
+                 weak_factory_.GetWeakPtr(), error_callback),
       create_vea_cb,
       create_video_encode_mem_cb);
 }
 
 void CastSessionDelegate::StartUDP(const net::IPEndPoint& remote_endpoint) {
   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(
@@ skipping 105 matching lines @@
   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::InitializationResultCB(
+    const ErrorCallback& error_callback,
     media::cast::CastInitializationStatus result) const {
   DCHECK(cast_sender_);
 
-  // TODO(pwestin): handle the error codes.
   if (result == media::cast::STATUS_AUDIO_INITIALIZED) {

[hubbe, 2014/09/09 00:25:45]

might be better to just inline CastErrorToString here...

[Alpha Left Google, 2014/09/09 00:37:11]

Done.

     audio_frame_input_available_callback_.Run(
         cast_sender_->audio_frame_input());
   } else if (result == media::cast::STATUS_VIDEO_INITIALIZED) {
     video_frame_input_available_callback_.Run(
         cast_sender_->video_frame_input());
+  } else if (result > media::cast::STATUS_VIDEO_INITIALIZED) {
+    error_callback.Run(CastErrorToString(result));
   }
 }
 
 void CastSessionDelegate::LogRawEvents(
     const std::vector<media::cast::PacketEvent>& packet_events,
     const std::vector<media::cast::FrameEvent>& frame_events) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   for (std::vector<media::cast::PacketEvent>::const_iterator it =
            packet_events.begin();
@@ skipping 23 matching lines @@
     } else {
       cast_environment_->Logging()->InsertFrameEvent(
           it->timestamp,
           it->type,
           it->media_type,
           it->rtp_timestamp,
           it->frame_id);
     }
   }
 }