Update internal SW codecs to return unique_ptrs

TBR=stefan@webrtc.org

Bug: webrtc:7925
Change-Id: I84239b071a2608d928f09b06809090eec5eafb14
Reviewed-on: https://webrtc-review.googlesource.com/21165
Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20650}

media/engine/internaldecoderfactory.cc

@@ -33,15 +33,15 @@ std::vector<SdpVideoFormat> InternalDecoderFactory::GetSupportedFormats()
 std::unique_ptr<VideoDecoder> InternalDecoderFactory::CreateVideoDecoder(
     const SdpVideoFormat& format) {
   if (cricket::CodecNamesEq(format.name, cricket::kVp8CodecName))
-    return std::unique_ptr<VideoDecoder>(VP8Decoder::Create());
+    return VP8Decoder::Create();
 
   if (cricket::CodecNamesEq(format.name, cricket::kVp9CodecName)) {
     RTC_DCHECK(VP9Decoder::IsSupported());
-    return std::unique_ptr<VideoDecoder>(VP9Decoder::Create());
+    return VP9Decoder::Create();
   }
 
   if (cricket::CodecNamesEq(format.name, cricket::kH264CodecName))
-    return std::unique_ptr<VideoDecoder>(H264Decoder::Create());
+    return H264Decoder::Create();
 
   RTC_LOG(LS_ERROR) << "Trying to create decoder for unsupported format";
   return nullptr;

media/engine/internalencoderfactory.cc

@@ -64,11 +64,11 @@ webrtc::VideoEncoder* InternalEncoderFactory::CreateVideoEncoder(
       webrtc::PayloadStringToCodecType(codec.name);
   switch (codec_type) {
     case webrtc::kVideoCodecH264:
-      return webrtc::H264Encoder::Create(codec);
+      return webrtc::H264Encoder::Create(codec).release();
     case webrtc::kVideoCodecVP8:
-      return webrtc::VP8Encoder::Create();
+      return webrtc::VP8Encoder::Create().release();
     case webrtc::kVideoCodecVP9:
-      return webrtc::VP9Encoder::Create();
+      return webrtc::VP9Encoder::Create().release();
     default:
       return nullptr;
   }

media/engine/simulcast_encoder_adapter_unittest.cc

@@ -13,9 +13,11 @@
 #include <vector>
 
 #include "common_video/include/video_frame_buffer.h"
+#include "media/engine/internalencoderfactory.h"
 #include "media/engine/simulcast_encoder_adapter.h"
 #include "modules/video_coding/codecs/vp8/simulcast_test_utility.h"
 #include "modules/video_coding/include/video_codec_interface.h"
+#include "rtc_base/ptr_util.h"
 #include "test/gmock.h"
 
 namespace webrtc {
@@ -23,39 +25,19 @@ namespace testing {
 
 class TestSimulcastEncoderAdapter : public TestVp8Simulcast {
  public:
-  TestSimulcastEncoderAdapter() : factory_(new Vp8EncoderFactory()) {}
+  TestSimulcastEncoderAdapter()
+      : factory_(new cricket::InternalEncoderFactory()) {}
 
  protected:
-  class Vp8EncoderFactory : public cricket::WebRtcVideoEncoderFactory {
-   public:
-    Vp8EncoderFactory() {
-      supported_codecs_.push_back(cricket::VideoCodec("VP8"));
+  std::unique_ptr<VP8Encoder> CreateEncoder() override {
+    return rtc::MakeUnique<SimulcastEncoderAdapter>(factory_.get());
   }
-
-    const std::vector<cricket::VideoCodec>& supported_codecs() const override {
-      return supported_codecs_;
+  std::unique_ptr<VP8Decoder> CreateDecoder() override {
+    return VP8Decoder::Create();
   }
 
-    VideoEncoder* CreateVideoEncoder(
-        const cricket::VideoCodec& codec) override {
-      return VP8Encoder::Create();
-    }
-
-    void DestroyVideoEncoder(VideoEncoder* encoder) override { delete encoder; }
-
-    virtual ~Vp8EncoderFactory() {}
-
  private:
-    std::vector<cricket::VideoCodec> supported_codecs_;
-  };
-
-  VP8Encoder* CreateEncoder() override {
-    return new SimulcastEncoderAdapter(factory_.get());
-  }
-  VP8Decoder* CreateDecoder() override { return VP8Decoder::Create(); }
-
- private:
-  std::unique_ptr<Vp8EncoderFactory> factory_;
+  std::unique_ptr<cricket::WebRtcVideoEncoderFactory> factory_;
 };
 
 TEST_F(TestSimulcastEncoderAdapter, TestKeyFrameRequestsOnAllStreams) {

modules/video_coding/codecs/h264/h264.cc

@@ -21,6 +21,7 @@
 
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
+#include "rtc_base/ptr_util.h"
 
 namespace webrtc {
 
@@ -70,12 +71,13 @@ std::vector<SdpVideoFormat> SupportedH264Codecs() {
           CreateH264Format(H264::kProfileConstrainedBaseline, H264::kLevel3_1)};
 }
 
-H264Encoder* H264Encoder::Create(const cricket::VideoCodec& codec) {
+std::unique_ptr<H264Encoder> H264Encoder::Create(
+    const cricket::VideoCodec& codec) {
   RTC_DCHECK(H264Encoder::IsSupported());
 #if defined(WEBRTC_USE_H264)
   RTC_CHECK(g_rtc_use_h264);
   RTC_LOG(LS_INFO) << "Creating H264EncoderImpl.";
-  return new H264EncoderImpl(codec);
+  return rtc::MakeUnique<H264EncoderImpl>(codec);
 #else
   RTC_NOTREACHED();
   return nullptr;
@@ -86,12 +88,12 @@ bool H264Encoder::IsSupported() {
   return IsH264CodecSupported();
 }
 
-H264Decoder* H264Decoder::Create() {
+std::unique_ptr<H264Decoder> H264Decoder::Create() {
   RTC_DCHECK(H264Decoder::IsSupported());
 #if defined(WEBRTC_USE_H264)
   RTC_CHECK(g_rtc_use_h264);
   RTC_LOG(LS_INFO) << "Creating H264DecoderImpl.";
-  return new H264DecoderImpl();
+  return rtc::MakeUnique<H264DecoderImpl>();
 #else
   RTC_NOTREACHED();
   return nullptr;

modules/video_coding/codecs/h264/include/h264.h

@@ -12,6 +12,7 @@
 #ifndef MODULES_VIDEO_CODING_CODECS_H264_INCLUDE_H264_H_
 #define MODULES_VIDEO_CODING_CODECS_H264_INCLUDE_H264_H_
 
+#include <memory>
 #include <vector>
 
 #include "media/base/codec.h"
@@ -33,7 +34,7 @@ std::vector<SdpVideoFormat> SupportedH264Codecs();
 
 class H264Encoder : public VideoEncoder {
  public:
-  static H264Encoder* Create(const cricket::VideoCodec& codec);
+  static std::unique_ptr<H264Encoder> Create(const cricket::VideoCodec& codec);
   // If H.264 is supported (any implementation).
   static bool IsSupported();
 
@@ -42,7 +43,7 @@ class H264Encoder : public VideoEncoder {
 
 class H264Decoder : public VideoDecoder {
  public:
-  static H264Decoder* Create();
+  static std::unique_ptr<H264Decoder> Create();
   static bool IsSupported();
 
   ~H264Decoder() override {}

modules/video_coding/codecs/h264/test/h264_impl_unittest.cc

@@ -16,11 +16,13 @@ namespace webrtc {
 
 class TestH264Impl : public VideoCodecTest {
  protected:
-  VideoEncoder* CreateEncoder() override {
+  std::unique_ptr<VideoEncoder> CreateEncoder() override {
     return H264Encoder::Create(cricket::VideoCodec(cricket::kH264CodecName));
   }
 
-  VideoDecoder* CreateDecoder() override { return H264Decoder::Create(); }
+  std::unique_ptr<VideoDecoder> CreateDecoder() override {
+    return H264Decoder::Create();
+  }
 
   VideoCodec codec_settings() override {
     VideoCodec codec_inst;

modules/video_coding/codecs/stereo/test/stereo_adapter_unittest.cc

@@ -31,12 +31,12 @@ class TestStereoAdapter : public VideoCodecTest {
         encoder_factory_(new webrtc::MockVideoEncoderFactory) {}
 
  protected:
-  VideoDecoder* CreateDecoder() override {
-    return new StereoDecoderAdapter(decoder_factory_.get());
+  std::unique_ptr<VideoDecoder> CreateDecoder() override {
+    return rtc::MakeUnique<StereoDecoderAdapter>(decoder_factory_.get());
   }
 
-  VideoEncoder* CreateEncoder() override {
-    return new StereoEncoderAdapter(encoder_factory_.get());
+  std::unique_ptr<VideoEncoder> CreateEncoder() override {
+    return rtc::MakeUnique<StereoEncoderAdapter>(encoder_factory_.get());
   }
 
   VideoCodec codec_settings() override {
@@ -62,15 +62,17 @@ class TestStereoAdapter : public VideoCodecTest {
  private:
   void SetUp() override {
     EXPECT_CALL(*decoder_factory_, Die());
-    VideoDecoder* decoder1 = VP9Decoder::Create();
-    VideoDecoder* decoder2 = VP9Decoder::Create();
+    // The decoders/encoders will be owned by the caller of
+    // CreateVideoDecoder()/CreateVideoEncoder().
+    VideoDecoder* decoder1 = VP9Decoder::Create().release();
+    VideoDecoder* decoder2 = VP9Decoder::Create().release();
     EXPECT_CALL(*decoder_factory_, CreateVideoDecoderProxy(_))
         .WillOnce(Return(decoder1))
         .WillOnce(Return(decoder2));
 
     EXPECT_CALL(*encoder_factory_, Die());
-    VideoEncoder* encoder1 = VP9Encoder::Create();
-    VideoEncoder* encoder2 = VP9Encoder::Create();
+    VideoEncoder* encoder1 = VP9Encoder::Create().release();
+    VideoEncoder* encoder2 = VP9Encoder::Create().release();
     EXPECT_CALL(*encoder_factory_, CreateVideoEncoderProxy(_))
         .WillOnce(Return(encoder1))
         .WillOnce(Return(encoder2));

modules/video_coding/codecs/test/video_codec_test.cc

@@ -63,8 +63,8 @@ void VideoCodecTest::SetUp() {
   input_frame_.reset(new VideoFrame(video_frame_buffer, kVideoRotation_0, 0));
   fclose(source_file_);
 
-  encoder_.reset(CreateEncoder());
-  decoder_.reset(CreateDecoder());
+  encoder_ = CreateEncoder();
+  decoder_ = CreateDecoder();
   encoder_->RegisterEncodeCompleteCallback(&encode_complete_callback_);
   decoder_->RegisterDecodeCompleteCallback(&decode_complete_callback_);
 

modules/video_coding/codecs/test/video_codec_test.h

@@ -68,8 +68,8 @@ class VideoCodecTest : public ::testing::Test {
     VideoCodecTest* const test_;
   };
 
-  virtual VideoEncoder* CreateEncoder() = 0;
-  virtual VideoDecoder* CreateDecoder() = 0;
+  virtual std::unique_ptr<VideoEncoder> CreateEncoder() = 0;
+  virtual std::unique_ptr<VideoDecoder> CreateDecoder() = 0;
   virtual VideoCodec codec_settings() = 0;
 
   void SetUp() override;

modules/video_coding/codecs/vp8/include/vp8.h

@@ -13,20 +13,22 @@
 #ifndef MODULES_VIDEO_CODING_CODECS_VP8_INCLUDE_VP8_H_
 #define MODULES_VIDEO_CODING_CODECS_VP8_INCLUDE_VP8_H_
 
+#include <memory>
+
 #include "modules/video_coding/include/video_codec_interface.h"
 
 namespace webrtc {
 
 class VP8Encoder : public VideoEncoder {
  public:
-  static VP8Encoder* Create();
+  static std::unique_ptr<VP8Encoder> Create();
 
   virtual ~VP8Encoder() {}
 };  // end of VP8Encoder class
 
 class VP8Decoder : public VideoDecoder {
  public:
-  static VP8Decoder* Create();
+  static std::unique_ptr<VP8Decoder> Create();
 
   virtual ~VP8Decoder() {}
 };  // end of VP8Decoder class

modules/video_coding/codecs/vp8/simulcast_test_utility.h

@@ -241,12 +241,12 @@ class TestVp8Simulcast : public ::testing::Test {
   }
 
  protected:
-  virtual VP8Encoder* CreateEncoder() = 0;
-  virtual VP8Decoder* CreateDecoder() = 0;
+  virtual std::unique_ptr<VP8Encoder> CreateEncoder() = 0;
+  virtual std::unique_ptr<VP8Decoder> CreateDecoder() = 0;
 
   void SetUp() override {
-    encoder_.reset(CreateEncoder());
-    decoder_.reset(CreateDecoder());
+    encoder_ = CreateEncoder();
+    decoder_ = CreateDecoder();
     SetUpCodec(kDefaultTemporalLayerProfile);
   }
 

modules/video_coding/codecs/vp8/simulcast_unittest.cc

@@ -15,8 +15,12 @@ namespace testing {
 
 class TestVp8Impl : public TestVp8Simulcast {
  protected:
-  VP8Encoder* CreateEncoder() override { return VP8Encoder::Create(); }
-  VP8Decoder* CreateDecoder() override { return VP8Decoder::Create(); }
+  std::unique_ptr<VP8Encoder> CreateEncoder() override {
+    return VP8Encoder::Create();
+  }
+  std::unique_ptr<VP8Decoder> CreateDecoder() override {
+    return VP8Decoder::Create();
+  }
 };
 
 TEST_F(TestVp8Impl, TestKeyFrameRequestsOnAllStreams) {

modules/video_coding/codecs/vp8/vp8_impl.cc

@@ -30,6 +30,7 @@
 #include "modules/video_coding/include/video_codec_interface.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/numerics/exp_filter.h"
+#include "rtc_base/ptr_util.h"
 #include "rtc_base/random.h"
 #include "rtc_base/timeutils.h"
 #include "rtc_base/trace_event.h"
@@ -162,12 +163,12 @@ void GetPostProcParamsFromFieldTrialGroup(
 
 }  // namespace
 
-VP8Encoder* VP8Encoder::Create() {
-  return new VP8EncoderImpl();
+std::unique_ptr<VP8Encoder> VP8Encoder::Create() {
+  return rtc::MakeUnique<VP8EncoderImpl>();
 }
 
-VP8Decoder* VP8Decoder::Create() {
-  return new VP8DecoderImpl();
+std::unique_ptr<VP8Decoder> VP8Decoder::Create() {
+  return rtc::MakeUnique<VP8DecoderImpl>();
 }
 
 vpx_enc_frame_flags_t VP8EncoderImpl::EncodeFlags(

modules/video_coding/codecs/vp9/include/vp9.h

@@ -12,6 +12,8 @@
 #ifndef MODULES_VIDEO_CODING_CODECS_VP9_INCLUDE_VP9_H_
 #define MODULES_VIDEO_CODING_CODECS_VP9_INCLUDE_VP9_H_
 
+#include <memory>
+
 #include "modules/video_coding/include/video_codec_interface.h"
 
 namespace webrtc {
@@ -19,7 +21,7 @@ namespace webrtc {
 class VP9Encoder : public VideoEncoder {
  public:
   static bool IsSupported();
-  static VP9Encoder* Create();
+  static std::unique_ptr<VP9Encoder> Create();
 
   virtual ~VP9Encoder() {}
 };
@@ -27,7 +29,7 @@ class VP9Encoder : public VideoEncoder {
 class VP9Decoder : public VideoDecoder {
  public:
   static bool IsSupported();
-  static VP9Decoder* Create();
+  static std::unique_ptr<VP9Decoder> Create();
 
   virtual ~VP9Decoder() {}
 };

modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc

@@ -20,9 +20,13 @@ constexpr uint32_t kTimestampIncrementPerFrame = 3000;
 
 class TestVp9Impl : public VideoCodecTest {
  protected:
-  VideoEncoder* CreateEncoder() override { return VP9Encoder::Create(); }
+  std::unique_ptr<VideoEncoder> CreateEncoder() override {
+    return VP9Encoder::Create();
+  }
 
-  VideoDecoder* CreateDecoder() override { return VP9Decoder::Create(); }
+  std::unique_ptr<VideoDecoder> CreateDecoder() override {
+    return VP9Decoder::Create();
+  }
 
   VideoCodec codec_settings() override {
     VideoCodec codec_settings;

modules/video_coding/codecs/vp9/vp9_impl.cc

@@ -27,6 +27,7 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/keep_ref_until_done.h"
 #include "rtc_base/logging.h"
+#include "rtc_base/ptr_util.h"
 #include "rtc_base/random.h"
 #include "rtc_base/timeutils.h"
 #include "rtc_base/trace_event.h"
@@ -52,8 +53,8 @@ bool VP9Encoder::IsSupported() {
   return true;
 }
 
-VP9Encoder* VP9Encoder::Create() {
-  return new VP9EncoderImpl();
+std::unique_ptr<VP9Encoder> VP9Encoder::Create() {
+  return rtc::MakeUnique<VP9EncoderImpl>();
 }
 
 void VP9EncoderImpl::EncoderOutputCodedPacketCallback(vpx_codec_cx_pkt* pkt,
@@ -841,8 +842,8 @@ bool VP9Decoder::IsSupported() {
   return true;
 }
 
-VP9Decoder* VP9Decoder::Create() {
-  return new VP9DecoderImpl();
+std::unique_ptr<VP9Decoder> VP9Decoder::Create() {
+  return rtc::MakeUnique<VP9DecoderImpl>();
 }
 
 VP9DecoderImpl::VP9DecoderImpl()

modules/video_coding/codecs/vp9/vp9_noop.cc

@@ -22,7 +22,7 @@ bool VP9Encoder::IsSupported() {
   return false;
 }
 
-VP9Encoder* VP9Encoder::Create() {
+std::unique_ptr<VP9Encoder> VP9Encoder::Create() {
   RTC_NOTREACHED();
   return nullptr;
 }
@@ -31,7 +31,7 @@ bool VP9Decoder::IsSupported() {
   return false;
 }
 
-VP9Decoder* VP9Decoder::Create() {
+std::unique_ptr<VP9Decoder> VP9Decoder::Create() {
   RTC_NOTREACHED();
   return nullptr;
 }

modules/video_coding/generic_decoder.cc

@@ -182,6 +182,9 @@ int32_t VCMDecodedFrameCallback::Pop(uint32_t timestamp) {
   return VCM_OK;
 }
 
+VCMGenericDecoder::VCMGenericDecoder(std::unique_ptr<VideoDecoder> decoder)
+    : VCMGenericDecoder(decoder.release(), false /* isExternal */) {}
+
 VCMGenericDecoder::VCMGenericDecoder(VideoDecoder* decoder, bool isExternal)
     : _callback(NULL),
       _frameInfos(),

modules/video_coding/generic_decoder.h

@@ -76,6 +76,7 @@ class VCMDecodedFrameCallback : public DecodedImageCallback {
 
 class VCMGenericDecoder {
  public:
+  explicit VCMGenericDecoder(std::unique_ptr<VideoDecoder> decoder);
   explicit VCMGenericDecoder(VideoDecoder* decoder, bool isExternal = false);
   ~VCMGenericDecoder();
 

modules/video_coding/video_sender_unittest.cc

@@ -418,7 +418,7 @@ class TestVideoSenderWithVp8 : public TestVideoSender {
         codec_, std::unique_ptr<TemporalLayersFactory>(tl_factory)));
     codec_.VP8()->tl_factory = tl_factory;
 
-    encoder_.reset(VP8Encoder::Create());
+    encoder_ = VP8Encoder::Create();
     sender_->RegisterExternalEncoder(encoder_.get(), codec_.plType, false);
     EXPECT_EQ(0, sender_->RegisterSendCodec(&codec_, 1, 1200));
   }

test/encoder_settings.cc

@@ -88,11 +88,11 @@ VideoReceiveStream::Decoder CreateMatchingDecoder(
   decoder.payload_type = encoder_settings.payload_type;
   decoder.payload_name = encoder_settings.payload_name;
   if (encoder_settings.payload_name == "H264") {
-    decoder.decoder = H264Decoder::Create();
+    decoder.decoder = H264Decoder::Create().release();
   } else if (encoder_settings.payload_name == "VP8") {
-    decoder.decoder = VP8Decoder::Create();
+    decoder.decoder = VP8Decoder::Create().release();
   } else if (encoder_settings.payload_name == "VP9") {
-    decoder.decoder = VP9Decoder::Create();
+    decoder.decoder = VP9Decoder::Create().release();
   } else {
     decoder.decoder = new FakeDecoder();
   }

video/end_to_end_tests.cc

@@ -329,16 +329,16 @@ class CodecObserver : public test::EndToEndTest,
   CodecObserver(int no_frames_to_wait_for,
                 VideoRotation rotation_to_test,
                 const std::string& payload_name,
-                webrtc::VideoEncoder* encoder,
-                webrtc::VideoDecoder* decoder)
+                std::unique_ptr<webrtc::VideoEncoder> encoder,
+                std::unique_ptr<webrtc::VideoDecoder> decoder)
       : EndToEndTest(4 * webrtc::EndToEndTest::kDefaultTimeoutMs),
         // TODO(hta): This timeout (120 seconds) is excessive.
         // https://bugs.webrtc.org/6830
         no_frames_to_wait_for_(no_frames_to_wait_for),
         expected_rotation_(rotation_to_test),
         payload_name_(payload_name),
-        encoder_(encoder),
-        decoder_(decoder),
+        encoder_(std::move(encoder)),
+        decoder_(std::move(decoder)),
         frame_counter_(0) {}
 
   void PerformTest() override {
@@ -1553,7 +1553,7 @@ class MultiStreamTest {
       receiver_transport->SetReceiver(sender_call->Receiver());
 
       for (size_t i = 0; i < kNumStreams; ++i)
-        encoders[i].reset(VP8Encoder::Create());
+        encoders[i] = VP8Encoder::Create();
 
       for (size_t i = 0; i < kNumStreams; ++i) {
         uint32_t ssrc = codec_settings[i].ssrc;
@@ -4327,7 +4327,7 @@ TEST_P(EndToEndTest, TestFlexfecRtpStatePreservation) {
     const int kNumFlexfecStreams = 1;
     CreateSendConfig(kNumVideoStreams, 0, kNumFlexfecStreams,
                      send_transport.get());
-    encoder = rtc::WrapUnique(VP8Encoder::Create());
+    encoder = VP8Encoder::Create();
     video_send_config_.encoder_settings.encoder = encoder.get();
     video_send_config_.encoder_settings.payload_name = "VP8";
     video_send_config_.encoder_settings.payload_type = kVideoSendPayloadType;
@@ -4994,8 +4994,8 @@ TEST_P(EndToEndLogTest, LogsEncodedFramesWhenRequested) {
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
-      encoder_.reset(VP8Encoder::Create());
-      decoder_.reset(VP8Decoder::Create());
+      encoder_ = VP8Encoder::Create();
+      decoder_ = VP8Decoder::Create();
 
       send_config->post_encode_callback = this;
       send_config->encoder_settings.payload_name = "VP8";

video/video_quality_test.cc

@@ -23,6 +23,7 @@
 #include "common_video/libyuv/include/webrtc_libyuv.h"
 #include "logging/rtc_event_log/output/rtc_event_log_output_file.h"
 #include "logging/rtc_event_log/rtc_event_log.h"
+#include "media/engine/internalencoderfactory.h"
 #include "media/engine/webrtcvideoengine.h"
 #include "modules/audio_mixer/audio_mixer_impl.h"
 #include "modules/rtp_rtcp/include/rtp_header_parser.h"
@@ -1129,35 +1130,6 @@ class VideoAnalyzer : public PacketReceiver,
   const int64_t start_ms_;
 };
 
-class Vp8EncoderFactory : public cricket::WebRtcVideoEncoderFactory {
- public:
-  Vp8EncoderFactory() {
-    supported_codecs_.push_back(cricket::VideoCodec("VP8"));
-  }
-  ~Vp8EncoderFactory() override { RTC_CHECK(live_encoders_.empty()); }
-
-  const std::vector<cricket::VideoCodec>& supported_codecs() const override {
-    return supported_codecs_;
-  }
-
-  VideoEncoder* CreateVideoEncoder(const cricket::VideoCodec& codec) override {
-    VideoEncoder* encoder = VP8Encoder::Create();
-    live_encoders_.insert(encoder);
-    return encoder;
-  }
-
-  void DestroyVideoEncoder(VideoEncoder* encoder) override {
-    auto it = live_encoders_.find(encoder);
-    RTC_CHECK(it != live_encoders_.end());
-    live_encoders_.erase(it);
-    delete encoder;
-  }
-
- private:
-  std::vector<cricket::VideoCodec> supported_codecs_;
-  std::set<VideoEncoder*> live_encoders_;
-};
-
 VideoQualityTest::VideoQualityTest()
     : clock_(Clock::GetRealTimeClock()), receive_logs_(0), send_logs_(0) {
   payload_type_map_ = test::CallTest::payload_type_map_;
@@ -1413,7 +1385,7 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
 
   int payload_type;
   if (params_.video.codec == "H264") {
-    video_encoder_.reset(H264Encoder::Create(cricket::VideoCodec("H264")));
+    video_encoder_ = H264Encoder::Create(cricket::VideoCodec("H264"));
     payload_type = kPayloadTypeH264;
   } else if (params_.video.codec == "VP8") {
     if (params_.screenshare.enabled && params_.ss.streams.size() > 1) {
@@ -1421,13 +1393,13 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
       // encoders usually can't natively do simulcast with different frame rates
       // for the different layers.
       video_encoder_.reset(
-          new SimulcastEncoderAdapter(new Vp8EncoderFactory()));
+          new SimulcastEncoderAdapter(new cricket::InternalEncoderFactory()));
     } else {
-      video_encoder_.reset(VP8Encoder::Create());
+      video_encoder_ = VP8Encoder::Create();
     }
     payload_type = kPayloadTypeVP8;
   } else if (params_.video.codec == "VP9") {
-    video_encoder_.reset(VP9Encoder::Create());
+    video_encoder_ = VP9Encoder::Create();
     payload_type = kPayloadTypeVP9;
   } else {
     RTC_NOTREACHED() << "Codec not supported!";