Move RtpFrameObject and EncodedFrame out of video_coding namespace.

Bug: webrtc:12579
Change-Id: Ib7ecd624eb5c54abb77fe08440a014aa1e963865
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/212860
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Philip Eliasson <philipel@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33542}

api/video/encoded_frame.cc

@@ -11,11 +11,9 @@
 #include "api/video/encoded_frame.h"
 
 namespace webrtc {
-namespace video_coding {
 
 bool EncodedFrame::delayed_by_retransmission() const {
   return 0;
 }
 
-}  // namespace video_coding
 }  // namespace webrtc

api/video/encoded_frame.h

@@ -17,7 +17,6 @@
 #include "modules/video_coding/encoded_frame.h"
 
 namespace webrtc {
-namespace video_coding {
 
 // TODO(philipel): Remove webrtc::VCMEncodedFrame inheritance.
 // TODO(philipel): Move transport specific info out of EncodedFrame.
@@ -60,7 +59,11 @@ class EncodedFrame : public webrtc::VCMEncodedFrame {
   int64_t id_ = -1;
 };
 
+// TODO(bugs.webrtc.org/12579): Remove when downstream has been updated.
+namespace video_coding {
+using ::webrtc::EncodedFrame;
 }  // namespace video_coding
+
 }  // namespace webrtc
 
 #endif  // API_VIDEO_ENCODED_FRAME_H_

api/video/video_stream_decoder.h

@@ -46,7 +46,7 @@ class VideoStreamDecoderInterface {
 
   virtual ~VideoStreamDecoderInterface() = default;
 
-  virtual void OnFrame(std::unique_ptr<video_coding::EncodedFrame> frame) = 0;
+  virtual void OnFrame(std::unique_ptr<EncodedFrame> frame) = 0;
 
   virtual void SetMinPlayoutDelay(TimeDelta min_delay) = 0;
   virtual void SetMaxPlayoutDelay(TimeDelta max_delay) = 0;

modules/video_coding/frame_buffer2_unittest.cc

@@ -199,7 +199,7 @@ class TestFrameBuffer2 : public ::testing::Test {
     time_task_queue_.PostTask([this, max_wait_time, keyframe_required]() {
       buffer_->NextFrame(
           max_wait_time, keyframe_required, &time_task_queue_,
-          [this](std::unique_ptr<video_coding::EncodedFrame> frame,
+          [this](std::unique_ptr<EncodedFrame> frame,
                  video_coding::FrameBuffer::ReturnReason reason) {
             if (reason != FrameBuffer::ReturnReason::kStopped) {
               frames_.emplace_back(std::move(frame));

modules/video_coding/frame_object.cc

@@ -19,7 +19,6 @@
 #include "rtc_base/checks.h"
 
 namespace webrtc {
-namespace video_coding {
 RtpFrameObject::RtpFrameObject(
     uint16_t first_seq_num,
     uint16_t last_seq_num,
@@ -128,5 +127,4 @@ const RTPVideoHeader& RtpFrameObject::GetRtpVideoHeader() const {
   return rtp_video_header_;
 }
 
-}  // namespace video_coding
 }  // namespace webrtc

modules/video_coding/frame_object.h

@@ -15,7 +15,6 @@
 #include "api/video/encoded_frame.h"
 
 namespace webrtc {
-namespace video_coding {
 
 class RtpFrameObject : public EncodedFrame {
  public:
@@ -64,7 +63,11 @@ class RtpFrameObject : public EncodedFrame {
   int times_nacked_;
 };
 
+// TODO(bugs.webrtc.org/12579): Remove when downstream has been updated.
+namespace video_coding {
+using ::webrtc::RtpFrameObject;
 }  // namespace video_coding
+
 }  // namespace webrtc
 
 #endif  // MODULES_VIDEO_CODING_FRAME_OBJECT_H_

modules/video_coding/rtp_frame_id_only_ref_finder.cc

@@ -17,7 +17,7 @@
 namespace webrtc {
 
 RtpFrameReferenceFinder::ReturnVector RtpFrameIdOnlyRefFinder::ManageFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame,
+    std::unique_ptr<RtpFrameObject> frame,
     int frame_id) {
   frame->SetSpatialIndex(0);
   frame->SetId(unwrapper_.Unwrap(frame_id & (kFrameIdLength - 1)));

modules/video_coding/rtp_frame_id_only_ref_finder.h

@@ -25,7 +25,7 @@ class RtpFrameIdOnlyRefFinder {
   RtpFrameIdOnlyRefFinder() = default;
 
   RtpFrameReferenceFinder::ReturnVector ManageFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame,
+      std::unique_ptr<RtpFrameObject> frame,
       int frame_id);
 
  private:

modules/video_coding/rtp_frame_reference_finder.cc

@@ -27,7 +27,7 @@ class RtpFrameReferenceFinderImpl {
   RtpFrameReferenceFinderImpl() = default;
 
   RtpFrameReferenceFinder::ReturnVector ManageFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame);
+      std::unique_ptr<RtpFrameObject> frame);
   RtpFrameReferenceFinder::ReturnVector PaddingReceived(uint16_t seq_num);
   void ClearTo(uint16_t seq_num);
 
@@ -45,7 +45,7 @@ class RtpFrameReferenceFinderImpl {
 };
 
 RtpFrameReferenceFinder::ReturnVector RtpFrameReferenceFinderImpl::ManageFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame) {
+    std::unique_ptr<RtpFrameObject> frame) {
   const RTPVideoHeader& video_header = frame->GetRtpVideoHeader();
 
   if (video_header.generic.has_value()) {
@@ -156,7 +156,7 @@ RtpFrameReferenceFinder::RtpFrameReferenceFinder(
 RtpFrameReferenceFinder::~RtpFrameReferenceFinder() = default;
 
 void RtpFrameReferenceFinder::ManageFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame) {
+    std::unique_ptr<RtpFrameObject> frame) {
   // If we have cleared past this frame, drop it.
   if (cleared_to_seq_num_ != -1 &&
       AheadOf<uint16_t>(cleared_to_seq_num_, frame->first_seq_num())) {

modules/video_coding/rtp_frame_reference_finder.h

@@ -25,8 +25,7 @@ class RtpFrameReferenceFinderImpl;
 class OnCompleteFrameCallback {
  public:
   virtual ~OnCompleteFrameCallback() {}
-  virtual void OnCompleteFrame(
+  virtual void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) = 0;
-      std::unique_ptr<video_coding::EncodedFrame> frame) = 0;
 };
 
 // TODO(bugs.webrtc.org/12579): Remove when downstream has been update.
@@ -36,8 +35,7 @@ using OnCompleteFrameCallback = webrtc::OnCompleteFrameCallback;
 
 class RtpFrameReferenceFinder {
  public:
-  using ReturnVector =
+  using ReturnVector = absl::InlinedVector<std::unique_ptr<RtpFrameObject>, 3>;
-      absl::InlinedVector<std::unique_ptr<video_coding::RtpFrameObject>, 3>;
 
   explicit RtpFrameReferenceFinder(OnCompleteFrameCallback* frame_callback);
   explicit RtpFrameReferenceFinder(OnCompleteFrameCallback* frame_callback,
@@ -50,7 +48,7 @@ class RtpFrameReferenceFinder {
   //  - We have too many stashed frames (determined by |kMaxStashedFrames|)
   //    so we drop this frame, or
   //  - It gets cleared by ClearTo, which also means we drop it.
-  void ManageFrame(std::unique_ptr<video_coding::RtpFrameObject> frame);
+  void ManageFrame(std::unique_ptr<RtpFrameObject> frame);
 
   // Notifies that padding has been received, which the reference finder
   // might need to calculate the references of a frame.

modules/video_coding/rtp_frame_reference_finder_unittest.cc

@@ -24,10 +24,9 @@
 #include "test/gtest.h"
 
 namespace webrtc {
-namespace video_coding {
 
 namespace {
-std::unique_ptr<video_coding::RtpFrameObject> CreateFrame(
+std::unique_ptr<RtpFrameObject> CreateFrame(
     uint16_t seq_num_start,
     uint16_t seq_num_end,
     bool keyframe,
@@ -39,7 +38,7 @@ std::unique_ptr<video_coding::RtpFrameObject> CreateFrame(
   video_header.video_type_header = video_type_header;
 
   // clang-format off
-  return std::make_unique<video_coding::RtpFrameObject>(
+  return std::make_unique<RtpFrameObject>(
       seq_num_start,
       seq_num_end,
       /*markerBit=*/true,
@@ -71,8 +70,7 @@ class TestRtpFrameReferenceFinder : public ::testing::Test,
 
   uint16_t Rand() { return rand_.Rand<uint16_t>(); }
 
-  void OnCompleteFrame(
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override {
-      std::unique_ptr<video_coding::EncodedFrame> frame) override {
     int64_t pid = frame->Id();
     uint16_t sidx = *frame->SpatialIndex();
     auto frame_it = frames_from_callback_.find(std::make_pair(pid, sidx));
@@ -89,7 +87,7 @@ class TestRtpFrameReferenceFinder : public ::testing::Test,
   void InsertGeneric(uint16_t seq_num_start,
                      uint16_t seq_num_end,
                      bool keyframe) {
-    std::unique_ptr<video_coding::RtpFrameObject> frame =
+    std::unique_ptr<RtpFrameObject> frame =
         CreateFrame(seq_num_start, seq_num_end, keyframe, kVideoCodecGeneric,
                     RTPVideoTypeHeader());
 
@@ -97,7 +95,7 @@ class TestRtpFrameReferenceFinder : public ::testing::Test,
   }
 
   void InsertH264(uint16_t seq_num_start, uint16_t seq_num_end, bool keyframe) {
-    std::unique_ptr<video_coding::RtpFrameObject> frame =
+    std::unique_ptr<RtpFrameObject> frame =
         CreateFrame(seq_num_start, seq_num_end, keyframe, kVideoCodecH264,
                     RTPVideoTypeHeader());
     reference_finder_->ManageFrame(std::move(frame));
@@ -156,10 +154,9 @@ class TestRtpFrameReferenceFinder : public ::testing::Test,
       return f1.first < f2.first;
     }
   };
-  std::map<std::pair<int64_t, uint8_t>,
+  std::
-           std::unique_ptr<video_coding::EncodedFrame>,
+      map<std::pair<int64_t, uint8_t>, std::unique_ptr<EncodedFrame>, FrameComp>
-           FrameComp>
+          frames_from_callback_;
-      frames_from_callback_;
 };
 
 TEST_F(TestRtpFrameReferenceFinder, PaddingPackets) {
@@ -307,7 +304,7 @@ TEST_F(TestRtpFrameReferenceFinder, H264SequenceNumberWrapMulti) {
 
 TEST_F(TestRtpFrameReferenceFinder, Av1FrameNoDependencyDescriptor) {
   uint16_t sn = 0xFFFF;
-  std::unique_ptr<video_coding::RtpFrameObject> frame =
+  std::unique_ptr<RtpFrameObject> frame =
       CreateFrame(/*seq_num_start=*/sn, /*seq_num_end=*/sn, /*keyframe=*/true,
                   kVideoCodecAV1, RTPVideoTypeHeader());
 
@@ -317,5 +314,4 @@ TEST_F(TestRtpFrameReferenceFinder, Av1FrameNoDependencyDescriptor) {
   CheckReferencesGeneric(sn);
 }
 
-}  // namespace video_coding
 }  // namespace webrtc

modules/video_coding/rtp_generic_ref_finder.cc

@@ -17,7 +17,7 @@
 namespace webrtc {
 
 RtpFrameReferenceFinder::ReturnVector RtpGenericFrameRefFinder::ManageFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame,
+    std::unique_ptr<RtpFrameObject> frame,
     const RTPVideoHeader::GenericDescriptorInfo& descriptor) {
   // Frame IDs are unwrapped in the RtpVideoStreamReceiver, no need to unwrap
   // them here.
@@ -25,8 +25,7 @@ RtpFrameReferenceFinder::ReturnVector RtpGenericFrameRefFinder::ManageFrame(
   frame->SetSpatialIndex(descriptor.spatial_index);
 
   RtpFrameReferenceFinder::ReturnVector res;
-  if (video_coding::EncodedFrame::kMaxFrameReferences <
+  if (EncodedFrame::kMaxFrameReferences < descriptor.dependencies.size()) {
-      descriptor.dependencies.size()) {
     RTC_LOG(LS_WARNING) << "Too many dependencies in generic descriptor.";
     return res;
   }

modules/video_coding/rtp_generic_ref_finder.h

@@ -23,7 +23,7 @@ class RtpGenericFrameRefFinder {
   RtpGenericFrameRefFinder() = default;
 
   RtpFrameReferenceFinder::ReturnVector ManageFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame,
+      std::unique_ptr<RtpFrameObject> frame,
       const RTPVideoHeader::GenericDescriptorInfo& descriptor);
 };
 

modules/video_coding/rtp_seq_num_only_ref_finder.cc

@@ -17,7 +17,7 @@
 namespace webrtc {
 
 RtpFrameReferenceFinder::ReturnVector RtpSeqNumOnlyRefFinder::ManageFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame) {
+    std::unique_ptr<RtpFrameObject> frame) {
   FrameDecision decision = ManageFrameInternal(frame.get());
 
   RtpFrameReferenceFinder::ReturnVector res;
@@ -39,8 +39,7 @@ RtpFrameReferenceFinder::ReturnVector RtpSeqNumOnlyRefFinder::ManageFrame(
 }
 
 RtpSeqNumOnlyRefFinder::FrameDecision
-RtpSeqNumOnlyRefFinder::ManageFrameInternal(
+RtpSeqNumOnlyRefFinder::ManageFrameInternal(RtpFrameObject* frame) {
-    video_coding::RtpFrameObject* frame) {
   if (frame->frame_type() == VideoFrameType::kVideoFrameKey) {
     last_seq_num_gop_.insert(std::make_pair(
         frame->last_seq_num(),

modules/video_coding/rtp_seq_num_only_ref_finder.h

@@ -29,7 +29,7 @@ class RtpSeqNumOnlyRefFinder {
   RtpSeqNumOnlyRefFinder() = default;
 
   RtpFrameReferenceFinder::ReturnVector ManageFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame);
+      std::unique_ptr<RtpFrameObject> frame);
   RtpFrameReferenceFinder::ReturnVector PaddingReceived(uint16_t seq_num);
   void ClearTo(uint16_t seq_num);
 
@@ -39,7 +39,7 @@ class RtpSeqNumOnlyRefFinder {
 
   enum FrameDecision { kStash, kHandOff, kDrop };
 
-  FrameDecision ManageFrameInternal(video_coding::RtpFrameObject* frame);
+  FrameDecision ManageFrameInternal(RtpFrameObject* frame);
   void RetryStashedFrames(RtpFrameReferenceFinder::ReturnVector& res);
   void UpdateLastPictureIdWithPadding(uint16_t seq_num);
 
@@ -58,7 +58,7 @@ class RtpSeqNumOnlyRefFinder {
 
   // Frames that have been fully received but didn't have all the information
   // needed to determine their references.
-  std::deque<std::unique_ptr<video_coding::RtpFrameObject>> stashed_frames_;
+  std::deque<std::unique_ptr<RtpFrameObject>> stashed_frames_;
 
   // Unwrapper used to unwrap generic RTP streams. In a generic stream we derive
   // a picture id from the packet sequence number.

modules/video_coding/rtp_vp8_ref_finder.cc

@@ -17,7 +17,7 @@
 namespace webrtc {
 
 RtpFrameReferenceFinder::ReturnVector RtpVp8RefFinder::ManageFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame) {
+    std::unique_ptr<RtpFrameObject> frame) {
   FrameDecision decision = ManageFrameInternal(frame.get());
 
   RtpFrameReferenceFinder::ReturnVector res;
@@ -39,7 +39,7 @@ RtpFrameReferenceFinder::ReturnVector RtpVp8RefFinder::ManageFrame(
 }
 
 RtpVp8RefFinder::FrameDecision RtpVp8RefFinder::ManageFrameInternal(
-    video_coding::RtpFrameObject* frame) {
+    RtpFrameObject* frame) {
   const RTPVideoHeader& video_header = frame->GetRtpVideoHeader();
   const RTPVideoHeaderVP8& codec_header =
       absl::get<RTPVideoHeaderVP8>(video_header.video_type_header);
@@ -178,7 +178,7 @@ RtpVp8RefFinder::FrameDecision RtpVp8RefFinder::ManageFrameInternal(
   return kHandOff;
 }
 
-void RtpVp8RefFinder::UpdateLayerInfoVp8(video_coding::RtpFrameObject* frame,
+void RtpVp8RefFinder::UpdateLayerInfoVp8(RtpFrameObject* frame,
                                          int64_t unwrapped_tl0,
                                          uint8_t temporal_idx) {
   auto layer_info_it = layer_info_.find(unwrapped_tl0);
@@ -226,7 +226,7 @@ void RtpVp8RefFinder::RetryStashedFrames(
   } while (complete_frame);
 }
 
-void RtpVp8RefFinder::UnwrapPictureIds(video_coding::RtpFrameObject* frame) {
+void RtpVp8RefFinder::UnwrapPictureIds(RtpFrameObject* frame) {
   for (size_t i = 0; i < frame->num_references; ++i)
     frame->references[i] = unwrapper_.Unwrap(frame->references[i]);
   frame->SetId(unwrapper_.Unwrap(frame->Id()));

modules/video_coding/rtp_vp8_ref_finder.h

@@ -28,7 +28,7 @@ class RtpVp8RefFinder {
   RtpVp8RefFinder() = default;
 
   RtpFrameReferenceFinder::ReturnVector ManageFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame);
+      std::unique_ptr<RtpFrameObject> frame);
   void ClearTo(uint16_t seq_num);
 
  private:
@@ -40,12 +40,12 @@ class RtpVp8RefFinder {
 
   enum FrameDecision { kStash, kHandOff, kDrop };
 
-  FrameDecision ManageFrameInternal(video_coding::RtpFrameObject* frame);
+  FrameDecision ManageFrameInternal(RtpFrameObject* frame);
   void RetryStashedFrames(RtpFrameReferenceFinder::ReturnVector& res);
-  void UpdateLayerInfoVp8(video_coding::RtpFrameObject* frame,
+  void UpdateLayerInfoVp8(RtpFrameObject* frame,
                           int64_t unwrapped_tl0,
                           uint8_t temporal_idx);
-  void UnwrapPictureIds(video_coding::RtpFrameObject* frame);
+  void UnwrapPictureIds(RtpFrameObject* frame);
 
   // Save the last picture id in order to detect when there is a gap in frames
   // that have not yet been fully received.
@@ -58,7 +58,7 @@ class RtpVp8RefFinder {
 
   // Frames that have been fully received but didn't have all the information
   // needed to determine their references.
-  std::deque<std::unique_ptr<video_coding::RtpFrameObject>> stashed_frames_;
+  std::deque<std::unique_ptr<RtpFrameObject>> stashed_frames_;
 
   // Holds the information about the last completed frame for a given temporal
   // layer given an unwrapped Tl0 picture index.

modules/video_coding/rtp_vp8_ref_finder_unittest.cc

@@ -25,7 +25,6 @@ using ::testing::SizeIs;
 using ::testing::UnorderedElementsAreArray;
 
 namespace webrtc {
-namespace video_coding {
 namespace {
 
 MATCHER_P2(HasIdAndRefs, id, refs, "") {
@@ -34,7 +33,7 @@ MATCHER_P2(HasIdAndRefs, id, refs, "") {
              rtc::ArrayView<int64_t>(arg->references, arg->num_references));
 }
 
-Matcher<const std::vector<std::unique_ptr<video_coding::EncodedFrame>>&>
+Matcher<const std::vector<std::unique_ptr<EncodedFrame>>&>
 HasFrameWithIdAndRefs(int64_t frame_id, const std::vector<int64_t>& refs) {
   return Contains(HasIdAndRefs(frame_id, refs));
 }
@@ -66,7 +65,7 @@ class Frame {
     return *this;
   }
 
-  operator std::unique_ptr<video_coding::RtpFrameObject>() {
+  operator std::unique_ptr<RtpFrameObject>() {
     RTPVideoHeaderVP8 vp8_header{};
     vp8_header.pictureId = *picture_id_;
     vp8_header.temporalIdx = *temporal_id_;
@@ -78,7 +77,7 @@ class Frame {
                                            : VideoFrameType::kVideoFrameDelta;
     video_header.video_type_header = vp8_header;
     // clang-format off
-    return std::make_unique<video_coding::RtpFrameObject>(
+    return std::make_unique<RtpFrameObject>(
         /*seq_num_start=*/0,
         /*seq_num_end=*/0,
         /*markerBit=*/true,
@@ -113,14 +112,14 @@ class RtpVp8RefFinderTest : public ::testing::Test {
  protected:
   RtpVp8RefFinderTest() : ref_finder_(std::make_unique<RtpVp8RefFinder>()) {}
 
-  void Insert(std::unique_ptr<video_coding::RtpFrameObject> frame) {
+  void Insert(std::unique_ptr<RtpFrameObject> frame) {
     for (auto& f : ref_finder_->ManageFrame(std::move(frame))) {
       frames_.push_back(std::move(f));
     }
   }
 
   std::unique_ptr<RtpVp8RefFinder> ref_finder_;
-  std::vector<std::unique_ptr<video_coding::EncodedFrame>> frames_;
+  std::vector<std::unique_ptr<EncodedFrame>> frames_;
 };
 
 TEST_F(RtpVp8RefFinderTest, Vp8RepeatedFrame_0) {
@@ -358,5 +357,4 @@ TEST_F(RtpVp8RefFinderTest, Vp8DetectMissingFrame_0212) {
   EXPECT_THAT(frames_, HasFrameWithIdAndRefs(8, {5, 6, 7}));
 }
 
-}  // namespace video_coding
 }  // namespace webrtc

modules/video_coding/rtp_vp9_ref_finder.cc

@@ -18,7 +18,7 @@
 namespace webrtc {
 
 RtpFrameReferenceFinder::ReturnVector RtpVp9RefFinder::ManageFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame) {
+    std::unique_ptr<RtpFrameObject> frame) {
   FrameDecision decision = ManageFrameInternal(frame.get());
 
   RtpFrameReferenceFinder::ReturnVector res;
@@ -40,7 +40,7 @@ RtpFrameReferenceFinder::ReturnVector RtpVp9RefFinder::ManageFrame(
 }
 
 RtpVp9RefFinder::FrameDecision RtpVp9RefFinder::ManageFrameInternal(
-    video_coding::RtpFrameObject* frame) {
+    RtpFrameObject* frame) {
   const RTPVideoHeader& video_header = frame->GetRtpVideoHeader();
   const RTPVideoHeaderVP9& codec_header =
       absl::get<RTPVideoHeaderVP9>(video_header.video_type_header);
@@ -57,8 +57,7 @@ RtpVp9RefFinder::FrameDecision RtpVp9RefFinder::ManageFrameInternal(
     last_picture_id_ = frame->Id();
 
   if (codec_header.flexible_mode) {
-    if (codec_header.num_ref_pics >
+    if (codec_header.num_ref_pics > EncodedFrame::kMaxFrameReferences) {
-        video_coding::EncodedFrame::kMaxFrameReferences) {
       return kDrop;
     }
     frame->num_references = codec_header.num_ref_pics;
@@ -179,8 +178,7 @@ RtpVp9RefFinder::FrameDecision RtpVp9RefFinder::ManageFrameInternal(
       ForwardDiff<uint16_t, kFrameIdLength>(info->gof->pid_start, frame->Id());
   size_t gof_idx = diff % info->gof->num_frames_in_gof;
 
-  if (info->gof->num_ref_pics[gof_idx] >
+  if (info->gof->num_ref_pics[gof_idx] > EncodedFrame::kMaxFrameReferences) {
-      video_coding::EncodedFrame::kMaxFrameReferences) {
     return kDrop;
   }
   // Populate references according to the scalability structure.
@@ -324,7 +322,7 @@ void RtpVp9RefFinder::RetryStashedFrames(
   } while (complete_frame);
 }
 
-void RtpVp9RefFinder::FlattenFrameIdAndRefs(video_coding::RtpFrameObject* frame,
+void RtpVp9RefFinder::FlattenFrameIdAndRefs(RtpFrameObject* frame,
                                             bool inter_layer_predicted) {
   for (size_t i = 0; i < frame->num_references; ++i) {
     frame->references[i] =
@@ -335,8 +333,7 @@ void RtpVp9RefFinder::FlattenFrameIdAndRefs(video_coding::RtpFrameObject* frame,
                *frame->SpatialIndex());
 
   if (inter_layer_predicted &&
-      frame->num_references + 1 <=
+      frame->num_references + 1 <= EncodedFrame::kMaxFrameReferences) {
-          video_coding::EncodedFrame::kMaxFrameReferences) {
     frame->references[frame->num_references] = frame->Id() - 1;
     ++frame->num_references;
   }

modules/video_coding/rtp_vp9_ref_finder.h

@@ -28,7 +28,7 @@ class RtpVp9RefFinder {
   RtpVp9RefFinder() = default;
 
   RtpFrameReferenceFinder::ReturnVector ManageFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame);
+      std::unique_ptr<RtpFrameObject> frame);
   void ClearTo(uint16_t seq_num);
 
  private:
@@ -48,7 +48,7 @@ class RtpVp9RefFinder {
     uint16_t last_picture_id;
   };
 
-  FrameDecision ManageFrameInternal(video_coding::RtpFrameObject* frame);
+  FrameDecision ManageFrameInternal(RtpFrameObject* frame);
   void RetryStashedFrames(RtpFrameReferenceFinder::ReturnVector& res);
 
   bool MissingRequiredFrameVp9(uint16_t picture_id, const GofInfo& info);
@@ -58,8 +58,7 @@ class RtpVp9RefFinder {
                              uint8_t temporal_idx,
                              uint16_t pid_ref);
 
-  void FlattenFrameIdAndRefs(video_coding::RtpFrameObject* frame,
+  void FlattenFrameIdAndRefs(RtpFrameObject* frame, bool inter_layer_predicted);
-                             bool inter_layer_predicted);
 
   // Save the last picture id in order to detect when there is a gap in frames
   // that have not yet been fully received.
@@ -67,7 +66,7 @@ class RtpVp9RefFinder {
 
   // Frames that have been fully received but didn't have all the information
   // needed to determine their references.
-  std::deque<std::unique_ptr<video_coding::RtpFrameObject>> stashed_frames_;
+  std::deque<std::unique_ptr<RtpFrameObject>> stashed_frames_;
 
   // Where the current scalability structure is in the
   // |scalability_structures_| array.

modules/video_coding/rtp_vp9_ref_finder_unittest.cc

@@ -26,7 +26,6 @@ using ::testing::Property;
 using ::testing::UnorderedElementsAreArray;
 
 namespace webrtc {
-namespace video_coding {
 
 namespace {
 class Frame {
@@ -83,7 +82,7 @@ class Frame {
     return *this;
   }
 
-  operator std::unique_ptr<video_coding::RtpFrameObject>() {
+  operator std::unique_ptr<RtpFrameObject>() {
     RTPVideoHeaderVP9 vp9_header{};
     vp9_header.picture_id = *picture_id;
     vp9_header.temporal_idx = *temporal_id;
@@ -112,7 +111,7 @@ class Frame {
                                        : VideoFrameType::kVideoFrameDelta;
     video_header.video_type_header = vp9_header;
     // clang-format off
-    return std::make_unique<video_coding::RtpFrameObject>(
+    return std::make_unique<RtpFrameObject>(
         seq_num_start,
         seq_num_end,
         /*markerBit=*/true,
@@ -209,7 +208,7 @@ class RtpVp9RefFinderTest : public ::testing::Test {
  protected:
   RtpVp9RefFinderTest() : ref_finder_(std::make_unique<RtpVp9RefFinder>()) {}
 
-  void Insert(std::unique_ptr<video_coding::RtpFrameObject> frame) {
+  void Insert(std::unique_ptr<RtpFrameObject> frame) {
     for (auto& f : ref_finder_->ManageFrame(std::move(frame))) {
       frames_.push_back(std::move(f));
     }
@@ -703,5 +702,4 @@ TEST_F(RtpVp9RefFinderTest, SpatialIndex) {
               Contains(Pointee(Property(&EncodedFrame::SpatialIndex, 2))));
 }
 
-}  // namespace video_coding
 }  // namespace webrtc

test/fuzzers/frame_buffer2_fuzzer.cc

@@ -49,7 +49,7 @@ struct DataReader {
   size_t offset_ = 0;
 };
 
-class FuzzyFrameObject : public video_coding::EncodedFrame {
+class FuzzyFrameObject : public EncodedFrame {
  public:
   FuzzyFrameObject() {}
   ~FuzzyFrameObject() {}
@@ -80,8 +80,8 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
       frame->SetId(reader.GetNum<int64_t>());
       frame->SetSpatialIndex(reader.GetNum<uint8_t>() % 5);
       frame->SetTimestamp(reader.GetNum<uint32_t>());
-      frame->num_references = reader.GetNum<uint8_t>() %
+      frame->num_references =
-                              video_coding::EncodedFrame::kMaxFrameReferences;
+          reader.GetNum<uint8_t>() % EncodedFrame::kMaxFrameReferences;
 
       for (size_t r = 0; r < frame->num_references; ++r)
         frame->references[r] = reader.GetNum<int64_t>();
@@ -98,7 +98,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
           frame_buffer.NextFrame(
               max_wait_time_ms, keyframe_required, &task_queue,
               [&next_frame_task_running](
-                  std::unique_ptr<video_coding::EncodedFrame> frame,
+                  std::unique_ptr<EncodedFrame> frame,
                   video_coding::FrameBuffer::ReturnReason res) {
                 next_frame_task_running = false;
               });

test/fuzzers/rtp_frame_reference_finder_fuzzer.cc

@@ -59,8 +59,7 @@ class DataReader {
 };
 
 class NullCallback : public OnCompleteFrameCallback {
-  void OnCompleteFrame(
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override {}
-      std::unique_ptr<video_coding::EncodedFrame> frame) override {}
 };
 
 absl::optional<RTPVideoHeader::GenericDescriptorInfo>
@@ -135,7 +134,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
     video_header.generic = GenerateGenericFrameDependencies(&reader);
 
     // clang-format off
-    auto frame = std::make_unique<video_coding::RtpFrameObject>(
+    auto frame = std::make_unique<RtpFrameObject>(
         first_seq_num,
         last_seq_num,
         marker_bit,

video/buffered_frame_decryptor.cc

@@ -36,7 +36,7 @@ void BufferedFrameDecryptor::SetFrameDecryptor(
 }
 
 void BufferedFrameDecryptor::ManageEncryptedFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> encrypted_frame) {
+    std::unique_ptr<RtpFrameObject> encrypted_frame) {
   switch (DecryptFrame(encrypted_frame.get())) {
     case FrameDecision::kStash:
       if (stashed_frames_.size() >= kMaxStashedFrames) {
@@ -55,7 +55,7 @@ void BufferedFrameDecryptor::ManageEncryptedFrame(
 }
 
 BufferedFrameDecryptor::FrameDecision BufferedFrameDecryptor::DecryptFrame(
-    video_coding::RtpFrameObject* frame) {
+    RtpFrameObject* frame) {
   // Optionally attempt to decrypt the raw video frame if it was provided.
   if (frame_decryptor_ == nullptr) {
     RTC_LOG(LS_INFO) << "Frame decryption required but not attached to this "

video/buffered_frame_decryptor.h

@@ -27,8 +27,7 @@ class OnDecryptedFrameCallback {
  public:
   virtual ~OnDecryptedFrameCallback() = default;
   // Called each time a decrypted frame is returned.
-  virtual void OnDecryptedFrame(
+  virtual void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) = 0;
-      std::unique_ptr<video_coding::RtpFrameObject> frame) = 0;
 };
 
 // This callback is called each time there is a status change in the decryption
@@ -72,8 +71,7 @@ class BufferedFrameDecryptor final {
 
   // Determines whether the frame should be stashed, dropped or handed off to
   // the OnDecryptedFrameCallback.
-  void ManageEncryptedFrame(
+  void ManageEncryptedFrame(std::unique_ptr<RtpFrameObject> encrypted_frame);
-      std::unique_ptr<video_coding::RtpFrameObject> encrypted_frame);
 
  private:
   // Represents what should be done with a given frame.
@@ -82,7 +80,7 @@ class BufferedFrameDecryptor final {
   // Attempts to decrypt the frame, if it fails and no prior frames have been
   // decrypted it will return kStash. Otherwise fail to decrypts will return
   // kDrop. Successful decryptions will always return kDecrypted.
-  FrameDecision DecryptFrame(video_coding::RtpFrameObject* frame);
+  FrameDecision DecryptFrame(RtpFrameObject* frame);
   // Retries all the stashed frames this is triggered each time a kDecrypted
   // event occurs.
   void RetryStashedFrames();
@@ -96,7 +94,7 @@ class BufferedFrameDecryptor final {
   rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor_;
   OnDecryptedFrameCallback* const decrypted_frame_callback_;
   OnDecryptionStatusChangeCallback* const decryption_status_change_callback_;
-  std::deque<std::unique_ptr<video_coding::RtpFrameObject>> stashed_frames_;
+  std::deque<std::unique_ptr<RtpFrameObject>> stashed_frames_;
 };
 
 }  // namespace webrtc

video/buffered_frame_decryptor_unittest.cc

@@ -43,8 +43,7 @@ class BufferedFrameDecryptorTest : public ::testing::Test,
                                    public OnDecryptionStatusChangeCallback {
  public:
   // Implements the OnDecryptedFrameCallbackInterface
-  void OnDecryptedFrame(
+  void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) override {
-      std::unique_ptr<video_coding::RtpFrameObject> frame) override {
     decrypted_frame_call_count_++;
   }
 
@@ -54,14 +53,13 @@ class BufferedFrameDecryptorTest : public ::testing::Test,
 
   // Returns a new fake RtpFrameObject it abstracts the difficult construction
   // of the RtpFrameObject to simplify testing.
-  std::unique_ptr<video_coding::RtpFrameObject> CreateRtpFrameObject(
+  std::unique_ptr<RtpFrameObject> CreateRtpFrameObject(bool key_frame) {
-      bool key_frame) {
     seq_num_++;
     RTPVideoHeader rtp_video_header;
     rtp_video_header.generic.emplace();
 
     // clang-format off
-    return std::make_unique<video_coding::RtpFrameObject>(
+    return std::make_unique<RtpFrameObject>(
         seq_num_,
         seq_num_,
         /*markerBit=*/true,

video/rtp_video_stream_receiver.cc

@@ -794,7 +794,7 @@ void RtpVideoStreamReceiver::OnInsertedPacket(
       }
 
       const video_coding::PacketBuffer::Packet& last_packet = *packet;
-      OnAssembledFrame(std::make_unique<video_coding::RtpFrameObject>(
+      OnAssembledFrame(std::make_unique<RtpFrameObject>(
           first_packet->seq_num,                             //
           last_packet.seq_num,                               //
           last_packet.marker_bit,                            //
@@ -821,7 +821,7 @@ void RtpVideoStreamReceiver::OnInsertedPacket(
 }
 
 void RtpVideoStreamReceiver::OnAssembledFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame) {
+    std::unique_ptr<RtpFrameObject> frame) {
   RTC_DCHECK_RUN_ON(&network_tc_);
   RTC_DCHECK(frame);
 
@@ -890,11 +890,10 @@ void RtpVideoStreamReceiver::OnAssembledFrame(
 }
 
 void RtpVideoStreamReceiver::OnCompleteFrame(
-    std::unique_ptr<video_coding::EncodedFrame> frame) {
+    std::unique_ptr<EncodedFrame> frame) {
   {
     MutexLock lock(&last_seq_num_mutex_);
-    video_coding::RtpFrameObject* rtp_frame =
+    RtpFrameObject* rtp_frame = static_cast<RtpFrameObject*>(frame.get());
-        static_cast<video_coding::RtpFrameObject*>(frame.get());
     last_seq_num_for_pic_id_[rtp_frame->Id()] = rtp_frame->last_seq_num();
   }
   last_completed_picture_id_ =
@@ -903,7 +902,7 @@ void RtpVideoStreamReceiver::OnCompleteFrame(
 }
 
 void RtpVideoStreamReceiver::OnDecryptedFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame) {
+    std::unique_ptr<RtpFrameObject> frame) {
   MutexLock lock(&reference_finder_lock_);
   reference_finder_->ManageFrame(std::move(frame));
 }
@@ -970,7 +969,7 @@ void RtpVideoStreamReceiver::RemoveSecondarySink(
 }
 
 void RtpVideoStreamReceiver::ManageFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame) {
+    std::unique_ptr<RtpFrameObject> frame) {
   MutexLock lock(&reference_finder_lock_);
   reference_finder_->ManageFrame(std::move(frame));
 }

video/rtp_video_stream_receiver.h

@@ -172,12 +172,10 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
   void RequestPacketRetransmit(const std::vector<uint16_t>& sequence_numbers);
 
   // Implements OnCompleteFrameCallback.
-  void OnCompleteFrame(
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override;
-      std::unique_ptr<video_coding::EncodedFrame> frame) override;
 
   // Implements OnDecryptedFrameCallback.
-  void OnDecryptedFrame(
+  void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) override;
-      std::unique_ptr<video_coding::RtpFrameObject> frame) override;
 
   // Implements OnDecryptionStatusChangeCallback.
   void OnDecryptionStatusChange(
@@ -208,8 +206,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
 
  private:
   // Implements RtpVideoFrameReceiver.
-  void ManageFrame(
+  void ManageFrame(std::unique_ptr<RtpFrameObject> frame) override;
-      std::unique_ptr<video_coding::RtpFrameObject> frame) override;
 
   // Used for buffering RTCP feedback messages and sending them all together.
   // Note:
@@ -305,7 +302,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
   ParseGenericDependenciesResult ParseGenericDependenciesExtension(
       const RtpPacketReceived& rtp_packet,
       RTPVideoHeader* video_header) RTC_RUN_ON(worker_task_checker_);
-  void OnAssembledFrame(std::unique_ptr<video_coding::RtpFrameObject> frame);
+  void OnAssembledFrame(std::unique_ptr<RtpFrameObject> frame);
 
   Clock* const clock_;
   // Ownership of this object lies with VideoReceiveStream, which owns |this|.

video/rtp_video_stream_receiver2.cc

@@ -764,7 +764,7 @@ void RtpVideoStreamReceiver2::OnInsertedPacket(
       }
 
       const video_coding::PacketBuffer::Packet& last_packet = *packet;
-      OnAssembledFrame(std::make_unique<video_coding::RtpFrameObject>(
+      OnAssembledFrame(std::make_unique<RtpFrameObject>(
           first_packet->seq_num,                             //
           last_packet.seq_num,                               //
           last_packet.marker_bit,                            //
@@ -791,7 +791,7 @@ void RtpVideoStreamReceiver2::OnInsertedPacket(
 }
 
 void RtpVideoStreamReceiver2::OnAssembledFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame) {
+    std::unique_ptr<RtpFrameObject> frame) {
   RTC_DCHECK_RUN_ON(&worker_task_checker_);
   RTC_DCHECK(frame);
 
@@ -859,10 +859,9 @@ void RtpVideoStreamReceiver2::OnAssembledFrame(
 }
 
 void RtpVideoStreamReceiver2::OnCompleteFrame(
-    std::unique_ptr<video_coding::EncodedFrame> frame) {
+    std::unique_ptr<EncodedFrame> frame) {
   RTC_DCHECK_RUN_ON(&worker_task_checker_);
-  video_coding::RtpFrameObject* rtp_frame =
+  RtpFrameObject* rtp_frame = static_cast<RtpFrameObject*>(frame.get());
-      static_cast<video_coding::RtpFrameObject*>(frame.get());
   last_seq_num_for_pic_id_[rtp_frame->Id()] = rtp_frame->last_seq_num();
 
   last_completed_picture_id_ =
@@ -871,7 +870,7 @@ void RtpVideoStreamReceiver2::OnCompleteFrame(
 }
 
 void RtpVideoStreamReceiver2::OnDecryptedFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame) {
+    std::unique_ptr<RtpFrameObject> frame) {
   RTC_DCHECK_RUN_ON(&worker_task_checker_);
   reference_finder_->ManageFrame(std::move(frame));
 }
@@ -922,7 +921,7 @@ absl::optional<int64_t> RtpVideoStreamReceiver2::LastReceivedKeyframePacketMs()
 }
 
 void RtpVideoStreamReceiver2::ManageFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame) {
+    std::unique_ptr<RtpFrameObject> frame) {
   RTC_DCHECK_RUN_ON(&worker_task_checker_);
   reference_finder_->ManageFrame(std::move(frame));
 }

video/rtp_video_stream_receiver2.h

@@ -148,12 +148,10 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
   void RequestPacketRetransmit(const std::vector<uint16_t>& sequence_numbers);
 
   // Implements OnCompleteFrameCallback.
-  void OnCompleteFrame(
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override;
-      std::unique_ptr<video_coding::EncodedFrame> frame) override;
 
   // Implements OnDecryptedFrameCallback.
-  void OnDecryptedFrame(
+  void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) override;
-      std::unique_ptr<video_coding::RtpFrameObject> frame) override;
 
   // Implements OnDecryptionStatusChangeCallback.
   void OnDecryptionStatusChange(
@@ -177,8 +175,7 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
 
  private:
   // Implements RtpVideoFrameReceiver.
-  void ManageFrame(
+  void ManageFrame(std::unique_ptr<RtpFrameObject> frame) override;
-      std::unique_ptr<video_coding::RtpFrameObject> frame) override;
 
   // Used for buffering RTCP feedback messages and sending them all together.
   // Note:
@@ -262,7 +259,7 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
   ParseGenericDependenciesResult ParseGenericDependenciesExtension(
       const RtpPacketReceived& rtp_packet,
       RTPVideoHeader* video_header) RTC_RUN_ON(worker_task_checker_);
-  void OnAssembledFrame(std::unique_ptr<video_coding::RtpFrameObject> frame);
+  void OnAssembledFrame(std::unique_ptr<RtpFrameObject> frame);
 
   Clock* const clock_;
   // Ownership of this object lies with VideoReceiveStream, which owns |this|.

video/rtp_video_stream_receiver2_unittest.cc

@@ -51,8 +51,7 @@ namespace {
 
 const uint8_t kH264StartCode[] = {0x00, 0x00, 0x00, 0x01};
 
-std::vector<uint64_t> GetAbsoluteCaptureTimestamps(
+std::vector<uint64_t> GetAbsoluteCaptureTimestamps(const EncodedFrame* frame) {
-    const video_coding::EncodedFrame* frame) {
   std::vector<uint64_t> result;
   for (const auto& packet_info : frame->PacketInfos()) {
     if (packet_info.absolute_capture_time()) {
@@ -97,21 +96,11 @@ class MockKeyFrameRequestSender : public KeyFrameRequestSender {
 
 class MockOnCompleteFrameCallback : public OnCompleteFrameCallback {
  public:
-  MOCK_METHOD(void, DoOnCompleteFrame, (video_coding::EncodedFrame*), ());
+  MOCK_METHOD(void, DoOnCompleteFrame, (EncodedFrame*), ());
-  MOCK_METHOD(void,
+  MOCK_METHOD(void, DoOnCompleteFrameFailNullptr, (EncodedFrame*), ());
-              DoOnCompleteFrameFailNullptr,
+  MOCK_METHOD(void, DoOnCompleteFrameFailLength, (EncodedFrame*), ());
-              (video_coding::EncodedFrame*),
+  MOCK_METHOD(void, DoOnCompleteFrameFailBitstream, (EncodedFrame*), ());
-              ());
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override {
-  MOCK_METHOD(void,
-              DoOnCompleteFrameFailLength,
-              (video_coding::EncodedFrame*),
-              ());
-  MOCK_METHOD(void,
-              DoOnCompleteFrameFailBitstream,
-              (video_coding::EncodedFrame*),
-              ());
-  void OnCompleteFrame(
-      std::unique_ptr<video_coding::EncodedFrame> frame) override {
     if (!frame) {
       DoOnCompleteFrameFailNullptr(nullptr);
       return;
@@ -351,7 +340,7 @@ TEST_F(RtpVideoStreamReceiver2Test, CacheColorSpaceFromLastPacketOfKeyframe) {
   EXPECT_TRUE(key_frame_packet2.GetExtension<ColorSpaceExtension>());
   rtp_video_stream_receiver_->OnRtpPacket(key_frame_packet1);
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
-      .WillOnce(Invoke([kColorSpace](video_coding::EncodedFrame* frame) {
+      .WillOnce(Invoke([kColorSpace](EncodedFrame* frame) {
         ASSERT_TRUE(frame->EncodedImage().ColorSpace());
         EXPECT_EQ(*frame->EncodedImage().ColorSpace(), kColorSpace);
       }));
@@ -367,7 +356,7 @@ TEST_F(RtpVideoStreamReceiver2Test, CacheColorSpaceFromLastPacketOfKeyframe) {
   // included in the RTP packet.
   EXPECT_FALSE(delta_frame_packet.GetExtension<ColorSpaceExtension>());
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
-      .WillOnce(Invoke([kColorSpace](video_coding::EncodedFrame* frame) {
+      .WillOnce(Invoke([kColorSpace](EncodedFrame* frame) {
         ASSERT_TRUE(frame->EncodedImage().ColorSpace());
         EXPECT_EQ(*frame->EncodedImage().ColorSpace(), kColorSpace);
       }));
@@ -409,11 +398,10 @@ TEST_F(RtpVideoStreamReceiver2Test, PacketInfoIsPropagatedIntoVideoFrames) {
   mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(),
                                                            data.size());
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
-      .WillOnce(Invoke(
+      .WillOnce(Invoke([kAbsoluteCaptureTimestamp](EncodedFrame* frame) {
-          [kAbsoluteCaptureTimestamp](video_coding::EncodedFrame* frame) {
+        EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame),
-            EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame),
+                    ElementsAre(kAbsoluteCaptureTimestamp));
-                        ElementsAre(kAbsoluteCaptureTimestamp));
+      }));
-          }));
   rtp_video_stream_receiver_->OnReceivedPayloadData(data, rtp_packet,
                                                     video_header);
 }
@@ -457,7 +445,7 @@ TEST_F(RtpVideoStreamReceiver2Test,
   // Expect rtp video stream receiver to extrapolate it for the resulting video
   // frame using absolute capture time from the previous packet.
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
-      .WillOnce(Invoke([](video_coding::EncodedFrame* frame) {
+      .WillOnce(Invoke([](EncodedFrame* frame) {
         EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame), SizeIs(1));
       }));
   rtp_video_stream_receiver_->OnReceivedPayloadData(data, rtp_packet,
@@ -670,9 +658,8 @@ TEST_P(RtpVideoStreamReceiver2TestH264, ForceSpsPpsIdrIsKeyframe) {
   mock_on_complete_frame_callback_.AppendExpectedBitstream(idr_data.data(),
                                                            idr_data.size());
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce(
-        EXPECT_TRUE(frame->is_keyframe());
+          [&](EncodedFrame* frame) { EXPECT_TRUE(frame->is_keyframe()); });
-      });
   rtp_video_stream_receiver_->OnReceivedPayloadData(idr_data, rtp_packet,
                                                     idr_video_header);
   mock_on_complete_frame_callback_.ClearExpectedBitstream();
@@ -682,9 +669,8 @@ TEST_P(RtpVideoStreamReceiver2TestH264, ForceSpsPpsIdrIsKeyframe) {
                                                            idr_data.size());
   rtp_packet.SetSequenceNumber(3);
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce(
-        EXPECT_FALSE(frame->is_keyframe());
+          [&](EncodedFrame* frame) { EXPECT_FALSE(frame->is_keyframe()); });
-      });
   rtp_video_stream_receiver_->OnReceivedPayloadData(idr_data, rtp_packet,
                                                     idr_video_header);
 }
@@ -826,7 +812,7 @@ TEST_F(RtpVideoStreamReceiver2Test, ParseGenericDescriptorOnePacket) {
   rtp_packet.SetSequenceNumber(1);
 
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce(Invoke([kSpatialIndex](video_coding::EncodedFrame* frame) {
+      .WillOnce(Invoke([kSpatialIndex](EncodedFrame* frame) {
         EXPECT_EQ(frame->num_references, 2U);
         EXPECT_EQ(frame->references[0], frame->Id() - 90);
         EXPECT_EQ(frame->references[1], frame->Id() - 80);
@@ -884,7 +870,7 @@ TEST_F(RtpVideoStreamReceiver2Test, ParseGenericDescriptorTwoPackets) {
                                                            data.size() - 1);
 
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce(Invoke([kSpatialIndex](video_coding::EncodedFrame* frame) {
+      .WillOnce(Invoke([kSpatialIndex](EncodedFrame* frame) {
         EXPECT_EQ(frame->num_references, 0U);
         EXPECT_EQ(frame->SpatialIndex(), kSpatialIndex);
         EXPECT_EQ(frame->EncodedImage()._encodedWidth, 480u);
@@ -963,13 +949,11 @@ TEST_F(RtpVideoStreamReceiver2Test, UnwrapsFrameId) {
 
   int64_t first_picture_id;
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce([&](EncodedFrame* frame) { first_picture_id = frame->Id(); });
-        first_picture_id = frame->Id();
-      });
   inject_packet(/*wrapped_frame_id=*/0xffff);
 
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce([&](EncodedFrame* frame) {
         EXPECT_EQ(frame->Id() - first_picture_id, 3);
       });
   inject_packet(/*wrapped_frame_id=*/0x0002);
@@ -1034,9 +1018,7 @@ TEST_F(RtpVideoStreamReceiver2DependencyDescriptorTest, UnwrapsFrameId) {
   // keyframe. Thus feed a key frame first, then test reodered delta frames.
   int64_t first_picture_id;
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce([&](EncodedFrame* frame) { first_picture_id = frame->Id(); });
-        first_picture_id = frame->Id();
-      });
   InjectPacketWith(stream_structure, keyframe_descriptor);
 
   DependencyDescriptor deltaframe1_descriptor;
@@ -1050,11 +1032,11 @@ TEST_F(RtpVideoStreamReceiver2DependencyDescriptorTest, UnwrapsFrameId) {
   // Parser should unwrap frame ids correctly even if packets were reordered by
   // the network.
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce([&](EncodedFrame* frame) {
         // 0x0002 - 0xfff0
         EXPECT_EQ(frame->Id() - first_picture_id, 18);
       })
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce([&](EncodedFrame* frame) {
         // 0xfffe - 0xfff0
         EXPECT_EQ(frame->Id() - first_picture_id, 14);
       });
@@ -1120,9 +1102,8 @@ TEST_F(RtpVideoStreamReceiver2DependencyDescriptorTest,
   keyframe2_descriptor.frame_number = 3;
 
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce(
-        EXPECT_EQ(frame->Id() & 0xFFFF, 3);
+          [&](EncodedFrame* frame) { EXPECT_EQ(frame->Id() & 0xFFFF, 3); });
-      });
   InjectPacketWith(stream_structure2, keyframe2_descriptor);
   InjectPacketWith(stream_structure1, keyframe1_descriptor);
 
@@ -1132,9 +1113,8 @@ TEST_F(RtpVideoStreamReceiver2DependencyDescriptorTest,
   deltaframe_descriptor.frame_dependencies = stream_structure2.templates[0];
   deltaframe_descriptor.frame_number = 4;
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce(
-        EXPECT_EQ(frame->Id() & 0xFFFF, 4);
+          [&](EncodedFrame* frame) { EXPECT_EQ(frame->Id() & 0xFFFF, 4); });
-      });
   InjectPacketWith(stream_structure2, deltaframe_descriptor);
 }
 
@@ -1218,8 +1198,8 @@ TEST_P(RtpVideoStreamReceiver2TestPlayoutDelay, PlayoutDelay) {
   // Expect the playout delay of encoded frame to be the same as the transmitted
   // playout delay unless it was overridden by a field trial.
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
-      .WillOnce(Invoke([expected_playout_delay = GetParam().expected_delay](
+      .WillOnce(Invoke([expected_playout_delay =
-                           video_coding::EncodedFrame* frame) {
+                            GetParam().expected_delay](EncodedFrame* frame) {
         EXPECT_EQ(frame->EncodedImage().playout_delay_, expected_playout_delay);
       }));
   rtp_video_stream_receiver_->OnReceivedPayloadData(

video/rtp_video_stream_receiver_frame_transformer_delegate.cc

@@ -24,9 +24,8 @@ namespace {
 class TransformableVideoReceiverFrame
     : public TransformableVideoFrameInterface {
  public:
-  TransformableVideoReceiverFrame(
+  TransformableVideoReceiverFrame(std::unique_ptr<RtpFrameObject> frame,
-      std::unique_ptr<video_coding::RtpFrameObject> frame,
+                                  uint32_t ssrc)
-      uint32_t ssrc)
       : frame_(std::move(frame)),
         metadata_(frame_->GetRtpVideoHeader()),
         ssrc_(ssrc) {}
@@ -55,12 +54,12 @@ class TransformableVideoReceiverFrame
 
   const VideoFrameMetadata& GetMetadata() const override { return metadata_; }
 
-  std::unique_ptr<video_coding::RtpFrameObject> ExtractFrame() && {
+  std::unique_ptr<RtpFrameObject> ExtractFrame() && {
     return std::move(frame_);
   }
 
  private:
-  std::unique_ptr<video_coding::RtpFrameObject> frame_;
+  std::unique_ptr<RtpFrameObject> frame_;
   const VideoFrameMetadata metadata_;
   const uint32_t ssrc_;
 };
@@ -91,7 +90,7 @@ void RtpVideoStreamReceiverFrameTransformerDelegate::Reset() {
 }
 
 void RtpVideoStreamReceiverFrameTransformerDelegate::TransformFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame) {
+    std::unique_ptr<RtpFrameObject> frame) {
   RTC_DCHECK_RUN_ON(&network_sequence_checker_);
   frame_transformer_->Transform(
       std::make_unique<TransformableVideoReceiverFrame>(std::move(frame),

video/rtp_video_stream_receiver_frame_transformer_delegate.h

@@ -25,8 +25,7 @@ namespace webrtc {
 // thread after transformation.
 class RtpVideoFrameReceiver {
  public:
-  virtual void ManageFrame(
+  virtual void ManageFrame(std::unique_ptr<RtpFrameObject> frame) = 0;
-      std::unique_ptr<video_coding::RtpFrameObject> frame) = 0;
 
  protected:
   virtual ~RtpVideoFrameReceiver() = default;
@@ -47,7 +46,7 @@ class RtpVideoStreamReceiverFrameTransformerDelegate
   void Reset();
 
   // Delegates the call to FrameTransformerInterface::TransformFrame.
-  void TransformFrame(std::unique_ptr<video_coding::RtpFrameObject> frame);
+  void TransformFrame(std::unique_ptr<RtpFrameObject> frame);
 
   // Implements TransformedFrameCallback. Can be called on any thread. Posts
   // the transformed frame to be managed on the |network_thread_|.

video/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc

@@ -35,15 +35,15 @@ using ::testing::ElementsAre;
 using ::testing::NiceMock;
 using ::testing::SaveArg;
 
-std::unique_ptr<video_coding::RtpFrameObject> CreateRtpFrameObject(
+std::unique_ptr<RtpFrameObject> CreateRtpFrameObject(
     const RTPVideoHeader& video_header) {
-  return std::make_unique<video_coding::RtpFrameObject>(
+  return std::make_unique<RtpFrameObject>(
       0, 0, true, 0, 0, 0, 0, 0, VideoSendTiming(), 0, video_header.codec,
       kVideoRotation_0, VideoContentType::UNSPECIFIED, video_header,
       absl::nullopt, RtpPacketInfos(), EncodedImageBuffer::Create(0));
 }
 
-std::unique_ptr<video_coding::RtpFrameObject> CreateRtpFrameObject() {
+std::unique_ptr<RtpFrameObject> CreateRtpFrameObject() {
   return CreateRtpFrameObject(RTPVideoHeader());
 }
 
@@ -54,7 +54,7 @@ class TestRtpVideoFrameReceiver : public RtpVideoFrameReceiver {
 
   MOCK_METHOD(void,
               ManageFrame,
-              (std::unique_ptr<video_coding::RtpFrameObject> frame),
+              (std::unique_ptr<RtpFrameObject> frame),
               (override));
 };
 

video/rtp_video_stream_receiver_unittest.cc

@@ -50,8 +50,7 @@ namespace {
 
 const uint8_t kH264StartCode[] = {0x00, 0x00, 0x00, 0x01};
 
-std::vector<uint64_t> GetAbsoluteCaptureTimestamps(
+std::vector<uint64_t> GetAbsoluteCaptureTimestamps(const EncodedFrame* frame) {
-    const video_coding::EncodedFrame* frame) {
   std::vector<uint64_t> result;
   for (const auto& packet_info : frame->PacketInfos()) {
     if (packet_info.absolute_capture_time()) {
@@ -96,21 +95,11 @@ class MockKeyFrameRequestSender : public KeyFrameRequestSender {
 
 class MockOnCompleteFrameCallback : public OnCompleteFrameCallback {
  public:
-  MOCK_METHOD(void, DoOnCompleteFrame, (video_coding::EncodedFrame*), ());
+  MOCK_METHOD(void, DoOnCompleteFrame, (EncodedFrame*), ());
-  MOCK_METHOD(void,
+  MOCK_METHOD(void, DoOnCompleteFrameFailNullptr, (EncodedFrame*), ());
-              DoOnCompleteFrameFailNullptr,
+  MOCK_METHOD(void, DoOnCompleteFrameFailLength, (EncodedFrame*), ());
-              (video_coding::EncodedFrame*),
+  MOCK_METHOD(void, DoOnCompleteFrameFailBitstream, (EncodedFrame*), ());
-              ());
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override {
-  MOCK_METHOD(void,
-              DoOnCompleteFrameFailLength,
-              (video_coding::EncodedFrame*),
-              ());
-  MOCK_METHOD(void,
-              DoOnCompleteFrameFailBitstream,
-              (video_coding::EncodedFrame*),
-              ());
-  void OnCompleteFrame(
-      std::unique_ptr<video_coding::EncodedFrame> frame) override {
     if (!frame) {
       DoOnCompleteFrameFailNullptr(nullptr);
       return;
@@ -338,7 +327,7 @@ TEST_F(RtpVideoStreamReceiverTest, CacheColorSpaceFromLastPacketOfKeyframe) {
   EXPECT_TRUE(key_frame_packet2.GetExtension<ColorSpaceExtension>());
   rtp_video_stream_receiver_->OnRtpPacket(key_frame_packet1);
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
-      .WillOnce(Invoke([kColorSpace](video_coding::EncodedFrame* frame) {
+      .WillOnce(Invoke([kColorSpace](EncodedFrame* frame) {
         ASSERT_TRUE(frame->EncodedImage().ColorSpace());
         EXPECT_EQ(*frame->EncodedImage().ColorSpace(), kColorSpace);
       }));
@@ -354,7 +343,7 @@ TEST_F(RtpVideoStreamReceiverTest, CacheColorSpaceFromLastPacketOfKeyframe) {
   // included in the RTP packet.
   EXPECT_FALSE(delta_frame_packet.GetExtension<ColorSpaceExtension>());
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
-      .WillOnce(Invoke([kColorSpace](video_coding::EncodedFrame* frame) {
+      .WillOnce(Invoke([kColorSpace](EncodedFrame* frame) {
         ASSERT_TRUE(frame->EncodedImage().ColorSpace());
         EXPECT_EQ(*frame->EncodedImage().ColorSpace(), kColorSpace);
       }));
@@ -396,11 +385,10 @@ TEST_F(RtpVideoStreamReceiverTest, PacketInfoIsPropagatedIntoVideoFrames) {
   mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(),
                                                            data.size());
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
-      .WillOnce(Invoke(
+      .WillOnce(Invoke([kAbsoluteCaptureTimestamp](EncodedFrame* frame) {
-          [kAbsoluteCaptureTimestamp](video_coding::EncodedFrame* frame) {
+        EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame),
-            EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame),
+                    ElementsAre(kAbsoluteCaptureTimestamp));
-                        ElementsAre(kAbsoluteCaptureTimestamp));
+      }));
-          }));
   rtp_video_stream_receiver_->OnReceivedPayloadData(data, rtp_packet,
                                                     video_header);
 }
@@ -444,7 +432,7 @@ TEST_F(RtpVideoStreamReceiverTest,
   // Expect rtp video stream receiver to extrapolate it for the resulting video
   // frame using absolute capture time from the previous packet.
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
-      .WillOnce(Invoke([](video_coding::EncodedFrame* frame) {
+      .WillOnce(Invoke([](EncodedFrame* frame) {
         EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame), SizeIs(1));
       }));
   rtp_video_stream_receiver_->OnReceivedPayloadData(data, rtp_packet,
@@ -656,9 +644,8 @@ TEST_P(RtpVideoStreamReceiverTestH264, ForceSpsPpsIdrIsKeyframe) {
   mock_on_complete_frame_callback_.AppendExpectedBitstream(idr_data.data(),
                                                            idr_data.size());
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce(
-        EXPECT_TRUE(frame->is_keyframe());
+          [&](EncodedFrame* frame) { EXPECT_TRUE(frame->is_keyframe()); });
-      });
   rtp_video_stream_receiver_->OnReceivedPayloadData(idr_data, rtp_packet,
                                                     idr_video_header);
   mock_on_complete_frame_callback_.ClearExpectedBitstream();
@@ -668,9 +655,8 @@ TEST_P(RtpVideoStreamReceiverTestH264, ForceSpsPpsIdrIsKeyframe) {
                                                            idr_data.size());
   rtp_packet.SetSequenceNumber(3);
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce(
-        EXPECT_FALSE(frame->is_keyframe());
+          [&](EncodedFrame* frame) { EXPECT_FALSE(frame->is_keyframe()); });
-      });
   rtp_video_stream_receiver_->OnReceivedPayloadData(idr_data, rtp_packet,
                                                     idr_video_header);
 }
@@ -858,7 +844,7 @@ TEST_F(RtpVideoStreamReceiverTest, ParseGenericDescriptorOnePacket) {
   rtp_packet.SetSequenceNumber(1);
 
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce(Invoke([kSpatialIndex](video_coding::EncodedFrame* frame) {
+      .WillOnce(Invoke([kSpatialIndex](EncodedFrame* frame) {
         EXPECT_EQ(frame->num_references, 2U);
         EXPECT_EQ(frame->references[0], frame->Id() - 90);
         EXPECT_EQ(frame->references[1], frame->Id() - 80);
@@ -916,7 +902,7 @@ TEST_F(RtpVideoStreamReceiverTest, ParseGenericDescriptorTwoPackets) {
                                                            data.size() - 1);
 
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce(Invoke([kSpatialIndex](video_coding::EncodedFrame* frame) {
+      .WillOnce(Invoke([kSpatialIndex](EncodedFrame* frame) {
         EXPECT_EQ(frame->num_references, 0U);
         EXPECT_EQ(frame->SpatialIndex(), kSpatialIndex);
         EXPECT_EQ(frame->EncodedImage()._encodedWidth, 480u);
@@ -995,13 +981,11 @@ TEST_F(RtpVideoStreamReceiverTest, UnwrapsFrameId) {
 
   int64_t first_picture_id;
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce([&](EncodedFrame* frame) { first_picture_id = frame->Id(); });
-        first_picture_id = frame->Id();
-      });
   inject_packet(/*wrapped_frame_id=*/0xffff);
 
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce([&](EncodedFrame* frame) {
         EXPECT_EQ(frame->Id() - first_picture_id, 3);
       });
   inject_packet(/*wrapped_frame_id=*/0x0002);
@@ -1066,9 +1050,7 @@ TEST_F(RtpVideoStreamReceiverDependencyDescriptorTest, UnwrapsFrameId) {
   // keyframe. Thus feed a key frame first, then test reodered delta frames.
   int64_t first_picture_id;
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce([&](EncodedFrame* frame) { first_picture_id = frame->Id(); });
-        first_picture_id = frame->Id();
-      });
   InjectPacketWith(stream_structure, keyframe_descriptor);
 
   DependencyDescriptor deltaframe1_descriptor;
@@ -1082,11 +1064,11 @@ TEST_F(RtpVideoStreamReceiverDependencyDescriptorTest, UnwrapsFrameId) {
   // Parser should unwrap frame ids correctly even if packets were reordered by
   // the network.
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce([&](EncodedFrame* frame) {
         // 0x0002 - 0xfff0
         EXPECT_EQ(frame->Id() - first_picture_id, 18);
       })
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce([&](EncodedFrame* frame) {
         // 0xfffe - 0xfff0
         EXPECT_EQ(frame->Id() - first_picture_id, 14);
       });
@@ -1152,9 +1134,8 @@ TEST_F(RtpVideoStreamReceiverDependencyDescriptorTest,
   keyframe2_descriptor.frame_number = 3;
 
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce(
-        EXPECT_EQ(frame->Id() & 0xFFFF, 3);
+          [&](EncodedFrame* frame) { EXPECT_EQ(frame->Id() & 0xFFFF, 3); });
-      });
   InjectPacketWith(stream_structure2, keyframe2_descriptor);
   InjectPacketWith(stream_structure1, keyframe1_descriptor);
 
@@ -1164,9 +1145,8 @@ TEST_F(RtpVideoStreamReceiverDependencyDescriptorTest,
   deltaframe_descriptor.frame_dependencies = stream_structure2.templates[0];
   deltaframe_descriptor.frame_number = 4;
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
+      .WillOnce(
-        EXPECT_EQ(frame->Id() & 0xFFFF, 4);
+          [&](EncodedFrame* frame) { EXPECT_EQ(frame->Id() & 0xFFFF, 4); });
-      });
   InjectPacketWith(stream_structure2, deltaframe_descriptor);
 }
 
@@ -1264,8 +1244,8 @@ TEST_P(RtpVideoStreamReceiverTestPlayoutDelay, PlayoutDelay) {
   // Expect the playout delay of encoded frame to be the same as the transmitted
   // playout delay unless it was overridden by a field trial.
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
-      .WillOnce(Invoke([expected_playout_delay = GetParam().expected_delay](
+      .WillOnce(Invoke([expected_playout_delay =
-                           video_coding::EncodedFrame* frame) {
+                            GetParam().expected_delay](EncodedFrame* frame) {
         EXPECT_EQ(frame->EncodedImage().playout_delay_, expected_playout_delay);
       }));
   rtp_video_stream_receiver_->OnReceivedPayloadData(

video/video_receive_stream.cc

@@ -60,7 +60,6 @@ constexpr int VideoReceiveStream::kMaxWaitForKeyFrameMs;
 
 namespace {
 
-using video_coding::EncodedFrame;
 using ReturnReason = video_coding::FrameBuffer::ReturnReason;
 
 constexpr int kMinBaseMinimumDelayMs = 0;
@@ -69,7 +68,7 @@ constexpr int kMaxBaseMinimumDelayMs = 10000;
 constexpr int kMaxWaitForFrameMs = 3000;
 
 // Concrete instance of RecordableEncodedFrame wrapping needed content
-// from video_coding::EncodedFrame.
+// from EncodedFrame.
 class WebRtcRecordableEncodedFrame : public RecordableEncodedFrame {
  public:
   explicit WebRtcRecordableEncodedFrame(const EncodedFrame& frame)
@@ -554,8 +553,7 @@ void VideoReceiveStream::RequestKeyFrame(int64_t timestamp_ms) {
   last_keyframe_request_ms_ = timestamp_ms;
 }
 
-void VideoReceiveStream::OnCompleteFrame(
+void VideoReceiveStream::OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) {
-    std::unique_ptr<video_coding::EncodedFrame> frame) {
   RTC_DCHECK_RUN_ON(&network_sequence_checker_);
   // TODO(https://bugs.webrtc.org/9974): Consider removing this workaround.
   int64_t time_now_ms = clock_->TimeInMilliseconds();

video/video_receive_stream.h

@@ -112,8 +112,7 @@ class VideoReceiveStream : public webrtc::DEPRECATED_VideoReceiveStream,
                 bool buffering_allowed) override;
 
   // Implements OnCompleteFrameCallback.
-  void OnCompleteFrame(
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override;
-      std::unique_ptr<video_coding::EncodedFrame> frame) override;
 
   // Implements CallStatsObserver::OnRttUpdate
   void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
@@ -138,7 +137,7 @@ class VideoReceiveStream : public webrtc::DEPRECATED_VideoReceiveStream,
  private:
   int64_t GetWaitMs() const;
   void StartNextDecode() RTC_RUN_ON(decode_queue_);
-  void HandleEncodedFrame(std::unique_ptr<video_coding::EncodedFrame> frame)
+  void HandleEncodedFrame(std::unique_ptr<EncodedFrame> frame)
       RTC_RUN_ON(decode_queue_);
   void HandleFrameBufferTimeout() RTC_RUN_ON(decode_queue_);
   void UpdatePlayoutDelays() const

video/video_receive_stream2.cc

@@ -58,7 +58,6 @@ constexpr int VideoReceiveStream2::kMaxWaitForKeyFrameMs;
 
 namespace {
 
-using video_coding::EncodedFrame;
 using ReturnReason = video_coding::FrameBuffer::ReturnReason;
 
 constexpr int kMinBaseMinimumDelayMs = 0;
@@ -69,7 +68,7 @@ constexpr int kMaxWaitForFrameMs = 3000;
 constexpr int kDefaultMaximumPreStreamDecoders = 100;
 
 // Concrete instance of RecordableEncodedFrame wrapping needed content
-// from video_coding::EncodedFrame.
+// from EncodedFrame.
 class WebRtcRecordableEncodedFrame : public RecordableEncodedFrame {
  public:
   explicit WebRtcRecordableEncodedFrame(const EncodedFrame& frame)
@@ -557,8 +556,7 @@ void VideoReceiveStream2::RequestKeyFrame(int64_t timestamp_ms) {
   });
 }
 
-void VideoReceiveStream2::OnCompleteFrame(
+void VideoReceiveStream2::OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) {
-    std::unique_ptr<video_coding::EncodedFrame> frame) {
   RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
 
   // TODO(https://bugs.webrtc.org/9974): Consider removing this workaround.

video/video_receive_stream2.h

@@ -131,8 +131,7 @@ class VideoReceiveStream2 : public webrtc::VideoReceiveStream,
                 bool buffering_allowed) override;
 
   // Implements OnCompleteFrameCallback.
-  void OnCompleteFrame(
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override;
-      std::unique_ptr<video_coding::EncodedFrame> frame) override;
 
   // Implements CallStatsObserver::OnRttUpdate
   void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
@@ -158,7 +157,7 @@ class VideoReceiveStream2 : public webrtc::VideoReceiveStream,
   void CreateAndRegisterExternalDecoder(const Decoder& decoder);
   int64_t GetMaxWaitMs() const RTC_RUN_ON(decode_queue_);
   void StartNextDecode() RTC_RUN_ON(decode_queue_);
-  void HandleEncodedFrame(std::unique_ptr<video_coding::EncodedFrame> frame)
+  void HandleEncodedFrame(std::unique_ptr<EncodedFrame> frame)
       RTC_RUN_ON(decode_queue_);
   void HandleFrameBufferTimeout(int64_t now_ms, int64_t wait_ms)
       RTC_RUN_ON(worker_sequence_checker_);

video/video_receive_stream2_unittest.cc

@@ -84,7 +84,7 @@ class MockVideoDecoderFactory : public VideoDecoderFactory {
                std::unique_ptr<VideoDecoder>(const SdpVideoFormat& format));
 };
 
-class FrameObjectFake : public video_coding::EncodedFrame {
+class FrameObjectFake : public EncodedFrame {
  public:
   void SetPayloadType(uint8_t payload_type) { _payloadType = payload_type; }
 
@@ -543,8 +543,7 @@ class VideoReceiveStream2TestWithSimulatedClock : public ::testing::Test {
 
   void OnFrameDecoded() { event_->Set(); }
 
-  void PassEncodedFrameAndWait(
+  void PassEncodedFrameAndWait(std::unique_ptr<EncodedFrame> frame) {
-      std::unique_ptr<video_coding::EncodedFrame> frame) {
     event_ = std::make_unique<rtc::Event>();
     // This call will eventually end up in the Decoded method where the
     // event is set.

video/video_receive_stream_unittest.cc

@@ -76,7 +76,7 @@ class MockVideoDecoder : public VideoDecoder {
   const char* ImplementationName() const { return "MockVideoDecoder"; }
 };
 
-class FrameObjectFake : public video_coding::EncodedFrame {
+class FrameObjectFake : public EncodedFrame {
  public:
   void SetPayloadType(uint8_t payload_type) { _payloadType = payload_type; }
 
@@ -496,13 +496,12 @@ class VideoReceiveStreamTestWithSimulatedClock : public ::testing::Test {
 
   void OnFrameDecoded() { event_->Set(); }
 
-  void PassEncodedFrameAndWait(
+  void PassEncodedFrameAndWait(std::unique_ptr<EncodedFrame> frame) {
-      std::unique_ptr<video_coding::EncodedFrame> frame) {
+    event_ = std::make_unique<rtc::Event>();
-      event_ = std::make_unique<rtc::Event>();
+    // This call will eventually end up in the Decoded method where the
-      // This call will eventually end up in the Decoded method where the
+    // event is set.
-      // event is set.
+    video_receive_stream_.OnCompleteFrame(std::move(frame));
-      video_receive_stream_.OnCompleteFrame(std::move(frame));
+    event_->Wait(rtc::Event::kForever);
-      event_->Wait(rtc::Event::kForever);
   }
 
  protected:

video/video_stream_decoder_impl.cc

@@ -50,8 +50,7 @@ VideoStreamDecoderImpl::~VideoStreamDecoderImpl() {
   shut_down_ = true;
 }
 
-void VideoStreamDecoderImpl::OnFrame(
+void VideoStreamDecoderImpl::OnFrame(std::unique_ptr<EncodedFrame> frame) {
-    std::unique_ptr<video_coding::EncodedFrame> frame) {
   if (!bookkeeping_queue_.IsCurrent()) {
     bookkeeping_queue_.PostTask([this, frame = std::move(frame)]() mutable {
       OnFrame(std::move(frame));
@@ -123,8 +122,7 @@ VideoDecoder* VideoStreamDecoderImpl::GetDecoder(int payload_type) {
   return decoder_.get();
 }
 
-void VideoStreamDecoderImpl::SaveFrameInfo(
+void VideoStreamDecoderImpl::SaveFrameInfo(const EncodedFrame& frame) {
-    const video_coding::EncodedFrame& frame) {
   FrameInfo* frame_info = &frame_info_[next_frame_info_index_];
   frame_info->timestamp = frame.Timestamp();
   frame_info->decode_start_time_ms = rtc::TimeMillis();
@@ -139,7 +137,7 @@ void VideoStreamDecoderImpl::StartNextDecode() {
 
   frame_buffer_.NextFrame(
       max_wait_time, keyframe_required_, &bookkeeping_queue_,
-      [this](std::unique_ptr<video_coding::EncodedFrame> frame,
+      [this](std::unique_ptr<EncodedFrame> frame,
              video_coding::FrameBuffer::ReturnReason res) mutable {
         RTC_DCHECK_RUN_ON(&bookkeeping_queue_);
         OnNextFrameCallback(std::move(frame), res);
@@ -147,7 +145,7 @@ void VideoStreamDecoderImpl::StartNextDecode() {
 }
 
 void VideoStreamDecoderImpl::OnNextFrameCallback(
-    std::unique_ptr<video_coding::EncodedFrame> frame,
+    std::unique_ptr<EncodedFrame> frame,
     video_coding::FrameBuffer::ReturnReason result) {
   switch (result) {
     case video_coding::FrameBuffer::kFrameFound: {
@@ -204,7 +202,7 @@ void VideoStreamDecoderImpl::OnNextFrameCallback(
 }
 
 VideoStreamDecoderImpl::DecodeResult VideoStreamDecoderImpl::DecodeFrame(
-    std::unique_ptr<video_coding::EncodedFrame> frame) {
+    std::unique_ptr<EncodedFrame> frame) {
   RTC_DCHECK(frame);
 
   VideoDecoder* decoder = GetDecoder(frame->PayloadType());

video/video_stream_decoder_impl.h

@@ -37,7 +37,7 @@ class VideoStreamDecoderImpl : public VideoStreamDecoderInterface {
 
   ~VideoStreamDecoderImpl() override;
 
-  void OnFrame(std::unique_ptr<video_coding::EncodedFrame> frame) override;
+  void OnFrame(std::unique_ptr<EncodedFrame> frame) override;
 
   void SetMinPlayoutDelay(TimeDelta min_delay) override;
   void SetMaxPlayoutDelay(TimeDelta max_delay) override;
@@ -69,11 +69,10 @@ class VideoStreamDecoderImpl : public VideoStreamDecoderInterface {
     VideoContentType content_type;
   };
 
-  void SaveFrameInfo(const video_coding::EncodedFrame& frame)
+  void SaveFrameInfo(const EncodedFrame& frame) RTC_RUN_ON(bookkeeping_queue_);
-      RTC_RUN_ON(bookkeeping_queue_);
   FrameInfo* GetFrameInfo(int64_t timestamp) RTC_RUN_ON(bookkeeping_queue_);
   void StartNextDecode() RTC_RUN_ON(bookkeeping_queue_);
-  void OnNextFrameCallback(std::unique_ptr<video_coding::EncodedFrame> frame,
+  void OnNextFrameCallback(std::unique_ptr<EncodedFrame> frame,
                            video_coding::FrameBuffer::ReturnReason res)
       RTC_RUN_ON(bookkeeping_queue_);
   void OnDecodedFrameCallback(VideoFrame& decodedImage,  // NOLINT
@@ -82,8 +81,7 @@ class VideoStreamDecoderImpl : public VideoStreamDecoderInterface {
 
   VideoDecoder* GetDecoder(int payload_type) RTC_RUN_ON(decode_queue_);
   VideoStreamDecoderImpl::DecodeResult DecodeFrame(
-      std::unique_ptr<video_coding::EncodedFrame> frame)
+      std::unique_ptr<EncodedFrame> frame) RTC_RUN_ON(decode_queue_);
-      RTC_RUN_ON(decode_queue_);
 
   VCMTiming timing_;
   DecodeCallbacks decode_callbacks_;

video/video_stream_decoder_impl_unittest.cc

@@ -127,7 +127,7 @@ class FakeVideoDecoderFactory : public VideoDecoderFactory {
   NiceMock<StubVideoDecoder> av1_decoder_;
 };
 
-class FakeEncodedFrame : public video_coding::EncodedFrame {
+class FakeEncodedFrame : public EncodedFrame {
  public:
   int64_t ReceivedTime() const override { return 0; }
   int64_t RenderTime() const override { return 0; }