Cast:Adding cast_transport_config and cleaning up

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 <list>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 42 matching lines @@
 VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
     VideoEncoderController* const video_encoder_controller,
     transport::PacedPacketSender* const paced_packet_sender)
     : rtp_max_delay_(
           base::TimeDelta::FromMilliseconds(video_config.rtp_max_delay_ms)),
       max_frame_rate_(video_config.max_frame_rate),
       cast_environment_(cast_environment),
       rtcp_feedback_(new LocalRtcpVideoSenderFeedback(this)),
-      rtp_sender_(new transport::RtpSender(cast_environment,
+      rtp_sender_(new transport::RtpSender(cast_environment->Clock(),
                                            NULL,
                                            &video_config,
                                            paced_packet_sender)),
       last_acked_frame_id_(-1),
       last_sent_frame_id_(-1),
       duplicate_ack_(0),
       last_skip_count_(0),
       congestion_control_(cast_environment->Clock(),
                           video_config.congestion_control_back_off,
                           video_config.max_bitrate,
@@ skipping 66 matching lines @@
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   cast_environment_->Logging()->InsertFrameEvent(now, kVideoFrameReceived,
       GetVideoRtpTimestamp(capture_time), kFrameIdUnknown);
 
   if (!video_encoder_->EncodeVideoFrame(video_frame, capture_time,
       base::Bind(&VideoSender::SendEncodedVideoFrameMainThread,
           weak_factory_.GetWeakPtr()))) {
   }
 }
 
-void VideoSender::InsertCodedVideoFrame(const EncodedVideoFrame* encoded_frame,
-                                        const base::TimeTicks& capture_time,
-                                        const base::Closure callback) {
+void VideoSender::InsertCodedVideoFrame(
+    const transport::EncodedVideoFrame* encoded_frame,
+    const base::TimeTicks& capture_time,
+    const base::Closure callback) {
   DCHECK(!video_encoder_.get()) << "Invalid state";
   DCHECK(encoded_frame) << "Invalid argument";
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   SendEncodedVideoFrame(encoded_frame, capture_time);
   cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE, callback);
 }
 
 void VideoSender::SendEncodedVideoFrameMainThread(
-    scoped_ptr<EncodedVideoFrame> video_frame,
+    scoped_ptr<transport::EncodedVideoFrame> video_frame,
     const base::TimeTicks& capture_time) {
   SendEncodedVideoFrame(video_frame.get(), capture_time);
 }
 
-bool VideoSender::EncryptVideoFrame(const EncodedVideoFrame& video_frame,
-                                    EncodedVideoFrame* encrypted_frame) {
+bool VideoSender::EncryptVideoFrame(
+    const transport::EncodedVideoFrame& video_frame,
+    transport::EncodedVideoFrame* encrypted_frame) {
   DCHECK(encryptor_) << "Invalid state";
 
   if (!encryptor_->SetCounter(GetAesNonce(video_frame.frame_id, iv_mask_))) {
     NOTREACHED() << "Failed to set counter";
     return false;
   }
 
   if (!encryptor_->Encrypt(video_frame.data, &encrypted_frame->data)) {
     NOTREACHED() << "Encrypt error";
     return false;
   }
   encrypted_frame->codec = video_frame.codec;
   encrypted_frame->key_frame = video_frame.key_frame;
   encrypted_frame->frame_id = video_frame.frame_id;
   encrypted_frame->last_referenced_frame_id =
       video_frame.last_referenced_frame_id;
   return true;
 }
 
-void VideoSender::SendEncodedVideoFrame(const EncodedVideoFrame* encoded_frame,
-                                        const base::TimeTicks& capture_time) {
+void VideoSender::SendEncodedVideoFrame(
+    const transport::EncodedVideoFrame* encoded_frame,
+    const base::TimeTicks& capture_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   last_send_time_ = cast_environment_->Clock()->NowTicks();
 
   if (encryptor_) {
-    EncodedVideoFrame encrypted_video_frame;
+    transport::EncodedVideoFrame encrypted_video_frame;
 
     if (!EncryptVideoFrame(*encoded_frame, &encrypted_video_frame)) {
       // Logging already done.
       return;
     }
     rtp_sender_->IncomingEncodedVideoFrame(&encrypted_video_frame,
                                            capture_time);
   } else {
     rtp_sender_->IncomingEncodedVideoFrame(encoded_frame, capture_time);
   }
@@ skipping 252 matching lines @@
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   MissingFramesAndPacketsMap missing_frames_and_packets;
   PacketIdSet missing;
   missing_frames_and_packets.insert(std::make_pair(resend_frame_id, missing));
   rtp_sender_->ResendPackets(missing_frames_and_packets);
   last_send_time_ = cast_environment_->Clock()->NowTicks();
 }
 
 }  // namespace cast
 }  // namespace media