Cast: IPC glue between cast library transport and encoders.

media/cast/transport/rtcp/rtcp_builder.cc

Index: media/cast/transport/rtcp/rtcp_builder.cc
diff --git a/media/cast/transport/rtcp/rtcp_builder.cc b/media/cast/transport/rtcp/rtcp_builder.cc
index e89102378d8e94127dbb4c6fa10293e766a5873b..461745c66cda4460851bef00be87962d597a7256 100644
--- a/media/cast/transport/rtcp/rtcp_builder.cc
+++ b/media/cast/transport/rtcp/rtcp_builder.cc
@@ -55,17 +55,17 @@ void RtcpBuilder::SendRtcpFromRtpSender(
   Packet packet;
   packet.reserve(kMaxIpPacketSize);
   if (packet_type_flags & kRtcpSr) {
-    BuildSR(sender_info, &packet);
-    BuildSdec(&packet);
+    if (!BuildSR(sender_info, &packet)) return;
+    if (!BuildSdec(&packet)) return;
   }
   if (packet_type_flags & kRtcpBye) {
-    BuildBye(&packet);
+    if (!BuildBye(&packet)) return;
   }
   if (packet_type_flags & kRtcpDlrr) {
-    BuildDlrrRb(dlrr, &packet);
+    if (!BuildDlrrRb(dlrr, &packet)) return;
   }
   if (packet_type_flags & kRtcpSenderLog) {
-    BuildSenderLog(sender_log, &packet);
+    if (!BuildSenderLog(sender_log, &packet)) return;
   }
   if (packet.empty())
     return;  // Sanity - don't send empty packets.
@@ -73,12 +73,12 @@ void RtcpBuilder::SendRtcpFromRtpSender(
   transport_->SendRtcpPacket(packet);
 }
 
-void RtcpBuilder::BuildSR(const RtcpSenderInfo& sender_info,
+bool RtcpBuilder::BuildSR(const RtcpSenderInfo& sender_info,
                           Packet* packet) const {
   // Sender report.
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 52, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 52 > kMaxIpPacketSize) return;
+  if (start_size + 52 > kMaxIpPacketSize) return false;
 
   uint16 number_of_rows = 6;
   packet->resize(start_size + 28);
@@ -93,13 +93,14 @@ void RtcpBuilder::BuildSR(const RtcpSenderInfo& sender_info,
   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));
+  return true;
 }
 
-void RtcpBuilder::BuildSdec(Packet* packet) const {
+bool RtcpBuilder::BuildSdec(Packet* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size +  12 + c_name_.length(), kMaxIpPacketSize)
       << "Not enough buffer space";
-  if (start_size + 12 > kMaxIpPacketSize) return;
+  if (start_size + 12 + c_name_.length() > kMaxIpPacketSize) return false;

[palmer, 2014/02/14 23:53:01]

To avoid duplicating the check logic, why not do:

if (start_size + 12 + c_name_.length() > kMaxIpPacketSize) {
  DCHECK() << "Not enough buffer space";
  return false;
}

[hubbe, 2014/02/15 00:00:18]

Good idea (except DCHECK() doesn't work, but DLOG(FATAL) does)

 
   // SDES Source Description.
   packet->resize(start_size + 10);
@@ -136,12 +137,13 @@ void RtcpBuilder::BuildSdec(Packet* packet) const {
   // 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;
+  return true;
 }
 
-void RtcpBuilder::BuildBye(Packet* packet) const {
+bool RtcpBuilder::BuildBye(Packet* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 8, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 8 > kMaxIpPacketSize) return;
+  if (start_size + 8 > kMaxIpPacketSize) return false;
 
   packet->resize(start_size + 8);
 
@@ -150,6 +152,7 @@ void RtcpBuilder::BuildBye(Packet* packet) const {
   big_endian_writer.WriteU8(kPacketTypeBye);
   big_endian_writer.WriteU16(1);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
+  return true;
 }
 
 /*
@@ -169,11 +172,11 @@ void RtcpBuilder::BuildBye(Packet* packet) const {
   |                   delay since last RR (DLRR)                  |
   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 */
-void RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock& dlrr,
+bool RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock& dlrr,
                               Packet* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 24 > kMaxIpPacketSize) return;
+  if (start_size + 24 > kMaxIpPacketSize) return true;
 
   packet->resize(start_size + 24);
 
@@ -188,9 +191,10 @@ void RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock& dlrr,
   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);
+  return false;
 }
 
-void RtcpBuilder::BuildSenderLog(const RtcpSenderLogMessage& sender_log_message,
+bool RtcpBuilder::BuildSenderLog(const RtcpSenderLogMessage& sender_log_message,
                                  Packet* packet) const {
   DCHECK(packet);
   size_t start_size = packet->size();
@@ -198,7 +202,7 @@ void RtcpBuilder::BuildSenderLog(const RtcpSenderLogMessage& sender_log_message,
   DCHECK_GE(remaining_space, kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
        << "Not enough buffer space";
   if (remaining_space < kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
-    return;
+    return false;
 
   size_t space_for_x_messages =
       (remaining_space - kRtcpCastLogHeaderSize) / kRtcpSenderFrameLogSize;
@@ -216,7 +220,7 @@ void RtcpBuilder::BuildSenderLog(const RtcpSenderLogMessage& sender_log_message,
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(kCast);
 
-  std::list<RtcpSenderFrameLogMessage>::const_iterator it =
+  std::vector<RtcpSenderFrameLogMessage>::const_iterator it =
       sender_log_message.begin();
   for (; number_of_messages > 0; --number_of_messages) {
     DCHECK(!sender_log_message.empty());
@@ -228,6 +232,7 @@ void RtcpBuilder::BuildSenderLog(const RtcpSenderLogMessage& sender_log_message,
     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp));
     ++it;
   }
+  return true;
 }
 
 }  // namespace transport