Refactoring: CastTransport InitializeAudio/InitializeVideo.

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 <stdint.h>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/sender/performance_metrics_overlay.h"
 #include "media/cast/sender/video_encoder.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
@@ skipping 64 matching lines @@
 VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const FrameSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
     CastTransport* const transport_sender,
     const PlayoutDelayChangeCB& playout_delay_change_cb)
     : FrameSender(
           cast_environment,
-          false,
           transport_sender,
-          kVideoFrequency,
-          video_config.sender_ssrc,
-          video_config.max_frame_rate,
-          video_config.min_playout_delay,
-          video_config.max_playout_delay,
-          video_config.animated_playout_delay,
+          video_config,
           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),
       low_latency_mode_(false),
       last_reported_encoder_utilization_(-1.0),
       last_reported_lossy_utilization_(-1.0),
       weak_factory_(this) {
   video_encoder_ = VideoEncoder::Create(
       cast_environment_,
       video_config,
       status_change_cb,
       create_vea_cb,
       create_video_encode_mem_cb);
   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.sender_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::WrapUnique(new FrameSender::RtcpClient(
-                            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));
 
@@ skipping 196 matching lines @@
         media::VideoFrameMetadata::RESOURCE_UTILIZATION,
         encoded_frame->dependency == EncodedFrame::KEY ?
             std::min(1.0, attenuated_utilization) : attenuated_utilization);
   }
 
   SendEncodedFrame(encoder_bitrate, std::move(encoded_frame));
 }
 
 }  // namespace cast
 }  // namespace media