Cast:Adding cast_transport_config and cleaning up

media/cast/transport/rtcp/rtcp_builder.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/transport/rtcp/rtcp_builder.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/logging.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;
 
 namespace media {
 namespace cast {
 namespace transport {
 
+namespace {
+// RFC 3550 page 44, including end null.
+static const size_t kRtcpCnameSize = 256;
+static const uint32 kCast = ('C' << 24) + ('A' << 16) + ('S' << 8) + 'T';
+static const uint8 kSenderLogSubtype = 1;
+};
+
 RtcpBuilder::RtcpBuilder(PacedPacketSender* outgoing_transport,
                              uint32 sending_ssrc,
                              const std::string& c_name)
      : ssrc_(sending_ssrc),
        c_name_(c_name),
        transport_(outgoing_transport) {
   DCHECK_LT(c_name_.length(), kRtcpCnameSize) << "Invalid config";
 }
 
 RtcpBuilder::~RtcpBuilder() {}
 
 void RtcpBuilder::SendRtcpFromRtpSender(uint32 packet_type_flags,
                                           const RtcpSenderInfo* sender_info,
                                           const RtcpDlrrReportBlock* dlrr,
                                           RtcpSenderLogMessage* sender_log) {
   if (packet_type_flags & kRtcpRr ||
       packet_type_flags & kRtcpPli ||
       packet_type_flags & kRtcpRrtr ||
       packet_type_flags & kRtcpCast ||
       packet_type_flags & kRtcpReceiverLog ||
       packet_type_flags & kRtcpRpsi ||
       packet_type_flags & kRtcpRemb ||
       packet_type_flags & kRtcpNack) {
     NOTREACHED() << "Invalid argument";
   }
 
   std::vector<uint8> packet;
-  packet.reserve(kIpPacketSize);
+  packet.reserve(kMaxIpPacketSize);
   if (packet_type_flags & kRtcpSr) {
     DCHECK(sender_info) << "Invalid argument";
     BuildSR(*sender_info, NULL, &packet);
     BuildSdec(&packet);
   }
   if (packet_type_flags & kRtcpBye) {
     BuildBye(&packet);
   }
   if (packet_type_flags & kRtcpDlrr) {
     DCHECK(dlrr) << "Invalid argument";
     BuildDlrrRb(dlrr, &packet);
   }
   if (packet_type_flags & kRtcpSenderLog) {
     DCHECK(sender_log) << "Invalid argument";
     BuildSenderLog(sender_log, &packet);
   }
   if (packet.empty())
     return;  // Sanity don't send empty packets.
 
   transport_->SendRtcpPacket(packet);
 }
 
 void RtcpBuilder::BuildSR(const RtcpSenderInfo& sender_info,
                             const RtcpReportBlock* report_block,
                             std::vector<uint8>* packet) const {
   // Sender report.
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 52, kIpPacketSize) << "Not enough buffer space";
-  if (start_size + 52 > kIpPacketSize) return;
+  DCHECK_LT(start_size + 52, kMaxIpPacketSize) << "Not enough buffer space";
+  if (start_size + 52 > kMaxIpPacketSize) return;
 
   uint16 number_of_rows = (report_block) ? 12 : 6;
   packet->resize(start_size + 28);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 28);
   big_endian_writer.WriteU8(0x80 + (report_block ? 1 : 0));
   big_endian_writer.WriteU8(kPacketTypeSenderReport);
   big_endian_writer.WriteU16(number_of_rows);
   big_endian_writer.WriteU32(ssrc_);
   big_endian_writer.WriteU32(sender_info.ntp_seconds);
   big_endian_writer.WriteU32(sender_info.ntp_fraction);
   big_endian_writer.WriteU32(sender_info.rtp_timestamp);
   big_endian_writer.WriteU32(sender_info.send_packet_count);
   big_endian_writer.WriteU32(static_cast<uint32>(sender_info.send_octet_count));
 
   if (report_block) {
     AddReportBlocks(*report_block, packet);  // Adds 24 bytes.
   }
 }
 
 void RtcpBuilder::AddReportBlocks(const 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;
+  DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
+  if (start_size + 24 > kMaxIpPacketSize) 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);
   big_endian_writer.WriteU8(report_block.cumulative_lost >> 16);
   big_endian_writer.WriteU8(report_block.cumulative_lost >> 8);
   big_endian_writer.WriteU8(report_block.cumulative_lost);
 
   // Extended highest seq_no, contain the highest sequence number received.
   big_endian_writer.WriteU32(report_block.extended_high_sequence_number);
   big_endian_writer.WriteU32(report_block.jitter);
 
   // Last SR timestamp; our NTP time when we received the last report.
   // This is the value that we read from the send report packet not when we
   // received it.
   big_endian_writer.WriteU32(report_block.last_sr);
 
   // Delay since last received report, time since we received the report.
   big_endian_writer.WriteU32(report_block.delay_since_last_sr);
 }
 
 void RtcpBuilder::BuildSdec(std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size +  12 + c_name_.length(), kIpPacketSize)
+  DCHECK_LT(start_size +  12 + c_name_.length(), kMaxIpPacketSize)
       << "Not enough buffer space";
-  if (start_size + 12 > kIpPacketSize) return;
+  if (start_size + 12 > kMaxIpPacketSize) return;
 
   // SDES Source Description.
   packet->resize(start_size + 10);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 10);
   // We always need to add one SDES CNAME.
   big_endian_writer.WriteU8(0x80 + 1);
   big_endian_writer.WriteU8(kPacketTypeSdes);
 
   // Handle SDES length later on.
@@ skipping 20 matching lines @@
   }
   sdes_length += padding;
 
   // In 32-bit words minus one and we don't count the header.
   uint8 buffer_length = static_cast<uint8>((sdes_length / 4) - 1);
   (*packet)[sdes_length_position] = buffer_length;
 }
 
 void RtcpBuilder::BuildBye(std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 8, kIpPacketSize) << "Not enough buffer space";
-  if (start_size + 8 > kIpPacketSize) return;
+  DCHECK_LT(start_size + 8, kMaxIpPacketSize) << "Not enough buffer space";
+  if (start_size + 8 > kMaxIpPacketSize) return;
 
   packet->resize(start_size + 8);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8);
   big_endian_writer.WriteU8(0x80 + 1);
   big_endian_writer.WriteU8(kPacketTypeBye);
   big_endian_writer.WriteU16(1);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 }
 
@@ skipping 10 matching lines @@
   |                 SSRC_1 (SSRC of first receiver)               | sub-
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ block
   |                         last RR (LRR)                         |   1
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                   delay since last RR (DLRR)                  |
   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 */
 void RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock* dlrr,
                                 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;
+  DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
+  if (start_size + 24 > kMaxIpPacketSize) return;
 
   packet->resize(start_size + 24);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 24);
   big_endian_writer.WriteU8(0x80);
   big_endian_writer.WriteU8(kPacketTypeXr);
   big_endian_writer.WriteU16(5);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU8(5);  // Add block type.
   big_endian_writer.WriteU8(0);  // Add reserved.
   big_endian_writer.WriteU16(3);  // Block length.
   big_endian_writer.WriteU32(ssrc_);  // Add the media (received RTP) SSRC.
   big_endian_writer.WriteU32(dlrr->last_rr);
   big_endian_writer.WriteU32(dlrr->delay_since_last_rr);
 }
 
 void RtcpBuilder::BuildSenderLog(RtcpSenderLogMessage* sender_log_message,
                                    std::vector<uint8>* packet) const {
   DCHECK(sender_log_message);
   DCHECK(packet);
   size_t start_size = packet->size();
-  size_t remaining_space = kIpPacketSize - start_size;
+  size_t remaining_space = kMaxIpPacketSize - start_size;
   DCHECK_GE(remaining_space, kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
        << "Not enough buffer space";
   if (remaining_space < kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
     return;
 
   size_t space_for_x_messages =
       (remaining_space - kRtcpCastLogHeaderSize) / kRtcpSenderFrameLogSize;
   size_t number_of_messages = std::min(space_for_x_messages,
                                        sender_log_message->size());
 
@@ skipping 16 matching lines @@
     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 16));
     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 8));
     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp));
     sender_log_message->pop_front();
   }
 }
 
 }  // namespace transport
 }  // namespace cast
 }  // namespace media