diff --git a/media/engine/internal_decoder_factory.cc b/media/engine/internal_decoder_factory.cc
index e623aeb43a..d79cbf2712 100644
--- a/media/engine/internal_decoder_factory.cc
+++ b/media/engine/internal_decoder_factory.cc
@@ -11,6 +11,7 @@
 #include "media/engine/internal_decoder_factory.h"
 
 #include "absl/strings/match.h"
+#include "api/environment/environment.h"
 #include "api/video_codecs/av1_profile.h"
 #include "api/video_codecs/sdp_video_format.h"
 #include "api/video_codecs/video_codec.h"
@@ -78,7 +79,8 @@ VideoDecoderFactory::CodecSupport InternalDecoderFactory::QueryCodecSupport(
   return codec_support;
 }
 
-std::unique_ptr<VideoDecoder> InternalDecoderFactory::CreateVideoDecoder(
+std::unique_ptr<VideoDecoder> InternalDecoderFactory::Create(
+    const Environment& env,
     const SdpVideoFormat& format) {
   if (!format.IsCodecInList(GetSupportedFormats())) {
     RTC_LOG(LS_WARNING) << "Trying to create decoder for unsupported format. "
@@ -87,7 +89,7 @@ std::unique_ptr<VideoDecoder> InternalDecoderFactory::CreateVideoDecoder(
   }
 
   if (absl::EqualsIgnoreCase(format.name, cricket::kVp8CodecName))
-    return VP8Decoder::Create();
+    return CreateVp8Decoder(env);
   if (absl::EqualsIgnoreCase(format.name, cricket::kVp9CodecName))
     return VP9Decoder::Create();
   if (absl::EqualsIgnoreCase(format.name, cricket::kH264CodecName))
diff --git a/media/engine/internal_decoder_factory.h b/media/engine/internal_decoder_factory.h
index 0129fb2173..a2cd362069 100644
--- a/media/engine/internal_decoder_factory.h
+++ b/media/engine/internal_decoder_factory.h
@@ -14,6 +14,7 @@
 #include <memory>
 #include <vector>
 
+#include "api/environment/environment.h"
 #include "api/video_codecs/sdp_video_format.h"
 #include "api/video_codecs/video_decoder.h"
 #include "api/video_codecs/video_decoder_factory.h"
@@ -26,8 +27,8 @@ class RTC_EXPORT InternalDecoderFactory : public VideoDecoderFactory {
   std::vector<SdpVideoFormat> GetSupportedFormats() const override;
   CodecSupport QueryCodecSupport(const SdpVideoFormat& format,
                                  bool reference_scaling) const override;
-  std::unique_ptr<VideoDecoder> CreateVideoDecoder(
-      const SdpVideoFormat& format) override;
+  std::unique_ptr<VideoDecoder> Create(const Environment& env,
+                                       const SdpVideoFormat& format) override;
 };
 
 }  // namespace webrtc
diff --git a/media/engine/internal_decoder_factory_unittest.cc b/media/engine/internal_decoder_factory_unittest.cc
index e06b4c3d77..7debe737f5 100644
--- a/media/engine/internal_decoder_factory_unittest.cc
+++ b/media/engine/internal_decoder_factory_unittest.cc
@@ -10,6 +10,8 @@
 
 #include "media/engine/internal_decoder_factory.h"
 
+#include "api/environment/environment.h"
+#include "api/environment/environment_factory.h"
 #include "api/video_codecs/av1_profile.h"
 #include "api/video_codecs/sdp_video_format.h"
 #include "api/video_codecs/video_decoder.h"
@@ -56,44 +58,48 @@ MATCHER_P(Support, expected, "") {
 }
 
 TEST(InternalDecoderFactoryTest, Vp8) {
+  const Environment env = CreateEnvironment();
   InternalDecoderFactory factory;
   std::unique_ptr<VideoDecoder> decoder =
-      factory.CreateVideoDecoder(SdpVideoFormat(cricket::kVp8CodecName));
+      factory.Create(env, SdpVideoFormat(cricket::kVp8CodecName));
   EXPECT_TRUE(decoder);
 }
 
 TEST(InternalDecoderFactoryTest, Vp9Profile0) {
+  const Environment env = CreateEnvironment();
   InternalDecoderFactory factory;
-  std::unique_ptr<VideoDecoder> decoder =
-      factory.CreateVideoDecoder(SdpVideoFormat(
-          cricket::kVp9CodecName,
-          {{kVP9FmtpProfileId, VP9ProfileToString(VP9Profile::kProfile0)}}));
+  std::unique_ptr<VideoDecoder> decoder = factory.Create(
+      env, SdpVideoFormat(cricket::kVp9CodecName,
+                          {{kVP9FmtpProfileId,
+                            VP9ProfileToString(VP9Profile::kProfile0)}}));
   EXPECT_EQ(static_cast<bool>(decoder), kVp9Enabled);
 }
 
 TEST(InternalDecoderFactoryTest, Vp9Profile1) {
+  const Environment env = CreateEnvironment();
   InternalDecoderFactory factory;
-  std::unique_ptr<VideoDecoder> decoder =
-      factory.CreateVideoDecoder(SdpVideoFormat(
-          cricket::kVp9CodecName,
-          {{kVP9FmtpProfileId, VP9ProfileToString(VP9Profile::kProfile1)}}));
+  std::unique_ptr<VideoDecoder> decoder = factory.Create(
+      env, SdpVideoFormat(cricket::kVp9CodecName,
+                          {{kVP9FmtpProfileId,
+                            VP9ProfileToString(VP9Profile::kProfile1)}}));
   EXPECT_EQ(static_cast<bool>(decoder), kVp9Enabled);
 }
 
 TEST(InternalDecoderFactoryTest, H264) {
+  const Environment env = CreateEnvironment();
   InternalDecoderFactory factory;
   std::unique_ptr<VideoDecoder> decoder =
-      factory.CreateVideoDecoder(SdpVideoFormat(cricket::kH264CodecName));
+      factory.Create(env, SdpVideoFormat(cricket::kH264CodecName));
   EXPECT_EQ(static_cast<bool>(decoder), kH264Enabled);
 }
 
 TEST(InternalDecoderFactoryTest, Av1Profile0) {
+  const Environment env = CreateEnvironment();
   InternalDecoderFactory factory;
   if (kDav1dIsIncluded) {
     EXPECT_THAT(factory.GetSupportedFormats(),
                 Contains(Field(&SdpVideoFormat::name, cricket::kAv1CodecName)));
-    EXPECT_TRUE(
-        factory.CreateVideoDecoder(SdpVideoFormat(cricket::kAv1CodecName)));
+    EXPECT_TRUE(factory.Create(env, SdpVideoFormat(cricket::kAv1CodecName)));
   } else {
     EXPECT_THAT(
         factory.GetSupportedFormats(),
@@ -103,9 +109,10 @@ TEST(InternalDecoderFactoryTest, Av1Profile0) {
 
 // At current stage since internal H.265 decoder is not implemented,
 TEST(InternalDecoderFactoryTest, H265IsNotEnabled) {
+  const Environment env = CreateEnvironment();
   InternalDecoderFactory factory;
   std::unique_ptr<VideoDecoder> decoder =
-      factory.CreateVideoDecoder(SdpVideoFormat(cricket::kH265CodecName));
+      factory.Create(env, SdpVideoFormat(cricket::kH265CodecName));
   EXPECT_EQ(static_cast<bool>(decoder), kH265Enabled);
 }
 
@@ -118,8 +125,10 @@ TEST(InternalDecoderFactoryTest, Av1) {
 #endif
 
 TEST(InternalDecoderFactoryTest, Av1Profile1_Dav1dDecoderTrialEnabled) {
+  const Environment env = CreateEnvironment();
   InternalDecoderFactory factory;
-  std::unique_ptr<VideoDecoder> decoder = factory.CreateVideoDecoder(
+  std::unique_ptr<VideoDecoder> decoder = factory.Create(
+      env,
       SdpVideoFormat(cricket::kAv1CodecName,
                      {{cricket::kAv1FmtpProfile,
                        AV1ProfileToString(AV1Profile::kProfile1).data()}}));