Cast: Wiring up the asyc initialization with the video encoders.

This is a follow up cl to complete the async intialization.

Review URL: https://codereview.chromium.org/151103004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@249576 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 105 insertions, 66 deletions

diff --git a/media/cast/cast_sender_impl.cc b/media/cast/cast_sender_impl.cc
index 8d0ddc7..618ed55 100644
--- a/media/cast/cast_sender_impl.cc
+++ b/media/cast/cast_sender_impl.cc
@@ -56,13 +56,13 @@ CastSender* CastSender::CreateCastSender(
     const AudioSenderConfig& audio_config,
     const VideoSenderConfig& video_config,
     const scoped_refptr<GpuVideoAcceleratorFactories>& gpu_factories,
-    const CastInitializationCallback& initialization_status,
+    const CastInitializationCallback& initialization_callback,
     transport::CastTransportSender* const transport_sender) {
   return new CastSenderImpl(cast_environment,
                             audio_config,
                             video_config,
                             gpu_factories,
-                            initialization_status,
+                            initialization_callback,
                             transport_sender);
 }
 
@@ -71,13 +71,13 @@ CastSenderImpl::CastSenderImpl(
     const AudioSenderConfig& audio_config,
     const VideoSenderConfig& video_config,
     const scoped_refptr<GpuVideoAcceleratorFactories>& gpu_factories,
-    const CastInitializationCallback& initialization_status,
+    const CastInitializationCallback& initialization_callback,
     transport::CastTransportSender* const transport_sender)
     : audio_sender_(cast_environment, audio_config, transport_sender),
       video_sender_(cast_environment,
                     video_config,
                     gpu_factories,
-                    initialization_status,
+                    initialization_callback,
                     transport_sender),
       frame_input_(new LocalFrameInput(cast_environment,
                                        audio_sender_.AsWeakPtr(),
@@ -94,7 +94,7 @@ CastSenderImpl::CastSenderImpl(
   if (status != STATUS_INITIALIZED) {
     cast_environment->PostTask(CastEnvironment::MAIN,
                                FROM_HERE,
-                               base::Bind(initialization_status, status));
+                               base::Bind(initialization_callback, status));
     return;
   }
   // Handing over responsibility to call NotifyInitialization to the
diff --git a/media/cast/cast_sender_impl.h b/media/cast/cast_sender_impl.h
index e1a11ba..949864c 100644
--- a/media/cast/cast_sender_impl.h
+++ b/media/cast/cast_sender_impl.h
@@ -31,7 +31,7 @@ class CastSenderImpl : public CastSender {
       const AudioSenderConfig& audio_config,
       const VideoSenderConfig& video_config,
       const scoped_refptr<GpuVideoAcceleratorFactories>& gpu_factories,
-      const CastInitializationCallback& initialization_status,
+      const CastInitializationCallback& initialization_callback,
       transport::CastTransportSender* const transport_sender);
 
   virtual ~CastSenderImpl();
diff --git a/media/cast/video_sender/codecs/vp8/vp8_encoder.cc b/media/cast/video_sender/codecs/vp8/vp8_encoder.cc
index a073b9f0..7734bea 100644
--- a/media/cast/video_sender/codecs/vp8/vp8_encoder.cc
+++ b/media/cast/video_sender/codecs/vp8/vp8_encoder.cc
@@ -64,7 +64,7 @@ Vp8Encoder::~Vp8Encoder() {
   vpx_img_free(raw_image_);
 }
 
-void Vp8Encoder::Initialize() {
+bool Vp8Encoder::Initialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
   config_.reset(new vpx_codec_enc_cfg_t());
   encoder_.reset(new vpx_codec_ctx_t());
@@ -79,14 +79,15 @@ void Vp8Encoder::Initialize() {
     acked_frame_buffers_[i] = true;
     used_buffers_frame_id_[i] = kStartFrameId;
   }
-  InitEncode(cast_config_.number_of_cores);
+  return InitEncode(cast_config_.number_of_cores);
 }
 
-void Vp8Encoder::InitEncode(int number_of_cores) {
+bool Vp8Encoder::InitEncode(int number_of_cores) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Populate encoder configuration with default values.
   if (vpx_codec_enc_config_default(vpx_codec_vp8_cx(), config_.get(), 0)) {
-    DCHECK(false) << "Invalid return value";
+    NOTREACHED() << "Invalid return value";
+    return false;
   }
   config_->g_w = cast_config_.width;
   config_->g_h = cast_config_.height;
@@ -130,15 +131,16 @@ void Vp8Encoder::InitEncode(int number_of_cores) {
   // TODO(mikhal): Tune settings.
   if (vpx_codec_enc_init(
           encoder_.get(), vpx_codec_vp8_cx(), config_.get(), flags)) {
-    DCHECK(false) << "vpx_codec_enc_init() failed.";
+    NOTREACHED() << "vpx_codec_enc_init() failed.";
     encoder_.reset();
-    return;
+    return false;
   }
   vpx_codec_control(encoder_.get(), VP8E_SET_STATIC_THRESHOLD, 1);
   vpx_codec_control(encoder_.get(), VP8E_SET_NOISE_SENSITIVITY, 0);
   vpx_codec_control(encoder_.get(), VP8E_SET_CPUUSED, -6);
   vpx_codec_control(
       encoder_.get(), VP8E_SET_MAX_INTRA_BITRATE_PCT, rc_max_intra_target);
+  return true;
 }
 
 bool Vp8Encoder::Encode(const scoped_refptr<media::VideoFrame>& video_frame,
diff --git a/media/cast/video_sender/codecs/vp8/vp8_encoder.h b/media/cast/video_sender/codecs/vp8/vp8_encoder.h
index 7cc3754..413baf2 100644
--- a/media/cast/video_sender/codecs/vp8/vp8_encoder.h
+++ b/media/cast/video_sender/codecs/vp8/vp8_encoder.h
@@ -31,7 +31,7 @@ class Vp8Encoder {
 
   // Initialize the encoder before Encode() can be called. This method
   // must be called on the thread that Encode() is called.
-  void Initialize();
+  bool Initialize();
 
   // Encode a raw image (as a part of a video stream).
   bool Encode(const scoped_refptr<media::VideoFrame>& video_frame,
@@ -53,7 +53,7 @@ class Vp8Encoder {
     kNoBuffer = 3  // Note: must be last.
   };
 
-  void InitEncode(int number_of_cores);
+  bool InitEncode(int number_of_cores);
 
   // Calculate the max target in % for a keyframe.
   uint32 MaxIntraTarget(uint32 optimal_buffer_size) const;
diff --git a/media/cast/video_sender/external_video_encoder.cc b/media/cast/video_sender/external_video_encoder.cc
index f810e63..79a378e 100644
--- a/media/cast/video_sender/external_video_encoder.cc
+++ b/media/cast/video_sender/external_video_encoder.cc
@@ -183,7 +183,8 @@ class LocalVideoEncodeAcceleratorClient
     cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
-        base::Bind(&ExternalVideoEncoder::EncoderInitialized, weak_owner_));
+        base::Bind(
+            &ExternalVideoEncoder::InitializationResult, weak_owner_, true));
   }
 
   virtual void NotifyError(VideoEncodeAccelerator::Error error) OVERRIDE {
@@ -197,7 +198,8 @@ class LocalVideoEncodeAcceleratorClient
     cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
-        base::Bind(&ExternalVideoEncoder::EncoderError, weak_owner_));
+        base::Bind(
+            &ExternalVideoEncoder::InitializationResult, weak_owner_, false));
   }
 
   // Called to allocate the input and output buffers.
@@ -350,9 +352,11 @@ class LocalVideoEncodeAcceleratorClient
 ExternalVideoEncoder::ExternalVideoEncoder(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
-    scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories)
+    scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories,
+    const CastInitializationCallback& initialization_callback)
     : video_config_(video_config),
       cast_environment_(cast_environment),
+      initialization_callback_(initialization_callback),
       encoder_active_(false),
       key_frame_requested_(false),
       skip_next_frame_(false),
@@ -378,14 +382,19 @@ ExternalVideoEncoder::~ExternalVideoEncoder() {
                  video_accelerator_client_));
 }
 
-void ExternalVideoEncoder::EncoderInitialized() {
+void ExternalVideoEncoder::InitializationResult(bool success) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  encoder_active_ = true;
-}
+  encoder_active_ = success;
 
-void ExternalVideoEncoder::EncoderError() {
-  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  encoder_active_ = false;
+  CastInitializationStatus result;
+  if (success)
+    result = STATUS_INITIALIZED;
+  else
+    result = STATUS_GPU_ACCELERATION_ERROR;
+
+  cast_environment_->PostTask(CastEnvironment::MAIN,
+                              FROM_HERE,
+                              base::Bind(initialization_callback_, result));
 }
 
 bool ExternalVideoEncoder::EncodeVideoFrame(
diff --git a/media/cast/video_sender/external_video_encoder.h b/media/cast/video_sender/external_video_encoder.h
index 446cac5..1ce9b69 100644
--- a/media/cast/video_sender/external_video_encoder.h
+++ b/media/cast/video_sender/external_video_encoder.h
@@ -28,7 +28,8 @@ class ExternalVideoEncoder : public VideoEncoder {
   ExternalVideoEncoder(
       scoped_refptr<CastEnvironment> cast_environment,
       const VideoSenderConfig& video_config,
-      scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories);
+      scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories,
+      const CastInitializationCallback& initialization_callback);
 
   virtual ~ExternalVideoEncoder();
 
@@ -52,14 +53,14 @@ class ExternalVideoEncoder : public VideoEncoder {
   virtual int NumberOfSkippedFrames() const OVERRIDE;
 
  protected:
-  void EncoderInitialized();
-  void EncoderError();
+  void InitializationResult(bool success);
 
  private:
   friend class LocalVideoEncodeAcceleratorClient;
 
   const VideoSenderConfig video_config_;
   scoped_refptr<CastEnvironment> cast_environment_;
+  const CastInitializationCallback initialization_callback_;
 
   bool encoder_active_;
   bool key_frame_requested_;
diff --git a/media/cast/video_sender/external_video_encoder_unittest.cc b/media/cast/video_sender/external_video_encoder_unittest.cc
index 8f9b2f7..c71548e 100644
--- a/media/cast/video_sender/external_video_encoder_unittest.cc
+++ b/media/cast/video_sender/external_video_encoder_unittest.cc
@@ -100,7 +100,13 @@ class ExternalVideoEncoderTest : public ::testing::Test {
     video_encoder_.reset(new ExternalVideoEncoder(
         cast_environment_,
         video_config_,
-        new test::FakeGpuVideoAcceleratorFactories(task_runner_)));
+        new test::FakeGpuVideoAcceleratorFactories(task_runner_),
+        base::Bind(&ExternalVideoEncoderTest::CheckInitializationResult,
+                   base::Unretained(this))));
+  }
+
+  void CheckInitializationResult(CastInitializationStatus result) {
+    EXPECT_EQ(result, STATUS_INITIALIZED);
   }
 
   virtual ~ExternalVideoEncoderTest() {}
diff --git a/media/cast/video_sender/video_encoder_impl.cc b/media/cast/video_sender/video_encoder_impl.cc
index 94b9840..18a36b0b 100644
--- a/media/cast/video_sender/video_encoder_impl.cc
+++ b/media/cast/video_sender/video_encoder_impl.cc
@@ -32,20 +32,31 @@ void LogFrameEncodedEvent(const base::TimeTicks& now,
 }
 
 void InitializeVp8EncoderOnEncoderThread(
-    const scoped_refptr<CastEnvironment>& environment,
+    const scoped_refptr<CastEnvironment>& cast_environment,
+    const CastInitializationCallback& initialization_callback,
     Vp8Encoder* vp8_encoder) {
-  DCHECK(environment->CurrentlyOn(CastEnvironment::VIDEO_ENCODER));
-  vp8_encoder->Initialize();
+  DCHECK(cast_environment->CurrentlyOn(CastEnvironment::VIDEO_ENCODER));
+  if (vp8_encoder->Initialize()) {
+    cast_environment->PostTask(
+        CastEnvironment::MAIN,
+        FROM_HERE,
+        base::Bind(initialization_callback, STATUS_INITIALIZED));
+  } else {
+    cast_environment->PostTask(CastEnvironment::MAIN,
+                               FROM_HERE,
+                               base::Bind(initialization_callback,
+                                          STATUS_INVALID_VIDEO_CONFIGURATION));
+  }
 }
 
 void EncodeVideoFrameOnEncoderThread(
-    scoped_refptr<CastEnvironment> environment,
+    const scoped_refptr<CastEnvironment>& cast_environment,
     Vp8Encoder* vp8_encoder,
     const scoped_refptr<media::VideoFrame>& video_frame,
     const base::TimeTicks& capture_time,
     const VideoEncoderImpl::CodecDynamicConfig& dynamic_config,
     const VideoEncoderImpl::FrameEncodedCallback& frame_encoded_callback) {
-  DCHECK(environment->CurrentlyOn(CastEnvironment::VIDEO_ENCODER));
+  DCHECK(cast_environment->CurrentlyOn(CastEnvironment::VIDEO_ENCODER));
   if (dynamic_config.key_frame_requested) {
     vp8_encoder->GenerateKeyFrame();
   }
@@ -57,11 +68,11 @@ void EncodeVideoFrameOnEncoderThread(
       new transport::EncodedVideoFrame());
   bool retval = vp8_encoder->Encode(video_frame, encoded_frame.get());
 
-  base::TimeTicks now = environment->Clock()->NowTicks();
-  environment->PostTask(
+  base::TimeTicks now = cast_environment->Clock()->NowTicks();
+  cast_environment->PostTask(
       CastEnvironment::MAIN,
       FROM_HERE,
-      base::Bind(LogFrameEncodedEvent, now, environment, capture_time));
+      base::Bind(LogFrameEncodedEvent, now, cast_environment, capture_time));
 
   if (!retval) {
     VLOG(1) << "Encoding failed";
@@ -71,7 +82,7 @@ void EncodeVideoFrameOnEncoderThread(
     VLOG(1) << "Encoding resulted in an empty frame";
     return;
   }
-  environment->PostTask(
+  cast_environment->PostTask(
       CastEnvironment::MAIN,
       FROM_HERE,
       base::Bind(
@@ -82,9 +93,11 @@ void EncodeVideoFrameOnEncoderThread(
 VideoEncoderImpl::VideoEncoderImpl(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
+    const CastInitializationCallback& initialization_callback,
     uint8 max_unacked_frames)
     : video_config_(video_config),
       cast_environment_(cast_environment),
+      initialization_callback_(initialization_callback),
       skip_next_frame_(false),
       skip_count_(0) {
   if (video_config.codec == transport::kVp8) {
@@ -93,11 +106,16 @@ VideoEncoderImpl::VideoEncoderImpl(
                                 FROM_HERE,
                                 base::Bind(&InitializeVp8EncoderOnEncoderThread,
                                            cast_environment,
+                                           initialization_callback,
                                            vp8_encoder_.get()));
   } else {
-    DCHECK(false) << "Invalid config";  // Codec not supported.
+    NOTREACHED() << "Invalid config";  // Codec not supported.
+    cast_environment_->PostTask(CastEnvironment::MAIN,
+                                FROM_HERE,
+                                base::Bind(initialization_callback_,
+                                           STATUS_INVALID_VIDEO_CONFIGURATION));
+    return;
   }
-
   dynamic_config_.key_frame_requested = false;
   dynamic_config_.latest_frame_id_to_reference = kStartFrameId;
   dynamic_config_.bit_rate = video_config.start_bitrate;
diff --git a/media/cast/video_sender/video_encoder_impl.h b/media/cast/video_sender/video_encoder_impl.h
index 887a779..33dfd71 100644
--- a/media/cast/video_sender/video_encoder_impl.h
+++ b/media/cast/video_sender/video_encoder_impl.h
@@ -31,6 +31,7 @@ class VideoEncoderImpl : public VideoEncoder {
 
   VideoEncoderImpl(scoped_refptr<CastEnvironment> cast_environment,
                    const VideoSenderConfig& video_config,
+                   const CastInitializationCallback& initialization_callback,
                    uint8 max_unacked_frames);
 
   virtual ~VideoEncoderImpl();
@@ -57,6 +58,7 @@ class VideoEncoderImpl : public VideoEncoder {
  private:
   const VideoSenderConfig video_config_;
   scoped_refptr<CastEnvironment> cast_environment_;
+  const CastInitializationCallback initialization_callback_;
   CodecDynamicConfig dynamic_config_;
   bool skip_next_frame_;
   int skip_count_;
diff --git a/media/cast/video_sender/video_encoder_impl_unittest.cc b/media/cast/video_sender/video_encoder_impl_unittest.cc
index 6efcd6f..f95109a 100644
--- a/media/cast/video_sender/video_encoder_impl_unittest.cc
+++ b/media/cast/video_sender/video_encoder_impl_unittest.cc
@@ -108,7 +108,15 @@ class VideoEncoderImplTest : public ::testing::Test {
 
   void Configure(uint8 max_unacked_frames) {
     video_encoder_.reset(new VideoEncoderImpl(
-        cast_environment_, video_config_, max_unacked_frames));
+        cast_environment_,
+        video_config_,
+        base::Bind(&VideoEncoderImplTest::CheckInitializationResult,
+                   base::Unretained(this)),
+        max_unacked_frames));
+  }
+
+  void CheckInitializationResult(CastInitializationStatus result) {
+    EXPECT_EQ(result, STATUS_INITIALIZED);
   }
 
   base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
diff --git a/media/cast/video_sender/video_sender.cc b/media/cast/video_sender/video_sender.cc
index eeb2930..c4636ac 100644
--- a/media/cast/video_sender/video_sender.cc
+++ b/media/cast/video_sender/video_sender.cc
@@ -80,7 +80,7 @@ VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
     const scoped_refptr<GpuVideoAcceleratorFactories>& gpu_factories,
-    const CastInitializationCallback& initialization_status,
+    const CastInitializationCallback& initialization_callback,
     transport::CastTransportSender* const transport_sender)
     : rtp_max_delay_(base::TimeDelta::FromMilliseconds(
           video_config.rtp_config.max_delay_ms)),
@@ -110,32 +110,25 @@ VideoSender::VideoSender(
       new LocalRtpVideoSenderStatistics(transport_sender));
 
   if (video_config.use_external_encoder) {
-    video_encoder_.reset(new ExternalVideoEncoder(
-        cast_environment, video_config, gpu_factories));
+    video_encoder_.reset(new ExternalVideoEncoder(cast_environment,
+        video_config, gpu_factories, initialization_callback));
   } else {
-    video_encoder_.reset(new VideoEncoderImpl(
-        cast_environment, video_config, max_unacked_frames_));
+    video_encoder_.reset(new VideoEncoderImpl(cast_environment, video_config,
+        initialization_callback, max_unacked_frames_));
   }
 
-  rtcp_.reset(
-      new Rtcp(cast_environment_,
-               rtcp_feedback_.get(),
-               transport_sender_,
-               NULL,  // paced sender.
-               rtp_video_sender_statistics_.get(),
-               NULL,
-               video_config.rtcp_mode,
-               base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
-               video_config.sender_ssrc,
-               video_config.incoming_feedback_ssrc,
-               video_config.rtcp_c_name));
-
-  // TODO(pwestin): pass cast_initialization to |video_encoder_|
-  // and remove this call.
-  cast_environment->PostTask(
-      CastEnvironment::MAIN,
-      FROM_HERE,
-      base::Bind(initialization_status, STATUS_INITIALIZED));
+  rtcp_.reset(new Rtcp(
+      cast_environment_,
+      rtcp_feedback_.get(),
+      transport_sender_,
+      NULL,  // paced sender.
+      rtp_video_sender_statistics_.get(),
+      NULL,
+      video_config.rtcp_mode,
+      base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
+      video_config.sender_ssrc,
+      video_config.incoming_feedback_ssrc,
+      video_config.rtcp_c_name));
 }
 
 VideoSender::~VideoSender() {}
diff --git a/media/cast/video_sender/video_sender.h b/media/cast/video_sender/video_sender.h
index 15688fe..15f2e64 100644
--- a/media/cast/video_sender/video_sender.h
+++ b/media/cast/video_sender/video_sender.h
@@ -45,7 +45,7 @@ class VideoSender : public base::NonThreadSafe,
   VideoSender(scoped_refptr<CastEnvironment> cast_environment,
               const VideoSenderConfig& video_config,
               const scoped_refptr<GpuVideoAcceleratorFactories>& gpu_factories,
-              const CastInitializationCallback& initialization_status,
+              const CastInitializationCallback& initialization_callback,
               transport::CastTransportSender* const transport_sender);
 
   virtual ~VideoSender();
diff --git a/media/cast/video_sender/video_sender_unittest.cc b/media/cast/video_sender/video_sender_unittest.cc
index aeffe233..37ee946 100644
--- a/media/cast/video_sender/video_sender_unittest.cc
+++ b/media/cast/video_sender/video_sender_unittest.cc
@@ -64,12 +64,12 @@ class PeerVideoSender : public VideoSender {
       scoped_refptr<CastEnvironment> cast_environment,
       const VideoSenderConfig& video_config,
       const scoped_refptr<GpuVideoAcceleratorFactories>& gpu_factories,
-      const CastInitializationCallback& initialization_status,
+      const CastInitializationCallback& initialization_callback,
       transport::CastTransportSender* const transport_sender)
       : VideoSender(cast_environment,
                     video_config,
                     gpu_factories,
-                    initialization_status,
+                    initialization_callback,
                     transport_sender) {}
   using VideoSender::OnReceivedCastFeedback;
 };