Cast: move net->transport

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"
 #include "base/message_loop/message_loop.h"
 #include "crypto/encryptor.h"
 #include "crypto/symmetric_key.h"
 #include "media/cast/cast_defines.h"
-#include "media/cast/net/pacing/paced_sender.h"
+#include "media/cast/transport/pacing/paced_sender.h"
 #include "media/cast/video_sender/video_encoder.h"
 
 namespace media {
 namespace cast {
 
 const int64 kMinSchedulingDelayMs = 1;
 
 class LocalRtcpVideoSenderFeedback : public RtcpSenderFeedback {
  public:
   explicit LocalRtcpVideoSenderFeedback(VideoSender* video_sender)
       : video_sender_(video_sender) {
   }
 
   virtual void OnReceivedCastFeedback(
       const RtcpCastMessage& cast_feedback) OVERRIDE {
     video_sender_->OnReceivedCastFeedback(cast_feedback);
   }
 
  private:
   VideoSender* video_sender_;
 };
 
 class LocalRtpVideoSenderStatistics : public RtpSenderStatistics {
  public:
-  explicit LocalRtpVideoSenderStatistics(RtpSender* rtp_sender)
+  explicit LocalRtpVideoSenderStatistics(transport::RtpSender* rtp_sender)
      : rtp_sender_(rtp_sender) {
   }
 
   virtual void GetStatistics(const base::TimeTicks& now,
-                             RtcpSenderInfo* sender_info) OVERRIDE {
+                             transport::RtcpSenderInfo* sender_info) OVERRIDE {
     rtp_sender_->RtpStatistics(now, sender_info);
   }
 
  private:
-  RtpSender* rtp_sender_;
+  transport::RtpSender* rtp_sender_;
 };
 
 VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
     VideoEncoderController* const video_encoder_controller,
-    PacedPacketSender* const paced_packet_sender)
+    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 RtpSender(cast_environment, NULL, &video_config,
-                                paced_packet_sender)),
+      rtp_sender_(new transport::RtpSender(cast_environment,
+                                           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,
                           video_config.min_bitrate,
                           video_config.start_bitrate),
       initialized_(false),
@@ skipping 150 matching lines @@
       base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
 
   cast_environment_->PostDelayedTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(&VideoSender::SendRtcpReport, weak_factory_.GetWeakPtr()),
                  time_to_next);
 }
 
 void VideoSender::SendRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
-  RtcpSenderLogMessage sender_log_message;
+  transport::RtcpSenderLogMessage sender_log_message;
   const FrameRawMap& frame_raw_map =
       cast_environment_->Logging()->GetFrameRawData();
 
   FrameRawMap::const_iterator it = frame_raw_map.begin();
   while (it != frame_raw_map.end()) {
-    RtcpSenderFrameLogMessage frame_message;
+    transport::RtcpSenderFrameLogMessage frame_message;
     frame_message.rtp_timestamp = it->first;
-    frame_message.frame_status = kRtcpSenderFrameStatusUnknown;
+    frame_message.frame_status = transport::kRtcpSenderFrameStatusUnknown;
     if (it->second.type.empty()) {
       ++it;
       continue;
     }
     CastLoggingEvent last_event = it->second.type.back();
     switch (last_event) {
       case kVideoFrameCaptured:
-        frame_message.frame_status = kRtcpSenderFrameStatusDroppedByFlowControl;
+        frame_message.frame_status =
+            transport::kRtcpSenderFrameStatusDroppedByFlowControl;
         break;
       case kVideoFrameSentToEncoder:
-        frame_message.frame_status = kRtcpSenderFrameStatusDroppedByEncoder;
+        frame_message.frame_status =
+            transport::kRtcpSenderFrameStatusDroppedByEncoder;
         break;
       case kVideoFrameEncoded:
-        frame_message.frame_status = kRtcpSenderFrameStatusSentToNetwork;
+        frame_message.frame_status =
+            transport::kRtcpSenderFrameStatusSentToNetwork;
         break;
       default:
         ++it;
         continue;
     }
     ++it;
     if (it == frame_raw_map.end()) {
       // Last message on our map; only send if it is kVideoFrameEncoded.
       if (last_event != kVideoFrameEncoded) {
         // For other events we will wait for it to finish and report the result
@@ skipping 184 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