diff --git a/media/base/fakemediaengine.h b/media/base/fakemediaengine.h
index 0b080af..921623c 100644
--- a/media/base/fakemediaengine.h
+++ b/media/base/fakemediaengine.h
@@ -774,13 +774,7 @@
 
 class FakeVoiceEngine : public FakeBaseEngine {
  public:
-  FakeVoiceEngine(webrtc::AudioDeviceModule* adm,
-                  const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
-                      audio_encoder_factory,
-                  const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
-                      audio_decoder_factory,
-                  rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
-                  rtc::scoped_refptr<webrtc::AudioProcessing> apm) {
+  FakeVoiceEngine() {
     // Add a fake audio codec. Note that the name must not be "" as there are
     // sanity checks against that.
     codecs_.push_back(AudioCodec(101, "fake_audio_codec", 0, 0, 1));
@@ -843,8 +837,6 @@
     codecs_.push_back(VideoCodec(0, "fake_video_codec"));
   }
 
-  void Init() {}
-
   bool SetOptions(const VideoOptions& options) {
     options_ = options;
     options_changed_ = true;
@@ -895,55 +887,50 @@
     public CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine> {
  public:
   FakeMediaEngine()
-      : CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine>(nullptr,
-                                                               nullptr,
-                                                               nullptr,
-                                                               nullptr,
-                                                               nullptr) {}
+      : CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine>(std::tuple<>(),
+                                                               std::tuple<>()) {
+  }
+
   virtual ~FakeMediaEngine() {}
 
   void SetAudioCodecs(const std::vector<AudioCodec>& codecs) {
-    voice_.SetCodecs(codecs);
+    voice().SetCodecs(codecs);
   }
   void SetVideoCodecs(const std::vector<VideoCodec>& codecs) {
-    video_.SetCodecs(codecs);
+    video().SetCodecs(codecs);
   }
 
   void SetAudioRtpHeaderExtensions(
       const std::vector<RtpExtension>& extensions) {
-    voice_.set_rtp_header_extensions(extensions);
+    voice().set_rtp_header_extensions(extensions);
   }
   void SetVideoRtpHeaderExtensions(
       const std::vector<RtpExtension>& extensions) {
-    video_.set_rtp_header_extensions(extensions);
+    video().set_rtp_header_extensions(extensions);
   }
 
   void SetAudioRtpHeaderExtensions(
       const std::vector<cricket::RtpHeaderExtension>& extensions) {
-    voice_.set_rtp_header_extensions(extensions);
+    voice().set_rtp_header_extensions(extensions);
   }
   void SetVideoRtpHeaderExtensions(
       const std::vector<cricket::RtpHeaderExtension>& extensions) {
-    video_.set_rtp_header_extensions(extensions);
+    video().set_rtp_header_extensions(extensions);
   }
 
   FakeVoiceMediaChannel* GetVoiceChannel(size_t index) {
-    return voice_.GetChannel(index);
+    return voice().GetChannel(index);
   }
   FakeVideoMediaChannel* GetVideoChannel(size_t index) {
-    return video_.GetChannel(index);
+    return video().GetChannel(index);
   }
 
-  bool capture() const { return video_.capture_; }
-  bool options_changed() const {
-    return video_.options_changed_;
-  }
-  void clear_options_changed() {
-    video_.options_changed_ = false;
-  }
+  bool capture() const { return video().capture_; }
+  bool options_changed() const { return video().options_changed_; }
+  void clear_options_changed() { video().options_changed_ = false; }
   void set_fail_create_channel(bool fail) {
-    voice_.set_fail_create_channel(fail);
-    video_.set_fail_create_channel(fail);
+    voice().set_fail_create_channel(fail);
+    video().set_fail_create_channel(fail);
   }
 };
 
diff --git a/media/base/mediaengine.h b/media/base/mediaengine.h
index 8ce6075..52a55f9 100644
--- a/media/base/mediaengine.h
+++ b/media/base/mediaengine.h
@@ -109,71 +109,65 @@
 
 // CompositeMediaEngine constructs a MediaEngine from separate
 // voice and video engine classes.
-template<class VOICE, class VIDEO>
+template <class VOICE, class VIDEO>
 class CompositeMediaEngine : public MediaEngineInterface {
  public:
-  CompositeMediaEngine(
-      webrtc::AudioDeviceModule* adm,
-      const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
-          audio_encoder_factory,
-      const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
-          audio_decoder_factory,
-      rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
-      rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing)
-      : voice_(adm,
-               audio_encoder_factory,
-               audio_decoder_factory,
-               audio_mixer,
-               audio_processing) {}
+  template <class... Args1, class... Args2>
+  CompositeMediaEngine(std::tuple<Args1...> first_args,
+                       std::tuple<Args2...> second_args)
+      : engines_(std::piecewise_construct,
+                 std::move(first_args),
+                 std::move(second_args)) {}
+
   virtual ~CompositeMediaEngine() {}
   virtual bool Init() {
-    voice_.Init();
-    video_.Init();
+    voice().Init();
     return true;
   }
 
   virtual rtc::scoped_refptr<webrtc::AudioState> GetAudioState() const {
-    return voice_.GetAudioState();
+    return voice().GetAudioState();
   }
   virtual VoiceMediaChannel* CreateChannel(webrtc::Call* call,
                                            const MediaConfig& config,
                                            const AudioOptions& options) {
-    return voice_.CreateChannel(call, config, options);
+    return voice().CreateChannel(call, config, options);
   }
   virtual VideoMediaChannel* CreateVideoChannel(webrtc::Call* call,
                                                 const MediaConfig& config,
                                                 const VideoOptions& options) {
-    return video_.CreateChannel(call, config, options);
+    return video().CreateChannel(call, config, options);
   }
 
-  virtual int GetInputLevel() {
-    return voice_.GetInputLevel();
-  }
+  virtual int GetInputLevel() { return voice().GetInputLevel(); }
   virtual const std::vector<AudioCodec>& audio_send_codecs() {
-    return voice_.send_codecs();
+    return voice().send_codecs();
   }
   virtual const std::vector<AudioCodec>& audio_recv_codecs() {
-    return voice_.recv_codecs();
+    return voice().recv_codecs();
   }
   virtual RtpCapabilities GetAudioCapabilities() {
-    return voice_.GetCapabilities();
+    return voice().GetCapabilities();
   }
-  virtual std::vector<VideoCodec> video_codecs() { return video_.codecs(); }
+  virtual std::vector<VideoCodec> video_codecs() { return video().codecs(); }
   virtual RtpCapabilities GetVideoCapabilities() {
-    return video_.GetCapabilities();
+    return video().GetCapabilities();
   }
 
   virtual bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes) {
-    return voice_.StartAecDump(file, max_size_bytes);
+    return voice().StartAecDump(file, max_size_bytes);
   }
 
-  virtual void StopAecDump() {
-    voice_.StopAecDump();
-  }
+  virtual void StopAecDump() { voice().StopAecDump(); }
 
  protected:
-  VOICE voice_;
-  VIDEO video_;
+  VOICE& voice() { return engines_.first; }
+  VIDEO& video() { return engines_.second; }
+  const VOICE& voice() const { return engines_.first; }
+  const VIDEO& video() const { return engines_.second; }
+
+ private:
+  std::pair<VOICE, VIDEO> engines_;
 };
 
 enum DataChannelType { DCT_NONE = 0, DCT_RTP = 1, DCT_SCTP = 2, DCT_QUIC = 3 };
diff --git a/media/base/videoengine_unittest.h b/media/base/videoengine_unittest.h
index 77062ec..64fda56 100644
--- a/media/base/videoengine_unittest.h
+++ b/media/base/videoengine_unittest.h
@@ -64,7 +64,9 @@
                               public sigslot::has_slots<> {
  protected:
   VideoMediaChannelTest<E, C>()
-      : call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))) {}
+      : call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))),
+        engine_(nullptr /* external_encoder_factory */,
+                nullptr /* external_decoder_factory */) {}
 
   virtual cricket::VideoCodec DefaultCodec() = 0;
 
@@ -73,7 +75,6 @@
   }
 
   virtual void SetUp() {
-    engine_.Init();
     cricket::MediaConfig media_config;
     // Disabling cpu overuse detection actually disables quality scaling too; it
     // implies DegradationPreference kMaintainResolution. Automatic scaling
diff --git a/media/engine/nullwebrtcvideoengine.h b/media/engine/nullwebrtcvideoengine.h
index 2fe87f4..9c687b9 100644
--- a/media/engine/nullwebrtcvideoengine.h
+++ b/media/engine/nullwebrtcvideoengine.h
@@ -33,31 +33,15 @@
 // CompositeMediaEngine.
 class NullWebRtcVideoEngine {
  public:
-  NullWebRtcVideoEngine() {}
-  ~NullWebRtcVideoEngine() {}
+  std::vector<VideoCodec> codecs() const { return std::vector<VideoCodec>(); }
 
-  void SetExternalDecoderFactory(WebRtcVideoDecoderFactory* decoder_factory) {}
-  void SetExternalEncoderFactory(WebRtcVideoEncoderFactory* encoder_factory) {}
-
-  void Init() {}
-
-  const std::vector<VideoCodec>& codecs() {
-    return codecs_;
-  }
-
-  RtpCapabilities GetCapabilities() {
-    RtpCapabilities capabilities;
-    return capabilities;
-  }
+  RtpCapabilities GetCapabilities() const { return RtpCapabilities(); }
 
   VideoMediaChannel* CreateChannel(webrtc::Call* call,
                                    const MediaConfig& config,
                                    const VideoOptions& options) {
     return nullptr;
   }
-
- private:
-  std::vector<VideoCodec> codecs_;
 };
 
 }  // namespace cricket
diff --git a/media/engine/nullwebrtcvideoengine_unittest.cc b/media/engine/nullwebrtcvideoengine_unittest.cc
index e1a2964..5fa7b01 100644
--- a/media/engine/nullwebrtcvideoengine_unittest.cc
+++ b/media/engine/nullwebrtcvideoengine_unittest.cc
@@ -25,18 +25,14 @@
       const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
           audio_encoder_factory,
       const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
-          audio_decoder_factory,
-      WebRtcVideoEncoderFactory* video_encoder_factory,
-      WebRtcVideoDecoderFactory* video_decoder_factory)
+          audio_decoder_factory)
       : CompositeMediaEngine<WebRtcVoiceEngine, NullWebRtcVideoEngine>(
-            adm,
-            audio_encoder_factory,
-            audio_decoder_factory,
-            nullptr,
-            webrtc::AudioProcessing::Create()) {
-    video_.SetExternalDecoderFactory(video_decoder_factory);
-    video_.SetExternalEncoderFactory(video_encoder_factory);
-  }
+            std::forward_as_tuple(adm,
+                                  audio_encoder_factory,
+                                  audio_decoder_factory,
+                                  nullptr,
+                                  webrtc::AudioProcessing::Create()),
+            std::forward_as_tuple()) {}
 };
 
 // Simple test to check if NullWebRtcVideoEngine implements the methods
@@ -44,7 +40,7 @@
 TEST(NullWebRtcVideoEngineTest, CheckInterface) {
   WebRtcMediaEngineNullVideo engine(
       nullptr, webrtc::MockAudioEncoderFactory::CreateUnusedFactory(),
-      webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr, nullptr);
+      webrtc::MockAudioDecoderFactory::CreateUnusedFactory());
   EXPECT_TRUE(engine.Init());
 }
 
diff --git a/media/engine/webrtcmediaengine.cc b/media/engine/webrtcmediaengine.cc
index 774b6b7..3a61ad7 100644
--- a/media/engine/webrtcmediaengine.cc
+++ b/media/engine/webrtcmediaengine.cc
@@ -24,65 +24,33 @@
 
 namespace cricket {
 
-class WebRtcMediaEngine2
-#ifdef HAVE_WEBRTC_VIDEO
-    : public CompositeMediaEngine<WebRtcVoiceEngine, WebRtcVideoEngine> {
-#else
-    : public CompositeMediaEngine<WebRtcVoiceEngine, NullWebRtcVideoEngine> {
-#endif
- public:
-  WebRtcMediaEngine2(
-      webrtc::AudioDeviceModule* adm,
-      const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
-          audio_encoder_factory,
-      const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
-          audio_decoder_factory,
-      WebRtcVideoEncoderFactory* video_encoder_factory,
-      WebRtcVideoDecoderFactory* video_decoder_factory,
-      rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
-      rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing)
-#ifdef HAVE_WEBRTC_VIDEO
-      : CompositeMediaEngine<WebRtcVoiceEngine, WebRtcVideoEngine>(
-            adm,
-            audio_encoder_factory,
-            audio_decoder_factory,
-            audio_mixer,
-            audio_processing){
-#else
-      : CompositeMediaEngine<WebRtcVoiceEngine, NullWebRtcVideoEngine>(
-            adm,
-            audio_encoder_factory,
-            audio_decoder_factory,
-            audio_mixer,
-            audio_processing) {
-#endif
-            video_.SetExternalDecoderFactory(video_decoder_factory);
-  video_.SetExternalEncoderFactory(video_encoder_factory);
-  }
-};
+namespace {
 
-}  // namespace cricket
-
-cricket::MediaEngineInterface* CreateWebRtcMediaEngine(
+MediaEngineInterface* CreateWebRtcMediaEngine(
     webrtc::AudioDeviceModule* adm,
     const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
         audio_encoder_factory,
     const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
         audio_decoder_factory,
-    cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
-    cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
+    WebRtcVideoEncoderFactory* video_encoder_factory,
+    WebRtcVideoDecoderFactory* video_decoder_factory,
     rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
     rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing) {
-  return new cricket::WebRtcMediaEngine2(
-      adm, audio_encoder_factory, audio_decoder_factory, video_encoder_factory,
-      video_decoder_factory, audio_mixer, audio_processing);
+#ifdef HAVE_WEBRTC_VIDEO
+  typedef WebRtcVideoEngine VideoEngine;
+  std::tuple<WebRtcVideoEncoderFactory*, WebRtcVideoDecoderFactory*> video_args(
+      video_encoder_factory, video_decoder_factory);
+#else
+  typedef NullWebRtcVideoEngine VideoEngine;
+  std::tuple<> video_args;
+#endif
+  return new CompositeMediaEngine<WebRtcVoiceEngine, VideoEngine>(
+      std::forward_as_tuple(adm, audio_encoder_factory, audio_decoder_factory,
+                            audio_mixer, audio_processing),
+      std::move(video_args));
 }
 
-void DestroyWebRtcMediaEngine(cricket::MediaEngineInterface* media_engine) {
-  delete media_engine;
-}
-
-namespace cricket {
+}  // namespace
 
 // TODO(ossu): Backwards-compatible interface. Will be deprecated once the
 // audio decoder factory is fully plumbed and used throughout WebRTC.
diff --git a/media/engine/webrtcvideoengine.cc b/media/engine/webrtcvideoengine.cc
index 284eb9a..a21f633 100644
--- a/media/engine/webrtcvideoengine.cc
+++ b/media/engine/webrtcvideoengine.cc
@@ -68,8 +68,6 @@
       bool is_conference_mode_screenshare) const = 0;
 
   virtual std::vector<VideoCodec> GetSupportedCodecs() const = 0;
-
-  virtual std::unique_ptr<EncoderFactoryAdapter> clone() const = 0;
 };
 
 class DecoderFactoryAdapter {
@@ -79,12 +77,13 @@
   virtual std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
       const VideoCodec& codec,
       const VideoDecoderParams& decoder_params) const = 0;
-
-  virtual std::unique_ptr<DecoderFactoryAdapter> clone() const = 0;
 };
 
 namespace {
 
+std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
+    const std::vector<VideoCodec>& input_codecs);
+
 // Wraps cricket::WebRtcVideoEncoderFactory* into common EncoderFactoryAdapter
 // interface.
 // TODO(magjed): Add wrapper class for future webrtc::VideoEncoderFactory
@@ -107,11 +106,6 @@
 
   std::vector<VideoCodec> GetSupportedCodecs() const override;
 
-  std::unique_ptr<EncoderFactoryAdapter> clone() const override {
-    return std::unique_ptr<EncoderFactoryAdapter>(
-        new CricketEncoderFactoryAdapter(*this));
-  }
-
   const std::unique_ptr<WebRtcVideoEncoderFactory> internal_encoder_factory_;
   WebRtcVideoEncoderFactory* const external_encoder_factory_;
 };
@@ -132,11 +126,6 @@
       const VideoCodec& codec,
       const VideoDecoderParams& decoder_params) const override;
 
-  std::unique_ptr<DecoderFactoryAdapter> clone() const override {
-    return std::unique_ptr<DecoderFactoryAdapter>(
-        new CricketDecoderFactoryAdapter(*this));
-  }
-
   const std::unique_ptr<WebRtcVideoDecoderFactory> internal_decoder_factory_;
   WebRtcVideoDecoderFactory* const external_decoder_factory_;
 };
@@ -402,12 +391,13 @@
   }
 }
 
-WebRtcVideoEngine::WebRtcVideoEngine()
-    : initialized_(false),
-      decoder_factory_(new CricketDecoderFactoryAdapter(
-          nullptr /* external_decoder_factory */)),
-      encoder_factory_(new CricketEncoderFactoryAdapter(
-          nullptr /* external_encoder_factory */)) {
+WebRtcVideoEngine::WebRtcVideoEngine(
+    WebRtcVideoEncoderFactory* external_video_encoder_factory,
+    WebRtcVideoDecoderFactory* external_video_decoder_factory)
+    : decoder_factory_(
+          new CricketDecoderFactoryAdapter(external_video_decoder_factory)),
+      encoder_factory_(
+          new CricketEncoderFactoryAdapter(external_video_encoder_factory)) {
   LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
 }
 
@@ -415,19 +405,13 @@
   LOG(LS_INFO) << "WebRtcVideoEngine::~WebRtcVideoEngine";
 }
 
-void WebRtcVideoEngine::Init() {
-  LOG(LS_INFO) << "WebRtcVideoEngine::Init";
-  initialized_ = true;
-}
-
 WebRtcVideoChannel* WebRtcVideoEngine::CreateChannel(
     webrtc::Call* call,
     const MediaConfig& config,
     const VideoOptions& options) {
-  RTC_DCHECK(initialized_);
   LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
-  return new WebRtcVideoChannel(call, config, options, *encoder_factory_,
-                                *decoder_factory_);
+  return new WebRtcVideoChannel(call, config, options, encoder_factory_.get(),
+                                decoder_factory_.get());
 }
 
 std::vector<VideoCodec> WebRtcVideoEngine::codecs() const {
@@ -460,23 +444,12 @@
   return capabilities;
 }
 
-void WebRtcVideoEngine::SetExternalDecoderFactory(
-    WebRtcVideoDecoderFactory* decoder_factory) {
-  RTC_DCHECK(!initialized_);
-  decoder_factory_.reset(new CricketDecoderFactoryAdapter(decoder_factory));
-}
-
-void WebRtcVideoEngine::SetExternalEncoderFactory(
-    WebRtcVideoEncoderFactory* encoder_factory) {
-  RTC_DCHECK(!initialized_);
-  encoder_factory_.reset(new CricketEncoderFactoryAdapter(encoder_factory));
-}
-
+namespace {
 // This function will assign dynamic payload types (in the range [96, 127]) to
 // the input codecs, and also add associated RTX codecs for recognized codecs
 // (VP8, VP9, H264, and RED). It will also add default feedback params to the
 // codecs.
-static std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
+std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
     const std::vector<VideoCodec>& input_codecs) {
   static const int kFirstDynamicPayloadType = 96;
   static const int kLastDynamicPayloadType = 127;
@@ -513,6 +486,7 @@
   }
   return output_codecs;
 }
+}  // namespace
 
 std::vector<VideoCodec> CricketEncoderFactoryAdapter::GetSupportedCodecs()
     const {
@@ -540,14 +514,14 @@
     webrtc::Call* call,
     const MediaConfig& config,
     const VideoOptions& options,
-    const EncoderFactoryAdapter& encoder_factory,
-    const DecoderFactoryAdapter& decoder_factory)
+    const EncoderFactoryAdapter* encoder_factory,
+    const DecoderFactoryAdapter* decoder_factory)
     : VideoMediaChannel(config),
       call_(call),
       unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
       video_config_(config.video),
-      encoder_factory_(encoder_factory.clone()),
-      decoder_factory_(decoder_factory.clone()),
+      encoder_factory_(encoder_factory),
+      decoder_factory_(decoder_factory),
       default_send_options_(options),
       last_stats_log_ms_(-1) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
@@ -1052,7 +1026,7 @@
   config.periodic_alr_bandwidth_probing =
       video_config_.periodic_alr_bandwidth_probing;
   WebRtcVideoSendStream* stream = new WebRtcVideoSendStream(
-      call_, sp, std::move(config), default_send_options_, *encoder_factory_,
+      call_, sp, std::move(config), default_send_options_, encoder_factory_,
       video_config_.enable_cpu_overuse_detection,
       bitrate_config_.max_bitrate_bps, send_codec_, send_rtp_extensions_,
       send_params_);
@@ -1163,7 +1137,7 @@
   config.sync_group = sp.sync_label;
 
   receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
-      call_, sp, std::move(config), *decoder_factory_, default_stream,
+      call_, sp, std::move(config), decoder_factory_, default_stream,
       recv_codecs_, flexfec_config);
 
   return true;
@@ -1502,7 +1476,7 @@
     const StreamParams& sp,
     webrtc::VideoSendStream::Config config,
     const VideoOptions& options,
-    const EncoderFactoryAdapter& encoder_factory,
+    const EncoderFactoryAdapter* encoder_factory,
     bool enable_cpu_overuse_detection,
     int max_bitrate_bps,
     const rtc::Optional<VideoCodecSettings>& codec_settings,
@@ -1516,7 +1490,7 @@
       call_(call),
       enable_cpu_overuse_detection_(enable_cpu_overuse_detection),
       source_(nullptr),
-      encoder_factory_(encoder_factory.clone()),
+      encoder_factory_(encoder_factory),
       stream_(nullptr),
       encoder_sink_(nullptr),
       parameters_(std::move(config), options, max_bitrate_bps, codec_settings),
@@ -2103,7 +2077,7 @@
     webrtc::Call* call,
     const StreamParams& sp,
     webrtc::VideoReceiveStream::Config config,
-    const DecoderFactoryAdapter& decoder_factory,
+    const DecoderFactoryAdapter* decoder_factory,
     bool default_stream,
     const std::vector<VideoCodecSettings>& recv_codecs,
     const webrtc::FlexfecReceiveStream::Config& flexfec_config)
@@ -2114,7 +2088,7 @@
       config_(std::move(config)),
       flexfec_config_(flexfec_config),
       flexfec_stream_(nullptr),
-      decoder_factory_(decoder_factory.clone()),
+      decoder_factory_(decoder_factory),
       sink_(NULL),
       first_frame_timestamp_(-1),
       estimated_remote_start_ntp_time_ms_(0) {
diff --git a/media/engine/webrtcvideoengine.h b/media/engine/webrtcvideoengine.h
index e61f422..8c8aefb 100644
--- a/media/engine/webrtcvideoengine.h
+++ b/media/engine/webrtcvideoengine.h
@@ -97,12 +97,13 @@
 // WebRtcVideoEngine is used for the new native WebRTC Video API (webrtc:1667).
 class WebRtcVideoEngine {
  public:
-  WebRtcVideoEngine();
+  // Video engine does not take ownership of the video codec factories and the
+  // caller needs to make sure they outlive the video engine. Internal SW video
+  // codecs will be added on top of the external codecs.
+  WebRtcVideoEngine(WebRtcVideoEncoderFactory* external_video_encoder_factory,
+                    WebRtcVideoDecoderFactory* external_video_decoder_factory);
   virtual ~WebRtcVideoEngine();
 
-  // Basic video engine implementation.
-  void Init();
-
   WebRtcVideoChannel* CreateChannel(webrtc::Call* call,
                                     const MediaConfig& config,
                                     const VideoOptions& options);
@@ -110,21 +111,9 @@
   std::vector<VideoCodec> codecs() const;
   RtpCapabilities GetCapabilities() const;
 
-  // Set a WebRtcVideoDecoderFactory for external decoding. Video engine does
-  // not take the ownership of |decoder_factory|. The caller needs to make sure
-  // that |decoder_factory| outlives the video engine.
-  void SetExternalDecoderFactory(WebRtcVideoDecoderFactory* decoder_factory);
-  // Set a WebRtcVideoEncoderFactory for external encoding. Video engine does
-  // not take the ownership of |encoder_factory|. The caller needs to make sure
-  // that |encoder_factory| outlives the video engine.
-  virtual void SetExternalEncoderFactory(
-      WebRtcVideoEncoderFactory* encoder_factory);
-
  private:
-  bool initialized_;
-
-  std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
-  std::unique_ptr<EncoderFactoryAdapter> encoder_factory_;
+  const std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
+  const std::unique_ptr<EncoderFactoryAdapter> encoder_factory_;
 };
 
 class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
@@ -132,8 +121,8 @@
   WebRtcVideoChannel(webrtc::Call* call,
                      const MediaConfig& config,
                      const VideoOptions& options,
-                     const EncoderFactoryAdapter& encoder_factory,
-                     const DecoderFactoryAdapter& decoder_factory);
+                     const EncoderFactoryAdapter* encoder_factory,
+                     const DecoderFactoryAdapter* decoder_factory);
   ~WebRtcVideoChannel() override;
 
   // VideoMediaChannel implementation
@@ -261,7 +250,7 @@
         const StreamParams& sp,
         webrtc::VideoSendStream::Config config,
         const VideoOptions& options,
-        const EncoderFactoryAdapter& encoder_factory,
+        const EncoderFactoryAdapter* encoder_factory,
         bool enable_cpu_overuse_detection,
         int max_bitrate_bps,
         const rtc::Optional<VideoCodecSettings>& codec_settings,
@@ -338,9 +327,9 @@
     webrtc::Call* const call_;
     const bool enable_cpu_overuse_detection_;
     rtc::VideoSourceInterface<webrtc::VideoFrame>* source_
-        RTC_ACCESS_ON(&thread_checker_);
-    std::unique_ptr<EncoderFactoryAdapter> encoder_factory_
-        RTC_ACCESS_ON(&thread_checker_);
+        ACCESS_ON(&thread_checker_);
+    const EncoderFactoryAdapter* const encoder_factory_
+        ACCESS_ON(&thread_checker_);
 
     webrtc::VideoSendStream* stream_ RTC_ACCESS_ON(&thread_checker_);
     rtc::VideoSinkInterface<webrtc::VideoFrame>* encoder_sink_
@@ -371,7 +360,7 @@
         webrtc::Call* call,
         const StreamParams& sp,
         webrtc::VideoReceiveStream::Config config,
-        const DecoderFactoryAdapter& decoder_factory,
+        const DecoderFactoryAdapter* decoder_factory,
         bool default_stream,
         const std::vector<VideoCodecSettings>& recv_codecs,
         const webrtc::FlexfecReceiveStream::Config& flexfec_config);
@@ -432,7 +421,7 @@
     webrtc::FlexfecReceiveStream::Config flexfec_config_;
     webrtc::FlexfecReceiveStream* flexfec_stream_;
 
-    std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
+    const DecoderFactoryAdapter* decoder_factory_;
     DecoderMap allocated_decoders_;
 
     rtc::CriticalSection sink_lock_;
@@ -496,8 +485,8 @@
   rtc::Optional<VideoCodecSettings> send_codec_;
   rtc::Optional<std::vector<webrtc::RtpExtension>> send_rtp_extensions_;
 
-  std::unique_ptr<EncoderFactoryAdapter> encoder_factory_;
-  std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
+  const EncoderFactoryAdapter* const encoder_factory_;
+  const DecoderFactoryAdapter* const decoder_factory_;
   std::vector<VideoCodecSettings> recv_codecs_;
   std::vector<webrtc::RtpExtension> recv_rtp_extensions_;
   // See reason for keeping track of the FlexFEC payload type separately in
diff --git a/media/engine/webrtcvideoengine_unittest.cc b/media/engine/webrtcvideoengine_unittest.cc
index 1306082..683ccd5 100644
--- a/media/engine/webrtcvideoengine_unittest.cc
+++ b/media/engine/webrtcvideoengine_unittest.cc
@@ -147,7 +147,7 @@
   explicit WebRtcVideoEngineTest(const char* field_trials)
       : override_field_trials_(field_trials),
         call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))),
-        engine_() {
+        engine_(&encoder_factory_, &decoder_factory_) {
     std::vector<VideoCodec> engine_codecs = engine_.codecs();
     RTC_DCHECK(!engine_codecs.empty());
     bool codec_set = false;
@@ -172,11 +172,9 @@
   // present.
   cricket::VideoCodec GetEngineCodec(const std::string& name);
 
-  VideoMediaChannel* SetUpForExternalEncoderFactory(
-      cricket::WebRtcVideoEncoderFactory* encoder_factory);
+  VideoMediaChannel* SetUpForExternalEncoderFactory();
 
   VideoMediaChannel* SetUpForExternalDecoderFactory(
-      cricket::WebRtcVideoDecoderFactory* decoder_factory,
       const std::vector<VideoCodec>& codecs);
 
   void TestExtendedEncoderOveruse(bool use_external_encoder);
@@ -186,6 +184,8 @@
   // Used in WebRtcVideoEngineVoiceTest, but defined here so it's properly
   // initialized when the constructor is called.
   std::unique_ptr<webrtc::Call> call_;
+  cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
+  cricket::FakeWebRtcVideoDecoderFactory decoder_factory_;
   WebRtcVideoEngine engine_;
   VideoCodec default_codec_;
   std::map<int, int> default_apt_rtx_types_;
@@ -273,11 +273,9 @@
   // dtor is called.
   cricket::FakeVideoCapturer capturer;
 
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("VP8");
+  encoder_factory_.AddSupportedVideoCodecType("VP8");
 
-  std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalEncoderFactory(&encoder_factory));
+  std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
 
   // Add CVO extension.
@@ -305,11 +303,9 @@
   // dtor is called.
   cricket::FakeVideoCapturer capturer;
 
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("VP8");
+  encoder_factory_.AddSupportedVideoCodecType("VP8");
 
-  std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalEncoderFactory(&encoder_factory));
+  std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
   // Add CVO extension.
   const int id = 1;
   cricket::VideoSendParameters parameters;
@@ -329,12 +325,10 @@
 TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionAfterCapturer) {
   cricket::FakeVideoCapturer capturer;
 
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("VP8");
-  encoder_factory.AddSupportedVideoCodecType("VP9");
+  encoder_factory_.AddSupportedVideoCodecType("VP8");
+  encoder_factory_.AddSupportedVideoCodecType("VP9");
 
-  std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalEncoderFactory(&encoder_factory));
+  std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
 
   // Set capturer.
@@ -364,7 +358,6 @@
 }
 
 TEST_F(WebRtcVideoEngineTest, SetSendFailsBeforeSettingCodecs) {
-  engine_.Init();
   std::unique_ptr<VideoMediaChannel> channel(
       engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
 
@@ -377,7 +370,6 @@
 }
 
 TEST_F(WebRtcVideoEngineTest, GetStatsWithoutSendCodecsSetDoesNotCrash) {
-  engine_.Init();
   std::unique_ptr<VideoMediaChannel> channel(
       engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
@@ -386,16 +378,14 @@
 }
 
 TEST_F(WebRtcVideoEngineTest, UseExternalFactoryForVp8WhenSupported) {
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("VP8");
+  encoder_factory_.AddSupportedVideoCodecType("VP8");
 
-  std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalEncoderFactory(&encoder_factory));
+  std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
   channel->OnReadyToSend(true);
 
   EXPECT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
-  EXPECT_EQ(0, encoder_factory.GetNumCreatedEncoders());
+  EXPECT_EQ(0, encoder_factory_.GetNumCreatedEncoders());
   EXPECT_TRUE(channel->SetSend(true));
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
@@ -403,11 +393,11 @@
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(capturer.CaptureFrame());
   // Sending one frame will have allocate the encoder.
-  ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(1));
-  EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0,
+  ASSERT_TRUE(encoder_factory_.WaitForCreatedVideoEncoders(1));
+  EXPECT_TRUE_WAIT(encoder_factory_.encoders()[0]->GetNumEncodedFrames() > 0,
                    kTimeout);
 
-  int num_created_encoders = encoder_factory.GetNumCreatedEncoders();
+  int num_created_encoders = encoder_factory_.GetNumCreatedEncoders();
   EXPECT_EQ(num_created_encoders, 1);
 
   // Setting codecs of the same type should not reallocate any encoders
@@ -415,11 +405,11 @@
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
-  EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders());
+  EXPECT_EQ(num_created_encoders, encoder_factory_.GetNumCreatedEncoders());
 
   // Remove stream previously added to free the external encoder instance.
   EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
-  EXPECT_EQ(0u, encoder_factory.encoders().size());
+  EXPECT_EQ(0u, encoder_factory_.encoders().size());
 }
 
 // Test that when an external encoder factory supports a codec we don't
@@ -443,12 +433,9 @@
   h264_high.params[kH264FmtpProfileLevelId] = *ProfileLevelIdToString(
       ProfileLevelId(webrtc::H264::kProfileHigh, kLevel1));
 
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodec(h264_constrained_baseline);
-  encoder_factory.AddSupportedVideoCodec(h264_constrained_high);
-  encoder_factory.AddSupportedVideoCodec(h264_high);
-  engine_.SetExternalEncoderFactory(&encoder_factory);
-  engine_.Init();
+  encoder_factory_.AddSupportedVideoCodec(h264_constrained_baseline);
+  encoder_factory_.AddSupportedVideoCodec(h264_constrained_high);
+  encoder_factory_.AddSupportedVideoCodec(h264_high);
 
   // First figure out what payload types the test codecs got assigned.
   const std::vector<cricket::VideoCodec> codecs = engine_.codecs();
@@ -464,15 +451,13 @@
 
 void WebRtcVideoEngineTest::TestExtendedEncoderOveruse(
     bool use_external_encoder) {
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("VP8");
   std::unique_ptr<VideoMediaChannel> channel;
   FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_));
   call_.reset(fake_call);
   if (use_external_encoder) {
-    channel.reset(SetUpForExternalEncoderFactory(&encoder_factory));
+    encoder_factory_.AddSupportedVideoCodecType("VP8");
+    channel.reset(SetUpForExternalEncoderFactory());
   } else {
-    engine_.Init();
     channel.reset(
         engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
   }
@@ -500,11 +485,9 @@
 
 #if !defined(RTC_DISABLE_VP9)
 TEST_F(WebRtcVideoEngineTest, CanConstructDecoderForVp9EncoderFactory) {
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("VP9");
+  encoder_factory_.AddSupportedVideoCodecType("VP9");
 
-  std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalEncoderFactory(&encoder_factory));
+  std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
 
   EXPECT_TRUE(
       channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -512,12 +495,10 @@
 #endif  // !defined(RTC_DISABLE_VP9)
 
 TEST_F(WebRtcVideoEngineTest, PropagatesInputFrameTimestamp) {
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("VP8");
+  encoder_factory_.AddSupportedVideoCodecType("VP8");
   FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_));
   call_.reset(fake_call);
-  std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalEncoderFactory(&encoder_factory));
+  std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
 
   EXPECT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -578,16 +559,12 @@
   return cricket::VideoCodec();
 }
 
-VideoMediaChannel* WebRtcVideoEngineTest::SetUpForExternalEncoderFactory(
-    cricket::WebRtcVideoEncoderFactory* encoder_factory) {
-  engine_.SetExternalEncoderFactory(encoder_factory);
-  engine_.Init();
-
+VideoMediaChannel* WebRtcVideoEngineTest::SetUpForExternalEncoderFactory() {
   VideoMediaChannel* channel =
       engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions());
   cricket::VideoSendParameters parameters;
   // We need to look up the codec in the engine to get the correct payload type.
-  for (const VideoCodec& codec : encoder_factory->supported_codecs())
+  for (const VideoCodec& codec : encoder_factory_.supported_codecs())
     parameters.codecs.push_back(GetEngineCodec(codec.name));
 
   EXPECT_TRUE(channel->SetSendParameters(parameters));
@@ -596,11 +573,7 @@
 }
 
 VideoMediaChannel* WebRtcVideoEngineTest::SetUpForExternalDecoderFactory(
-    cricket::WebRtcVideoDecoderFactory* decoder_factory,
     const std::vector<VideoCodec>& codecs) {
-  engine_.SetExternalDecoderFactory(decoder_factory);
-  engine_.Init();
-
   VideoMediaChannel* channel =
       engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions());
   cricket::VideoRecvParameters parameters;
@@ -611,11 +584,9 @@
 }
 
 TEST_F(WebRtcVideoEngineTest, UsesSimulcastAdapterForVp8Factories) {
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("VP8");
+  encoder_factory_.AddSupportedVideoCodecType("VP8");
 
-  std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalEncoderFactory(&encoder_factory));
+  std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
 
   std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
 
@@ -629,15 +600,15 @@
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(capturer.CaptureFrame());
 
-  ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(2));
+  ASSERT_TRUE(encoder_factory_.WaitForCreatedVideoEncoders(2));
 
   // Verify that encoders are configured for simulcast through adapter
   // (increasing resolution and only configured to send one stream each).
   int prev_width = -1;
-  for (size_t i = 0; i < encoder_factory.encoders().size(); ++i) {
-    ASSERT_TRUE(encoder_factory.encoders()[i]->WaitForInitEncode());
+  for (size_t i = 0; i < encoder_factory_.encoders().size(); ++i) {
+    ASSERT_TRUE(encoder_factory_.encoders()[i]->WaitForInitEncode());
     webrtc::VideoCodec codec_settings =
-        encoder_factory.encoders()[i]->GetCodecSettings();
+        encoder_factory_.encoders()[i]->GetCodecSettings();
     EXPECT_EQ(0, codec_settings.numberOfSimulcastStreams);
     EXPECT_GT(codec_settings.width, prev_width);
     prev_width = codec_settings.width;
@@ -646,33 +617,27 @@
   EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, nullptr));
 
   channel.reset();
-  ASSERT_EQ(0u, encoder_factory.encoders().size());
+  ASSERT_EQ(0u, encoder_factory_.encoders().size());
 }
 
 TEST_F(WebRtcVideoEngineTest, ChannelWithExternalH264CanChangeToInternalVp8) {
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("H264");
+  encoder_factory_.AddSupportedVideoCodecType("H264");
 
-  std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalEncoderFactory(&encoder_factory));
+  std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
 
   EXPECT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
-  ASSERT_EQ(1u, encoder_factory.encoders().size());
+  ASSERT_EQ(1u, encoder_factory_.encoders().size());
 
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
-  ASSERT_EQ(0u, encoder_factory.encoders().size());
+  ASSERT_EQ(0u, encoder_factory_.encoders().size());
 }
 
 TEST_F(WebRtcVideoEngineTest,
        DontUseExternalEncoderFactoryForUnsupportedCodecs) {
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("H264");
-
-  engine_.SetExternalEncoderFactory(&encoder_factory);
-  engine_.Init();
+  encoder_factory_.AddSupportedVideoCodecType("H264");
 
   std::unique_ptr<VideoMediaChannel> channel(
       engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
@@ -683,17 +648,13 @@
   EXPECT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
   // Make sure DestroyVideoEncoder was called on the factory.
-  ASSERT_EQ(0u, encoder_factory.encoders().size());
+  ASSERT_EQ(0u, encoder_factory_.encoders().size());
 }
 
 TEST_F(WebRtcVideoEngineTest,
        UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("VP8");
-  encoder_factory.AddSupportedVideoCodecType("H264");
-
-  engine_.SetExternalEncoderFactory(&encoder_factory);
-  engine_.Init();
+  encoder_factory_.AddSupportedVideoCodecType("VP8");
+  encoder_factory_.AddSupportedVideoCodecType("H264");
 
   std::unique_ptr<VideoMediaChannel> channel(
       engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
@@ -716,24 +677,20 @@
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(capturer.CaptureFrame());
 
-  ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(2));
-  ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode());
+  ASSERT_TRUE(encoder_factory_.WaitForCreatedVideoEncoders(2));
+  ASSERT_TRUE(encoder_factory_.encoders()[0]->WaitForInitEncode());
   EXPECT_EQ(webrtc::kVideoCodecVP8,
-            encoder_factory.encoders()[0]->GetCodecSettings().codecType);
+            encoder_factory_.encoders()[0]->GetCodecSettings().codecType);
 
   channel.reset();
   // Make sure DestroyVideoEncoder was called on the factory.
-  EXPECT_EQ(0u, encoder_factory.encoders().size());
+  EXPECT_EQ(0u, encoder_factory_.encoders().size());
 }
 
 TEST_F(WebRtcVideoEngineTest,
        DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) {
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("VP8");
-  encoder_factory.AddSupportedVideoCodecType("H264");
-
-  engine_.SetExternalEncoderFactory(&encoder_factory);
-  engine_.Init();
+  encoder_factory_.AddSupportedVideoCodecType("VP8");
+  encoder_factory_.AddSupportedVideoCodecType("H264");
 
   std::unique_ptr<VideoMediaChannel> channel(
       engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
@@ -743,7 +700,7 @@
 
   EXPECT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
-  ASSERT_EQ(1u, encoder_factory.encoders().size());
+  ASSERT_EQ(1u, encoder_factory_.encoders().size());
 
   // Send a frame of 720p. This should trigger a "real" encoder initialization.
   cricket::VideoFormat format(
@@ -752,21 +709,19 @@
   EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
   EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(format));
   EXPECT_TRUE(capturer.CaptureFrame());
-  ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode());
+  ASSERT_TRUE(encoder_factory_.encoders()[0]->WaitForInitEncode());
   EXPECT_EQ(webrtc::kVideoCodecH264,
-            encoder_factory.encoders()[0]->GetCodecSettings().codecType);
+            encoder_factory_.encoders()[0]->GetCodecSettings().codecType);
 
   channel.reset();
   // Make sure DestroyVideoEncoder was called on the factory.
-  ASSERT_EQ(0u, encoder_factory.encoders().size());
+  ASSERT_EQ(0u, encoder_factory_.encoders().size());
 }
 
 TEST_F(WebRtcVideoEngineTest, SimulcastDisabledForH264) {
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("H264");
+  encoder_factory_.AddSupportedVideoCodecType("H264");
 
-  std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalEncoderFactory(&encoder_factory));
+  std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
 
   const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
   EXPECT_TRUE(
@@ -780,9 +735,9 @@
   EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(format));
   EXPECT_TRUE(capturer.CaptureFrame());
 
-  ASSERT_EQ(1u, encoder_factory.encoders().size());
-  FakeWebRtcVideoEncoder* encoder = encoder_factory.encoders()[0];
-  ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode());
+  ASSERT_EQ(1u, encoder_factory_.encoders().size());
+  FakeWebRtcVideoEncoder* encoder = encoder_factory_.encoders()[0];
+  ASSERT_TRUE(encoder_factory_.encoders()[0]->WaitForInitEncode());
   EXPECT_EQ(webrtc::kVideoCodecH264, encoder->GetCodecSettings().codecType);
   EXPECT_EQ(1u, encoder->GetCodecSettings().numberOfSimulcastStreams);
   EXPECT_TRUE(channel->SetVideoSend(ssrcs[0], true, nullptr, nullptr));
@@ -801,7 +756,6 @@
   };
 
   // FlexFEC is not active without field trial.
-  engine_.Init();
   const std::vector<VideoCodec> codecs_before = engine_.codecs();
   EXPECT_EQ(codecs_before.end(), std::find_if(codecs_before.begin(),
                                               codecs_before.end(), is_flexfec));
@@ -816,10 +770,7 @@
 
 // Test that external codecs are added to the end of the supported codec list.
 TEST_F(WebRtcVideoEngineTest, ReportSupportedExternalCodecs) {
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("FakeExternalCodec");
-  engine_.SetExternalEncoderFactory(&encoder_factory);
-  engine_.Init();
+  encoder_factory_.AddSupportedVideoCodecType("FakeExternalCodec");
 
   std::vector<cricket::VideoCodec> codecs(engine_.codecs());
   ASSERT_GE(codecs.size(), 2u);
@@ -835,42 +786,38 @@
 // does show up in the codec list after it was added.
 TEST_F(WebRtcVideoEngineTest, ReportSupportedExternalCodecsWithAddedCodec) {
   // Set up external encoder factory with first codec, and initialize engine.
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("FakeExternalCodec1");
-  engine_.SetExternalEncoderFactory(&encoder_factory);
-  engine_.Init();
+  encoder_factory_.AddSupportedVideoCodecType("FakeExternalCodec1");
 
   // The first external codec will appear last in the vector.
   std::vector<cricket::VideoCodec> codecs_before(engine_.codecs());
   EXPECT_EQ("FakeExternalCodec1", codecs_before.back().name);
 
   // Add second codec.
-  encoder_factory.AddSupportedVideoCodecType("FakeExternalCodec2");
+  encoder_factory_.AddSupportedVideoCodecType("FakeExternalCodec2");
   std::vector<cricket::VideoCodec> codecs_after(engine_.codecs());
   EXPECT_EQ(codecs_before.size() + 1, codecs_after.size());
   EXPECT_EQ("FakeExternalCodec2", codecs_after.back().name);
 }
 
 TEST_F(WebRtcVideoEngineTest, RegisterExternalDecodersIfSupported) {
-  cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
-  decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
+  decoder_factory_.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
   cricket::VideoRecvParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
 
   std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
+      SetUpForExternalDecoderFactory(parameters.codecs));
 
   EXPECT_TRUE(
       channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
-  ASSERT_EQ(1u, decoder_factory.decoders().size());
+  ASSERT_EQ(1u, decoder_factory_.decoders().size());
 
   // Setting codecs of the same type should not reallocate the decoder.
   EXPECT_TRUE(channel->SetRecvParameters(parameters));
-  EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders());
+  EXPECT_EQ(1, decoder_factory_.GetNumCreatedDecoders());
 
   // Remove stream previously added to free the external decoder instance.
   EXPECT_TRUE(channel->RemoveRecvStream(kSsrc));
-  EXPECT_EQ(0u, decoder_factory.decoders().size());
+  EXPECT_EQ(0u, decoder_factory_.decoders().size());
 }
 
 // Verifies that we can set up decoders that are not internally supported.
@@ -879,20 +826,17 @@
   // can't even query the WebRtcVideoDecoderFactory for supported codecs.
   // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
   // codecs.
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("H264");
-  engine_.SetExternalEncoderFactory(&encoder_factory);
-  cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
-  decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
+  encoder_factory_.AddSupportedVideoCodecType("H264");
+  decoder_factory_.AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
   std::vector<cricket::VideoCodec> codecs;
   codecs.push_back(GetEngineCodec("H264"));
 
   std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalDecoderFactory(&decoder_factory, codecs));
+      SetUpForExternalDecoderFactory(codecs));
 
   EXPECT_TRUE(
       channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
-  ASSERT_EQ(1u, decoder_factory.decoders().size());
+  ASSERT_EQ(1u, decoder_factory_.decoders().size());
 }
 
 class WebRtcVideoChannelBaseTest
@@ -915,31 +859,28 @@
 
 // Verifies that id given in stream params is passed to the decoder factory.
 TEST_F(WebRtcVideoEngineTest, StreamParamsIdPassedToDecoderFactory) {
-  cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
-  decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
+  decoder_factory_.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
   cricket::VideoRecvParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
 
   std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
+      SetUpForExternalDecoderFactory(parameters.codecs));
 
   StreamParams sp = cricket::StreamParams::CreateLegacy(kSsrc);
   sp.id = "FakeStreamParamsId";
   EXPECT_TRUE(channel->AddRecvStream(sp));
-  EXPECT_EQ(1u, decoder_factory.decoders().size());
+  EXPECT_EQ(1u, decoder_factory_.decoders().size());
 
-  std::vector<cricket::VideoDecoderParams> params = decoder_factory.params();
+  std::vector<cricket::VideoDecoderParams> params = decoder_factory_.params();
   ASSERT_EQ(1u, params.size());
   EXPECT_EQ(sp.id, params[0].receive_stream_id);
 }
 
 TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) {
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("VP8");
+  encoder_factory_.AddSupportedVideoCodecType("VP8");
   std::unique_ptr<FakeCall> fake_call(
       new FakeCall(webrtc::Call::Config(&event_log_)));
-  std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalEncoderFactory(&encoder_factory));
+  std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
   ASSERT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
   cricket::VideoCodec codec = GetEngineCodec("VP8");
@@ -956,14 +897,14 @@
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(capturer.CaptureFrame());
-  ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(1));
+  ASSERT_TRUE(encoder_factory_.WaitForCreatedVideoEncoders(1));
   EXPECT_EQ(webrtc::kRealtimeVideo,
-            encoder_factory.encoders().back()->GetCodecSettings().mode);
+            encoder_factory_.encoders().back()->GetCodecSettings().mode);
 
   EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, &options, &capturer));
   EXPECT_TRUE(capturer.CaptureFrame());
   // No change in content type, keep current encoder.
-  EXPECT_EQ(1, encoder_factory.GetNumCreatedEncoders());
+  EXPECT_EQ(1, encoder_factory_.GetNumCreatedEncoders());
 
   options.is_screencast.emplace(true);
   EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, &options, &capturer));
@@ -971,14 +912,14 @@
   // Change to screen content, recreate encoder. For the simulcast encoder
   // adapter case, this will result in two calls since InitEncode triggers a
   // a new instance.
-  ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(2));
+  ASSERT_TRUE(encoder_factory_.WaitForCreatedVideoEncoders(2));
   EXPECT_EQ(webrtc::kScreensharing,
-            encoder_factory.encoders().back()->GetCodecSettings().mode);
+            encoder_factory_.encoders().back()->GetCodecSettings().mode);
 
   EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, &options, &capturer));
   EXPECT_TRUE(capturer.CaptureFrame());
   // Still screen content, no need to update encoder.
-  EXPECT_EQ(2, encoder_factory.GetNumCreatedEncoders());
+  EXPECT_EQ(2, encoder_factory_.GetNumCreatedEncoders());
 
   options.is_screencast.emplace(false);
   options.video_noise_reduction.emplace(false);
@@ -986,13 +927,13 @@
   // Change back to regular video content, update encoder. Also change
   // a non |is_screencast| option just to verify it doesn't affect recreation.
   EXPECT_TRUE(capturer.CaptureFrame());
-  ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(3));
+  ASSERT_TRUE(encoder_factory_.WaitForCreatedVideoEncoders(3));
   EXPECT_EQ(webrtc::kRealtimeVideo,
-            encoder_factory.encoders().back()->GetCodecSettings().mode);
+            encoder_factory_.encoders().back()->GetCodecSettings().mode);
 
   // Remove stream previously added to free the external encoder instance.
   EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
-  EXPECT_EQ(0u, encoder_factory.encoders().size());
+  EXPECT_EQ(0u, encoder_factory_.encoders().size());
 }
 
 #define WEBRTC_BASE_TEST(test) \
@@ -1060,7 +1001,6 @@
       : WebRtcVideoEngineTest(field_trials), last_ssrc_(0) {}
   void SetUp() override {
     fake_call_.reset(new FakeCall(webrtc::Call::Config(&event_log_)));
-    engine_.Init();
     channel_.reset(engine_.CreateChannel(fake_call_.get(), GetMediaConfig(),
                                          VideoOptions()));
     channel_->OnReadyToSend(true);
@@ -1979,19 +1919,11 @@
   virtual ~Vp9SettingsTest() {}
 
  protected:
-  void SetUp() override {
-    engine_.SetExternalEncoderFactory(&encoder_factory_);
-
-    WebRtcVideoChannelTest::SetUp();
-  }
-
   void TearDown() override {
     // Remove references to encoder_factory_ since this will be destroyed
     // before channel_ and engine_.
     ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
   }
-
-  cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
 };
 
 TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
@@ -4498,10 +4430,11 @@
 class WebRtcVideoChannelSimulcastTest : public testing::Test {
  public:
   WebRtcVideoChannelSimulcastTest()
-      : fake_call_(webrtc::Call::Config(&event_log_)), last_ssrc_(0) {}
+      : fake_call_(webrtc::Call::Config(&event_log_)),
+        engine_(&encoder_factory_, &decoder_factory_),
+        last_ssrc_(0) {}
 
   void SetUp() override {
-    engine_.Init();
     channel_.reset(
         engine_.CreateChannel(&fake_call_, GetMediaConfig(), VideoOptions()));
     channel_->OnReadyToSend(true);
@@ -4657,6 +4590,8 @@
 
   webrtc::RtcEventLogNullImpl event_log_;
   FakeCall fake_call_;
+  cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
+  cricket::FakeWebRtcVideoDecoderFactory decoder_factory_;
   WebRtcVideoEngine engine_;
   std::unique_ptr<VideoMediaChannel> channel_;
   uint32_t last_ssrc_;