Remove webrtc::VideoEncoderFactory

webrtc/media/engine/simulcast_encoder_adapter_unittest.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <array>
 #include <memory>
 #include <vector>
 
 #include "webrtc/common_video/include/video_frame_buffer.h"
-#include "webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h"
-#include "webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h"
+#include "webrtc/media/engine/simulcast_encoder_adapter.h"
+#include "webrtc/modules/video_coding/codecs/vp8/simulcast_test_utility.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/test/gmock.h"
 
 namespace webrtc {
 namespace testing {
 
 class TestSimulcastEncoderAdapter : public TestVp8Simulcast {
  public:
-  TestSimulcastEncoderAdapter()
-      : TestVp8Simulcast(new SimulcastEncoderAdapter(new Vp8EncoderFactory()),
-                         VP8Decoder::Create()) {}
+  TestSimulcastEncoderAdapter() : factory_(new Vp8EncoderFactory()) {}
 
  protected:
-  class Vp8EncoderFactory : public VideoEncoderFactory {
+  class Vp8EncoderFactory : public cricket::WebRtcVideoEncoderFactory {
    public:
-    VideoEncoder* Create() override { return VP8Encoder::Create(); }
+    Vp8EncoderFactory() {
+      supported_codecs_.push_back(cricket::VideoCodec("VP8"));
+    }
 
-    void Destroy(VideoEncoder* encoder) override { delete encoder; }
+    const std::vector<cricket::VideoCodec>& supported_codecs() const override {
+      return supported_codecs_;
+    }
+
+    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_;
   };
 
-  virtual void SetUp() { TestVp8Simulcast::SetUp(); }
-  virtual void TearDown() { TestVp8Simulcast::TearDown(); }
+  VP8Encoder* CreateEncoder() override {
+    return new SimulcastEncoderAdapter(factory_.get());
+  }
+  VP8Decoder* CreateDecoder() override { return VP8Decoder::Create(); }
+
+ private:
+  std::unique_ptr<Vp8EncoderFactory> factory_;
 };
 
 TEST_F(TestSimulcastEncoderAdapter, TestKeyFrameRequestsOnAllStreams) {
   TestVp8Simulcast::TestKeyFrameRequestsOnAllStreams();
 }
 
 TEST_F(TestSimulcastEncoderAdapter, TestPaddingAllStreams) {
   TestVp8Simulcast::TestPaddingAllStreams();
 }
 
@@ skipping 108 matching lines @@
 
  private:
   bool supports_native_handle_ = false;
   int32_t init_encode_return_value_ = 0;
   BitrateAllocation last_set_bitrate_;
 
   VideoCodec codec_;
   EncodedImageCallback* callback_;
 };
 
-class MockVideoEncoderFactory : public VideoEncoderFactory {
+class MockVideoEncoderFactory : public cricket::WebRtcVideoEncoderFactory {
  public:
-  VideoEncoder* Create() override {
-    MockVideoEncoder* encoder = new
-        ::testing::NiceMock<MockVideoEncoder>();
+  MockVideoEncoderFactory() {
+    supported_codecs_.push_back(cricket::VideoCodec("VP8"));
+  }
+
+  const std::vector<cricket::VideoCodec>& supported_codecs() const override {
+    return supported_codecs_;
+  }
+
+  VideoEncoder* CreateVideoEncoder(const cricket::VideoCodec& codec) override {
+    MockVideoEncoder* encoder = new ::testing::NiceMock<MockVideoEncoder>();
     encoder->set_init_encode_return_value(init_encode_return_value_);
     const char* encoder_name = encoder_names_.empty()
                                    ? "codec_implementation_name"
                                    : encoder_names_[encoders_.size()];
     ON_CALL(*encoder, ImplementationName()).WillByDefault(Return(encoder_name));
     encoders_.push_back(encoder);
     return encoder;
   }
 
-  void Destroy(VideoEncoder* encoder) override {
+  void DestroyVideoEncoder(VideoEncoder* encoder) override {
     for (size_t i = 0; i < encoders_.size(); ++i) {
       if (encoders_[i] == encoder) {
         encoders_.erase(encoders_.begin() + i);
         break;
       }
     }
     delete encoder;
   }
 
   virtual ~MockVideoEncoderFactory() {}
 
   const std::vector<MockVideoEncoder*>& encoders() const { return encoders_; }
   void SetEncoderNames(const std::vector<const char*>& encoder_names) {
     encoder_names_ = encoder_names;
   }
   void set_init_encode_return_value(int32_t value) {
     init_encode_return_value_ = value;
   }
 
  private:
+  std::vector<cricket::VideoCodec> supported_codecs_;
   int32_t init_encode_return_value_ = 0;
   std::vector<MockVideoEncoder*> encoders_;
   std::vector<const char*> encoder_names_;
 };
 
 class TestSimulcastEncoderAdapterFakeHelper {
  public:
   TestSimulcastEncoderAdapterFakeHelper()
       : factory_(new MockVideoEncoderFactory()) {}
 
   // Can only be called once as the SimulcastEncoderAdapter will take the
   // ownership of |factory_|.
   VP8Encoder* CreateMockEncoderAdapter() {
-    return new SimulcastEncoderAdapter(factory_);
+    return new SimulcastEncoderAdapter(factory_.get());
   }
 
   void ExpectCallSetChannelParameters(uint32_t packetLoss, int64_t rtt) {
     EXPECT_TRUE(!factory_->encoders().empty());
     for (size_t i = 0; i < factory_->encoders().size(); ++i) {
       EXPECT_CALL(*factory_->encoders()[i],
                   SetChannelParameters(packetLoss, rtt))
           .Times(1);
     }
   }
 
-  MockVideoEncoderFactory* factory() { return factory_; }
+  MockVideoEncoderFactory* factory() { return factory_.get(); }
 
  private:
-  MockVideoEncoderFactory* factory_;
+  std::unique_ptr<MockVideoEncoderFactory> factory_;
 };
 
 static const int kTestTemporalLayerProfile[3] = {3, 2, 1};
 
 class TestSimulcastEncoderAdapterFake : public ::testing::Test,
                                         public EncodedImageCallback {
  public:
   TestSimulcastEncoderAdapterFake()
       : helper_(new TestSimulcastEncoderAdapterFakeHelper()),
         adapter_(helper_->CreateMockEncoderAdapter()),
@@ skipping 546 matching lines @@
   codec_.numberOfSimulcastStreams = 3;
   helper_->factory()->set_init_encode_return_value(
       WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE,
             adapter_->InitEncode(&codec_, 1, 1200));
   EXPECT_TRUE(helper_->factory()->encoders().empty());
 }
 
 }  // namespace testing
 }  // namespace webrtc