Simplify passing video codec factories in media engine

webrtc/media/engine/webrtcvideoengine_unittest.cc

 /*
  *  Copyright (c) 2004 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.
  */
 
@@ skipping 129 matching lines @@
 
 }  // namespace
 
 namespace cricket {
 class WebRtcVideoEngineTest : public ::testing::Test {
  public:
   WebRtcVideoEngineTest() : WebRtcVideoEngineTest("") {}
   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;
     for (const cricket::VideoCodec& codec : engine_codecs) {
       if (codec.name == "rtx") {
         int associated_payload_type;
         if (codec.GetParam(kCodecParamAssociatedPayloadType,
                            &associated_payload_type)) {
           default_apt_rtx_types_[associated_payload_type] = codec.id;
         }
       } else if (!codec_set && codec.name != "red" && codec.name != "ulpfec") {
         default_codec_ = codec;
         codec_set = true;
       }
     }
 
     RTC_DCHECK(codec_set);
   }
 
  protected:
   // Find the codec in the engine with the given name. The codec must be
   // 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);
 
   webrtc::test::ScopedFieldTrials override_field_trials_;
   webrtc::RtcEventLogNullImpl event_log_;
   // 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_;
 };
 
 TEST_F(WebRtcVideoEngineTest, AnnouncesVp9AccordingToBuildFlags) {
   bool claims_vp9_support = false;
   for (const cricket::VideoCodec& codec : engine_.codecs()) {
     if (codec.name == "VP9") {
       claims_vp9_support = true;
@@ skipping 67 matching lines @@
     }
   }
   FAIL() << "Video Rotation extension not in header-extension list.";
 }
 
 TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeCapturer) {
   // Allocate the capturer first to prevent early destruction before channel's
   // 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.
   const int id = 1;
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   parameters.extensions.push_back(
       RtpExtension(RtpExtension::kVideoRotationUri, id));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   // Set capturer.
   EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
 
   // Verify capturer has turned off applying rotation.
   EXPECT_FALSE(capturer.apply_rotation());
 
   // Verify removing header extension turns on applying rotation.
   parameters.extensions.clear();
   EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_TRUE(capturer.apply_rotation());
 }
 
 TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeAddSendStream) {
   // Allocate the capturer first to prevent early destruction before channel's
   // 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;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   parameters.extensions.push_back(
       RtpExtension(RtpExtension::kVideoRotationUri, id));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
 
   // Set capturer.
   EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
 
   // Verify capturer has turned off applying rotation.
   EXPECT_FALSE(capturer.apply_rotation());
 }
 
 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.
   EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
 
   // Verify capturer has turned on applying rotation.
   EXPECT_TRUE(capturer.apply_rotation());
 
   // Add CVO extension.
   const int id = 1;
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   parameters.codecs.push_back(GetEngineCodec("VP9"));
   parameters.extensions.push_back(
       RtpExtension(RtpExtension::kVideoRotationUri, id));
   // Also remove the first codec to trigger a codec change as well.
   parameters.codecs.erase(parameters.codecs.begin());
   EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   // Verify capturer has turned off applying rotation.
   EXPECT_FALSE(capturer.apply_rotation());
 
   // Verify removing header extension turns on applying rotation.
   parameters.extensions.clear();
   EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_TRUE(capturer.apply_rotation());
 }
 
 TEST_F(WebRtcVideoEngineTest, SetSendFailsBeforeSettingCodecs) {
-  engine_.Init();
   std::unique_ptr<VideoMediaChannel> channel(
       engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
 
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
 
   EXPECT_FALSE(channel->SetSend(true))
       << "Channel should not start without codecs.";
   EXPECT_TRUE(channel->SetSend(false))
       << "Channel should be stoppable even without set codecs.";
 }
 
 TEST_F(WebRtcVideoEngineTest, GetStatsWithoutSendCodecsSetDoesNotCrash) {
-  engine_.Init();
   std::unique_ptr<VideoMediaChannel> channel(
       engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
   VideoMediaInfo info;
   channel->GetStats(&info);
 }
 
 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));
   EXPECT_EQ(cricket::CS_RUNNING,
             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
   // (expecting a no-op).
   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
 // internally support, we still add an RTX codec for it.
 // TODO(deadbeef): Currently this test is only effective if WebRTC is
 // built with no internal H264 support. This test should be updated
 // if/when we start adding RTX codecs for unrecognized codec names.
 TEST_F(WebRtcVideoEngineTest, RtxCodecAddedForExternalCodec) {
   using webrtc::H264::ProfileLevelIdToString;
   using webrtc::H264::ProfileLevelId;
   using webrtc::H264::kLevel1;
   cricket::VideoCodec h264_constrained_baseline("H264");
   h264_constrained_baseline.params[kH264FmtpProfileLevelId] =
       *ProfileLevelIdToString(
           ProfileLevelId(webrtc::H264::kProfileConstrainedBaseline, kLevel1));
   cricket::VideoCodec h264_constrained_high("H264");
   h264_constrained_high.params[kH264FmtpProfileLevelId] =
       *ProfileLevelIdToString(
           ProfileLevelId(webrtc::H264::kProfileConstrainedHigh, kLevel1));
   cricket::VideoCodec h264_high("H264");
   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();
   // Now search for RTX codecs for them. Expect that they all have associated
   // RTX codecs.
   EXPECT_TRUE(HasRtxCodec(
       codecs, FindMatchingCodec(codecs, h264_constrained_baseline)->id));
   EXPECT_TRUE(HasRtxCodec(
       codecs, FindMatchingCodec(codecs, h264_constrained_high)->id));
   EXPECT_TRUE(HasRtxCodec(
       codecs, FindMatchingCodec(codecs, h264_high)->id));
 }
 
 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()));
   }
   ASSERT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_TRUE(channel->SetSend(true));
   FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
 
   EXPECT_EQ(use_external_encoder,
             stream->GetConfig().encoder_settings.full_overuse_time);
   // Remove stream previously added to free the external encoder instance.
   EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
 }
 
 TEST_F(WebRtcVideoEngineTest, EnablesFullEncoderTimeForExternalEncoders) {
   TestExtendedEncoderOveruse(true);
 }
 
 TEST_F(WebRtcVideoEngineTest, DisablesFullEncoderTimeForNonExternalEncoders) {
   TestExtendedEncoderOveruse(false);
 }
 
 #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)));
 }
 #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)));
 
   FakeVideoCapturer capturer;
   EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
   capturer.Start(cricket::VideoFormat(1280, 720,
                                       cricket::VideoFormat::FpsToInterval(60),
                                       cricket::FOURCC_I420));
   channel->SetSend(true);
@@ skipping 40 matching lines @@
     const std::string& name) {
   for (const cricket::VideoCodec& engine_codec : engine_.codecs()) {
     if (CodecNamesEq(name, engine_codec.name))
       return engine_codec;
   }
   // This point should never be reached.
   ADD_FAILURE() << "Unrecognized codec name: " << name;
   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));
 
   return channel;
 }
 
 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;
   parameters.codecs = codecs;
   EXPECT_TRUE(channel->SetRecvParameters(parameters));
 
   return channel;
 }
 
 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);
 
   EXPECT_TRUE(
       channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
   EXPECT_TRUE(channel->SetSend(true));
 
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, &capturer));
   EXPECT_EQ(cricket::CS_RUNNING,
             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;
   }
 
   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()));
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   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()));
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
 
   EXPECT_TRUE(
       channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
   EXPECT_TRUE(channel->SetSend(true));
 
   // Send a fake frame, or else the media engine will configure the simulcast
   // encoder adapter at a low-enough size that it'll only create a single
   // encoder layer.
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, &capturer));
   EXPECT_EQ(cricket::CS_RUNNING,
             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()));
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("H264"));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   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(
       1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420);
   cricket::FakeVideoCapturer capturer;
   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(
       channel->AddSendStream(cricket::CreateSimStreamParams("cname", ssrcs)));
 
   // Send a frame of 720p. This should trigger a "real" encoder initialization.
   cricket::VideoFormat format(
       1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420);
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel->SetVideoSend(ssrcs[0], true, nullptr, &capturer));
   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));
 }
 
 // Test that the FlexFEC field trial properly alters the output of
 // WebRtcVideoEngine::codecs(), for an existing |engine_| object.
 //
 // TODO(brandtr): Remove this test, when the FlexFEC field trial is gone.
 TEST_F(WebRtcVideoEngineTest,
        Flexfec03SupportedAsInternalCodecBehindFieldTrial) {
   auto is_flexfec = [](const VideoCodec& codec) {
     if (codec.name == "flexfec-03")
       return true;
     return false;
   };
 
   // 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));
 
   // FlexFEC is active with field trial.
   webrtc::test::ScopedFieldTrials override_field_trials_(
       "WebRTC-FlexFEC-03-Advertised/Enabled/");
   const std::vector<VideoCodec> codecs_after = engine_.codecs();
   EXPECT_NE(codecs_after.end(),
             std::find_if(codecs_after.begin(), codecs_after.end(), is_flexfec));
 }
 
 // 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);
   cricket::VideoCodec internal_codec = codecs.front();
   cricket::VideoCodec external_codec = codecs.back();
 
   // The external codec will appear last in the vector.
   EXPECT_EQ("VP8", internal_codec.name);
   EXPECT_EQ("FakeExternalCodec", external_codec.name);
 }
 
 // Test that an external codec that was added after the engine was initialized
 // 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.
 TEST_F(WebRtcVideoEngineTest, RegisterExternalH264DecoderIfSupported) {
   // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We
   // 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
     : public VideoMediaChannelTest<WebRtcVideoEngine, WebRtcVideoChannel> {
  protected:
   typedef VideoMediaChannelTest<WebRtcVideoEngine, WebRtcVideoChannel> Base;
 
   cricket::VideoCodec GetEngineCodec(const std::string& name) {
     for (const cricket::VideoCodec& engine_codec : engine_.codecs()) {
       if (CodecNamesEq(name, engine_codec.name))
         return engine_codec;
     }
     // This point should never be reached.
     ADD_FAILURE() << "Unrecognized codec name: " << name;
     return cricket::VideoCodec();
   }
 
   cricket::VideoCodec DefaultCodec() override { return GetEngineCodec("VP8"); }
 };
 
 // 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");
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(codec);
   channel->OnReadyToSend(true);
   channel->SetSend(true);
   ASSERT_TRUE(channel->SetSendParameters(parameters));
 
   cricket::FakeVideoCapturer capturer;
   VideoOptions options;
   EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, &options, &capturer));
 
   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));
   EXPECT_TRUE(capturer.CaptureFrame());
   // 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);
   EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, &options, &capturer));
   // 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) \
   TEST_F(WebRtcVideoChannelBaseTest, test) { Base::test(); }
 
 #define WEBRTC_DISABLED_BASE_TEST(test) \
   TEST_F(WebRtcVideoChannelBaseTest, DISABLED_##test) { Base::test(); }
 
 WEBRTC_BASE_TEST(SetSend);
 WEBRTC_BASE_TEST(SetSendWithoutCodecs);
@@ skipping 47 matching lines @@
   Base::TwoStreamsSendAndReceive(codec);
 }
 
 class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
  public:
   WebRtcVideoChannelTest() : WebRtcVideoChannelTest("") {}
   explicit WebRtcVideoChannelTest(const char* field_trials)
       : 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);
     last_ssrc_ = 123;
     send_parameters_.codecs = engine_.codecs();
     recv_parameters_.codecs = engine_.codecs();
     ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
   }
 
  protected:
@@ skipping 898 matching lines @@
 class Vp9SettingsTest : public WebRtcVideoChannelTest {
  public:
   Vp9SettingsTest() : Vp9SettingsTest("") {}
   explicit Vp9SettingsTest(const char* field_trials)
       : WebRtcVideoChannelTest(field_trials) {
     encoder_factory_.AddSupportedVideoCodecType("VP9");
   }
   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) {
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP9"));
   ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
   FakeVideoSendStream* stream = SetUpSimulcast(false, false);
 
   cricket::FakeVideoCapturer capturer;
@@ skipping 2486 matching lines @@
   TestReceiverLocalSsrcConfiguration(false);
 }
 
 TEST_F(WebRtcVideoChannelTest, ConfiguresLocalSsrcOnExistingReceivers) {
   TestReceiverLocalSsrcConfiguration(true);
 }
 
 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);
     last_ssrc_ = 123;
   }
 
  protected:
   void VerifySimulcastSettings(const VideoCodec& codec,
                                int capture_width,
                                int capture_height,
@@ skipping 135 matching lines @@
         fake_call_.GetVideoReceiveStreams().size();
     EXPECT_TRUE(channel_->AddRecvStream(sp));
     std::vector<FakeVideoReceiveStream*> streams =
         fake_call_.GetVideoReceiveStreams();
     EXPECT_EQ(num_streams + 1, streams.size());
     return streams[streams.size() - 1];
   }
 
   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_;
 };
 
 TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsWith2SimulcastStreams) {
   VerifySimulcastSettings(cricket::VideoCodec("VP8"), 640, 360, 2, 2, false,
                           true);
 }
 
@@ skipping 28 matching lines @@
 
 TEST_F(WebRtcVideoChannelSimulcastTest,
        NoSimulcastScreenshareWithoutConference) {
   webrtc::test::ScopedFieldTrials override_field_trials_(
       "WebRTC-SimulcastScreenshare/Enabled/");
   VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 1, true,
                           false);
 }
 
 }  // namespace cricket