diff --git a/api/media_transport_interface.cc b/api/media_transport_interface.cc
index 2164198831..ccdcb91688 100644
--- a/api/media_transport_interface.cc
+++ b/api/media_transport_interface.cc
@@ -129,11 +129,10 @@ MediaTransportEncodedVideoFrame::MediaTransportEncodedVideoFrame(
 }
 
 void MediaTransportEncodedVideoFrame::Retain() {
-  if (encoded_image_._buffer && encoded_data_.empty()) {
-    encoded_data_ =
-        std::vector<uint8_t>(encoded_image_._buffer,
-                             encoded_image_._buffer + encoded_image_._length);
-    encoded_image_._buffer = encoded_data_.data();
+  if (encoded_image_.data() && encoded_data_.empty()) {
+    encoded_data_ = std::vector<uint8_t>(
+        encoded_image_.data(), encoded_image_.data() + encoded_image_.size());
+    encoded_image_.set_buffer(encoded_data_.data(), encoded_image_.size());
   }
 }
 
diff --git a/api/test/loopback_media_transport_unittest.cc b/api/test/loopback_media_transport_unittest.cc
index c67a9d5ec1..13373558f2 100644
--- a/api/test/loopback_media_transport_unittest.cc
+++ b/api/test/loopback_media_transport_unittest.cc
@@ -105,8 +105,8 @@ TEST(LoopbackMediaTransport, VideoDeliveredToSink) {
   testing::StrictMock<MockMediaTransportVideoSinkInterface> sink;
   uint8_t encoded_data[] = {1, 2, 3};
   EncodedImage encoded_image;
-  encoded_image._buffer = encoded_data;
-  encoded_image._length = sizeof(encoded_data);
+  encoded_image.set_buffer(encoded_data, sizeof(encoded_data));
+  encoded_image.set_size(sizeof(encoded_data));
 
   EXPECT_CALL(sink, OnData(1, testing::Property(
                                   &MediaTransportEncodedVideoFrame::frame_id,
@@ -114,12 +114,12 @@ TEST(LoopbackMediaTransport, VideoDeliveredToSink) {
       .WillOnce(testing::Invoke(
           [&encoded_image](int frame_id,
                            const MediaTransportEncodedVideoFrame& frame) {
-            EXPECT_NE(frame.encoded_image()._buffer, encoded_image._buffer);
-            EXPECT_EQ(frame.encoded_image()._length, encoded_image._length);
-            EXPECT_EQ(
-                0, memcmp(frame.encoded_image()._buffer, encoded_image._buffer,
-                          std::min(frame.encoded_image()._length,
-                                   encoded_image._length)));
+            EXPECT_NE(frame.encoded_image().data(), encoded_image.data());
+            EXPECT_EQ(frame.encoded_image().size(), encoded_image.size());
+            EXPECT_EQ(0,
+                      memcmp(frame.encoded_image().data(), encoded_image.data(),
+                             std::min(frame.encoded_image().size(),
+                                      encoded_image.size())));
           }));
 
   transport_pair.second()->SetReceiveVideoSink(&sink);
diff --git a/api/video/encoded_image.cc b/api/video/encoded_image.cc
index 34d481397e..994bf15675 100644
--- a/api/video/encoded_image.cc
+++ b/api/video/encoded_image.cc
@@ -31,8 +31,8 @@ EncodedImage::EncodedImage() : EncodedImage(nullptr, 0, 0) {}
 
 EncodedImage::EncodedImage(const EncodedImage&) = default;
 
-EncodedImage::EncodedImage(uint8_t* buffer, size_t length, size_t capacity)
-    : _buffer(buffer), _length(length), capacity_(capacity) {}
+EncodedImage::EncodedImage(uint8_t* buffer, size_t size, size_t capacity)
+    : _buffer(buffer), size_(size), capacity_(capacity) {}
 
 void EncodedImage::SetEncodeTime(int64_t encode_start_ms,
                                  int64_t encode_finish_ms) {
diff --git a/api/video/encoded_image.h b/api/video/encoded_image.h
index ed1bb4b7b9..4828b02733 100644
--- a/api/video/encoded_image.h
+++ b/api/video/encoded_image.h
@@ -67,10 +67,10 @@ class RTC_EXPORT EncodedImage {
         color_space ? absl::make_optional(*color_space) : absl::nullopt;
   }
 
-  size_t size() const { return _length; }
+  size_t size() const { return size_; }
   void set_size(size_t new_size) {
     RTC_DCHECK_LE(new_size, capacity_);
-    _length = new_size;
+    size_ = new_size;
   }
   size_t capacity() const { return capacity_; }
 
@@ -89,8 +89,6 @@ class RTC_EXPORT EncodedImage {
   int64_t capture_time_ms_ = 0;
   FrameType _frameType = kVideoFrameDelta;
   uint8_t* _buffer;
-  // TODO(bugs.webrtc.org/9378): Rename to size_, capacity_ and make private.
-  size_t _length;
   VideoRotation rotation_ = kVideoRotation_0;
   VideoContentType content_type_ = VideoContentType::UNSPECIFIED;
   bool _completeFrame = false;
@@ -114,6 +112,7 @@ class RTC_EXPORT EncodedImage {
   } timing_;
 
  private:
+  size_t size_;      // Size of encoded frame data.
   size_t capacity_;  // Allocated size of _buffer.
   uint32_t timestamp_rtp_ = 0;
   absl::optional<int> spatial_index_;
diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc
index 9958d36e5e..6d13821e79 100644
--- a/call/rtp_video_sender.cc
+++ b/call/rtp_video_sender.cc
@@ -349,7 +349,7 @@ EncodedImageCallback::Result RtpVideoSender::OnEncodedImage(
     const EncodedImage& encoded_image,
     const CodecSpecificInfo* codec_specific_info,
     const RTPFragmentationHeader* fragmentation) {
-  fec_controller_->UpdateWithEncodedData(encoded_image._length,
+  fec_controller_->UpdateWithEncodedData(encoded_image.size(),
                                          encoded_image._frameType);
   rtc::CritScope lock(&crit_);
   RTC_DCHECK(!rtp_modules_.empty());
@@ -377,7 +377,7 @@ EncodedImageCallback::Result RtpVideoSender::OnEncodedImage(
   bool send_result = rtp_modules_[stream_index]->SendOutgoingData(
       encoded_image._frameType, rtp_config_.payload_type,
       encoded_image.Timestamp(), encoded_image.capture_time_ms_,
-      encoded_image._buffer, encoded_image._length, fragmentation,
+      encoded_image.data(), encoded_image.size(), fragmentation,
       &rtp_video_header, &frame_id);
   if (!send_result)
     return Result(Result::ERROR_SEND_FAILED);
diff --git a/call/rtp_video_sender_unittest.cc b/call/rtp_video_sender_unittest.cc
index f5731e9045..73194ebef1 100644
--- a/call/rtp_video_sender_unittest.cc
+++ b/call/rtp_video_sender_unittest.cc
@@ -144,8 +144,8 @@ TEST_P(RtpVideoSenderTest, SendOnOneModule) {
   encoded_image.SetTimestamp(1);
   encoded_image.capture_time_ms_ = 2;
   encoded_image._frameType = kVideoFrameKey;
-  encoded_image._buffer = &payload;
-  encoded_image._length = 1;
+  encoded_image.set_buffer(&payload, 1);
+  encoded_image.set_size(1);
 
   RtpVideoSenderTestFixture test({kSsrc1}, kPayloadType, {});
   EXPECT_NE(
@@ -174,8 +174,8 @@ TEST_P(RtpVideoSenderTest, SendSimulcastSetActive) {
   encoded_image_1.SetTimestamp(1);
   encoded_image_1.capture_time_ms_ = 2;
   encoded_image_1._frameType = kVideoFrameKey;
-  encoded_image_1._buffer = &payload;
-  encoded_image_1._length = 1;
+  encoded_image_1.set_buffer(&payload, 1);
+  encoded_image_1.set_size(1);
 
   RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {});
 
@@ -218,8 +218,9 @@ TEST_P(RtpVideoSenderTest, SendSimulcastSetActiveModules) {
   encoded_image_1.SetTimestamp(1);
   encoded_image_1.capture_time_ms_ = 2;
   encoded_image_1._frameType = kVideoFrameKey;
-  encoded_image_1._buffer = &payload;
-  encoded_image_1._length = 1;
+  encoded_image_1.set_buffer(&payload, 1);
+  encoded_image_1.set_size(1);
+
   EncodedImage encoded_image_2(encoded_image_1);
   encoded_image_2.SetSpatialIndex(1);
 
diff --git a/modules/video_coding/codecs/h264/h264_decoder_impl.cc b/modules/video_coding/codecs/h264/h264_decoder_impl.cc
index 89155f2e4c..298485ae39 100644
--- a/modules/video_coding/codecs/h264/h264_decoder_impl.cc
+++ b/modules/video_coding/codecs/h264/h264_decoder_impl.cc
@@ -241,7 +241,7 @@ int32_t H264DecoderImpl::Decode(const EncodedImage& input_image,
     ReportError();
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
-  if (!input_image._buffer || !input_image._length) {
+  if (!input_image.data() || !input_image.size()) {
     ReportError();
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
@@ -254,24 +254,23 @@ int32_t H264DecoderImpl::Decode(const EncodedImage& input_image,
   // FFmpeg requires padding due to some optimized bitstream readers reading 32
   // or 64 bits at once and could read over the end. See avcodec_decode_video2.
   RTC_CHECK_GE(input_image.capacity(),
-               input_image._length +
+               input_image.size() +
                    EncodedImage::GetBufferPaddingBytes(kVideoCodecH264));
   // "If the first 23 bits of the additional bytes are not 0, then damaged MPEG
   // bitstreams could cause overread and segfault." See
   // AV_INPUT_BUFFER_PADDING_SIZE. We'll zero the entire padding just in case.
-  memset(input_image._buffer + input_image._length,
-         0,
+  memset(input_image._buffer + input_image.size(), 0,
          EncodedImage::GetBufferPaddingBytes(kVideoCodecH264));
 
   AVPacket packet;
   av_init_packet(&packet);
   packet.data = input_image._buffer;
-  if (input_image._length >
+  if (input_image.size() >
       static_cast<size_t>(std::numeric_limits<int>::max())) {
     ReportError();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
-  packet.size = static_cast<int>(input_image._length);
+  packet.size = static_cast<int>(input_image.size());
   int64_t frame_timestamp_us = input_image.ntp_time_ms_ * 1000;  // ms -> μs
   av_context_->reordered_opaque = frame_timestamp_us;
 
@@ -318,8 +317,7 @@ int32_t H264DecoderImpl::Decode(const EncodedImage& input_image,
 
   absl::optional<uint8_t> qp;
   // TODO(sakal): Maybe it is possible to get QP directly from FFmpeg.
-  h264_bitstream_parser_.ParseBitstream(input_image._buffer,
-                                        input_image._length);
+  h264_bitstream_parser_.ParseBitstream(input_image.data(), input_image.size());
   int qp_int;
   if (h264_bitstream_parser_.GetLastSliceQp(&qp_int)) {
     qp.emplace(qp_int);
diff --git a/modules/video_coding/codecs/h264/h264_encoder_impl.cc b/modules/video_coding/codecs/h264/h264_encoder_impl.cc
index 05b26fecde..3eee819bc3 100644
--- a/modules/video_coding/codecs/h264/h264_encoder_impl.cc
+++ b/modules/video_coding/codecs/h264/h264_encoder_impl.cc
@@ -135,7 +135,7 @@ static void RtpFragmentize(EncodedImage* encoded_image,
   const uint8_t start_code[4] = {0, 0, 0, 1};
   frag_header->VerifyAndAllocateFragmentationHeader(fragments_count);
   size_t frag = 0;
-  encoded_image->_length = 0;
+  encoded_image->set_size(0);
   for (int layer = 0; layer < info->iLayerNum; ++layer) {
     const SLayerBSInfo& layerInfo = info->sLayerInfo[layer];
     // Iterate NAL units making up this layer, noting fragments.
@@ -149,15 +149,15 @@ static void RtpFragmentize(EncodedImage* encoded_image,
       RTC_DCHECK_EQ(layerInfo.pBsBuf[layer_len + 2], start_code[2]);
       RTC_DCHECK_EQ(layerInfo.pBsBuf[layer_len + 3], start_code[3]);
       frag_header->fragmentationOffset[frag] =
-          encoded_image->_length + layer_len + sizeof(start_code);
+          encoded_image->size() + layer_len + sizeof(start_code);
       frag_header->fragmentationLength[frag] =
           layerInfo.pNalLengthInByte[nal] - sizeof(start_code);
       layer_len += layerInfo.pNalLengthInByte[nal];
     }
     // Copy the entire layer's data (including start codes).
-    memcpy(encoded_image->_buffer + encoded_image->_length, layerInfo.pBsBuf,
+    memcpy(encoded_image->data() + encoded_image->size(), layerInfo.pBsBuf,
            layer_len);
-    encoded_image->_length += layer_len;
+    encoded_image->set_size(encoded_image->size() + layer_len);
   }
 }
 
@@ -308,7 +308,7 @@ int32_t H264EncoderImpl::InitEncode(const VideoCodec* inst,
     encoded_images_[i]._completeFrame = true;
     encoded_images_[i]._encodedWidth = codec_.simulcastStream[idx].width;
     encoded_images_[i]._encodedHeight = codec_.simulcastStream[idx].height;
-    encoded_images_[i]._length = 0;
+    encoded_images_[i].set_size(0);
   }
 
   SimulcastRateAllocator init_allocator(codec_);
@@ -519,10 +519,10 @@ int32_t H264EncoderImpl::Encode(const VideoFrame& input_frame,
 
     // Encoder can skip frames to save bandwidth in which case
     // |encoded_images_[i]._length| == 0.
-    if (encoded_images_[i]._length > 0) {
+    if (encoded_images_[i].size() > 0) {
       // Parse QP.
-      h264_bitstream_parser_.ParseBitstream(encoded_images_[i]._buffer,
-                                            encoded_images_[i]._length);
+      h264_bitstream_parser_.ParseBitstream(encoded_images_[i].data(),
+                                            encoded_images_[i].size());
       h264_bitstream_parser_.GetLastSliceQp(&encoded_images_[i].qp_);
 
       // Deliver encoded image.
diff --git a/modules/video_coding/codecs/multiplex/multiplex_encoded_image_packer.cc b/modules/video_coding/codecs/multiplex/multiplex_encoded_image_packer.cc
index 65146d77df..03f362177a 100644
--- a/modules/video_coding/codecs/multiplex/multiplex_encoded_image_packer.cc
+++ b/modules/video_coding/codecs/multiplex/multiplex_encoded_image_packer.cc
@@ -128,7 +128,7 @@ MultiplexImageComponentHeader UnpackFrameHeader(uint8_t* buffer) {
 }
 
 void PackBitstream(uint8_t* buffer, MultiplexImageComponent image) {
-  memcpy(buffer, image.encoded_image._buffer, image.encoded_image._length);
+  memcpy(buffer, image.encoded_image.data(), image.encoded_image.size());
 }
 
 MultiplexImage::MultiplexImage(uint16_t picture_index,
@@ -170,7 +170,7 @@ EncodedImage MultiplexEncodedImagePacker::PackAndRelease(
     const size_t padding =
         EncodedImage::GetBufferPaddingBytes(images[i].codec_type);
     frame_header.bitstream_length =
-        static_cast<uint32_t>(images[i].encoded_image._length + padding);
+        static_cast<uint32_t>(images[i].encoded_image.size() + padding);
     bitstream_offset += frame_header.bitstream_length;
 
     frame_header.codec_type = images[i].codec_type;
@@ -188,9 +188,8 @@ EncodedImage MultiplexEncodedImagePacker::PackAndRelease(
     frame_headers.push_back(frame_header);
   }
 
-  combined_image._length = bitstream_offset;
-  combined_image.set_buffer(new uint8_t[combined_image._length],
-                            combined_image._length);
+  combined_image.set_buffer(new uint8_t[bitstream_offset], bitstream_offset);
+  combined_image.set_size(bitstream_offset);
 
   // header
   header_offset = PackHeader(combined_image._buffer, header);
@@ -268,7 +267,7 @@ MultiplexImage MultiplexEncodedImagePacker::Unpack(
         static_cast<size_t>(frame_headers[i].bitstream_length));
     const size_t padding =
         EncodedImage::GetBufferPaddingBytes(image_component.codec_type);
-    encoded_image._length = encoded_image.capacity() - padding;
+    encoded_image.set_size(encoded_image.capacity() - padding);
 
     image_component.encoded_image = encoded_image;
 
diff --git a/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc b/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
index 450cc4b51b..158efd3d4d 100644
--- a/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
+++ b/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
@@ -275,9 +275,11 @@ EncodedImageCallback::Result MultiplexEncoderAdapter::OnEncodedImage(
   image_component.codec_type =
       PayloadStringToCodecType(associated_format_.name);
   image_component.encoded_image = encodedImage;
-  image_component.encoded_image._buffer = new uint8_t[encodedImage._length];
-  std::memcpy(image_component.encoded_image._buffer, encodedImage._buffer,
-              encodedImage._length);
+  image_component.encoded_image.set_buffer(new uint8_t[encodedImage.size()],
+                                           encodedImage.size());
+  image_component.encoded_image.set_size(encodedImage.size());
+  std::memcpy(image_component.encoded_image.data(), encodedImage.data(),
+              encodedImage.size());
 
   rtc::CritScope cs(&crit_);
   const auto& stashed_image_itr =
diff --git a/modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc b/modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
index de3dad3939..88e11e9c04 100644
--- a/modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
+++ b/modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
@@ -320,8 +320,7 @@ void VideoCodecTestFixtureImpl::H264KeyframeChecker::CheckEncodedFrame(
   bool contains_pps = false;
   bool contains_idr = false;
   const std::vector<webrtc::H264::NaluIndex> nalu_indices =
-      webrtc::H264::FindNaluIndices(encoded_frame._buffer,
-                                    encoded_frame._length);
+      webrtc::H264::FindNaluIndices(encoded_frame.data(), encoded_frame.size());
   for (const webrtc::H264::NaluIndex& index : nalu_indices) {
     webrtc::H264::NaluType nalu_type = webrtc::H264::ParseNaluType(
         encoded_frame._buffer[index.payload_start_offset]);
diff --git a/modules/video_coding/codecs/test/videocodec_test_libvpx.cc b/modules/video_coding/codecs/test/videocodec_test_libvpx.cc
index 4f63aa9ac8..ae079c6802 100644
--- a/modules/video_coding/codecs/test/videocodec_test_libvpx.cc
+++ b/modules/video_coding/codecs/test/videocodec_test_libvpx.cc
@@ -45,11 +45,9 @@ class QpFrameChecker : public VideoCodecTestFixture::EncodedFrameChecker {
                          const EncodedImage& encoded_frame) const override {
     int qp;
     if (codec == kVideoCodecVP8) {
-      EXPECT_TRUE(
-          vp8::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
+      EXPECT_TRUE(vp8::GetQp(encoded_frame.data(), encoded_frame.size(), &qp));
     } else if (codec == kVideoCodecVP9) {
-      EXPECT_TRUE(
-          vp9::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
+      EXPECT_TRUE(vp9::GetQp(encoded_frame.data(), encoded_frame.size(), &qp));
     } else {
       RTC_NOTREACHED();
     }
diff --git a/modules/video_coding/codecs/test/videoprocessor.cc b/modules/video_coding/codecs/test/videoprocessor.cc
index 85e717323e..706df79a0f 100644
--- a/modules/video_coding/codecs/test/videoprocessor.cc
+++ b/modules/video_coding/codecs/test/videoprocessor.cc
@@ -51,8 +51,7 @@ size_t GetMaxNaluSizeBytes(const EncodedImage& encoded_frame,
     return 0;
 
   std::vector<webrtc::H264::NaluIndex> nalu_indices =
-      webrtc::H264::FindNaluIndices(encoded_frame._buffer,
-                                    encoded_frame._length);
+      webrtc::H264::FindNaluIndices(encoded_frame.data(), encoded_frame.size());
 
   RTC_CHECK(!nalu_indices.empty());
 
@@ -392,7 +391,7 @@ void VideoProcessor::FrameEncoded(
       frame_stat->encode_start_ns, encode_stop_ns - post_encode_time_ns_);
   frame_stat->target_bitrate_kbps =
       bitrate_allocation_.GetTemporalLayerSum(spatial_idx, temporal_idx) / 1000;
-  frame_stat->length_bytes = encoded_image._length;
+  frame_stat->length_bytes = encoded_image.size();
   frame_stat->frame_type = encoded_image._frameType;
   frame_stat->temporal_idx = temporal_idx;
   frame_stat->max_nalu_size_bytes = GetMaxNaluSizeBytes(encoded_image, config_);
@@ -554,7 +553,7 @@ const webrtc::EncodedImage* VideoProcessor::BuildAndStoreSuperframe(
   RTC_CHECK_GT(config_.NumberOfSpatialLayers(), 1);
 
   EncodedImage base_image;
-  RTC_CHECK_EQ(base_image._length, 0);
+  RTC_CHECK_EQ(base_image.size(), 0);
 
   // Each SVC layer is decoded with dedicated decoder. Find the nearest
   // non-dropped base frame and merge it and current frame into superframe.
@@ -568,29 +567,29 @@ const webrtc::EncodedImage* VideoProcessor::BuildAndStoreSuperframe(
       }
     }
   }
-  const size_t payload_size_bytes = base_image._length + encoded_image._length;
+  const size_t payload_size_bytes = base_image.size() + encoded_image.size();
   const size_t buffer_size_bytes =
       payload_size_bytes + EncodedImage::GetBufferPaddingBytes(codec);
 
   uint8_t* copied_buffer = new uint8_t[buffer_size_bytes];
   RTC_CHECK(copied_buffer);
 
-  if (base_image._length) {
+  if (base_image.size()) {
     RTC_CHECK(base_image._buffer);
-    memcpy(copied_buffer, base_image._buffer, base_image._length);
+    memcpy(copied_buffer, base_image.data(), base_image.size());
   }
-  memcpy(copied_buffer + base_image._length, encoded_image._buffer,
-         encoded_image._length);
+  memcpy(copied_buffer + base_image.size(), encoded_image.data(),
+         encoded_image.size());
 
   EncodedImage copied_image = encoded_image;
   copied_image = encoded_image;
   copied_image.set_buffer(copied_buffer, buffer_size_bytes);
-  copied_image._length = payload_size_bytes;
+  copied_image.set_size(payload_size_bytes);
 
   // Replace previous EncodedImage for this spatial layer.
-  uint8_t* old_buffer = merged_encoded_frames_.at(spatial_idx)._buffer;
-  if (old_buffer) {
-    delete[] old_buffer;
+  uint8_t* old_data = merged_encoded_frames_.at(spatial_idx).data();
+  if (old_data) {
+    delete[] old_data;
   }
   merged_encoded_frames_.at(spatial_idx) = copied_image;
 
diff --git a/modules/video_coding/codecs/test/videoprocessor.h b/modules/video_coding/codecs/test/videoprocessor.h
index aaf9ccfec1..943ca878ef 100644
--- a/modules/video_coding/codecs/test/videoprocessor.h
+++ b/modules/video_coding/codecs/test/videoprocessor.h
@@ -109,7 +109,7 @@ class VideoProcessor {
                          const webrtc::EncodedImage& encoded_image,
                          const webrtc::CodecSpecificInfo* codec_specific_info)
           : video_processor_(video_processor),
-            buffer_(encoded_image._buffer, encoded_image._length),
+            buffer_(encoded_image._buffer, encoded_image.size()),
             encoded_image_(encoded_image),
             codec_specific_info_(*codec_specific_info) {
         encoded_image_._buffer = buffer_.data();
diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.cc b/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.cc
index 7b95d2b7b3..158f71b2df 100644
--- a/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.cc
+++ b/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.cc
@@ -161,7 +161,7 @@ int LibvpxVp8Decoder::Decode(const EncodedImage& input_image,
   if (decode_complete_callback_ == NULL) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
-  if (input_image._buffer == NULL && input_image._length > 0) {
+  if (input_image.data() == NULL && input_image.size() > 0) {
     // Reset to avoid requesting key frames too often.
     if (propagation_cnt_ > 0)
       propagation_cnt_ = 0;
@@ -249,10 +249,10 @@ int LibvpxVp8Decoder::Decode(const EncodedImage& input_image,
   }
 
   uint8_t* buffer = input_image._buffer;
-  if (input_image._length == 0) {
+  if (input_image.size() == 0) {
     buffer = NULL;  // Triggers full frame concealment.
   }
-  if (vpx_codec_decode(decoder_, buffer, input_image._length, 0,
+  if (vpx_codec_decode(decoder_, buffer, input_image.size(), 0,
                        kDecodeDeadlineRealtime)) {
     // Reset to avoid requesting key frames too often.
     if (propagation_cnt_ > 0) {
diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
index 9f2cb8ef99..57a362c3e4 100644
--- a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
+++ b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
@@ -861,7 +861,7 @@ void LibvpxVp8Encoder::PopulateCodecSpecific(CodecSpecificInfo* codec_specific,
   int qp = 0;
   vpx_codec_control(&encoders_[encoder_idx], VP8E_GET_LAST_QUANTIZER_64, &qp);
   temporal_layers_[stream_idx]->OnEncodeDone(
-      timestamp, encoded_images_[encoder_idx]._length,
+      timestamp, encoded_images_[encoder_idx].size(),
       (pkt.data.frame.flags & VPX_FRAME_IS_KEY) != 0, qp, vp8Info);
 }
 
@@ -871,7 +871,7 @@ int LibvpxVp8Encoder::GetEncodedPartitions(const VideoFrame& input_image) {
   for (size_t encoder_idx = 0; encoder_idx < encoders_.size();
        ++encoder_idx, --stream_idx) {
     vpx_codec_iter_t iter = NULL;
-    encoded_images_[encoder_idx]._length = 0;
+    encoded_images_[encoder_idx].set_size(0);
     encoded_images_[encoder_idx]._frameType = kVideoFrameDelta;
     CodecSpecificInfo codec_specific;
     const vpx_codec_cx_pkt_t* pkt = NULL;
@@ -879,7 +879,7 @@ int LibvpxVp8Encoder::GetEncodedPartitions(const VideoFrame& input_image) {
            NULL) {
       switch (pkt->kind) {
         case VPX_CODEC_CX_FRAME_PKT: {
-          size_t length = encoded_images_[encoder_idx]._length;
+          size_t length = encoded_images_[encoder_idx].size();
           if (pkt->data.frame.sz + length >
               encoded_images_[encoder_idx].capacity()) {
             uint8_t* buffer = new uint8_t[pkt->data.frame.sz + length];
@@ -890,8 +890,8 @@ int LibvpxVp8Encoder::GetEncodedPartitions(const VideoFrame& input_image) {
           }
           memcpy(&encoded_images_[encoder_idx]._buffer[length],
                  pkt->data.frame.buf, pkt->data.frame.sz);
-          encoded_images_[encoder_idx]._length += pkt->data.frame.sz;
-          assert(length <= encoded_images_[encoder_idx].capacity());
+          encoded_images_[encoder_idx].set_size(
+              encoded_images_[encoder_idx].size() + pkt->data.frame.sz);
           break;
         }
         default:
@@ -921,9 +921,9 @@ int LibvpxVp8Encoder::GetEncodedPartitions(const VideoFrame& input_image) {
     encoded_images_[encoder_idx].SetColorSpace(input_image.color_space());
 
     if (send_stream_[stream_idx]) {
-      if (encoded_images_[encoder_idx]._length > 0) {
+      if (encoded_images_[encoder_idx].size() > 0) {
         TRACE_COUNTER_ID1("webrtc", "EncodedFrameSize", encoder_idx,
-                          encoded_images_[encoder_idx]._length);
+                          encoded_images_[encoder_idx].size());
         encoded_images_[encoder_idx]._encodedHeight =
             codec_.simulcastStream[stream_idx].height;
         encoded_images_[encoder_idx]._encodedWidth =
@@ -937,7 +937,7 @@ int LibvpxVp8Encoder::GetEncodedPartitions(const VideoFrame& input_image) {
       } else if (!temporal_layers_[stream_idx]
                       ->SupportsEncoderFrameDropping()) {
         result = WEBRTC_VIDEO_CODEC_TARGET_BITRATE_OVERSHOOT;
-        if (encoded_images_[encoder_idx]._length == 0) {
+        if (encoded_images_[encoder_idx].size() == 0) {
           // Dropped frame that will be re-encoded.
           temporal_layers_[stream_idx]->OnEncodeDone(input_image.timestamp(), 0,
                                                      false, 0, nullptr);
diff --git a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
index ccc294c56e..12ffcb5d91 100644
--- a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
@@ -98,8 +98,8 @@ class TestVp8Impl : public VideoCodecUnitTest {
 
   void VerifyQpParser(const EncodedImage& encoded_frame) const {
     int qp;
-    EXPECT_GT(encoded_frame._length, 0u);
-    ASSERT_TRUE(vp8::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
+    EXPECT_GT(encoded_frame.size(), 0u);
+    ASSERT_TRUE(vp8::GetQp(encoded_frame.data(), encoded_frame.size(), &qp));
     EXPECT_EQ(encoded_frame.qp_, qp) << "Encoder QP != parsed bitstream QP.";
   }
 };
diff --git a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
index 085af97eff..98e0452940 100644
--- a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
@@ -243,7 +243,7 @@ TEST_F(TestVp9Impl, ParserQpEqualsEncodedQp) {
   ASSERT_TRUE(WaitForEncodedFrame(&encoded_frame, &codec_specific_info));
 
   int qp = 0;
-  ASSERT_TRUE(vp9::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
+  ASSERT_TRUE(vp9::GetQp(encoded_frame.data(), encoded_frame.size(), &qp));
   EXPECT_EQ(encoded_frame.qp_, qp);
 }
 
diff --git a/modules/video_coding/codecs/vp9/vp9_impl.cc b/modules/video_coding/codecs/vp9/vp9_impl.cc
index 6f3e979a85..3b92738e72 100644
--- a/modules/video_coding/codecs/vp9/vp9_impl.cc
+++ b/modules/video_coding/codecs/vp9/vp9_impl.cc
@@ -1263,7 +1263,7 @@ int VP9EncoderImpl::GetEncodedLayerFrame(const vpx_codec_cx_pkt* pkt) {
                               pkt->data.frame.sz);
   }
   memcpy(encoded_image_._buffer, pkt->data.frame.buf, pkt->data.frame.sz);
-  encoded_image_._length = pkt->data.frame.sz;
+  encoded_image_.set_size(pkt->data.frame.sz);
 
   const bool is_key_frame =
       (pkt->data.frame.flags & VPX_FRAME_IS_KEY) ? true : false;
@@ -1276,7 +1276,7 @@ int VP9EncoderImpl::GetEncodedLayerFrame(const vpx_codec_cx_pkt* pkt) {
     encoded_image_._frameType = kVideoFrameKey;
     force_key_frame_ = false;
   }
-  RTC_DCHECK_LE(encoded_image_._length, encoded_image_.capacity());
+  RTC_DCHECK_LE(encoded_image_.size(), encoded_image_.capacity());
 
   memset(&codec_specific_, 0, sizeof(codec_specific_));
   absl::optional<int> spatial_index;
@@ -1288,7 +1288,7 @@ int VP9EncoderImpl::GetEncodedLayerFrame(const vpx_codec_cx_pkt* pkt) {
     UpdateReferenceBuffers(*pkt, pics_since_key_);
   }
 
-  TRACE_COUNTER1("webrtc", "EncodedFrameSize", encoded_image_._length);
+  TRACE_COUNTER1("webrtc", "EncodedFrameSize", encoded_image_.size());
   encoded_image_.SetTimestamp(input_image_->timestamp());
   encoded_image_.capture_time_ms_ = input_image_->render_time_ms();
   encoded_image_.rotation_ = input_image_->rotation();
@@ -1315,7 +1315,7 @@ int VP9EncoderImpl::GetEncodedLayerFrame(const vpx_codec_cx_pkt* pkt) {
 }
 
 void VP9EncoderImpl::DeliverBufferedFrame(bool end_of_picture) {
-  if (encoded_image_._length > 0) {
+  if (encoded_image_.size() > 0) {
     codec_specific_.codecSpecific.VP9.end_of_picture = end_of_picture;
 
     // No data partitioning in VP9, so 1 partition only.
@@ -1323,13 +1323,13 @@ void VP9EncoderImpl::DeliverBufferedFrame(bool end_of_picture) {
     RTPFragmentationHeader frag_info;
     frag_info.VerifyAndAllocateFragmentationHeader(1);
     frag_info.fragmentationOffset[part_idx] = 0;
-    frag_info.fragmentationLength[part_idx] = encoded_image_._length;
+    frag_info.fragmentationLength[part_idx] = encoded_image_.size();
     frag_info.fragmentationPlType[part_idx] = 0;
     frag_info.fragmentationTimeDiff[part_idx] = 0;
 
     encoded_complete_callback_->OnEncodedImage(encoded_image_, &codec_specific_,
                                                &frag_info);
-    encoded_image_._length = 0;
+    encoded_image_.set_size(0);
 
     if (codec_.mode == VideoCodecMode::kScreensharing) {
       const uint8_t spatial_idx = encoded_image_.SpatialIndex().value_or(0);
@@ -1432,13 +1432,13 @@ int VP9DecoderImpl::Decode(const EncodedImage& input_image,
   vpx_codec_iter_t iter = nullptr;
   vpx_image_t* img;
   uint8_t* buffer = input_image._buffer;
-  if (input_image._length == 0) {
+  if (input_image.size() == 0) {
     buffer = nullptr;  // Triggers full frame concealment.
   }
   // During decode libvpx may get and release buffers from |frame_buffer_pool_|.
   // In practice libvpx keeps a few (~3-4) buffers alive at a time.
   if (vpx_codec_decode(decoder_, buffer,
-                       static_cast<unsigned int>(input_image._length), 0,
+                       static_cast<unsigned int>(input_image.size()), 0,
                        VPX_DL_REALTIME)) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
diff --git a/modules/video_coding/encoded_frame.cc b/modules/video_coding/encoded_frame.cc
index e19146da1c..3c677f77e4 100644
--- a/modules/video_coding/encoded_frame.cc
+++ b/modules/video_coding/encoded_frame.cc
@@ -52,7 +52,7 @@ void VCMEncodedFrame::Reset() {
   _encodedHeight = 0;
   _completeFrame = false;
   _missingFrame = false;
-  _length = 0;
+  set_size(0);
   _codecSpecificInfo.codecType = kVideoCodecGeneric;
   _codec = kVideoCodecGeneric;
   rotation_ = kVideoRotation_0;
diff --git a/modules/video_coding/frame_buffer.cc b/modules/video_coding/frame_buffer.cc
index 9be2ef0097..908a2a2806 100644
--- a/modules/video_coding/frame_buffer.cc
+++ b/modules/video_coding/frame_buffer.cc
@@ -138,8 +138,8 @@ VCMFrameBufferEnum VCMFrameBuffer::InsertPacket(
   } else if (retVal == -3) {
     return kOutOfBoundsPacket;
   }
-  // update length
-  _length = size() + static_cast<uint32_t>(retVal);
+  // update size
+  set_size(size() + static_cast<uint32_t>(retVal));
 
   _latestPacketTimeMs = timeInMs;
 
@@ -216,7 +216,7 @@ int VCMFrameBuffer::NumPackets() const {
 
 void VCMFrameBuffer::Reset() {
   TRACE_EVENT0("webrtc", "VCMFrameBuffer::Reset");
-  _length = 0;
+  set_size(0);
   _sessionInfo.Reset();
   _payloadType = 0;
   _nackCount = 0;
@@ -265,7 +265,7 @@ VCMFrameBufferStateEnum VCMFrameBuffer::GetState() const {
 void VCMFrameBuffer::PrepareForDecode(bool continuous) {
   TRACE_EVENT0("webrtc", "VCMFrameBuffer::PrepareForDecode");
   size_t bytes_removed = _sessionInfo.MakeDecodable();
-  _length -= bytes_removed;
+  set_size(size() - bytes_removed);
   // Transfer frame information to EncodedFrame and create any codec
   // specific information.
   _frameType = _sessionInfo.FrameType();
diff --git a/modules/video_coding/frame_buffer2_unittest.cc b/modules/video_coding/frame_buffer2_unittest.cc
index 321281f4c7..94a5551da5 100644
--- a/modules/video_coding/frame_buffer2_unittest.cc
+++ b/modules/video_coding/frame_buffer2_unittest.cc
@@ -91,10 +91,6 @@ class FrameObjectFake : public EncodedFrame {
   int64_t ReceivedTime() const override { return 0; }
 
   int64_t RenderTime() const override { return _renderTimeMs; }
-
-  // In EncodedImage |_length| is used to descibe its size and |_size| to
-  // describe its capacity.
-  void SetSize(int size) { _length = size; }
 };
 
 class VCMReceiveStatisticsCallbackMock : public VCMReceiveStatisticsCallback {
@@ -168,7 +164,7 @@ class TestFrameBuffer2 : public ::testing::Test {
     frame->is_last_spatial_layer = last_spatial_layer;
     // Add some data to buffer.
     frame->VerifyAndAllocate(kFrameSize);
-    frame->SetSize(kFrameSize);
+    frame->set_size(kFrameSize);
     for (size_t r = 0; r < references.size(); ++r)
       frame->references[r] = references[r];
 
@@ -491,7 +487,7 @@ TEST_F(TestFrameBuffer2, StatsCallback) {
   {
     std::unique_ptr<FrameObjectFake> frame(new FrameObjectFake());
     frame->VerifyAndAllocate(kFrameSize);
-    frame->SetSize(kFrameSize);
+    frame->set_size(kFrameSize);
     frame->id.picture_id = pid;
     frame->id.spatial_layer = 0;
     frame->SetTimestamp(ts);
diff --git a/modules/video_coding/frame_object.cc b/modules/video_coding/frame_object.cc
index 8fd8983451..6fcb573740 100644
--- a/modules/video_coding/frame_object.cc
+++ b/modules/video_coding/frame_object.cc
@@ -139,11 +139,6 @@ int64_t RtpFrameObject::RenderTime() const {
   return _renderTimeMs;
 }
 
-void RtpFrameObject::SetSize(size_t size) {
-  RTC_DCHECK_LE(size, capacity());
-  _length = size;
-}
-
 bool RtpFrameObject::delayed_by_retransmission() const {
   return times_nacked() > 0;
 }
@@ -188,7 +183,7 @@ void RtpFrameObject::AllocateBitstreamBuffer(size_t frame_size) {
     set_buffer(new uint8_t[new_size], new_size);
   }
 
-  _length = frame_size;
+  set_size(frame_size);
 }
 
 }  // namespace video_coding
diff --git a/modules/video_coding/frame_object.h b/modules/video_coding/frame_object.h
index 5a3efd9513..8b9ad9203c 100644
--- a/modules/video_coding/frame_object.h
+++ b/modules/video_coding/frame_object.h
@@ -40,7 +40,6 @@ class RtpFrameObject : public EncodedFrame {
   VideoCodecType codec_type() const;
   int64_t ReceivedTime() const override;
   int64_t RenderTime() const override;
-  void SetSize(size_t size);
   bool delayed_by_retransmission() const override;
   absl::optional<RTPVideoHeader> GetRtpVideoHeader() const;
   absl::optional<RtpGenericFrameDescriptor> GetGenericFrameDescriptor() const;
diff --git a/modules/video_coding/generic_encoder.cc b/modules/video_coding/generic_encoder.cc
index 221a8b2d81..52a82f3aa1 100644
--- a/modules/video_coding/generic_encoder.cc
+++ b/modules/video_coding/generic_encoder.cc
@@ -327,7 +327,7 @@ void VCMEncodedFrameCallback::FillTimingInfo(size_t simulcast_svc_idx,
 
     // Outliers trigger timing frames, but do not affect scheduled timing
     // frames.
-    if (outlier_frame_size && encoded_image->_length >= *outlier_frame_size) {
+    if (outlier_frame_size && encoded_image->size() >= *outlier_frame_size) {
       timing_flags |= VideoSendTiming::kTriggeredBySize;
     }
 
diff --git a/modules/video_coding/generic_encoder_unittest.cc b/modules/video_coding/generic_encoder_unittest.cc
index 66d787322f..4ea2506355 100644
--- a/modules/video_coding/generic_encoder_unittest.cc
+++ b/modules/video_coding/generic_encoder_unittest.cc
@@ -82,6 +82,7 @@ std::vector<std::vector<FrameType>> GetTimingFrames(
       {delay_ms, kDefaultOutlierFrameSizePercent});
   callback.OnFrameRateChanged(kFramerate);
   int s, i;
+  std::vector<uint8_t> frame_data(max_frame_size);
   std::vector<std::vector<FrameType>> result(num_streams);
   for (s = 0; s < num_streams; ++s)
     callback.OnTargetBitrateChanged(average_frame_sizes[s] * kFramerate, s);
@@ -94,7 +95,8 @@ std::vector<std::vector<FrameType>> GetTimingFrames(
 
       EncodedImage image;
       CodecSpecificInfo codec_specific;
-      image._length = FrameSize(min_frame_size, max_frame_size, s, i);
+      image.set_buffer(frame_data.data(), frame_data.size());
+      image.set_size(FrameSize(min_frame_size, max_frame_size, s, i));
       image.capture_time_ms_ = current_timestamp;
       image.SetTimestamp(static_cast<uint32_t>(current_timestamp * 90));
       image.SetSpatialIndex(s);
@@ -187,7 +189,9 @@ TEST(TestVCMEncodedFrameCallback, NoTimingFrameIfNoEncodeStartTime) {
   EncodedImage image;
   CodecSpecificInfo codec_specific;
   int64_t timestamp = 1;
-  image._length = 500;
+  uint8_t frame_data[500];
+  image.set_buffer(frame_data, sizeof(frame_data));
+  image.set_size(sizeof(frame_data));
   image.capture_time_ms_ = timestamp;
   image.SetTimestamp(static_cast<uint32_t>(timestamp * 90));
   codec_specific.codecType = kVideoCodecGeneric;
@@ -218,7 +222,9 @@ TEST(TestVCMEncodedFrameCallback, AdjustsCaptureTimeForInternalSourceEncoder) {
   const int64_t kEncodeStartDelayMs = 2;
   const int64_t kEncodeFinishDelayMs = 10;
   int64_t timestamp = 1;
-  image._length = 500;
+  uint8_t frame_data[500];
+  image.set_buffer(frame_data, sizeof(frame_data));
+  image.set_size(sizeof(frame_data));
   image.capture_time_ms_ = timestamp;
   image.SetTimestamp(static_cast<uint32_t>(timestamp * 90));
   codec_specific.codecType = kVideoCodecGeneric;
diff --git a/modules/video_coding/utility/ivf_file_writer.cc b/modules/video_coding/utility/ivf_file_writer.cc
index d9917c8ddb..225996ae15 100644
--- a/modules/video_coding/utility/ivf_file_writer.cc
+++ b/modules/video_coding/utility/ivf_file_writer.cc
@@ -160,7 +160,7 @@ bool IvfFileWriter::WriteFrame(const EncodedImage& encoded_image,
 
   const size_t kFrameHeaderSize = 12;
   if (byte_limit_ != 0 &&
-      bytes_written_ + kFrameHeaderSize + encoded_image._length > byte_limit_) {
+      bytes_written_ + kFrameHeaderSize + encoded_image.size() > byte_limit_) {
     RTC_LOG(LS_WARNING) << "Closing IVF file due to reaching size limit: "
                         << byte_limit_ << " bytes.";
     Close();
@@ -168,16 +168,16 @@ bool IvfFileWriter::WriteFrame(const EncodedImage& encoded_image,
   }
   uint8_t frame_header[kFrameHeaderSize] = {};
   ByteWriter<uint32_t>::WriteLittleEndian(
-      &frame_header[0], static_cast<uint32_t>(encoded_image._length));
+      &frame_header[0], static_cast<uint32_t>(encoded_image.size()));
   ByteWriter<uint64_t>::WriteLittleEndian(&frame_header[4], timestamp);
   if (file_.Write(frame_header, kFrameHeaderSize) < kFrameHeaderSize ||
-      file_.Write(encoded_image._buffer, encoded_image._length) <
-          encoded_image._length) {
+      file_.Write(encoded_image.data(), encoded_image.size()) <
+          encoded_image.size()) {
     RTC_LOG(LS_ERROR) << "Unable to write frame to file.";
     return false;
   }
 
-  bytes_written_ += kFrameHeaderSize + encoded_image._length;
+  bytes_written_ += kFrameHeaderSize + encoded_image.size();
 
   ++num_frames_;
   return true;
diff --git a/modules/video_coding/utility/ivf_file_writer_unittest.cc b/modules/video_coding/utility/ivf_file_writer_unittest.cc
index 6f71496b3b..82d604a117 100644
--- a/modules/video_coding/utility/ivf_file_writer_unittest.cc
+++ b/modules/video_coding/utility/ivf_file_writer_unittest.cc
@@ -41,11 +41,11 @@ class IvfFileWriterTest : public ::testing::Test {
                             int num_frames,
                             bool use_capture_tims_ms) {
     EncodedImage frame;
-    frame._buffer = dummy_payload;
+    frame.set_buffer(dummy_payload, sizeof(dummy_payload));
     frame._encodedWidth = width;
     frame._encodedHeight = height;
     for (int i = 1; i <= num_frames; ++i) {
-      frame._length = i % sizeof(dummy_payload);
+      frame.set_size(i % sizeof(dummy_payload));
       if (use_capture_tims_ms) {
         frame.capture_time_ms_ = i;
       } else {
diff --git a/modules/video_coding/utility/simulcast_test_fixture_impl.cc b/modules/video_coding/utility/simulcast_test_fixture_impl.cc
index 0230316469..6700e87eb7 100644
--- a/modules/video_coding/utility/simulcast_test_fixture_impl.cc
+++ b/modules/video_coding/utility/simulcast_test_fixture_impl.cc
@@ -85,18 +85,18 @@ class SimulcastTestFixtureImpl::TestEncodedImageCallback
         delete[] encoded_key_frame_._buffer;
         encoded_key_frame_.set_buffer(new uint8_t[encoded_image.capacity()],
                                       encoded_image.capacity());
-        encoded_key_frame_._length = encoded_image._length;
+        encoded_key_frame_.set_size(encoded_image.size());
         encoded_key_frame_._frameType = kVideoFrameKey;
         encoded_key_frame_._completeFrame = encoded_image._completeFrame;
         memcpy(encoded_key_frame_._buffer, encoded_image._buffer,
-               encoded_image._length);
+               encoded_image.size());
       } else {
         delete[] encoded_frame_._buffer;
         encoded_frame_.set_buffer(new uint8_t[encoded_image.capacity()],
                                   encoded_image.capacity());
-        encoded_frame_._length = encoded_image._length;
+        encoded_frame_.set_size(encoded_image.size());
         memcpy(encoded_frame_._buffer, encoded_image._buffer,
-               encoded_image._length);
+               encoded_image.size());
       }
     }
     if (is_vp8) {
@@ -858,11 +858,11 @@ void SimulcastTestFixtureImpl::TestDecodeWidthHeightSet() {
             encoded_frame[index].set_buffer(
                 new uint8_t[encoded_image.capacity()],
                 encoded_image.capacity());
-            encoded_frame[index]._length = encoded_image._length;
+            encoded_frame[index].set_size(encoded_image.size());
             encoded_frame[index]._frameType = encoded_image._frameType;
             encoded_frame[index]._completeFrame = encoded_image._completeFrame;
             memcpy(encoded_frame[index]._buffer, encoded_image._buffer,
-                   encoded_image._length);
+                   encoded_image.size());
             return EncodedImageCallback::Result(
                 EncodedImageCallback::Result::OK, 0);
           }));
diff --git a/modules/video_coding/video_packet_buffer_unittest.cc b/modules/video_coding/video_packet_buffer_unittest.cc
index 49b1c26819..190e0e78eb 100644
--- a/modules/video_coding/video_packet_buffer_unittest.cc
+++ b/modules/video_coding/video_packet_buffer_unittest.cc
@@ -643,7 +643,7 @@ TEST_P(TestPacketBufferH264Parameterized, GetBitstreamBufferPadding) {
   packet_buffer_->InsertPacket(&packet);
 
   ASSERT_EQ(1UL, frames_from_callback_.size());
-  EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage()._length,
+  EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage().size(),
             sizeof(data_data));
   EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage().capacity(),
             sizeof(data_data) + EncodedImage::kBufferPaddingBytesH264);
diff --git a/modules/video_coding/video_sender_unittest.cc b/modules/video_coding/video_sender_unittest.cc
index 44e9c3452d..11a69be137 100644
--- a/modules/video_coding/video_sender_unittest.cc
+++ b/modules/video_coding/video_sender_unittest.cc
@@ -104,7 +104,7 @@ class EncodedImageCallbackImpl : public EncodedImageCallback {
                         const RTPFragmentationHeader* fragmentation) override {
     assert(codec_specific_info);
     frame_data_.push_back(
-        FrameData(encoded_image._length, *codec_specific_info));
+        FrameData(encoded_image.size(), *codec_specific_info));
     return Result(Result::OK, encoded_image.Timestamp());
   }
 
diff --git a/sdk/android/src/jni/android_media_decoder.cc b/sdk/android/src/jni/android_media_decoder.cc
index a73167d717..35f415ef1a 100644
--- a/sdk/android/src/jni/android_media_decoder.cc
+++ b/sdk/android/src/jni/android_media_decoder.cc
@@ -360,7 +360,7 @@ int32_t MediaCodecVideoDecoder::Decode(
     ALOGE << "Decode() - callback_ is NULL";
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
-  if (inputImage._buffer == NULL && inputImage._length > 0) {
+  if (inputImage.data() == NULL && inputImage.size() > 0) {
     ALOGE << "Decode() - inputImage is incorrect";
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
@@ -408,7 +408,7 @@ int32_t MediaCodecVideoDecoder::Decode(
     }
     key_frame_required_ = false;
   }
-  if (inputImage._length == 0) {
+  if (inputImage.size() == 0) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
@@ -476,35 +476,34 @@ int32_t MediaCodecVideoDecoder::DecodeOnCodecThread(
   RTC_CHECK(buffer) << "Indirect buffer??";
   size_t buffer_capacity =
       rtc::dchecked_cast<size_t>(jni->GetDirectBufferCapacity(j_input_buffer));
-  if (CheckException(jni) || buffer_capacity < inputImage._length) {
-    ALOGE << "Input frame size " << inputImage._length
+  if (CheckException(jni) || buffer_capacity < inputImage.size()) {
+    ALOGE << "Input frame size " << inputImage.size()
           << " is bigger than buffer size " << buffer_capacity;
     return ProcessHWErrorOnCodecThread();
   }
   jlong presentation_timestamp_us = static_cast<jlong>(
       static_cast<int64_t>(frames_received_) * 1000000 / codec_.maxFramerate);
-  memcpy(buffer, inputImage._buffer, inputImage._length);
+  memcpy(buffer, inputImage.data(), inputImage.size());
 
   if (frames_decoded_ < frames_decoded_logged_) {
     ALOGD << "Decoder frame in # " << frames_received_
           << ". Type: " << inputImage._frameType << ". Buffer # "
           << j_input_buffer_index
           << ". TS: " << presentation_timestamp_us / 1000
-          << ". Size: " << inputImage._length;
+          << ". Size: " << inputImage.size();
   }
 
   // Save input image timestamps for later output.
   frames_received_++;
-  current_bytes_ += inputImage._length;
+  current_bytes_ += inputImage.size();
   absl::optional<uint8_t> qp;
   if (codecType_ == kVideoCodecVP8) {
     int qp_int;
-    if (vp8::GetQp(inputImage._buffer, inputImage._length, &qp_int)) {
+    if (vp8::GetQp(inputImage.data(), inputImage.size(), &qp_int)) {
       qp = qp_int;
     }
   } else if (codecType_ == kVideoCodecH264) {
-    h264_bitstream_parser_.ParseBitstream(inputImage._buffer,
-                                          inputImage._length);
+    h264_bitstream_parser_.ParseBitstream(inputImage.data(), inputImage.size());
     int qp_int;
     if (h264_bitstream_parser_.GetLastSliceQp(&qp_int)) {
       qp = qp_int;
@@ -515,7 +514,7 @@ int32_t MediaCodecVideoDecoder::DecodeOnCodecThread(
   // Feed input to decoder.
   bool success = Java_MediaCodecVideoDecoder_queueInputBuffer(
       jni, j_media_codec_video_decoder_, j_input_buffer_index,
-      static_cast<int>(inputImage._length), presentation_timestamp_us,
+      static_cast<int>(inputImage.size()), presentation_timestamp_us,
       static_cast<int64_t>(inputImage.Timestamp()), inputImage.ntp_time_ms_);
   if (CheckException(jni) || !success) {
     ALOGE << "queueInputBuffer error";
diff --git a/sdk/android/src/jni/android_media_encoder.cc b/sdk/android/src/jni/android_media_encoder.cc
index aaa2d9adba..69f0134686 100644
--- a/sdk/android/src/jni/android_media_encoder.cc
+++ b/sdk/android/src/jni/android_media_encoder.cc
@@ -1047,7 +1047,7 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {
       if (codec_type == kVideoCodecVP8 || codec_type == kVideoCodecVP9) {
         header.VerifyAndAllocateFragmentationHeader(1);
         header.fragmentationOffset[0] = 0;
-        header.fragmentationLength[0] = image->_length;
+        header.fragmentationLength[0] = image->size();
         header.fragmentationPlType[0] = 0;
         header.fragmentationTimeDiff[0] = 0;
         if (codec_type == kVideoCodecVP8) {
diff --git a/sdk/android/src/jni/encoded_image.cc b/sdk/android/src/jni/encoded_image.cc
index daa7788bf3..c801ce5f10 100644
--- a/sdk/android/src/jni/encoded_image.cc
+++ b/sdk/android/src/jni/encoded_image.cc
@@ -27,8 +27,8 @@ ScopedJavaLocalRef<jobject> NativeToJavaFrameType(JNIEnv* env,
 ScopedJavaLocalRef<jobject> NativeToJavaEncodedImage(
     JNIEnv* jni,
     const EncodedImage& image) {
-  ScopedJavaLocalRef<jobject> buffer =
-      NewDirectByteBuffer(jni, image._buffer, image._length);
+  ScopedJavaLocalRef<jobject> buffer = NewDirectByteBuffer(
+      jni, const_cast<uint8_t*>(image.data()), image.size());
   ScopedJavaLocalRef<jobject> frame_type =
       NativeToJavaFrameType(jni, image._frameType);
   ScopedJavaLocalRef<jobject> qp;
diff --git a/sdk/android/src/jni/video_decoder_wrapper.cc b/sdk/android/src/jni/video_decoder_wrapper.cc
index 26dc3d5ed2..037aef1d78 100644
--- a/sdk/android/src/jni/video_decoder_wrapper.cc
+++ b/sdk/android/src/jni/video_decoder_wrapper.cc
@@ -237,21 +237,21 @@ absl::optional<uint8_t> VideoDecoderWrapper::ParseQP(
   switch (codec_settings_.codecType) {
     case kVideoCodecVP8: {
       int qp_int;
-      if (vp8::GetQp(input_image._buffer, input_image._length, &qp_int)) {
+      if (vp8::GetQp(input_image.data(), input_image.size(), &qp_int)) {
         qp = qp_int;
       }
       break;
     }
     case kVideoCodecVP9: {
       int qp_int;
-      if (vp9::GetQp(input_image._buffer, input_image._length, &qp_int)) {
+      if (vp9::GetQp(input_image.data(), input_image.size(), &qp_int)) {
         qp = qp_int;
       }
       break;
     }
     case kVideoCodecH264: {
-      h264_bitstream_parser_.ParseBitstream(input_image._buffer,
-                                            input_image._length);
+      h264_bitstream_parser_.ParseBitstream(input_image.data(),
+                                            input_image.size());
       int qp_int;
       if (h264_bitstream_parser_.GetLastSliceQp(&qp_int)) {
         qp = qp_int;
diff --git a/sdk/objc/api/peerconnection/RTCEncodedImage+Private.mm b/sdk/objc/api/peerconnection/RTCEncodedImage+Private.mm
index 6f2d1f46d9..59962c89f8 100644
--- a/sdk/objc/api/peerconnection/RTCEncodedImage+Private.mm
+++ b/sdk/objc/api/peerconnection/RTCEncodedImage+Private.mm
@@ -17,9 +17,9 @@
 - (instancetype)initWithNativeEncodedImage:(webrtc::EncodedImage)encodedImage {
   if (self = [super init]) {
     // Wrap the buffer in NSData without copying, do not take ownership.
-    self.buffer = [NSData dataWithBytesNoCopy:encodedImage._buffer
-                                   length:encodedImage._length
-                             freeWhenDone:NO];
+    self.buffer = [NSData dataWithBytesNoCopy:encodedImage.data()
+                                       length:encodedImage.size()
+                                 freeWhenDone:NO];
     self.encodedWidth = rtc::dchecked_cast<int32_t>(encodedImage._encodedWidth);
     self.encodedHeight = rtc::dchecked_cast<int32_t>(encodedImage._encodedHeight);
     self.timeStamp = encodedImage.Timestamp();
diff --git a/test/fake_decoder.cc b/test/fake_decoder.cc
index 2dc5b6424a..8bf4ba07c1 100644
--- a/test/fake_decoder.cc
+++ b/test/fake_decoder.cc
@@ -80,9 +80,9 @@ int32_t FakeH264Decoder::Decode(const EncodedImage& input,
                                 const CodecSpecificInfo* codec_specific_info,
                                 int64_t render_time_ms) {
   uint8_t value = 0;
-  for (size_t i = 0; i < input._length; ++i) {
+  for (size_t i = 0; i < input.size(); ++i) {
     uint8_t kStartCode[] = {0, 0, 0, 1};
-    if (i < input._length - sizeof(kStartCode) &&
+    if (i < input.size() - sizeof(kStartCode) &&
         !memcmp(&input._buffer[i], kStartCode, sizeof(kStartCode))) {
       i += sizeof(kStartCode) + 1;  // Skip start code and NAL header.
     }
diff --git a/test/fake_encoder.cc b/test/fake_encoder.cc
index 06329c680a..2e64cdbbb1 100644
--- a/test/fake_encoder.cc
+++ b/test/fake_encoder.cc
@@ -304,7 +304,7 @@ EncodedImageCallback::Result FakeH264Encoder::OnEncodedImage(
   }
   RTPFragmentationHeader fragmentation;
   if (current_idr_counter % kIdrFrequency == 0 &&
-      encoded_image._length > kSpsSize + kPpsSize + 1) {
+      encoded_image.size() > kSpsSize + kPpsSize + 1) {
     const size_t kNumSlices = 3;
     fragmentation.VerifyAndAllocateFragmentationHeader(kNumSlices);
     fragmentation.fragmentationOffset[0] = 0;
@@ -313,7 +313,7 @@ EncodedImageCallback::Result FakeH264Encoder::OnEncodedImage(
     fragmentation.fragmentationLength[1] = kPpsSize;
     fragmentation.fragmentationOffset[2] = kSpsSize + kPpsSize;
     fragmentation.fragmentationLength[2] =
-        encoded_image._length - (kSpsSize + kPpsSize);
+        encoded_image.size() - (kSpsSize + kPpsSize);
     const size_t kSpsNalHeader = 0x67;
     const size_t kPpsNalHeader = 0x68;
     const size_t kIdrNalHeader = 0x65;
@@ -324,13 +324,13 @@ EncodedImageCallback::Result FakeH264Encoder::OnEncodedImage(
     const size_t kNumSlices = 1;
     fragmentation.VerifyAndAllocateFragmentationHeader(kNumSlices);
     fragmentation.fragmentationOffset[0] = 0;
-    fragmentation.fragmentationLength[0] = encoded_image._length;
+    fragmentation.fragmentationLength[0] = encoded_image.size();
     const size_t kNalHeader = 0x41;
     encoded_image._buffer[fragmentation.fragmentationOffset[0]] = kNalHeader;
   }
   uint8_t value = 0;
   int fragment_counter = 0;
-  for (size_t i = 0; i < encoded_image._length; ++i) {
+  for (size_t i = 0; i < encoded_image.size(); ++i) {
     if (fragment_counter == fragmentation.fragmentationVectorSize ||
         i != fragmentation.fragmentationOffset[fragment_counter]) {
       encoded_image._buffer[i] = value++;
diff --git a/test/fake_vp8_decoder.cc b/test/fake_vp8_decoder.cc
index 7b0cea0fae..2311228ca1 100644
--- a/test/fake_vp8_decoder.cc
+++ b/test/fake_vp8_decoder.cc
@@ -49,7 +49,7 @@ int32_t FakeVp8Decoder::Decode(const EncodedImage& input,
                                const CodecSpecificInfo* codec_specific_info,
                                int64_t render_time_ms) {
   constexpr size_t kMinPayLoadHeaderLength = 10;
-  if (input._length < kMinPayLoadHeaderLength) {
+  if (input.size() < kMinPayLoadHeaderLength) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   ParseFakeVp8(input._buffer, &width_, &height_);
diff --git a/test/fake_vp8_encoder.cc b/test/fake_vp8_encoder.cc
index dfd4802f49..f0c953c0c9 100644
--- a/test/fake_vp8_encoder.cc
+++ b/test/fake_vp8_encoder.cc
@@ -121,7 +121,7 @@ EncodedImageCallback::Result FakeVP8Encoder::OnEncodedImage(
   uint8_t stream_idx = encoded_image.SpatialIndex().value_or(0);
   CodecSpecificInfo overrided_specific_info;
   temporal_layers_[stream_idx]->UpdateLayerConfig(encoded_image.Timestamp());
-  PopulateCodecSpecific(&overrided_specific_info, encoded_image._length,
+  PopulateCodecSpecific(&overrided_specific_info, encoded_image.size(),
                         encoded_image._frameType, stream_idx,
                         encoded_image.Timestamp());
 
diff --git a/video/buffered_frame_decryptor.cc b/video/buffered_frame_decryptor.cc
index 5b1f7f0e0c..99dc74254b 100644
--- a/video/buffered_frame_decryptor.cc
+++ b/video/buffered_frame_decryptor.cc
@@ -87,7 +87,7 @@ BufferedFrameDecryptor::FrameDecision BufferedFrameDecryptor::DecryptFrame(
   }
   RTC_CHECK_LE(bytes_written, max_plaintext_byte_size);
   // Update the frame to contain just the written bytes.
-  frame->SetSize(bytes_written);
+  frame->set_size(bytes_written);
 
   // Indicate that all future fail to decrypt frames should be dropped.
   if (!first_frame_decrypted_) {
diff --git a/video/send_statistics_proxy.cc b/video/send_statistics_proxy.cc
index 24e9641947..e5e527ff81 100644
--- a/video/send_statistics_proxy.cc
+++ b/video/send_statistics_proxy.cc
@@ -959,7 +959,7 @@ void SendStatisticsProxy::OnSendEncodedImage(
     }
   }
 
-  media_byte_rate_tracker_.AddSamples(encoded_image._length);
+  media_byte_rate_tracker_.AddSamples(encoded_image.size());
 
   // Initialize to current since |is_limited_in_resolution| is only updated
   // when an encoded frame is removed from the EncodedFrameMap.
diff --git a/video/video_replay.cc b/video/video_replay.cc
index 79d13eb452..084abb964a 100644
--- a/video/video_replay.cc
+++ b/video/video_replay.cc
@@ -225,8 +225,8 @@ class DecoderBitstreamFileWriter : public test::FakeDecoder {
                  bool /* missing_frames */,
                  const CodecSpecificInfo* /* codec_specific_info */,
                  int64_t /* render_time_ms */) override {
-    if (fwrite(encoded_frame._buffer, 1, encoded_frame._length, file_) <
-        encoded_frame._length) {
+    if (fwrite(encoded_frame.data(), 1, encoded_frame.size(), file_) <
+        encoded_frame.size()) {
       RTC_LOG_ERR(LS_ERROR) << "fwrite of encoded frame failed.";
       return WEBRTC_VIDEO_CODEC_ERROR;
     }