Cast: move net->transport

media/cast/rtcp/rtcp.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/rtcp/rtcp.h"
 
 #include "base/rand_util.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
-#include "media/cast/net/rtcp/rtcp_builder.h"
 #include "media/cast/rtcp/rtcp_defines.h"
 #include "media/cast/rtcp/rtcp_receiver.h"
 #include "media/cast/rtcp/rtcp_sender.h"
 #include "media/cast/rtcp/rtcp_utility.h"
+#include "media/cast/transport/cast_transport_defines.h"
 #include "net/base/big_endian.h"
 
 namespace media {
 namespace cast {
 
 static const int kMaxRttMs = 10000;  // 10 seconds.
 
 // Time limit for received RTCP messages when we stop using it for lip-sync.
 static const int64 kMaxDiffSinceReceivedRtcpMs = 100000;  // 100 seconds.
 
@@ skipping 33 matching lines @@
 RtcpReceiverFrameLogMessage::~RtcpReceiverFrameLogMessage() {}
 
 class LocalRtcpReceiverFeedback : public RtcpReceiverFeedback {
  public:
   LocalRtcpReceiverFeedback(Rtcp* rtcp,
                            scoped_refptr<CastEnvironment> cast_environment)
       : rtcp_(rtcp), cast_environment_(cast_environment) {
   }
 
   virtual void OnReceivedSenderReport(
-      const RtcpSenderInfo& remote_sender_info) OVERRIDE {
+      const transport::RtcpSenderInfo& remote_sender_info) OVERRIDE {
     rtcp_->OnReceivedNtp(remote_sender_info.ntp_seconds,
                          remote_sender_info.ntp_fraction);
     if (remote_sender_info.send_packet_count != 0) {
       rtcp_->OnReceivedLipSyncInfo(remote_sender_info.rtp_timestamp,
                                    remote_sender_info.ntp_seconds,
                                    remote_sender_info.ntp_fraction);
     }
   }
 
   virtual void OnReceiverReferenceTimeReport(
@@ skipping 39 matching lines @@
           default:
             VLOG(2) << "Received log message via RTCP that we did not expect: "
                     << static_cast<int>(event_it->type);
             break;
         }
       }
     }
   }
 
   virtual void OnReceivedSenderLog(
-      const RtcpSenderLogMessage& sender_log)  OVERRIDE {
-    RtcpSenderLogMessage::const_iterator it = sender_log.begin();
+      const transport::RtcpSenderLogMessage& sender_log)  OVERRIDE {
+    transport::RtcpSenderLogMessage::const_iterator it = sender_log.begin();
 
     for (; it != sender_log.end(); ++it) {
       uint32 rtp_timestamp = it->rtp_timestamp;
       CastLoggingEvent log_event = kUnknown;
 
       // These events are provided to know the status of frames that never
       // reached the receiver. The timing information for these events are not
       // relevant and is not sent over the wire.
       switch (it->frame_status) {
-        case kRtcpSenderFrameStatusDroppedByFlowControl:
+        case transport::kRtcpSenderFrameStatusDroppedByFlowControl:
           // A frame that have been dropped by the flow control would have
           // kVideoFrameCaptured as its last event in the log.
           log_event = kVideoFrameCaptured;
           break;
-        case kRtcpSenderFrameStatusDroppedByEncoder:
+        case transport::kRtcpSenderFrameStatusDroppedByEncoder:
           // A frame that have been dropped by the encoder would have
           // kVideoFrameSentToEncoder as its last event in the log.
           log_event = kVideoFrameSentToEncoder;
           break;
-        case kRtcpSenderFrameStatusSentToNetwork:
+        case transport::kRtcpSenderFrameStatusSentToNetwork:
           // A frame that have be encoded is always sent to the network. We
           // do not add a new log entry for this.
           log_event = kVideoFrameEncoded;
           break;
         default:
           continue;
       }
       // TODO(pwestin): how do we handle the truncated rtp_timestamp?
       // Add received log messages into our log system.
       // TODO(pwestin): how do we handle the time? we don't care about it but
       // we need to send in one.
       base::TimeTicks now = cast_environment_->Clock()->NowTicks();
       cast_environment_->Logging()->InsertFrameEvent(now, log_event,
           rtp_timestamp, kFrameIdUnknown);
     }
   }
 
  private:
   Rtcp* rtcp_;
   scoped_refptr<CastEnvironment> cast_environment_;
 };
 
 Rtcp::Rtcp(scoped_refptr<CastEnvironment> cast_environment,
            RtcpSenderFeedback* sender_feedback,
-           PacedPacketSender* paced_packet_sender,
+           transport::PacedPacketSender* paced_packet_sender,
            RtpSenderStatistics* rtp_sender_statistics,
            RtpReceiverStatistics* rtp_receiver_statistics,
            RtcpMode rtcp_mode,
            const base::TimeDelta& rtcp_interval,
            uint32 local_ssrc,
            uint32 remote_ssrc,
            const std::string& c_name)
     : rtcp_interval_(rtcp_interval),
       rtcp_mode_(rtcp_mode),
       local_ssrc_(local_ssrc),
       remote_ssrc_(remote_ssrc),
       rtp_sender_statistics_(rtp_sender_statistics),
       rtp_receiver_statistics_(rtp_receiver_statistics),
       receiver_feedback_(new LocalRtcpReceiverFeedback(this, cast_environment)),
       rtt_feedback_(new LocalRtcpRttFeedback(this)),
       rtcp_sender_(new RtcpSender(cast_environment, paced_packet_sender,
                                   local_ssrc, c_name)),
-      rtcp_builder_(new RtcpBuilder(paced_packet_sender, local_ssrc, c_name)),
+      rtcp_builder_(new
+          transport::RtcpBuilder(paced_packet_sender, local_ssrc, c_name)),
       last_report_received_(0),
       last_received_rtp_timestamp_(0),
       last_received_ntp_seconds_(0),
       last_received_ntp_fraction_(0),
       min_rtt_(base::TimeDelta::FromMilliseconds(kMaxRttMs)),
       number_of_rtt_in_avg_(0),
       cast_environment_(cast_environment) {
   rtcp_receiver_.reset(new RtcpReceiver(cast_environment,
                                         sender_feedback,
                                         receiver_feedback_.get(),
@@ skipping 41 matching lines @@
     return;
   }
   rtcp_receiver_->IncomingRtcpPacket(&rtcp_parser);
 }
 
 void Rtcp::SendRtcpFromRtpReceiver(const RtcpCastMessage* cast_message,
                                    RtcpReceiverLogMessage* receiver_log) {
   uint32 packet_type_flags = 0;
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
-  RtcpReportBlock report_block;
+  transport::RtcpReportBlock report_block;
   RtcpReceiverReferenceTimeReport rrtr;
 
   if (cast_message) {
     packet_type_flags |= RtcpSender::kRtcpCast;
     cast_environment_->Logging()->InsertGenericEvent(now, kAckSent,
         cast_message->ack_frame_id_);
   }
   if (receiver_log) {
     packet_type_flags |= RtcpSender::kRtcpReceiverLog;
   }
@@ skipping 35 matching lines @@
     UpdateNextTimeToSendRtcp();
   }
   rtcp_sender_->SendRtcpFromRtpReceiver(packet_type_flags,
                                         &report_block,
                                         &rrtr,
                                         cast_message,
                                         receiver_log);
 }
 
 void Rtcp::SendRtcpFromRtpSender(
-    RtcpSenderLogMessage* sender_log_message) {
+    transport::RtcpSenderLogMessage* sender_log_message) {
   uint32 packet_type_flags = RtcpSender::kRtcpSr;
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
 
   if (sender_log_message) {
     packet_type_flags |= RtcpSender::kRtcpSenderLog;
   }
 
-  RtcpSenderInfo sender_info;
+  transport::RtcpSenderInfo sender_info;
   if (rtp_sender_statistics_) {
     rtp_sender_statistics_->GetStatistics(now, &sender_info);
   } else {
     memset(&sender_info, 0, sizeof(sender_info));
   }
   SaveLastSentNtpTime(now, sender_info.ntp_seconds, sender_info.ntp_fraction);
 
-  RtcpDlrrReportBlock dlrr;
+  transport::RtcpDlrrReportBlock dlrr;
   if (!time_last_report_received_.is_null()) {
     packet_type_flags |= RtcpSender::kRtcpDlrr;
     dlrr.last_rr = last_report_received_;
     uint32 delay_seconds = 0;
     uint32 delay_fraction = 0;
     base::TimeDelta delta = now - time_last_report_received_;
     ConvertTimeToFractions(delta.InMicroseconds(),
                            &delay_seconds,
                            &delay_fraction);
 
@@ skipping 161 matching lines @@
   int random = base::RandInt(0, 999);
   base::TimeDelta time_to_next = (rtcp_interval_ / 2) +
       (rtcp_interval_ * random / 1000);
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   next_time_to_send_rtcp_ = now + time_to_next;
 }
 
 }  // namespace cast
 }  // namespace media