diff --git a/api/audio_codecs/test/audio_encoder_factory_template_unittest.cc b/api/audio_codecs/test/audio_encoder_factory_template_unittest.cc
index fdf04de926..5b8e35dc8d 100644
--- a/api/audio_codecs/test/audio_encoder_factory_template_unittest.cc
+++ b/api/audio_codecs/test/audio_encoder_factory_template_unittest.cc
@@ -216,8 +216,6 @@ TEST(AudioEncoderFactoryTemplateTest, NoEncoderTypes) {
           audio_encoder_factory_template_impl::AudioEncoderFactoryT<>>());
   EXPECT_THAT(factory->GetSupportedEncoders(), ::testing::IsEmpty());
   EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
-  EXPECT_EQ(nullptr,
-            factory->MakeAudioEncoder(17, {"bar", 16000, 1}, absl::nullopt));
 
   EXPECT_THAT(factory->Create(env, {"bar", 16000, 1}, {}), IsNull());
 }
@@ -231,11 +229,6 @@ TEST(AudioEncoderFactoryTemplateTest, OneEncoderType) {
   EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
   EXPECT_EQ(AudioCodecInfo(8000, 1, 12345),
             factory->QueryAudioEncoder({"bogus", 8000, 1}));
-  EXPECT_EQ(nullptr,
-            factory->MakeAudioEncoder(17, {"bar", 16000, 1}, absl::nullopt));
-  auto enc = factory->MakeAudioEncoder(17, {"bogus", 8000, 1}, absl::nullopt);
-  ASSERT_NE(nullptr, enc);
-  EXPECT_EQ(8000, enc->SampleRateHz());
 
   EXPECT_THAT(factory->Create(env, {"bar", 16000, 1}, {}), IsNull());
   EXPECT_THAT(factory->Create(env, {"bogus", 8000, 1}, {}),
@@ -257,27 +250,18 @@ TEST(AudioEncoderFactoryTemplateTest, TwoEncoderTypes) {
   EXPECT_EQ(
       AudioCodecInfo(16000, 2, 23456),
       factory->QueryAudioEncoder({"sham", 16000, 2, {{"param", "value"}}}));
-  EXPECT_EQ(nullptr,
-            factory->MakeAudioEncoder(17, {"bar", 16000, 1}, absl::nullopt));
-  auto enc1 = factory->MakeAudioEncoder(17, {"bogus", 8000, 1}, absl::nullopt);
-  ASSERT_NE(nullptr, enc1);
-  EXPECT_EQ(8000, enc1->SampleRateHz());
-  EXPECT_EQ(nullptr,
-            factory->MakeAudioEncoder(17, {"sham", 16000, 2}, absl::nullopt));
-  auto enc2 = factory->MakeAudioEncoder(
-      17, {"sham", 16000, 2, {{"param", "value"}}}, absl::nullopt);
-  ASSERT_NE(nullptr, enc2);
-  EXPECT_EQ(16000, enc2->SampleRateHz());
 
   EXPECT_THAT(factory->Create(env, {"bar", 16000, 1}, {}), IsNull());
   EXPECT_THAT(factory->Create(env, {"bogus", 8000, 1}, {}),
               Pointer(Property(&AudioEncoder::SampleRateHz, 8000)));
+  EXPECT_THAT(factory->Create(env, {"sham", 16000, 2}, {}), IsNull());
   EXPECT_THAT(
       factory->Create(env, {"sham", 16000, 2, {{"param", "value"}}}, {}),
       Pointer(Property(&AudioEncoder::SampleRateHz, 16000)));
 }
 
 TEST(AudioEncoderFactoryTemplateTest, G711) {
+  const Environment env = CreateEnvironment();
   auto factory = CreateAudioEncoderFactory<AudioEncoderG711>();
   EXPECT_THAT(factory->GetSupportedEncoders(),
               ::testing::ElementsAre(
@@ -286,17 +270,16 @@ TEST(AudioEncoderFactoryTemplateTest, G711) {
   EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"PCMA", 16000, 1}));
   EXPECT_EQ(AudioCodecInfo(8000, 1, 64000),
             factory->QueryAudioEncoder({"PCMA", 8000, 1}));
-  EXPECT_EQ(nullptr,
-            factory->MakeAudioEncoder(17, {"PCMU", 16000, 1}, absl::nullopt));
-  auto enc1 = factory->MakeAudioEncoder(17, {"PCMU", 8000, 1}, absl::nullopt);
-  ASSERT_NE(nullptr, enc1);
-  EXPECT_EQ(8000, enc1->SampleRateHz());
-  auto enc2 = factory->MakeAudioEncoder(17, {"PCMA", 8000, 1}, absl::nullopt);
-  ASSERT_NE(nullptr, enc2);
-  EXPECT_EQ(8000, enc2->SampleRateHz());
+
+  EXPECT_THAT(factory->Create(env, {"PCMU", 16000, 1}, {}), IsNull());
+  EXPECT_THAT(factory->Create(env, {"PCMU", 8000, 1}, {}),
+              Pointer(Property(&AudioEncoder::SampleRateHz, 8000)));
+  EXPECT_THAT(factory->Create(env, {"PCMA", 8000, 1}, {}),
+              Pointer(Property(&AudioEncoder::SampleRateHz, 8000)));
 }
 
 TEST(AudioEncoderFactoryTemplateTest, G722) {
+  const Environment env = CreateEnvironment();
   auto factory = CreateAudioEncoderFactory<AudioEncoderG722>();
   EXPECT_THAT(factory->GetSupportedEncoders(),
               ::testing::ElementsAre(
@@ -304,14 +287,14 @@ TEST(AudioEncoderFactoryTemplateTest, G722) {
   EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
   EXPECT_EQ(AudioCodecInfo(16000, 1, 64000),
             factory->QueryAudioEncoder({"G722", 8000, 1}));
-  EXPECT_EQ(nullptr,
-            factory->MakeAudioEncoder(17, {"bar", 16000, 1}, absl::nullopt));
-  auto enc = factory->MakeAudioEncoder(17, {"G722", 8000, 1}, absl::nullopt);
-  ASSERT_NE(nullptr, enc);
-  EXPECT_EQ(16000, enc->SampleRateHz());
+
+  EXPECT_THAT(factory->Create(env, {"bar", 16000, 1}, {}), IsNull());
+  EXPECT_THAT(factory->Create(env, {"G722", 8000, 1}, {}),
+              Pointer(Property(&AudioEncoder::SampleRateHz, 16000)));
 }
 
 TEST(AudioEncoderFactoryTemplateTest, Ilbc) {
+  const Environment env = CreateEnvironment();
   auto factory = CreateAudioEncoderFactory<AudioEncoderIlbc>();
   EXPECT_THAT(factory->GetSupportedEncoders(),
               ::testing::ElementsAre(
@@ -319,14 +302,14 @@ TEST(AudioEncoderFactoryTemplateTest, Ilbc) {
   EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
   EXPECT_EQ(AudioCodecInfo(8000, 1, 13333),
             factory->QueryAudioEncoder({"ilbc", 8000, 1}));
-  EXPECT_EQ(nullptr,
-            factory->MakeAudioEncoder(17, {"bar", 8000, 1}, absl::nullopt));
-  auto enc = factory->MakeAudioEncoder(17, {"ilbc", 8000, 1}, absl::nullopt);
-  ASSERT_NE(nullptr, enc);
-  EXPECT_EQ(8000, enc->SampleRateHz());
+
+  EXPECT_THAT(factory->Create(env, {"bar", 8000, 1}, {}), IsNull());
+  EXPECT_THAT(factory->Create(env, {"ilbc", 8000, 1}, {}),
+              Pointer(Property(&AudioEncoder::SampleRateHz, 8000)));
 }
 
 TEST(AudioEncoderFactoryTemplateTest, L16) {
+  const Environment env = CreateEnvironment();
   auto factory = CreateAudioEncoderFactory<AudioEncoderL16>();
   EXPECT_THAT(
       factory->GetSupportedEncoders(),
@@ -340,14 +323,14 @@ TEST(AudioEncoderFactoryTemplateTest, L16) {
   EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"L16", 8000, 0}));
   EXPECT_EQ(AudioCodecInfo(48000, 1, 48000 * 16),
             factory->QueryAudioEncoder({"L16", 48000, 1}));
-  EXPECT_EQ(nullptr,
-            factory->MakeAudioEncoder(17, {"L16", 8000, 0}, absl::nullopt));
-  auto enc = factory->MakeAudioEncoder(17, {"L16", 48000, 2}, absl::nullopt);
-  ASSERT_NE(nullptr, enc);
-  EXPECT_EQ(48000, enc->SampleRateHz());
+
+  EXPECT_THAT(factory->Create(env, {"L16", 8000, 0}, {}), IsNull());
+  EXPECT_THAT(factory->Create(env, {"L16", 48000, 2}, {}),
+              Pointer(Property(&AudioEncoder::SampleRateHz, 48000)));
 }
 
 TEST(AudioEncoderFactoryTemplateTest, Opus) {
+  const Environment env = CreateEnvironment();
   auto factory = CreateAudioEncoderFactory<AudioEncoderOpus>();
   AudioCodecInfo info = {48000, 1, 32000, 6000, 510000};
   info.allow_comfort_noise = false;
@@ -362,11 +345,11 @@ TEST(AudioEncoderFactoryTemplateTest, Opus) {
       info,
       factory->QueryAudioEncoder(
           {"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}}));
-  EXPECT_EQ(nullptr,
-            factory->MakeAudioEncoder(17, {"bar", 16000, 1}, absl::nullopt));
-  auto enc = factory->MakeAudioEncoder(17, {"opus", 48000, 2}, absl::nullopt);
-  ASSERT_NE(nullptr, enc);
-  EXPECT_EQ(48000, enc->SampleRateHz());
+
+  EXPECT_THAT(factory->Create(env, {"bar", 16000, 1}, {.payload_type = 17}),
+              IsNull());
+  EXPECT_THAT(factory->Create(env, {"opus", 48000, 2}, {.payload_type = 17}),
+              Pointer(Property(&AudioEncoder::SampleRateHz, 48000)));
 }
 
 }  // namespace
diff --git a/audio/channel_send_unittest.cc b/audio/channel_send_unittest.cc
index 3d67e8a8e4..5755776397 100644
--- a/audio/channel_send_unittest.cc
+++ b/audio/channel_send_unittest.cc
@@ -67,7 +67,7 @@ class ChannelSendTest : public ::testing::Test {
     encoder_factory_ = CreateBuiltinAudioEncoderFactory();
     SdpAudioFormat opus = SdpAudioFormat("opus", kRtpRateHz, 2);
     std::unique_ptr<AudioEncoder> encoder =
-        encoder_factory_->MakeAudioEncoder(kPayloadType, opus, {});
+        encoder_factory_->Create(env_, opus, {.payload_type = kPayloadType});
     channel_->SetEncoder(kPayloadType, opus, std::move(encoder));
     transport_controller_.EnsureStarted();
     channel_->RegisterSenderCongestionControlObjects(&transport_controller_);
diff --git a/audio/voip/test/BUILD.gn b/audio/voip/test/BUILD.gn
index 5dae88832f..7f120065b5 100644
--- a/audio/voip/test/BUILD.gn
+++ b/audio/voip/test/BUILD.gn
@@ -49,6 +49,8 @@ if (rtc_include_tests) {
       "../../../api:transport_api",
       "../../../api/audio_codecs:builtin_audio_decoder_factory",
       "../../../api/audio_codecs:builtin_audio_encoder_factory",
+      "../../../api/environment",
+      "../../../api/environment:environment_factory",
       "../../../api/task_queue:task_queue",
       "../../../modules/audio_mixer:audio_mixer_impl",
       "../../../modules/audio_mixer:audio_mixer_test_utils",
@@ -70,6 +72,8 @@ if (rtc_include_tests) {
       "../../../api:transport_api",
       "../../../api/audio_codecs:builtin_audio_decoder_factory",
       "../../../api/audio_codecs:builtin_audio_encoder_factory",
+      "../../../api/environment",
+      "../../../api/environment:environment_factory",
       "../../../api/task_queue:default_task_queue_factory",
       "../../../api/units:time_delta",
       "../../../api/units:timestamp",
@@ -91,6 +95,8 @@ if (rtc_include_tests) {
       "..:audio_egress",
       "../../../api:transport_api",
       "../../../api/audio_codecs:builtin_audio_encoder_factory",
+      "../../../api/environment",
+      "../../../api/environment:environment_factory",
       "../../../api/task_queue:default_task_queue_factory",
       "../../../api/units:time_delta",
       "../../../api/units:timestamp",
diff --git a/audio/voip/test/audio_channel_unittest.cc b/audio/voip/test/audio_channel_unittest.cc
index 0c8312b738..08ca47d12d 100644
--- a/audio/voip/test/audio_channel_unittest.cc
+++ b/audio/voip/test/audio_channel_unittest.cc
@@ -14,6 +14,8 @@
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/call/transport.h"
+#include "api/environment/environment.h"
+#include "api/environment/environment_factory.h"
 #include "api/task_queue/task_queue_base.h"
 #include "api/task_queue/task_queue_factory.h"
 #include "audio/voip/test/mock_task_queue.h"
@@ -44,8 +46,11 @@ class AudioChannelTest : public ::testing::Test {
   const SdpAudioFormat kPcmuFormat = {"pcmu", 8000, 1};
 
   AudioChannelTest()
-      : fake_clock_(kStartTime), wave_generator_(1000.0, kAudioLevel) {
-    task_queue_factory_ = std::make_unique<MockTaskQueueFactory>(&task_queue_);
+      : fake_clock_(kStartTime),
+        wave_generator_(1000.0, kAudioLevel),
+        env_(CreateEnvironment(
+            &fake_clock_,
+            std::make_unique<MockTaskQueueFactory>(&task_queue_))) {
     audio_mixer_ = AudioMixerImpl::Create();
     encoder_factory_ = CreateBuiltinAudioEncoderFactory();
     decoder_factory_ = CreateBuiltinAudioDecoderFactory();
@@ -68,11 +73,12 @@ class AudioChannelTest : public ::testing::Test {
     // simplify network routing logic.
     rtc::scoped_refptr<AudioChannel> audio_channel =
         rtc::make_ref_counted<AudioChannel>(
-            &transport_, ssrc, task_queue_factory_.get(), audio_mixer_.get(),
+            &transport_, ssrc, &env_.task_queue_factory(), audio_mixer_.get(),
             decoder_factory_);
-    audio_channel->SetEncoder(kPcmuPayload, kPcmuFormat,
-                              encoder_factory_->MakeAudioEncoder(
-                                  kPcmuPayload, kPcmuFormat, absl::nullopt));
+    audio_channel->SetEncoder(
+        kPcmuPayload, kPcmuFormat,
+        encoder_factory_->Create(env_, kPcmuFormat,
+                                 {.payload_type = kPcmuPayload}));
     audio_channel->SetReceiveCodecs({{kPcmuPayload, kPcmuFormat}});
     audio_channel->StartSend();
     audio_channel->StartPlay();
@@ -93,7 +99,7 @@ class AudioChannelTest : public ::testing::Test {
   SineWaveGenerator wave_generator_;
   NiceMock<MockTransport> transport_;
   NiceMock<MockTaskQueue> task_queue_;
-  std::unique_ptr<TaskQueueFactory> task_queue_factory_;
+  const Environment env_;
   rtc::scoped_refptr<AudioMixer> audio_mixer_;
   rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_;
   rtc::scoped_refptr<AudioEncoderFactory> encoder_factory_;
diff --git a/audio/voip/test/audio_egress_unittest.cc b/audio/voip/test/audio_egress_unittest.cc
index 83df26eef1..c42b78f2e6 100644
--- a/audio/voip/test/audio_egress_unittest.cc
+++ b/audio/voip/test/audio_egress_unittest.cc
@@ -12,7 +12,8 @@
 
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/call/transport.h"
-#include "api/task_queue/default_task_queue_factory.h"
+#include "api/environment/environment.h"
+#include "api/environment/environment_factory.h"
 #include "api/units/time_delta.h"
 #include "api/units/timestamp.h"
 #include "modules/audio_mixer/sine_wave_generator.h"
@@ -74,8 +75,8 @@ class AudioEgressTest : public ::testing::Test {
         time_controller_.GetTaskQueueFactory());
     constexpr int kPcmuPayload = 0;
     egress_->SetEncoder(kPcmuPayload, kPcmuFormat,
-                        encoder_factory_->MakeAudioEncoder(
-                            kPcmuPayload, kPcmuFormat, absl::nullopt));
+                        encoder_factory_->Create(
+                            env_, kPcmuFormat, {.payload_type = kPcmuPayload}));
     egress_->StartSend();
     rtp_rtcp_->SetSequenceNumber(kSeqNum);
     rtp_rtcp_->SetSendingStatus(true);
@@ -104,6 +105,9 @@ class AudioEgressTest : public ::testing::Test {
   }
 
   GlobalSimulatedTimeController time_controller_{Timestamp::Micros(kStartTime)};
+  const Environment env_ =
+      CreateEnvironment(time_controller_.GetClock(),
+                        time_controller_.GetTaskQueueFactory());
   NiceMock<MockTransport> transport_;
   SineWaveGenerator wave_generator_;
   std::unique_ptr<ModuleRtpRtcpImpl2> rtp_rtcp_;
@@ -235,8 +239,8 @@ TEST_F(AudioEgressTest, ChangeEncoderFromPcmuToOpus) {
   const SdpAudioFormat kOpusFormat = {"opus", 48000, 2};
 
   egress_->SetEncoder(kOpusPayload, kOpusFormat,
-                      encoder_factory_->MakeAudioEncoder(
-                          kOpusPayload, kOpusFormat, absl::nullopt));
+                      encoder_factory_->Create(env_, kOpusFormat,
+                                               {.payload_type = kOpusPayload}));
 
   absl::optional<SdpAudioFormat> opus = egress_->GetEncoderFormat();
   EXPECT_TRUE(opus);
diff --git a/audio/voip/test/audio_ingress_unittest.cc b/audio/voip/test/audio_ingress_unittest.cc
index c7736b247a..194d97a55c 100644
--- a/audio/voip/test/audio_ingress_unittest.cc
+++ b/audio/voip/test/audio_ingress_unittest.cc
@@ -13,6 +13,8 @@
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/call/transport.h"
+#include "api/environment/environment.h"
+#include "api/environment/environment_factory.h"
 #include "api/task_queue/default_task_queue_factory.h"
 #include "api/units/time_delta.h"
 #include "audio/voip/audio_egress.h"
@@ -70,8 +72,8 @@ class AudioIngressTest : public ::testing::Test {
         rtp_rtcp_.get(), time_controller_.GetClock(),
         time_controller_.GetTaskQueueFactory());
     egress_->SetEncoder(kPcmuPayload, kPcmuFormat,
-                        encoder_factory_->MakeAudioEncoder(
-                            kPcmuPayload, kPcmuFormat, absl::nullopt));
+                        encoder_factory_->Create(
+                            env_, kPcmuFormat, {.payload_type = kPcmuPayload}));
     egress_->StartSend();
     ingress_->StartPlay();
     rtp_rtcp_->SetSendingStatus(true);
@@ -96,6 +98,9 @@ class AudioIngressTest : public ::testing::Test {
   }
 
   GlobalSimulatedTimeController time_controller_{Timestamp::Micros(123456789)};
+  const Environment env_ =
+      CreateEnvironment(time_controller_.GetClock(),
+                        time_controller_.GetTaskQueueFactory());
   SineWaveGenerator wave_generator_;
   NiceMock<MockTransport> transport_;
   std::unique_ptr<ReceiveStatistics> receive_statistics_;
diff --git a/modules/audio_coding/BUILD.gn b/modules/audio_coding/BUILD.gn
index 5416f83901..bb707774a3 100644
--- a/modules/audio_coding/BUILD.gn
+++ b/modules/audio_coding/BUILD.gn
@@ -942,6 +942,8 @@ rtc_library("audio_coding_modules_tests_shared") {
     "../../api/audio:audio_frame_api",
     "../../api/audio_codecs:builtin_audio_decoder_factory",
     "../../api/audio_codecs:builtin_audio_encoder_factory",
+    "../../api/environment",
+    "../../api/environment:environment_factory",
     "../../api/neteq:neteq_api",
     "../../api/units:timestamp",
     "../../rtc_base:checks",
@@ -1073,6 +1075,8 @@ if (rtc_include_tests) {
       "../../api/audio_codecs/ilbc:audio_encoder_ilbc",
       "../../api/audio_codecs/opus:audio_decoder_opus",
       "../../api/audio_codecs/opus:audio_encoder_opus",
+      "../../api/environment",
+      "../../api/environment:environment_factory",
       "../../api/units:timestamp",
       "../../common_audio",
       "../../rtc_base:checks",
@@ -1155,6 +1159,8 @@ if (rtc_include_tests) {
       "../../api/audio_codecs:audio_codecs_api",
       "../../api/audio_codecs:builtin_audio_decoder_factory",
       "../../api/audio_codecs:builtin_audio_encoder_factory",
+      "../../api/environment",
+      "../../api/environment:environment_factory",
       "../../rtc_base:checks",
       "../../rtc_base:stringutils",
       "../../test:test_support",
@@ -1686,6 +1692,8 @@ if (rtc_include_tests) {
         "../../api/audio_codecs/opus:audio_decoder_opus",
         "../../api/audio_codecs/opus:audio_encoder_multiopus",
         "../../api/audio_codecs/opus:audio_encoder_opus",
+        "../../api/environment",
+        "../../api/environment:environment_factory",
         "../../api/neteq:default_neteq_controller_factory",
         "../../api/neteq:neteq_api",
         "../../api/neteq:neteq_controller_api",
diff --git a/modules/audio_coding/acm2/acm_receiver_unittest.cc b/modules/audio_coding/acm2/acm_receiver_unittest.cc
index e86c718961..8b6342492a 100644
--- a/modules/audio_coding/acm2/acm_receiver_unittest.cc
+++ b/modules/audio_coding/acm2/acm_receiver_unittest.cc
@@ -16,6 +16,8 @@
 #include "absl/types/optional.h"
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
+#include "api/environment/environment.h"
+#include "api/environment/environment_factory.h"
 #include "api/units/timestamp.h"
 #include "modules/audio_coding/codecs/cng/audio_encoder_cng.h"
 #include "modules/audio_coding/include/audio_coding_module.h"
@@ -69,7 +71,7 @@ class AcmReceiverTestOldApi : public AudioPacketizationCallback,
         encoder_factory_->QueryAudioEncoder(format);
     RTC_CHECK(info.has_value());
     std::unique_ptr<AudioEncoder> enc =
-        encoder_factory_->MakeAudioEncoder(payload_type, format, absl::nullopt);
+        encoder_factory_->Create(env_, format, {.payload_type = payload_type});
 
     // If we have a compatible CN specification, stack a CNG on top.
     auto it = cng_payload_types.find(info->sample_rate_hz);
@@ -132,6 +134,7 @@ class AcmReceiverTestOldApi : public AudioPacketizationCallback,
     return 0;
   }
 
+  const Environment env_ = CreateEnvironment();
   const rtc::scoped_refptr<AudioEncoderFactory> encoder_factory_ =
       CreateBuiltinAudioEncoderFactory();
   const rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_ =
diff --git a/modules/audio_coding/acm2/acm_send_test.cc b/modules/audio_coding/acm2/acm_send_test.cc
index fddaa87701..c08fd4d661 100644
--- a/modules/audio_coding/acm2/acm_send_test.cc
+++ b/modules/audio_coding/acm2/acm_send_test.cc
@@ -18,6 +18,7 @@
 #include "api/audio_codecs/audio_encoder.h"
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
+#include "api/environment/environment_factory.h"
 #include "modules/audio_coding/include/audio_coding_module.h"
 #include "modules/audio_coding/neteq/tools/input_audio_file.h"
 #include "modules/audio_coding/neteq/tools/packet.h"
@@ -32,6 +33,7 @@ AcmSendTestOldApi::AcmSendTestOldApi(InputAudioFile* audio_source,
                                      int source_rate_hz,
                                      int test_duration_ms)
     : clock_(0),
+      env_(CreateEnvironment(&clock_)),
       acm_(webrtc::AudioCodingModule::Create()),
       audio_source_(audio_source),
       source_rate_hz_(source_rate_hz),
@@ -73,7 +75,7 @@ bool AcmSendTestOldApi::RegisterCodec(absl::string_view payload_name,
       frame_size_samples, rtc::CheckedDivExact(clockrate_hz, 1000)));
   auto factory = CreateBuiltinAudioEncoderFactory();
   acm_->SetEncoder(
-      factory->MakeAudioEncoder(payload_type, format, absl::nullopt));
+      factory->Create(env_, format, {.payload_type = payload_type}));
   codec_registered_ = true;
   input_frame_.num_channels_ = num_channels;
   RTC_DCHECK_LE(input_block_size_samples_ * input_frame_.num_channels_,
diff --git a/modules/audio_coding/acm2/acm_send_test.h b/modules/audio_coding/acm2/acm_send_test.h
index 0bd24705fd..1bba67618b 100644
--- a/modules/audio_coding/acm2/acm_send_test.h
+++ b/modules/audio_coding/acm2/acm_send_test.h
@@ -16,6 +16,7 @@
 
 #include "absl/strings/string_view.h"
 #include "api/audio/audio_frame.h"
+#include "api/environment/environment.h"
 #include "modules/audio_coding/include/audio_coding_module.h"
 #include "modules/audio_coding/neteq/tools/packet_source.h"
 #include "system_wrappers/include/clock.h"
@@ -70,6 +71,7 @@ class AcmSendTestOldApi : public AudioPacketizationCallback,
   std::unique_ptr<Packet> CreatePacket();
 
   SimulatedClock clock_;
+  const Environment env_;
   std::unique_ptr<AudioCodingModule> acm_;
   InputAudioFile* audio_source_;
   int source_rate_hz_;
diff --git a/modules/audio_coding/acm2/audio_coding_module_unittest.cc b/modules/audio_coding/acm2/audio_coding_module_unittest.cc
index 44e7bceb32..8eaa2bf0c1 100644
--- a/modules/audio_coding/acm2/audio_coding_module_unittest.cc
+++ b/modules/audio_coding/acm2/audio_coding_module_unittest.cc
@@ -25,6 +25,8 @@
 #include "api/audio_codecs/opus/audio_decoder_opus.h"
 #include "api/audio_codecs/opus/audio_encoder_multi_channel_opus.h"
 #include "api/audio_codecs/opus/audio_encoder_opus.h"
+#include "api/environment/environment.h"
+#include "api/environment/environment_factory.h"
 #include "api/units/timestamp.h"
 #include "modules/audio_coding/acm2/acm_receive_test.h"
 #include "modules/audio_coding/acm2/acm_send_test.h"
@@ -163,8 +165,8 @@ class PacketizationCallbackStubOldApi : public AudioPacketizationCallback {
 class AudioCodingModuleTestOldApi : public ::testing::Test {
  protected:
   AudioCodingModuleTestOldApi()
-      : rtp_utility_(new RtpData(kFrameSizeSamples, kPayloadType)),
-        clock_(Clock::GetRealTimeClock()) {}
+      : env_(CreateEnvironment()),
+        rtp_utility_(new RtpData(kFrameSizeSamples, kPayloadType)) {}
 
   ~AudioCodingModuleTestOldApi() {}
 
@@ -173,7 +175,7 @@ class AudioCodingModuleTestOldApi : public ::testing::Test {
   void SetUp() {
     acm_ = AudioCodingModule::Create();
     acm2::AcmReceiver::Config config;
-    config.clock = *clock_;
+    config.clock = env_.clock();
     config.decoder_factory = CreateBuiltinAudioDecoderFactory();
     acm_receiver_ = std::make_unique<acm2::AcmReceiver>(config);
 
@@ -199,8 +201,8 @@ class AudioCodingModuleTestOldApi : public ::testing::Test {
 
   virtual void RegisterCodec() {
     acm_receiver_->SetCodecs({{kPayloadType, *audio_format_}});
-    acm_->SetEncoder(CreateBuiltinAudioEncoderFactory()->MakeAudioEncoder(
-        kPayloadType, *audio_format_, absl::nullopt));
+    acm_->SetEncoder(CreateBuiltinAudioEncoderFactory()->Create(
+        env_, *audio_format_, {.payload_type = kPayloadType}));
   }
 
   virtual void InsertPacketAndPullAudio() {
@@ -240,6 +242,7 @@ class AudioCodingModuleTestOldApi : public ::testing::Test {
     VerifyEncoding();
   }
 
+  Environment env_;
   std::unique_ptr<RtpData> rtp_utility_;
   std::unique_ptr<AudioCodingModule> acm_;
   std::unique_ptr<acm2::AcmReceiver> acm_receiver_;
@@ -249,8 +252,6 @@ class AudioCodingModuleTestOldApi : public ::testing::Test {
 
   absl::optional<SdpAudioFormat> audio_format_;
   int pac_size_ = -1;
-
-  Clock* clock_;
 };
 
 class AudioCodingModuleTestOldApiDeathTest
@@ -381,7 +382,9 @@ class AudioCodingModuleMtTestOldApi : public AudioCodingModuleTestOldApi {
         pull_audio_count_(0),
         next_insert_packet_time_ms_(0),
         fake_clock_(new SimulatedClock(0)) {
-    clock_ = fake_clock_.get();
+    EnvironmentFactory override_clock(env_);
+    override_clock.Set(fake_clock_.get());
+    env_ = override_clock.Create();
   }
 
   void SetUp() {
@@ -458,7 +461,7 @@ class AudioCodingModuleMtTestOldApi : public AudioCodingModuleTestOldApi {
     SleepMs(1);
     {
       MutexLock lock(&mutex_);
-      if (clock_->TimeInMilliseconds() < next_insert_packet_time_ms_) {
+      if (env_.clock().TimeInMilliseconds() < next_insert_packet_time_ms_) {
         return;
       }
       next_insert_packet_time_ms_ += 10;
@@ -473,7 +476,7 @@ class AudioCodingModuleMtTestOldApi : public AudioCodingModuleTestOldApi {
     {
       MutexLock lock(&mutex_);
       // Don't let the insert thread fall behind.
-      if (next_insert_packet_time_ms_ < clock_->TimeInMilliseconds()) {
+      if (next_insert_packet_time_ms_ < env_.clock().TimeInMilliseconds()) {
         return;
       }
       ++pull_audio_count_;
@@ -534,9 +537,10 @@ class AcmAbsoluteCaptureTimestamp : public ::testing::Test {
     rtc::scoped_refptr<AudioEncoderFactory> codec_factory =
         CreateBuiltinAudioEncoderFactory();
     acm_ = AudioCodingModule::Create();
-    std::unique_ptr<AudioEncoder> encoder = codec_factory->MakeAudioEncoder(
-        111, SdpAudioFormat("OPUS", kSampleRateHz, kNumChannels),
-        absl::nullopt);
+    std::unique_ptr<AudioEncoder> encoder = codec_factory->Create(
+        CreateEnvironment(),
+        SdpAudioFormat("OPUS", kSampleRateHz, kNumChannels),
+        {.payload_type = 111});
     encoder->SetDtx(true);
     encoder->SetReceiverFrameLengthRange(kPTimeMs, kPTimeMs);
     acm_->SetEncoder(std::move(encoder));
diff --git a/modules/audio_coding/codecs/builtin_audio_encoder_factory_unittest.cc b/modules/audio_coding/codecs/builtin_audio_encoder_factory_unittest.cc
index 95b67de610..6ca08b517a 100644
--- a/modules/audio_coding/codecs/builtin_audio_encoder_factory_unittest.cc
+++ b/modules/audio_coding/codecs/builtin_audio_encoder_factory_unittest.cc
@@ -14,6 +14,8 @@
 #include <memory>
 #include <vector>
 
+#include "api/environment/environment.h"
+#include "api/environment/environment_factory.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
@@ -40,11 +42,12 @@ TEST_P(AudioEncoderFactoryTest, CanQueryAllSupportedFormats) {
 }
 
 TEST_P(AudioEncoderFactoryTest, CanConstructAllSupportedEncoders) {
+  const Environment env = CreateEnvironment();
   auto factory = GetParam();
   auto supported_encoders = factory->GetSupportedEncoders();
   for (const auto& spec : supported_encoders) {
     auto info = factory->QueryAudioEncoder(spec.format);
-    auto encoder = factory->MakeAudioEncoder(127, spec.format, absl::nullopt);
+    auto encoder = factory->Create(env, spec.format, {.payload_type = 127});
     EXPECT_TRUE(encoder);
     EXPECT_EQ(encoder->SampleRateHz(), info->sample_rate_hz);
     EXPECT_EQ(encoder->NumChannels(), info->num_channels);
@@ -54,6 +57,7 @@ TEST_P(AudioEncoderFactoryTest, CanConstructAllSupportedEncoders) {
 
 TEST_P(AudioEncoderFactoryTest, CanRunAllSupportedEncoders) {
   constexpr int kTestPayloadType = 127;
+  const Environment env = CreateEnvironment();
   auto factory = GetParam();
   auto supported_encoders = factory->GetSupportedEncoders();
   for (const auto& spec : supported_encoders) {
@@ -64,7 +68,7 @@ TEST_P(AudioEncoderFactoryTest, CanRunAllSupportedEncoders) {
     }
 #endif
     auto encoder =
-        factory->MakeAudioEncoder(kTestPayloadType, spec.format, absl::nullopt);
+        factory->Create(env, spec.format, {.payload_type = kTestPayloadType});
     EXPECT_TRUE(encoder);
     encoder->Reset();
     const int num_samples = rtc::checked_cast<int>(
@@ -153,6 +157,7 @@ TEST(BuiltinAudioEncoderFactoryTest, SupportsTheExpectedFormats) {
 
 // Tests that using more channels than the maximum does not work.
 TEST(BuiltinAudioEncoderFactoryTest, MaxNrOfChannels) {
+  const Environment env = CreateEnvironment();
   rtc::scoped_refptr<AudioEncoderFactory> aef =
       CreateBuiltinAudioEncoderFactory();
   std::vector<std::string> codecs = {
@@ -173,11 +178,10 @@ TEST(BuiltinAudioEncoderFactoryTest, MaxNrOfChannels) {
   };
 
   for (auto codec : codecs) {
-    EXPECT_FALSE(aef->MakeAudioEncoder(
-        /*payload_type=*/111,
-        /*format=*/
+    EXPECT_FALSE(aef->Create(
+        env, /*format=*/
         SdpAudioFormat(codec, 32000, AudioEncoder::kMaxNumberOfChannels + 1),
-        /*codec_pair_id=*/absl::nullopt));
+        {.payload_type = 111}));
   }
 }
 
diff --git a/modules/audio_coding/test/EncodeDecodeTest.cc b/modules/audio_coding/test/EncodeDecodeTest.cc
index c51ad370d8..a480773cb6 100644
--- a/modules/audio_coding/test/EncodeDecodeTest.cc
+++ b/modules/audio_coding/test/EncodeDecodeTest.cc
@@ -18,6 +18,8 @@
 #include "absl/strings/string_view.h"
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
+#include "api/environment/environment.h"
+#include "api/environment/environment_factory.h"
 #include "modules/audio_coding/include/audio_coding_module.h"
 #include "rtc_base/strings/string_builder.h"
 #include "test/gtest.h"
@@ -67,8 +69,8 @@ void Sender::Setup(AudioCodingModule* acm,
   // Fast-forward 1 second (100 blocks) since the file starts with silence.
   _pcmFile.FastForward(100);
 
-  acm->SetEncoder(CreateBuiltinAudioEncoderFactory()->MakeAudioEncoder(
-      payload_type, format, absl::nullopt));
+  acm->SetEncoder(CreateBuiltinAudioEncoderFactory()->Create(
+      CreateEnvironment(), format, {.payload_type = payload_type}));
   _packetization = new TestPacketization(rtpStream, format.clockrate_hz);
   EXPECT_EQ(0, acm->RegisterTransportCallback(_packetization));
 
diff --git a/modules/audio_coding/test/TestAllCodecs.cc b/modules/audio_coding/test/TestAllCodecs.cc
index 9d9c317b7c..821b88117d 100644
--- a/modules/audio_coding/test/TestAllCodecs.cc
+++ b/modules/audio_coding/test/TestAllCodecs.cc
@@ -17,6 +17,7 @@
 #include "absl/strings/match.h"
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
+#include "api/environment/environment_factory.h"
 #include "modules/audio_coding/include/audio_coding_module_typedefs.h"
 #include "modules/include/module_common_types.h"
 #include "rtc_base/logging.h"
@@ -107,7 +108,8 @@ void TestPack::reset_payload_size() {
 }
 
 TestAllCodecs::TestAllCodecs()
-    : acm_a_(AudioCodingModule::Create()),
+    : env_(CreateEnvironment()),
+      acm_a_(AudioCodingModule::Create()),
       acm_b_(std::make_unique<acm2::AcmReceiver>(
           acm2::AcmReceiver::Config(CreateBuiltinAudioDecoderFactory()))),
       channel_a_to_b_(NULL),
@@ -319,12 +321,10 @@ void TestAllCodecs::RegisterSendCodec(char* codec_name,
   }
 
   auto factory = CreateBuiltinAudioEncoderFactory();
-  constexpr int payload_type = 17;
   SdpAudioFormat format = {codec_name, clockrate_hz, num_channels};
   format.parameters["ptime"] = rtc::ToString(rtc::CheckedDivExact(
       packet_size, rtc::CheckedDivExact(sampling_freq_hz, 1000)));
-  acm_a_->SetEncoder(
-      factory->MakeAudioEncoder(payload_type, format, absl::nullopt));
+  acm_a_->SetEncoder(factory->Create(env_, format, {.payload_type = 17}));
 }
 
 void TestAllCodecs::Run(TestPack* channel) {
diff --git a/modules/audio_coding/test/TestAllCodecs.h b/modules/audio_coding/test/TestAllCodecs.h
index a17038ad84..e078f49f42 100644
--- a/modules/audio_coding/test/TestAllCodecs.h
+++ b/modules/audio_coding/test/TestAllCodecs.h
@@ -13,6 +13,7 @@
 
 #include <memory>
 
+#include "api/environment/environment.h"
 #include "modules/audio_coding/acm2/acm_receiver.h"
 #include "modules/audio_coding/include/audio_coding_module.h"
 #include "modules/audio_coding/test/PCMFile.h"
@@ -68,6 +69,7 @@ class TestAllCodecs {
   void Run(TestPack* channel);
   void OpenOutFile(int test_number);
 
+  const Environment env_;
   std::unique_ptr<AudioCodingModule> acm_a_;
   std::unique_ptr<acm2::AcmReceiver> acm_b_;
   TestPack* channel_a_to_b_;
diff --git a/modules/audio_coding/test/TestRedFec.cc b/modules/audio_coding/test/TestRedFec.cc
index 83e5d61f36..6f765e9407 100644
--- a/modules/audio_coding/test/TestRedFec.cc
+++ b/modules/audio_coding/test/TestRedFec.cc
@@ -24,6 +24,7 @@
 #include "api/audio_codecs/g722/audio_encoder_g722.h"
 #include "api/audio_codecs/opus/audio_decoder_opus.h"
 #include "api/audio_codecs/opus/audio_encoder_opus.h"
+#include "api/environment/environment_factory.h"
 #include "modules/audio_coding/codecs/cng/audio_encoder_cng.h"
 #include "modules/audio_coding/codecs/red/audio_encoder_copy_red.h"
 #include "modules/audio_coding/include/audio_coding_module_typedefs.h"
@@ -34,7 +35,8 @@
 namespace webrtc {
 
 TestRedFec::TestRedFec()
-    : encoder_factory_(CreateAudioEncoderFactory<AudioEncoderG711,
+    : env_(CreateEnvironment(&field_trials_)),
+      encoder_factory_(CreateAudioEncoderFactory<AudioEncoderG711,
                                                  AudioEncoderG722,
                                                  AudioEncoderL16,
                                                  AudioEncoderOpus>()),
@@ -136,8 +138,8 @@ void TestRedFec::RegisterSendCodec(
     bool use_red) {
   constexpr int payload_type = 17, cn_payload_type = 27, red_payload_type = 37;
 
-  auto encoder = encoder_factory_->MakeAudioEncoder(payload_type, codec_format,
-                                                    absl::nullopt);
+  auto encoder = encoder_factory_->Create(env_, codec_format,
+                                          {.payload_type = payload_type});
   EXPECT_NE(encoder, nullptr);
   std::map<int, SdpAudioFormat> receive_codecs = {{payload_type, codec_format}};
   if (!absl::EqualsIgnoreCase(codec_format.name, "opus")) {
diff --git a/modules/audio_coding/test/TestRedFec.h b/modules/audio_coding/test/TestRedFec.h
index 173b03f4fc..8c43c1d582 100644
--- a/modules/audio_coding/test/TestRedFec.h
+++ b/modules/audio_coding/test/TestRedFec.h
@@ -16,6 +16,7 @@
 
 #include "api/audio_codecs/audio_decoder_factory.h"
 #include "api/audio_codecs/audio_encoder_factory.h"
+#include "api/environment/environment.h"
 #include "common_audio/vad/include/vad.h"
 #include "modules/audio_coding/acm2/acm_receiver.h"
 #include "modules/audio_coding/test/Channel.h"
@@ -40,6 +41,7 @@ class TestRedFec final {
   void OpenOutFile(int16_t testNumber);
 
   test::ScopedKeyValueConfig field_trials_;
+  const Environment env_;
   const rtc::scoped_refptr<AudioEncoderFactory> encoder_factory_;
   const rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_;
   std::unique_ptr<AudioCodingModule> _acmA;
diff --git a/modules/audio_coding/test/TestStereo.cc b/modules/audio_coding/test/TestStereo.cc
index cf1f91365f..535aadb495 100644
--- a/modules/audio_coding/test/TestStereo.cc
+++ b/modules/audio_coding/test/TestStereo.cc
@@ -15,6 +15,7 @@
 #include "absl/strings/match.h"
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
+#include "api/environment/environment_factory.h"
 #include "modules/audio_coding/include/audio_coding_module_typedefs.h"
 #include "modules/include/module_common_types.h"
 #include "rtc_base/strings/string_builder.h"
@@ -98,7 +99,8 @@ void TestPackStereo::set_lost_packet(bool lost) {
 }
 
 TestStereo::TestStereo()
-    : acm_a_(AudioCodingModule::Create()),
+    : env_(CreateEnvironment()),
+      acm_a_(AudioCodingModule::Create()),
       acm_b_(std::make_unique<acm2::AcmReceiver>(
           acm2::AcmReceiver::Config(CreateBuiltinAudioDecoderFactory()))),
       channel_a2b_(NULL),
@@ -488,10 +490,9 @@ void TestStereo::RegisterSendCodec(char side,
     channels = 2;
     params["maxaveragebitrate"] = rtc::ToString(rate);
   }
-  constexpr int payload_type = 17;
-  auto encoder = encoder_factory->MakeAudioEncoder(
-      payload_type, SdpAudioFormat(codec_name, clockrate_hz, channels, params),
-      absl::nullopt);
+  auto encoder = encoder_factory->Create(
+      env_, SdpAudioFormat(codec_name, clockrate_hz, channels, params),
+      {.payload_type = 17});
   EXPECT_NE(nullptr, encoder);
   my_acm->SetEncoder(std::move(encoder));
 
diff --git a/modules/audio_coding/test/TestStereo.h b/modules/audio_coding/test/TestStereo.h
index a215c90ec1..b53187b9d5 100644
--- a/modules/audio_coding/test/TestStereo.h
+++ b/modules/audio_coding/test/TestStereo.h
@@ -15,6 +15,7 @@
 
 #include <memory>
 
+#include "api/environment/environment.h"
 #include "modules/audio_coding/acm2/acm_receiver.h"
 #include "modules/audio_coding/include/audio_coding_module.h"
 #include "modules/audio_coding/test/PCMFile.h"
@@ -81,6 +82,7 @@ class TestStereo {
            int percent_loss = 0);
   void OpenOutFile(int16_t test_number);
 
+  const Environment env_;
   std::unique_ptr<AudioCodingModule> acm_a_;
   std::unique_ptr<acm2::AcmReceiver> acm_b_;
 
diff --git a/modules/audio_coding/test/TestVADDTX.cc b/modules/audio_coding/test/TestVADDTX.cc
index d6595c047c..17eba26567 100644
--- a/modules/audio_coding/test/TestVADDTX.cc
+++ b/modules/audio_coding/test/TestVADDTX.cc
@@ -20,6 +20,7 @@
 #include "api/audio_codecs/ilbc/audio_encoder_ilbc.h"
 #include "api/audio_codecs/opus/audio_decoder_opus.h"
 #include "api/audio_codecs/opus/audio_encoder_opus.h"
+#include "api/environment/environment_factory.h"
 #include "modules/audio_coding/codecs/cng/audio_encoder_cng.h"
 #include "modules/audio_coding/test/PCMFile.h"
 #include "rtc_base/strings/string_builder.h"
@@ -66,7 +67,8 @@ void MonitoringAudioPacketizationCallback::GetStatistics(uint32_t* counter) {
 }
 
 TestVadDtx::TestVadDtx()
-    : encoder_factory_(
+    : env_(CreateEnvironment()),
+      encoder_factory_(
           CreateAudioEncoderFactory<AudioEncoderIlbc, AudioEncoderOpus>()),
       decoder_factory_(
           CreateAudioDecoderFactory<AudioDecoderIlbc, AudioDecoderOpus>()),
@@ -87,8 +89,8 @@ bool TestVadDtx::RegisterCodec(const SdpAudioFormat& codec_format,
   constexpr int payload_type = 17, cn_payload_type = 117;
   bool added_comfort_noise = false;
 
-  auto encoder = encoder_factory_->MakeAudioEncoder(payload_type, codec_format,
-                                                    absl::nullopt);
+  auto encoder = encoder_factory_->Create(env_, codec_format,
+                                          {.payload_type = payload_type});
   if (vad_mode.has_value() &&
       !absl::EqualsIgnoreCase(codec_format.name, "opus")) {
     AudioEncoderCngConfig config;
diff --git a/modules/audio_coding/test/TestVADDTX.h b/modules/audio_coding/test/TestVADDTX.h
index 17b3f4185d..427c94c106 100644
--- a/modules/audio_coding/test/TestVADDTX.h
+++ b/modules/audio_coding/test/TestVADDTX.h
@@ -16,6 +16,7 @@
 #include "absl/strings/string_view.h"
 #include "api/audio_codecs/audio_decoder_factory.h"
 #include "api/audio_codecs/audio_encoder_factory.h"
+#include "api/environment/environment.h"
 #include "common_audio/vad/include/vad.h"
 #include "modules/audio_coding/acm2/acm_receiver.h"
 #include "modules/audio_coding/include/audio_coding_module.h"
@@ -82,6 +83,7 @@ class TestVadDtx {
            bool append,
            const int* expects);
 
+  const Environment env_;
   const rtc::scoped_refptr<AudioEncoderFactory> encoder_factory_;
   const rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_;
   std::unique_ptr<AudioCodingModule> acm_send_;
diff --git a/pc/BUILD.gn b/pc/BUILD.gn
index 51025ecef4..062980c19d 100644
--- a/pc/BUILD.gn
+++ b/pc/BUILD.gn
@@ -2338,6 +2338,7 @@ if (rtc_include_tests && !build_with_chromium) {
       "../api/crypto:frame_decryptor_interface",
       "../api/crypto:frame_encryptor_interface",
       "../api/crypto:options",
+      "../api/environment",
       "../api/environment:environment_factory",
       "../api/rtc_event_log",
       "../api/rtc_event_log:rtc_event_log_factory",
diff --git a/pc/peer_connection_end_to_end_unittest.cc b/pc/peer_connection_end_to_end_unittest.cc
index 5881cf45b5..516a01edce 100644
--- a/pc/peer_connection_end_to_end_unittest.cc
+++ b/pc/peer_connection_end_to_end_unittest.cc
@@ -34,6 +34,7 @@
 #include "api/audio_codecs/opus_audio_encoder_factory.h"
 #include "api/audio_options.h"
 #include "api/data_channel_interface.h"
+#include "api/environment/environment.h"
 #include "api/media_stream_interface.h"
 #include "api/peer_connection_interface.h"
 #include "api/rtc_error.h"
@@ -63,11 +64,11 @@ using ::testing::AtLeast;
 using ::testing::Invoke;
 using ::testing::StrictMock;
 using ::testing::Values;
-
-using webrtc::DataChannelInterface;
-using webrtc::MediaStreamInterface;
-using webrtc::PeerConnectionInterface;
-using webrtc::SdpSemantics;
+using ::webrtc::DataChannelInterface;
+using ::webrtc::Environment;
+using ::webrtc::MediaStreamInterface;
+using ::webrtc::PeerConnectionInterface;
+using ::webrtc::SdpSemantics;
 
 namespace {
 
@@ -427,6 +428,14 @@ TEST_P(PeerConnectionEndToEndTest, CallWithCustomCodec) {
       codec_ids_->push_back(*codec_pair_id);
       return fact_->MakeAudioEncoder(payload_type, format, codec_pair_id);
     }
+    std::unique_ptr<webrtc::AudioEncoder> Create(
+        const Environment& env,
+        const webrtc::SdpAudioFormat& format,
+        Options options) override {
+      EXPECT_TRUE(options.codec_pair_id.has_value());
+      codec_ids_->push_back(*options.codec_pair_id);
+      return fact_->Create(env, format, options);
+    }
 
    private:
     const rtc::scoped_refptr<webrtc::AudioEncoderFactory> fact_;