diff --git a/api/test/mock_video_bitrate_allocator_factory.h b/api/test/mock_video_bitrate_allocator_factory.h
index 16af191..7c6492e 100644
--- a/api/test/mock_video_bitrate_allocator_factory.h
+++ b/api/test/mock_video_bitrate_allocator_factory.h
@@ -18,13 +18,12 @@
 
 namespace webrtc {
 
-class MockVideoBitrateAllocatorFactory
-    : public webrtc::VideoBitrateAllocatorFactory {
+class MockVideoBitrateAllocatorFactory : public VideoBitrateAllocatorFactory {
  public:
   ~MockVideoBitrateAllocatorFactory() override { Die(); }
   MOCK_METHOD(std::unique_ptr<VideoBitrateAllocator>,
-              CreateVideoBitrateAllocator,
-              (const VideoCodec&),
+              Create,
+              (const Environment&, const VideoCodec&),
               (override));
   MOCK_METHOD(void, Die, ());
 };
diff --git a/api/video/BUILD.gn b/api/video/BUILD.gn
index 72befb5..48b13c9 100644
--- a/api/video/BUILD.gn
+++ b/api/video/BUILD.gn
@@ -264,6 +264,8 @@
   sources = [ "video_bitrate_allocator_factory.h" ]
   deps = [
     ":video_bitrate_allocator",
+    "../../rtc_base:checks",
+    "../environment",
     "../video_codecs:video_codecs_api",
   ]
 }
diff --git a/api/video/video_bitrate_allocator_factory.h b/api/video/video_bitrate_allocator_factory.h
index cb34ebb..a6e0a1a 100644
--- a/api/video/video_bitrate_allocator_factory.h
+++ b/api/video/video_bitrate_allocator_factory.h
@@ -13,8 +13,10 @@
 
 #include <memory>
 
+#include "api/environment/environment.h"
 #include "api/video/video_bitrate_allocator.h"
 #include "api/video_codecs/video_codec.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 
@@ -23,9 +25,19 @@
 class VideoBitrateAllocatorFactory {
  public:
   virtual ~VideoBitrateAllocatorFactory() = default;
+
   // Creates a VideoBitrateAllocator for a specific video codec.
+  virtual std::unique_ptr<VideoBitrateAllocator> Create(
+      const Environment& env,
+      const VideoCodec& codec) {
+    return CreateVideoBitrateAllocator(codec);
+  }
   virtual std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator(
-      const VideoCodec& codec) = 0;
+      const VideoCodec& codec) {
+    // Newer code shouldn't call this function,
+    // Older code should implement it in derived classes.
+    RTC_CHECK_NOTREACHED();
+  }
 };
 
 }  // namespace webrtc
diff --git a/media/engine/webrtc_video_engine_unittest.cc b/media/engine/webrtc_video_engine_unittest.cc
index f8612f8..6debc13 100644
--- a/media/engine/webrtc_video_engine_unittest.cc
+++ b/media/engine/webrtc_video_engine_unittest.cc
@@ -1363,9 +1363,9 @@
   std::unique_ptr<webrtc::MockVideoBitrateAllocatorFactory>
       rate_allocator_factory =
           std::make_unique<webrtc::MockVideoBitrateAllocatorFactory>();
-  EXPECT_CALL(*rate_allocator_factory,
-              CreateVideoBitrateAllocator(Field(&webrtc::VideoCodec::codecType,
-                                                webrtc::kVideoCodecVP8)))
+  EXPECT_CALL(
+      *rate_allocator_factory,
+      Create(_, Field(&webrtc::VideoCodec::codecType, webrtc::kVideoCodecVP8)))
       .WillOnce(
           [] { return std::make_unique<webrtc::MockVideoBitrateAllocator>(); });
   webrtc::FieldTrialBasedConfig trials;
diff --git a/modules/video_coding/BUILD.gn b/modules/video_coding/BUILD.gn
index d2246d5..1b3a244 100644
--- a/modules/video_coding/BUILD.gn
+++ b/modules/video_coding/BUILD.gn
@@ -1204,6 +1204,7 @@
       "../../api:scoped_refptr",
       "../../api:simulcast_test_fixture_api",
       "../../api:videocodec_test_fixture_api",
+      "../../api/environment",
       "../../api/environment:environment_factory",
       "../../api/task_queue",
       "../../api/task_queue:default_task_queue_factory",
diff --git a/modules/video_coding/codecs/test/video_codec_test.cc b/modules/video_coding/codecs/test/video_codec_test.cc
index e7a7f75..89c387a 100644
--- a/modules/video_coding/codecs/test/video_codec_test.cc
+++ b/modules/video_coding/codecs/test/video_codec_test.cc
@@ -319,7 +319,7 @@
   VideoSourceSettings source_settings = ToSourceSettings(video_info);
 
   EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
-      codec_type, /*scalability_mode=*/"L1T1", width, height,
+      env, codec_type, /*scalability_mode=*/"L1T1", width, height,
       {DataRate::KilobitsPerSec(bitrate_kbps)},
       Frequency::Hertz(framerate_fps));
 
@@ -398,14 +398,14 @@
   VideoSourceSettings source_settings = ToSourceSettings(video_info);
 
   EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
-      codec_type, /*scalability_mode=*/"L1T1",
+      env, codec_type, /*scalability_mode=*/"L1T1",
       /*width=*/640, /*height=*/360,
       {DataRate::KilobitsPerSec(bitrate_kbps.first)},
       /*framerate=*/Frequency::Hertz(30));
 
   EncodingSettings encoding_settings2 =
       VideoCodecTester::CreateEncodingSettings(
-          codec_type, /*scalability_mode=*/"L1T1",
+          env, codec_type, /*scalability_mode=*/"L1T1",
           /*width=*/640, /*height=*/360,
           {DataRate::KilobitsPerSec(bitrate_kbps.second)},
           /*framerate=*/Frequency::Hertz(30));
@@ -484,14 +484,14 @@
   VideoSourceSettings source_settings = ToSourceSettings(video_info);
 
   EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
-      codec_type, /*scalability_mode=*/"L1T1",
+      env, codec_type, /*scalability_mode=*/"L1T1",
       /*width=*/640, /*height=*/360,
       /*bitrate=*/{DataRate::KilobitsPerSec(512)},
       Frequency::Hertz(framerate_fps.first));
 
   EncodingSettings encoding_settings2 =
       VideoCodecTester::CreateEncodingSettings(
-          codec_type, /*scalability_mode=*/"L1T1",
+          env, codec_type, /*scalability_mode=*/"L1T1",
           /*width=*/640, /*height=*/360,
           /*bitrate=*/{DataRate::KilobitsPerSec(512)},
           Frequency::Hertz(framerate_fps.second));
@@ -571,7 +571,7 @@
           .value_or(absl::GetFlag(FLAGS_input_framerate_fps)));
 
   EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
-      CodecNameToCodecType(absl::GetFlag(FLAGS_encoder)),
+      env, CodecNameToCodecType(absl::GetFlag(FLAGS_encoder)),
       absl::GetFlag(FLAGS_scalability_mode),
       absl::GetFlag(FLAGS_width).value_or(absl::GetFlag(FLAGS_input_width)),
       absl::GetFlag(FLAGS_height).value_or(absl::GetFlag(FLAGS_input_height)),
diff --git a/modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc b/modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
index a4c5045..9c70826 100644
--- a/modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
+++ b/modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
@@ -446,6 +446,7 @@
                            webrtc::LibvpxVp9DecoderTemplateAdapter,
                            webrtc::OpenH264DecoderTemplateAdapter,
                            webrtc::Dav1dDecoderTemplateAdapter>>()),
+      env_(CreateEnvironment()),
       config_(config) {}
 
 VideoCodecTestFixtureImpl::VideoCodecTestFixtureImpl(
@@ -454,6 +455,7 @@
     std::unique_ptr<VideoEncoderFactory> encoder_factory)
     : encoder_factory_(std::move(encoder_factory)),
       decoder_factory_(std::move(decoder_factory)),
+      env_(CreateEnvironment()),
       config_(config) {}
 
 VideoCodecTestFixtureImpl::~VideoCodecTestFixtureImpl() = default;
@@ -695,8 +697,6 @@
 }
 
 bool VideoCodecTestFixtureImpl::CreateEncoderAndDecoder() {
-  const Environment env = CreateEnvironment();
-
   SdpVideoFormat encoder_format(CreateSdpVideoFormat(config_));
   SdpVideoFormat decoder_format = encoder_format;
 
@@ -711,7 +711,7 @@
     decoder_format = *config_.decoder_format;
   }
 
-  encoder_ = encoder_factory_->Create(env, encoder_format);
+  encoder_ = encoder_factory_->Create(env_, encoder_format);
   EXPECT_TRUE(encoder_) << "Encoder not successfully created.";
   if (encoder_ == nullptr) {
     return false;
@@ -721,7 +721,7 @@
       config_.NumberOfSimulcastStreams(), config_.NumberOfSpatialLayers());
   for (size_t i = 0; i < num_simulcast_or_spatial_layers; ++i) {
     std::unique_ptr<VideoDecoder> decoder =
-        decoder_factory_->Create(env, decoder_format);
+        decoder_factory_->Create(env_, decoder_format);
     EXPECT_TRUE(decoder) << "Decoder not successfully created.";
     if (decoder == nullptr) {
       return false;
@@ -818,7 +818,7 @@
 
   task_queue->SendTask([this]() {
     processor_ = std::make_unique<VideoProcessor>(
-        encoder_.get(), &decoders_, source_frame_reader_.get(), config_,
+        env_, encoder_.get(), &decoders_, source_frame_reader_.get(), config_,
         &stats_, &encoded_frame_writers_,
         decoded_frame_writers_.empty() ? nullptr : &decoded_frame_writers_);
   });
diff --git a/modules/video_coding/codecs/test/videocodec_test_fixture_impl.h b/modules/video_coding/codecs/test/videocodec_test_fixture_impl.h
index 005b7c0..088e7b7 100644
--- a/modules/video_coding/codecs/test/videocodec_test_fixture_impl.h
+++ b/modules/video_coding/codecs/test/videocodec_test_fixture_impl.h
@@ -15,6 +15,7 @@
 #include <string>
 #include <vector>
 
+#include "api/environment/environment.h"
 #include "api/test/videocodec_test_fixture.h"
 #include "api/video_codecs/video_decoder_factory.h"
 #include "api/video_codecs/video_encoder_factory.h"
@@ -92,6 +93,7 @@
   VideoProcessor::VideoDecoderList decoders_;
 
   // Helper objects.
+  const Environment env_;
   Config config_;
   VideoCodecTestStatsImpl stats_;
   std::unique_ptr<FrameReader> source_frame_reader_;
diff --git a/modules/video_coding/codecs/test/videoprocessor.cc b/modules/video_coding/codecs/test/videoprocessor.cc
index 15a51e0..c5e7ed0 100644
--- a/modules/video_coding/codecs/test/videoprocessor.cc
+++ b/modules/video_coding/codecs/test/videoprocessor.cc
@@ -135,7 +135,8 @@
 
 }  // namespace
 
-VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder,
+VideoProcessor::VideoProcessor(const Environment& env,
+                               webrtc::VideoEncoder* encoder,
                                VideoDecoderList* decoders,
                                FrameReader* input_frame_reader,
                                const VideoCodecTestFixture::Config& config,
@@ -150,9 +151,9 @@
       stats_(stats),
       encoder_(encoder),
       decoders_(decoders),
-      bitrate_allocator_(
-          CreateBuiltinVideoBitrateAllocatorFactory()
-              ->CreateVideoBitrateAllocator(config_.codec_settings)),
+      bitrate_allocator_(CreateBuiltinVideoBitrateAllocatorFactory()->Create(
+          env,
+          config_.codec_settings)),
       encode_callback_(this),
       input_frame_reader_(input_frame_reader),
       merged_encoded_frames_(num_simulcast_or_spatial_layers_),
diff --git a/modules/video_coding/codecs/test/videoprocessor.h b/modules/video_coding/codecs/test/videoprocessor.h
index 502fa3d..e6ecdff 100644
--- a/modules/video_coding/codecs/test/videoprocessor.h
+++ b/modules/video_coding/codecs/test/videoprocessor.h
@@ -20,6 +20,7 @@
 #include <vector>
 
 #include "absl/types/optional.h"
+#include "api/environment/environment.h"
 #include "api/sequence_checker.h"
 #include "api/task_queue/task_queue_base.h"
 #include "api/test/videocodec_test_fixture.h"
@@ -61,7 +62,8 @@
   using FrameWriterList = std::vector<std::unique_ptr<FrameWriter>>;
   using FrameStatistics = VideoCodecTestStats::FrameStatistics;
 
-  VideoProcessor(webrtc::VideoEncoder* encoder,
+  VideoProcessor(const Environment& env,
+                 VideoEncoder* encoder,
                  VideoDecoderList* decoders,
                  FrameReader* input_frame_reader,
                  const VideoCodecTestFixture::Config& config,
diff --git a/modules/video_coding/codecs/test/videoprocessor_unittest.cc b/modules/video_coding/codecs/test/videoprocessor_unittest.cc
index 28c369f..8082542 100644
--- a/modules/video_coding/codecs/test/videoprocessor_unittest.cc
+++ b/modules/video_coding/codecs/test/videoprocessor_unittest.cc
@@ -12,6 +12,7 @@
 
 #include <memory>
 
+#include "api/environment/environment_factory.h"
 #include "api/scoped_refptr.h"
 #include "api/test/mock_video_decoder.h"
 #include "api/test/mock_video_encoder.h"
@@ -53,8 +54,9 @@
     ExpectInit();
     q_.SendTask([this] {
       video_processor_ = std::make_unique<VideoProcessor>(
-          &encoder_mock_, &decoders_, &frame_reader_mock_, config_, &stats_,
-          &encoded_frame_writers_, /*decoded_frame_writers=*/nullptr);
+          CreateEnvironment(), &encoder_mock_, &decoders_, &frame_reader_mock_,
+          config_, &stats_, &encoded_frame_writers_,
+          /*decoded_frame_writers=*/nullptr);
     });
   }
 
diff --git a/modules/video_coding/video_codec_initializer_unittest.cc b/modules/video_coding/video_codec_initializer_unittest.cc
index b4858bf..109b095 100644
--- a/modules/video_coding/video_codec_initializer_unittest.cc
+++ b/modules/video_coding/video_codec_initializer_unittest.cc
@@ -16,6 +16,8 @@
 #include <memory>
 
 #include "absl/types/optional.h"
+#include "api/environment/environment.h"
+#include "api/environment/environment_factory.h"
 #include "api/scoped_refptr.h"
 #include "api/test/mock_fec_controller_override.h"
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
@@ -92,10 +94,10 @@
 
   void InitializeCodec() {
     frame_buffer_controller_.reset();
-    codec_out_ =
-        VideoCodecInitializer::SetupCodec(field_trials_, config_, streams_);
-    bitrate_allocator_ = CreateBuiltinVideoBitrateAllocatorFactory()
-                             ->CreateVideoBitrateAllocator(codec_out_);
+    codec_out_ = VideoCodecInitializer::SetupCodec(env_.field_trials(), config_,
+                                                   streams_);
+    bitrate_allocator_ =
+        CreateBuiltinVideoBitrateAllocatorFactory()->Create(env_, codec_out_);
     RTC_CHECK(bitrate_allocator_);
 
     // Make sure temporal layers instances have been created.
@@ -137,7 +139,7 @@
     return stream;
   }
 
-  const test::ExplicitKeyValueConfig field_trials_{""};
+  const Environment env_ = CreateEnvironment();
   MockFecControllerOverride fec_controller_override_;
 
   // Input settings.
@@ -505,7 +507,7 @@
   streams[0].scalability_mode = ScalabilityMode::kL1T2;
 
   VideoCodec codec =
-      VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
+      VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams);
 
   EXPECT_GE(codec.spatialLayers[0].targetBitrate,
             codec.spatialLayers[0].minBitrate);
@@ -520,7 +522,7 @@
   streams[0].scalability_mode = ScalabilityMode::kL2T2;
 
   VideoCodec codec =
-      VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
+      VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams);
 
   EXPECT_GE(codec.spatialLayers[0].targetBitrate,
             codec.spatialLayers[0].minBitrate);
@@ -541,7 +543,7 @@
   config.spatial_layers = {};
 
   VideoCodec codec =
-      VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
+      VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams);
 
   EXPECT_TRUE(codec.spatialLayers[0].active);
   EXPECT_TRUE(codec.spatialLayers[1].active);
@@ -557,7 +559,7 @@
   config.spatial_layers[1].active = false;
 
   VideoCodec codec =
-      VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
+      VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams);
 
   EXPECT_TRUE(codec.spatialLayers[0].active);
   EXPECT_FALSE(codec.spatialLayers[1].active);
@@ -575,7 +577,7 @@
   streams[0].scalability_mode = ScalabilityMode::kL1T2;
 
   VideoCodec codec =
-      VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
+      VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams);
 
   EXPECT_EQ(1u, codec.VP9()->numberOfSpatialLayers);
   // Target is consistent with min and max (min <= target <= max).
@@ -603,7 +605,7 @@
   streams[0].scalability_mode = ScalabilityMode::kL2T2;
 
   VideoCodec codec =
-      VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
+      VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams);
 
   EXPECT_EQ(2u, codec.VP9()->numberOfSpatialLayers);
   EXPECT_GE(codec.spatialLayers[0].targetBitrate,
@@ -627,14 +629,15 @@
   streams[0].scalability_mode = ScalabilityMode::kL2T3_KEY;
 
   VideoCodec codec =
-      VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
+      VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams);
 
   EXPECT_EQ(codec.VP9()->numberOfSpatialLayers, 2u);
   EXPECT_EQ(codec.VP9()->numberOfTemporalLayers, 3u);
   EXPECT_EQ(codec.VP9()->interLayerPred, InterLayerPredMode::kOnKeyPic);
 
   streams[0].scalability_mode = ScalabilityMode::kS3T1;
-  codec = VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
+  codec =
+      VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams);
 
   EXPECT_EQ(codec.VP9()->numberOfSpatialLayers, 3u);
   EXPECT_EQ(codec.VP9()->numberOfTemporalLayers, 1u);
diff --git a/rtc_tools/video_encoder/video_encoder.cc b/rtc_tools/video_encoder/video_encoder.cc
index 53641b7..a48d72a 100644
--- a/rtc_tools/video_encoder/video_encoder.cc
+++ b/rtc_tools/video_encoder/video_encoder.cc
@@ -333,13 +333,13 @@
     RTC_CHECK_EQ(ret, WEBRTC_VIDEO_CODEC_OK);
 
     // Set bitrates.
-    std::unique_ptr<webrtc::VideoBitrateAllocator> bitrate_allocator_;
-    bitrate_allocator_ = webrtc::CreateBuiltinVideoBitrateAllocatorFactory()
-                             ->CreateVideoBitrateAllocator(video_codec_setting);
-    RTC_CHECK(bitrate_allocator_);
+    std::unique_ptr<VideoBitrateAllocator> bitrate_allocator =
+        CreateBuiltinVideoBitrateAllocatorFactory()->Create(
+            env, video_codec_setting);
+    RTC_CHECK(bitrate_allocator);
 
     webrtc::VideoBitrateAllocation allocation =
-        bitrate_allocator_->GetAllocation(bitrate_kbps * 1000, frame_rate_fps);
+        bitrate_allocator->GetAllocation(bitrate_kbps * 1000, frame_rate_fps);
     RTC_LOG(LS_INFO) << allocation.ToString();
 
     video_encoder->SetRates(webrtc::VideoEncoder::RateControlParameters(
diff --git a/test/video_codec_tester.cc b/test/video_codec_tester.cc
index 4c9fc40..8f5feee 100644
--- a/test/video_codec_tester.cc
+++ b/test/video_codec_tester.cc
@@ -1300,7 +1300,8 @@
 }
 
 std::tuple<std::vector<DataRate>, ScalabilityMode>
-SplitBitrateAndUpdateScalabilityMode(std::string codec_type,
+SplitBitrateAndUpdateScalabilityMode(const Environment& env,
+                                     std::string codec_type,
                                      ScalabilityMode scalability_mode,
                                      int width,
                                      int height,
@@ -1407,8 +1408,7 @@
   }
 
   std::unique_ptr<VideoBitrateAllocator> bitrate_allocator =
-      CreateBuiltinVideoBitrateAllocatorFactory()->CreateVideoBitrateAllocator(
-          vc);
+      CreateBuiltinVideoBitrateAllocatorFactory()->Create(env, vc);
   VideoBitrateAllocation bitrate_allocation =
       bitrate_allocator->Allocate(VideoBitrateAllocationParameters(
           total_bitrate.bps(), framerate.hertz<double>()));
@@ -1486,6 +1486,7 @@
 }
 
 EncodingSettings VideoCodecTester::CreateEncodingSettings(
+    const Environment& env,
     std::string codec_type,
     std::string scalability_name,
     int width,
@@ -1499,7 +1500,7 @@
 
   auto [adjusted_bitrate, scalability_mode] =
       SplitBitrateAndUpdateScalabilityMode(
-          codec_type, *ScalabilityModeFromString(scalability_name), width,
+          env, codec_type, *ScalabilityModeFromString(scalability_name), width,
           height, bitrate, framerate, content_type);
 
   int num_spatial_layers = ScalabilityModeToNumSpatialLayers(scalability_mode);
diff --git a/test/video_codec_tester.h b/test/video_codec_tester.h
index 7032cc8..3789f56 100644
--- a/test/video_codec_tester.h
+++ b/test/video_codec_tester.h
@@ -194,7 +194,8 @@
   // and per-temporal layer. If layer bitrates are not explicitly specified,
   // then the codec-specific rate allocators used to distribute the total
   // bitrate across spatial or/and temporal layers.
-  static EncodingSettings CreateEncodingSettings(std::string codec_type,
+  static EncodingSettings CreateEncodingSettings(const Environment& env,
+                                                 std::string codec_type,
                                                  std::string scalability_name,
                                                  int width,
                                                  int height,
diff --git a/test/video_codec_tester_unittest.cc b/test/video_codec_tester_unittest.cc
index 2361d25..ddc2410 100644
--- a/test/video_codec_tester_unittest.cc
+++ b/test/video_codec_tester_unittest.cc
@@ -620,7 +620,7 @@
   }));
 
   EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
-      "VP8", "L1T1", kSourceWidth, kSourceHeight, {kBitrate}, kFramerate);
+      env, "VP8", "L1T1", kSourceWidth, kSourceHeight, {kBitrate}, kFramerate);
   std::map<uint32_t, EncodingSettings> frame_settings =
       VideoCodecTester::CreateFrameSettings(encoding_settings, kNumFrames);
 
@@ -687,7 +687,8 @@
 TEST_P(VideoCodecTesterTestEncodingSettings, CreateEncodingSettings) {
   EncodingSettingsTestParameters test_params = GetParam();
   EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
-      test_params.codec_type, test_params.scalability_mode, /*width=*/1280,
+      CreateEnvironment(), test_params.codec_type, test_params.scalability_mode,
+      /*width=*/1280,
       /*height=*/720, test_params.bitrate, kFramerate);
   const std::map<LayerId, LayerSettings>& layers_settings =
       encoding_settings.layers_settings;
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 38b21bc..21698ce 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -2697,7 +2697,8 @@
               CreateBuiltinVideoBitrateAllocatorFactory()) {}
 
    private:
-    std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator(
+    std::unique_ptr<VideoBitrateAllocator> Create(
+        const Environment& env,
         const VideoCodec& codec) override {
       EXPECT_GE(codec.startBitrate, codec.minBitrate);
       EXPECT_LE(codec.startBitrate, codec.maxBitrate);
@@ -2722,7 +2723,7 @@
       ++num_rate_allocator_creations_;
       create_rate_allocator_event_.Set();
 
-      return bitrate_allocator_factory_->CreateVideoBitrateAllocator(codec);
+      return bitrate_allocator_factory_->Create(env, codec);
     }
 
     int32_t InitEncode(const VideoCodec* codecSettings,
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 8ae14f1..26601b0 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -1267,8 +1267,7 @@
         }
       }));
 
-  rate_allocator_ =
-      settings_.bitrate_allocator_factory->CreateVideoBitrateAllocator(codec);
+  rate_allocator_ = settings_.bitrate_allocator_factory->Create(env_, codec);
   rate_allocator_->SetLegacyConferenceMode(
       encoder_config_.legacy_conference_mode);
 
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index 907d840..267b7d6 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -1601,11 +1601,12 @@
         : bitrate_allocator_factory_(
               CreateBuiltinVideoBitrateAllocatorFactory()) {}
 
-    std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator(
+    std::unique_ptr<VideoBitrateAllocator> Create(
+        const Environment& env,
         const VideoCodec& codec) override {
       MutexLock lock(&mutex_);
       codec_config_ = codec;
-      return bitrate_allocator_factory_->CreateVideoBitrateAllocator(codec);
+      return bitrate_allocator_factory_->Create(env, codec);
     }
 
     VideoCodec codec_config() const {