Cast: move net->transport

media/cast/rtcp/rtcp_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/rtcp/rtcp_sender.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/logging.h"
 #include "media/cast/cast_environment.h"
-#include "media/cast/net/cast_net_defines.h"
-#include "media/cast/net/pacing/paced_sender.h"
 #include "media/cast/rtcp/rtcp_utility.h"
+#include "media/cast/transport/cast_transport_defines.h"
+#include "media/cast/transport/pacing/paced_sender.h"
 #include "net/base/big_endian.h"
 
 static const size_t kRtcpCastLogHeaderSize = 12;
 static const size_t kRtcpSenderFrameLogSize = 4;
 static const size_t kRtcpReceiverFrameLogSize = 8;
 static const size_t kRtcpReceiverEventLogSize = 4;
 
 namespace {
 uint16 MergeEventTypeAndTimestampForWireFormat(
     const media::cast::CastLoggingEvent& event,
@@ skipping 93 matching lines @@
   VLOG(1) << "total messages to send " << *total_number_of_messages_to_send;
   VLOG(1) << "rtcp log size " << *rtcp_log_size;
   return true;
 }
 }  // namespace
 
 namespace media {
 namespace cast {
 
 RtcpSender::RtcpSender(scoped_refptr<CastEnvironment> cast_environment,
-                       PacedPacketSender* outgoing_transport,
+                       transport::PacedPacketSender* outgoing_transport,
                        uint32 sending_ssrc,
                        const std::string& c_name)
      : ssrc_(sending_ssrc),
        c_name_(c_name),
        transport_(outgoing_transport),
        cast_environment_(cast_environment) {
   DCHECK_LT(c_name_.length(), kRtcpCnameSize) << "Invalid config";
 }
 
 RtcpSender::~RtcpSender() {}
 
 void RtcpSender::SendRtcpFromRtpReceiver(
     uint32 packet_type_flags,
-    const RtcpReportBlock* report_block,
+    const transport::RtcpReportBlock* report_block,
     const RtcpReceiverReferenceTimeReport* rrtr,
     const RtcpCastMessage* cast_message,
     RtcpReceiverLogMessage* receiver_log) {
   if (packet_type_flags & kRtcpSr ||
       packet_type_flags & kRtcpDlrr ||
       packet_type_flags & kRtcpSenderLog) {
     NOTREACHED() << "Invalid argument";
   }
   if (packet_type_flags & kRtcpPli ||
       packet_type_flags & kRtcpRpsi ||
@@ skipping 24 matching lines @@
   }
   if (packet_type_flags & kRtcpReceiverLog) {
     DCHECK(receiver_log) << "Invalid argument";
     BuildReceiverLog(receiver_log, &packet);
   }
   if (packet.empty()) return;  // Sanity don't send empty packets.
 
   transport_->SendRtcpPacket(packet);
 }
 
-void RtcpSender::BuildRR(const RtcpReportBlock* report_block,
+void RtcpSender::BuildRR(const transport::RtcpReportBlock* report_block,
                          std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 32, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 32 > kIpPacketSize) return;
 
   uint16 number_of_rows = (report_block) ? 7 : 1;
   packet->resize(start_size + 8);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8);
   big_endian_writer.WriteU8(0x80 + (report_block ? 1 : 0));
   big_endian_writer.WriteU8(kPacketTypeReceiverReport);
   big_endian_writer.WriteU16(number_of_rows);
   big_endian_writer.WriteU32(ssrc_);
 
   if (report_block) {
     AddReportBlocks(*report_block, packet);  // Adds 24 bytes.
   }
 }
 
-void RtcpSender::AddReportBlocks(const RtcpReportBlock& report_block,
+void RtcpSender::AddReportBlocks(const transport::RtcpReportBlock& report_block,
                                  std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 24, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 24 > kIpPacketSize) return;
 
   packet->resize(start_size + 24);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 24);
   big_endian_writer.WriteU32(report_block.media_ssrc);
   big_endian_writer.WriteU8(report_block.fraction_lost);
@@ skipping 431 matching lines @@
     if (frame_log_messages.event_log_messages_.empty()) {
       // We sent all messages on this frame; pop the frame header.
       receiver_log_message->pop_front();
     }
   }
   DCHECK_EQ(total_number_of_messages_to_send, 0);
 }
 
 }  // namespace cast
 }  // namespace media