Cast:Adding cast_transport_config and cleaning up

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"
@@ skipping 50 matching lines @@
 }
 
 bool ScanRtcpReceiverLogMessage(
     const media::cast::RtcpReceiverLogMessage& receiver_log_message,
     size_t start_size,
     size_t* number_of_frames,
     size_t* total_number_of_messages_to_send,
     size_t* rtcp_log_size) {
   if (receiver_log_message.empty()) return false;
 
-  size_t remaining_space = media::cast::kIpPacketSize - start_size;
+  size_t remaining_space = media::cast::kMaxIpPacketSize - start_size;
 
   // We must have space for at least one message
   DCHECK_GE(remaining_space, kRtcpCastLogHeaderSize +
       kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize)
       << "Not enough buffer space";
 
   if (remaining_space < kRtcpCastLogHeaderSize + kRtcpReceiverFrameLogSize +
       kRtcpReceiverEventLogSize) {
     return false;
   }
@@ skipping 25 matching lines @@
 
     if (remaining_space <
         kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize) {
       // Make sure that we have room for at least one more message.
       break;
     }
   }
   *rtcp_log_size = kRtcpCastLogHeaderSize +
       *number_of_frames * kRtcpReceiverFrameLogSize +
       *total_number_of_messages_to_send * kRtcpReceiverEventLogSize;
-  DCHECK_GE(media::cast::kIpPacketSize,
+  DCHECK_GE(media::cast::kMaxIpPacketSize,
             start_size + *rtcp_log_size) << "Not enough buffer space";
 
   VLOG(1) << "number of frames " << *number_of_frames;
   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 {
@@ skipping 24 matching lines @@
     NOTREACHED() << "Invalid argument";
   }
   if (packet_type_flags & kRtcpPli ||
       packet_type_flags & kRtcpRpsi ||
       packet_type_flags & kRtcpRemb ||
       packet_type_flags & kRtcpNack) {
     // Implement these for webrtc interop.
     NOTIMPLEMENTED();
   }
   std::vector<uint8> packet;
-  packet.reserve(kIpPacketSize);
+  packet.reserve(kMaxIpPacketSize);
 
   if (packet_type_flags & kRtcpRr) {
     BuildRR(report_block, &packet);
     if (!c_name_.empty()) {
       BuildSdec(&packet);
     }
   }
   if (packet_type_flags & kRtcpBye) {
     BuildBye(&packet);
   }
@@ skipping 10 matching lines @@
     BuildReceiverLog(receiver_log, &packet);
   }
   if (packet.empty()) return;  // Sanity don't send empty packets.
 
   transport_->SendRtcpPacket(packet);
 }
 
 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;
+  DCHECK_LT(start_size + 32, kMaxIpPacketSize) << "Not enough buffer space";
+  if (start_size + 32 > kMaxIpPacketSize) 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.WriteU8(transport::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 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;
+  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 RtcpSender::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);
+  big_endian_writer.WriteU8(transport::kPacketTypeSdes);
 
   // Handle SDES length later on.
   uint32 sdes_length_position = static_cast<uint32>(start_size) + 3;
   big_endian_writer.WriteU16(0);
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU8(1);  // CNAME = 1
   big_endian_writer.WriteU8(static_cast<uint8>(c_name_.length()));
 
   size_t sdes_length = 10 + c_name_.length();
   packet->insert(packet->end(), c_name_.c_str(),
@@ skipping 13 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 RtcpSender::BuildPli(uint32 remote_ssrc,
                           std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 12, kIpPacketSize) << "Not enough buffer space";
-  if (start_size + 12 > kIpPacketSize) return;
+  DCHECK_LT(start_size + 12, kMaxIpPacketSize) << "Not enough buffer space";
+  if (start_size + 12 > kMaxIpPacketSize) return;
 
   packet->resize(start_size + 12);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 12);
   uint8 FMT = 1;  // Picture loss indicator.
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
+  big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
   big_endian_writer.WriteU16(2);  // Used fixed length of 2.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(remote_ssrc);  // Add the remote SSRC.
 }
 
 /*
     0                   1                   2                   3
     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |      PB       |0| Payload Type|    Native Rpsi bit string     |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |   defined per codec          ...                | Padding (0) |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 */
 void RtcpSender::BuildRpsi(const RtcpRpsiMessage* rpsi,
                            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);
   uint8 FMT = 3;  // Reference Picture Selection Indication.
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
+  big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
 
   // Calculate length.
   uint32 bits_required = 7;
   uint8 bytes_required = 1;
   while ((rpsi->picture_id >> bits_required) > 0) {
     bits_required += 7;
     bytes_required++;
   }
   uint8 size = 3;
   if (bytes_required > 6) {
@@ skipping 25 matching lines @@
   // Add padding.
   for (int j = 0; j < padding_bytes; ++j) {
     big_endian_writer.WriteU8(0);
   }
 }
 
 void RtcpSender::BuildRemb(const RtcpRembMessage* remb,
                            std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   size_t remb_size = 20 + 4 * remb->remb_ssrcs.size();
-  DCHECK_LT(start_size + remb_size, kIpPacketSize)
+  DCHECK_LT(start_size + remb_size, kMaxIpPacketSize)
       << "Not enough buffer space";
-  if (start_size + remb_size > kIpPacketSize) return;
+  if (start_size + remb_size > kMaxIpPacketSize) return;
 
   packet->resize(start_size + remb_size);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), remb_size);
 
   // Add application layer feedback.
   uint8 FMT = 15;
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
+  big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
   big_endian_writer.WriteU8(0);
   big_endian_writer.WriteU8(static_cast<uint8>(remb->remb_ssrcs.size() + 4));
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(0);  // Remote SSRC must be 0.
   big_endian_writer.WriteU32(kRemb);
   big_endian_writer.WriteU8(static_cast<uint8>(remb->remb_ssrcs.size()));
 
   // 6 bit exponent and a 18 bit mantissa.
   uint8 bitrate_exponent;
   uint32 bitrate_mantissa;
@@ skipping 11 matching lines @@
     big_endian_writer.WriteU32(*it);
   }
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   cast_environment_->Logging()->InsertGenericEvent(now, kRembBitrate,
                                                    remb->remb_bitrate);
 }
 
 void RtcpSender::BuildNack(const RtcpNackMessage* nack,
                            std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 16, kIpPacketSize) << "Not enough buffer space";
-  if (start_size + 16 > kIpPacketSize) return;
+  DCHECK_LT(start_size + 16, kMaxIpPacketSize) << "Not enough buffer space";
+  if (start_size + 16 > kMaxIpPacketSize) return;
 
   packet->resize(start_size + 16);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 16);
 
   uint8 FMT = 1;
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(kPacketTypeGenericRtpFeedback);
+  big_endian_writer.WriteU8(transport::kPacketTypeGenericRtpFeedback);
   big_endian_writer.WriteU8(0);
   size_t nack_size_pos = start_size + 3;
   big_endian_writer.WriteU8(3);
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(nack->remote_ssrc);  // Add the remote SSRC.
 
   // Build NACK bitmasks and write them to the Rtcp message.
   // The nack list should be sorted and not contain duplicates.
   size_t number_of_nack_fields = 0;
   size_t max_number_of_nack_fields = std::min<size_t>(kRtcpMaxNackFields,
-      (kIpPacketSize - packet->size()) / 4);
+      (kMaxIpPacketSize - packet->size()) / 4);
 
   std::list<uint16>::const_iterator it = nack->nack_list.begin();
   while (it != nack->nack_list.end() &&
          number_of_nack_fields < max_number_of_nack_fields) {
     uint16 nack_sequence_number = *it;
     uint16 bitmask = 0;
     ++it;
     while (it != nack->nack_list.end()) {
       int shift = static_cast<uint16>(*it - nack_sequence_number) - 1;
       if (shift >= 0 && shift <= 15) {
         bitmask |= (1 << shift);
         ++it;
       } else {
         break;
       }
     }
     // Write the sequence number and the bitmask to the packet.
     start_size = packet->size();
-    DCHECK_LT(start_size + 4, kIpPacketSize) << "Not enough buffer space";
-    if (start_size + 4 > kIpPacketSize) return;
+    DCHECK_LT(start_size + 4, kMaxIpPacketSize) << "Not enough buffer space";
+    if (start_size + 4 > kMaxIpPacketSize) return;
 
     packet->resize(start_size + 4);
     net::BigEndianWriter big_endian_nack_writer(&((*packet)[start_size]), 4);
     big_endian_nack_writer.WriteU16(nack_sequence_number);
     big_endian_nack_writer.WriteU16(bitmask);
     number_of_nack_fields++;
   }
   DCHECK_GE(kRtcpMaxNackFields, number_of_nack_fields);
   (*packet)[nack_size_pos] = static_cast<uint8>(2 + number_of_nack_fields);
 }
 
 void RtcpSender::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.WriteU8(transport::kPacketTypeBye);
   big_endian_writer.WriteU16(1);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 }
 
 void RtcpSender::BuildRrtr(const RtcpReceiverReferenceTimeReport* rrtr,
                            std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 20, kIpPacketSize) << "Not enough buffer space";
-  if (start_size + 20 > kIpPacketSize) return;
+  DCHECK_LT(start_size + 20, kMaxIpPacketSize) << "Not enough buffer space";
+  if (start_size + 20 > kMaxIpPacketSize) return;
 
   packet->resize(start_size + 20);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 20);
 
   big_endian_writer.WriteU8(0x80);
-  big_endian_writer.WriteU8(kPacketTypeXr);
+  big_endian_writer.WriteU8(transport::kPacketTypeXr);
   big_endian_writer.WriteU16(4);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU8(4);  // Add block type.
   big_endian_writer.WriteU8(0);  // Add reserved.
   big_endian_writer.WriteU16(2);  // Block length.
 
   // Add the media (received RTP) SSRC.
   big_endian_writer.WriteU32(rrtr->ntp_seconds);
   big_endian_writer.WriteU32(rrtr->ntp_fraction);
 }
 
 void RtcpSender::BuildCast(const RtcpCastMessage* cast,
                            std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 20, kIpPacketSize) << "Not enough buffer space";
-  if (start_size + 20 > kIpPacketSize) return;
+  DCHECK_LT(start_size + 20, kMaxIpPacketSize) << "Not enough buffer space";
+  if (start_size + 20 > kMaxIpPacketSize) return;
 
   packet->resize(start_size + 20);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 20);
   uint8 FMT = 15;  // Application layer feedback.
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
+  big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
   big_endian_writer.WriteU8(0);
   size_t cast_size_pos = start_size + 3; // Save length position.
   big_endian_writer.WriteU8(4);
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(cast->media_ssrc_);  // Remote SSRC.
   big_endian_writer.WriteU32(kCast);
   big_endian_writer.WriteU8(static_cast<uint8>(cast->ack_frame_id_));
   size_t cast_loss_field_pos = start_size + 17;  // Save loss field position.
   big_endian_writer.WriteU8(0);  // Overwritten with number_of_loss_fields.
   big_endian_writer.WriteU8(0);  // Reserved.
   big_endian_writer.WriteU8(0);  // Reserved.
 
   size_t number_of_loss_fields = 0;
   size_t max_number_of_loss_fields = std::min<size_t>(kRtcpMaxCastLossFields,
-      (kIpPacketSize - packet->size()) / 4);
+      (kMaxIpPacketSize - packet->size()) / 4);
 
   MissingFramesAndPacketsMap::const_iterator frame_it =
       cast->missing_frames_and_packets_.begin();
 
   for (; frame_it != cast->missing_frames_and_packets_.end() &&
       number_of_loss_fields < max_number_of_loss_fields; ++frame_it) {
     // Iterate through all frames with missing packets.
     if (frame_it->second.empty()) {
       // Special case all packets in a frame is missing.
       start_size = packet->size();
@@ skipping 51 matching lines @@
                                   &number_of_frames,
                                   &total_number_of_messages_to_send,
                                   &rtcp_log_size)) {
     return;
   }
   packet->resize(packet_start_size + rtcp_log_size);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[packet_start_size]),
                                          rtcp_log_size);
   big_endian_writer.WriteU8(0x80 + kReceiverLogSubtype);
-  big_endian_writer.WriteU8(kPacketTypeApplicationDefined);
+  big_endian_writer.WriteU8(transport::kPacketTypeApplicationDefined);
   big_endian_writer.WriteU16(static_cast<uint16>(2 + 2 * number_of_frames +
                              total_number_of_messages_to_send));
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(kCast);
 
   while (!receiver_log_message->empty() &&
          total_number_of_messages_to_send > 0) {
     RtcpReceiverFrameLogMessage& frame_log_messages =
         receiver_log_message->front();
     // Add our frame header.
@@ skipping 48 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