Cast: Flow hw encoder initialization error to extensions API

media/cast/sender/video_sender.cc

 // Copyright 2014 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 "media/cast/sender/video_sender.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/sender/external_video_encoder.h"
 #include "media/cast/sender/video_encoder_impl.h"
 
 namespace media {
 namespace cast {
 
 // Note, we use a fixed bitrate value when external video encoder is used.
 // Some hardware encoder shows bad behavior if we set the bitrate too
 // frequently, e.g. quality drop, not abiding by target bitrate, etc.
 // See details: crbug.com/392086.
 VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
+    const CastInitializationCallback& initialization_cb,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
     CastTransportSender* const transport_sender)
     : FrameSender(
         cast_environment,
         false,
         transport_sender,
         base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
         kVideoFrequency,
         video_config.ssrc,
         video_config.max_frame_rate,
         video_config.target_playout_delay,
         NewFixedCongestionControl(
             (video_config.min_bitrate + video_config.max_bitrate) / 2)),
       frames_in_encoder_(0),
       last_bitrate_(0),
       weak_factory_(this) {
   cast_initialization_status_ = STATUS_VIDEO_UNINITIALIZED;
   VLOG(1) << "max_unacked_frames is " << max_unacked_frames_
           << " for target_playout_delay="
           << target_playout_delay_.InMilliseconds() << " ms"
           << " and max_frame_rate=" << video_config.max_frame_rate;
   DCHECK_GT(max_unacked_frames_, 0);
 
   if (video_config.use_external_encoder) {
-    video_encoder_.reset(new ExternalVideoEncoder(cast_environment,
-                                                  video_config,
-                                                  create_vea_cb,
-                                                  create_video_encode_mem_cb));
+    video_encoder_.reset(new ExternalVideoEncoder(
+        cast_environment,
+        video_config,
+        base::Bind(&VideoSender::OnEncoderInitialized,
+                   weak_factory_.GetWeakPtr(), initialization_cb),
+        create_vea_cb,
+        create_video_encode_mem_cb));
   } else {
+    // Software encoder is initialized immediately.
     congestion_control_.reset(
         NewAdaptiveCongestionControl(cast_environment->Clock(),
                                      video_config.max_bitrate,
                                      video_config.min_bitrate,
                                      max_unacked_frames_));
     video_encoder_.reset(new VideoEncoderImpl(
         cast_environment, video_config, max_unacked_frames_));
+    cast_initialization_status_ = STATUS_VIDEO_INITIALIZED;
   }
-  cast_initialization_status_ = STATUS_VIDEO_INITIALIZED;
+
+  if (cast_initialization_status_ == STATUS_VIDEO_INITIALIZED) {
+    cast_environment->PostTask(
+        CastEnvironment::MAIN,
+        FROM_HERE,
+        base::Bind(initialization_cb, cast_initialization_status_));
+  }
 
   media::cast::CastTransportRtpConfig transport_config;
   transport_config.ssrc = video_config.ssrc;
   transport_config.feedback_ssrc = video_config.incoming_feedback_ssrc;
   transport_config.rtp_payload_type = video_config.rtp_payload_type;
   transport_config.stored_frames = max_unacked_frames_;
   transport_config.aes_key = video_config.aes_key;
   transport_config.aes_iv_mask = video_config.aes_iv_mask;
 
   transport_sender->InitializeVideo(
@@ skipping 59 matching lines @@
 }
 
 int VideoSender::GetNumberOfFramesInEncoder() const {
   return frames_in_encoder_;
 }
 
 void VideoSender::OnAck(uint32 frame_id) {
   video_encoder_->LatestFrameIdToReference(frame_id);
 }
 
+void VideoSender::OnEncoderInitialized(
+    const CastInitializationCallback& initialization_cb,
+    CastInitializationStatus status) {
+  cast_initialization_status_ = status;
+  initialization_cb.Run(status);
+}
+
 void VideoSender::OnEncodedVideoFrame(
     int encoder_bitrate,
     scoped_ptr<EncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   frames_in_encoder_--;
   DCHECK_GE(frames_in_encoder_, 0);
 
   SendEncodedFrame(encoder_bitrate, encoded_frame.Pass());
 }
 
 }  // namespace cast
 }  // namespace media