RtpPacketHistory rewritten to use RtpPacket class.

webrtc/modules/rtp_rtcp/source/rtp_packet.cc

 /*
  *  Copyright (c) 2016 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 60 matching lines @@
     uint8_t id = data()[extension_entries_[i].offset - 1] >> 4;
     extension_entries_[i].type = extensions_->GetType(id);
   }
 }
 
 bool Packet::Parse(const uint8_t* buffer, size_t buffer_size) {
   if (!ParseBuffer(buffer, buffer_size)) {
     Clear();
     return false;
   }
+  buffer_.SetData(buffer, buffer_size);
   RTC_DCHECK_EQ(size(), buffer_size);
-  buffer_.SetData(buffer, buffer_size);
   return true;
 }
 
-bool Packet::Parse(rtc::Buffer buffer) {
-  if (!ParseBuffer(buffer.data(), buffer.size())) {
+bool Packet::Parse(rtc::CopyOnWriteBuffer buffer) {
+  if (!ParseBuffer(buffer.cdata(), buffer.size())) {
     Clear();
     return false;
   }
-  RTC_DCHECK_EQ(size(), buffer.size());
+  size_t buffer_size = buffer.size();
   buffer_ = std::move(buffer);
+  RTC_DCHECK_EQ(size(), buffer_size);
   return true;
 }
 
 bool Packet::Marker() const {
   RTC_DCHECK_EQ(marker_, (data()[1] & 0x80) != 0);
   return marker_;
 }
 
 uint8_t Packet::PayloadType() const {
   RTC_DCHECK_EQ(payload_type_, data()[1] & 0x7f);
@@ skipping 64 matching lines @@
 }
 
 size_t Packet::padding_size() const {
   return padding_size_;
 }
 
 const uint8_t* Packet::payload() const {
   return data() + payload_offset_;
 }
 
+rtc::CopyOnWriteBuffer Packet::Buffer() const {
+  return buffer_;
+}
+
 size_t Packet::capacity() const {
-  return buffer_.size();
+  return buffer_.capacity();
 }
 
 size_t Packet::size() const {
-  return payload_offset_ + payload_size_ + padding_size_;
+  size_t ret = payload_offset_ + payload_size_ + padding_size_;
+  RTC_DCHECK_EQ(buffer_.size(), ret);
+  return ret;
 }
 
 const uint8_t* Packet::data() const {
-  return buffer_.data();
+  return buffer_.cdata();
 }
 
 size_t Packet::FreeCapacity() const {
   return capacity() - size();
 }
 
 size_t Packet::MaxPayloadSize() const {
   return capacity() - payload_offset_;
 }
 
-void Packet::CopyHeader(const Packet& packet) {
+void Packet::CopyHeaderFrom(const Packet& packet) {
   RTC_DCHECK_GE(capacity(), packet.headers_size());
 
   marker_ = packet.marker_;
   payload_type_ = packet.payload_type_;
   sequence_number_ = packet.sequence_number_;
   timestamp_ = packet.timestamp_;
   ssrc_ = packet.ssrc_;
   payload_offset_ = packet.payload_offset_;
   num_extensions_ = packet.num_extensions_;
   for (size_t i = 0; i < num_extensions_; ++i) {
@@ skipping 42 matching lines @@
   RTC_DCHECK_EQ(padding_size_, 0u);
   RTC_DCHECK_LE(csrcs.size(), 0x0fu);
   RTC_DCHECK_LE(kFixedHeaderSize + 4 * csrcs.size(), capacity());
   payload_offset_ = kFixedHeaderSize + 4 * csrcs.size();
   WriteAt(0, (data()[0] & 0xF0) | csrcs.size());
   size_t offset = kFixedHeaderSize;
   for (uint32_t csrc : csrcs) {
     ByteWriter<uint32_t>::WriteBigEndian(WriteAt(offset), csrc);
     offset += 4;
   }
+  buffer_.SetSize(payload_offset_);
 }
 
 uint8_t* Packet::AllocatePayload(size_t size_bytes) {
   RTC_DCHECK_EQ(padding_size_, 0u);
   if (payload_offset_ + size_bytes > capacity()) {
     LOG(LS_WARNING) << "Cannot set payload, not enough space in buffer.";
     return nullptr;
   }
   payload_size_ = size_bytes;
+  buffer_.SetSize(payload_offset_ + payload_size_);
   return WriteAt(payload_offset_);
 }
 
 void Packet::SetPayloadSize(size_t size_bytes) {
   RTC_DCHECK_EQ(padding_size_, 0u);
   RTC_DCHECK_LE(size_bytes, payload_size_);
   payload_size_ = size_bytes;
+  buffer_.SetSize(payload_offset_ + payload_size_);
 }
 
 bool Packet::SetPadding(uint8_t size_bytes, Random* random) {
   RTC_DCHECK(random);
   if (payload_offset_ + payload_size_ + size_bytes > capacity()) {
     LOG(LS_WARNING) << "Cannot set padding size " << size_bytes << ", only "
                     << (capacity() - payload_offset_ - payload_size_)
                     << " bytes left in buffer.";
     return false;
   }
   padding_size_ = size_bytes;
+  buffer_.SetSize(payload_offset_ + payload_size_ + padding_size_);
   if (padding_size_ > 0) {
     size_t padding_offset = payload_offset_ + payload_size_;
     size_t padding_end = padding_offset + padding_size_;
     for (size_t offset = padding_offset; offset < padding_end - 1; ++offset) {
       WriteAt(offset, random->Rand<uint8_t>());
     }
     WriteAt(padding_end - 1, padding_size_);
     WriteAt(0, data()[0] | 0x20);  // Set padding bit.
   } else {
     WriteAt(0, data()[0] & ~0x20);  // Clear padding bit.
   }
   return true;
 }
 
 void Packet::Clear() {
   marker_ = false;
   payload_type_ = 0;
   sequence_number_ = 0;
   timestamp_ = 0;
   ssrc_ = 0;
   payload_offset_ = kFixedHeaderSize;
   payload_size_ = 0;
   padding_size_ = 0;
   num_extensions_ = 0;
   extensions_size_ = 0;
 
   memset(WriteAt(0), 0, kFixedHeaderSize);
+  buffer_.SetSize(kFixedHeaderSize);
   WriteAt(0, kRtpVersion << 6);
 }
 
 bool Packet::ParseBuffer(const uint8_t* buffer, size_t size) {
   if (size < kFixedHeaderSize) {
     return false;
   }
   const uint8_t version = buffer[0] >> 6;
   if (version != kRtpVersion) {
     return false;
@@ skipping 166 matching lines @@
   extensions_size_ = new_extensions_size;
 
   // Update header length field.
   ByteWriter<uint16_t>::WriteBigEndian(WriteAt(extensions_offset - 2),
                                        extensions_words);
   // Fill extension padding place with zeroes.
   size_t extension_padding_size = 4 * extensions_words - extensions_size_;
   memset(WriteAt(extensions_offset + extensions_size_), 0,
          extension_padding_size);
   payload_offset_ = extensions_offset + 4 * extensions_words;
+  buffer_.SetSize(payload_offset_);
   return true;
 }
 
 uint8_t* Packet::WriteAt(size_t offset) {
   return buffer_.data() + offset;
 }
 
 void Packet::WriteAt(size_t offset, uint8_t byte) {
   buffer_.data()[offset] = byte;
 }
 
 }  // namespace rtp
 }  // namespace webrtc