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"
@@ skipping 20 matching lines @@
   if (!video_config.use_external_encoder)
     return 0;
   return (video_config.min_bitrate + video_config.max_bitrate) / 2;
 }
 
 }  // namespace
 
 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,
         transport_sender,
         base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
         kVideoFrequency,
         video_config.ssrc,
         video_config.max_frame_rate,
         video_config.target_playout_delay),
       fixed_bitrate_(GetFixedBitrate(video_config)),
       frames_in_encoder_(0),
       congestion_control_(cast_environment->Clock(),
                           video_config.max_bitrate,
                           video_config.min_bitrate,
                           max_unacked_frames_),
       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.
     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 121 matching lines @@
   congestion_control_.SendFrameToTransport(
       frame_id, encoded_frame->data.size() * 8, last_send_time_);
 
   if (send_target_playout_delay_) {
     encoded_frame->new_playout_delay_ms =
         target_playout_delay_.InMilliseconds();
   }
   transport_sender_->InsertFrame(ssrc_, *encoded_frame);
 }
 
+void VideoSender::OnEncoderInitialized(
+    const CastInitializationCallback& initialization_cb,
+    CastInitializationStatus status) {
+  cast_initialization_status_ = status;
+  initialization_cb.Run(status);
+}
+
 void VideoSender::OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   base::TimeDelta rtt;
   base::TimeDelta avg_rtt;
   base::TimeDelta min_rtt;
   base::TimeDelta max_rtt;
   if (is_rtt_available()) {
     rtt = rtt_;
     avg_rtt = avg_rtt_;
@@ skipping 92 matching lines @@
           << duration_in_flight.InMicroseconds() << " usec ("
           << (target_playout_delay_ > base::TimeDelta() ?
                   100 * duration_in_flight / target_playout_delay_ :
                   kint64max) << "%)";
   return frames_in_flight >= max_unacked_frames_ ||
       duration_in_flight >= target_playout_delay_;
 }
 
 }  // namespace cast
 }  // namespace media