Remove webrtc::VideoEncoderFactory

webrtc/modules/video_coding/codecs/vp8/simulcast_test_utility.h

 /*
  *  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.
  */
 
-#ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_UNITTEST_H_
-#define WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_UNITTEST_H_
+#ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_TEST_UTILITY_H_
+#define WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_TEST_UTILITY_H_
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "webrtc/api/video/i420_buffer.h"
 #include "webrtc/api/video/video_frame.h"
 #include "webrtc/common_video/include/video_frame.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
@@ skipping 131 matching lines @@
     Decoded(decoded_image);
   }
   int DecodedFrames() { return decoded_frames_; }
 
  private:
   int decoded_frames_;
 };
 
 class TestVp8Simulcast : public ::testing::Test {
  public:
-  TestVp8Simulcast(VP8Encoder* encoder, VP8Decoder* decoder)
-      : encoder_(encoder), decoder_(decoder) {}
-
   static void SetPlane(uint8_t* data,
                        uint8_t value,
                        int width,
                        int height,
                        int stride) {
     for (int i = 0; i < height; i++, data += stride) {
       // Setting allocated area to zero - setting only image size to
       // requested values - will make it easier to distinguish between image
       // size and frame size (accounting for stride).
       memset(data, value, width);
@@ skipping 60 matching lines @@
     stream->width = width;
     stream->height = height;
     stream->maxBitrate = max_bitrate;
     stream->minBitrate = min_bitrate;
     stream->targetBitrate = target_bitrate;
     stream->numberOfTemporalLayers = num_temporal_layers;
     stream->qpMax = 45;
   }
 
  protected:
-  void SetUp() override { SetUpCodec(kDefaultTemporalLayerProfile); }
+  virtual VP8Encoder* CreateEncoder() = 0;
+  virtual VP8Decoder* CreateDecoder() = 0;
+
+  void SetUp() override {
+    encoder_.reset(CreateEncoder());
+    decoder_.reset(CreateDecoder());
+    SetUpCodec(kDefaultTemporalLayerProfile);
+  }
 
   void TearDown() override {
     encoder_->Release();
     decoder_->Release();
+    encoder_.reset();
+    decoder_.reset();
   }
 
   void SetUpCodec(const int* temporal_layer_profile) {
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback_);
     decoder_->RegisterDecodeCompleteCallback(&decoder_callback_);
     DefaultSettings(&settings_, temporal_layer_profile);
     SetUpRateAllocator();
     EXPECT_EQ(0, encoder_->InitEncode(&settings_, 1, 1200));
     EXPECT_EQ(0, decoder_->InitDecode(&settings_, 1));
     input_buffer_ = I420Buffer::Create(kDefaultWidth, kDefaultHeight);
@@ skipping 477 matching lines @@
   MockDecodedImageCallback decoder_callback_;
   VideoCodec settings_;
   rtc::scoped_refptr<I420Buffer> input_buffer_;
   std::unique_ptr<VideoFrame> input_frame_;
   std::unique_ptr<SimulcastRateAllocator> rate_allocator_;
 };
 
 }  // namespace testing
 }  // namespace webrtc
 
-#endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_UNITTEST_H_
+#endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_TEST_UTILITY_H_