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}

diff --git a/api/video/encoded_frame.cc b/api/video/encoded_frame.cc
index 26a794e..42d6b06 100644
--- a/api/video/encoded_frame.cc
+++ b/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

diff --git a/api/video/encoded_frame.h b/api/video/encoded_frame.h
index 44a1430..d88d711 100644
--- a/api/video/encoded_frame.h
+++ b/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 @@
   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_

diff --git a/api/video/video_stream_decoder.h b/api/video/video_stream_decoder.h
index a1f4406..8d71dd3 100644
--- a/api/video/video_stream_decoder.h
+++ b/api/video/video_stream_decoder.h

@@ -46,7 +46,7 @@
 
   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;

diff --git a/modules/video_coding/frame_buffer2_unittest.cc b/modules/video_coding/frame_buffer2_unittest.cc
index e179dad..68acf81 100644
--- a/modules/video_coding/frame_buffer2_unittest.cc
+++ b/modules/video_coding/frame_buffer2_unittest.cc

@@ -199,7 +199,7 @@
     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));

diff --git a/modules/video_coding/frame_object.cc b/modules/video_coding/frame_object.cc
index 25fd232..8d011b9 100644
--- a/modules/video_coding/frame_object.cc
+++ b/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 @@
   return rtp_video_header_;
 }
 
-}  // namespace video_coding
 }  // namespace webrtc

diff --git a/modules/video_coding/frame_object.h b/modules/video_coding/frame_object.h
index d812b8f..3b0d94a 100644
--- a/modules/video_coding/frame_object.h
+++ b/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 @@
   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_

diff --git a/modules/video_coding/rtp_frame_id_only_ref_finder.cc b/modules/video_coding/rtp_frame_id_only_ref_finder.cc
index 8846e68..9f3d5bb 100644
--- a/modules/video_coding/rtp_frame_id_only_ref_finder.cc
+++ b/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)));

diff --git a/modules/video_coding/rtp_frame_id_only_ref_finder.h b/modules/video_coding/rtp_frame_id_only_ref_finder.h
index 4dc8250..1df4870 100644
--- a/modules/video_coding/rtp_frame_id_only_ref_finder.h
+++ b/modules/video_coding/rtp_frame_id_only_ref_finder.h

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

diff --git a/modules/video_coding/rtp_frame_reference_finder.cc b/modules/video_coding/rtp_frame_reference_finder.cc
index 4d24546..a060f84 100644
--- a/modules/video_coding/rtp_frame_reference_finder.cc
+++ b/modules/video_coding/rtp_frame_reference_finder.cc

@@ -27,7 +27,7 @@
   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 @@
 };
 
 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() = 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())) {

diff --git a/modules/video_coding/rtp_frame_reference_finder.h b/modules/video_coding/rtp_frame_reference_finder.h
index d3b0cc5..4667522 100644
--- a/modules/video_coding/rtp_frame_reference_finder.h
+++ b/modules/video_coding/rtp_frame_reference_finder.h

@@ -25,8 +25,7 @@
 class OnCompleteFrameCallback {
  public:
   virtual ~OnCompleteFrameCallback() {}
-  virtual void OnCompleteFrame(
-      std::unique_ptr<video_coding::EncodedFrame> frame) = 0;
+  virtual void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) = 0;
 };
 
 // TODO(bugs.webrtc.org/12579): Remove when downstream has been update.
@@ -36,8 +35,7 @@
 
 class RtpFrameReferenceFinder {
  public:
-  using ReturnVector =
-      absl::InlinedVector<std::unique_ptr<video_coding::RtpFrameObject>, 3>;
+  using ReturnVector = absl::InlinedVector<std::unique_ptr<RtpFrameObject>, 3>;
 
   explicit RtpFrameReferenceFinder(OnCompleteFrameCallback* frame_callback);
   explicit RtpFrameReferenceFinder(OnCompleteFrameCallback* frame_callback,
@@ -50,7 +48,7 @@
   //  - 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.

diff --git a/modules/video_coding/rtp_frame_reference_finder_unittest.cc b/modules/video_coding/rtp_frame_reference_finder_unittest.cc
index de8c1ae..5141b49 100644
--- a/modules/video_coding/rtp_frame_reference_finder_unittest.cc
+++ b/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 @@
   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 @@
 
   uint16_t Rand() { return rand_.Rand<uint16_t>(); }
 
-  void OnCompleteFrame(
-      std::unique_ptr<video_coding::EncodedFrame> frame) override {
+  void OnCompleteFrame(std::unique_ptr<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 @@
   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 @@
   }
 
   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 @@
       return f1.first < f2.first;
     }
   };
-  std::map<std::pair<int64_t, uint8_t>,
-           std::unique_ptr<video_coding::EncodedFrame>,
-           FrameComp>
-      frames_from_callback_;
+  std::
+      map<std::pair<int64_t, uint8_t>, std::unique_ptr<EncodedFrame>, FrameComp>
+          frames_from_callback_;
 };
 
 TEST_F(TestRtpFrameReferenceFinder, PaddingPackets) {
@@ -307,7 +304,7 @@
 
 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 @@
   CheckReferencesGeneric(sn);
 }
 
-}  // namespace video_coding
 }  // namespace webrtc

diff --git a/modules/video_coding/rtp_generic_ref_finder.cc b/modules/video_coding/rtp_generic_ref_finder.cc
index 3a2a94e..87fff9c 100644
--- a/modules/video_coding/rtp_generic_ref_finder.cc
+++ b/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 @@
   frame->SetSpatialIndex(descriptor.spatial_index);
 
   RtpFrameReferenceFinder::ReturnVector res;
-  if (video_coding::EncodedFrame::kMaxFrameReferences <
-      descriptor.dependencies.size()) {
+  if (EncodedFrame::kMaxFrameReferences < descriptor.dependencies.size()) {
     RTC_LOG(LS_WARNING) << "Too many dependencies in generic descriptor.";
     return res;
   }

diff --git a/modules/video_coding/rtp_generic_ref_finder.h b/modules/video_coding/rtp_generic_ref_finder.h
index 5f8462a..87d7b59 100644
--- a/modules/video_coding/rtp_generic_ref_finder.h
+++ b/modules/video_coding/rtp_generic_ref_finder.h

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

diff --git a/modules/video_coding/rtp_seq_num_only_ref_finder.cc b/modules/video_coding/rtp_seq_num_only_ref_finder.cc
index 3202313..4381cf0 100644
--- a/modules/video_coding/rtp_seq_num_only_ref_finder.cc
+++ b/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 @@
 }
 
 RtpSeqNumOnlyRefFinder::FrameDecision
-RtpSeqNumOnlyRefFinder::ManageFrameInternal(
-    video_coding::RtpFrameObject* frame) {
+RtpSeqNumOnlyRefFinder::ManageFrameInternal(RtpFrameObject* frame) {
   if (frame->frame_type() == VideoFrameType::kVideoFrameKey) {
     last_seq_num_gop_.insert(std::make_pair(
         frame->last_seq_num(),

diff --git a/modules/video_coding/rtp_seq_num_only_ref_finder.h b/modules/video_coding/rtp_seq_num_only_ref_finder.h
index e6cf0f6..ef3c022 100644
--- a/modules/video_coding/rtp_seq_num_only_ref_finder.h
+++ b/modules/video_coding/rtp_seq_num_only_ref_finder.h

@@ -29,7 +29,7 @@
   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 @@
 
   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 @@
 
   // 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.

diff --git a/modules/video_coding/rtp_vp8_ref_finder.cc b/modules/video_coding/rtp_vp8_ref_finder.cc
index 0074558..b448b23 100644
--- a/modules/video_coding/rtp_vp8_ref_finder.cc
+++ b/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 @@
 }
 
 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 @@
   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 @@
   } 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()));

diff --git a/modules/video_coding/rtp_vp8_ref_finder.h b/modules/video_coding/rtp_vp8_ref_finder.h
index 4ac4d10..0a6cd7e 100644
--- a/modules/video_coding/rtp_vp8_ref_finder.h
+++ b/modules/video_coding/rtp_vp8_ref_finder.h

@@ -28,7 +28,7 @@
   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 @@
 
   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 @@
 
   // 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.

diff --git a/modules/video_coding/rtp_vp8_ref_finder_unittest.cc b/modules/video_coding/rtp_vp8_ref_finder_unittest.cc
index 34836e6..a77149a 100644
--- a/modules/video_coding/rtp_vp8_ref_finder_unittest.cc
+++ b/modules/video_coding/rtp_vp8_ref_finder_unittest.cc

@@ -25,7 +25,6 @@
 using ::testing::UnorderedElementsAreArray;
 
 namespace webrtc {
-namespace video_coding {
 namespace {
 
 MATCHER_P2(HasIdAndRefs, id, refs, "") {
@@ -34,7 +33,7 @@
              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 @@
     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 @@
                                            : 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 @@
  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 @@
   EXPECT_THAT(frames_, HasFrameWithIdAndRefs(8, {5, 6, 7}));
 }
 
-}  // namespace video_coding
 }  // namespace webrtc

diff --git a/modules/video_coding/rtp_vp9_ref_finder.cc b/modules/video_coding/rtp_vp9_ref_finder.cc
index 46a0946..b44bb25 100644
--- a/modules/video_coding/rtp_vp9_ref_finder.cc
+++ b/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 @@
 }
 
 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 @@
     last_picture_id_ = frame->Id();
 
   if (codec_header.flexible_mode) {
-    if (codec_header.num_ref_pics >
-        video_coding::EncodedFrame::kMaxFrameReferences) {
+    if (codec_header.num_ref_pics > EncodedFrame::kMaxFrameReferences) {
       return kDrop;
     }
     frame->num_references = codec_header.num_ref_pics;
@@ -179,8 +178,7 @@
       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] >
-      video_coding::EncodedFrame::kMaxFrameReferences) {
+  if (info->gof->num_ref_pics[gof_idx] > EncodedFrame::kMaxFrameReferences) {
     return kDrop;
   }
   // Populate references according to the scalability structure.
@@ -324,7 +322,7 @@
   } 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 @@
                *frame->SpatialIndex());
 
   if (inter_layer_predicted &&
-      frame->num_references + 1 <=
-          video_coding::EncodedFrame::kMaxFrameReferences) {
+      frame->num_references + 1 <= EncodedFrame::kMaxFrameReferences) {
     frame->references[frame->num_references] = frame->Id() - 1;
     ++frame->num_references;
   }

diff --git a/modules/video_coding/rtp_vp9_ref_finder.h b/modules/video_coding/rtp_vp9_ref_finder.h
index 0179918..81008fea 100644
--- a/modules/video_coding/rtp_vp9_ref_finder.h
+++ b/modules/video_coding/rtp_vp9_ref_finder.h

@@ -28,7 +28,7 @@
   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 @@
     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 @@
                              uint8_t temporal_idx,
                              uint16_t pid_ref);
 
-  void FlattenFrameIdAndRefs(video_coding::RtpFrameObject* frame,
-                             bool inter_layer_predicted);
+  void FlattenFrameIdAndRefs(RtpFrameObject* frame, 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 @@
 
   // 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.

diff --git a/modules/video_coding/rtp_vp9_ref_finder_unittest.cc b/modules/video_coding/rtp_vp9_ref_finder_unittest.cc
index 7b2d02a..6de7ce1 100644
--- a/modules/video_coding/rtp_vp9_ref_finder_unittest.cc
+++ b/modules/video_coding/rtp_vp9_ref_finder_unittest.cc

@@ -26,7 +26,6 @@
 using ::testing::UnorderedElementsAreArray;
 
 namespace webrtc {
-namespace video_coding {
 
 namespace {
 class Frame {
@@ -83,7 +82,7 @@
     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 @@
                                        : 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 @@
  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 @@
               Contains(Pointee(Property(&EncodedFrame::SpatialIndex, 2))));
 }
 
-}  // namespace video_coding
 }  // namespace webrtc

diff --git a/test/fuzzers/frame_buffer2_fuzzer.cc b/test/fuzzers/frame_buffer2_fuzzer.cc
index bd85983..0572675 100644
--- a/test/fuzzers/frame_buffer2_fuzzer.cc
+++ b/test/fuzzers/frame_buffer2_fuzzer.cc

@@ -49,7 +49,7 @@
   size_t offset_ = 0;
 };
 
-class FuzzyFrameObject : public video_coding::EncodedFrame {
+class FuzzyFrameObject : public EncodedFrame {
  public:
   FuzzyFrameObject() {}
   ~FuzzyFrameObject() {}
@@ -80,8 +80,8 @@
       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>() %
-                              video_coding::EncodedFrame::kMaxFrameReferences;
+      frame->num_references =
+          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 @@
           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;
               });

diff --git a/test/fuzzers/rtp_frame_reference_finder_fuzzer.cc b/test/fuzzers/rtp_frame_reference_finder_fuzzer.cc
index c158cd0..aeeb5c0 100644
--- a/test/fuzzers/rtp_frame_reference_finder_fuzzer.cc
+++ b/test/fuzzers/rtp_frame_reference_finder_fuzzer.cc

@@ -59,8 +59,7 @@
 };
 
 class NullCallback : public OnCompleteFrameCallback {
-  void OnCompleteFrame(
-      std::unique_ptr<video_coding::EncodedFrame> frame) override {}
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override {}
 };
 
 absl::optional<RTPVideoHeader::GenericDescriptorInfo>
@@ -135,7 +134,7 @@
     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,

diff --git a/video/buffered_frame_decryptor.cc b/video/buffered_frame_decryptor.cc
index 187bac6..436fff8 100644
--- a/video/buffered_frame_decryptor.cc
+++ b/video/buffered_frame_decryptor.cc

@@ -36,7 +36,7 @@
 }
 
 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 @@
 }
 
 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 "

diff --git a/video/buffered_frame_decryptor.h b/video/buffered_frame_decryptor.h
index ff04837..f6dd8d8 100644
--- a/video/buffered_frame_decryptor.h
+++ b/video/buffered_frame_decryptor.h

@@ -27,8 +27,7 @@
  public:
   virtual ~OnDecryptedFrameCallback() = default;
   // Called each time a decrypted frame is returned.
-  virtual void OnDecryptedFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame) = 0;
+  virtual void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) = 0;
 };
 
 // This callback is called each time there is a status change in the decryption
@@ -72,8 +71,7 @@
 
   // Determines whether the frame should be stashed, dropped or handed off to
   // the OnDecryptedFrameCallback.
-  void ManageEncryptedFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> encrypted_frame);
+  void ManageEncryptedFrame(std::unique_ptr<RtpFrameObject> encrypted_frame);
 
  private:
   // Represents what should be done with a given frame.
@@ -82,7 +80,7 @@
   // 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 @@
   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

diff --git a/video/buffered_frame_decryptor_unittest.cc b/video/buffered_frame_decryptor_unittest.cc
index bbc08b0..5ede4fe 100644
--- a/video/buffered_frame_decryptor_unittest.cc
+++ b/video/buffered_frame_decryptor_unittest.cc

@@ -43,8 +43,7 @@
                                    public OnDecryptionStatusChangeCallback {
  public:
   // Implements the OnDecryptedFrameCallbackInterface
-  void OnDecryptedFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame) override {
+  void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) override {
     decrypted_frame_call_count_++;
   }
 
@@ -54,14 +53,13 @@
 
   // Returns a new fake RtpFrameObject it abstracts the difficult construction
   // of the RtpFrameObject to simplify testing.
-  std::unique_ptr<video_coding::RtpFrameObject> CreateRtpFrameObject(
-      bool key_frame) {
+  std::unique_ptr<RtpFrameObject> CreateRtpFrameObject(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,

diff --git a/video/rtp_video_stream_receiver.cc b/video/rtp_video_stream_receiver.cc
index a2e6273..12ac57a 100644
--- a/video/rtp_video_stream_receiver.cc
+++ b/video/rtp_video_stream_receiver.cc

@@ -794,7 +794,7 @@
       }
 
       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::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::OnCompleteFrame(
-    std::unique_ptr<video_coding::EncodedFrame> frame) {
+    std::unique_ptr<EncodedFrame> frame) {
   {
     MutexLock lock(&last_seq_num_mutex_);
-    video_coding::RtpFrameObject* rtp_frame =
-        static_cast<video_coding::RtpFrameObject*>(frame.get());
+    RtpFrameObject* rtp_frame = static_cast<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::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::ManageFrame(
-    std::unique_ptr<video_coding::RtpFrameObject> frame) {
+    std::unique_ptr<RtpFrameObject> frame) {
   MutexLock lock(&reference_finder_lock_);
   reference_finder_->ManageFrame(std::move(frame));
 }

diff --git a/video/rtp_video_stream_receiver.h b/video/rtp_video_stream_receiver.h
index c480cb2..cc3499a 100644
--- a/video/rtp_video_stream_receiver.h
+++ b/video/rtp_video_stream_receiver.h

@@ -172,12 +172,10 @@
   void RequestPacketRetransmit(const std::vector<uint16_t>& sequence_numbers);
 
   // Implements OnCompleteFrameCallback.
-  void OnCompleteFrame(
-      std::unique_ptr<video_coding::EncodedFrame> frame) override;
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override;
 
   // Implements OnDecryptedFrameCallback.
-  void OnDecryptedFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame) override;
+  void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) override;
 
   // Implements OnDecryptionStatusChangeCallback.
   void OnDecryptionStatusChange(
@@ -208,8 +206,7 @@
 
  private:
   // Implements RtpVideoFrameReceiver.
-  void ManageFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame) override;
+  void ManageFrame(std::unique_ptr<RtpFrameObject> frame) override;
 
   // Used for buffering RTCP feedback messages and sending them all together.
   // Note:
@@ -305,7 +302,7 @@
   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|.

diff --git a/video/rtp_video_stream_receiver2.cc b/video/rtp_video_stream_receiver2.cc
index 8ea1bc7..f02dccd 100644
--- a/video/rtp_video_stream_receiver2.cc
+++ b/video/rtp_video_stream_receiver2.cc

@@ -764,7 +764,7 @@
       }
 
       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::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::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 =
-      static_cast<video_coding::RtpFrameObject*>(frame.get());
+  RtpFrameObject* rtp_frame = static_cast<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::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 @@
 }
 
 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));
 }

diff --git a/video/rtp_video_stream_receiver2.h b/video/rtp_video_stream_receiver2.h
index 1215003..d1319d9 100644
--- a/video/rtp_video_stream_receiver2.h
+++ b/video/rtp_video_stream_receiver2.h

@@ -148,12 +148,10 @@
   void RequestPacketRetransmit(const std::vector<uint16_t>& sequence_numbers);
 
   // Implements OnCompleteFrameCallback.
-  void OnCompleteFrame(
-      std::unique_ptr<video_coding::EncodedFrame> frame) override;
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override;
 
   // Implements OnDecryptedFrameCallback.
-  void OnDecryptedFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame) override;
+  void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) override;
 
   // Implements OnDecryptionStatusChangeCallback.
   void OnDecryptionStatusChange(
@@ -177,8 +175,7 @@
 
  private:
   // Implements RtpVideoFrameReceiver.
-  void ManageFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame) override;
+  void ManageFrame(std::unique_ptr<RtpFrameObject> frame) override;
 
   // Used for buffering RTCP feedback messages and sending them all together.
   // Note:
@@ -262,7 +259,7 @@
   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|.

diff --git a/video/rtp_video_stream_receiver2_unittest.cc b/video/rtp_video_stream_receiver2_unittest.cc
index ae5b508..41e9ed8 100644
--- a/video/rtp_video_stream_receiver2_unittest.cc
+++ b/video/rtp_video_stream_receiver2_unittest.cc

@@ -51,8 +51,7 @@
 
 const uint8_t kH264StartCode[] = {0x00, 0x00, 0x00, 0x01};
 
-std::vector<uint64_t> GetAbsoluteCaptureTimestamps(
-    const video_coding::EncodedFrame* frame) {
+std::vector<uint64_t> GetAbsoluteCaptureTimestamps(const 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 MockOnCompleteFrameCallback : public OnCompleteFrameCallback {
  public:
-  MOCK_METHOD(void, DoOnCompleteFrame, (video_coding::EncodedFrame*), ());
-  MOCK_METHOD(void,
-              DoOnCompleteFrameFailNullptr,
-              (video_coding::EncodedFrame*),
-              ());
-  MOCK_METHOD(void,
-              DoOnCompleteFrameFailLength,
-              (video_coding::EncodedFrame*),
-              ());
-  MOCK_METHOD(void,
-              DoOnCompleteFrameFailBitstream,
-              (video_coding::EncodedFrame*),
-              ());
-  void OnCompleteFrame(
-      std::unique_ptr<video_coding::EncodedFrame> frame) override {
+  MOCK_METHOD(void, DoOnCompleteFrame, (EncodedFrame*), ());
+  MOCK_METHOD(void, DoOnCompleteFrameFailNullptr, (EncodedFrame*), ());
+  MOCK_METHOD(void, DoOnCompleteFrameFailLength, (EncodedFrame*), ());
+  MOCK_METHOD(void, DoOnCompleteFrameFailBitstream, (EncodedFrame*), ());
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override {
     if (!frame) {
       DoOnCompleteFrameFailNullptr(nullptr);
       return;
@@ -351,7 +340,7 @@
   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 @@
   // 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 @@
   mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(),
                                                            data.size());
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
-      .WillOnce(Invoke(
-          [kAbsoluteCaptureTimestamp](video_coding::EncodedFrame* frame) {
-            EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame),
-                        ElementsAre(kAbsoluteCaptureTimestamp));
-          }));
+      .WillOnce(Invoke([kAbsoluteCaptureTimestamp](EncodedFrame* frame) {
+        EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame),
+                    ElementsAre(kAbsoluteCaptureTimestamp));
+      }));
   rtp_video_stream_receiver_->OnReceivedPayloadData(data, rtp_packet,
                                                     video_header);
 }
@@ -457,7 +445,7 @@
   // 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 @@
   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) {
-        EXPECT_TRUE(frame->is_keyframe());
-      });
+      .WillOnce(
+          [&](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 @@
                                                            idr_data.size());
   rtp_packet.SetSequenceNumber(3);
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
-        EXPECT_FALSE(frame->is_keyframe());
-      });
+      .WillOnce(
+          [&](EncodedFrame* frame) { EXPECT_FALSE(frame->is_keyframe()); });
   rtp_video_stream_receiver_->OnReceivedPayloadData(idr_data, rtp_packet,
                                                     idr_video_header);
 }
@@ -826,7 +812,7 @@
   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 @@
                                                            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 @@
 
   int64_t first_picture_id;
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
-        first_picture_id = frame->Id();
-      });
+      .WillOnce([&](EncodedFrame* frame) { 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 @@
   // 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) {
-        first_picture_id = frame->Id();
-      });
+      .WillOnce([&](EncodedFrame* frame) { first_picture_id = frame->Id(); });
   InjectPacketWith(stream_structure, keyframe_descriptor);
 
   DependencyDescriptor deltaframe1_descriptor;
@@ -1050,11 +1032,11 @@
   // 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 @@
   keyframe2_descriptor.frame_number = 3;
 
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
-        EXPECT_EQ(frame->Id() & 0xFFFF, 3);
-      });
+      .WillOnce(
+          [&](EncodedFrame* frame) { EXPECT_EQ(frame->Id() & 0xFFFF, 3); });
   InjectPacketWith(stream_structure2, keyframe2_descriptor);
   InjectPacketWith(stream_structure1, keyframe1_descriptor);
 
@@ -1132,9 +1113,8 @@
   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) {
-        EXPECT_EQ(frame->Id() & 0xFFFF, 4);
-      });
+      .WillOnce(
+          [&](EncodedFrame* frame) { EXPECT_EQ(frame->Id() & 0xFFFF, 4); });
   InjectPacketWith(stream_structure2, deltaframe_descriptor);
 }
 
@@ -1218,8 +1198,8 @@
   // 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](
-                           video_coding::EncodedFrame* frame) {
+      .WillOnce(Invoke([expected_playout_delay =
+                            GetParam().expected_delay](EncodedFrame* frame) {
         EXPECT_EQ(frame->EncodedImage().playout_delay_, expected_playout_delay);
       }));
   rtp_video_stream_receiver_->OnReceivedPayloadData(

diff --git a/video/rtp_video_stream_receiver_frame_transformer_delegate.cc b/video/rtp_video_stream_receiver_frame_transformer_delegate.cc
index 31eb344..f2f81df 100644
--- a/video/rtp_video_stream_receiver_frame_transformer_delegate.cc
+++ b/video/rtp_video_stream_receiver_frame_transformer_delegate.cc

@@ -24,9 +24,8 @@
 class TransformableVideoReceiverFrame
     : public TransformableVideoFrameInterface {
  public:
-  TransformableVideoReceiverFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame,
-      uint32_t ssrc)
+  TransformableVideoReceiverFrame(std::unique_ptr<RtpFrameObject> frame,
+                                  uint32_t ssrc)
       : frame_(std::move(frame)),
         metadata_(frame_->GetRtpVideoHeader()),
         ssrc_(ssrc) {}
@@ -55,12 +54,12 @@
 
   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::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),

diff --git a/video/rtp_video_stream_receiver_frame_transformer_delegate.h b/video/rtp_video_stream_receiver_frame_transformer_delegate.h
index f7431dd..ef05d91 100644
--- a/video/rtp_video_stream_receiver_frame_transformer_delegate.h
+++ b/video/rtp_video_stream_receiver_frame_transformer_delegate.h

@@ -25,8 +25,7 @@
 // thread after transformation.
 class RtpVideoFrameReceiver {
  public:
-  virtual void ManageFrame(
-      std::unique_ptr<video_coding::RtpFrameObject> frame) = 0;
+  virtual void ManageFrame(std::unique_ptr<RtpFrameObject> frame) = 0;
 
  protected:
   virtual ~RtpVideoFrameReceiver() = default;
@@ -47,7 +46,7 @@
   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_|.

diff --git a/video/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc b/video/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc
index a411ca6..f3306f0 100644
--- a/video/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc
+++ b/video/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc

@@ -35,15 +35,15 @@
 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 @@
 
   MOCK_METHOD(void,
               ManageFrame,
-              (std::unique_ptr<video_coding::RtpFrameObject> frame),
+              (std::unique_ptr<RtpFrameObject> frame),
               (override));
 };
 

diff --git a/video/rtp_video_stream_receiver_unittest.cc b/video/rtp_video_stream_receiver_unittest.cc
index 0d7d4c9..acdc2b7 100644
--- a/video/rtp_video_stream_receiver_unittest.cc
+++ b/video/rtp_video_stream_receiver_unittest.cc

@@ -50,8 +50,7 @@
 
 const uint8_t kH264StartCode[] = {0x00, 0x00, 0x00, 0x01};
 
-std::vector<uint64_t> GetAbsoluteCaptureTimestamps(
-    const video_coding::EncodedFrame* frame) {
+std::vector<uint64_t> GetAbsoluteCaptureTimestamps(const 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 MockOnCompleteFrameCallback : public OnCompleteFrameCallback {
  public:
-  MOCK_METHOD(void, DoOnCompleteFrame, (video_coding::EncodedFrame*), ());
-  MOCK_METHOD(void,
-              DoOnCompleteFrameFailNullptr,
-              (video_coding::EncodedFrame*),
-              ());
-  MOCK_METHOD(void,
-              DoOnCompleteFrameFailLength,
-              (video_coding::EncodedFrame*),
-              ());
-  MOCK_METHOD(void,
-              DoOnCompleteFrameFailBitstream,
-              (video_coding::EncodedFrame*),
-              ());
-  void OnCompleteFrame(
-      std::unique_ptr<video_coding::EncodedFrame> frame) override {
+  MOCK_METHOD(void, DoOnCompleteFrame, (EncodedFrame*), ());
+  MOCK_METHOD(void, DoOnCompleteFrameFailNullptr, (EncodedFrame*), ());
+  MOCK_METHOD(void, DoOnCompleteFrameFailLength, (EncodedFrame*), ());
+  MOCK_METHOD(void, DoOnCompleteFrameFailBitstream, (EncodedFrame*), ());
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override {
     if (!frame) {
       DoOnCompleteFrameFailNullptr(nullptr);
       return;
@@ -338,7 +327,7 @@
   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 @@
   // 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 @@
   mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(),
                                                            data.size());
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
-      .WillOnce(Invoke(
-          [kAbsoluteCaptureTimestamp](video_coding::EncodedFrame* frame) {
-            EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame),
-                        ElementsAre(kAbsoluteCaptureTimestamp));
-          }));
+      .WillOnce(Invoke([kAbsoluteCaptureTimestamp](EncodedFrame* frame) {
+        EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame),
+                    ElementsAre(kAbsoluteCaptureTimestamp));
+      }));
   rtp_video_stream_receiver_->OnReceivedPayloadData(data, rtp_packet,
                                                     video_header);
 }
@@ -444,7 +432,7 @@
   // 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 @@
   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) {
-        EXPECT_TRUE(frame->is_keyframe());
-      });
+      .WillOnce(
+          [&](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 @@
                                                            idr_data.size());
   rtp_packet.SetSequenceNumber(3);
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
-        EXPECT_FALSE(frame->is_keyframe());
-      });
+      .WillOnce(
+          [&](EncodedFrame* frame) { EXPECT_FALSE(frame->is_keyframe()); });
   rtp_video_stream_receiver_->OnReceivedPayloadData(idr_data, rtp_packet,
                                                     idr_video_header);
 }
@@ -858,7 +844,7 @@
   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 @@
                                                            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 @@
 
   int64_t first_picture_id;
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
-        first_picture_id = frame->Id();
-      });
+      .WillOnce([&](EncodedFrame* frame) { 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 @@
   // 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) {
-        first_picture_id = frame->Id();
-      });
+      .WillOnce([&](EncodedFrame* frame) { first_picture_id = frame->Id(); });
   InjectPacketWith(stream_structure, keyframe_descriptor);
 
   DependencyDescriptor deltaframe1_descriptor;
@@ -1082,11 +1064,11 @@
   // 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 @@
   keyframe2_descriptor.frame_number = 3;
 
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
-      .WillOnce([&](video_coding::EncodedFrame* frame) {
-        EXPECT_EQ(frame->Id() & 0xFFFF, 3);
-      });
+      .WillOnce(
+          [&](EncodedFrame* frame) { EXPECT_EQ(frame->Id() & 0xFFFF, 3); });
   InjectPacketWith(stream_structure2, keyframe2_descriptor);
   InjectPacketWith(stream_structure1, keyframe1_descriptor);
 
@@ -1164,9 +1145,8 @@
   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) {
-        EXPECT_EQ(frame->Id() & 0xFFFF, 4);
-      });
+      .WillOnce(
+          [&](EncodedFrame* frame) { EXPECT_EQ(frame->Id() & 0xFFFF, 4); });
   InjectPacketWith(stream_structure2, deltaframe_descriptor);
 }
 
@@ -1264,8 +1244,8 @@
   // 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](
-                           video_coding::EncodedFrame* frame) {
+      .WillOnce(Invoke([expected_playout_delay =
+                            GetParam().expected_delay](EncodedFrame* frame) {
         EXPECT_EQ(frame->EncodedImage().playout_delay_, expected_playout_delay);
       }));
   rtp_video_stream_receiver_->OnReceivedPayloadData(

diff --git a/video/video_receive_stream.cc b/video/video_receive_stream.cc
index 037c5d3..d69eba5 100644
--- a/video/video_receive_stream.cc
+++ b/video/video_receive_stream.cc

@@ -60,7 +60,6 @@
 
 namespace {
 
-using video_coding::EncodedFrame;
 using ReturnReason = video_coding::FrameBuffer::ReturnReason;
 
 constexpr int kMinBaseMinimumDelayMs = 0;
@@ -69,7 +68,7 @@
 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 @@
   last_keyframe_request_ms_ = timestamp_ms;
 }
 
-void VideoReceiveStream::OnCompleteFrame(
-    std::unique_ptr<video_coding::EncodedFrame> frame) {
+void VideoReceiveStream::OnCompleteFrame(std::unique_ptr<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();

diff --git a/video/video_receive_stream.h b/video/video_receive_stream.h
index f647fb1..f3b5189 100644
--- a/video/video_receive_stream.h
+++ b/video/video_receive_stream.h

@@ -112,8 +112,7 @@
                 bool buffering_allowed) override;
 
   // Implements OnCompleteFrameCallback.
-  void OnCompleteFrame(
-      std::unique_ptr<video_coding::EncodedFrame> frame) override;
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override;
 
   // Implements CallStatsObserver::OnRttUpdate
   void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
@@ -138,7 +137,7 @@
  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

diff --git a/video/video_receive_stream2.cc b/video/video_receive_stream2.cc
index c2a0792..0b4b66f 100644
--- a/video/video_receive_stream2.cc
+++ b/video/video_receive_stream2.cc

@@ -58,7 +58,6 @@
 
 namespace {
 
-using video_coding::EncodedFrame;
 using ReturnReason = video_coding::FrameBuffer::ReturnReason;
 
 constexpr int kMinBaseMinimumDelayMs = 0;
@@ -69,7 +68,7 @@
 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::OnCompleteFrame(
-    std::unique_ptr<video_coding::EncodedFrame> frame) {
+void VideoReceiveStream2::OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) {
   RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
 
   // TODO(https://bugs.webrtc.org/9974): Consider removing this workaround.

diff --git a/video/video_receive_stream2.h b/video/video_receive_stream2.h
index 305c6a1..d8bc160 100644
--- a/video/video_receive_stream2.h
+++ b/video/video_receive_stream2.h

@@ -131,8 +131,7 @@
                 bool buffering_allowed) override;
 
   // Implements OnCompleteFrameCallback.
-  void OnCompleteFrame(
-      std::unique_ptr<video_coding::EncodedFrame> frame) override;
+  void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override;
 
   // Implements CallStatsObserver::OnRttUpdate
   void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
@@ -158,7 +157,7 @@
   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_);

diff --git a/video/video_receive_stream2_unittest.cc b/video/video_receive_stream2_unittest.cc
index b59d167..aa9cee3 100644
--- a/video/video_receive_stream2_unittest.cc
+++ b/video/video_receive_stream2_unittest.cc

@@ -84,7 +84,7 @@
                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 @@
 
   void OnFrameDecoded() { event_->Set(); }
 
-  void PassEncodedFrameAndWait(
-      std::unique_ptr<video_coding::EncodedFrame> frame) {
+  void PassEncodedFrameAndWait(std::unique_ptr<EncodedFrame> frame) {
     event_ = std::make_unique<rtc::Event>();
     // This call will eventually end up in the Decoded method where the
     // event is set.

diff --git a/video/video_receive_stream_unittest.cc b/video/video_receive_stream_unittest.cc
index 31f9f7b..e69820e 100644
--- a/video/video_receive_stream_unittest.cc
+++ b/video/video_receive_stream_unittest.cc

@@ -76,7 +76,7 @@
   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 @@
 
   void OnFrameDecoded() { event_->Set(); }
 
-  void PassEncodedFrameAndWait(
-      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_receive_stream_.OnCompleteFrame(std::move(frame));
-      event_->Wait(rtc::Event::kForever);
+  void PassEncodedFrameAndWait(std::unique_ptr<EncodedFrame> frame) {
+    event_ = std::make_unique<rtc::Event>();
+    // This call will eventually end up in the Decoded method where the
+    // event is set.
+    video_receive_stream_.OnCompleteFrame(std::move(frame));
+    event_->Wait(rtc::Event::kForever);
   }
 
  protected:

diff --git a/video/video_stream_decoder_impl.cc b/video/video_stream_decoder_impl.cc
index eab1c94..b6d754e 100644
--- a/video/video_stream_decoder_impl.cc
+++ b/video/video_stream_decoder_impl.cc

@@ -50,8 +50,7 @@
   shut_down_ = true;
 }
 
-void VideoStreamDecoderImpl::OnFrame(
-    std::unique_ptr<video_coding::EncodedFrame> frame) {
+void VideoStreamDecoderImpl::OnFrame(std::unique_ptr<EncodedFrame> frame) {
   if (!bookkeeping_queue_.IsCurrent()) {
     bookkeeping_queue_.PostTask([this, frame = std::move(frame)]() mutable {
       OnFrame(std::move(frame));
@@ -123,8 +122,7 @@
   return decoder_.get();
 }
 
-void VideoStreamDecoderImpl::SaveFrameInfo(
-    const video_coding::EncodedFrame& frame) {
+void VideoStreamDecoderImpl::SaveFrameInfo(const 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 @@
 
   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::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 @@
 }
 
 VideoStreamDecoderImpl::DecodeResult VideoStreamDecoderImpl::DecodeFrame(
-    std::unique_ptr<video_coding::EncodedFrame> frame) {
+    std::unique_ptr<EncodedFrame> frame) {
   RTC_DCHECK(frame);
 
   VideoDecoder* decoder = GetDecoder(frame->PayloadType());

diff --git a/video/video_stream_decoder_impl.h b/video/video_stream_decoder_impl.h
index 740b812..106f383 100644
--- a/video/video_stream_decoder_impl.h
+++ b/video/video_stream_decoder_impl.h

@@ -37,7 +37,7 @@
 
   ~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 @@
     VideoContentType content_type;
   };
 
-  void SaveFrameInfo(const video_coding::EncodedFrame& frame)
-      RTC_RUN_ON(bookkeeping_queue_);
+  void SaveFrameInfo(const EncodedFrame& frame) 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 @@
 
   VideoDecoder* GetDecoder(int payload_type) RTC_RUN_ON(decode_queue_);
   VideoStreamDecoderImpl::DecodeResult DecodeFrame(
-      std::unique_ptr<video_coding::EncodedFrame> frame)
-      RTC_RUN_ON(decode_queue_);
+      std::unique_ptr<EncodedFrame> frame) RTC_RUN_ON(decode_queue_);
 
   VCMTiming timing_;
   DecodeCallbacks decode_callbacks_;

diff --git a/video/video_stream_decoder_impl_unittest.cc b/video/video_stream_decoder_impl_unittest.cc
index caa7c0e..a3e2589 100644
--- a/video/video_stream_decoder_impl_unittest.cc
+++ b/video/video_stream_decoder_impl_unittest.cc

@@ -127,7 +127,7 @@
   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; }