[Cast] Repurpose CastInitializationStatus for variable frame size support.

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/logging.h"
-#include "base/message_loop/message_loop.h"
 #include "base/trace_event/trace_event.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"
 #include "media/cast/sender/video_frame_factory.h"
 
 #if defined(OS_MACOSX)
 #include "media/cast/sender/h264_vt_encoder.h"
 #endif
@@ skipping 16 matching lines @@
 
 }  // namespace
 
 // 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 StatusChangeCallback& status_change_cb,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
     CastTransportSender* const transport_sender,
     const PlayoutDelayChangeCB& playout_delay_change_cb)
     : FrameSender(
         cast_environment,
         false,
         transport_sender,
         base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
         kVideoFrequency,
         video_config.ssrc,
         video_config.max_frame_rate,
         video_config.min_playout_delay,
         video_config.max_playout_delay,
         video_config.use_external_encoder ?
             NewFixedCongestionControl(
                 (video_config.min_bitrate + video_config.max_bitrate) / 2) :
             NewAdaptiveCongestionControl(cast_environment->Clock(),
                                          video_config.max_bitrate,
                                          video_config.min_bitrate,
                                          video_config.max_frame_rate)),
       frames_in_encoder_(0),
       last_bitrate_(0),
       playout_delay_change_cb_(playout_delay_change_cb),
       weak_factory_(this) {
-  cast_initialization_status_ = STATUS_VIDEO_UNINITIALIZED;
-
 #if defined(OS_MACOSX)
   // On Apple platforms, use the hardware H.264 encoder if possible. It is the
   // only reasonable option for iOS.
   if (!video_config.use_external_encoder &&
       video_config.codec == CODEC_VIDEO_H264) {
     video_encoder_.reset(new H264VideoToolboxEncoder(
         cast_environment,
         video_config,
         gfx::Size(video_config.width, video_config.height),
-        base::Bind(&VideoSender::OnEncoderInitialized,
-                   weak_factory_.GetWeakPtr(),
-                   initialization_cb)));
+        status_change_cb));
   }
 #endif  // defined(OS_MACOSX)
 #if !defined(OS_IOS)
   if (video_config.use_external_encoder) {
     video_encoder_.reset(new ExternalVideoEncoder(
         cast_environment,
         video_config,
         gfx::Size(video_config.width, video_config.height),
-        base::Bind(&VideoSender::OnEncoderInitialized,
-                   weak_factory_.GetWeakPtr(), initialization_cb),
+        status_change_cb,
         create_vea_cb,
         create_video_encode_mem_cb));
   } else if (!video_encoder_) {
     // Software encoder is initialized immediately.
     video_encoder_.reset(new VideoEncoderImpl(
-        cast_environment, video_config, initialization_cb));
-    cast_initialization_status_ = STATUS_VIDEO_INITIALIZED;
+        cast_environment, video_config, status_change_cb));
   }
 #endif  // !defined(OS_IOS)
 
+  if (!video_encoder_) {
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN,
+        FROM_HERE,
+        base::Bind(status_change_cb, STATUS_UNSUPPORTED_CODEC));
+  }
+
   media::cast::CastTransportRtpConfig transport_config;
   transport_config.ssrc = video_config.ssrc;
   transport_config.feedback_ssrc = video_config.receiver_ssrc;
   transport_config.rtp_payload_type = video_config.rtp_payload_type;
   transport_config.aes_key = video_config.aes_key;
   transport_config.aes_iv_mask = video_config.aes_iv_mask;
 
   transport_sender->InitializeVideo(
       transport_config,
       base::Bind(&VideoSender::OnReceivedCastFeedback,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&VideoSender::OnMeasuredRoundTripTime,
                  weak_factory_.GetWeakPtr()));
 }
 
 VideoSender::~VideoSender() {
 }
 
 void VideoSender::InsertRawVideoFrame(
     const scoped_refptr<media::VideoFrame>& video_frame,
     const base::TimeTicks& reference_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  if (cast_initialization_status_ != STATUS_VIDEO_INITIALIZED) {
+
+  if (!video_encoder_) {
     NOTREACHED();
     return;
   }
-  DCHECK(video_encoder_.get()) << "Invalid state";
 
   const RtpTimestamp rtp_timestamp =
       TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency);
   const base::TimeTicks insertion_time = cast_environment_->Clock()->NowTicks();
   // TODO(miu): Plumb in capture timestamps.  For now, make it look like capture
   // took zero time by setting the BEGIN and END event to the same timestamp.
   cast_environment_->Logging()->InsertFrameEvent(
       insertion_time, FRAME_CAPTURE_BEGIN, VIDEO_EVENT, rtp_timestamp,
       kFrameIdUnknown);
   cast_environment_->Logging()->InsertFrameEvent(
@@ skipping 65 matching lines @@
     frames_in_encoder_++;
     duration_in_encoder_ += duration_added_by_next_frame;
     last_enqueued_frame_rtp_timestamp_ = rtp_timestamp;
     last_enqueued_frame_reference_time_ = reference_time;
   } else {
     VLOG(1) << "Encoder rejected a frame.  Skipping...";
   }
 }
 
 scoped_ptr<VideoFrameFactory> VideoSender::CreateVideoFrameFactory() {
-  DCHECK(cast_initialization_status_ == STATUS_VIDEO_INITIALIZED);
-  DCHECK(video_encoder_.get()) << "Invalid state";
-  return video_encoder_->CreateVideoFrameFactory();
+  return video_encoder_ ? video_encoder_->CreateVideoFrameFactory() : nullptr;
 }
 
 int VideoSender::GetNumberOfFramesInEncoder() const {
   return frames_in_encoder_;
 }
 
 base::TimeDelta VideoSender::GetInFlightMediaDuration() const {
   if (GetUnacknowledgedFrameCount() > 0) {
     const uint32 oldest_unacked_frame_id = latest_acked_frame_id_ + 1;
     return last_enqueued_frame_reference_time_ -
         GetRecordedReferenceTime(oldest_unacked_frame_id);
   } else {
     return duration_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);
 
   duration_in_encoder_ =
       last_enqueued_frame_reference_time_ - encoded_frame->reference_time;
 
   SendEncodedFrame(encoder_bitrate, encoded_frame.Pass());
 }
 
 }  // namespace cast
 }  // namespace media