Split ByteBuffer into writer/reader objects.

webrtc/media/base/testutils.cc

 /*
  *  Copyright (c) 2004 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 14 matching lines @@
 #include "webrtc/media/base/rtpdump.h"
 #include "webrtc/media/base/videocapturer.h"
 #include "webrtc/media/base/videoframe.h"
 
 namespace cricket {
 
 /////////////////////////////////////////////////////////////////////////
 // Implementation of RawRtpPacket
 /////////////////////////////////////////////////////////////////////////
 void RawRtpPacket::WriteToByteBuffer(uint32_t in_ssrc,
-                                     rtc::ByteBuffer* buf) const {
+                                     rtc::ByteBufferWriter* buf) const {
   if (!buf) return;
 
   buf->WriteUInt8(ver_to_cc);
   buf->WriteUInt8(m_to_pt);
   buf->WriteUInt16(sequence_number);
   buf->WriteUInt32(timestamp);
   buf->WriteUInt32(in_ssrc);
   buf->WriteBytes(payload, sizeof(payload));
 }
 
-bool RawRtpPacket::ReadFromByteBuffer(rtc::ByteBuffer* buf) {
+bool RawRtpPacket::ReadFromByteBuffer(rtc::ByteBufferReader* buf) {
   if (!buf) return false;
 
   bool ret = true;
   ret &= buf->ReadUInt8(&ver_to_cc);
   ret &= buf->ReadUInt8(&m_to_pt);
   ret &= buf->ReadUInt16(&sequence_number);
   ret &= buf->ReadUInt32(&timestamp);
   ret &= buf->ReadUInt32(&ssrc);
   ret &= buf->ReadBytes(payload, sizeof(payload));
   return ret;
 }
 
 bool RawRtpPacket::SameExceptSeqNumTimestampSsrc(const RawRtpPacket& packet,
                                                  uint16_t seq,
                                                  uint32_t ts,
                                                  uint32_t ssc) const {
   return sequence_number == seq &&
       timestamp == ts &&
       ver_to_cc == packet.ver_to_cc &&
       m_to_pt == packet.m_to_pt &&
       ssrc == ssc &&
       0 == memcmp(payload, packet.payload, sizeof(payload));
 }
 
 /////////////////////////////////////////////////////////////////////////
 // Implementation of RawRtcpPacket
 /////////////////////////////////////////////////////////////////////////
-void RawRtcpPacket::WriteToByteBuffer(rtc::ByteBuffer *buf) const {
+void RawRtcpPacket::WriteToByteBuffer(rtc::ByteBufferWriter *buf) const {
   if (!buf) return;
 
   buf->WriteUInt8(ver_to_count);
   buf->WriteUInt8(type);
   buf->WriteUInt16(length);
   buf->WriteBytes(payload, sizeof(payload));
 }
 
-bool RawRtcpPacket::ReadFromByteBuffer(rtc::ByteBuffer* buf) {
+bool RawRtcpPacket::ReadFromByteBuffer(rtc::ByteBufferReader* buf) {
   if (!buf) return false;
 
   bool ret = true;
   ret &= buf->ReadUInt8(&ver_to_count);
   ret &= buf->ReadUInt8(&type);
   ret &= buf->ReadUInt16(&length);
   ret &= buf->ReadBytes(payload, sizeof(payload));
   return ret;
 }
 
@@ skipping 28 matching lines @@
 
 bool RtpTestUtility::WriteTestPackets(size_t count,
                                       bool rtcp,
                                       uint32_t rtp_ssrc,
                                       RtpDumpWriter* writer) {
   if (!writer || count > GetTestPacketCount()) return false;
 
   bool result = true;
   uint32_t elapsed_time_ms = 0;
   for (size_t i = 0; i < count && result; ++i) {
-    rtc::ByteBuffer buf;
+    rtc::ByteBufferWriter buf;
     if (rtcp) {
       kTestRawRtcpPackets[i].WriteToByteBuffer(&buf);
     } else {
       kTestRawRtpPackets[i].WriteToByteBuffer(rtp_ssrc, &buf);
     }
 
     RtpDumpPacket dump_packet(buf.Data(), buf.Length(), elapsed_time_ms, rtcp);
     elapsed_time_ms += kElapsedTimeInterval;
     result &= (rtc::SR_SUCCESS == writer->WritePacket(dump_packet));
   }
@@ skipping 14 matching lines @@
     size_t loop = i / GetTestPacketCount();
     size_t index = i % GetTestPacketCount();
 
     RtpDumpPacket packet;
     result &= (rtc::SR_SUCCESS == reader.ReadPacket(&packet));
     // Check the elapsed time of the dump packet.
     result &= (packet.elapsed_time >= prev_elapsed_time);
     prev_elapsed_time = packet.elapsed_time;
 
     // Check the RTP or RTCP packet.
-    rtc::ByteBuffer buf(reinterpret_cast<const char*>(&packet.data[0]),
+    rtc::ByteBufferReader buf(reinterpret_cast<const char*>(&packet.data[0]),
                               packet.data.size());
     if (packet.is_rtcp()) {
       // RTCP packet.
       RawRtcpPacket rtcp_packet;
       result &= rtcp_packet.ReadFromByteBuffer(&buf);
       result &= rtcp_packet.EqualsTo(kTestRawRtcpPackets[index]);
     } else {
       // RTP packet.
       RawRtpPacket rtp_packet;
       result &= rtp_packet.ReadFromByteBuffer(&buf);
       result &= rtp_packet.SameExceptSeqNumTimestampSsrc(
           kTestRawRtpPackets[index],
           static_cast<uint16_t>(kTestRawRtpPackets[index].sequence_number +
                                 loop * GetTestPacketCount()),
           static_cast<uint32_t>(kTestRawRtpPackets[index].timestamp +
                                 loop * kRtpTimestampIncrease),
           ssrc);
     }
   }
 
   stream->Rewind();
   return result;
 }
 
 bool RtpTestUtility::VerifyPacket(const RtpDumpPacket* dump,
                                   const RawRtpPacket* raw,
                                   bool header_only) {
   if (!dump || !raw) return false;
 
-  rtc::ByteBuffer buf;
+  rtc::ByteBufferWriter buf;
   raw->WriteToByteBuffer(RtpTestUtility::kDefaultSsrc, &buf);
 
   if (header_only) {
     size_t header_len = 0;
     dump->GetRtpHeaderLen(&header_len);
     return header_len == dump->data.size() &&
         buf.Length() > dump->data.size() &&
         0 == memcmp(buf.Data(), &dump->data[0], dump->data.size());
   } else {
     return buf.Length() == dump->data.size() &&
@@ skipping 152 matching lines @@
     std::vector<uint32_t> fid_ssrcs;
     fid_ssrcs.push_back(ssrcs[i]);
     fid_ssrcs.push_back(rtx_ssrcs[i]);
     cricket::SsrcGroup fid_group(cricket::kFidSsrcGroupSemantics, fid_ssrcs);
     sp.ssrc_groups.push_back(fid_group);
   }
   return sp;
 }
 
 }  // namespace cricket