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}

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));
   }