diff --git a/modules/rtp_rtcp/source/fec_test_helper.cc b/modules/rtp_rtcp/source/fec_test_helper.cc
index 8823e8b..a98d33f 100644
--- a/modules/rtp_rtcp/source/fec_test_helper.cc
+++ b/modules/rtp_rtcp/source/fec_test_helper.cc
@@ -53,8 +53,8 @@
   for (int i = 0; i < num_media_packets; ++i) {
     std::unique_ptr<ForwardErrorCorrection::Packet> media_packet(
         new ForwardErrorCorrection::Packet());
-    media_packet->length = random_->Rand(min_packet_size_, max_packet_size_);
-    media_packet->data.SetSize(media_packet->length);
+    media_packet->data.SetSize(
+        random_->Rand(min_packet_size_, max_packet_size_));
 
     // Generate random values for the first 2 bytes
     media_packet->data[0] = random_->Rand<uint8_t>();
@@ -80,7 +80,7 @@
     webrtc::ByteWriter<uint32_t>::WriteBigEndian(&media_packet->data[8], ssrc_);
 
     // Generate random values for payload.
-    for (size_t j = 12; j < media_packet->length; ++j)
+    for (size_t j = 12; j < media_packet->data.size(); ++j)
       media_packet->data[j] = random_->Rand<uint8_t>();
     seq_num++;
     media_packets.push_back(std::move(media_packet));
@@ -124,8 +124,7 @@
   packet->data.SetSize(length + kRtpHeaderSize);
   for (size_t i = 0; i < length; ++i)
     packet->data[i + kRtpHeaderSize] = offset + i;
-  packet->length = length + kRtpHeaderSize;
-  packet->data.SetSize(packet->length);
+  packet->data.SetSize(length + kRtpHeaderSize);
   packet->header.headerLength = kRtpHeaderSize;
   packet->header.markerBit = (num_packets_ == 1);
   packet->header.payloadType = kVp8PayloadType;
@@ -158,7 +157,7 @@
 
 std::unique_ptr<AugmentedPacket> FlexfecPacketGenerator::BuildFlexfecPacket(
     const ForwardErrorCorrection::Packet& packet) {
-  RTC_DCHECK_LE(packet.length,
+  RTC_DCHECK_LE(packet.data.size(),
                 static_cast<size_t>(IP_PACKET_SIZE - kRtpHeaderSize));
 
   RTPHeader header;
@@ -170,11 +169,10 @@
 
   std::unique_ptr<AugmentedPacket> packet_with_rtp_header(
       new AugmentedPacket());
-  packet_with_rtp_header->data.SetSize(kRtpHeaderSize + packet.length);
+  packet_with_rtp_header->data.SetSize(kRtpHeaderSize + packet.data.size());
   WriteRtpHeader(header, packet_with_rtp_header->data.data());
   memcpy(packet_with_rtp_header->data.data() + kRtpHeaderSize,
-         packet.data.cdata(), packet.length);
-  packet_with_rtp_header->length = kRtpHeaderSize + packet.length;
+         packet.data.cdata(), packet.data.size());
 
   return packet_with_rtp_header;
 }
@@ -188,13 +186,13 @@
 
   const size_t kHeaderLength = packet.header.headerLength;
   red_packet->header = packet.header;
-  red_packet->length = packet.length + 1;  // 1 byte RED header.
-  red_packet->data.SetSize(packet.length + 1);
+  red_packet->data.SetSize(packet.data.size() + 1);
   // Copy RTP header.
   memcpy(red_packet->data.data(), packet.data.cdata(), kHeaderLength);
   SetRedHeader(red_packet->data[1] & 0x7f, kHeaderLength, red_packet.get());
   memcpy(red_packet->data.data() + kHeaderLength + 1,
-         packet.data.cdata() + kHeaderLength, packet.length - kHeaderLength);
+         packet.data.cdata() + kHeaderLength,
+         packet.data.size() - kHeaderLength);
 
   return red_packet;
 }
@@ -204,15 +202,14 @@
   // Create a fake media packet to get a correct header. 1 byte RED header.
   ++num_packets_;
   std::unique_ptr<AugmentedPacket> red_packet =
-      NextPacket(0, packet.length + 1);
+      NextPacket(0, packet.data.size() + 1);
 
   red_packet->data[1] &= ~0x80;  // Clear marker bit.
   const size_t kHeaderLength = red_packet->header.headerLength;
-  red_packet->data.SetSize(kHeaderLength + 1 + packet.length);
+  red_packet->data.SetSize(kHeaderLength + 1 + packet.data.size());
   SetRedHeader(kFecPayloadType, kHeaderLength, red_packet.get());
   memcpy(red_packet->data.data() + kHeaderLength + 1, packet.data.cdata(),
-         packet.length);
-  red_packet->length = kHeaderLength + 1 + packet.length;
+         packet.data.size());
 
   return red_packet;
 }
diff --git a/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc b/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc
index 04b48ca..6acf368 100644
--- a/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc
+++ b/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc
@@ -80,7 +80,8 @@
 // retransmissions, and/or several protected SSRCs.
 bool FlexfecHeaderReader::ReadFecHeader(
     ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const {
-  if (fec_packet->pkt->length <= kBaseHeaderSize + kStreamSpecificHeaderSize) {
+  if (fec_packet->pkt->data.size() <=
+      kBaseHeaderSize + kStreamSpecificHeaderSize) {
     RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet.";
     return false;
   }
@@ -121,7 +122,7 @@
   //
   // We treat the mask parts as unsigned integers with host order endianness
   // in order to simplify the bit shifting between bytes.
-  if (fec_packet->pkt->length < kHeaderSizes[0]) {
+  if (fec_packet->pkt->data.size() < kHeaderSizes[0]) {
     RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet.";
     return false;
   }
@@ -138,7 +139,7 @@
     // is payload.
     packet_mask_size = kFlexfecPacketMaskSizes[0];
   } else {
-    if (fec_packet->pkt->length < kHeaderSizes[1]) {
+    if (fec_packet->pkt->data.size() < kHeaderSizes[1]) {
       return false;
     }
     bool k_bit1 = (packet_mask[2] & 0x80) != 0;
@@ -158,7 +159,7 @@
       // and the rest of the packet is payload.
       packet_mask_size = kFlexfecPacketMaskSizes[1];
     } else {
-      if (fec_packet->pkt->length < kHeaderSizes[2]) {
+      if (fec_packet->pkt->data.size() < kHeaderSizes[2]) {
         RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet.";
         return false;
       }
@@ -198,7 +199,7 @@
 
   // In FlexFEC, all media packets are protected in their entirety.
   fec_packet->protection_length =
-      fec_packet->pkt->length - fec_packet->fec_header_size;
+      fec_packet->pkt->data.size() - fec_packet->fec_header_size;
 
   return true;
 }
diff --git a/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc b/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc
index 7c1e4db..1d86dd0 100644
--- a/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc
+++ b/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc
@@ -77,9 +77,8 @@
                                        size_t packet_mask_size) {
   FlexfecHeaderWriter writer;
   rtc::scoped_refptr<Packet> written_packet(new Packet());
-  written_packet->length = kMediaPacketLength;
   written_packet->data.SetSize(kMediaPacketLength);
-  for (size_t i = 0; i < written_packet->length; ++i) {
+  for (size_t i = 0; i < written_packet->data.size(); ++i) {
     written_packet->data[i] = i;  // Actual content doesn't matter.
   }
   writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask,
@@ -93,7 +92,6 @@
   read_packet->ssrc = kFlexfecSsrc;
   read_packet->pkt = rtc::scoped_refptr<Packet>(new Packet());
   read_packet->pkt->data = written_packet.data;
-  read_packet->pkt->length = written_packet.length;
   EXPECT_TRUE(reader.ReadFecHeader(read_packet.get()));
   return read_packet;
 }
@@ -110,7 +108,7 @@
   const size_t packet_mask_offset = read_packet.packet_mask_offset;
   EXPECT_EQ(kFlexfecPacketMaskOffset, packet_mask_offset);
   EXPECT_EQ(expected_packet_mask_size, read_packet.packet_mask_size);
-  EXPECT_EQ(read_packet.pkt->length - expected_fec_header_size,
+  EXPECT_EQ(read_packet.pkt->data.size() - expected_fec_header_size,
             read_packet.protection_length);
   // Ensure that the K-bits are removed and the packet mask has been packed.
   EXPECT_THAT(
@@ -147,7 +145,7 @@
   EXPECT_EQ(kMediaStartSeqNum, read_packet.seq_num_base);
   EXPECT_EQ(kFlexfecPacketMaskOffset, read_packet.packet_mask_offset);
   ASSERT_EQ(expected_packet_mask_size, read_packet.packet_mask_size);
-  EXPECT_EQ(written_packet.length - expected_fec_header_size,
+  EXPECT_EQ(written_packet.data.size() - expected_fec_header_size,
             read_packet.protection_length);
   // Verify that the call to ReadFecHeader did normalize the packet masks.
   EXPECT_THAT(::testing::make_tuple(
@@ -158,10 +156,10 @@
   // Verify that the call to ReadFecHeader did not tamper with the payload.
   EXPECT_THAT(::testing::make_tuple(
                   read_packet.pkt->data.cdata() + read_packet.fec_header_size,
-                  read_packet.pkt->length - read_packet.fec_header_size),
+                  read_packet.pkt->data.size() - read_packet.fec_header_size),
               ::testing::ElementsAreArray(
                   written_packet.data.cdata() + expected_fec_header_size,
-                  written_packet.length - expected_fec_header_size));
+                  written_packet.data.size() - expected_fec_header_size));
 }
 
 }  // namespace
@@ -185,7 +183,6 @@
   ReceivedFecPacket read_packet;
   read_packet.pkt = rtc::scoped_refptr<Packet>(new Packet());
   read_packet.pkt->data.SetData(kPacketData, packet_length);
-  read_packet.pkt->length = packet_length;
 
   FlexfecHeaderReader reader;
   EXPECT_TRUE(reader.ReadFecHeader(&read_packet));
@@ -217,7 +214,6 @@
   ReceivedFecPacket read_packet;
   read_packet.pkt = rtc::scoped_refptr<Packet>(new Packet());
   read_packet.pkt->data.SetData(kPacketData, packet_length);
-  read_packet.pkt->length = packet_length;
 
   FlexfecHeaderReader reader;
   EXPECT_TRUE(reader.ReadFecHeader(&read_packet));
@@ -256,7 +252,6 @@
   ReceivedFecPacket read_packet;
   read_packet.pkt = rtc::scoped_refptr<Packet>(new Packet());
   read_packet.pkt->data.SetData(kPacketData, packet_length);
-  read_packet.pkt->length = packet_length;
 
   FlexfecHeaderReader reader;
   EXPECT_TRUE(reader.ReadFecHeader(&read_packet));
@@ -274,8 +269,7 @@
   ReceivedFecPacket read_packet;
   read_packet.ssrc = kFlexfecSsrc;
   read_packet.pkt = std::move(written_packet);
-  read_packet.pkt->length = 12;
-  read_packet.pkt->data.SetSize(read_packet.pkt->length);
+  read_packet.pkt->data.SetSize(12);
 
   FlexfecHeaderReader reader;
   EXPECT_FALSE(reader.ReadFecHeader(&read_packet));
@@ -290,8 +284,7 @@
   ReceivedFecPacket read_packet;
   read_packet.ssrc = kFlexfecSsrc;
   read_packet.pkt = std::move(written_packet);
-  read_packet.pkt->length = 18;
-  read_packet.pkt->data.SetSize(read_packet.pkt->length);
+  read_packet.pkt->data.SetSize(18);
 
   FlexfecHeaderReader reader;
   EXPECT_FALSE(reader.ReadFecHeader(&read_packet));
@@ -307,8 +300,7 @@
   ReceivedFecPacket read_packet;
   read_packet.ssrc = kFlexfecSsrc;
   read_packet.pkt = std::move(written_packet);
-  read_packet.pkt->length = 20;
-  read_packet.pkt->data.SetSize(read_packet.pkt->length);
+  read_packet.pkt->data.SetSize(20);
 
   FlexfecHeaderReader reader;
   EXPECT_FALSE(reader.ReadFecHeader(&read_packet));
@@ -324,8 +316,7 @@
   ReceivedFecPacket read_packet;
   read_packet.ssrc = kFlexfecSsrc;
   read_packet.pkt = std::move(written_packet);
-  read_packet.pkt->length = 24;
-  read_packet.pkt->data.SetSize(read_packet.pkt->length);
+  read_packet.pkt->data.SetSize(24);
 
   FlexfecHeaderReader reader;
   EXPECT_FALSE(reader.ReadFecHeader(&read_packet));
@@ -336,9 +327,8 @@
   constexpr uint8_t kFlexfecPacketMask[] = {0x88, 0x81};
   constexpr uint8_t kUlpfecPacketMask[] = {0x11, 0x02};
   Packet written_packet;
-  written_packet.length = kMediaPacketLength;
-  written_packet.data.SetSize(written_packet.length);
-  for (size_t i = 0; i < written_packet.length; ++i) {
+  written_packet.data.SetSize(kMediaPacketLength);
+  for (size_t i = 0; i < written_packet.data.size(); ++i) {
     written_packet.data[i] = i;
   }
 
@@ -355,9 +345,8 @@
   constexpr uint8_t kFlexfecPacketMask[] = {0x48, 0x81, 0x82, 0x11, 0x00, 0x21};
   constexpr uint8_t kUlpfecPacketMask[] = {0x91, 0x02, 0x08, 0x44, 0x00, 0x84};
   Packet written_packet;
-  written_packet.length = kMediaPacketLength;
-  written_packet.data.SetSize(written_packet.length);
-  for (size_t i = 0; i < written_packet.length; ++i) {
+  written_packet.data.SetSize(kMediaPacketLength);
+  for (size_t i = 0; i < written_packet.data.size(); ++i) {
     written_packet.data[i] = i;
   }
 
@@ -378,9 +367,8 @@
   };
   constexpr uint8_t kUlpfecPacketMask[] = {0x22, 0x22, 0x44, 0x44, 0x44, 0x41};
   Packet written_packet;
-  written_packet.length = kMediaPacketLength;
-  written_packet.data.SetSize(written_packet.length);
-  for (size_t i = 0; i < written_packet.length; ++i) {
+  written_packet.data.SetSize(kMediaPacketLength);
+  for (size_t i = 0; i < written_packet.data.size(); ++i) {
     written_packet.data[i] = i;
   }
 
diff --git a/modules/rtp_rtcp/source/flexfec_receiver.cc b/modules/rtp_rtcp/source/flexfec_receiver.cc
index da7bda1..ba09db9 100644
--- a/modules/rtp_rtcp/source/flexfec_receiver.cc
+++ b/modules/rtp_rtcp/source/flexfec_receiver.cc
@@ -113,7 +113,6 @@
     // of initializing COW buffer with ArrayView.
     auto payload = packet.payload();
     received_packet->pkt->data.SetData(payload.data(), payload.size());
-    received_packet->pkt->length = payload.size();
   } else {
     // This is a media packet, or a FlexFEC packet belonging to some
     // other FlexFEC stream.
@@ -129,7 +128,6 @@
     RtpPacketReceived packet_copy(packet);
     packet_copy.ZeroMutableExtensions();
     received_packet->pkt->data = packet_copy.Buffer();
-    received_packet->pkt->length = received_packet->pkt->data.size();
   }
 
   ++packet_counter_.num_packets;
@@ -165,7 +163,8 @@
     recovered_packet->returned = true;
     RTC_CHECK_GT(recovered_packet->pkt->data.size(), 0);
     recovered_packet_receiver_->OnRecoveredPacket(
-        recovered_packet->pkt->data.cdata(), recovered_packet->pkt->length);
+        recovered_packet->pkt->data.cdata(),
+        recovered_packet->pkt->data.size());
     // Periodically log the incoming packets.
     int64_t now_ms = clock_->TimeInMilliseconds();
     if (now_ms - last_recovered_packet_ms_ > kPacketLogIntervalMs) {
diff --git a/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc b/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc
index 1542e74..224fee6 100644
--- a/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc
+++ b/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc
@@ -149,7 +149,7 @@
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
   const auto& media_packet = media_packets.front();
   // Simulate truncated FlexFEC payload.
-  fec_packets.front()->length = 1;
+  fec_packets.front()->data.SetSize(1);
   auto fec_packet = packet_generator_.BuildFlexfecPacket(*fec_packets.front());
 
   std::unique_ptr<ForwardErrorCorrection::ReceivedPacket> received_packet =
@@ -240,9 +240,9 @@
       packet_generator_.BuildFlexfecPacket(**fec_it);
   media_it++;
   EXPECT_CALL(recovered_packet_receiver_,
-              OnRecoveredPacket(_, (*media_it)->length))
-      .With(Args<0, 1>(
-          ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length)));
+              OnRecoveredPacket(_, (*media_it)->data.size()))
+      .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(),
+                                        (*media_it)->data.size())));
   receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
 }
 
@@ -262,9 +262,9 @@
       packet_generator_.BuildFlexfecPacket(**fec_it);
   auto media_it = media_packets.begin();
   EXPECT_CALL(recovered_packet_receiver_,
-              OnRecoveredPacket(_, (*media_it)->length))
-      .With(Args<0, 1>(
-          ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length)));
+              OnRecoveredPacket(_, (*media_it)->data.size()))
+      .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(),
+                                        (*media_it)->data.size())));
   receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
 
   // Receive second FEC packet and recover second lost media packet.
@@ -272,9 +272,9 @@
   packet_with_rtp_header = packet_generator_.BuildFlexfecPacket(**fec_it);
   media_it++;
   EXPECT_CALL(recovered_packet_receiver_,
-              OnRecoveredPacket(_, (*media_it)->length))
-      .With(Args<0, 1>(
-          ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length)));
+              OnRecoveredPacket(_, (*media_it)->data.size()))
+      .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(),
+                                        (*media_it)->data.size())));
   receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
 }
 
@@ -311,9 +311,9 @@
       packet_generator_.BuildFlexfecPacket(**fec_it);
   media_it++;
   EXPECT_CALL(recovered_packet_receiver_,
-              OnRecoveredPacket(_, (*media_it)->length))
-      .With(Args<0, 1>(
-          ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length)));
+              OnRecoveredPacket(_, (*media_it)->data.size()))
+      .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(),
+                                        (*media_it)->data.size())));
   receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
 
   // Receive the FEC packet again, but do not call back.
@@ -364,9 +364,9 @@
       break;
     }
     EXPECT_CALL(recovered_packet_receiver_,
-                OnRecoveredPacket(_, (*media_it)->length))
-        .With(Args<0, 1>(
-            ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length)));
+                OnRecoveredPacket(_, (*media_it)->data.size()))
+        .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(),
+                                          (*media_it)->data.size())));
     receiver_.OnRtpPacket(ParsePacket(*fec_packet_with_rtp_header));
     ++media_it;
   }
@@ -404,9 +404,9 @@
       packet_generator_.BuildFlexfecPacket(**fec_it);
   media_it = media_packets.begin();
   EXPECT_CALL(recovered_packet_receiver_,
-              OnRecoveredPacket(_, (*media_it)->length))
-      .With(Args<0, 1>(
-          ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length)));
+              OnRecoveredPacket(_, (*media_it)->data.size()))
+      .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(),
+                                        (*media_it)->data.size())));
   receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
 }
 
@@ -533,13 +533,13 @@
 
   // Expect to recover lost media packets.
   EXPECT_CALL(recovered_packet_receiver_,
-              OnRecoveredPacket(_, (*media_packet1)->length))
+              OnRecoveredPacket(_, (*media_packet1)->data.size()))
       .With(Args<0, 1>(ElementsAreArray((*media_packet1)->data.cdata(),
-                                        (*media_packet1)->length)));
+                                        (*media_packet1)->data.size())));
   EXPECT_CALL(recovered_packet_receiver_,
-              OnRecoveredPacket(_, (*media_packet4)->length))
+              OnRecoveredPacket(_, (*media_packet4)->data.size()))
       .With(Args<0, 1>(ElementsAreArray((*media_packet4)->data.cdata(),
-                                        (*media_packet4)->length)));
+                                        (*media_packet4)->data.size())));
 
   // Add FEC packets.
   auto fec_it = fec_packets.begin();
@@ -635,9 +635,9 @@
       packet_generator_.BuildFlexfecPacket(**fec_it);
   media_it++;
   EXPECT_CALL(recovered_packet_receiver_,
-              OnRecoveredPacket(_, (*media_it)->length))
-      .With(Args<0, 1>(
-          ElementsAreArray((*media_it)->data.cdata(), (*media_it)->length)));
+              OnRecoveredPacket(_, (*media_it)->data.size()))
+      .With(Args<0, 1>(ElementsAreArray((*media_it)->data.cdata(),
+                                        (*media_it)->data.size())));
   receiver_.OnRtpPacket(ParsePacket(*packet_with_rtp_header));
 
   // Check stats calculations.
diff --git a/modules/rtp_rtcp/source/flexfec_sender.cc b/modules/rtp_rtcp/source/flexfec_sender.cc
index 3fb51cd..d35f4d6 100644
--- a/modules/rtp_rtcp/source/flexfec_sender.cc
+++ b/modules/rtp_rtcp/source/flexfec_sender.cc
@@ -153,8 +153,9 @@
     }
 
     // RTP payload.
-    uint8_t* payload = fec_packet_to_send->AllocatePayload(fec_packet->length);
-    memcpy(payload, fec_packet->data.cdata(), fec_packet->length);
+    uint8_t* payload =
+        fec_packet_to_send->AllocatePayload(fec_packet->data.size());
+    memcpy(payload, fec_packet->data.cdata(), fec_packet->data.size());
 
     fec_packets_to_send.push_back(std::move(fec_packet_to_send));
   }
diff --git a/modules/rtp_rtcp/source/forward_error_correction.cc b/modules/rtp_rtcp/source/forward_error_correction.cc
index bfb4c2d..a098c4e 100644
--- a/modules/rtp_rtcp/source/forward_error_correction.cc
+++ b/modules/rtp_rtcp/source/forward_error_correction.cc
@@ -33,7 +33,7 @@
 constexpr size_t kTransportOverhead = 28;
 }  // namespace
 
-ForwardErrorCorrection::Packet::Packet() : length(0), data(), ref_count_(0) {}
+ForwardErrorCorrection::Packet::Packet() : data(0), ref_count_(0) {}
 ForwardErrorCorrection::Packet::~Packet() = default;
 
 int32_t ForwardErrorCorrection::Packet::AddRef() {
@@ -128,16 +128,16 @@
   // Error check the media packets.
   for (const auto& media_packet : media_packets) {
     RTC_DCHECK(media_packet);
-    if (media_packet->length < kRtpHeaderSize) {
-      RTC_LOG(LS_WARNING) << "Media packet " << media_packet->length
+    if (media_packet->data.size() < kRtpHeaderSize) {
+      RTC_LOG(LS_WARNING) << "Media packet " << media_packet->data.size()
                           << " bytes "
                           << "is smaller than RTP header.";
       return -1;
     }
     // Ensure the FEC packets will fit in a typical MTU.
-    if (media_packet->length + MaxPacketOverhead() + kTransportOverhead >
+    if (media_packet->data.size() + MaxPacketOverhead() + kTransportOverhead >
         IP_PACKET_SIZE) {
-      RTC_LOG(LS_WARNING) << "Media packet " << media_packet->length
+      RTC_LOG(LS_WARNING) << "Media packet " << media_packet->data.size()
                           << " bytes "
                           << "with overhead is larger than " << IP_PACKET_SIZE
                           << " bytes.";
@@ -153,7 +153,6 @@
     generated_fec_packets_[i].data.EnsureCapacity(IP_PACKET_SIZE);
     memset(generated_fec_packets_[i].data.data(), 0, IP_PACKET_SIZE);
     // Use this as a marker for untouched packets.
-    generated_fec_packets_[i].length = 0;
     generated_fec_packets_[i].data.SetSize(0);
     fec_packets->push_back(&generated_fec_packets_[i]);
   }
@@ -219,16 +218,16 @@
       Packet* const media_packet = media_packets_it->get();
       // Should |media_packet| be protected by |fec_packet|?
       if (packet_masks_[pkt_mask_idx] & (1 << (7 - media_pkt_idx))) {
-        size_t media_payload_length = media_packet->length - kRtpHeaderSize;
+        size_t media_payload_length =
+            media_packet->data.size() - kRtpHeaderSize;
 
-        bool first_protected_packet = (fec_packet->length == 0);
+        bool first_protected_packet = (fec_packet->data.size() == 0);
         size_t fec_packet_length = fec_header_size + media_payload_length;
-        if (fec_packet_length > fec_packet->length) {
+        if (fec_packet_length > fec_packet->data.size()) {
           // Recall that XORing with zero (which the FEC packets are prefilled
           // with) is the identity operator, thus all prior XORs are
           // still correct even though we expand the packet length here.
-          fec_packet->length = fec_packet_length;
-          fec_packet->data.SetSize(fec_packet->length);
+          fec_packet->data.SetSize(fec_packet_length);
         }
         if (first_protected_packet) {
           // Write P, X, CC, M, and PT recovery fields.
@@ -261,7 +260,7 @@
       pkt_mask_idx += media_pkt_idx / 8;
       media_pkt_idx %= 8;
     }
-    RTC_DCHECK_GT(fec_packet->length, 0)
+    RTC_DCHECK_GT(fec_packet->data.size(), 0)
         << "Packet mask is wrong or poorly designed.";
   }
 }
@@ -378,7 +377,6 @@
   recovered_packet->ssrc = received_packet.ssrc;
   recovered_packet->seq_num = received_packet.seq_num;
   recovered_packet->pkt = received_packet.pkt;
-  recovered_packet->pkt->length = received_packet.pkt->length;
   // TODO(holmer): Consider replacing this with a binary search for the right
   // position, and then just insert the new packet. Would get rid of the sort.
   RecoveredPacket* recovered_packet_ptr = recovered_packet.get();
@@ -538,7 +536,7 @@
     const ReceivedFecPacket& fec_packet,
     RecoveredPacket* recovered_packet) {
   // Sanity check packet length.
-  if (fec_packet.pkt->length < fec_packet.fec_header_size) {
+  if (fec_packet.pkt->data.size() < fec_packet.fec_header_size) {
     RTC_LOG(LS_WARNING)
         << "The FEC packet is truncated: it does not contain enough room "
         << "for its own header.";
@@ -585,7 +583,6 @@
                         << "typical IP packet, and is thus dropped.";
     return false;
   }
-  recovered_packet->pkt->length = new_size;
   recovered_packet->pkt->data.SetSize(new_size);
   // Set the SN field.
   ByteWriter<uint16_t>::WriteBigEndian(&recovered_packet->pkt->data[2],
@@ -605,7 +602,7 @@
   // XOR the length recovery field.
   uint8_t src_payload_length_network_order[2];
   ByteWriter<uint16_t>::WriteBigEndian(src_payload_length_network_order,
-                                       src.length - kRtpHeaderSize);
+                                       src.data.size() - kRtpHeaderSize);
   dst->data[2] ^= src_payload_length_network_order[0];
   dst->data[3] ^= src_payload_length_network_order[1];
 
@@ -642,7 +639,7 @@
     } else {
       XorHeaders(*protected_packet->pkt, recovered_packet->pkt);
       XorPayloads(*protected_packet->pkt,
-                  protected_packet->pkt->length - kRtpHeaderSize,
+                  protected_packet->pkt->data.size() - kRtpHeaderSize,
                   kRtpHeaderSize, recovered_packet->pkt);
     }
   }
diff --git a/modules/rtp_rtcp/source/forward_error_correction.h b/modules/rtp_rtcp/source/forward_error_correction.h
index c002647..70ec3c6 100644
--- a/modules/rtp_rtcp/source/forward_error_correction.h
+++ b/modules/rtp_rtcp/source/forward_error_correction.h
@@ -53,7 +53,6 @@
     // reaches zero.
     virtual int32_t Release();
 
-    size_t length;                 // Length of packet in bytes.
     rtc::CopyOnWriteBuffer data;   // Packet data.
 
    private:
diff --git a/modules/rtp_rtcp/source/rtp_fec_unittest.cc b/modules/rtp_rtcp/source/rtp_fec_unittest.cc
index 7d3b054..eb559f2 100644
--- a/modules/rtp_rtcp/source/rtp_fec_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_fec_unittest.cc
@@ -120,7 +120,6 @@
       std::unique_ptr<ForwardErrorCorrection::ReceivedPacket> received_packet(
           new ForwardErrorCorrection::ReceivedPacket());
       received_packet->pkt = new ForwardErrorCorrection::Packet();
-      received_packet->pkt->length = packet->length;
       received_packet->pkt->data = packet->data;
       received_packet->is_fec = is_fec;
       if (!is_fec) {
@@ -155,12 +154,12 @@
       [](const std::unique_ptr<ForwardErrorCorrection::Packet>& media_packet,
          const std::unique_ptr<ForwardErrorCorrection::RecoveredPacket>&
              recovered_packet) {
-        if (media_packet->length != recovered_packet->pkt->length) {
+        if (media_packet->data.size() != recovered_packet->pkt->data.size()) {
           return false;
         }
         if (memcmp(media_packet->data.cdata(),
                    recovered_packet->pkt->data.cdata(),
-                   media_packet->length) != 0) {
+                   media_packet->data.size()) != 0) {
           return false;
         }
         return true;
diff --git a/modules/rtp_rtcp/source/ulpfec_generator.cc b/modules/rtp_rtcp/source/ulpfec_generator.cc
index 791fff9..92e65df 100644
--- a/modules/rtp_rtcp/source/ulpfec_generator.cc
+++ b/modules/rtp_rtcp/source/ulpfec_generator.cc
@@ -148,7 +148,6 @@
         new ForwardErrorCorrection::Packet());
     RTC_DCHECK_GE(data_buffer.size(), rtp_header_length);
     packet->data = data_buffer;
-    packet->length = packet->data.size();
     media_packets_.push_back(std::move(packet));
     // Keep track of the RTP header length, so we can copy the RTP header
     // from |packet| to newly generated ULPFEC+RED packets.
@@ -226,13 +225,13 @@
     RTC_DCHECK_GT(last_media_packet_rtp_header_length_, 0);
     std::unique_ptr<RedPacket> red_packet(
         new RedPacket(last_media_packet_rtp_header_length_ +
-                      kRedForFecHeaderLength + fec_packet->length));
+                      kRedForFecHeaderLength + fec_packet->data.size()));
     red_packet->CreateHeader(last_media_packet->data.data(),
                              last_media_packet_rtp_header_length_,
                              red_payload_type, ulpfec_payload_type);
     red_packet->SetSeqNum(seq_num++);
     red_packet->ClearMarkerBit();
-    red_packet->AssignPayload(fec_packet->data.data(), fec_packet->length);
+    red_packet->AssignPayload(fec_packet->data.data(), fec_packet->data.size());
     red_packets.push_back(std::move(red_packet));
   }
 
diff --git a/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc b/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc
index 7086b13..496fe73 100644
--- a/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc
+++ b/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc
@@ -123,8 +123,8 @@
   // Protection length is set to entire packet. (This is not
   // required in general.)
   const size_t fec_header_size = FecHeaderSize(packet_mask_size);
-  ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[10],
-                                       fec_packet->length - fec_header_size);
+  ByteWriter<uint16_t>::WriteBigEndian(
+      &fec_packet->data[10], fec_packet->data.size() - fec_header_size);
   // Copy the packet mask.
   memcpy(&fec_packet->data[12], packet_mask, packet_mask_size);
 }
diff --git a/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc b/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc
index fb593b3..19da2c8 100644
--- a/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc
+++ b/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc
@@ -52,9 +52,8 @@
                                     size_t packet_mask_size) {
   UlpfecHeaderWriter writer;
   std::unique_ptr<Packet> written_packet(new Packet());
-  written_packet->length = kMediaPacketLength;
-  written_packet->data.SetSize(written_packet->length);
-  for (size_t i = 0; i < written_packet->length; ++i) {
+  written_packet->data.SetSize(kMediaPacketLength);
+  for (size_t i = 0; i < written_packet->data.size(); ++i) {
     written_packet->data[i] = i;  // Actual content doesn't matter.
   }
   writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask,
@@ -68,7 +67,6 @@
   read_packet->ssrc = kMediaSsrc;
   read_packet->pkt = rtc::scoped_refptr<Packet>(new Packet());
   read_packet->pkt->data = written_packet.data;
-  read_packet->pkt->length = written_packet.length;
   EXPECT_TRUE(reader.ReadFecHeader(read_packet.get()));
   return read_packet;
 }
@@ -84,7 +82,7 @@
   EXPECT_EQ(kMediaStartSeqNum, read_packet.seq_num_base);
   EXPECT_EQ(kUlpfecPacketMaskOffset, read_packet.packet_mask_offset);
   ASSERT_EQ(expected_packet_mask_size, read_packet.packet_mask_size);
-  EXPECT_EQ(written_packet.length - expected_fec_header_size,
+  EXPECT_EQ(written_packet.data.size() - expected_fec_header_size,
             read_packet.protection_length);
   EXPECT_EQ(0, memcmp(expected_packet_mask,
                       &read_packet.pkt->data[read_packet.packet_mask_offset],
@@ -92,7 +90,7 @@
   // Verify that the call to ReadFecHeader did not tamper with the payload.
   EXPECT_EQ(0, memcmp(written_packet.data.data() + expected_fec_header_size,
                       read_packet.pkt->data.cdata() + expected_fec_header_size,
-                      written_packet.length - expected_fec_header_size));
+                      written_packet.data.size() - expected_fec_header_size));
 }
 
 }  // namespace
@@ -109,7 +107,6 @@
   ReceivedFecPacket read_packet;
   read_packet.pkt = rtc::scoped_refptr<Packet>(new Packet());
   read_packet.pkt->data.SetData(packet, packet_length);
-  read_packet.pkt->length = packet_length;
 
   UlpfecHeaderReader reader;
   EXPECT_TRUE(reader.ReadFecHeader(&read_packet));
@@ -134,7 +131,6 @@
   ReceivedFecPacket read_packet;
   read_packet.pkt = rtc::scoped_refptr<Packet>(new Packet());
   read_packet.pkt->data.SetData(packet, packet_length);
-  read_packet.pkt->length = packet_length;
 
   UlpfecHeaderReader reader;
   EXPECT_TRUE(reader.ReadFecHeader(&read_packet));
@@ -150,9 +146,8 @@
   const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
   auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
   Packet written_packet;
-  written_packet.length = kMediaPacketLength;
-  written_packet.data.SetSize(written_packet.length);
-  for (size_t i = 0; i < written_packet.length; ++i) {
+  written_packet.data.SetSize(kMediaPacketLength);
+  for (size_t i = 0; i < written_packet.data.size(); ++i) {
     written_packet.data[i] = i;
   }
 
@@ -175,9 +170,8 @@
   const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
   auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
   Packet written_packet;
-  written_packet.length = kMediaPacketLength;
-  written_packet.data.SetSize(written_packet.length);
-  for (size_t i = 0; i < written_packet.length; ++i) {
+  written_packet.data.SetSize(kMediaPacketLength);
+  for (size_t i = 0; i < written_packet.data.size(); ++i) {
     written_packet.data[i] = i;
   }
 
diff --git a/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc b/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc
index b950cbd..9088a0c 100644
--- a/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc
+++ b/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc
@@ -133,7 +133,6 @@
     received_packet->pkt->data.SetData(
         incoming_rtp_packet + header.headerLength + red_header_length,
         payload_data_length - red_header_length);
-    received_packet->pkt->length = payload_data_length - red_header_length;
     received_packet->ssrc =
         ByteReader<uint32_t>::ReadBigEndian(&incoming_rtp_packet[8]);
 
@@ -152,11 +151,9 @@
              incoming_rtp_packet + header.headerLength + red_header_length,
              payload_data_length - red_header_length);
     }
-    received_packet->pkt->length =
-        header.headerLength + payload_data_length - red_header_length;
   }
 
-  if (received_packet->pkt->length == 0) {
+  if (received_packet->pkt->data.size() == 0) {
     return 0;
   }
 
@@ -185,7 +182,7 @@
       ForwardErrorCorrection::Packet* packet = received_packet->pkt;
       crit_sect_.Leave();
       recovered_packet_callback_->OnRecoveredPacket(packet->data.data(),
-                                                    packet->length);
+                                                    packet->data.size());
       crit_sect_.Enter();
       // Create a packet with the buffer to modify it.
       RtpPacketReceived rtp_packet;
@@ -213,7 +210,7 @@
     recovered_packet->returned = true;
     crit_sect_.Leave();
     recovered_packet_callback_->OnRecoveredPacket(packet->data.data(),
-                                                  packet->length);
+                                                  packet->data.size());
     crit_sect_.Enter();
   }
 
diff --git a/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc b/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc
index bbe616f..40bf0a5 100644
--- a/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc
+++ b/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc
@@ -127,7 +127,7 @@
       packet_generator_.BuildMediaRedPacket(*packet));
   EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket(
                    red_packet->header, red_packet->data.cdata(),
-                   red_packet->length, kFecPayloadType));
+                   red_packet->data.size(), kFecPayloadType));
 }
 
 void UlpfecReceiverTest::BuildAndAddRedFecPacket(Packet* packet) {
@@ -135,7 +135,7 @@
       packet_generator_.BuildUlpfecRedPacket(*packet));
   EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket(
                    red_packet->header, red_packet->data.cdata(),
-                   red_packet->length, kFecPayloadType));
+                   red_packet->data.size(), kFecPayloadType));
 }
 
 void UlpfecReceiverTest::VerifyReconstructedMediaPacket(
@@ -144,8 +144,10 @@
   // Verify that the content of the reconstructed packet is equal to the
   // content of |packet|, and that the same content is received |times| number
   // of times in a row.
-  EXPECT_CALL(recovered_packet_receiver_, OnRecoveredPacket(_, packet.length))
-      .With(Args<0, 1>(ElementsAreArray(packet.data.cdata(), packet.length)))
+  EXPECT_CALL(recovered_packet_receiver_,
+              OnRecoveredPacket(_, packet.data.size()))
+      .With(
+          Args<0, 1>(ElementsAreArray(packet.data.cdata(), packet.data.size())))
       .Times(times);
 }
 
diff --git a/modules/rtp_rtcp/test/testFec/test_fec.cc b/modules/rtp_rtcp/test/testFec/test_fec.cc
index 434d3ac..ff586e9 100644
--- a/modules/rtp_rtcp/test/testFec/test_fec.cc
+++ b/modules/rtp_rtcp/test/testFec/test_fec.cc
@@ -71,7 +71,6 @@
       *duplicate_packet = *received_packet;
       duplicate_packet->pkt = new ForwardErrorCorrection::Packet();
       duplicate_packet->pkt->data = received_packet->pkt->data;
-      duplicate_packet->pkt->length = received_packet->pkt->length;
 
       to_decode_list->push_back(std::move(duplicate_packet));
       random_variable = random->Rand<float>();
@@ -251,9 +250,8 @@
               const uint32_t kMinPacketSize = 12;
               const uint32_t kMaxPacketSize = static_cast<uint32_t>(
                   IP_PACKET_SIZE - 12 - 28 - fec->MaxPacketOverhead());
-              media_packet->length =
-                  random.Rand(kMinPacketSize, kMaxPacketSize);
-              media_packet->data.SetSize(media_packet->length);
+              media_packet->data.SetSize(
+                  random.Rand(kMinPacketSize, kMaxPacketSize));
 
               // Generate random values for the first 2 bytes.
               media_packet->data[0] = random.Rand<uint8_t>();
@@ -282,7 +280,7 @@
               ByteWriter<uint32_t>::WriteBigEndian(&media_packet->data[8],
                                                    media_ssrc);
               // Generate random values for payload
-              for (size_t j = 12; j < media_packet->length; ++j) {
+              for (size_t j = 12; j < media_packet->data.size(); ++j) {
                 media_packet->data[j] = random.Rand<uint8_t>();
               }
               media_packet_list.push_back(std::move(media_packet));
@@ -311,7 +309,6 @@
                     received_packet(
                         new ForwardErrorCorrection::ReceivedPacket());
                 received_packet->pkt = new ForwardErrorCorrection::Packet();
-                received_packet->pkt->length = media_packet->length;
                 received_packet->pkt->data = media_packet->data;
                 received_packet->ssrc = media_ssrc;
                 received_packet->seq_num =
@@ -332,7 +329,6 @@
                     received_packet(
                         new ForwardErrorCorrection::ReceivedPacket());
                 received_packet->pkt = new ForwardErrorCorrection::Packet();
-                received_packet->pkt->length = fec_packet->length;
                 received_packet->pkt->data = fec_packet->data;
                 received_packet->seq_num = fec_seq_num_offset + seq_num;
                 received_packet->is_fec = true;
@@ -421,12 +417,13 @@
                 ForwardErrorCorrection::RecoveredPacket* recovered_packet =
                     recovered_packet_list_it->get();
 
-                ASSERT_EQ(recovered_packet->pkt->length, media_packet->length)
+                ASSERT_EQ(recovered_packet->pkt->data.size(),
+                          media_packet->data.size())
                     << "Recovered packet length not identical to original "
                     << "media packet";
-                ASSERT_EQ(
-                    0, memcmp(recovered_packet->pkt->data.cdata(),
-                              media_packet->data.cdata(), media_packet->length))
+                ASSERT_EQ(0, memcmp(recovered_packet->pkt->data.cdata(),
+                                    media_packet->data.cdata(),
+                                    media_packet->data.size()))
                     << "Recovered packet payload not identical to original "
                     << "media packet";
                 recovered_packet_list.pop_front();
diff --git a/test/fuzzers/flexfec_header_reader_fuzzer.cc b/test/fuzzers/flexfec_header_reader_fuzzer.cc
index 2f4c498..4eb9a05 100644
--- a/test/fuzzers/flexfec_header_reader_fuzzer.cc
+++ b/test/fuzzers/flexfec_header_reader_fuzzer.cc
@@ -27,7 +27,6 @@
       std::min(size, static_cast<size_t>(IP_PACKET_SIZE));
   packet.pkt->data.SetSize(packet_size);
   memcpy(packet.pkt->data.data(), data, packet_size);
-  packet.pkt->length = packet_size;
 
   FlexfecHeaderReader flexfec_reader;
   flexfec_reader.ReadFecHeader(&packet);
diff --git a/test/fuzzers/forward_error_correction_fuzzer.cc b/test/fuzzers/forward_error_correction_fuzzer.cc
index 3e674cd..6c880a3 100644
--- a/test/fuzzers/forward_error_correction_fuzzer.cc
+++ b/test/fuzzers/forward_error_correction_fuzzer.cc
@@ -56,7 +56,7 @@
         new ForwardErrorCorrection::RecoveredPacket();
     recovered_packet->pkt = rtc::scoped_refptr<ForwardErrorCorrection::Packet>(
         new ForwardErrorCorrection::Packet());
-    recovered_packet->pkt->length = kPacketSize;
+    recovered_packet->pkt->data.SetSize(kPacketSize);
     recovered_packet->ssrc = kMediaSsrc;
     recovered_packet->seq_num = media_seqnum++;
     recovered_packets.emplace_back(recovered_packet);
@@ -66,7 +66,7 @@
   ForwardErrorCorrection::ReceivedPacket received_packet;
   received_packet.pkt = rtc::scoped_refptr<ForwardErrorCorrection::Packet>(
       new ForwardErrorCorrection::Packet());
-  received_packet.pkt->length = kPacketSize;
+  received_packet.pkt->data.SetSize(kPacketSize);
   uint8_t* packet_buffer = received_packet.pkt->data.data();
   uint8_t reordering;
   uint16_t seq_num_diff;
diff --git a/test/fuzzers/ulpfec_header_reader_fuzzer.cc b/test/fuzzers/ulpfec_header_reader_fuzzer.cc
index cf211f1..f3f6581 100644
--- a/test/fuzzers/ulpfec_header_reader_fuzzer.cc
+++ b/test/fuzzers/ulpfec_header_reader_fuzzer.cc
@@ -27,7 +27,6 @@
       std::min(size, static_cast<size_t>(IP_PACKET_SIZE));
   packet.pkt->data.SetSize(packet_size);
   memcpy(packet.pkt->data.data(), data, packet_size);
-  packet.pkt->length = packet_size;
 
   UlpfecHeaderReader ulpfec_reader;
   ulpfec_reader.ReadFecHeader(&packet);