diff --git a/api/video/encoded_image.cc b/api/video/encoded_image.cc
index 1c73bdabe6..61d921c4fd 100644
--- a/api/video/encoded_image.cc
+++ b/api/video/encoded_image.cc
@@ -66,21 +66,11 @@ EncodedImage::EncodedImage() = default;
 EncodedImage::EncodedImage(EncodedImage&&) = default;
 EncodedImage::EncodedImage(const EncodedImage&) = default;
 
-EncodedImage::EncodedImage(uint8_t* buffer, size_t size, size_t capacity)
-    : size_(size), buffer_(buffer), capacity_(capacity) {}
-
 EncodedImage::~EncodedImage() = default;
 
 EncodedImage& EncodedImage::operator=(EncodedImage&&) = default;
 EncodedImage& EncodedImage::operator=(const EncodedImage&) = default;
 
-void EncodedImage::Retain() {
-  if (buffer_) {
-    encoded_data_ = EncodedImageBuffer::Create(buffer_, size_);
-    buffer_ = nullptr;
-  }
-}
-
 void EncodedImage::SetEncodeTime(int64_t encode_start_ms,
                                  int64_t encode_finish_ms) {
   timing_.encode_start_ms = encode_start_ms;
diff --git a/api/video/encoded_image.h b/api/video/encoded_image.h
index 60e6625991..827175dea5 100644
--- a/api/video/encoded_image.h
+++ b/api/video/encoded_image.h
@@ -73,13 +73,10 @@ class RTC_EXPORT EncodedImage {
   EncodedImage();
   EncodedImage(EncodedImage&&);
   EncodedImage(const EncodedImage&);
-  ABSL_DEPRECATED("")
-  EncodedImage(uint8_t* buffer, size_t length, size_t capacity);
 
   ~EncodedImage();
 
   EncodedImage& operator=(EncodedImage&&);
-  // Discouraged: potentially expensive.
   EncodedImage& operator=(const EncodedImage&);
 
   // TODO(nisse): Change style to timestamp(), set_timestamp(), for consistency
@@ -129,33 +126,30 @@ class RTC_EXPORT EncodedImage {
     RTC_DCHECK_LE(new_size, new_size == 0 ? 0 : capacity());
     size_ = new_size;
   }
+
   void SetEncodedData(
       rtc::scoped_refptr<EncodedImageBufferInterface> encoded_data) {
     encoded_data_ = encoded_data;
     size_ = encoded_data->size();
-    buffer_ = nullptr;
   }
 
   void ClearEncodedData() {
     encoded_data_ = nullptr;
     size_ = 0;
-    buffer_ = nullptr;
-    capacity_ = 0;
   }
 
   rtc::scoped_refptr<EncodedImageBufferInterface> GetEncodedData() const {
-    RTC_DCHECK(buffer_ == nullptr);
     return encoded_data_;
   }
 
   const uint8_t* data() const {
-    return buffer_ ? buffer_
-                   : (encoded_data_ ? encoded_data_->data() : nullptr);
+    return encoded_data_ ? encoded_data_->data() : nullptr;
   }
 
-  // Hack to workaround lack of ownership of the encoded data. If we don't
-  // already own the underlying data, make an owned copy.
-  void Retain();
+  // TODO(bugs.webrtc.org/9378): Obsolete, delete as soon as downstream calls
+  // are fixed.
+  ABSL_DEPRECATED("")
+  void Retain() {}
 
   uint32_t _encodedWidth = 0;
   uint32_t _encodedHeight = 0;
@@ -186,18 +180,10 @@ class RTC_EXPORT EncodedImage {
   } timing_;
 
  private:
-  size_t capacity() const {
-    return buffer_ ? capacity_ : (encoded_data_ ? encoded_data_->size() : 0);
-  }
+  size_t capacity() const { return encoded_data_ ? encoded_data_->size() : 0; }
 
-  // TODO(bugs.webrtc.org/9378): We're transitioning to always owning the
-  // encoded data.
   rtc::scoped_refptr<EncodedImageBufferInterface> encoded_data_;
   size_t size_ = 0;  // Size of encoded frame data.
-  // Non-null when used with an un-owned buffer.
-  uint8_t* buffer_ = nullptr;
-  // Allocated size of _buffer; relevant only if it's non-null.
-  size_t capacity_ = 0;
   uint32_t timestamp_rtp_ = 0;
   absl::optional<int> spatial_index_;
   std::map<int, size_t> spatial_layer_frame_size_bytes_;
diff --git a/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc b/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
index 040fe9cce5..b08c5b1fc4 100644
--- a/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
+++ b/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
@@ -298,9 +298,6 @@ EncodedImageCallback::Result MultiplexEncoderAdapter::OnEncodedImage(
       PayloadStringToCodecType(associated_format_.name);
   image_component.encoded_image = encodedImage;
 
-  // If we don't already own the buffer, make a copy.
-  image_component.encoded_image.Retain();
-
   MutexLock lock(&mutex_);
   const auto& stashed_image_itr =
       stashed_images_.find(encodedImage.Timestamp());
diff --git a/modules/video_coding/codecs/test/videoprocessor.h b/modules/video_coding/codecs/test/videoprocessor.h
index 15c9d78718..d9e10f13bf 100644
--- a/modules/video_coding/codecs/test/videoprocessor.h
+++ b/modules/video_coding/codecs/test/videoprocessor.h
@@ -121,7 +121,6 @@ class VideoProcessor {
           : video_processor_(video_processor),
             encoded_image_(encoded_image),
             codec_specific_info_(*codec_specific_info) {
-        encoded_image_.Retain();
       }
 
       bool Run() override {
diff --git a/modules/video_coding/encoded_frame.h b/modules/video_coding/encoded_frame.h
index 61054ead35..9cc769277d 100644
--- a/modules/video_coding/encoded_frame.h
+++ b/modules/video_coding/encoded_frame.h
@@ -52,7 +52,6 @@ class RTC_EXPORT VCMEncodedFrame : public EncodedImage {
   using EncodedImage::GetEncodedData;
   using EncodedImage::NtpTimeMs;
   using EncodedImage::PacketInfos;
-  using EncodedImage::Retain;
   using EncodedImage::set_size;
   using EncodedImage::SetColorSpace;
   using EncodedImage::SetEncodedData;
diff --git a/video/video_receive_stream.cc b/video/video_receive_stream.cc
index 9e94e5e94e..037c5d31eb 100644
--- a/video/video_receive_stream.cc
+++ b/video/video_receive_stream.cc
@@ -683,7 +683,6 @@ void VideoReceiveStream::HandleEncodedFrame(
   }
 
   if (encoded_frame_buffer_function_) {
-    frame->Retain();
     encoded_frame_buffer_function_(WebRtcRecordableEncodedFrame(*frame));
   }
 }
diff --git a/video/video_receive_stream2.cc b/video/video_receive_stream2.cc
index ff31c6613a..c2a0792c46 100644
--- a/video/video_receive_stream2.cc
+++ b/video/video_receive_stream2.cc
@@ -725,7 +725,6 @@ void VideoReceiveStream2::HandleEncodedFrame(
       }));
 
   if (encoded_frame_buffer_function_) {
-    frame->Retain();
     encoded_frame_buffer_function_(WebRtcRecordableEncodedFrame(*frame));
   }
 }