diff --git a/api/test/video_codec_tester.h b/api/test/video_codec_tester.h
index b2ce88c..83408e6 100644
--- a/api/test/video_codec_tester.h
+++ b/api/test/video_codec_tester.h
@@ -106,25 +106,25 @@
   // Returns `VideoCodecTestStats` object that contains collected per-frame
   // metrics.
   virtual std::unique_ptr<VideoCodecStats> RunDecodeTest(
-      std::unique_ptr<CodedVideoSource> video_source,
-      std::unique_ptr<Decoder> decoder,
+      CodedVideoSource* video_source,
+      Decoder* decoder,
       const DecoderSettings& decoder_settings) = 0;
 
   // Pulls raw video frames from `video_source` and passes them to `encoder`.
   // Returns `VideoCodecTestStats` object that contains collected per-frame
   // metrics.
   virtual std::unique_ptr<VideoCodecStats> RunEncodeTest(
-      std::unique_ptr<RawVideoSource> video_source,
-      std::unique_ptr<Encoder> encoder,
+      RawVideoSource* video_source,
+      Encoder* encoder,
       const EncoderSettings& encoder_settings) = 0;
 
   // Pulls raw video frames from `video_source`, passes them to `encoder` and
   // then passes encoded frames to `decoder`. Returns `VideoCodecTestStats`
   // object that contains collected per-frame metrics.
   virtual std::unique_ptr<VideoCodecStats> RunEncodeDecodeTest(
-      std::unique_ptr<RawVideoSource> video_source,
-      std::unique_ptr<Encoder> encoder,
-      std::unique_ptr<Decoder> decoder,
+      RawVideoSource* video_source,
+      Encoder* encoder,
+      Decoder* decoder,
       const EncoderSettings& encoder_settings,
       const DecoderSettings& decoder_settings) = 0;
 };
diff --git a/modules/video_coding/codecs/test/video_codec_test.cc b/modules/video_coding/codecs/test/video_codec_test.cc
index d2ad743..ce7f4e7 100644
--- a/modules/video_coding/codecs/test/video_codec_test.cc
+++ b/modules/video_coding/codecs/test/video_codec_test.cc
@@ -423,7 +423,7 @@
 
 TEST_P(EncodeDecodeTest, DISABLED_TestEncodeDecode) {
   std::unique_ptr<VideoCodecStats> stats = tester_->RunEncodeDecodeTest(
-      std::move(video_source_), std::move(encoder_), std::move(decoder_),
+      video_source_.get(), encoder_.get(), decoder_.get(),
       test_params_.encoder_settings, test_params_.decoder_settings);
 
   const auto& frame_settings = test_params_.encoding_settings.frame_settings;
diff --git a/modules/video_coding/codecs/test/video_codec_tester_impl.cc b/modules/video_coding/codecs/test/video_codec_tester_impl.cc
index 09c5978..3655c30 100644
--- a/modules/video_coding/codecs/test/video_codec_tester_impl.cc
+++ b/modules/video_coding/codecs/test/video_codec_tester_impl.cc
@@ -45,8 +45,8 @@
 // that reads reference frames from a separate thread.
 class SyncRawVideoSource : public VideoCodecAnalyzer::ReferenceVideoSource {
  public:
-  explicit SyncRawVideoSource(std::unique_ptr<RawVideoSource> video_source)
-      : video_source_(std::move(video_source)) {}
+  explicit SyncRawVideoSource(RawVideoSource* video_source)
+      : video_source_(video_source) {}
 
   absl::optional<VideoFrame> PullFrame() {
     MutexLock lock(&mutex_);
@@ -59,7 +59,7 @@
   }
 
  protected:
-  std::unique_ptr<RawVideoSource> video_source_ RTC_GUARDED_BY(mutex_);
+  RawVideoSource* const video_source_ RTC_GUARDED_BY(mutex_);
   Mutex mutex_;
 };
 
@@ -153,11 +153,11 @@
 
 class TesterDecoder {
  public:
-  TesterDecoder(std::unique_ptr<Decoder> decoder,
+  TesterDecoder(Decoder* decoder,
                 VideoCodecAnalyzer* analyzer,
                 const DecoderSettings& settings,
                 rtc::TaskQueue& task_queue)
-      : decoder_(std::move(decoder)),
+      : decoder_(decoder),
         analyzer_(analyzer),
         settings_(settings),
         pacer_(settings.pacing),
@@ -183,7 +183,7 @@
   void Flush() { task_queue_.WaitForPreviouslyPostedTasks(); }
 
  protected:
-  std::unique_ptr<Decoder> decoder_;
+  Decoder* const decoder_;
   VideoCodecAnalyzer* const analyzer_;
   const DecoderSettings& settings_;
   Pacer pacer_;
@@ -192,12 +192,12 @@
 
 class TesterEncoder {
  public:
-  TesterEncoder(std::unique_ptr<Encoder> encoder,
+  TesterEncoder(Encoder* encoder,
                 TesterDecoder* decoder,
                 VideoCodecAnalyzer* analyzer,
                 const EncoderSettings& settings,
                 rtc::TaskQueue& task_queue)
-      : encoder_(std::move(encoder)),
+      : encoder_(encoder),
         decoder_(decoder),
         analyzer_(analyzer),
         settings_(settings),
@@ -225,7 +225,7 @@
   void Flush() { task_queue_.WaitForPreviouslyPostedTasks(); }
 
  protected:
-  std::unique_ptr<Encoder> encoder_;
+  Encoder* const encoder_;
   TesterDecoder* const decoder_;
   VideoCodecAnalyzer* const analyzer_;
   const EncoderSettings& settings_;
@@ -247,8 +247,8 @@
 }
 
 std::unique_ptr<VideoCodecStats> VideoCodecTesterImpl::RunDecodeTest(
-    std::unique_ptr<CodedVideoSource> video_source,
-    std::unique_ptr<Decoder> decoder,
+    CodedVideoSource* video_source,
+    Decoder* decoder,
     const DecoderSettings& decoder_settings) {
   rtc::TaskQueue analyser_task_queue(task_queue_factory_->CreateTaskQueue(
       "Analyzer", TaskQueueFactory::Priority::NORMAL));
@@ -256,8 +256,8 @@
       "Decoder", TaskQueueFactory::Priority::NORMAL));
 
   VideoCodecAnalyzer perf_analyzer(analyser_task_queue);
-  TesterDecoder tester_decoder(std::move(decoder), &perf_analyzer,
-                               decoder_settings, decoder_task_queue);
+  TesterDecoder tester_decoder(decoder, &perf_analyzer, decoder_settings,
+                               decoder_task_queue);
 
   while (auto frame = video_source->PullFrame()) {
     tester_decoder.Decode(*frame);
@@ -269,19 +269,18 @@
 }
 
 std::unique_ptr<VideoCodecStats> VideoCodecTesterImpl::RunEncodeTest(
-    std::unique_ptr<RawVideoSource> video_source,
-    std::unique_ptr<Encoder> encoder,
+    RawVideoSource* video_source,
+    Encoder* encoder,
     const EncoderSettings& encoder_settings) {
   rtc::TaskQueue analyser_task_queue(task_queue_factory_->CreateTaskQueue(
       "Analyzer", TaskQueueFactory::Priority::NORMAL));
   rtc::TaskQueue encoder_task_queue(task_queue_factory_->CreateTaskQueue(
       "Encoder", TaskQueueFactory::Priority::NORMAL));
 
-  SyncRawVideoSource sync_source(std::move(video_source));
+  SyncRawVideoSource sync_source(video_source);
   VideoCodecAnalyzer perf_analyzer(analyser_task_queue);
-  TesterEncoder tester_encoder(std::move(encoder), /*decoder=*/nullptr,
-                               &perf_analyzer, encoder_settings,
-                               encoder_task_queue);
+  TesterEncoder tester_encoder(encoder, /*decoder=*/nullptr, &perf_analyzer,
+                               encoder_settings, encoder_task_queue);
 
   while (auto frame = sync_source.PullFrame()) {
     tester_encoder.Encode(*frame);
@@ -293,9 +292,9 @@
 }
 
 std::unique_ptr<VideoCodecStats> VideoCodecTesterImpl::RunEncodeDecodeTest(
-    std::unique_ptr<RawVideoSource> video_source,
-    std::unique_ptr<Encoder> encoder,
-    std::unique_ptr<Decoder> decoder,
+    RawVideoSource* video_source,
+    Encoder* encoder,
+    Decoder* decoder,
     const EncoderSettings& encoder_settings,
     const DecoderSettings& decoder_settings) {
   rtc::TaskQueue analyser_task_queue(task_queue_factory_->CreateTaskQueue(
@@ -305,13 +304,12 @@
   rtc::TaskQueue encoder_task_queue(task_queue_factory_->CreateTaskQueue(
       "Encoder", TaskQueueFactory::Priority::NORMAL));
 
-  SyncRawVideoSource sync_source(std::move(video_source));
+  SyncRawVideoSource sync_source(video_source);
   VideoCodecAnalyzer perf_analyzer(analyser_task_queue, &sync_source);
-  TesterDecoder tester_decoder(std::move(decoder), &perf_analyzer,
-                               decoder_settings, decoder_task_queue);
-  TesterEncoder tester_encoder(std::move(encoder), &tester_decoder,
-                               &perf_analyzer, encoder_settings,
-                               encoder_task_queue);
+  TesterDecoder tester_decoder(decoder, &perf_analyzer, decoder_settings,
+                               decoder_task_queue);
+  TesterEncoder tester_encoder(encoder, &tester_decoder, &perf_analyzer,
+                               encoder_settings, encoder_task_queue);
 
   while (auto frame = sync_source.PullFrame()) {
     tester_encoder.Encode(*frame);
diff --git a/modules/video_coding/codecs/test/video_codec_tester_impl.h b/modules/video_coding/codecs/test/video_codec_tester_impl.h
index 4ac61ee..bb8ee72 100644
--- a/modules/video_coding/codecs/test/video_codec_tester_impl.h
+++ b/modules/video_coding/codecs/test/video_codec_tester_impl.h
@@ -26,19 +26,19 @@
   explicit VideoCodecTesterImpl(TaskQueueFactory* task_queue_factory);
 
   std::unique_ptr<VideoCodecStats> RunDecodeTest(
-      std::unique_ptr<CodedVideoSource> video_source,
-      std::unique_ptr<Decoder> decoder,
+      CodedVideoSource* video_source,
+      Decoder* decoder,
       const DecoderSettings& decoder_settings) override;
 
   std::unique_ptr<VideoCodecStats> RunEncodeTest(
-      std::unique_ptr<RawVideoSource> video_source,
-      std::unique_ptr<Encoder> encoder,
+      RawVideoSource* video_source,
+      Encoder* encoder,
       const EncoderSettings& encoder_settings) override;
 
   std::unique_ptr<VideoCodecStats> RunEncodeDecodeTest(
-      std::unique_ptr<RawVideoSource> video_source,
-      std::unique_ptr<Encoder> encoder,
-      std::unique_ptr<Decoder> decoder,
+      RawVideoSource* video_source,
+      Encoder* encoder,
+      Decoder* decoder,
       const EncoderSettings& encoder_settings,
       const DecoderSettings& decoder_settings) override;
 
diff --git a/modules/video_coding/codecs/test/video_codec_tester_impl_unittest.cc b/modules/video_coding/codecs/test/video_codec_tester_impl_unittest.cc
index 409e813..c1195a7 100644
--- a/modules/video_coding/codecs/test/video_codec_tester_impl_unittest.cc
+++ b/modules/video_coding/codecs/test/video_codec_tester_impl_unittest.cc
@@ -149,10 +149,10 @@
 };
 
 TEST_P(VideoCodecTesterImplPacingTest, PaceEncode) {
-  auto video_source = std::make_unique<MockRawVideoSource>();
+  MockRawVideoSource video_source;
 
   size_t frame_num = 0;
-  EXPECT_CALL(*video_source, PullFrame).WillRepeatedly(Invoke([&]() mutable {
+  EXPECT_CALL(video_source, PullFrame).WillRepeatedly(Invoke([&]() mutable {
     if (frame_num >= num_frames_) {
       return absl::optional<VideoFrame>();
     }
@@ -164,15 +164,13 @@
     return absl::optional<VideoFrame>(CreateVideoFrame(timestamp_rtp));
   }));
 
-  auto encoder = std::make_unique<MockEncoder>();
+  MockEncoder encoder;
   EncoderSettings encoder_settings;
   encoder_settings.pacing = pacing_settings_;
 
   VideoCodecTesterImpl tester(&task_queue_factory_);
-  auto fs = tester
-                .RunEncodeTest(std::move(video_source), std::move(encoder),
-                               encoder_settings)
-                ->Slice();
+  auto fs =
+      tester.RunEncodeTest(&video_source, &encoder, encoder_settings)->Slice();
   ASSERT_EQ(fs.size(), num_frames_);
 
   for (size_t i = 0; i < fs.size(); ++i) {
@@ -182,10 +180,10 @@
 }
 
 TEST_P(VideoCodecTesterImplPacingTest, PaceDecode) {
-  auto video_source = std::make_unique<MockCodedVideoSource>();
+  MockCodedVideoSource video_source;
 
   size_t frame_num = 0;
-  EXPECT_CALL(*video_source, PullFrame).WillRepeatedly(Invoke([&]() mutable {
+  EXPECT_CALL(video_source, PullFrame).WillRepeatedly(Invoke([&]() mutable {
     if (frame_num >= num_frames_) {
       return absl::optional<EncodedImage>();
     }
@@ -197,15 +195,13 @@
     return absl::optional<EncodedImage>(CreateEncodedImage(timestamp_rtp));
   }));
 
-  auto decoder = std::make_unique<MockDecoder>();
+  MockDecoder decoder;
   DecoderSettings decoder_settings;
   decoder_settings.pacing = pacing_settings_;
 
   VideoCodecTesterImpl tester(&task_queue_factory_);
-  auto fs = tester
-                .RunDecodeTest(std::move(video_source), std::move(decoder),
-                               decoder_settings)
-                ->Slice();
+  auto fs =
+      tester.RunDecodeTest(&video_source, &decoder, decoder_settings)->Slice();
   ASSERT_EQ(fs.size(), num_frames_);
 
   for (size_t i = 0; i < fs.size(); ++i) {