Cast: Re-factor rtcp_sender.cc into rtcp_builder.cc and do some cleanup

media/cast/net/rtcp/rtcp_builder.cc

Index: media/cast/net/rtcp/rtcp_builder.cc
diff --git a/media/cast/net/rtcp/rtcp_sender.cc b/media/cast/net/rtcp/rtcp_builder.cc
similarity index 56%
rename from media/cast/net/rtcp/rtcp_sender.cc
rename to media/cast/net/rtcp/rtcp_builder.cc
index 4ca6eb581bd73c454766cfa90f989d925f2e9715..b4e58c3d362b273df80a6f2a1b9842e726ea3e2a 100644
--- a/media/cast/net/rtcp/rtcp_sender.cc
+++ b/media/cast/net/rtcp/rtcp_builder.cc
@@ -2,17 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "media/cast/net/rtcp/rtcp_sender.h"
+#include "media/cast/net/rtcp/rtcp_builder.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <vector>
 
-#include "base/big_endian.h"
 #include "base/logging.h"
 #include "media/cast/net/cast_transport_defines.h"
-#include "media/cast/net/pacing/paced_sender.h"
 #include "media/cast/net/rtcp/rtcp_defines.h"
 #include "media/cast/net/rtcp/rtcp_utility.h"
 
@@ -46,7 +44,7 @@ bool EventTimestampLessThan(const RtcpReceiverEventLogMessage& lhs,
   return lhs.event_timestamp < rhs.event_timestamp;
 }
 
-void AddReceiverLog(
+void AddReceiverLogEntries(
     const RtcpReceiverLogMessage& redundancy_receiver_log_message,
     RtcpReceiverLogMessage* receiver_log_message,
     size_t* remaining_space,
@@ -67,7 +65,7 @@ void AddReceiverLog(
 
     *remaining_space -= kRtcpReceiverFrameLogSize +
                         event_log_messages.size() * kRtcpReceiverEventLogSize;
-    ++*number_of_frames;
+    ++number_of_frames;
     *total_number_of_messages_to_send += event_log_messages.size();
     ++it;
   }
@@ -145,161 +143,139 @@ class NackStringBuilder {
 };
 }  // namespace
 
-RtcpSender::RtcpSender(PacedPacketSender* outgoing_transport,
-                       uint32 sending_ssrc)
-    : ssrc_(sending_ssrc),
-      transport_(outgoing_transport) {
+RtcpBuilder::RtcpBuilder(uint32 sending_ssrc)
+    : writer_(NULL, 0),
+      ssrc_(sending_ssrc),
+      ptr_of_length_(NULL) {
 }
 
-RtcpSender::~RtcpSender() {}
+RtcpBuilder::~RtcpBuilder() {}
+
+void RtcpBuilder::PatchLengthField() {
+  if (ptr_of_length_) {
+    // Back-patch the packet length. The client must have taken
+    // care of proper padding to 32-bit words.
+    int this_packet_length = (writer_.ptr() - ptr_of_length_ - 2);
+    DCHECK_EQ(0, this_packet_length % 4)
+        << "Packets must be a multiple of 32 bits long";
+    *ptr_of_length_ = this_packet_length >> 10;
+    *(ptr_of_length_ + 1) = (this_packet_length >> 2) & 0xFF;
+    ptr_of_length_ = NULL;
+  }
+}
+
+// Set the 5-bit value in the 1st byte of the header
+// and the payload type. Set aside room for the length field,
+// and make provision for back-patching it.
+void RtcpBuilder::AddRtcpHeader(RtcpPacketFields payload, int format_or_count) {
+  PatchLengthField();
+  writer_.WriteU8(0x80 | (format_or_count & 0x1F));
+  writer_.WriteU8(payload);
+  ptr_of_length_ = writer_.ptr();
+
+  // Initialize length to "clearly illegal".
+  writer_.WriteU16(0xDEAD);
+}
+
+void RtcpBuilder::Start() {
+  packet_ = new base::RefCountedData<Packet>;
+  packet_->data.resize(kMaxIpPacketSize);
+  writer_ = base::BigEndianWriter(
+      reinterpret_cast<char*>(&(packet_->data[0])), kMaxIpPacketSize);
+}
 
-void RtcpSender::SendRtcpFromRtpReceiver(
+PacketRef RtcpBuilder::Finish() {
+  PatchLengthField();
+  packet_->data.resize(kMaxIpPacketSize - writer_.remaining());
+  writer_ = base::BigEndianWriter(NULL, 0);
+  PacketRef ret = packet_;
+  packet_ = NULL;
+  return ret;
+}
+
+PacketRef RtcpBuilder::BuildRtcpFromReceiver(
     const RtcpReportBlock* report_block,
     const RtcpReceiverReferenceTimeReport* rrtr,
     const RtcpCastMessage* cast_message,
     const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events,
     base::TimeDelta target_delay) {
-  PacketRef packet(new base::RefCountedData<Packet>);
-  packet->data.reserve(kMaxIpPacketSize);
+  Start();
+
   if (report_block)
-    BuildRR(report_block, &packet->data);
+    AddRR(report_block);
   if (rrtr)
-    BuildRrtr(rrtr, &packet->data);
+    AddRrtr(rrtr);
   if (cast_message)
-    BuildCast(cast_message, target_delay, &packet->data);
+    AddCast(cast_message, target_delay);
   if (rtcp_events)
-    BuildReceiverLog(*rtcp_events, &packet->data);
-
-  if (packet->data.empty()) {
-    NOTREACHED() << "Empty packet.";
-    return;  // Sanity don't send empty packets.
-  }
+    AddReceiverLog(*rtcp_events);
 
-  transport_->SendRtcpPacket(ssrc_, packet);
+  return Finish();
 }
 
-void RtcpSender::SendRtcpFromRtpSender(
-    const RtcpSenderInfo& sender_info) {
-  PacketRef packet(new base::RefCountedData<Packet>);
-  packet->data.reserve(kMaxIpPacketSize);
-  BuildSR(sender_info, &packet->data);
-
-  if (packet->data.empty()) {
-    NOTREACHED() << "Empty packet.";
-    return;  // Sanity - don't send empty packets.
-  }
-
-  transport_->SendRtcpPacket(ssrc_, packet);
+PacketRef RtcpBuilder::BuildRtcpFromSender(const RtcpSenderInfo& sender_info) {
+  Start();
+  AddSR(sender_info);
+  return Finish();
 }
 
-void RtcpSender::BuildRR(const RtcpReportBlock* report_block,
-                         Packet* packet) const {
-  size_t start_size = packet->size();
-  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);
-
-  base::BigEndianWriter big_endian_writer(
-      reinterpret_cast<char*>(&((*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_);
-
+void RtcpBuilder::AddRR(const RtcpReportBlock* report_block) {
+  AddRtcpHeader(kPacketTypeReceiverReport, report_block ? 1 : 0);
+  writer_.WriteU32(ssrc_);
   if (report_block) {
-    AddReportBlocks(*report_block, packet);  // Adds 24 bytes.
+    AddReportBlocks(*report_block);  // Adds 24 bytes.
   }
 }
 
-void RtcpSender::AddReportBlocks(const RtcpReportBlock& report_block,
-                                 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;
-
-  packet->resize(start_size + 24);
-
-  base::BigEndianWriter big_endian_writer(
-      reinterpret_cast<char*>(&((*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);
+void RtcpBuilder::AddReportBlocks(const RtcpReportBlock& report_block) {
+  writer_.WriteU32(report_block.media_ssrc);
+  writer_.WriteU8(report_block.fraction_lost);
+  writer_.WriteU8(report_block.cumulative_lost >> 16);
+  writer_.WriteU8(report_block.cumulative_lost >> 8);
+  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);
+  writer_.WriteU32(report_block.extended_high_sequence_number);
+  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);
+  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);
+  writer_.WriteU32(report_block.delay_since_last_sr);
 }
 
-void RtcpSender::BuildRrtr(const RtcpReceiverReferenceTimeReport* rrtr,
-                           Packet* packet) const {
-  size_t start_size = packet->size();
-  DCHECK_LT(start_size + 20, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 20 > kMaxIpPacketSize)
-    return;
-
-  packet->resize(start_size + 20);
-
-  base::BigEndianWriter big_endian_writer(
-      reinterpret_cast<char*>(&((*packet)[start_size])), 20);
-
-  big_endian_writer.WriteU8(0x80);
-  big_endian_writer.WriteU8(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.
+void RtcpBuilder::AddRrtr(const RtcpReceiverReferenceTimeReport* rrtr) {
+  AddRtcpHeader(kPacketTypeXr, 0);
+  writer_.WriteU32(ssrc_);  // Add our own SSRC.
+  writer_.WriteU8(4);       // Add block type.
+  writer_.WriteU8(0);       // Add reserved.
+  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);
+  writer_.WriteU32(rrtr->ntp_seconds);
+  writer_.WriteU32(rrtr->ntp_fraction);
 }
 
-void RtcpSender::BuildCast(const RtcpCastMessage* cast,
-                           base::TimeDelta target_delay,
-                           Packet* packet) const {
-  size_t start_size = packet->size();
-  DCHECK_LT(start_size + 20, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 20 > kMaxIpPacketSize)
-    return;
-
-  packet->resize(start_size + 20);
-
-  base::BigEndianWriter big_endian_writer(
-      reinterpret_cast<char*>(&((*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(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.
+void RtcpBuilder::AddCast(const RtcpCastMessage* cast,
+                          base::TimeDelta target_delay) {
+  // See RTC 4585 Section 6.4 for application specific feedback messages.
+  AddRtcpHeader(kPacketTypePayloadSpecific, 15);
+  writer_.WriteU32(ssrc_);              // Add our own SSRC.
+  writer_.WriteU32(cast->media_ssrc);  // Remote SSRC.
+  writer_.WriteU32(kCast);
+  writer_.WriteU8(static_cast<uint8>(cast->ack_frame_id));
+  uint8* cast_loss_field_pos = reinterpret_cast<uint8*>(writer_.ptr());
+  writer_.WriteU8(0);  // Overwritten with number_of_loss_fields.
   DCHECK_LE(target_delay.InMilliseconds(),
             std::numeric_limits<uint16_t>::max());
-  big_endian_writer.WriteU16(target_delay.InMilliseconds());
+  writer_.WriteU16(target_delay.InMilliseconds());
 
   size_t number_of_loss_fields = 0;
   size_t max_number_of_loss_fields = std::min<size_t>(
-      kRtcpMaxCastLossFields, (kMaxIpPacketSize - packet->size()) / 4);
+      kRtcpMaxCastLossFields, writer_.remaining() / 4);
 
   MissingFramesAndPacketsMap::const_iterator frame_it =
       cast->missing_frames_and_packets.begin();
@@ -312,28 +288,18 @@ void RtcpSender::BuildCast(const RtcpCastMessage* cast,
     // 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();
-      packet->resize(start_size + 4);
-      base::BigEndianWriter big_endian_nack_writer(
-          reinterpret_cast<char*>(&((*packet)[start_size])), 4);
-      big_endian_nack_writer.WriteU8(static_cast<uint8>(frame_it->first));
-      big_endian_nack_writer.WriteU16(kRtcpCastAllPacketsLost);
-      big_endian_nack_writer.WriteU8(0);
+      writer_.WriteU8(static_cast<uint8>(frame_it->first));
+      writer_.WriteU16(kRtcpCastAllPacketsLost);
+      writer_.WriteU8(0);
       nack_string_builder.PushPacket(kRtcpCastAllPacketsLost);
       ++number_of_loss_fields;
     } else {
       PacketIdSet::const_iterator packet_it = frame_it->second.begin();
       while (packet_it != frame_it->second.end()) {
         uint16 packet_id = *packet_it;
-
-        start_size = packet->size();
-        packet->resize(start_size + 4);
-        base::BigEndianWriter big_endian_nack_writer(
-            reinterpret_cast<char*>(&((*packet)[start_size])), 4);
-
         // Write frame and packet id to buffer before calculating bitmask.
-        big_endian_nack_writer.WriteU8(static_cast<uint8>(frame_it->first));
-        big_endian_nack_writer.WriteU16(packet_id);
+        writer_.WriteU8(static_cast<uint8>(frame_it->first));
+        writer_.WriteU16(packet_id);
         nack_string_builder.PushPacket(packet_id);
 
         uint8 bitmask = 0;
@@ -348,7 +314,7 @@ void RtcpSender::BuildCast(const RtcpCastMessage* cast,
             break;
           }
         }
-        big_endian_nack_writer.WriteU8(bitmask);
+        writer_.WriteU8(bitmask);
         ++number_of_loss_fields;
       }
     }
@@ -358,34 +324,17 @@ void RtcpSender::BuildCast(const RtcpCastMessage* cast,
       << ", ACK: " << cast->ack_frame_id
       << ", NACK: " << nack_string_builder.GetString();
   DCHECK_LE(number_of_loss_fields, kRtcpMaxCastLossFields);
-  (*packet)[cast_size_pos] = static_cast<uint8>(4 + number_of_loss_fields);
-  (*packet)[cast_loss_field_pos] = static_cast<uint8>(number_of_loss_fields);
+  *cast_loss_field_pos = static_cast<uint8>(number_of_loss_fields);
 }
 
-void RtcpSender::BuildSR(const RtcpSenderInfo& sender_info,
-                         Packet* packet) const {
-  // Sender report.
-  size_t start_size = packet->size();
-  if (start_size + 52 > kMaxIpPacketSize) {
-    DLOG(FATAL) << "Not enough buffer space";
-    return;
-  }
-
-  uint16 number_of_rows = 6;
-  packet->resize(start_size + 28);
-
-  base::BigEndianWriter big_endian_writer(
-      reinterpret_cast<char*>(&((*packet)[start_size])), 28);
-  big_endian_writer.WriteU8(0x80);
-  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));
-  return;
+void RtcpBuilder::AddSR(const RtcpSenderInfo& sender_info) {
+  AddRtcpHeader(kPacketTypeSenderReport, 0);
+  writer_.WriteU32(ssrc_);
+  writer_.WriteU32(sender_info.ntp_seconds);
+  writer_.WriteU32(sender_info.ntp_fraction);
+  writer_.WriteU32(sender_info.rtp_timestamp);
+  writer_.WriteU32(sender_info.send_packet_count);
+  writer_.WriteU32(static_cast<uint32>(sender_info.send_octet_count));
 }
 
 /*
@@ -405,58 +354,31 @@ void RtcpSender::BuildSR(const RtcpSenderInfo& sender_info,
   |                   delay since last RR (DLRR)                  |
   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 */
-void RtcpSender::BuildDlrrRb(const RtcpDlrrReportBlock& dlrr,
-                             Packet* packet) const {
-  size_t start_size = packet->size();
-  if (start_size + 24 > kMaxIpPacketSize) {
-    DLOG(FATAL) << "Not enough buffer space";
-    return;
-  }
-
-  packet->resize(start_size + 24);
-
-  base::BigEndianWriter big_endian_writer(
-      reinterpret_cast<char*>(&((*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);
-  return;
+void RtcpBuilder::AddDlrrRb(const RtcpDlrrReportBlock& dlrr) {
+  AddRtcpHeader(kPacketTypeXr, 0);
+  writer_.WriteU32(ssrc_);  // Add our own SSRC.
+  writer_.WriteU8(5);  // Add block type.
+  writer_.WriteU8(0);  // Add reserved.
+  writer_.WriteU16(3);  // Block length.
+  writer_.WriteU32(ssrc_);  // Add the media (received RTP) SSRC.
+  writer_.WriteU32(dlrr.last_rr);
+  writer_.WriteU32(dlrr.delay_since_last_rr);
 }
 
-void RtcpSender::BuildReceiverLog(
-    const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events,
-    Packet* packet) {
-  const size_t packet_start_size = packet->size();
-  size_t number_of_frames = 0;
+void RtcpBuilder::AddReceiverLog(
+    const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events) {
   size_t total_number_of_messages_to_send = 0;
-  size_t rtcp_log_size = 0;
   RtcpReceiverLogMessage receiver_log_message;
 
-  if (!BuildRtcpReceiverLogMessage(rtcp_events,
-                                   packet_start_size,
-                                   &receiver_log_message,
-                                   &number_of_frames,
-                                   &total_number_of_messages_to_send,
-                                   &rtcp_log_size)) {
+  if (!GetRtcpReceiverLogMessage(rtcp_events,
+                                 &receiver_log_message,
+                                 &total_number_of_messages_to_send)) {
     return;
   }
-  packet->resize(packet_start_size + rtcp_log_size);
 
-  base::BigEndianWriter big_endian_writer(
-      reinterpret_cast<char*>(&((*packet)[packet_start_size])), rtcp_log_size);
-  big_endian_writer.WriteU8(0x80 + kReceiverLogSubtype);
-  big_endian_writer.WriteU8(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);
+  AddRtcpHeader(kPacketTypeApplicationDefined, kReceiverLogSubtype);
+  writer_.WriteU32(ssrc_);  // Add our own SSRC.
+  writer_.WriteU32(kCast);
 
   while (!receiver_log_message.empty() &&
          total_number_of_messages_to_send > 0) {
@@ -464,7 +386,7 @@ void RtcpSender::BuildReceiverLog(
         receiver_log_message.front());
 
     // Add our frame header.
-    big_endian_writer.WriteU32(frame_log_messages.rtp_timestamp_);
+    writer_.WriteU32(frame_log_messages.rtp_timestamp_);
     size_t messages_in_frame = frame_log_messages.event_log_messages_.size();
     if (messages_in_frame > total_number_of_messages_to_send) {
       // We are running out of space.
@@ -474,15 +396,15 @@ void RtcpSender::BuildReceiverLog(
     total_number_of_messages_to_send -= messages_in_frame;
 
     // On the wire format is number of messages - 1.
-    big_endian_writer.WriteU8(static_cast<uint8>(messages_in_frame - 1));
+    writer_.WriteU8(static_cast<uint8>(messages_in_frame - 1));
 
     base::TimeTicks event_timestamp_base =
         frame_log_messages.event_log_messages_.front().event_timestamp;
     uint32 base_timestamp_ms =
         (event_timestamp_base - base::TimeTicks()).InMilliseconds();
-    big_endian_writer.WriteU8(static_cast<uint8>(base_timestamp_ms >> 16));
-    big_endian_writer.WriteU8(static_cast<uint8>(base_timestamp_ms >> 8));
-    big_endian_writer.WriteU8(static_cast<uint8>(base_timestamp_ms));
+    writer_.WriteU8(static_cast<uint8>(base_timestamp_ms >> 16));
+    writer_.WriteU8(static_cast<uint8>(base_timestamp_ms >> 8));
+    writer_.WriteU8(static_cast<uint8>(base_timestamp_ms));
 
     while (!frame_log_messages.event_log_messages_.empty() &&
            messages_in_frame > 0) {
@@ -496,13 +418,13 @@ void RtcpSender::BuildReceiverLog(
         case FRAME_ACK_SENT:
         case FRAME_PLAYOUT:
         case FRAME_DECODED:
-          big_endian_writer.WriteU16(
+          writer_.WriteU16(
               static_cast<uint16>(event_message.delay_delta.InMilliseconds()));
-          big_endian_writer.WriteU16(event_type_and_timestamp_delta);
+          writer_.WriteU16(event_type_and_timestamp_delta);
           break;
         case PACKET_RECEIVED:
-          big_endian_writer.WriteU16(event_message.packet_id);
-          big_endian_writer.WriteU16(event_type_and_timestamp_delta);
+          writer_.WriteU16(event_message.packet_id);
+          writer_.WriteU16(event_type_and_timestamp_delta);
           break;
         default:
           NOTREACHED();
@@ -518,15 +440,13 @@ void RtcpSender::BuildReceiverLog(
   DCHECK_EQ(total_number_of_messages_to_send, 0u);
 }
 
-bool RtcpSender::BuildRtcpReceiverLogMessage(
+bool RtcpBuilder::GetRtcpReceiverLogMessage(
     const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events,
-    size_t start_size,
     RtcpReceiverLogMessage* receiver_log_message,
-    size_t* number_of_frames,
-    size_t* total_number_of_messages_to_send,
-    size_t* rtcp_log_size) {
+    size_t* total_number_of_messages_to_send) {
+  size_t number_of_frames = 0;
   size_t remaining_space =
-      std::min(kMaxReceiverLogBytes, kMaxIpPacketSize - start_size);
+      std::min<size_t>(kMaxReceiverLogBytes, writer_.remaining());
   if (remaining_space < kRtcpCastLogHeaderSize + kRtcpReceiverFrameLogSize +
                             kRtcpReceiverEventLogSize) {
     return false;
@@ -548,7 +468,7 @@ bool RtcpSender::BuildRtcpReceiverLogMessage(
     const RtpTimestamp rtp_timestamp = rit->first;
     RtcpReceiverFrameLogMessage frame_log(rtp_timestamp);
     remaining_space -= kRtcpReceiverFrameLogSize;
-    ++*number_of_frames;
+    ++number_of_frames;
 
     // Get all events of a single frame.
     sorted_log_messages.clear();
@@ -598,20 +518,20 @@ bool RtcpSender::BuildRtcpReceiverLogMessage(
   // unlikely there will be a match anyway.
   if (rtcp_events_history_.size() > kFirstRedundancyOffset) {
     // Add first redundnacy messages, if enough space remaining
-    AddReceiverLog(rtcp_events_history_[kFirstRedundancyOffset],
-                   receiver_log_message,
-                   &remaining_space,
-                   number_of_frames,
-                   total_number_of_messages_to_send);
+    AddReceiverLogEntries(rtcp_events_history_[kFirstRedundancyOffset],
+                          receiver_log_message,
+                          &remaining_space,
+                          &number_of_frames,
+                          total_number_of_messages_to_send);
   }
 
   if (rtcp_events_history_.size() > kSecondRedundancyOffset) {
     // Add second redundancy messages, if enough space remaining
-    AddReceiverLog(rtcp_events_history_[kSecondRedundancyOffset],
-                   receiver_log_message,
-                   &remaining_space,
-                   number_of_frames,
-                   total_number_of_messages_to_send);
+    AddReceiverLogEntries(rtcp_events_history_[kSecondRedundancyOffset],
+                          receiver_log_message,
+                          &remaining_space,
+                          &number_of_frames,
+                          total_number_of_messages_to_send);
   }
 
   if (rtcp_events_history_.size() > kReceiveLogMessageHistorySize) {
@@ -620,16 +540,9 @@ bool RtcpSender::BuildRtcpReceiverLogMessage(
 
   DCHECK_LE(rtcp_events_history_.size(), kReceiveLogMessageHistorySize);
 
-  *rtcp_log_size =
-      kRtcpCastLogHeaderSize + *number_of_frames * kRtcpReceiverFrameLogSize +
-      *total_number_of_messages_to_send * kRtcpReceiverEventLogSize;
-  DCHECK_GE(kMaxIpPacketSize, start_size + *rtcp_log_size)
-      << "Not enough buffer space.";
-
-  VLOG(3) << "number of frames: " << *number_of_frames;
+  VLOG(3) << "number of frames: " << number_of_frames;
   VLOG(3) << "total messages to send: " << *total_number_of_messages_to_send;
-  VLOG(3) << "rtcp log size: " << *rtcp_log_size;
-  return *number_of_frames > 0;
+  return number_of_frames > 0;
 }
 
 }  // namespace cast