[Cast] Cleanup: Remove TransportXXXXXSender, an unnecessary layer of indirection.

media/cast/video_sender/video_sender.cc

 // Copyright 2013 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/video_sender/video_sender.h"
 
 #include <cstring>
 #include <list>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 namespace cast {
 
 const int kNumAggressiveReportsSentAtStart = 100;
 const int kMinSchedulingDelayMs = 1;
 
 VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
-    const CastInitializationCallback& cast_initialization_cb,
     transport::CastTransportSender* const transport_sender)
     : rtp_max_delay_(base::TimeDelta::FromMilliseconds(
           video_config.rtp_config.max_delay_ms)),
       max_frame_rate_(video_config.max_frame_rate),
       cast_environment_(cast_environment),
       transport_sender_(transport_sender),
       rtp_timestamp_helper_(kVideoFrequency),
       num_aggressive_rtcp_reports_sent_(0),
       last_acked_frame_id_(-1),
       last_sent_frame_id_(-1),
       frames_in_encoder_(0),
       duplicate_ack_(0),
       last_skip_count_(0),
       current_requested_bitrate_(video_config.start_bitrate),
       congestion_control_(cast_environment->Clock(),
                           video_config.congestion_control_back_off,
                           video_config.max_bitrate,
                           video_config.min_bitrate,
                           video_config.start_bitrate),
+      cast_initialization_status_(STATUS_VIDEO_UNINITIALIZED),
       initialized_(false),
       active_session_(false),
       weak_factory_(this) {
   max_unacked_frames_ =
       1 + static_cast<uint8>(video_config.rtp_config.max_delay_ms *
                              max_frame_rate_ / 1000);
   VLOG(1) << "max_unacked_frames " << static_cast<int>(max_unacked_frames_);
   DCHECK_GT(max_unacked_frames_, 0) << "Invalid argument";
-
   if (video_config.use_external_encoder) {
     video_encoder_.reset(new ExternalVideoEncoder(cast_environment,
                                                   video_config,
                                                   create_vea_cb,
                                                   create_video_encode_mem_cb));
   } else {
     video_encoder_.reset(new VideoEncoderImpl(
         cast_environment, video_config, max_unacked_frames_));
   }
-
+  cast_initialization_status_ = STATUS_VIDEO_INITIALIZED;
 
   media::cast::transport::CastTransportVideoConfig transport_config;
   transport_config.codec = video_config.codec;
   transport_config.rtp.config = video_config.rtp_config;
   transport_config.rtp.max_outstanding_frames = max_unacked_frames_ + 1;
   transport_sender_->InitializeVideo(transport_config);
 
   rtcp_.reset(
       new Rtcp(cast_environment_,
                this,
                transport_sender_,
                NULL,  // paced sender.
                NULL,
                video_config.rtcp_mode,
                base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
                video_config.rtp_config.ssrc,
                video_config.incoming_feedback_ssrc,
                video_config.rtcp_c_name,
                VIDEO_EVENT));
   rtcp_->SetCastReceiverEventHistorySize(kReceiverRtcpEventHistorySize);
 
-  // TODO(pwestin): pass cast_initialization_cb to |video_encoder_|
-  // and remove this call.
-  cast_environment_->PostTask(
-      CastEnvironment::MAIN,
-      FROM_HERE,
-      base::Bind(cast_initialization_cb, STATUS_VIDEO_INITIALIZED));
-
   memset(frame_id_to_rtp_timestamp_, 0, sizeof(frame_id_to_rtp_timestamp_));
 }
 
 VideoSender::~VideoSender() {
 }
 
 void VideoSender::InitializeTimers() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (!initialized_) {
     initialized_ = true;
     ScheduleNextResendCheck();
     ScheduleNextSkippedFramesCheck();
   }
 }
 
 void VideoSender::InsertRawVideoFrame(
     const scoped_refptr<media::VideoFrame>& video_frame,
     const base::TimeTicks& capture_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
+  if (cast_initialization_status_ != STATUS_VIDEO_INITIALIZED) {
+    NOTREACHED();
+    return;
+  }
   DCHECK(video_encoder_.get()) << "Invalid state";
 
   RtpTimestamp rtp_timestamp = GetVideoRtpTimestamp(capture_time);
   cast_environment_->Logging()->InsertFrameEvent(
       capture_time, FRAME_CAPTURE_BEGIN, VIDEO_EVENT,
       rtp_timestamp, kFrameIdUnknown);
   cast_environment_->Logging()->InsertFrameEvent(
       cast_environment_->Clock()->NowTicks(),
       FRAME_CAPTURE_END, VIDEO_EVENT,
       rtp_timestamp,
       kFrameIdUnknown);
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT2(
       "cast_perf_test", "InsertRawVideoFrame",
       TRACE_EVENT_SCOPE_THREAD,
       "timestamp", capture_time.ToInternalValue(),
       "rtp_timestamp", rtp_timestamp);
 
   if (video_encoder_->EncodeVideoFrame(
           video_frame,
           capture_time,
-          base::Bind(&VideoSender::SendEncodedVideoFrameMainThread,
+          base::Bind(&VideoSender::SendEncodedVideoFrame,
                      weak_factory_.GetWeakPtr(),
                      current_requested_bitrate_))) {
     frames_in_encoder_++;
     UpdateFramesInFlight();
   }
 }
 
-void VideoSender::SendEncodedVideoFrameMainThread(
+void VideoSender::SendEncodedVideoFrame(
     int requested_bitrate_before_encode,
     scoped_ptr<transport::EncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   VLOG_IF(1, encoded_frame->dependency == transport::EncodedFrame::KEY)
       << "Send encoded key frame; frame_id: " << encoded_frame->frame_id;
 
   DCHECK_GT(frames_in_encoder_, 0);
   frames_in_encoder_--;
   uint32 frame_id = encoded_frame->frame_id;
   cast_environment_->Logging()->InsertEncodedFrameEvent(
       last_send_time_, FRAME_ENCODED, VIDEO_EVENT, encoded_frame->rtp_timestamp,
       frame_id, static_cast<int>(encoded_frame->data.size()),
       encoded_frame->dependency == transport::EncodedFrame::KEY,
       requested_bitrate_before_encode);
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT1(
       "cast_perf_test", "VideoFrameEncoded",
       TRACE_EVENT_SCOPE_THREAD,
       "rtp_timestamp", encoded_frame->rtp_timestamp);
 
   // Only use lowest 8 bits as key.
   frame_id_to_rtp_timestamp_[frame_id & 0xff] = encoded_frame->rtp_timestamp;
 
   last_sent_frame_id_ = static_cast<int>(encoded_frame->frame_id);
+
   DCHECK(!encoded_frame->reference_time.is_null());
   rtp_timestamp_helper_.StoreLatestTime(encoded_frame->reference_time,
                                         encoded_frame->rtp_timestamp);
 
   // At the start of the session, it's important to send reports before each
   // frame so that the receiver can properly compute playout times.  The reason
   // more than one report is sent is because transmission is not guaranteed,
   // only best effort, so send enough that one should almost certainly get
   // through.
   if (num_aggressive_rtcp_reports_sent_ < kNumAggressiveReportsSentAtStart) {
@@ skipping 251 matching lines @@
 
 void VideoSender::UpdateBitrate(int new_bitrate) {
   // Make sure we don't set the bitrate too insanely low.
   DCHECK_GT(new_bitrate, 1000);
   video_encoder_->SetBitRate(new_bitrate);
   current_requested_bitrate_ = new_bitrate;
 }
 
 }  // namespace cast
 }  // namespace media