Revert "Update internal SW codecs to return unique_ptrs"

This reverts commit 4fe6adc06a8524ac25f85260bfe392eb31dae6b4.

Reason for revert: Breaks android compile.

Original change's description:
> 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}

TBR=magjed@webrtc.org,sprang@webrtc.org,stefan@webrtc.org

Change-Id: If33c3a0ee0dfce63d105558a2897a472f0633306
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:7925
Reviewed-on: https://webrtc-review.googlesource.com/22540
Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20652}

modules/video_coding/codecs/h264/h264.cc

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

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

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

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

@@ -16,13 +16,11 @@ namespace webrtc {
 
 class TestH264Impl : public VideoCodecTest {
  protected:
-  std::unique_ptr<VideoEncoder> CreateEncoder() override {
+  VideoEncoder* CreateEncoder() override {
     return H264Encoder::Create(cricket::VideoCodec(cricket::kH264CodecName));
   }
 
-  std::unique_ptr<VideoDecoder> CreateDecoder() override {
-    return H264Decoder::Create();
-  }
+  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:
-  std::unique_ptr<VideoDecoder> CreateDecoder() override {
-    return rtc::MakeUnique<StereoDecoderAdapter>(decoder_factory_.get());
+  VideoDecoder* CreateDecoder() override {
+    return new StereoDecoderAdapter(decoder_factory_.get());
   }
 
-  std::unique_ptr<VideoEncoder> CreateEncoder() override {
-    return rtc::MakeUnique<StereoEncoderAdapter>(encoder_factory_.get());
+  VideoEncoder* CreateEncoder() override {
+    return new StereoEncoderAdapter(encoder_factory_.get());
   }
 
   VideoCodec codec_settings() override {
@@ -62,17 +62,15 @@ class TestStereoAdapter : public VideoCodecTest {
  private:
   void SetUp() override {
     EXPECT_CALL(*decoder_factory_, Die());
-    // The decoders/encoders will be owned by the caller of
-    // CreateVideoDecoder()/CreateVideoEncoder().
-    VideoDecoder* decoder1 = VP9Decoder::Create().release();
-    VideoDecoder* decoder2 = VP9Decoder::Create().release();
+    VideoDecoder* decoder1 = VP9Decoder::Create();
+    VideoDecoder* decoder2 = VP9Decoder::Create();
     EXPECT_CALL(*decoder_factory_, CreateVideoDecoderProxy(_))
         .WillOnce(Return(decoder1))
         .WillOnce(Return(decoder2));
 
     EXPECT_CALL(*encoder_factory_, Die());
-    VideoEncoder* encoder1 = VP9Encoder::Create().release();
-    VideoEncoder* encoder2 = VP9Encoder::Create().release();
+    VideoEncoder* encoder1 = VP9Encoder::Create();
+    VideoEncoder* encoder2 = VP9Encoder::Create();
     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_ = CreateEncoder();
-  decoder_ = CreateDecoder();
+  encoder_.reset(CreateEncoder());
+  decoder_.reset(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 std::unique_ptr<VideoEncoder> CreateEncoder() = 0;
-  virtual std::unique_ptr<VideoDecoder> CreateDecoder() = 0;
+  virtual VideoEncoder* CreateEncoder() = 0;
+  virtual VideoDecoder* CreateDecoder() = 0;
   virtual VideoCodec codec_settings() = 0;
 
   void SetUp() override;

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

@@ -13,22 +13,20 @@
 #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 std::unique_ptr<VP8Encoder> Create();
+  static VP8Encoder* Create();
 
   virtual ~VP8Encoder() {}
 };  // end of VP8Encoder class
 
 class VP8Decoder : public VideoDecoder {
  public:
-  static std::unique_ptr<VP8Decoder> Create();
+  static 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 std::unique_ptr<VP8Encoder> CreateEncoder() = 0;
-  virtual std::unique_ptr<VP8Decoder> CreateDecoder() = 0;
+  virtual VP8Encoder* CreateEncoder() = 0;
+  virtual VP8Decoder* CreateDecoder() = 0;
 
   void SetUp() override {
-    encoder_ = CreateEncoder();
-    decoder_ = CreateDecoder();
+    encoder_.reset(CreateEncoder());
+    decoder_.reset(CreateDecoder());
     SetUpCodec(kDefaultTemporalLayerProfile);
   }
 

modules/video_coding/codecs/vp8/simulcast_unittest.cc

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

modules/video_coding/codecs/vp8/vp8_impl.cc

@@ -30,7 +30,6 @@
 #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"
@@ -163,12 +162,12 @@ void GetPostProcParamsFromFieldTrialGroup(
 
 }  // namespace
 
-std::unique_ptr<VP8Encoder> VP8Encoder::Create() {
-  return rtc::MakeUnique<VP8EncoderImpl>();
+VP8Encoder* VP8Encoder::Create() {
+  return new VP8EncoderImpl();
 }
 
-std::unique_ptr<VP8Decoder> VP8Decoder::Create() {
-  return rtc::MakeUnique<VP8DecoderImpl>();
+VP8Decoder* VP8Decoder::Create() {
+  return new VP8DecoderImpl();
 }
 
 vpx_enc_frame_flags_t VP8EncoderImpl::EncodeFlags(

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

@@ -12,8 +12,6 @@
 #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 {
@@ -21,7 +19,7 @@ namespace webrtc {
 class VP9Encoder : public VideoEncoder {
  public:
   static bool IsSupported();
-  static std::unique_ptr<VP9Encoder> Create();
+  static VP9Encoder* Create();
 
   virtual ~VP9Encoder() {}
 };
@@ -29,7 +27,7 @@ class VP9Encoder : public VideoEncoder {
 class VP9Decoder : public VideoDecoder {
  public:
   static bool IsSupported();
-  static std::unique_ptr<VP9Decoder> Create();
+  static VP9Decoder* Create();
 
   virtual ~VP9Decoder() {}
 };

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

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

modules/video_coding/codecs/vp9/vp9_impl.cc

@@ -27,7 +27,6 @@
 #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"
@@ -53,8 +52,8 @@ bool VP9Encoder::IsSupported() {
   return true;
 }
 
-std::unique_ptr<VP9Encoder> VP9Encoder::Create() {
-  return rtc::MakeUnique<VP9EncoderImpl>();
+VP9Encoder* VP9Encoder::Create() {
+  return new VP9EncoderImpl();
 }
 
 void VP9EncoderImpl::EncoderOutputCodedPacketCallback(vpx_codec_cx_pkt* pkt,
@@ -842,8 +841,8 @@ bool VP9Decoder::IsSupported() {
   return true;
 }
 
-std::unique_ptr<VP9Decoder> VP9Decoder::Create() {
-  return rtc::MakeUnique<VP9DecoderImpl>();
+VP9Decoder* VP9Decoder::Create() {
+  return new VP9DecoderImpl();
 }
 
 VP9DecoderImpl::VP9DecoderImpl()

modules/video_coding/codecs/vp9/vp9_noop.cc

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