Revert 249576 "Cast: Wiring up the asyc initialization with the ..."

> 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

Suspected cause of browser_tests/CastStreamingApiTest.Basics failure:
http://build.chromium.org/p/chromium.mac/builders/Mac%2010.6%20Tests%20%28dbg%29%281%29/builds/46664/steps/browser_tests/logs/stdio

TBR=pwestin@google.com

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

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

11 files changed, 60 insertions, 99 deletions

diff --git a/media/cast/video_sender/codecs/vp8/vp8_encoder.cc b/media/cast/video_sender/codecs/vp8/vp8_encoder.cc
index 7734bea..a073b9f0 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_);
 }
 
-bool Vp8Encoder::Initialize() {
+void Vp8Encoder::Initialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
   config_.reset(new vpx_codec_enc_cfg_t());
   encoder_.reset(new vpx_codec_ctx_t());
@@ -79,15 +79,14 @@ bool Vp8Encoder::Initialize() {
     acked_frame_buffers_[i] = true;
     used_buffers_frame_id_[i] = kStartFrameId;
   }
-  return InitEncode(cast_config_.number_of_cores);
+  InitEncode(cast_config_.number_of_cores);
 }
 
-bool Vp8Encoder::InitEncode(int number_of_cores) {
+void 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)) {
-    NOTREACHED() << "Invalid return value";
-    return false;
+    DCHECK(false) << "Invalid return value";
   }
   config_->g_w = cast_config_.width;
   config_->g_h = cast_config_.height;
@@ -131,16 +130,15 @@ bool Vp8Encoder::InitEncode(int number_of_cores) {
   // TODO(mikhal): Tune settings.
   if (vpx_codec_enc_init(
           encoder_.get(), vpx_codec_vp8_cx(), config_.get(), flags)) {
-    NOTREACHED() << "vpx_codec_enc_init() failed.";
+    DCHECK(false) << "vpx_codec_enc_init() failed.";
     encoder_.reset();
-    return false;
+    return;
   }
   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 413baf2..7cc3754 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.
-  bool Initialize();
+  void 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.
   };
 
-  bool InitEncode(int number_of_cores);
+  void 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 79a378e..f810e63 100644
--- a/media/cast/video_sender/external_video_encoder.cc
+++ b/media/cast/video_sender/external_video_encoder.cc
@@ -183,8 +183,7 @@ class LocalVideoEncodeAcceleratorClient
     cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
-        base::Bind(
-            &ExternalVideoEncoder::InitializationResult, weak_owner_, true));
+        base::Bind(&ExternalVideoEncoder::EncoderInitialized, weak_owner_));
   }
 
   virtual void NotifyError(VideoEncodeAccelerator::Error error) OVERRIDE {
@@ -198,8 +197,7 @@ class LocalVideoEncodeAcceleratorClient
     cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
-        base::Bind(
-            &ExternalVideoEncoder::InitializationResult, weak_owner_, false));
+        base::Bind(&ExternalVideoEncoder::EncoderError, weak_owner_));
   }
 
   // Called to allocate the input and output buffers.
@@ -352,11 +350,9 @@ class LocalVideoEncodeAcceleratorClient
 ExternalVideoEncoder::ExternalVideoEncoder(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
-    scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories,
-    const CastInitializationCallback& initialization_callback)
+    scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories)
     : video_config_(video_config),
       cast_environment_(cast_environment),
-      initialization_callback_(initialization_callback),
       encoder_active_(false),
       key_frame_requested_(false),
       skip_next_frame_(false),
@@ -382,19 +378,14 @@ ExternalVideoEncoder::~ExternalVideoEncoder() {
                  video_accelerator_client_));
 }
 
-void ExternalVideoEncoder::InitializationResult(bool success) {
+void ExternalVideoEncoder::EncoderInitialized() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  encoder_active_ = success;
-
-  CastInitializationStatus result;
-  if (success)
-    result = STATUS_INITIALIZED;
-  else
-    result = STATUS_GPU_ACCELERATION_ERROR;
+  encoder_active_ = true;
+}
 
-  cast_environment_->PostTask(CastEnvironment::MAIN,
-                              FROM_HERE,
-                              base::Bind(initialization_callback_, result));
+void ExternalVideoEncoder::EncoderError() {
+  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
+  encoder_active_ = false;
 }
 
 bool ExternalVideoEncoder::EncodeVideoFrame(
diff --git a/media/cast/video_sender/external_video_encoder.h b/media/cast/video_sender/external_video_encoder.h
index 1ce9b69..446cac5 100644
--- a/media/cast/video_sender/external_video_encoder.h
+++ b/media/cast/video_sender/external_video_encoder.h
@@ -28,8 +28,7 @@ class ExternalVideoEncoder : public VideoEncoder {
   ExternalVideoEncoder(
       scoped_refptr<CastEnvironment> cast_environment,
       const VideoSenderConfig& video_config,
-      scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories,
-      const CastInitializationCallback& initialization_callback);
+      scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories);
 
   virtual ~ExternalVideoEncoder();
 
@@ -53,14 +52,14 @@ class ExternalVideoEncoder : public VideoEncoder {
   virtual int NumberOfSkippedFrames() const OVERRIDE;
 
  protected:
-  void InitializationResult(bool success);
+  void EncoderInitialized();
+  void EncoderError();
 
  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 c71548e..8f9b2f7 100644
--- a/media/cast/video_sender/external_video_encoder_unittest.cc
+++ b/media/cast/video_sender/external_video_encoder_unittest.cc
@@ -100,13 +100,7 @@ class ExternalVideoEncoderTest : public ::testing::Test {
     video_encoder_.reset(new ExternalVideoEncoder(
         cast_environment_,
         video_config_,
-        new test::FakeGpuVideoAcceleratorFactories(task_runner_),
-        base::Bind(&ExternalVideoEncoderTest::CheckInitializationResult,
-                   base::Unretained(this))));
-  }
-
-  void CheckInitializationResult(CastInitializationStatus result) {
-    EXPECT_EQ(result, STATUS_INITIALIZED);
+        new test::FakeGpuVideoAcceleratorFactories(task_runner_)));
   }
 
   virtual ~ExternalVideoEncoderTest() {}
diff --git a/media/cast/video_sender/video_encoder_impl.cc b/media/cast/video_sender/video_encoder_impl.cc
index 18a36b0b..94b9840 100644
--- a/media/cast/video_sender/video_encoder_impl.cc
+++ b/media/cast/video_sender/video_encoder_impl.cc
@@ -32,31 +32,20 @@ void LogFrameEncodedEvent(const base::TimeTicks& now,
 }
 
 void InitializeVp8EncoderOnEncoderThread(
-    const scoped_refptr<CastEnvironment>& cast_environment,
-    const CastInitializationCallback& initialization_callback,
+    const scoped_refptr<CastEnvironment>& environment,
     Vp8Encoder* vp8_encoder) {
-  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));
-  }
+  DCHECK(environment->CurrentlyOn(CastEnvironment::VIDEO_ENCODER));
+  vp8_encoder->Initialize();
 }
 
 void EncodeVideoFrameOnEncoderThread(
-    const scoped_refptr<CastEnvironment>& cast_environment,
+    scoped_refptr<CastEnvironment> 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(cast_environment->CurrentlyOn(CastEnvironment::VIDEO_ENCODER));
+  DCHECK(environment->CurrentlyOn(CastEnvironment::VIDEO_ENCODER));
   if (dynamic_config.key_frame_requested) {
     vp8_encoder->GenerateKeyFrame();
   }
@@ -68,11 +57,11 @@ void EncodeVideoFrameOnEncoderThread(
       new transport::EncodedVideoFrame());
   bool retval = vp8_encoder->Encode(video_frame, encoded_frame.get());
 
-  base::TimeTicks now = cast_environment->Clock()->NowTicks();
-  cast_environment->PostTask(
+  base::TimeTicks now = environment->Clock()->NowTicks();
+  environment->PostTask(
       CastEnvironment::MAIN,
       FROM_HERE,
-      base::Bind(LogFrameEncodedEvent, now, cast_environment, capture_time));
+      base::Bind(LogFrameEncodedEvent, now, environment, capture_time));
 
   if (!retval) {
     VLOG(1) << "Encoding failed";
@@ -82,7 +71,7 @@ void EncodeVideoFrameOnEncoderThread(
     VLOG(1) << "Encoding resulted in an empty frame";
     return;
   }
-  cast_environment->PostTask(
+  environment->PostTask(
       CastEnvironment::MAIN,
       FROM_HERE,
       base::Bind(
@@ -93,11 +82,9 @@ 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) {
@@ -106,16 +93,11 @@ VideoEncoderImpl::VideoEncoderImpl(
                                 FROM_HERE,
                                 base::Bind(&InitializeVp8EncoderOnEncoderThread,
                                            cast_environment,
-                                           initialization_callback,
                                            vp8_encoder_.get()));
   } else {
-    NOTREACHED() << "Invalid config";  // Codec not supported.
-    cast_environment_->PostTask(CastEnvironment::MAIN,
-                                FROM_HERE,
-                                base::Bind(initialization_callback_,
-                                           STATUS_INVALID_VIDEO_CONFIGURATION));
-    return;
+    DCHECK(false) << "Invalid config";  // Codec not supported.
   }
+
   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 33dfd71..887a779 100644
--- a/media/cast/video_sender/video_encoder_impl.h
+++ b/media/cast/video_sender/video_encoder_impl.h
@@ -31,7 +31,6 @@ class VideoEncoderImpl : public VideoEncoder {
 
   VideoEncoderImpl(scoped_refptr<CastEnvironment> cast_environment,
                    const VideoSenderConfig& video_config,
-                   const CastInitializationCallback& initialization_callback,
                    uint8 max_unacked_frames);
 
   virtual ~VideoEncoderImpl();
@@ -58,7 +57,6 @@ 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 f95109a..6efcd6f 100644
--- a/media/cast/video_sender/video_encoder_impl_unittest.cc
+++ b/media/cast/video_sender/video_encoder_impl_unittest.cc
@@ -108,15 +108,7 @@ class VideoEncoderImplTest : public ::testing::Test {
 
   void Configure(uint8 max_unacked_frames) {
     video_encoder_.reset(new VideoEncoderImpl(
-        cast_environment_,
-        video_config_,
-        base::Bind(&VideoEncoderImplTest::CheckInitializationResult,
-                   base::Unretained(this)),
-        max_unacked_frames));
-  }
-
-  void CheckInitializationResult(CastInitializationStatus result) {
-    EXPECT_EQ(result, STATUS_INITIALIZED);
+        cast_environment_, video_config_, max_unacked_frames));
   }
 
   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 c4636ac..eeb2930 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_callback,
+    const CastInitializationCallback& initialization_status,
     transport::CastTransportSender* const transport_sender)
     : rtp_max_delay_(base::TimeDelta::FromMilliseconds(
           video_config.rtp_config.max_delay_ms)),
@@ -110,25 +110,32 @@ VideoSender::VideoSender(
       new LocalRtpVideoSenderStatistics(transport_sender));
 
   if (video_config.use_external_encoder) {
-    video_encoder_.reset(new ExternalVideoEncoder(cast_environment,
-        video_config, gpu_factories, initialization_callback));
+    video_encoder_.reset(new ExternalVideoEncoder(
+        cast_environment, video_config, gpu_factories));
   } else {
-    video_encoder_.reset(new VideoEncoderImpl(cast_environment, video_config,
-        initialization_callback, max_unacked_frames_));
+    video_encoder_.reset(new VideoEncoderImpl(
+        cast_environment, video_config, 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));
+  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));
 }
 
 VideoSender::~VideoSender() {}
diff --git a/media/cast/video_sender/video_sender.h b/media/cast/video_sender/video_sender.h
index 15f2e64..15688fe 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_callback,
+              const CastInitializationCallback& initialization_status,
               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 37ee946..aeffe233 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_callback,
+      const CastInitializationCallback& initialization_status,
       transport::CastTransportSender* const transport_sender)
       : VideoSender(cast_environment,
                     video_config,
                     gpu_factories,
-                    initialization_callback,
+                    initialization_status,
                     transport_sender) {}
   using VideoSender::OnReceivedCastFeedback;
 };