diff --git a/media/engine/fake_webrtc_call.cc b/media/engine/fake_webrtc_call.cc
index f5a1f693e4..894f69fedc 100644
--- a/media/engine/fake_webrtc_call.cc
+++ b/media/engine/fake_webrtc_call.cc
@@ -259,11 +259,8 @@ void FakeVideoSendStream::OnFrame(const webrtc::VideoFrame& frame) {
               encoder_config_);
     } else {
       webrtc::VideoEncoder::EncoderInfo encoder_info;
-      auto factory = rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-          encoder_config_.video_format.name, encoder_config_.max_qp,
-          encoder_config_.content_type ==
-              webrtc::VideoEncoderConfig::ContentType::kScreen,
-          encoder_config_.legacy_conference_mode, encoder_info);
+      auto factory =
+          rtc::make_ref_counted<cricket::EncoderStreamFactory>(encoder_info);
 
       video_streams_ = factory->CreateEncoderStreams(
           env_.field_trials(), frame.width(), frame.height(), encoder_config_);
@@ -302,10 +299,8 @@ void FakeVideoSendStream::ReconfigureVideoEncoder(
         env_.field_trials(), width, height, config);
   } else {
     webrtc::VideoEncoder::EncoderInfo encoder_info;
-    auto factory = rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-        config.video_format.name, config.max_qp,
-        config.content_type == webrtc::VideoEncoderConfig::ContentType::kScreen,
-        config.legacy_conference_mode, encoder_info);
+    auto factory =
+        rtc::make_ref_counted<cricket::EncoderStreamFactory>(encoder_info);
 
     video_streams_ = factory->CreateEncoderStreams(env_.field_trials(), width,
                                                    height, config);
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index 75031fe445..ac7d0f884a 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -2240,21 +2240,10 @@ WebRtcVideoSendChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig(
   // Ensure frame dropping is always enabled.
   encoder_config.frame_drop_enabled = true;
 
-  int max_qp;
-  switch (encoder_config.codec_type) {
-    case webrtc::kVideoCodecH264:
-    case webrtc::kVideoCodecH265:
-      max_qp = kDefaultVideoMaxQpH26x;
-      break;
-    case webrtc::kVideoCodecVP8:
-    case webrtc::kVideoCodecVP9:
-    case webrtc::kVideoCodecAV1:
-    case webrtc::kVideoCodecGeneric:
-      max_qp = kDefaultVideoMaxQpVpx;
-      break;
+  int max_qp = -1;
+  if (codec.GetParam(kCodecParamMaxQuantization, &max_qp) && max_qp > 0) {
+    encoder_config.max_qp = max_qp;
   }
-  codec.GetParam(kCodecParamMaxQuantization, &max_qp);
-  encoder_config.max_qp = max_qp;
 
   return encoder_config;
 }
diff --git a/modules/video_coding/BUILD.gn b/modules/video_coding/BUILD.gn
index 606a49f9b7..7b8ac7c4c9 100644
--- a/modules/video_coding/BUILD.gn
+++ b/modules/video_coding/BUILD.gn
@@ -442,6 +442,7 @@ rtc_library("video_coding_utility") {
     "../../rtc_base/system:file_wrapper",
     "../../rtc_base/system:no_unique_address",
     "../../rtc_base/task_utils:repeating_task",
+    "../../video/config:encoder_config",
     "../rtp_rtcp:rtp_rtcp_format",
     "svc:scalability_mode_util",
     "//third_party/abseil-cpp/absl/numeric:bits",
diff --git a/modules/video_coding/utility/simulcast_utility.cc b/modules/video_coding/utility/simulcast_utility.cc
index 824f4b0eac..b637e7fdd0 100644
--- a/modules/video_coding/utility/simulcast_utility.cc
+++ b/modules/video_coding/utility/simulcast_utility.cc
@@ -75,7 +75,18 @@ bool SimulcastUtility::ValidSimulcastParameters(const VideoCodec& codec,
 
 bool SimulcastUtility::IsConferenceModeScreenshare(const VideoCodec& codec) {
   return codec.mode == VideoCodecMode::kScreensharing &&
-         codec.legacy_conference_mode;
+         codec.legacy_conference_mode &&
+         (codec.codecType == kVideoCodecVP8 ||
+          codec.codecType == kVideoCodecH264);
+}
+
+bool SimulcastUtility::IsConferenceModeScreenshare(
+    const VideoEncoderConfig& encoder_config) {
+  return encoder_config.content_type ==
+             VideoEncoderConfig::ContentType::kScreen &&
+         encoder_config.legacy_conference_mode &&
+         (encoder_config.codec_type == webrtc::VideoCodecType::kVideoCodecVP8 ||
+          encoder_config.codec_type == webrtc::VideoCodecType::kVideoCodecH264);
 }
 
 int SimulcastUtility::NumberOfTemporalLayers(const VideoCodec& codec,
diff --git a/modules/video_coding/utility/simulcast_utility.h b/modules/video_coding/utility/simulcast_utility.h
index e25a594360..4270f9181d 100644
--- a/modules/video_coding/utility/simulcast_utility.h
+++ b/modules/video_coding/utility/simulcast_utility.h
@@ -14,6 +14,7 @@
 #include <stdint.h>
 
 #include "api/video_codecs/video_codec.h"
+#include "video/config/video_encoder_config.h"
 
 namespace webrtc {
 
@@ -26,6 +27,8 @@ class SimulcastUtility {
   static int NumberOfTemporalLayers(const VideoCodec& codec, int spatial_id);
   // TODO(sprang): Remove this hack when ScreenshareLayers is gone.
   static bool IsConferenceModeScreenshare(const VideoCodec& codec);
+  static bool IsConferenceModeScreenshare(
+      const VideoEncoderConfig& encoder_config);
 };
 
 }  // namespace webrtc
diff --git a/rtc_tools/rtp_generator/rtp_generator.cc b/rtc_tools/rtp_generator/rtp_generator.cc
index 0c6d3e3a48..ade169ac94 100644
--- a/rtc_tools/rtp_generator/rtp_generator.cc
+++ b/rtc_tools/rtp_generator/rtp_generator.cc
@@ -237,11 +237,6 @@ RtpGenerator::RtpGenerator(const RtpGeneratorOptions& options)
       encoder_config.simulcast_layers[i].max_framerate = send_config.video_fps;
     }
 
-    encoder_config.video_stream_factory =
-        rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-            video_config.rtp.payload_name, /*max qp*/ 56, /*screencast*/ false,
-            /*screenshare enabled*/ false, encoder_info);
-
     // Setup the fake video stream for this.
     std::unique_ptr<test::FrameGeneratorCapturer> frame_generator =
         std::make_unique<test::FrameGeneratorCapturer>(
diff --git a/test/scenario/video_stream.cc b/test/scenario/video_stream.cc
index 188e89fd8c..eb403f9309 100644
--- a/test/scenario/video_stream.cc
+++ b/test/scenario/video_stream.cc
@@ -57,23 +57,7 @@ uint8_t CodecTypeToPayloadType(VideoCodecType codec_type) {
   }
   return {};
 }
-std::string CodecTypeToCodecName(VideoCodecType codec_type) {
-  switch (codec_type) {
-    case VideoCodecType::kVideoCodecGeneric:
-      return "";
-    case VideoCodecType::kVideoCodecVP8:
-      return cricket::kVp8CodecName;
-    case VideoCodecType::kVideoCodecVP9:
-      return cricket::kVp9CodecName;
-    case VideoCodecType::kVideoCodecH264:
-      return cricket::kH264CodecName;
-    case VideoCodecType::kVideoCodecH265:
-      return cricket::kH265CodecName;
-    default:
-      RTC_DCHECK_NOTREACHED();
-  }
-  return {};
-}
+
 VideoEncoderConfig::ContentType ConvertContentType(
     VideoStreamConfig::Encoder::ContentType content_type) {
   switch (content_type) {
@@ -224,19 +208,6 @@ VideoEncoderConfig CreateVideoEncoderConfig(VideoStreamConfig config) {
       std::vector<VideoStream>(encoder_config.number_of_streams);
   encoder_config.min_transmit_bitrate_bps = config.stream.pad_to_rate.bps();
 
-  std::string cricket_codec = CodecTypeToCodecName(config.encoder.codec);
-  if (!cricket_codec.empty()) {
-    bool screenshare = config.encoder.content_type ==
-                       VideoStreamConfig::Encoder::ContentType::kScreen;
-    encoder_config.video_stream_factory =
-        rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-            cricket_codec, cricket::kDefaultVideoMaxQpVpx, screenshare,
-            screenshare, encoder_info);
-  } else {
-    encoder_config.video_stream_factory =
-        rtc::make_ref_counted<DefaultVideoStreamFactory>();
-  }
-
   // TODO(srte): Base this on encoder capabilities.
   encoder_config.max_bitrate_bps =
       config.encoder.max_data_rate.value_or(DataRate::KilobitsPerSec(10000))
diff --git a/video/config/encoder_stream_factory.cc b/video/config/encoder_stream_factory.cc
index 733e398cf2..936e7f25bd 100644
--- a/video/config/encoder_stream_factory.cc
+++ b/video/config/encoder_stream_factory.cc
@@ -22,6 +22,7 @@
 #include "media/base/media_constants.h"
 #include "media/base/video_adapter.h"
 #include "modules/video_coding/codecs/vp9/svc_config.h"
+#include "modules/video_coding/utility/simulcast_utility.h"
 #include "rtc_base/experiments/min_video_bitrate_experiment.h"
 #include "rtc_base/experiments/normalize_simulcast_size_experiment.h"
 #include "rtc_base/logging.h"
@@ -60,10 +61,10 @@ bool IsScaleFactorsPowerOfTwo(const webrtc::VideoEncoderConfig& config) {
   return true;
 }
 
-bool IsTemporalLayersSupported(const std::string& codec_name) {
-  return absl::EqualsIgnoreCase(codec_name, kVp8CodecName) ||
-         absl::EqualsIgnoreCase(codec_name, kVp9CodecName) ||
-         absl::EqualsIgnoreCase(codec_name, kAv1CodecName);
+bool IsTemporalLayersSupported(webrtc::VideoCodecType codec_type) {
+  return codec_type == webrtc::VideoCodecType::kVideoCodecVP8 ||
+         codec_type == webrtc::VideoCodecType::kVideoCodecVP9 ||
+         codec_type == webrtc::VideoCodecType::kVideoCodecAV1;
 }
 
 size_t FindRequiredActiveLayers(
@@ -97,23 +98,25 @@ static int GetMaxDefaultVideoBitrateKbps(int width,
   return max_bitrate;
 }
 
+int GetDefaultMaxQp(webrtc::VideoCodecType codec_type) {
+  switch (codec_type) {
+    case webrtc::kVideoCodecH264:
+    case webrtc::kVideoCodecH265:
+      return kDefaultVideoMaxQpH26x;
+    case webrtc::kVideoCodecVP8:
+    case webrtc::kVideoCodecVP9:
+    case webrtc::kVideoCodecAV1:
+    case webrtc::kVideoCodecGeneric:
+      return kDefaultVideoMaxQpVpx;
+  }
+}
+
 }  // namespace
 
-// TODO(bugs.webrtc.org/8785): Consider removing max_qp as member of
-// EncoderStreamFactory and instead set this value individually for each stream
-// in the VideoEncoderConfig.simulcast_layers.
 EncoderStreamFactory::EncoderStreamFactory(
-    std::string codec_name,
-    int max_qp,
-    bool is_screenshare,
-    bool conference_mode,
     const webrtc::VideoEncoder::EncoderInfo& encoder_info,
     absl::optional<webrtc::VideoSourceRestrictions> restrictions)
-    : codec_name_(codec_name),
-      max_qp_(max_qp),
-      is_screenshare_(is_screenshare),
-      conference_mode_(conference_mode),
-      encoder_info_requested_resolution_alignment_(
+    : encoder_info_requested_resolution_alignment_(
           encoder_info.requested_resolution_alignment),
       restrictions_(restrictions) {}
 
@@ -146,9 +149,8 @@ std::vector<webrtc::VideoStream> EncoderStreamFactory::CreateEncoderStreams(
     }
   }
 
-  if (is_simulcast || ((absl::EqualsIgnoreCase(codec_name_, kVp8CodecName) ||
-                        absl::EqualsIgnoreCase(codec_name_, kH264CodecName)) &&
-                       is_screenshare_ && conference_mode_)) {
+  if (is_simulcast ||
+      webrtc::SimulcastUtility::IsConferenceModeScreenshare(encoder_config)) {
     return CreateSimulcastOrConferenceModeScreenshareStreams(
         trials, frame_width, frame_height, encoder_config,
         experimental_min_bitrate);
@@ -164,7 +166,8 @@ EncoderStreamFactory::CreateDefaultVideoStreams(
     int height,
     const webrtc::VideoEncoderConfig& encoder_config,
     const absl::optional<webrtc::DataRate>& experimental_min_bitrate) const {
-  std::vector<webrtc::VideoStream> layers;
+  bool is_screencast = encoder_config.content_type ==
+                       webrtc::VideoEncoderConfig::ContentType::kScreen;
 
   // The max bitrate specified by the API.
   // - `encoder_config.simulcast_layers[0].max_bitrate_bps` comes from the first
@@ -187,8 +190,7 @@ EncoderStreamFactory::CreateDefaultVideoStreams(
   int max_bitrate_bps =
       api_max_bitrate_bps.has_value()
           ? *api_max_bitrate_bps
-          : GetMaxDefaultVideoBitrateKbps(width, height, is_screenshare_) *
-                1000;
+          : GetMaxDefaultVideoBitrateKbps(width, height, is_screencast) * 1000;
 
   int min_bitrate_bps =
       experimental_min_bitrate
@@ -234,7 +236,7 @@ EncoderStreamFactory::CreateDefaultVideoStreams(
         kMinLayerSize);
   }
 
-  if (absl::EqualsIgnoreCase(codec_name_, kVp9CodecName)) {
+  if (encoder_config.codec_type == webrtc::VideoCodecType::kVideoCodecVP9) {
     RTC_DCHECK(encoder_config.encoder_specific_settings);
     // Use VP9 SVC layering from codec settings which might be initialized
     // though field trial in ConfigureVideoEncoderSettings.
@@ -256,7 +258,7 @@ EncoderStreamFactory::CreateDefaultVideoStreams(
       std::vector<webrtc::SpatialLayer> svc_layers =
           webrtc::GetSvcConfig(width, height, max_framerate,
                                /*first_active_layer=*/0, num_spatial_layers,
-                               *layer.num_temporal_layers, is_screenshare_);
+                               *layer.num_temporal_layers, is_screencast);
       int sum_max_bitrates_kbps = 0;
       for (const webrtc::SpatialLayer& spatial_layer : svc_layers) {
         sum_max_bitrates_kbps += spatial_layer.maxBitrate;
@@ -282,10 +284,15 @@ EncoderStreamFactory::CreateDefaultVideoStreams(
         encoder_config.simulcast_layers[0].target_bitrate_bps, max_bitrate_bps);
   }
   layer.max_bitrate_bps = max_bitrate_bps;
-  layer.max_qp = max_qp_;
   layer.bitrate_priority = encoder_config.bitrate_priority;
 
-  if (IsTemporalLayersSupported(codec_name_)) {
+  if (encoder_config.max_qp > 0) {
+    layer.max_qp = encoder_config.max_qp;
+  } else {
+    layer.max_qp = GetDefaultMaxQp(encoder_config.codec_type);
+  }
+
+  if (IsTemporalLayersSupported(encoder_config.codec_type)) {
     // Use configured number of temporal layers if set.
     if (encoder_config.simulcast_layers[0].num_temporal_layers) {
       layer.num_temporal_layers =
@@ -293,8 +300,7 @@ EncoderStreamFactory::CreateDefaultVideoStreams(
     }
   }
   layer.scalability_mode = encoder_config.simulcast_layers[0].scalability_mode;
-  layers.push_back(layer);
-  return layers;
+  return {layer};
 }
 
 std::vector<webrtc::VideoStream>
@@ -304,17 +310,20 @@ EncoderStreamFactory::CreateSimulcastOrConferenceModeScreenshareStreams(
     int height,
     const webrtc::VideoEncoderConfig& encoder_config,
     const absl::optional<webrtc::DataRate>& experimental_min_bitrate) const {
+  bool is_screencast = encoder_config.content_type ==
+                       webrtc::VideoEncoderConfig::ContentType::kScreen;
   std::vector<webrtc::VideoStream> layers;
 
-  const bool temporal_layers_supported = IsTemporalLayersSupported(codec_name_);
+  const bool temporal_layers_supported =
+      IsTemporalLayersSupported(encoder_config.codec_type);
   // Use legacy simulcast screenshare if conference mode is explicitly enabled
   // or use the regular simulcast configuration path which is generic.
-  layers = GetSimulcastConfig(FindRequiredActiveLayers(encoder_config),
-                              encoder_config.number_of_streams, width, height,
-                              encoder_config.bitrate_priority, max_qp_,
-                              is_screenshare_ && conference_mode_,
-                              temporal_layers_supported, trials,
-                              encoder_config.codec_type);
+  layers = GetSimulcastConfig(
+      FindRequiredActiveLayers(encoder_config),
+      encoder_config.number_of_streams, width, height,
+      encoder_config.bitrate_priority, encoder_config.max_qp,
+      webrtc::SimulcastUtility::IsConferenceModeScreenshare(encoder_config),
+      temporal_layers_supported, trials, encoder_config.codec_type);
   // Allow an experiment to override the minimum bitrate for the lowest
   // spatial layer. The experiment's configuration has the lowest priority.
   if (experimental_min_bitrate) {
@@ -355,7 +364,7 @@ EncoderStreamFactory::CreateSimulcastOrConferenceModeScreenshareStreams(
         encoder_config.simulcast_layers[i].requested_resolution;
     // Update with configured num temporal layers if supported by codec.
     if (encoder_config.simulcast_layers[i].num_temporal_layers &&
-        IsTemporalLayersSupported(codec_name_)) {
+        temporal_layers_supported) {
       layers[i].num_temporal_layers =
           *encoder_config.simulcast_layers[i].num_temporal_layers;
     }
@@ -419,12 +428,21 @@ EncoderStreamFactory::CreateSimulcastOrConferenceModeScreenshareStreams(
           std::min(layers[i].target_bitrate_bps, layers[i].max_bitrate_bps),
           layers[i].min_bitrate_bps);
     }
+
+    if (encoder_config.simulcast_layers[i].max_qp > 0) {
+      layers[i].max_qp = encoder_config.simulcast_layers[i].max_qp;
+    } else if (encoder_config.max_qp > 0) {
+      layers[i].max_qp = encoder_config.max_qp;
+    } else {
+      layers[i].max_qp = GetDefaultMaxQp(encoder_config.codec_type);
+    }
+
     if (i == layers.size() - 1) {
       is_highest_layer_max_bitrate_configured =
           encoder_config.simulcast_layers[i].max_bitrate_bps > 0;
     }
   }
-  if (!is_screenshare_ && !is_highest_layer_max_bitrate_configured &&
+  if (!is_screencast && !is_highest_layer_max_bitrate_configured &&
       encoder_config.max_bitrate_bps > 0) {
     // No application-configured maximum for the largest layer.
     // If there is bitrate leftover, give it to the largest layer.
diff --git a/video/config/encoder_stream_factory.h b/video/config/encoder_stream_factory.h
index 92e440313e..ef27fb87cf 100644
--- a/video/config/encoder_stream_factory.h
+++ b/video/config/encoder_stream_factory.h
@@ -24,11 +24,7 @@ namespace cricket {
 class EncoderStreamFactory
     : public webrtc::VideoEncoderConfig::VideoStreamFactoryInterface {
  public:
-  EncoderStreamFactory(std::string codec_name,
-                       int max_qp,
-                       bool is_screenshare,
-                       bool conference_mode,
-                       const webrtc::VideoEncoder::EncoderInfo& encoder_info,
+  EncoderStreamFactory(const webrtc::VideoEncoder::EncoderInfo& encoder_info,
                        absl::optional<webrtc::VideoSourceRestrictions>
                            restrictions = absl::nullopt);
 
@@ -58,12 +54,6 @@ class EncoderStreamFactory
       int in_frame_height,
       webrtc::Resolution requested_resolution) const;
 
-  const std::string codec_name_;
-  const int max_qp_;
-  const bool is_screenshare_;
-  // Allows a screenshare specific configuration, which enables temporal
-  // layering and various settings.
-  const bool conference_mode_;
   const int encoder_info_requested_resolution_alignment_;
   const absl::optional<webrtc::VideoSourceRestrictions> restrictions_;
 };
diff --git a/video/config/encoder_stream_factory_unittest.cc b/video/config/encoder_stream_factory_unittest.cc
index 811b877680..47ecf9f034 100644
--- a/video/config/encoder_stream_factory_unittest.cc
+++ b/video/config/encoder_stream_factory_unittest.cc
@@ -20,8 +20,6 @@ namespace {
 using ::cricket::EncoderStreamFactory;
 using test::ExplicitKeyValueConfig;
 
-constexpr int kMaxQp = 48;
-
 std::vector<Resolution> GetStreamResolutions(
     const std::vector<VideoStream>& streams) {
   std::vector<Resolution> res;
@@ -45,10 +43,7 @@ VideoStream LayerWithRequestedResolution(Resolution res) {
 TEST(EncoderStreamFactory, SinglecastRequestedResolution) {
   ExplicitKeyValueConfig field_trials("");
   VideoEncoder::EncoderInfo encoder_info;
-  auto factory = rtc::make_ref_counted<EncoderStreamFactory>(
-      "VP8", kMaxQp,
-      /* is_screenshare= */ false,
-      /* conference_mode= */ false, encoder_info);
+  auto factory = rtc::make_ref_counted<EncoderStreamFactory>(encoder_info);
   VideoEncoderConfig encoder_config;
   encoder_config.number_of_streams = 1;
   encoder_config.simulcast_layers.push_back(
@@ -69,10 +64,8 @@ TEST(EncoderStreamFactory, SinglecastRequestedResolutionWithAdaptation) {
       /* target_pixels_per_frame= */ absl::nullopt,
       /* max_frame_rate= */ absl::nullopt);
   VideoEncoder::EncoderInfo encoder_info;
-  auto factory = rtc::make_ref_counted<EncoderStreamFactory>(
-      "VP8", kMaxQp,
-      /* is_screenshare= */ false,
-      /* conference_mode= */ false, encoder_info, restrictions);
+  auto factory =
+      rtc::make_ref_counted<EncoderStreamFactory>(encoder_info, restrictions);
   VideoEncoderConfig encoder_config;
   encoder_config.number_of_streams = 1;
   encoder_config.simulcast_layers.push_back(
diff --git a/video/config/video_encoder_config.cc b/video/config/video_encoder_config.cc
index 84442aeddf..5cecc45a5d 100644
--- a/video/config/video_encoder_config.cc
+++ b/video/config/video_encoder_config.cc
@@ -59,7 +59,8 @@ VideoEncoderConfig::VideoEncoderConfig()
       bitrate_priority(1.0),
       number_of_streams(0),
       legacy_conference_mode(false),
-      is_quality_scaling_allowed(false) {}
+      is_quality_scaling_allowed(false),
+      max_qp(-1) {}
 
 VideoEncoderConfig::VideoEncoderConfig(VideoEncoderConfig&&) = default;
 
diff --git a/video/end_to_end_tests/resolution_bitrate_limits_tests.cc b/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
index 2ee1589c07..794937651e 100644
--- a/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
+++ b/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
@@ -147,17 +147,13 @@ class InitEncodeTest : public test::EndToEndTest,
       VideoSendStream::Config* send_config,
       std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
-    webrtc::VideoEncoder::EncoderInfo encoder_info;
     send_config->encoder_settings.encoder_factory = &encoder_factory_;
     send_config->rtp.payload_name = payload_name_;
     send_config->rtp.payload_type =
         test::VideoTestConstants::kVideoSendPayloadType;
     const VideoCodecType codec_type = PayloadStringToCodecType(payload_name_);
     encoder_config->codec_type = codec_type;
-    encoder_config->video_stream_factory =
-        rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-            payload_name_, /*max qp*/ 0, /*screencast*/ false,
-            /*screenshare enabled*/ false, encoder_info);
+    encoder_config->video_stream_factory = nullptr;
     encoder_config->max_bitrate_bps = -1;
     if (configs_.size() == 1 && configs_[0].bitrate.max)
       encoder_config->max_bitrate_bps = configs_[0].bitrate.max->bps();
diff --git a/video/quality_scaling_tests.cc b/video/quality_scaling_tests.cc
index 9040b65fad..cd67e686e7 100644
--- a/video/quality_scaling_tests.cc
+++ b/video/quality_scaling_tests.cc
@@ -125,7 +125,6 @@ class ScalingObserver : public test::SendTest {
       VideoSendStream::Config* send_config,
       std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
-    VideoEncoder::EncoderInfo encoder_info;
     send_config->encoder_settings.encoder_factory = &encoder_factory_;
     send_config->rtp.payload_name = payload_name_;
     send_config->rtp.payload_type =
@@ -133,10 +132,6 @@ class ScalingObserver : public test::SendTest {
     encoder_config->video_format.name = payload_name_;
     const VideoCodecType codec_type = PayloadStringToCodecType(payload_name_);
     encoder_config->codec_type = codec_type;
-    encoder_config->video_stream_factory =
-        rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-            payload_name_, /*max_qp=*/0, /*is_screenshare=*/false,
-            /*conference_mode=*/false, encoder_info);
     encoder_config->max_bitrate_bps =
         std::max(start_bps_, encoder_config->max_bitrate_bps);
     if (payload_name_ == "VP9") {
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index 3753ec1744..0c63953871 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -617,9 +617,7 @@ void VideoQualityTest::FillScalabilitySettings(
     encoder_config.spatial_layers = params->ss[video_idx].spatial_layers;
     encoder_config.simulcast_layers = std::vector<VideoStream>(num_streams);
     encoder_config.video_stream_factory =
-        rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-            params->video[video_idx].codec, cricket::kDefaultVideoMaxQpVpx,
-            params->screenshare[video_idx].enabled, true, encoder_info);
+        rtc::make_ref_counted<cricket::EncoderStreamFactory>(encoder_info);
     params->ss[video_idx].streams =
         encoder_config.video_stream_factory->CreateEncoderStreams(
             env().field_trials(), params->video[video_idx].width,
@@ -799,11 +797,6 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
       video_encoder_configs_[video_idx].simulcast_layers =
           params_.ss[video_idx].streams;
     }
-    video_encoder_configs_[video_idx].video_stream_factory =
-        rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-            params_.video[video_idx].codec,
-            params_.ss[video_idx].streams[0].max_qp,
-            params_.screenshare[video_idx].enabled, true, encoder_info);
 
     video_encoder_configs_[video_idx].spatial_layers =
         params_.ss[video_idx].spatial_layers;
@@ -823,6 +816,7 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
       // Fill out codec settings.
       video_encoder_configs_[video_idx].content_type =
           VideoEncoderConfig::ContentType::kScreen;
+      video_encoder_configs_[video_idx].legacy_conference_mode = true;
       degradation_preference_ = DegradationPreference::MAINTAIN_RESOLUTION;
       if (params_.video[video_idx].codec == "VP8") {
         VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings();
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 82373548bc..387695a338 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -4077,10 +4077,6 @@ void VideoSendStreamTest::TestTemporalLayers(
           test::VideoTestConstants::kVideoSendPayloadType;
       encoder_config->video_format.name = payload_name_;
       encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
-      encoder_config->video_stream_factory =
-          rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-              payload_name_, /*max_qp=*/56, /*is_screenshare=*/false,
-              /*conference_mode=*/false, encoder_info);
       encoder_config->max_bitrate_bps = kMaxBitrateBps;
       if (absl::EqualsIgnoreCase(payload_name_, "VP9")) {
         encoder_config->encoder_specific_settings = rtc::make_ref_counted<
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 1e7672cb2d..92f730838c 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -996,11 +996,7 @@ void VideoStreamEncoder::ReconfigureEncoder() {
         encoder_config_);
   } else {
     auto factory = rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-        encoder_config_.video_format.name, encoder_config_.max_qp,
-        encoder_config_.content_type ==
-            webrtc::VideoEncoderConfig::ContentType::kScreen,
-        encoder_config_.legacy_conference_mode, encoder_->GetEncoderInfo(),
-        latest_restrictions_);
+        encoder_->GetEncoderInfo(), latest_restrictions_);
 
     streams = factory->CreateEncoderStreams(
         env_.field_trials(), last_frame_info_->width, last_frame_info_->height,
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index 6549bd5de9..aab791f80a 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -2226,16 +2226,12 @@ TEST_F(VideoStreamEncoderTest,
 
   // Two streams, highest stream active.
   VideoEncoderConfig config;
-  webrtc::VideoEncoder::EncoderInfo encoder_info;
   const int kNumStreams = 2;
   test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
   config.max_bitrate_bps = 0;
   config.simulcast_layers[0].active = false;
   config.simulcast_layers[1].active = true;
-  config.video_stream_factory =
-      rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-          "VP8", /*max qp*/ 56, /*screencast*/ false,
-          /*screenshare enabled*/ false, encoder_info);
+  config.video_stream_factory = nullptr;
   video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
 
   // The encoder bitrate limits for 270p should be used.
@@ -2291,16 +2287,12 @@ TEST_F(VideoStreamEncoderTest,
        DefaultEncoderMaxAndMinBitratesUsedForTwoStreamsHighestActive) {
   // Two streams, highest stream active.
   VideoEncoderConfig config;
-  webrtc::VideoEncoder::EncoderInfo encoder_info;
   const int kNumStreams = 2;
   test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
   config.max_bitrate_bps = 0;
   config.simulcast_layers[0].active = false;
   config.simulcast_layers[1].active = true;
-  config.video_stream_factory =
-      rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-          "VP8", /*max qp*/ 56, /*screencast*/ false,
-          /*screenshare enabled*/ false, encoder_info);
+  config.video_stream_factory = nullptr;
   video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
 
   // Default bitrate limits for 270p should be used.
@@ -2365,16 +2357,12 @@ TEST_F(VideoStreamEncoderTest,
 
   // Three streams, middle stream active.
   VideoEncoderConfig config;
-  webrtc::VideoEncoder::EncoderInfo encoder_info;
   const int kNumStreams = 3;
   test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
   config.simulcast_layers[0].active = false;
   config.simulcast_layers[1].active = true;
   config.simulcast_layers[2].active = false;
-  config.video_stream_factory =
-      rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-          "VP8", /*max qp*/ 56, /*screencast*/ false,
-          /*screenshare enabled*/ false, encoder_info);
+  config.video_stream_factory = nullptr;
   video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
 
   // The encoder bitrate limits for 360p should be used.
@@ -2410,16 +2398,12 @@ TEST_F(VideoStreamEncoderTest,
 
   // Three streams, lowest stream active.
   VideoEncoderConfig config;
-  webrtc::VideoEncoder::EncoderInfo encoder_info;
   const int kNumStreams = 3;
   test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
   config.simulcast_layers[0].active = true;
   config.simulcast_layers[1].active = false;
   config.simulcast_layers[2].active = false;
-  config.video_stream_factory =
-      rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-          "VP8", /*max qp*/ 56, /*screencast*/ false,
-          /*screenshare enabled*/ false, encoder_info);
+  config.video_stream_factory = nullptr;
   video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
 
   // Resolution on lowest stream lower than 270p. The encoder limits not applied
@@ -2447,16 +2431,12 @@ TEST_F(VideoStreamEncoderTest,
 
   // Two streams, highest stream active.
   VideoEncoderConfig config;
-  webrtc::VideoEncoder::EncoderInfo encoder_info;
   const int kNumStreams = 2;
   test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
   config.simulcast_layers[0].active = false;
   config.simulcast_layers[1].active = true;
   config.simulcast_layers[1].max_bitrate_bps = kMaxBitrateBps;
-  config.video_stream_factory =
-      rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-          "VP8", /*max qp*/ 56, /*screencast*/ false,
-          /*screenshare enabled*/ false, encoder_info);
+  config.video_stream_factory = nullptr;
   video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
 
   // The encoder bitrate limits for 270p should be used.
@@ -2675,15 +2655,11 @@ TEST_P(ResolutionAlignmentTest, SinkWantsAlignmentApplied) {
   // Fill config with the scaling factor by which to reduce encoding size.
   const int num_streams = scale_factors_.size();
   VideoEncoderConfig config;
-  webrtc::VideoEncoder::EncoderInfo encoder_info;
   test::FillEncoderConfiguration(kVideoCodecVP8, num_streams, &config);
   for (int i = 0; i < num_streams; ++i) {
     config.simulcast_layers[i].scale_resolution_down_by = scale_factors_[i];
   }
-  config.video_stream_factory =
-      rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-          "VP8", /*max qp*/ 56, /*screencast*/ false,
-          /*screenshare enabled*/ false, encoder_info);
+  config.video_stream_factory = nullptr;
   video_stream_encoder_->ConfigureEncoder(std::move(config), kMaxPayloadLength);
 
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
@@ -5842,13 +5818,9 @@ TEST_F(VideoStreamEncoderTest,
 
 TEST_F(VideoStreamEncoderTest, InitialFrameDropAccountsForResolutionScaling) {
   VideoEncoderConfig video_encoder_config;
-  webrtc::VideoEncoder::EncoderInfo encoder_info;
   test::FillEncoderConfiguration(PayloadStringToCodecType("VP8"), 1,
                                  &video_encoder_config);
-  video_encoder_config.video_stream_factory =
-      rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-          "VP8", /*max qp*/ 56, /*screencast*/ false,
-          /*screenshare enabled*/ false, encoder_info);
+  video_encoder_config.video_stream_factory = nullptr;
   for (auto& layer : video_encoder_config.simulcast_layers) {
     layer.num_temporal_layers = 1;
     layer.max_framerate = kDefaultFramerate;
@@ -5894,13 +5866,9 @@ TEST_F(VideoStreamEncoderTest, InitialFrameDropActivatesWhenLayersChange) {
   // Trigger QVGA "singlecast"
   // Update the config.
   VideoEncoderConfig video_encoder_config;
-  webrtc::VideoEncoder::EncoderInfo encoder_info;
   test::FillEncoderConfiguration(PayloadStringToCodecType("VP8"), 3,
                                  &video_encoder_config);
-  video_encoder_config.video_stream_factory =
-      rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-          "VP8", /*max qp*/ 56, /*screencast*/ false,
-          /*screenshare enabled*/ false, encoder_info);
+  video_encoder_config.video_stream_factory = nullptr;
   for (auto& layer : video_encoder_config.simulcast_layers) {
     layer.num_temporal_layers = 1;
     layer.max_framerate = kDefaultFramerate;
@@ -8099,16 +8067,12 @@ TEST_F(VideoStreamEncoderTest, EncoderResetAccordingToParameterChange) {
   const int number_layers =
       sizeof(downscale_factors) / sizeof(downscale_factors[0]);
   VideoEncoderConfig config;
-  webrtc::VideoEncoder::EncoderInfo encoder_info;
   test::FillEncoderConfiguration(kVideoCodecVP8, number_layers, &config);
   for (int i = 0; i < number_layers; ++i) {
     config.simulcast_layers[i].scale_resolution_down_by = downscale_factors[i];
     config.simulcast_layers[i].active = true;
   }
-  config.video_stream_factory =
-      rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-          "VP8", /*max qp*/ 56, /*screencast*/ false,
-          /*screenshare enabled*/ false, encoder_info);
+  config.video_stream_factory = nullptr;
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kSimulcastTargetBitrate, kSimulcastTargetBitrate, kSimulcastTargetBitrate,
       0, 0, 0);
@@ -8225,16 +8189,12 @@ TEST_F(VideoStreamEncoderTest, EncoderResolutionsExposedInSimulcast) {
       kFrameWidth / kDownscaleFactors[2], kFrameHeight / kDownscaleFactors[2]);
 
   VideoEncoderConfig config;
-  webrtc::VideoEncoder::EncoderInfo encoder_info;
   test::FillEncoderConfiguration(kVideoCodecVP8, kNumSimulcastLayers, &config);
   for (size_t i = 0; i < kNumSimulcastLayers; ++i) {
     config.simulcast_layers[i].scale_resolution_down_by = kDownscaleFactors[i];
     config.simulcast_layers[i].active = true;
   }
-  config.video_stream_factory =
-      rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-          "VP8", /*max qp*/ 56, /*screencast*/ false,
-          /*screenshare enabled*/ false, encoder_info);
+  config.video_stream_factory = nullptr;
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kSimulcastTargetBitrate, kSimulcastTargetBitrate, kSimulcastTargetBitrate,
       0, 0, 0);
@@ -8998,7 +8958,6 @@ TEST_P(VideoStreamEncoderWithRealEncoderTest, HandlesLayerToggling) {
       kFrameWidth / kDownscaleFactors[2], kFrameHeight / kDownscaleFactors[2]);
 
   VideoEncoderConfig config;
-  webrtc::VideoEncoder::EncoderInfo encoder_info;
   if (codec_type_ == VideoCodecType::kVideoCodecVP9) {
     test::FillEncoderConfiguration(codec_type_, 1, &config);
     config.max_bitrate_bps = kSimulcastTargetBitrate.bps();
@@ -9048,11 +9007,7 @@ TEST_P(VideoStreamEncoderWithRealEncoderTest, HandlesLayerToggling) {
     }
   };
 
-  config.video_stream_factory =
-      rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-          CodecTypeToPayloadString(codec_type_), /*max qp*/ 56,
-          /*screencast*/ false,
-          /*screenshare enabled*/ false, encoder_info);
+  config.video_stream_factory = nullptr;
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kSimulcastTargetBitrate, kSimulcastTargetBitrate, kSimulcastTargetBitrate,
       0, 0, 0);
@@ -9169,15 +9124,10 @@ class ReconfigureEncoderTest : public VideoStreamEncoderTest {
 
   void ConfigureEncoder(const VideoStream& stream) {
     VideoEncoderConfig config;
-    webrtc::VideoEncoder::EncoderInfo encoder_info;
-
     test::FillEncoderConfiguration(kVideoCodecVP8, /*num_streams=*/1, &config);
     config.max_bitrate_bps = stream.max_bitrate_bps;
     config.simulcast_layers[0] = stream;
-    config.video_stream_factory =
-        rtc::make_ref_counted<cricket::EncoderStreamFactory>(
-            /*codec_name=*/"VP8", /*max_qp=*/0, /*is_screenshare=*/false,
-            /*conference_mode=*/false, encoder_info);
+    config.video_stream_factory = nullptr;
     video_stream_encoder_->ConfigureEncoder(std::move(config),
                                             kMaxPayloadLength);
   }