diff --git a/media/base/codec.h b/media/base/codec.h
index af604b7..99a6852 100644
--- a/media/base/codec.h
+++ b/media/base/codec.h
@@ -200,11 +200,12 @@
 };
 
 // TODO(webrtc:15214): Compatibility names, to be migrated away and removed.
-using VideoCodec = Codec;
-using AudioCodec = Codec;
+using VideoCodec [[deprecated]] = Codec;
+using AudioCodec [[deprecated]] = Codec;
 
-using VideoCodecs = std::vector<Codec>;
-using AudioCodecs = std::vector<Codec>;
+using VideoCodecs [[deprecated]] = std::vector<Codec>;
+using AudioCodecs [[deprecated]] = std::vector<Codec>;
+using Codecs = std::vector<Codec>;
 
 Codec CreateAudioCodec(int id,
                        const std::string& name,
diff --git a/media/base/codec_unittest.cc b/media/base/codec_unittest.cc
index b985259..08b37fb 100644
--- a/media/base/codec_unittest.cc
+++ b/media/base/codec_unittest.cc
@@ -18,13 +18,11 @@
 #include "modules/video_coding/codecs/h264/include/h264.h"
 #include "rtc_base/gunit.h"
 
-using cricket::AudioCodec;
 using cricket::Codec;
 using cricket::FeedbackParam;
 using cricket::kCodecParamAssociatedPayloadType;
 using cricket::kCodecParamMaxBitrate;
 using cricket::kCodecParamMinBitrate;
-using cricket::VideoCodec;
 
 class TestCodec : public Codec {
  public:
@@ -69,27 +67,27 @@
 }
 
 TEST(CodecTest, TestAudioCodecOperators) {
-  AudioCodec c0 = cricket::CreateAudioCodec(96, "A", 44100, 2);
-  AudioCodec c1 = cricket::CreateAudioCodec(95, "A", 44100, 2);
-  AudioCodec c2 = cricket::CreateAudioCodec(96, "x", 44100, 2);
-  AudioCodec c3 = cricket::CreateAudioCodec(96, "A", 48000, 2);
-  AudioCodec c4 = cricket::CreateAudioCodec(96, "A", 44100, 2);
+  Codec c0 = cricket::CreateAudioCodec(96, "A", 44100, 2);
+  Codec c1 = cricket::CreateAudioCodec(95, "A", 44100, 2);
+  Codec c2 = cricket::CreateAudioCodec(96, "x", 44100, 2);
+  Codec c3 = cricket::CreateAudioCodec(96, "A", 48000, 2);
+  Codec c4 = cricket::CreateAudioCodec(96, "A", 44100, 2);
   c4.bitrate = 10000;
-  AudioCodec c5 = cricket::CreateAudioCodec(96, "A", 44100, 1);
+  Codec c5 = cricket::CreateAudioCodec(96, "A", 44100, 1);
   EXPECT_NE(c0, c1);
   EXPECT_NE(c0, c2);
   EXPECT_NE(c0, c3);
   EXPECT_NE(c0, c4);
   EXPECT_NE(c0, c5);
 
-  AudioCodec c8 = cricket::CreateAudioCodec(0, "", 0, 0);
-  AudioCodec c9 = c0;
+  Codec c8 = cricket::CreateAudioCodec(0, "", 0, 0);
+  Codec c9 = c0;
   EXPECT_EQ(c9, c0);
 
-  AudioCodec c10(c0);
-  AudioCodec c11(c0);
-  AudioCodec c12(c0);
-  AudioCodec c13(c0);
+  Codec c10(c0);
+  Codec c11(c0);
+  Codec c12(c0);
+  Codec c13(c0);
   c10.params["x"] = "abc";
   c11.params["x"] = "def";
   c12.params["y"] = "abc";
@@ -103,9 +101,9 @@
   EXPECT_EQ(c13, c10);
 }
 
-TEST(CodecTest, TestAudioCodecMatches) {
+TEST(CodecTest, TestCodecMatches) {
   // Test a codec with a static payload type.
-  AudioCodec c0 = cricket::CreateAudioCodec(34, "A", 44100, 1);
+  Codec c0 = cricket::CreateAudioCodec(34, "A", 44100, 1);
   EXPECT_TRUE(c0.Matches(cricket::CreateAudioCodec(34, "", 44100, 1)));
   EXPECT_TRUE(c0.Matches(cricket::CreateAudioCodec(34, "", 44100, 0)));
   EXPECT_TRUE(c0.Matches(cricket::CreateAudioCodec(34, "", 44100, 0)));
@@ -118,7 +116,7 @@
   EXPECT_FALSE(c0.Matches(cricket::CreateAudioCodec(95, "", 55100, 2)));
 
   // Test a codec with a dynamic payload type.
-  AudioCodec c1 = cricket::CreateAudioCodec(96, "A", 44100, 1);
+  Codec c1 = cricket::CreateAudioCodec(96, "A", 44100, 1);
   EXPECT_TRUE(c1.Matches(cricket::CreateAudioCodec(96, "A", 0, 0)));
   EXPECT_TRUE(c1.Matches(cricket::CreateAudioCodec(97, "A", 0, 0)));
   EXPECT_TRUE(c1.Matches(cricket::CreateAudioCodec(96, "a", 0, 0)));
@@ -132,7 +130,7 @@
   EXPECT_FALSE(c1.Matches(cricket::CreateAudioCodec(96, "A", 55100, 1)));
 
   // Test a codec with a dynamic payload type, and auto bitrate.
-  AudioCodec c2 = cricket::CreateAudioCodec(97, "A", 16000, 1);
+  Codec c2 = cricket::CreateAudioCodec(97, "A", 16000, 1);
   // Use default bitrate.
   EXPECT_TRUE(c2.Matches(cricket::CreateAudioCodec(97, "A", 16000, 1)));
   EXPECT_TRUE(c2.Matches(cricket::CreateAudioCodec(97, "A", 16000, 0)));
@@ -142,16 +140,16 @@
   EXPECT_TRUE(c2.Matches(cricket::CreateAudioCodec(97, "A", 16000, 1)));
 
   // Stereo doesn't match channels = 0.
-  AudioCodec c3 = cricket::CreateAudioCodec(96, "A", 44100, 2);
+  Codec c3 = cricket::CreateAudioCodec(96, "A", 44100, 2);
   EXPECT_TRUE(c3.Matches(cricket::CreateAudioCodec(96, "A", 44100, 2)));
   EXPECT_FALSE(c3.Matches(cricket::CreateAudioCodec(96, "A", 44100, 1)));
   EXPECT_FALSE(c3.Matches(cricket::CreateAudioCodec(96, "A", 44100, 0)));
 }
 
 TEST(CodecTest, TestOpusAudioCodecWithDifferentParameters) {
-  AudioCodec opus_with_fec = cricket::CreateAudioCodec(96, "opus", 48000, 2);
+  Codec opus_with_fec = cricket::CreateAudioCodec(96, "opus", 48000, 2);
   opus_with_fec.params["useinbandfec"] = "1";
-  AudioCodec opus_without_fec = cricket::CreateAudioCodec(96, "opus", 48000, 2);
+  Codec opus_without_fec = cricket::CreateAudioCodec(96, "opus", 48000, 2);
 
   EXPECT_TRUE(opus_with_fec != opus_without_fec);
   // Matches does not compare parameters for audio.
@@ -165,21 +163,21 @@
 }
 
 TEST(CodecTest, TestVideoCodecOperators) {
-  VideoCodec c0 = cricket::CreateVideoCodec(96, "V");
-  VideoCodec c1 = cricket::CreateVideoCodec(95, "V");
-  VideoCodec c2 = cricket::CreateVideoCodec(96, "x");
+  Codec c0 = cricket::CreateVideoCodec(96, "V");
+  Codec c1 = cricket::CreateVideoCodec(95, "V");
+  Codec c2 = cricket::CreateVideoCodec(96, "x");
 
   EXPECT_TRUE(c0 != c1);
   EXPECT_TRUE(c0 != c2);
 
-  VideoCodec c8 = cricket::CreateVideoCodec(0, "");
-  VideoCodec c9 = c0;
+  Codec c8 = cricket::CreateVideoCodec(0, "");
+  Codec c9 = c0;
   EXPECT_TRUE(c9 == c0);
 
-  VideoCodec c10(c0);
-  VideoCodec c11(c0);
-  VideoCodec c12(c0);
-  VideoCodec c13(c0);
+  Codec c10(c0);
+  Codec c11(c0);
+  Codec c12(c0);
+  Codec c13(c0);
   c10.params["x"] = "abc";
   c11.params["x"] = "def";
   c12.params["y"] = "abc";
@@ -194,9 +192,9 @@
 }
 
 TEST(CodecTest, TestVideoCodecEqualsWithDifferentPacketization) {
-  VideoCodec c0 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
-  VideoCodec c1 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
-  VideoCodec c2 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
+  Codec c0 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
+  Codec c1 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
+  Codec c2 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
   c2.packetization = "raw";
 
   EXPECT_EQ(c0, c1);
@@ -207,13 +205,13 @@
 
 TEST(CodecTest, TestVideoCodecMatches) {
   // Test a codec with a static payload type.
-  VideoCodec c0 = cricket::CreateVideoCodec(34, "V");
+  Codec c0 = cricket::CreateVideoCodec(34, "V");
   EXPECT_TRUE(c0.Matches(cricket::CreateVideoCodec(34, "")));
   EXPECT_FALSE(c0.Matches(cricket::CreateVideoCodec(96, "")));
   EXPECT_FALSE(c0.Matches(cricket::CreateVideoCodec(96, "V")));
 
   // Test a codec with a dynamic payload type.
-  VideoCodec c1 = cricket::CreateVideoCodec(96, "V");
+  Codec c1 = cricket::CreateVideoCodec(96, "V");
   EXPECT_TRUE(c1.Matches(cricket::CreateVideoCodec(96, "V")));
   EXPECT_TRUE(c1.Matches(cricket::CreateVideoCodec(97, "V")));
   EXPECT_TRUE(c1.Matches(cricket::CreateVideoCodec(96, "v")));
@@ -227,8 +225,8 @@
 }
 
 TEST(CodecTest, TestVideoCodecMatchesWithDifferentPacketization) {
-  VideoCodec c0 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
-  VideoCodec c1 = cricket::CreateVideoCodec(101, cricket::kVp8CodecName);
+  Codec c0 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
+  Codec c1 = cricket::CreateVideoCodec(101, cricket::kVp8CodecName);
   c1.packetization = "raw";
 
   EXPECT_TRUE(c0.Matches(c1));
@@ -241,13 +239,12 @@
   const char kProfile1[] = "1";
   const char kProfile2[] = "2";
 
-  VideoCodec c_no_profile =
-      cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
-  VideoCodec c_profile0 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
+  Codec c_no_profile = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
+  Codec c_profile0 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
   c_profile0.params[cricket::kAv1FmtpProfile] = kProfile0;
-  VideoCodec c_profile1 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
+  Codec c_profile1 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
   c_profile1.params[cricket::kAv1FmtpProfile] = kProfile1;
-  VideoCodec c_profile2 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
+  Codec c_profile2 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
   c_profile2.params[cricket::kAv1FmtpProfile] = kProfile2;
 
   // An AV1 entry with no profile specified should be treated as profile-0.
@@ -255,23 +252,21 @@
 
   {
     // Two AV1 entries without a profile specified are treated as duplicates.
-    VideoCodec c_no_profile_eq =
+    Codec c_no_profile_eq =
         cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
     EXPECT_TRUE(c_no_profile.Matches(c_no_profile_eq));
   }
 
   {
     // Two AV1 entries with profile 0 specified are treated as duplicates.
-    VideoCodec c_profile0_eq =
-        cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
+    Codec c_profile0_eq = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
     c_profile0_eq.params[cricket::kAv1FmtpProfile] = kProfile0;
     EXPECT_TRUE(c_profile0.Matches(c_profile0_eq));
   }
 
   {
     // Two AV1 entries with profile 1 specified are treated as duplicates.
-    VideoCodec c_profile1_eq =
-        cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
+    Codec c_profile1_eq = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
     c_profile1_eq.params[cricket::kAv1FmtpProfile] = kProfile1;
     EXPECT_TRUE(c_profile1.Matches(c_profile1_eq));
   }
@@ -290,30 +285,27 @@
   const char kProfile0[] = "0";
   const char kProfile2[] = "2";
 
-  VideoCodec c_no_profile =
-      cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
-  VideoCodec c_profile0 = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
+  Codec c_no_profile = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
+  Codec c_profile0 = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
   c_profile0.params[webrtc::kVP9FmtpProfileId] = kProfile0;
 
   EXPECT_TRUE(c_profile0.Matches(c_no_profile));
 
   {
-    VideoCodec c_profile0_eq =
-        cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
+    Codec c_profile0_eq = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
     c_profile0_eq.params[webrtc::kVP9FmtpProfileId] = kProfile0;
     EXPECT_TRUE(c_profile0.Matches(c_profile0_eq));
   }
 
   {
-    VideoCodec c_profile2 =
-        cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
+    Codec c_profile2 = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
     c_profile2.params[webrtc::kVP9FmtpProfileId] = kProfile2;
     EXPECT_FALSE(c_profile0.Matches(c_profile2));
     EXPECT_FALSE(c_no_profile.Matches(c_profile2));
   }
 
   {
-    VideoCodec c_no_profile_eq =
+    Codec c_no_profile_eq =
         cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
     EXPECT_TRUE(c_no_profile.Matches(c_no_profile_eq));
   }
@@ -326,12 +318,12 @@
   const char kProfileLevelId2[] = "42a01e";
   const char kProfileLevelId3[] = "42e01e";
 
-  VideoCodec pli_1_pm_0 = cricket::CreateVideoCodec(95, "H264");
+  Codec pli_1_pm_0 = cricket::CreateVideoCodec(95, "H264");
   pli_1_pm_0.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId1;
   pli_1_pm_0.params[cricket::kH264FmtpPacketizationMode] = "0";
 
   {
-    VideoCodec pli_1_pm_blank = cricket::CreateVideoCodec(95, "H264");
+    Codec pli_1_pm_blank = cricket::CreateVideoCodec(95, "H264");
     pli_1_pm_blank.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId1;
     pli_1_pm_blank.params.erase(
         pli_1_pm_blank.params.find(cricket::kH264FmtpPacketizationMode));
@@ -345,7 +337,7 @@
   }
 
   {
-    VideoCodec pli_1_pm_1 = cricket::CreateVideoCodec(95, "H264");
+    Codec pli_1_pm_1 = cricket::CreateVideoCodec(95, "H264");
     pli_1_pm_1.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId1;
     pli_1_pm_1.params[cricket::kH264FmtpPacketizationMode] = "1";
 
@@ -356,7 +348,7 @@
   }
 
   {
-    VideoCodec pli_2_pm_0 = cricket::CreateVideoCodec(95, "H264");
+    Codec pli_2_pm_0 = cricket::CreateVideoCodec(95, "H264");
     pli_2_pm_0.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId2;
     pli_2_pm_0.params[cricket::kH264FmtpPacketizationMode] = "0";
 
@@ -367,7 +359,7 @@
   }
 
   {
-    VideoCodec pli_3_pm_0_asym = cricket::CreateVideoCodec(95, "H264");
+    Codec pli_3_pm_0_asym = cricket::CreateVideoCodec(95, "H264");
     pli_3_pm_0_asym.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId3;
     pli_3_pm_0_asym.params[cricket::kH264FmtpPacketizationMode] = "0";
 
@@ -391,12 +383,10 @@
   constexpr char kLevel4[] = "120";
   constexpr char kTxMrst[] = "MRST";
 
-  VideoCodec c_ptl_blank =
-      cricket::CreateVideoCodec(95, cricket::kH265CodecName);
+  Codec c_ptl_blank = cricket::CreateVideoCodec(95, cricket::kH265CodecName);
 
   {
-    VideoCodec c_profile_1 =
-        cricket::CreateVideoCodec(95, cricket::kH265CodecName);
+    Codec c_profile_1 = cricket::CreateVideoCodec(95, cricket::kH265CodecName);
     c_profile_1.params[cricket::kH265FmtpProfileId] = kProfile1;
 
     // Matches since profile-id unspecified defaults to "1".
@@ -404,7 +394,7 @@
   }
 
   {
-    VideoCodec c_tier_flag_1 =
+    Codec c_tier_flag_1 =
         cricket::CreateVideoCodec(95, cricket::kH265CodecName);
     c_tier_flag_1.params[cricket::kH265FmtpTierFlag] = kTier1;
 
@@ -413,7 +403,7 @@
   }
 
   {
-    VideoCodec c_level_id_3_1 =
+    Codec c_level_id_3_1 =
         cricket::CreateVideoCodec(95, cricket::kH265CodecName);
     c_level_id_3_1.params[cricket::kH265FmtpLevelId] = kLevel3_1;
 
@@ -422,8 +412,7 @@
   }
 
   {
-    VideoCodec c_level_id_4 =
-        cricket::CreateVideoCodec(95, cricket::kH265CodecName);
+    Codec c_level_id_4 = cricket::CreateVideoCodec(95, cricket::kH265CodecName);
     c_level_id_4.params[cricket::kH265FmtpLevelId] = kLevel4;
 
     // Does not match since different level-ids are specified.
@@ -431,7 +420,7 @@
   }
 
   {
-    VideoCodec c_tx_mode_mrst =
+    Codec c_tx_mode_mrst =
         cricket::CreateVideoCodec(95, cricket::kH265CodecName);
     c_tx_mode_mrst.params[cricket::kH265FmtpTxMode] = kTxMrst;
 
@@ -444,7 +433,7 @@
 #endif
 
 TEST(CodecTest, TestSetParamGetParamAndRemoveParam) {
-  AudioCodec codec = cricket::CreateAudioCodec(0, "foo", 22222, 2);
+  Codec codec = cricket::CreateAudioCodec(0, "foo", 22222, 2);
   codec.SetParam("a", "1");
   codec.SetParam("b", "x");
 
@@ -485,11 +474,11 @@
 
 TEST(CodecTest, TestGetCodecType) {
   // Codec type comparison should be case insensitive on names.
-  const VideoCodec codec = cricket::CreateVideoCodec(96, "V");
-  const VideoCodec rtx_codec = cricket::CreateVideoCodec(96, "rTx");
-  const VideoCodec ulpfec_codec = cricket::CreateVideoCodec(96, "ulpFeC");
-  const VideoCodec flexfec_codec = cricket::CreateVideoCodec(96, "FlExFeC-03");
-  const VideoCodec red_codec = cricket::CreateVideoCodec(96, "ReD");
+  const Codec codec = cricket::CreateVideoCodec(96, "V");
+  const Codec rtx_codec = cricket::CreateVideoCodec(96, "rTx");
+  const Codec ulpfec_codec = cricket::CreateVideoCodec(96, "ulpFeC");
+  const Codec flexfec_codec = cricket::CreateVideoCodec(96, "FlExFeC-03");
+  const Codec red_codec = cricket::CreateVideoCodec(96, "ReD");
   EXPECT_TRUE(codec.IsMediaCodec());
   EXPECT_EQ(codec.GetResiliencyType(), Codec::ResiliencyType::kNone);
   EXPECT_EQ(rtx_codec.GetResiliencyType(), Codec::ResiliencyType::kRtx);
@@ -499,7 +488,7 @@
 }
 
 TEST(CodecTest, TestCreateRtxCodec) {
-  const VideoCodec rtx_codec = cricket::CreateVideoRtxCodec(96, 120);
+  const Codec rtx_codec = cricket::CreateVideoRtxCodec(96, 120);
   EXPECT_EQ(96, rtx_codec.id);
   EXPECT_EQ(rtx_codec.GetResiliencyType(), Codec::ResiliencyType::kRtx);
   int associated_payload_type;
@@ -509,8 +498,8 @@
 }
 
 TEST(CodecTest, TestMatchesRtpCodecRtx) {
-  const VideoCodec rtx_codec_1 = cricket::CreateVideoRtxCodec(96, 120);
-  const VideoCodec rtx_codec_2 = cricket::CreateVideoRtxCodec(96, 121);
+  const Codec rtx_codec_1 = cricket::CreateVideoRtxCodec(96, 120);
+  const Codec rtx_codec_2 = cricket::CreateVideoRtxCodec(96, 121);
   EXPECT_TRUE(rtx_codec_1.Matches(rtx_codec_2));
   // MatchesRtpCodec ignores the different associated payload type (apt) for
   // RTX.
@@ -518,48 +507,48 @@
 }
 
 TEST(CodecTest, TestValidateCodecFormat) {
-  const VideoCodec codec = cricket::CreateVideoCodec(96, "V");
+  const Codec codec = cricket::CreateVideoCodec(96, "V");
   ASSERT_TRUE(codec.ValidateCodecFormat());
 
   // Accept 0-127 as payload types.
-  VideoCodec low_payload_type = codec;
+  Codec low_payload_type = codec;
   low_payload_type.id = 0;
-  VideoCodec high_payload_type = codec;
+  Codec high_payload_type = codec;
   high_payload_type.id = 127;
   ASSERT_TRUE(low_payload_type.ValidateCodecFormat());
   EXPECT_TRUE(high_payload_type.ValidateCodecFormat());
 
   // Reject negative payloads.
-  VideoCodec negative_payload_type = codec;
+  Codec negative_payload_type = codec;
   negative_payload_type.id = -1;
   EXPECT_FALSE(negative_payload_type.ValidateCodecFormat());
 
   // Reject too-high payloads.
-  VideoCodec too_high_payload_type = codec;
+  Codec too_high_payload_type = codec;
   too_high_payload_type.id = 128;
   EXPECT_FALSE(too_high_payload_type.ValidateCodecFormat());
 
   // Reject codecs with min bitrate > max bitrate.
-  VideoCodec incorrect_bitrates = codec;
+  Codec incorrect_bitrates = codec;
   incorrect_bitrates.params[kCodecParamMinBitrate] = "100";
   incorrect_bitrates.params[kCodecParamMaxBitrate] = "80";
   EXPECT_FALSE(incorrect_bitrates.ValidateCodecFormat());
 
   // Accept min bitrate == max bitrate.
-  VideoCodec equal_bitrates = codec;
+  Codec equal_bitrates = codec;
   equal_bitrates.params[kCodecParamMinBitrate] = "100";
   equal_bitrates.params[kCodecParamMaxBitrate] = "100";
   EXPECT_TRUE(equal_bitrates.ValidateCodecFormat());
 
   // Accept min bitrate < max bitrate.
-  VideoCodec different_bitrates = codec;
+  Codec different_bitrates = codec;
   different_bitrates.params[kCodecParamMinBitrate] = "99";
   different_bitrates.params[kCodecParamMaxBitrate] = "100";
   EXPECT_TRUE(different_bitrates.ValidateCodecFormat());
 }
 
 TEST(CodecTest, TestToCodecParameters) {
-  VideoCodec v = cricket::CreateVideoCodec(96, "V");
+  Codec v = cricket::CreateVideoCodec(96, "V");
   v.SetParam("p1", "v1");
   webrtc::RtpCodecParameters codec_params_1 = v.ToCodecParameters();
   EXPECT_EQ(96, codec_params_1.payload_type);
@@ -571,7 +560,7 @@
   EXPECT_EQ("p1", codec_params_1.parameters.begin()->first);
   EXPECT_EQ("v1", codec_params_1.parameters.begin()->second);
 
-  AudioCodec a = cricket::CreateAudioCodec(97, "A", 44100, 2);
+  Codec a = cricket::CreateAudioCodec(97, "A", 44100, 2);
   a.SetParam("p1", "a1");
   webrtc::RtpCodecParameters codec_params_2 = a.ToCodecParameters();
   EXPECT_EQ(97, codec_params_2.payload_type);
diff --git a/media/base/fake_media_engine.cc b/media/base/fake_media_engine.cc
index 5a1da33..d5c0e02 100644
--- a/media/base/fake_media_engine.cc
+++ b/media/base/fake_media_engine.cc
@@ -62,8 +62,7 @@
   SetOptions(options);
 }
 FakeVoiceMediaReceiveChannel::~FakeVoiceMediaReceiveChannel() = default;
-const std::vector<AudioCodec>& FakeVoiceMediaReceiveChannel::recv_codecs()
-    const {
+const std::vector<Codec>& FakeVoiceMediaReceiveChannel::recv_codecs() const {
   return recv_codecs_;
 }
 const std::vector<FakeVoiceMediaReceiveChannel::DtmfInfo>&
@@ -160,7 +159,7 @@
   return std::vector<webrtc::RtpSource>();
 }
 bool FakeVoiceMediaReceiveChannel::SetRecvCodecs(
-    const std::vector<AudioCodec>& codecs) {
+    const std::vector<Codec>& codecs) {
   if (fail_set_recv_codecs()) {
     // Fake the failure in SetRecvCodecs.
     return false;
@@ -216,7 +215,7 @@
   SetOptions(options);
 }
 FakeVoiceMediaSendChannel::~FakeVoiceMediaSendChannel() = default;
-const std::vector<AudioCodec>& FakeVoiceMediaSendChannel::send_codecs() const {
+const std::vector<Codec>& FakeVoiceMediaSendChannel::send_codecs() const {
   return send_codecs_;
 }
 absl::optional<Codec> FakeVoiceMediaSendChannel::GetSendCodec() const {
@@ -267,7 +266,7 @@
   return local_sinks_.find(ssrc) != local_sinks_.end();
 }
 bool FakeVoiceMediaSendChannel::CanInsertDtmf() {
-  for (std::vector<AudioCodec>::const_iterator it = send_codecs_.begin();
+  for (std::vector<Codec>::const_iterator it = send_codecs_.begin();
        it != send_codecs_.end(); ++it) {
     // Find the DTMF telephone event "codec".
     if (absl::EqualsIgnoreCase(it->name, "telephone-event")) {
@@ -292,7 +291,7 @@
   return false;
 }
 bool FakeVoiceMediaSendChannel::SetSendCodecs(
-    const std::vector<AudioCodec>& codecs) {
+    const std::vector<Codec>& codecs) {
   if (fail_set_send_codecs()) {
     // Fake the failure in SetSendCodecs.
     return false;
@@ -343,10 +342,10 @@
   SetOptions(options);
 }
 FakeVideoMediaSendChannel::~FakeVideoMediaSendChannel() = default;
-const std::vector<VideoCodec>& FakeVideoMediaSendChannel::send_codecs() const {
+const std::vector<Codec>& FakeVideoMediaSendChannel::send_codecs() const {
   return send_codecs_;
 }
-const std::vector<VideoCodec>& FakeVideoMediaSendChannel::codecs() const {
+const std::vector<Codec>& FakeVideoMediaSendChannel::codecs() const {
   return send_codecs();
 }
 const VideoOptions& FakeVideoMediaSendChannel::options() const {
@@ -393,7 +392,7 @@
   return false;
 }
 bool FakeVideoMediaSendChannel::SetSendCodecs(
-    const std::vector<VideoCodec>& codecs) {
+    const std::vector<Codec>& codecs) {
   if (fail_set_send_codecs()) {
     // Fake the failure in SetSendCodecs.
     return false;
@@ -424,8 +423,7 @@
   SetOptions(options);
 }
 FakeVideoMediaReceiveChannel::~FakeVideoMediaReceiveChannel() = default;
-const std::vector<VideoCodec>& FakeVideoMediaReceiveChannel::recv_codecs()
-    const {
+const std::vector<Codec>& FakeVideoMediaReceiveChannel::recv_codecs() const {
   return recv_codecs_;
 }
 bool FakeVideoMediaReceiveChannel::rendering() const {
@@ -503,7 +501,7 @@
   return absl::nullopt;
 }
 bool FakeVideoMediaReceiveChannel::SetRecvCodecs(
-    const std::vector<VideoCodec>& codecs) {
+    const std::vector<Codec>& codecs) {
   if (fail_set_recv_codecs()) {
     // Fake the failure in SetRecvCodecs.
     return false;
@@ -566,20 +564,20 @@
                                                      call->network_thread());
   return ch;
 }
-const std::vector<AudioCodec>& FakeVoiceEngine::send_codecs() const {
+const std::vector<Codec>& FakeVoiceEngine::send_codecs() const {
   return send_codecs_;
 }
-const std::vector<AudioCodec>& FakeVoiceEngine::recv_codecs() const {
+const std::vector<Codec>& FakeVoiceEngine::recv_codecs() const {
   return recv_codecs_;
 }
-void FakeVoiceEngine::SetCodecs(const std::vector<AudioCodec>& codecs) {
+void FakeVoiceEngine::SetCodecs(const std::vector<Codec>& codecs) {
   send_codecs_ = codecs;
   recv_codecs_ = codecs;
 }
-void FakeVoiceEngine::SetRecvCodecs(const std::vector<AudioCodec>& codecs) {
+void FakeVoiceEngine::SetRecvCodecs(const std::vector<Codec>& codecs) {
   recv_codecs_ = codecs;
 }
-void FakeVoiceEngine::SetSendCodecs(const std::vector<AudioCodec>& codecs) {
+void FakeVoiceEngine::SetSendCodecs(const std::vector<Codec>& codecs) {
   send_codecs_ = codecs;
 }
 int FakeVoiceEngine::GetInputLevel() {
@@ -647,19 +645,19 @@
                                                      call->network_thread());
   return ch;
 }
-std::vector<VideoCodec> FakeVideoEngine::send_codecs(bool use_rtx) const {
+std::vector<Codec> FakeVideoEngine::send_codecs(bool use_rtx) const {
   return send_codecs_;
 }
 
-std::vector<VideoCodec> FakeVideoEngine::recv_codecs(bool use_rtx) const {
+std::vector<Codec> FakeVideoEngine::recv_codecs(bool use_rtx) const {
   return recv_codecs_;
 }
 
-void FakeVideoEngine::SetSendCodecs(const std::vector<VideoCodec>& codecs) {
+void FakeVideoEngine::SetSendCodecs(const std::vector<Codec>& codecs) {
   send_codecs_ = codecs;
 }
 
-void FakeVideoEngine::SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
+void FakeVideoEngine::SetRecvCodecs(const std::vector<Codec>& codecs) {
   recv_codecs_ = codecs;
 }
 
@@ -682,18 +680,16 @@
       voice_(static_cast<FakeVoiceEngine*>(&voice())),
       video_(static_cast<FakeVideoEngine*>(&video())) {}
 FakeMediaEngine::~FakeMediaEngine() {}
-void FakeMediaEngine::SetAudioCodecs(const std::vector<AudioCodec>& codecs) {
+void FakeMediaEngine::SetAudioCodecs(const std::vector<Codec>& codecs) {
   voice_->SetCodecs(codecs);
 }
-void FakeMediaEngine::SetAudioRecvCodecs(
-    const std::vector<AudioCodec>& codecs) {
+void FakeMediaEngine::SetAudioRecvCodecs(const std::vector<Codec>& codecs) {
   voice_->SetRecvCodecs(codecs);
 }
-void FakeMediaEngine::SetAudioSendCodecs(
-    const std::vector<AudioCodec>& codecs) {
+void FakeMediaEngine::SetAudioSendCodecs(const std::vector<Codec>& codecs) {
   voice_->SetSendCodecs(codecs);
 }
-void FakeMediaEngine::SetVideoCodecs(const std::vector<VideoCodec>& codecs) {
+void FakeMediaEngine::SetVideoCodecs(const std::vector<Codec>& codecs) {
   video_->SetSendCodecs(codecs);
   video_->SetRecvCodecs(codecs);
 }
diff --git a/media/base/fake_media_engine.h b/media/base/fake_media_engine.h
index 6453890..b56af0e 100644
--- a/media/base/fake_media_engine.h
+++ b/media/base/fake_media_engine.h
@@ -452,7 +452,7 @@
   virtual ~FakeVoiceMediaReceiveChannel();
 
   // Test methods
-  const std::vector<AudioCodec>& recv_codecs() const;
+  const std::vector<Codec>& recv_codecs() const;
   const std::vector<DtmfInfo>& dtmf_info_queue() const;
   const AudioOptions& options() const;
   int max_bps() const;
@@ -516,11 +516,11 @@
     AudioSource* source_;
   };
 
-  bool SetRecvCodecs(const std::vector<AudioCodec>& codecs);
+  bool SetRecvCodecs(const std::vector<Codec>& codecs);
   bool SetMaxSendBandwidth(int bps);
   bool SetOptions(const AudioOptions& options);
 
-  std::vector<AudioCodec> recv_codecs_;
+  std::vector<Codec> recv_codecs_;
   std::map<uint32_t, double> output_scalings_;
   std::map<uint32_t, int> output_delays_;
   std::vector<DtmfInfo> dtmf_info_queue_;
@@ -543,7 +543,7 @@
                             webrtc::TaskQueueBase* network_thread);
   ~FakeVoiceMediaSendChannel() override;
 
-  const std::vector<AudioCodec>& send_codecs() const;
+  const std::vector<Codec>& send_codecs() const;
   const std::vector<DtmfInfo>& dtmf_info_queue() const;
   const AudioOptions& options() const;
   int max_bps() const;
@@ -599,12 +599,12 @@
     AudioSource* source_;
   };
 
-  bool SetSendCodecs(const std::vector<AudioCodec>& codecs);
+  bool SetSendCodecs(const std::vector<Codec>& codecs);
   bool SetMaxSendBandwidth(int bps);
   bool SetOptions(const AudioOptions& options);
   bool SetLocalSource(uint32_t ssrc, AudioSource* source);
 
-  std::vector<AudioCodec> send_codecs_;
+  std::vector<Codec> send_codecs_;
   std::map<uint32_t, double> output_scalings_;
   std::map<uint32_t, int> output_delays_;
   std::vector<DtmfInfo> dtmf_info_queue_;
@@ -637,8 +637,8 @@
     return cricket::MEDIA_TYPE_VIDEO;
   }
 
-  const std::vector<VideoCodec>& recv_codecs() const;
-  const std::vector<VideoCodec>& send_codecs() const;
+  const std::vector<Codec>& recv_codecs() const;
+  const std::vector<Codec>& send_codecs() const;
   bool rendering() const;
   const VideoOptions& options() const;
   const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
@@ -682,12 +682,12 @@
   }
 
  private:
-  bool SetRecvCodecs(const std::vector<VideoCodec>& codecs);
-  bool SetSendCodecs(const std::vector<VideoCodec>& codecs);
+  bool SetRecvCodecs(const std::vector<Codec>& codecs);
+  bool SetSendCodecs(const std::vector<Codec>& codecs);
   bool SetOptions(const VideoOptions& options);
   bool SetMaxSendBandwidth(int bps);
 
-  std::vector<VideoCodec> recv_codecs_;
+  std::vector<Codec> recv_codecs_;
   std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*> sinks_;
   std::map<uint32_t, rtc::VideoSourceInterface<webrtc::VideoFrame>*> sources_;
   std::map<uint32_t, int> output_delays_;
@@ -711,8 +711,8 @@
     return cricket::MEDIA_TYPE_VIDEO;
   }
 
-  const std::vector<VideoCodec>& send_codecs() const;
-  const std::vector<VideoCodec>& codecs() const;
+  const std::vector<Codec>& send_codecs() const;
+  const std::vector<Codec>& codecs() const;
   const VideoOptions& options() const;
   const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
   sinks() const;
@@ -749,11 +749,11 @@
   bool GetStats(VideoMediaSendInfo* info) override;
 
  private:
-  bool SetSendCodecs(const std::vector<VideoCodec>& codecs);
+  bool SetSendCodecs(const std::vector<Codec>& codecs);
   bool SetOptions(const VideoOptions& options);
   bool SetMaxSendBandwidth(int bps);
 
-  std::vector<VideoCodec> send_codecs_;
+  std::vector<Codec> send_codecs_;
   std::map<uint32_t, rtc::VideoSourceInterface<webrtc::VideoFrame>*> sources_;
   VideoOptions options_;
   int max_bps_;
@@ -780,11 +780,11 @@
 
   // TODO(ossu): For proper testing, These should either individually settable
   //             or the voice engine should reference mockable factories.
-  const std::vector<AudioCodec>& send_codecs() const override;
-  const std::vector<AudioCodec>& recv_codecs() const override;
-  void SetCodecs(const std::vector<AudioCodec>& codecs);
-  void SetRecvCodecs(const std::vector<AudioCodec>& codecs);
-  void SetSendCodecs(const std::vector<AudioCodec>& codecs);
+  const std::vector<Codec>& send_codecs() const override;
+  const std::vector<Codec>& recv_codecs() const override;
+  void SetCodecs(const std::vector<Codec>& codecs);
+  void SetRecvCodecs(const std::vector<Codec>& codecs);
+  void SetSendCodecs(const std::vector<Codec>& codecs);
   int GetInputLevel();
   bool StartAecDump(webrtc::FileWrapper file, int64_t max_size_bytes) override;
   void StopAecDump() override;
@@ -796,8 +796,8 @@
       std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions);
 
  private:
-  std::vector<AudioCodec> recv_codecs_;
-  std::vector<AudioCodec> send_codecs_;
+  std::vector<Codec> recv_codecs_;
+  std::vector<Codec> send_codecs_;
   bool fail_create_channel_;
   std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions_;
 
@@ -823,16 +823,12 @@
   FakeVideoMediaSendChannel* GetSendChannel(size_t index);
   FakeVideoMediaReceiveChannel* GetReceiveChannel(size_t index);
 
-  std::vector<VideoCodec> send_codecs() const override {
-    return send_codecs(true);
-  }
-  std::vector<VideoCodec> recv_codecs() const override {
-    return recv_codecs(true);
-  }
-  std::vector<VideoCodec> send_codecs(bool include_rtx) const override;
-  std::vector<VideoCodec> recv_codecs(bool include_rtx) const override;
-  void SetSendCodecs(const std::vector<VideoCodec>& codecs);
-  void SetRecvCodecs(const std::vector<VideoCodec>& codecs);
+  std::vector<Codec> send_codecs() const override { return send_codecs(true); }
+  std::vector<Codec> recv_codecs() const override { return recv_codecs(true); }
+  std::vector<Codec> send_codecs(bool include_rtx) const override;
+  std::vector<Codec> recv_codecs(bool include_rtx) const override;
+  void SetSendCodecs(const std::vector<Codec>& codecs);
+  void SetRecvCodecs(const std::vector<Codec>& codecs);
   bool SetCapture(bool capture);
   std::vector<webrtc::RtpHeaderExtensionCapability> GetRtpHeaderExtensions()
       const override;
@@ -840,8 +836,8 @@
       std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions);
 
  private:
-  std::vector<VideoCodec> send_codecs_;
-  std::vector<VideoCodec> recv_codecs_;
+  std::vector<Codec> send_codecs_;
+  std::vector<Codec> recv_codecs_;
   bool capture_;
   VideoOptions options_;
   bool fail_create_channel_;
@@ -856,10 +852,10 @@
 
   ~FakeMediaEngine() override;
 
-  void SetAudioCodecs(const std::vector<AudioCodec>& codecs);
-  void SetAudioRecvCodecs(const std::vector<AudioCodec>& codecs);
-  void SetAudioSendCodecs(const std::vector<AudioCodec>& codecs);
-  void SetVideoCodecs(const std::vector<VideoCodec>& codecs);
+  void SetAudioCodecs(const std::vector<Codec>& codecs);
+  void SetAudioRecvCodecs(const std::vector<Codec>& codecs);
+  void SetAudioSendCodecs(const std::vector<Codec>& codecs);
+  void SetVideoCodecs(const std::vector<Codec>& codecs);
 
   void set_fail_create_channel(bool fail);
 
diff --git a/media/base/media_engine.h b/media/base/media_engine.h
index 63cc86f..3deda09 100644
--- a/media/base/media_engine.h
+++ b/media/base/media_engine.h
@@ -118,8 +118,8 @@
     return nullptr;
   }
 
-  virtual const std::vector<AudioCodec>& send_codecs() const = 0;
-  virtual const std::vector<AudioCodec>& recv_codecs() const = 0;
+  virtual const std::vector<Codec>& send_codecs() const = 0;
+  virtual const std::vector<Codec>& recv_codecs() const = 0;
 
   // Starts AEC dump using existing file, a maximum file size in bytes can be
   // specified. Logging is stopped just before the size limit is exceeded.
@@ -164,16 +164,16 @@
   }
 
   // Retrieve list of supported codecs.
-  virtual std::vector<VideoCodec> send_codecs() const = 0;
-  virtual std::vector<VideoCodec> recv_codecs() const = 0;
+  virtual std::vector<Codec> send_codecs() const = 0;
+  virtual std::vector<Codec> recv_codecs() const = 0;
   // As above, but if include_rtx is false, don't include RTX codecs.
   // TODO(bugs.webrtc.org/13931): Remove default implementation once
   // upstream subclasses have converted.
-  virtual std::vector<VideoCodec> send_codecs(bool include_rtx) const {
+  virtual std::vector<Codec> send_codecs(bool include_rtx) const {
     RTC_DCHECK(include_rtx);
     return send_codecs();
   }
-  virtual std::vector<VideoCodec> recv_codecs(bool include_rtx) const {
+  virtual std::vector<Codec> recv_codecs(bool include_rtx) const {
     RTC_DCHECK(include_rtx);
     return recv_codecs();
   }
diff --git a/media/base/media_engine_unittest.cc b/media/base/media_engine_unittest.cc
index b8db32a..6f78d61 100644
--- a/media/base/media_engine_unittest.cc
+++ b/media/base/media_engine_unittest.cc
@@ -70,8 +70,8 @@
               GetAudioState,
               (),
               (const, override));
-  MOCK_METHOD(std::vector<AudioCodec>&, send_codecs, (), (const, override));
-  MOCK_METHOD(std::vector<AudioCodec>&, recv_codecs, (), (const, override));
+  MOCK_METHOD(std::vector<Codec>&, send_codecs, (), (const, override));
+  MOCK_METHOD(std::vector<Codec>&, recv_codecs, (), (const, override));
   MOCK_METHOD(bool,
               StartAecDump,
               (webrtc::FileWrapper file, int64_t max_size_bytes),
diff --git a/media/engine/fake_webrtc_video_engine.cc b/media/engine/fake_webrtc_video_engine.cc
index 556f696..cb70268 100644
--- a/media/engine/fake_webrtc_video_engine.cc
+++ b/media/engine/fake_webrtc_video_engine.cc
@@ -120,8 +120,8 @@
 
 void FakeWebRtcVideoDecoderFactory::AddSupportedVideoCodecType(
     const std::string& name) {
-  // This is to match the default H264 params of cricket::VideoCodec.
-  cricket::VideoCodec video_codec = cricket::CreateVideoCodec(name);
+  // This is to match the default H264 params of cricket::Codec.
+  cricket::Codec video_codec = cricket::CreateVideoCodec(name);
   supported_codec_formats_.push_back(
       webrtc::SdpVideoFormat(video_codec.name, video_codec.params));
 }
@@ -287,8 +287,8 @@
 void FakeWebRtcVideoEncoderFactory::AddSupportedVideoCodecType(
     const std::string& name,
     const std::vector<webrtc::ScalabilityMode>& scalability_modes) {
-  // This is to match the default H264 params of cricket::VideoCodec.
-  cricket::VideoCodec video_codec = cricket::CreateVideoCodec(name);
+  // This is to match the default H264 params of cricket::Codec.
+  cricket::Codec video_codec = cricket::CreateVideoCodec(name);
   formats_.push_back(webrtc::SdpVideoFormat(
       video_codec.name, video_codec.params,
       {scalability_modes.begin(), scalability_modes.end()}));
diff --git a/media/engine/payload_type_mapper.cc b/media/engine/payload_type_mapper.cc
index bd86453..0f7c00e 100644
--- a/media/engine/payload_type_mapper.cc
+++ b/media/engine/payload_type_mapper.cc
@@ -19,7 +19,7 @@
 
 namespace cricket {
 
-webrtc::SdpAudioFormat AudioCodecToSdpAudioFormat(const AudioCodec& ac) {
+webrtc::SdpAudioFormat AudioCodecToSdpAudioFormat(const Codec& ac) {
   return webrtc::SdpAudioFormat(ac.name, ac.clockrate, ac.channels, ac.params);
 }
 
@@ -122,7 +122,7 @@
   return absl::nullopt;
 }
 
-absl::optional<AudioCodec> PayloadTypeMapper::ToAudioCodec(
+absl::optional<Codec> PayloadTypeMapper::ToAudioCodec(
     const webrtc::SdpAudioFormat& format) {
   // TODO(ossu): We can safely set bitrate to zero here, since that field is
   // not presented in the SDP. It is used to ferry around some target bitrate
@@ -131,7 +131,7 @@
   // ACM or NetEq.
   auto opt_payload_type = GetMappingFor(format);
   if (opt_payload_type) {
-    AudioCodec codec =
+    Codec codec =
         cricket::CreateAudioCodec(*opt_payload_type, format.name,
                                   format.clockrate_hz, format.num_channels);
     codec.params = format.parameters;
diff --git a/media/engine/payload_type_mapper.h b/media/engine/payload_type_mapper.h
index 1d5cd71..3a79a4d 100644
--- a/media/engine/payload_type_mapper.h
+++ b/media/engine/payload_type_mapper.h
@@ -20,7 +20,7 @@
 
 namespace cricket {
 
-webrtc::SdpAudioFormat AudioCodecToSdpAudioFormat(const AudioCodec& ac);
+webrtc::SdpAudioFormat AudioCodecToSdpAudioFormat(const Codec& ac);
 
 class PayloadTypeMapper {
  public:
@@ -39,7 +39,7 @@
 
   // Like GetMappingFor, but fills in an AudioCodec structure with the necessary
   // information instead.
-  absl::optional<AudioCodec> ToAudioCodec(const webrtc::SdpAudioFormat& format);
+  absl::optional<Codec> ToAudioCodec(const webrtc::SdpAudioFormat& format);
 
  private:
   struct SdpAudioFormatOrdering {
diff --git a/media/engine/payload_type_mapper_unittest.cc b/media/engine/payload_type_mapper_unittest.cc
index 92253a0..62cca1e 100644
--- a/media/engine/payload_type_mapper_unittest.cc
+++ b/media/engine/payload_type_mapper_unittest.cc
@@ -126,7 +126,7 @@
 
   if (opt_payload_type && opt_audio_codec) {
     int payload_type = *opt_payload_type;
-    const AudioCodec& codec = *opt_audio_codec;
+    const Codec& codec = *opt_audio_codec;
 
     EXPECT_EQ(codec.id, payload_type);
     EXPECT_EQ(codec.name, format.name);
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index d4dccdf..7a10bf1 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -111,7 +111,7 @@
   return absl::StartsWith(trials.Lookup(name), "Disabled");
 }
 
-void AddDefaultFeedbackParams(VideoCodec* codec,
+void AddDefaultFeedbackParams(Codec* codec,
                               const webrtc::FieldTrialsView& trials) {
   // Don't add any feedback params for RED and ULPFEC.
   if (codec->name == kRedCodecName || codec->name == kUlpfecCodecName)
@@ -133,7 +133,7 @@
 
 // Helper function to determine whether a codec should use the [35, 63] range.
 // Should be used when adding new codecs (or variants).
-bool IsCodecValidForLowerRange(const VideoCodec& codec) {
+bool IsCodecValidForLowerRange(const Codec& codec) {
   if (absl::EqualsIgnoreCase(codec.name, kFlexfecCodecName) ||
       absl::EqualsIgnoreCase(codec.name, kAv1CodecName) ||
       absl::EqualsIgnoreCase(codec.name, kAv1xCodecName)) {
@@ -174,7 +174,7 @@
 // TODO(kron): Perhaps it is better to move the implicit knowledge to the place
 // where codecs are negotiated.
 template <class T>
-std::vector<VideoCodec> GetPayloadTypesAndDefaultCodecs(
+std::vector<Codec> GetPayloadTypesAndDefaultCodecs(
     const T* factory,
     bool is_decoder_factory,
     bool include_rtx,
@@ -190,7 +190,7 @@
   }
 
   if (supported_formats.empty())
-    return std::vector<VideoCodec>();
+    return std::vector<Codec>();
 
   supported_formats.push_back(webrtc::SdpVideoFormat(kRedCodecName));
   supported_formats.push_back(webrtc::SdpVideoFormat(kUlpfecCodecName));
@@ -217,9 +217,9 @@
   int payload_type_upper = kFirstDynamicPayloadTypeUpperRange;
   int payload_type_lower = kFirstDynamicPayloadTypeLowerRange;
 
-  std::vector<VideoCodec> output_codecs;
+  std::vector<Codec> output_codecs;
   for (const webrtc::SdpVideoFormat& format : supported_formats) {
-    VideoCodec codec = cricket::CreateVideoCodec(format);
+    Codec codec = cricket::CreateVideoCodec(format);
     bool isFecCodec = absl::EqualsIgnoreCase(codec.name, kUlpfecCodecName) ||
                       absl::EqualsIgnoreCase(codec.name, kFlexfecCodecName);
 
@@ -270,7 +270,7 @@
   return output_codecs;
 }
 
-static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) {
+static std::string CodecVectorToString(const std::vector<Codec>& codecs) {
   rtc::StringBuilder out;
   out << "{";
   for (size_t i = 0; i < codecs.size(); ++i) {
@@ -283,7 +283,7 @@
   return out.Release();
 }
 
-static bool ValidateCodecFormats(const std::vector<VideoCodec>& codecs) {
+static bool ValidateCodecFormats(const std::vector<Codec>& codecs) {
   bool has_video = false;
   for (size_t i = 0; i < codecs.size(); ++i) {
     if (!codecs[i].ValidateCodecFormat()) {
@@ -497,7 +497,7 @@
 }
 
 bool IsScalabilityModeSupportedByCodec(
-    const VideoCodec& codec,
+    const Codec& codec,
     const std::string& scalability_mode,
     const webrtc::VideoSendStream::Config& config) {
   return config.encoder_settings.encoder_factory
@@ -509,7 +509,7 @@
 // Fallback to default value if the scalability mode is unset or unsupported by
 // the codec.
 void FallbackToDefaultScalabilityModeIfNotSupported(
-    const VideoCodec& codec,
+    const Codec& codec,
     const webrtc::VideoSendStream::Config& config,
     std::vector<webrtc::RtpEncodingParameters>& encodings) {
   if (!absl::c_any_of(encodings,
@@ -545,8 +545,7 @@
 // "codecs". Note that VideoCodecSettings correspond to concrete codecs like
 // VP8, VP9, H264 while VideoCodecs correspond also to "virtual" codecs like
 // RTX, ULPFEC, FLEXFEC.
-std::vector<VideoCodecSettings> MapCodecs(
-    const std::vector<VideoCodec>& codecs) {
+std::vector<VideoCodecSettings> MapCodecs(const std::vector<Codec>& codecs) {
   if (codecs.empty()) {
     return {};
   }
@@ -560,7 +559,7 @@
   webrtc::UlpfecConfig ulpfec_config;
   absl::optional<int> flexfec_payload_type;
 
-  for (const VideoCodec& in_codec : codecs) {
+  for (const Codec& in_codec : codecs) {
     const int payload_type = in_codec.id;
 
     if (payload_codec_type.find(payload_type) != payload_codec_type.end()) {
@@ -796,13 +795,13 @@
       call, config, options, crypto_options, decoder_factory_.get());
 }
 
-std::vector<VideoCodec> WebRtcVideoEngine::send_codecs(bool include_rtx) const {
+std::vector<Codec> WebRtcVideoEngine::send_codecs(bool include_rtx) const {
   return GetPayloadTypesAndDefaultCodecs(encoder_factory_.get(),
                                          /*is_decoder_factory=*/false,
                                          include_rtx, trials_);
 }
 
-std::vector<VideoCodec> WebRtcVideoEngine::recv_codecs(bool include_rtx) const {
+std::vector<Codec> WebRtcVideoEngine::recv_codecs(bool include_rtx) const {
   return GetPayloadTypesAndDefaultCodecs(decoder_factory_.get(),
                                          /*is_decoder_factory=*/true,
                                          include_rtx, trials_);
@@ -902,7 +901,7 @@
 
 rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings>
 WebRtcVideoSendChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
-    const VideoCodec& codec) {
+    const Codec& codec) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   bool is_screencast = parameters_.options.is_screencast.value_or(false);
   // No automatic resizing when using simulcast or screencast, or when
@@ -1298,7 +1297,7 @@
   webrtc::RtpParameters rtp_params = it->second->GetRtpParameters();
   // Need to add the common list of codecs to the send stream-specific
   // RTP parameters.
-  for (const VideoCodec& codec : send_params_.codecs) {
+  for (const Codec& codec : send_params_.codecs) {
     if (send_codec() && send_codec()->codec.id == codec.id) {
       // Put the current send codec to the front of the codecs list.
       RTC_DCHECK_EQ(codec.name, send_codec()->codec.name);
@@ -2092,7 +2091,7 @@
 
 webrtc::VideoEncoderConfig
 WebRtcVideoSendChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig(
-    const VideoCodec& codec) const {
+    const Codec& codec) const {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   webrtc::VideoEncoderConfig encoder_config;
   encoder_config.codec_type = webrtc::PayloadStringToCodecType(codec.name);
@@ -2644,7 +2643,7 @@
   rtp_params.header_extensions = recv_rtp_extensions_;
 
   // Add codecs, which any stream is prepared to receive.
-  for (const VideoCodec& codec : recv_params_.codecs) {
+  for (const Codec& codec : recv_params_.codecs) {
     rtp_params.codecs.push_back(codec.ToCodecParameters());
   }
 
@@ -2664,7 +2663,7 @@
   rtp_params.encodings.emplace_back();
 
   // Add codecs, which any stream is prepared to receive.
-  for (const VideoCodec& codec : recv_params_.codecs) {
+  for (const Codec& codec : recv_params_.codecs) {
     rtp_params.codecs.push_back(codec.ToCodecParameters());
   }
 
@@ -2690,7 +2689,7 @@
 
   // Verify that every mapped codec is supported locally.
   if (params.is_stream_active) {
-    const std::vector<VideoCodec> local_supported_codecs =
+    const std::vector<Codec> local_supported_codecs =
         GetPayloadTypesAndDefaultCodecs(decoder_factory_,
                                         /*is_decoder_factory=*/true,
                                         /*include_rtx=*/true, call_->trials());
@@ -3041,7 +3040,7 @@
     VideoMediaReceiveInfo* video_media_info) {
   for (const auto& receiver : video_media_info->receivers) {
     auto codec =
-        absl::c_find_if(recv_params_.codecs, [&receiver](const VideoCodec& c) {
+        absl::c_find_if(recv_params_.codecs, [&receiver](const Codec& c) {
           return receiver.codec_payload_type &&
                  *receiver.codec_payload_type == c.id;
         });
@@ -3911,7 +3910,7 @@
 
 // ------------------------- VideoCodecSettings --------------------
 
-VideoCodecSettings::VideoCodecSettings(const VideoCodec& codec)
+VideoCodecSettings::VideoCodecSettings(const Codec& codec)
     : codec(codec), flexfec_payload_type(-1), rtx_payload_type(-1) {}
 
 bool VideoCodecSettings::operator==(const VideoCodecSettings& other) const {
diff --git a/media/engine/webrtc_video_engine.h b/media/engine/webrtc_video_engine.h
index d370a54..14df03a 100644
--- a/media/engine/webrtc_video_engine.h
+++ b/media/engine/webrtc_video_engine.h
@@ -116,14 +116,10 @@
       const VideoOptions& options,
       const webrtc::CryptoOptions& crypto_options) override;
 
-  std::vector<VideoCodec> send_codecs() const override {
-    return send_codecs(true);
-  }
-  std::vector<VideoCodec> recv_codecs() const override {
-    return recv_codecs(true);
-  }
-  std::vector<VideoCodec> send_codecs(bool include_rtx) const override;
-  std::vector<VideoCodec> recv_codecs(bool include_rtx) const override;
+  std::vector<Codec> send_codecs() const override { return send_codecs(true); }
+  std::vector<Codec> recv_codecs() const override { return recv_codecs(true); }
+  std::vector<Codec> send_codecs(bool include_rtx) const override;
+  std::vector<Codec> recv_codecs(bool include_rtx) const override;
   std::vector<webrtc::RtpHeaderExtensionCapability> GetRtpHeaderExtensions()
       const override;
 
@@ -136,7 +132,7 @@
 };
 
 struct VideoCodecSettings {
-  explicit VideoCodecSettings(const VideoCodec& codec);
+  explicit VideoCodecSettings(const Codec& codec);
 
   // Checks if all members of |*this| are equal to the corresponding members
   // of `other`.
@@ -148,7 +144,7 @@
   static bool EqualsDisregardingFlexfec(const VideoCodecSettings& a,
                                         const VideoCodecSettings& b);
 
-  VideoCodec codec;
+  Codec codec;
   webrtc::UlpfecConfig ulpfec;
   int flexfec_payload_type;  // -1 if absent.
   int rtx_payload_type;      // -1 if absent.
@@ -391,11 +387,11 @@
     };
 
     rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings>
-    ConfigureVideoEncoderSettings(const VideoCodec& codec);
+    ConfigureVideoEncoderSettings(const Codec& codec);
     void SetCodec(const VideoCodecSettings& codec);
     void RecreateWebRtcStream();
     webrtc::VideoEncoderConfig CreateVideoEncoderConfig(
-        const VideoCodec& codec) const;
+        const Codec& codec) const;
     void ReconfigureEncoder(webrtc::SetParametersCallback callback);
 
     // Calls Start or Stop according to whether or not `sending_` is true.
diff --git a/media/engine/webrtc_video_engine_unittest.cc b/media/engine/webrtc_video_engine_unittest.cc
index ca69dca..f8612f8 100644
--- a/media/engine/webrtc_video_engine_unittest.cc
+++ b/media/engine/webrtc_video_engine_unittest.cc
@@ -137,12 +137,12 @@
 static const char kUnsupportedExtensionName[] =
     "urn:ietf:params:rtp-hdrext:unsupported";
 
-cricket::VideoCodec RemoveFeedbackParams(cricket::VideoCodec&& codec) {
+cricket::Codec RemoveFeedbackParams(cricket::Codec&& codec) {
   codec.feedback_params = cricket::FeedbackParams();
   return std::move(codec);
 }
 
-void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec,
+void VerifyCodecHasDefaultFeedbackParams(const cricket::Codec& codec,
                                          bool lntf_expected) {
   EXPECT_EQ(lntf_expected,
             codec.HasFeedbackParam(cricket::FeedbackParam(
@@ -161,9 +161,8 @@
 
 // Return true if any codec in `codecs` is an RTX codec with associated
 // payload type `payload_type`.
-bool HasRtxCodec(const std::vector<cricket::VideoCodec>& codecs,
-                 int payload_type) {
-  for (const cricket::VideoCodec& codec : codecs) {
+bool HasRtxCodec(const std::vector<cricket::Codec>& codecs, int payload_type) {
+  for (const cricket::Codec& codec : codecs) {
     int associated_payload_type;
     if (absl::EqualsIgnoreCase(codec.name.c_str(), "rtx") &&
         codec.GetParam(cricket::kCodecParamAssociatedPayloadType,
@@ -177,8 +176,8 @@
 
 // Return true if any codec in `codecs` is an RTX codec, independent of
 // payload type.
-bool HasAnyRtxCodec(const std::vector<cricket::VideoCodec>& codecs) {
-  for (const cricket::VideoCodec& codec : codecs) {
+bool HasAnyRtxCodec(const std::vector<cricket::Codec>& codecs) {
+  for (const cricket::Codec& codec : codecs) {
     if (absl::EqualsIgnoreCase(codec.name.c_str(), "rtx")) {
       return true;
     }
@@ -381,7 +380,7 @@
 
   // Find the codec in the engine with the given name. The codec must be
   // present.
-  cricket::VideoCodec GetEngineCodec(const std::string& name) const;
+  cricket::Codec GetEngineCodec(const std::string& name) const;
   void AddSupportedVideoCodecType(
       const std::string& name,
       const std::vector<webrtc::ScalabilityMode>& scalability_modes = {});
@@ -391,7 +390,7 @@
   std::unique_ptr<VideoMediaReceiveChannelInterface>
   SetRecvParamsWithAllSupportedCodecs();
   std::unique_ptr<VideoMediaReceiveChannelInterface>
-  SetRecvParamsWithSupportedCodecs(const std::vector<VideoCodec>& codecs);
+  SetRecvParamsWithSupportedCodecs(const std::vector<Codec>& codecs);
 
   void ExpectRtpCapabilitySupport(const char* uri, bool supported) const;
 
@@ -406,7 +405,7 @@
   std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
       video_bitrate_allocator_factory_;
   WebRtcVideoEngine engine_;
-  absl::optional<VideoCodec> default_codec_;
+  absl::optional<Codec> default_codec_;
   std::map<int, int> default_apt_rtx_types_;
 };
 
@@ -414,7 +413,7 @@
   encoder_factory_->AddSupportedVideoCodecType("VP8");
   AssignDefaultCodec();
 
-  std::vector<VideoCodec> engine_codecs = engine_.send_codecs();
+  std::vector<Codec> engine_codecs = engine_.send_codecs();
   for (size_t i = 0; i < engine_codecs.size(); ++i) {
     if (engine_codecs[i].name != kRtxCodecName)
       continue;
@@ -717,7 +716,7 @@
   encoder_factory_->AddSupportedVideoCodec(h264_high);
 
   // First figure out what payload types the test codecs got assigned.
-  const std::vector<cricket::VideoCodec> codecs = engine_.send_codecs();
+  const std::vector<cricket::Codec> codecs = engine_.send_codecs();
   // Now search for RTX codecs for them. Expect that they all have associated
   // RTX codecs.
   EXPECT_TRUE(HasRtxCodec(
@@ -799,9 +798,9 @@
 }
 
 void WebRtcVideoEngineTest::AssignDefaultAptRtxTypes() {
-  std::vector<VideoCodec> engine_codecs = engine_.send_codecs();
+  std::vector<Codec> engine_codecs = engine_.send_codecs();
   RTC_DCHECK(!engine_codecs.empty());
-  for (const cricket::VideoCodec& codec : engine_codecs) {
+  for (const cricket::Codec& codec : engine_codecs) {
     if (codec.name == "rtx") {
       int associated_payload_type;
       if (codec.GetParam(kCodecParamAssociatedPayloadType,
@@ -813,10 +812,10 @@
 }
 
 void WebRtcVideoEngineTest::AssignDefaultCodec() {
-  std::vector<VideoCodec> engine_codecs = engine_.send_codecs();
+  std::vector<Codec> engine_codecs = engine_.send_codecs();
   RTC_DCHECK(!engine_codecs.empty());
   bool codec_set = false;
-  for (const cricket::VideoCodec& codec : engine_codecs) {
+  for (const cricket::Codec& codec : engine_codecs) {
     if (!codec_set && codec.name != "rtx" && codec.name != "red" &&
         codec.name != "ulpfec" && codec.name != "flexfec-03") {
       default_codec_ = codec;
@@ -829,9 +828,9 @@
 
 size_t WebRtcVideoEngineTest::GetEngineCodecIndex(
     const std::string& name) const {
-  const std::vector<cricket::VideoCodec> codecs = engine_.send_codecs();
+  const std::vector<cricket::Codec> codecs = engine_.send_codecs();
   for (size_t i = 0; i < codecs.size(); ++i) {
-    const cricket::VideoCodec engine_codec = codecs[i];
+    const cricket::Codec engine_codec = codecs[i];
     if (!absl::EqualsIgnoreCase(name, engine_codec.name))
       continue;
     // The tests only use H264 Constrained Baseline. Make sure we don't return
@@ -851,7 +850,7 @@
   return -1;
 }
 
-cricket::VideoCodec WebRtcVideoEngineTest::GetEngineCodec(
+cricket::Codec WebRtcVideoEngineTest::GetEngineCodec(
     const std::string& name) const {
   return engine_.send_codecs()[GetEngineCodecIndex(name)];
 }
@@ -873,7 +872,7 @@
   // We need to look up the codec in the engine to get the correct payload type.
   for (const webrtc::SdpVideoFormat& format :
        encoder_factory_->GetSupportedFormats()) {
-    cricket::VideoCodec engine_codec = GetEngineCodec(format.name);
+    cricket::Codec engine_codec = GetEngineCodec(format.name);
     if (!absl::c_linear_search(parameters.codecs, engine_codec)) {
       parameters.codecs.push_back(engine_codec);
     }
@@ -886,7 +885,7 @@
 
 std::unique_ptr<VideoMediaReceiveChannelInterface>
 WebRtcVideoEngineTest::SetRecvParamsWithSupportedCodecs(
-    const std::vector<VideoCodec>& codecs) {
+    const std::vector<Codec>& codecs) {
   std::unique_ptr<VideoMediaReceiveChannelInterface> channel =
       engine_.CreateReceiveChannel(call_.get(), GetMediaConfig(),
                                    VideoOptions(), webrtc::CryptoOptions());
@@ -899,10 +898,10 @@
 
 std::unique_ptr<VideoMediaReceiveChannelInterface>
 WebRtcVideoEngineTest::SetRecvParamsWithAllSupportedCodecs() {
-  std::vector<VideoCodec> codecs;
+  std::vector<Codec> codecs;
   for (const webrtc::SdpVideoFormat& format :
        decoder_factory_->GetSupportedFormats()) {
-    cricket::VideoCodec engine_codec = GetEngineCodec(format.name);
+    cricket::Codec engine_codec = GetEngineCodec(format.name);
     if (!absl::c_linear_search(codecs, engine_codec)) {
       codecs.push_back(engine_codec);
     }
@@ -965,7 +964,7 @@
   // Setup a channel with VP8, RTX and transport sequence number header
   // extension. Receive stream is not explicitly configured.
   AddSupportedVideoCodecType("VP8");
-  std::vector<VideoCodec> supported_codecs =
+  std::vector<Codec> supported_codecs =
       engine_.recv_codecs(/*include_rtx=*/true);
   ASSERT_EQ(supported_codecs[1].name, "rtx");
   int rtx_payload_type = supported_codecs[1].id;
@@ -1192,7 +1191,7 @@
 TEST_F(WebRtcVideoEngineTest, Flexfec03SendCodecEnablesWithFieldTrial) {
   encoder_factory_->AddSupportedVideoCodecType("VP8");
 
-  auto flexfec = Field("name", &VideoCodec::name, "flexfec-03");
+  auto flexfec = Field("name", &Codec::name, "flexfec-03");
 
   EXPECT_THAT(engine_.send_codecs(), Not(Contains(flexfec)));
 
@@ -1205,16 +1204,15 @@
 TEST_F(WebRtcVideoEngineTest, Flexfec03LowerPayloadTypeRange) {
   encoder_factory_->AddSupportedVideoCodecType("VP8");
 
-  auto flexfec = Field("name", &VideoCodec::name, "flexfec-03");
+  auto flexfec = Field("name", &Codec::name, "flexfec-03");
 
   // FlexFEC is active with field trial.
   webrtc::test::ScopedKeyValueConfig override_field_trials(
       field_trials_, "WebRTC-FlexFEC-03-Advertised/Enabled/");
   auto send_codecs = engine_.send_codecs();
-  auto it = std::find_if(send_codecs.begin(), send_codecs.end(),
-                         [](const cricket::VideoCodec& codec) {
-                           return codec.name == "flexfec-03";
-                         });
+  auto it = std::find_if(
+      send_codecs.begin(), send_codecs.end(),
+      [](const cricket::Codec& codec) { return codec.name == "flexfec-03"; });
   ASSERT_NE(it, send_codecs.end());
   EXPECT_LE(35, it->id);
   EXPECT_GE(65, it->id);
@@ -1241,11 +1239,11 @@
   // Set up external encoder factory with first codec, and initialize engine.
   encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName1);
 
-  std::vector<cricket::VideoCodec> codecs_before(engine_.send_codecs());
+  std::vector<cricket::Codec> codecs_before(engine_.send_codecs());
 
   // Add second codec.
   encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName2);
-  std::vector<cricket::VideoCodec> codecs_after(engine_.send_codecs());
+  std::vector<cricket::Codec> codecs_after(engine_.send_codecs());
   // The codec itself and RTX should have been added.
   EXPECT_EQ(codecs_before.size() + 2, codecs_after.size());
 
@@ -1293,7 +1291,7 @@
   // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
   // codecs.
   AddSupportedVideoCodecType("H264");
-  std::vector<cricket::VideoCodec> codecs;
+  std::vector<cricket::Codec> codecs;
   codecs.push_back(GetEngineCodec("H264"));
 
   auto receive_channel = SetRecvParamsWithSupportedCodecs(codecs);
@@ -1382,7 +1380,7 @@
       .WillRepeatedly(Return(supported_formats));
 
   // Verify the codecs from the engine.
-  const std::vector<VideoCodec> engine_codecs = engine.send_codecs();
+  const std::vector<Codec> engine_codecs = engine.send_codecs();
   // Verify default codecs has been added correctly.
   EXPECT_EQ(5u, engine_codecs.size());
   EXPECT_EQ("VP8", engine_codecs.at(0).name);
@@ -1481,7 +1479,7 @@
 
   ASSERT_TRUE(
       send_channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
-  cricket::VideoCodec codec = GetEngineCodec("VP8");
+  cricket::Codec codec = GetEngineCodec("VP8");
   cricket::VideoSenderParameters parameters;
   parameters.codecs.push_back(codec);
   send_channel->OnReadyToSend(true);
@@ -1536,8 +1534,8 @@
 
 TEST_F(WebRtcVideoEngineTest, SetVideoRtxEnabled) {
   AddSupportedVideoCodecType("VP8");
-  std::vector<VideoCodec> send_codecs;
-  std::vector<VideoCodec> recv_codecs;
+  std::vector<Codec> send_codecs;
+  std::vector<Codec> recv_codecs;
 
   webrtc::test::ScopedKeyValueConfig field_trials;
 
@@ -1831,7 +1829,7 @@
 
   bool SetDefaultCodec() { return SetOneCodec(DefaultCodec()); }
 
-  bool SetOneCodec(const cricket::VideoCodec& codec) {
+  bool SetOneCodec(const cricket::Codec& codec) {
     frame_source_ = std::make_unique<cricket::FakeFrameSource>(
         kVideoWidth, kVideoHeight, rtc::kNumMicrosecsPerSec / kFramerate);
 
@@ -1879,7 +1877,7 @@
   }
 
   // Tests that we can send and receive frames.
-  void SendAndReceive(const cricket::VideoCodec& codec) {
+  void SendAndReceive(const cricket::Codec& codec) {
     EXPECT_TRUE(SetOneCodec(codec));
     EXPECT_TRUE(SetSend(true));
     receive_channel_->SetDefaultSink(&renderer_);
@@ -1889,7 +1887,7 @@
     EXPECT_EQ(codec.id, GetPayloadType(GetRtpPacket(0)));
   }
 
-  void SendReceiveManyAndGetStats(const cricket::VideoCodec& codec,
+  void SendReceiveManyAndGetStats(const cricket::Codec& codec,
                                   int duration_sec,
                                   int fps) {
     EXPECT_TRUE(SetOneCodec(codec));
@@ -1920,7 +1918,7 @@
   // Two streams one channel tests.
 
   // Tests that we can send and receive frames.
-  void TwoStreamsSendAndReceive(const cricket::VideoCodec& codec) {
+  void TwoStreamsSendAndReceive(const cricket::Codec& codec) {
     SetUpSecondStream();
     // Test sending and receiving on first stream.
     SendAndReceive(codec);
@@ -1929,8 +1927,8 @@
     EXPECT_GT(NumRtpPackets(), 0);
   }
 
-  cricket::VideoCodec GetEngineCodec(const std::string& name) {
-    for (const cricket::VideoCodec& engine_codec : engine_.send_codecs()) {
+  cricket::Codec GetEngineCodec(const std::string& name) {
+    for (const cricket::Codec& engine_codec : engine_.send_codecs()) {
       if (absl::EqualsIgnoreCase(name, engine_codec.name))
         return engine_codec;
     }
@@ -1939,7 +1937,7 @@
     return cricket::CreateVideoCodec(0, "");
   }
 
-  cricket::VideoCodec DefaultCodec() { return GetEngineCodec("VP8"); }
+  cricket::Codec DefaultCodec() { return GetEngineCodec("VP8"); }
 
   cricket::StreamParams DefaultSendStreamParams() {
     return cricket::StreamParams::CreateLegacy(kSsrc);
@@ -2303,12 +2301,12 @@
 
 // Tests that we can add and remove capturers and frames are sent out properly
 TEST_F(WebRtcVideoChannelBaseTest, DISABLED_AddRemoveCapturer) {
+  using cricket::Codec;
   using cricket::FOURCC_I420;
-  using cricket::VideoCodec;
   using cricket::VideoFormat;
   using cricket::VideoOptions;
 
-  VideoCodec codec = DefaultCodec();
+  Codec codec = DefaultCodec();
   const int time_between_send_ms = VideoFormat::FpsToInterval(kFramerate);
   EXPECT_TRUE(SetOneCodec(codec));
   EXPECT_TRUE(SetSend(true));
@@ -2495,7 +2493,7 @@
   // initially will use QVGA instead of VGA.
   // TODO(pbos): Set up the quality scaler so that both senders reliably start
   // at QVGA, then verify that instead.
-  cricket::VideoCodec codec = GetEngineCodec("VP8");
+  cricket::Codec codec = GetEngineCodec("VP8");
   codec.params[kCodecParamStartBitrate] = "1000000";
   TwoStreamsSendAndReceive(codec);
 }
@@ -2508,7 +2506,7 @@
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
 
-  absl::optional<VideoCodec> codec = send_channel_->GetSendCodec();
+  absl::optional<Codec> codec = send_channel_->GetSendCodec();
   ASSERT_TRUE(codec);
   EXPECT_EQ("VP9", codec->name);
 
@@ -2534,7 +2532,7 @@
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
 
-  absl::optional<VideoCodec> codec = send_channel_->GetSendCodec();
+  absl::optional<Codec> codec = send_channel_->GetSendCodec();
   ASSERT_TRUE(codec);
   EXPECT_EQ("VP9", codec->name);
 
@@ -2552,7 +2550,7 @@
 }
 
 TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchStrictPreference) {
-  VideoCodec vp9 = GetEngineCodec("VP9");
+  Codec vp9 = GetEngineCodec("VP9");
   vp9.params["profile-id"] = "0";
 
   cricket::VideoSenderParameters parameters;
@@ -2560,7 +2558,7 @@
   parameters.codecs.push_back(vp9);
   EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
 
-  absl::optional<VideoCodec> codec = send_channel_->GetSendCodec();
+  absl::optional<Codec> codec = send_channel_->GetSendCodec();
   ASSERT_TRUE(codec);
   EXPECT_EQ("VP8", codec->name);
 
@@ -2674,8 +2672,8 @@
     return static_cast<cricket::WebRtcVideoSendChannel*>(channel)->transport();
   }
 
-  cricket::VideoCodec GetEngineCodec(const std::string& name) {
-    for (const cricket::VideoCodec& engine_codec : engine_.send_codecs()) {
+  cricket::Codec GetEngineCodec(const std::string& name) {
+    for (const cricket::Codec& engine_codec : engine_.send_codecs()) {
       if (absl::EqualsIgnoreCase(name, engine_codec.name))
         return engine_codec;
     }
@@ -2684,7 +2682,7 @@
     return cricket::CreateVideoCodec(0, "");
   }
 
-  cricket::VideoCodec DefaultCodec() { return GetEngineCodec("VP8"); }
+  cricket::Codec DefaultCodec() { return GetEngineCodec("VP8"); }
 
   // After receciving and processing the packet, enough time is advanced that
   // the unsignalled receive stream cooldown is no longer in effect.
@@ -3425,7 +3423,7 @@
 
 TEST_F(WebRtcVideoChannelTest, UsesCorrectSettingsForScreencast) {
   static const int kScreenshareMinBitrateKbps = 800;
-  cricket::VideoCodec codec = GetEngineCodec("VP8");
+  cricket::Codec codec = GetEngineCodec("VP8");
   cricket::VideoSenderParameters parameters;
   parameters.codecs.push_back(codec);
   EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
@@ -4126,7 +4124,7 @@
 }
 
 TEST_F(WebRtcVideoChannelTest, PreviousAdaptationDoesNotApplyToScreenshare) {
-  cricket::VideoCodec codec = GetEngineCodec("VP8");
+  cricket::Codec codec = GetEngineCodec("VP8");
   cricket::VideoSenderParameters parameters;
   parameters.codecs.push_back(codec);
 
@@ -4180,7 +4178,7 @@
 void WebRtcVideoChannelTest::TestDegradationPreference(
     bool resolution_scaling_enabled,
     bool fps_scaling_enabled) {
-  cricket::VideoCodec codec = GetEngineCodec("VP8");
+  cricket::Codec codec = GetEngineCodec("VP8");
   cricket::VideoSenderParameters parameters;
   parameters.codecs.push_back(codec);
 
@@ -4214,7 +4212,7 @@
 
 void WebRtcVideoChannelTest::TestCpuAdaptation(bool enable_overuse,
                                                bool is_screenshare) {
-  cricket::VideoCodec codec = GetEngineCodec("VP8");
+  cricket::Codec codec = GetEngineCodec("VP8");
   cricket::VideoSenderParameters parameters;
   parameters.codecs.push_back(codec);
 
@@ -4305,7 +4303,7 @@
   AssignDefaultAptRtxTypes();
   ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_));
 
-  absl::optional<VideoCodec> codec = send_channel_->GetSendCodec();
+  absl::optional<Codec> codec = send_channel_->GetSendCodec();
   ASSERT_TRUE(codec);
   EXPECT_TRUE(codec->Matches(engine_.send_codecs()[0]));
 
@@ -4534,7 +4532,7 @@
   cricket::VideoReceiverParameters recv_parameters;
   recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
   recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
-  cricket::VideoCodec duplicate = GetEngineCodec("flexfec-03");
+  cricket::Codec duplicate = GetEngineCodec("flexfec-03");
   duplicate.id = kUnusedPayloadType1;
   recv_parameters.codecs.push_back(duplicate);
   ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters));
@@ -4677,7 +4675,7 @@
   EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType));
 
   cricket::VideoSenderParameters parameters;
-  cricket::VideoCodec rtx_codec =
+  cricket::Codec rtx_codec =
       cricket::CreateVideoCodec(kUnusedPayloadType, "rtx");
   parameters.codecs.push_back(rtx_codec);
   EXPECT_FALSE(send_channel_->SetSenderParameters(parameters))
@@ -4691,7 +4689,7 @@
   EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType1));
   EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType2));
   {
-    cricket::VideoCodec rtx_codec = cricket::CreateVideoRtxCodec(
+    cricket::Codec rtx_codec = cricket::CreateVideoRtxCodec(
         kUnusedPayloadType1, GetEngineCodec("VP8").id);
     cricket::VideoSenderParameters parameters;
     parameters.codecs.push_back(GetEngineCodec("VP8"));
@@ -4699,7 +4697,7 @@
     ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
   }
   {
-    cricket::VideoCodec rtx_codec =
+    cricket::Codec rtx_codec =
         cricket::CreateVideoRtxCodec(kUnusedPayloadType1, kUnusedPayloadType2);
     cricket::VideoSenderParameters parameters;
     parameters.codecs.push_back(GetEngineCodec("VP8"));
@@ -4724,7 +4722,7 @@
   // Original payload type for RTX.
   cricket::VideoSenderParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
-  cricket::VideoCodec rtx_codec =
+  cricket::Codec rtx_codec =
       cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx");
   rtx_codec.SetParam("apt", GetEngineCodec("VP8").id);
   parameters.codecs.push_back(rtx_codec);
@@ -4794,7 +4792,7 @@
 
 TEST_F(WebRtcVideoChannelTest, SetSendCodecsChangesExistingStreams) {
   cricket::VideoSenderParameters parameters;
-  cricket::VideoCodec codec = cricket::CreateVideoCodec(100, "VP8");
+  cricket::Codec codec = cricket::CreateVideoCodec(100, "VP8");
   codec.SetParam(kCodecParamMaxQuantization, kDefaultVideoMaxQpVpx);
   parameters.codecs.push_back(codec);
 
@@ -5096,7 +5094,7 @@
   EXPECT_EQ(atoi(kMaxQuantization),
             AddSendStream()->GetVideoStreams().back().max_qp);
 
-  absl::optional<VideoCodec> codec = send_channel_->GetSendCodec();
+  absl::optional<Codec> codec = send_channel_->GetSendCodec();
   ASSERT_TRUE(codec);
   EXPECT_EQ(kMaxQuantization, codec->params[kCodecParamMaxQuantization]);
 }
@@ -5158,7 +5156,7 @@
 
   cricket::VideoReceiverParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
-  cricket::VideoCodec rtx_codec =
+  cricket::Codec rtx_codec =
       cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx");
   parameters.codecs.push_back(rtx_codec);
   EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters))
@@ -5171,7 +5169,7 @@
   parameters.codecs[1].SetParam("apt", GetEngineCodec("VP8").id);
   EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
 
-  cricket::VideoCodec rtx_codec2 =
+  cricket::Codec rtx_codec2 =
       cricket::CreateVideoCodec(kUnusedPayloadType2, "rtx");
   rtx_codec2.SetParam("apt", rtx_codec.id);
   parameters.codecs.push_back(rtx_codec2);
@@ -5182,7 +5180,7 @@
 }
 
 TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketization) {
-  cricket::VideoCodec vp8_codec = GetEngineCodec("VP8");
+  cricket::Codec vp8_codec = GetEngineCodec("VP8");
   vp8_codec.packetization = kPacketizationParamRaw;
 
   cricket::VideoReceiverParameters parameters;
@@ -5266,7 +5264,7 @@
   // Original payload type for RTX.
   cricket::VideoReceiverParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
-  cricket::VideoCodec rtx_codec =
+  cricket::Codec rtx_codec =
       cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx");
   rtx_codec.SetParam("apt", GetEngineCodec("VP8").id);
   parameters.codecs.push_back(rtx_codec);
@@ -5310,7 +5308,7 @@
   // Payload type for RTX.
   cricket::VideoReceiverParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
-  cricket::VideoCodec rtx_codec =
+  cricket::Codec rtx_codec =
       cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx");
   rtx_codec.SetParam("apt", GetEngineCodec("VP8").id);
   parameters.codecs.push_back(rtx_codec);
@@ -7376,8 +7374,8 @@
   EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kRedRtxPayloadType));
 
   // Add a RED RTX codec.
-  VideoCodec red_rtx_codec = cricket::CreateVideoRtxCodec(
-      kRedRtxPayloadType, GetEngineCodec("red").id);
+  Codec red_rtx_codec = cricket::CreateVideoRtxCodec(kRedRtxPayloadType,
+                                                     GetEngineCodec("red").id);
   recv_parameters_.codecs.push_back(red_rtx_codec);
   EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_));
 
@@ -7422,7 +7420,7 @@
 
 TEST_F(WebRtcVideoChannelTest, RtxPacketDoesntCreateUnsignalledStream) {
   AssignDefaultAptRtxTypes();
-  const cricket::VideoCodec vp8 = GetEngineCodec("VP8");
+  const cricket::Codec vp8 = GetEngineCodec("VP8");
   const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
   TestReceiveUnsignaledSsrcPacket(rtx_vp8_payload_type,
                                   false /* expect_created_receive_stream */);
@@ -7446,7 +7444,7 @@
 
 TEST_F(WebRtcVideoChannelTest, RtxAfterMediaPacketUpdatesUnsignalledRtxSsrc) {
   AssignDefaultAptRtxTypes();
-  const cricket::VideoCodec vp8 = GetEngineCodec("VP8");
+  const cricket::Codec vp8 = GetEngineCodec("VP8");
   const int payload_type = vp8.id;
   const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
   const uint32_t ssrc = kIncomingUnsignalledSsrc;
@@ -7481,7 +7479,7 @@
 
 TEST_F(WebRtcVideoChannelTest, UnsignaledStreamCreatedAfterMediaPacket) {
   AssignDefaultAptRtxTypes();
-  const cricket::VideoCodec vp8 = GetEngineCodec("VP8");
+  const cricket::Codec vp8 = GetEngineCodec("VP8");
   const int payload_type = vp8.id;
   const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
   const uint32_t ssrc = kIncomingUnsignalledSsrc;
@@ -7519,7 +7517,7 @@
   parameters.codecs.push_back(GetEngineCodec("VP9"));
 
 #if defined(WEBRTC_USE_H264)
-  cricket::VideoCodec H264codec = cricket::CreateVideoCodec(126, "H264");
+  cricket::Codec H264codec = cricket::CreateVideoCodec(126, "H264");
   parameters.codecs.push_back(H264codec);
 #endif
 
@@ -9197,10 +9195,10 @@
 TEST_F(WebRtcVideoChannelTest, DISABLED_GetRtpReceiveFmtpSprop) {
 #endif
   cricket::VideoReceiverParameters parameters;
-  cricket::VideoCodec kH264sprop1 = cricket::CreateVideoCodec(101, "H264");
+  cricket::Codec kH264sprop1 = cricket::CreateVideoCodec(101, "H264");
   kH264sprop1.SetParam(kH264FmtpSpropParameterSets, "uvw");
   parameters.codecs.push_back(kH264sprop1);
-  cricket::VideoCodec kH264sprop2 = cricket::CreateVideoCodec(102, "H264");
+  cricket::Codec kH264sprop2 = cricket::CreateVideoCodec(102, "H264");
   kH264sprop2.SetParam(kH264FmtpSpropParameterSets, "xyz");
   parameters.codecs.push_back(kH264sprop2);
   EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
@@ -9303,7 +9301,7 @@
        AddReceiveStreamAfterReceivingNonPrimaryUnsignaledSsrc) {
   // Receive VP8 RTX packet.
   RtpPacketReceived rtp_packet;
-  const cricket::VideoCodec vp8 = GetEngineCodec("VP8");
+  const cricket::Codec vp8 = GetEngineCodec("VP8");
   rtp_packet.SetPayloadType(default_apt_rtx_types_[vp8.id]);
   rtp_packet.SetSsrc(2);
   ReceivePacketAndAdvanceTime(rtp_packet);
@@ -9515,7 +9513,7 @@
   }
 
  protected:
-  void VerifySimulcastSettings(const VideoCodec& codec,
+  void VerifySimulcastSettings(const Codec& codec,
                                int capture_width,
                                int capture_height,
                                size_t num_configured_streams,
@@ -9753,7 +9751,7 @@
 }
 
 TEST_F(WebRtcVideoChannelBaseTest, EncoderSelectorSwitchCodec) {
-  VideoCodec vp9 = GetEngineCodec("VP9");
+  Codec vp9 = GetEngineCodec("VP9");
 
   cricket::VideoSenderParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
@@ -9761,7 +9759,7 @@
   EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
   send_channel_->SetSend(true);
 
-  absl::optional<VideoCodec> codec = send_channel_->GetSendCodec();
+  absl::optional<Codec> codec = send_channel_->GetSendCodec();
   ASSERT_TRUE(codec);
   EXPECT_EQ("VP8", codec->name);
 
diff --git a/media/engine/webrtc_voice_engine.cc b/media/engine/webrtc_voice_engine.cc
index 704544c..db43848 100644
--- a/media/engine/webrtc_voice_engine.cc
+++ b/media/engine/webrtc_voice_engine.cc
@@ -127,7 +127,7 @@
 }
 
 // Dumps an AudioCodec in RFC 2327-ish format.
-std::string ToString(const AudioCodec& codec) {
+std::string ToString(const Codec& codec) {
   rtc::StringBuilder ss;
   ss << codec.name << "/" << codec.clockrate << "/" << codec.channels;
   if (!codec.params.empty()) {
@@ -141,13 +141,13 @@
   return ss.Release();
 }
 
-bool IsCodec(const AudioCodec& codec, const char* ref_name) {
+bool IsCodec(const Codec& codec, const char* ref_name) {
   return absl::EqualsIgnoreCase(codec.name, ref_name);
 }
 
-absl::optional<AudioCodec> FindCodec(const std::vector<AudioCodec>& codecs,
-                                     const AudioCodec& codec) {
-  for (const AudioCodec& c : codecs) {
+absl::optional<Codec> FindCodec(const std::vector<Codec>& codecs,
+                                const Codec& codec) {
+  for (const Codec& c : codecs) {
     if (c.Matches(codec)) {
       return c;
     }
@@ -155,13 +155,13 @@
   return absl::nullopt;
 }
 
-bool VerifyUniquePayloadTypes(const std::vector<AudioCodec>& codecs) {
+bool VerifyUniquePayloadTypes(const std::vector<Codec>& codecs) {
   if (codecs.empty()) {
     return true;
   }
   std::vector<int> payload_types;
   absl::c_transform(codecs, std::back_inserter(payload_types),
-                    [](const AudioCodec& codec) { return codec.id; });
+                    [](const Codec& codec) { return codec.id; });
   absl::c_sort(payload_types);
   return absl::c_adjacent_find(payload_types) == payload_types.end();
 }
@@ -302,7 +302,7 @@
 
 // Utility function to check if RED codec and its parameters match a codec spec.
 bool CheckRedParameters(
-    const AudioCodec& red_codec,
+    const Codec& red_codec,
     const webrtc::AudioSendStream::Config::SendCodecSpec& send_codec_spec) {
   if (red_codec.clockrate != send_codec_spec.format.clockrate_hz ||
       red_codec.channels != send_codec_spec.format.num_channels) {
@@ -383,13 +383,13 @@
   // Load our audio codec lists.
   RTC_LOG(LS_VERBOSE) << "Supported send codecs in order of preference:";
   send_codecs_ = CollectCodecs(encoder_factory_->GetSupportedEncoders());
-  for (const AudioCodec& codec : send_codecs_) {
+  for (const Codec& codec : send_codecs_) {
     RTC_LOG(LS_VERBOSE) << ToString(codec);
   }
 
   RTC_LOG(LS_VERBOSE) << "Supported recv codecs in order of preference:";
   recv_codecs_ = CollectCodecs(decoder_factory_->GetSupportedDecoders());
-  for (const AudioCodec& codec : recv_codecs_) {
+  for (const Codec& codec : recv_codecs_) {
     RTC_LOG(LS_VERBOSE) << ToString(codec);
   }
 
@@ -629,12 +629,12 @@
   ap->ApplyConfig(apm_config);
 }
 
-const std::vector<AudioCodec>& WebRtcVoiceEngine::send_codecs() const {
+const std::vector<Codec>& WebRtcVoiceEngine::send_codecs() const {
   RTC_DCHECK(signal_thread_checker_.IsCurrent());
   return send_codecs_;
 }
 
-const std::vector<AudioCodec>& WebRtcVoiceEngine::recv_codecs() const {
+const std::vector<Codec>& WebRtcVoiceEngine::recv_codecs() const {
   RTC_DCHECK(signal_thread_checker_.IsCurrent());
   return recv_codecs_;
 }
@@ -707,10 +707,10 @@
   return audio_state_.get();
 }
 
-std::vector<AudioCodec> WebRtcVoiceEngine::CollectCodecs(
+std::vector<Codec> WebRtcVoiceEngine::CollectCodecs(
     const std::vector<webrtc::AudioCodecSpec>& specs) const {
   PayloadTypeMapper mapper;
-  std::vector<AudioCodec> out;
+  std::vector<Codec> out;
 
   // Only generate CN payload types for these clockrates:
   std::map<int, bool, std::greater<int>> generate_cn = {
@@ -720,8 +720,8 @@
       {8000, false}, {16000, false}, {32000, false}, {48000, false}};
 
   auto map_format = [&mapper](const webrtc::SdpAudioFormat& format,
-                              std::vector<AudioCodec>* out) {
-    absl::optional<AudioCodec> opt_codec = mapper.ToAudioCodec(format);
+                              std::vector<Codec>* out) {
+    absl::optional<Codec> opt_codec = mapper.ToAudioCodec(format);
     if (opt_codec) {
       if (out) {
         out->push_back(*opt_codec);
@@ -736,9 +736,9 @@
 
   for (const auto& spec : specs) {
     // We need to do some extra stuff before adding the main codecs to out.
-    absl::optional<AudioCodec> opt_codec = map_format(spec.format, nullptr);
+    absl::optional<Codec> opt_codec = map_format(spec.format, nullptr);
     if (opt_codec) {
-      AudioCodec& codec = *opt_codec;
+      Codec& codec = *opt_codec;
       if (spec.info.supports_network_adaption) {
         codec.AddFeedbackParam(
             FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
@@ -1772,7 +1772,7 @@
 void WebRtcVoiceSendChannel::FillSendCodecStats(
     VoiceMediaSendInfo* voice_media_info) {
   for (const auto& sender : voice_media_info->senders) {
-    auto codec = absl::c_find_if(send_codecs_, [&sender](const AudioCodec& c) {
+    auto codec = absl::c_find_if(send_codecs_, [&sender](const Codec& c) {
       return sender.codec_payload_type && *sender.codec_payload_type == c.id;
     });
     if (codec != send_codecs_.end()) {
@@ -1810,7 +1810,7 @@
   webrtc::RtpParameters rtp_params = it->second->rtp_parameters();
   // Need to add the common list of codecs to the send stream-specific
   // RTP parameters.
-  for (const AudioCodec& codec : send_codecs_) {
+  for (const Codec& codec : send_codecs_) {
     rtp_params.codecs.push_back(codec.ToCodecParameters());
   }
   return rtp_params;
@@ -2084,7 +2084,7 @@
   rtp_params.encodings.back().ssrc = it->second->stream().remote_ssrc();
   rtp_params.header_extensions = recv_rtp_extensions_;
 
-  for (const AudioCodec& codec : recv_codecs_) {
+  for (const Codec& codec : recv_codecs_) {
     rtp_params.codecs.push_back(codec.ToCodecParameters());
   }
   return rtp_params;
@@ -2102,7 +2102,7 @@
   }
   rtp_params.encodings.emplace_back();
 
-  for (const AudioCodec& codec : recv_codecs_) {
+  for (const Codec& codec : recv_codecs_) {
     rtp_params.codecs.push_back(codec.ToCodecParameters());
   }
   return rtp_params;
@@ -2124,7 +2124,7 @@
 }
 
 bool WebRtcVoiceReceiveChannel::SetRecvCodecs(
-    const std::vector<AudioCodec>& codecs) {
+    const std::vector<Codec>& codecs) {
   RTC_DCHECK_RUN_ON(worker_thread_);
 
   // Set the payload types to be used for incoming media.
@@ -2138,10 +2138,10 @@
   // Create a payload type -> SdpAudioFormat map with all the decoders. Fail
   // unless the factory claims to support all decoders.
   std::map<int, webrtc::SdpAudioFormat> decoder_map;
-  for (const AudioCodec& codec : codecs) {
+  for (const Codec& codec : codecs) {
     // Log a warning if a codec's payload type is changing. This used to be
     // treated as an error. It's abnormal, but not really illegal.
-    absl::optional<AudioCodec> old_codec = FindCodec(recv_codecs_, codec);
+    absl::optional<Codec> old_codec = FindCodec(recv_codecs_, codec);
     if (old_codec && old_codec->id != codec.id) {
       RTC_LOG(LS_WARNING) << codec.name << " mapped to a second payload type ("
                           << codec.id << ", was already mapped to "
@@ -2632,7 +2632,7 @@
     VoiceMediaReceiveInfo* voice_media_info) {
   for (const auto& receiver : voice_media_info->receivers) {
     auto codec =
-        absl::c_find_if(recv_codecs_, [&receiver](const AudioCodec& c) {
+        absl::c_find_if(recv_codecs_, [&receiver](const Codec& c) {
           return receiver.codec_payload_type &&
                  *receiver.codec_payload_type == c.id;
         });
diff --git a/media/engine/webrtc_voice_engine.h b/media/engine/webrtc_voice_engine.h
index 502a062..379e91d 100644
--- a/media/engine/webrtc_voice_engine.h
+++ b/media/engine/webrtc_voice_engine.h
@@ -116,8 +116,8 @@
       const webrtc::CryptoOptions& crypto_options,
       webrtc::AudioCodecPairId codec_pair_id) override;
 
-  const std::vector<AudioCodec>& send_codecs() const override;
-  const std::vector<AudioCodec>& recv_codecs() const override;
+  const std::vector<Codec>& send_codecs() const override;
+  const std::vector<Codec>& recv_codecs() const override;
   std::vector<webrtc::RtpHeaderExtensionCapability> GetRtpHeaderExtensions()
       const override;
 
@@ -147,7 +147,7 @@
   webrtc::AudioProcessing* apm() const;
   webrtc::AudioState* audio_state();
 
-  std::vector<AudioCodec> CollectCodecs(
+  std::vector<Codec> CollectCodecs(
       const std::vector<webrtc::AudioCodecSpec>& specs) const;
 
   webrtc::SequenceChecker signal_thread_checker_{
@@ -166,8 +166,8 @@
   std::unique_ptr<webrtc::AudioFrameProcessor> audio_frame_processor_;
   // The primary instance of WebRtc VoiceEngine.
   rtc::scoped_refptr<webrtc::AudioState> audio_state_;
-  std::vector<AudioCodec> send_codecs_;
-  std::vector<AudioCodec> recv_codecs_;
+  std::vector<Codec> send_codecs_;
+  std::vector<Codec> recv_codecs_;
   bool is_dumping_aec_ = false;
   bool initialized_ = false;
 
@@ -299,7 +299,7 @@
       webrtc::SequenceChecker::kDetached};
 
   WebRtcVoiceEngine* const engine_ = nullptr;
-  std::vector<AudioCodec> send_codecs_;
+  std::vector<Codec> send_codecs_;
 
   int max_send_bitrate_bps_ = 0;
   AudioOptions options_;
@@ -428,7 +428,7 @@
 
  private:
   bool SetOptions(const AudioOptions& options);
-  bool SetRecvCodecs(const std::vector<AudioCodec>& codecs);
+  bool SetRecvCodecs(const std::vector<Codec>& codecs);
   bool SetLocalSource(uint32_t ssrc, AudioSource* source);
   bool MuteStream(uint32_t ssrc, bool mute);
 
@@ -453,7 +453,7 @@
   // TODO(kwiberg): decoder_map_ and recv_codecs_ store the exact same
   // information, in slightly different formats. Eliminate recv_codecs_.
   std::map<int, webrtc::SdpAudioFormat> decoder_map_;
-  std::vector<AudioCodec> recv_codecs_;
+  std::vector<Codec> recv_codecs_;
 
   AudioOptions options_;
   bool recv_nack_enabled_ = false;
diff --git a/media/engine/webrtc_voice_engine_unittest.cc b/media/engine/webrtc_voice_engine_unittest.cc
index 852abd9..ad9140b 100644
--- a/media/engine/webrtc_voice_engine_unittest.cc
+++ b/media/engine/webrtc_voice_engine_unittest.cc
@@ -65,23 +65,22 @@
 
 constexpr uint32_t kMaxUnsignaledRecvStreams = 4;
 
-const cricket::AudioCodec kPcmuCodec =
-    cricket::CreateAudioCodec(0, "PCMU", 8000, 1);
-const cricket::AudioCodec kOpusCodec =
+const cricket::Codec kPcmuCodec = cricket::CreateAudioCodec(0, "PCMU", 8000, 1);
+const cricket::Codec kOpusCodec =
     cricket::CreateAudioCodec(111, "opus", 48000, 2);
-const cricket::AudioCodec kG722CodecVoE =
+const cricket::Codec kG722CodecVoE =
     cricket::CreateAudioCodec(9, "G722", 16000, 1);
-const cricket::AudioCodec kG722CodecSdp =
+const cricket::Codec kG722CodecSdp =
     cricket::CreateAudioCodec(9, "G722", 8000, 1);
-const cricket::AudioCodec kCn8000Codec =
+const cricket::Codec kCn8000Codec =
     cricket::CreateAudioCodec(13, "CN", 8000, 1);
-const cricket::AudioCodec kCn16000Codec =
+const cricket::Codec kCn16000Codec =
     cricket::CreateAudioCodec(105, "CN", 16000, 1);
-const cricket::AudioCodec kRed48000Codec =
+const cricket::Codec kRed48000Codec =
     cricket::CreateAudioCodec(112, "RED", 48000, 2);
-const cricket::AudioCodec kTelephoneEventCodec1 =
+const cricket::Codec kTelephoneEventCodec1 =
     cricket::CreateAudioCodec(106, "telephone-event", 8000, 1);
-const cricket::AudioCodec kTelephoneEventCodec2 =
+const cricket::Codec kTelephoneEventCodec2 =
     cricket::CreateAudioCodec(107, "telephone-event", 32000, 1);
 
 const uint32_t kSsrc0 = 0;
@@ -360,9 +359,7 @@
     EXPECT_TRUE(send_channel_->SetAudioSend(ssrc, enable, options, source));
   }
 
-  void TestInsertDtmf(uint32_t ssrc,
-                      bool caller,
-                      const cricket::AudioCodec& codec) {
+  void TestInsertDtmf(uint32_t ssrc, bool caller, const cricket::Codec& codec) {
     EXPECT_TRUE(SetupChannel());
     if (caller) {
       // If this is a caller, local description will be applied and add the
@@ -431,7 +428,7 @@
   // `max_bitrate` is a parameter to set to SetMaxSendBandwidth().
   // `expected_result` is the expected result from SetMaxSendBandwidth().
   // `expected_bitrate` is the expected audio bitrate afterward.
-  void TestMaxSendBandwidth(const cricket::AudioCodec& codec,
+  void TestMaxSendBandwidth(const cricket::Codec& codec,
                             int max_bitrate,
                             bool expected_result,
                             int expected_bitrate) {
@@ -456,7 +453,7 @@
     return send_channel_->SetRtpSendParameters(ssrc, parameters).ok();
   }
 
-  void SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) {
+  void SetGlobalMaxBitrate(const cricket::Codec& codec, int bitrate) {
     cricket::AudioSenderParameter send_parameters;
     send_parameters.codecs.push_back(codec);
     send_parameters.max_bandwidth_bps = bitrate;
@@ -484,7 +481,7 @@
     return GetSendStreamConfig(ssrc).audio_network_adaptor_config;
   }
 
-  void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec,
+  void SetAndExpectMaxBitrate(const cricket::Codec& codec,
                               int global_max,
                               int stream_max,
                               bool expected_result,
@@ -789,14 +786,14 @@
       const cricket::VoiceMediaSendInfo& send_info,
       const cricket::VoiceMediaReceiveInfo& receive_info) const {
     EXPECT_EQ(send_parameters_.codecs.size(), send_info.send_codecs.size());
-    for (const cricket::AudioCodec& codec : send_parameters_.codecs) {
+    for (const cricket::Codec& codec : send_parameters_.codecs) {
       ASSERT_EQ(send_info.send_codecs.count(codec.id), 1U);
       EXPECT_EQ(send_info.send_codecs.find(codec.id)->second,
                 codec.ToCodecParameters());
     }
     EXPECT_EQ(recv_parameters_.codecs.size(),
               receive_info.receive_codecs.size());
-    for (const cricket::AudioCodec& codec : recv_parameters_.codecs) {
+    for (const cricket::Codec& codec : recv_parameters_.codecs) {
       ASSERT_EQ(receive_info.receive_codecs.count(codec.id), 1U);
       EXPECT_EQ(receive_info.receive_codecs.find(codec.id)->second,
                 codec.ToCodecParameters());
@@ -893,9 +890,9 @@
 }
 
 TEST_P(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) {
-  const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs();
+  const std::vector<cricket::Codec>& codecs = engine_->send_codecs();
   bool opus_found = false;
-  for (const cricket::AudioCodec& codec : codecs) {
+  for (const cricket::Codec& codec : codecs) {
     if (codec.name == "opus") {
       EXPECT_TRUE(HasTransportCc(codec));
       opus_found = true;
@@ -3764,7 +3761,7 @@
         webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr, apm,
         nullptr, field_trials);
     engine.Init();
-    for (const cricket::AudioCodec& codec : engine.send_codecs()) {
+    for (const cricket::Codec& codec : engine.send_codecs()) {
       auto is_codec = [&codec](const char* name, int clockrate = 0) {
         return absl::EqualsIgnoreCase(codec.name, name) &&
                (clockrate == 0 || codec.clockrate == clockrate);
@@ -3952,8 +3949,8 @@
 
     // Rather than just ASSERTing that there are enough codecs, ensure that we
     // can check the actual values safely, to provide better test results.
-    auto get_codec = [&codecs](size_t index) -> const cricket::AudioCodec& {
-      static const cricket::AudioCodec missing_codec =
+    auto get_codec = [&codecs](size_t index) -> const cricket::Codec& {
+      static const cricket::Codec missing_codec =
           cricket::CreateAudioCodec(0, "<missing>", 0, 0);
       if (codecs.size() > index)
         return codecs[index];
@@ -3972,7 +3969,7 @@
     // check supplementary codecs are ordered after the general codecs.
     auto find_codec = [&codecs](const webrtc::SdpAudioFormat& format) -> int {
       for (size_t i = 0; i != codecs.size(); ++i) {
-        const cricket::AudioCodec& codec = codecs[i];
+        const cricket::Codec& codec = codecs[i];
         if (absl::EqualsIgnoreCase(codec.name, format.name) &&
             codec.clockrate == format.clockrate_hz &&
             codec.channels == format.num_channels) {
diff --git a/pc/channel.cc b/pc/channel.cc
index 7a1f55d..483b2ce 100644
--- a/pc/channel.cc
+++ b/pc/channel.cc
@@ -1029,15 +1029,15 @@
   // instead.
   bool needs_send_params_update = false;
   if (type == SdpType::kAnswer || type == SdpType::kPrAnswer) {
-    webrtc::flat_set<const VideoCodec*> matched_codecs;
-    for (VideoCodec& send_codec : send_params.codecs) {
-      if (absl::c_any_of(matched_codecs, [&](const VideoCodec* c) {
+    webrtc::flat_set<const Codec*> matched_codecs;
+    for (Codec& send_codec : send_params.codecs) {
+      if (absl::c_any_of(matched_codecs, [&](const Codec* c) {
             return send_codec.Matches(*c);
           })) {
         continue;
       }
 
-      std::vector<const VideoCodec*> recv_codecs =
+      std::vector<const Codec*> recv_codecs =
           FindAllMatchingCodecs(recv_params.codecs, send_codec);
       if (recv_codecs.empty()) {
         continue;
@@ -1045,7 +1045,7 @@
 
       bool may_ignore_packetization = false;
       bool has_matching_packetization = false;
-      for (const VideoCodec* recv_codec : recv_codecs) {
+      for (const Codec* recv_codec : recv_codecs) {
         if (!recv_codec->packetization.has_value() &&
             send_codec.packetization.has_value()) {
           may_ignore_packetization = true;
diff --git a/pc/channel_unittest.cc b/pc/channel_unittest.cc
index 21a147c..ade298b 100644
--- a/pc/channel_unittest.cc
+++ b/pc/channel_unittest.cc
@@ -2098,8 +2098,8 @@
 }
 
 TEST_F(VideoChannelSingleThreadTest, TestSetLocalOfferWithPacketization) {
-  const cricket::VideoCodec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
-  cricket::VideoCodec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
+  const cricket::Codec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
+  cricket::Codec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
   vp9_codec.packetization = cricket::kPacketizationParamRaw;
   cricket::VideoContentDescription video;
   video.set_codecs({kVp8Codec, vp9_codec});
@@ -2121,8 +2121,8 @@
 }
 
 TEST_F(VideoChannelSingleThreadTest, TestSetRemoteOfferWithPacketization) {
-  const cricket::VideoCodec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
-  cricket::VideoCodec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
+  const cricket::Codec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
+  cricket::Codec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
   vp9_codec.packetization = cricket::kPacketizationParamRaw;
   cricket::VideoContentDescription video;
   video.set_codecs({kVp8Codec, vp9_codec});
@@ -2143,8 +2143,8 @@
 }
 
 TEST_F(VideoChannelSingleThreadTest, TestSetAnswerWithPacketization) {
-  const cricket::VideoCodec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
-  cricket::VideoCodec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
+  const cricket::Codec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
+  cricket::Codec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
   vp9_codec.packetization = cricket::kPacketizationParamRaw;
   cricket::VideoContentDescription video;
   video.set_codecs({kVp8Codec, vp9_codec});
@@ -2175,8 +2175,8 @@
 }
 
 TEST_F(VideoChannelSingleThreadTest, TestSetLocalAnswerWithoutPacketization) {
-  const cricket::VideoCodec kLocalCodec = cricket::CreateVideoCodec(98, "VP8");
-  cricket::VideoCodec remote_codec = cricket::CreateVideoCodec(99, "VP8");
+  const cricket::Codec kLocalCodec = cricket::CreateVideoCodec(98, "VP8");
+  cricket::Codec remote_codec = cricket::CreateVideoCodec(99, "VP8");
   remote_codec.packetization = cricket::kPacketizationParamRaw;
   cricket::VideoContentDescription local_video;
   local_video.set_codecs({kLocalCodec});
@@ -2197,9 +2197,9 @@
 }
 
 TEST_F(VideoChannelSingleThreadTest, TestSetRemoteAnswerWithoutPacketization) {
-  cricket::VideoCodec local_codec = cricket::CreateVideoCodec(98, "VP8");
+  cricket::Codec local_codec = cricket::CreateVideoCodec(98, "VP8");
   local_codec.packetization = cricket::kPacketizationParamRaw;
-  const cricket::VideoCodec kRemoteCodec = cricket::CreateVideoCodec(99, "VP8");
+  const cricket::Codec kRemoteCodec = cricket::CreateVideoCodec(99, "VP8");
   cricket::VideoContentDescription local_video;
   local_video.set_codecs({local_codec});
   cricket::VideoContentDescription remote_video;
@@ -2221,9 +2221,9 @@
 
 TEST_F(VideoChannelSingleThreadTest,
        TestSetRemoteAnswerWithInvalidPacketization) {
-  cricket::VideoCodec local_codec = cricket::CreateVideoCodec(98, "VP8");
+  cricket::Codec local_codec = cricket::CreateVideoCodec(98, "VP8");
   local_codec.packetization = cricket::kPacketizationParamRaw;
-  cricket::VideoCodec remote_codec = cricket::CreateVideoCodec(99, "VP8");
+  cricket::Codec remote_codec = cricket::CreateVideoCodec(99, "VP8");
   remote_codec.packetization = "unknownpacketizationattributevalue";
   cricket::VideoContentDescription local_video;
   local_video.set_codecs({local_codec});
@@ -2246,9 +2246,9 @@
 
 TEST_F(VideoChannelSingleThreadTest,
        TestSetLocalAnswerWithInvalidPacketization) {
-  cricket::VideoCodec local_codec = cricket::CreateVideoCodec(98, "VP8");
+  cricket::Codec local_codec = cricket::CreateVideoCodec(98, "VP8");
   local_codec.packetization = cricket::kPacketizationParamRaw;
-  const cricket::VideoCodec kRemoteCodec = cricket::CreateVideoCodec(99, "VP8");
+  const cricket::Codec kRemoteCodec = cricket::CreateVideoCodec(99, "VP8");
   cricket::VideoContentDescription local_video;
   local_video.set_codecs({local_codec});
   cricket::VideoContentDescription remote_video;
@@ -2269,12 +2269,12 @@
 
 TEST_F(VideoChannelSingleThreadTest,
        StopsPacketizationVerificationWhenMatchIsFoundInRemoteAnswer) {
-  cricket::VideoCodec vp8_foo = cricket::CreateVideoCodec(96, "VP8");
+  cricket::Codec vp8_foo = cricket::CreateVideoCodec(96, "VP8");
   vp8_foo.packetization = "foo";
-  cricket::VideoCodec vp8_bar = cricket::CreateVideoCodec(97, "VP8");
+  cricket::Codec vp8_bar = cricket::CreateVideoCodec(97, "VP8");
   vp8_bar.packetization = "bar";
-  cricket::VideoCodec vp9 = cricket::CreateVideoCodec(98, "VP9");
-  cricket::VideoCodec vp9_foo = cricket::CreateVideoCodec(99, "VP9");
+  cricket::Codec vp9 = cricket::CreateVideoCodec(98, "VP9");
+  cricket::Codec vp9_foo = cricket::CreateVideoCodec(99, "VP9");
   vp9_foo.packetization = "bar";
   cricket::VideoContentDescription local;
   local.set_codecs({vp8_foo, vp8_bar, vp9_foo});
@@ -2305,12 +2305,12 @@
 
 TEST_F(VideoChannelSingleThreadTest,
        StopsPacketizationVerificationWhenMatchIsFoundInLocalAnswer) {
-  cricket::VideoCodec vp8_foo = cricket::CreateVideoCodec(96, "VP8");
+  cricket::Codec vp8_foo = cricket::CreateVideoCodec(96, "VP8");
   vp8_foo.packetization = "foo";
-  cricket::VideoCodec vp8_bar = cricket::CreateVideoCodec(97, "VP8");
+  cricket::Codec vp8_bar = cricket::CreateVideoCodec(97, "VP8");
   vp8_bar.packetization = "bar";
-  cricket::VideoCodec vp9 = cricket::CreateVideoCodec(98, "VP9");
-  cricket::VideoCodec vp9_foo = cricket::CreateVideoCodec(99, "VP9");
+  cricket::Codec vp9 = cricket::CreateVideoCodec(98, "VP9");
+  cricket::Codec vp9_foo = cricket::CreateVideoCodec(99, "VP9");
   vp9_foo.packetization = "bar";
   cricket::VideoContentDescription local;
   local.set_codecs({vp8_foo, vp9});
@@ -2341,8 +2341,8 @@
 
 TEST_F(VideoChannelSingleThreadTest,
        ConsidersAllCodecsWithDiffrentPacketizationsInRemoteAnswer) {
-  cricket::VideoCodec vp8 = cricket::CreateVideoCodec(96, "VP8");
-  cricket::VideoCodec vp8_raw = cricket::CreateVideoCodec(97, "VP8");
+  cricket::Codec vp8 = cricket::CreateVideoCodec(96, "VP8");
+  cricket::Codec vp8_raw = cricket::CreateVideoCodec(97, "VP8");
   vp8_raw.packetization = cricket::kPacketizationParamRaw;
   cricket::VideoContentDescription local;
   local.set_codecs({vp8, vp8_raw});
@@ -2373,8 +2373,8 @@
 
 TEST_F(VideoChannelSingleThreadTest,
        ConsidersAllCodecsWithDiffrentPacketizationsInLocalAnswer) {
-  cricket::VideoCodec vp8 = cricket::CreateVideoCodec(96, "VP8");
-  cricket::VideoCodec vp8_raw = cricket::CreateVideoCodec(97, "VP8");
+  cricket::Codec vp8 = cricket::CreateVideoCodec(96, "VP8");
+  cricket::Codec vp8_raw = cricket::CreateVideoCodec(97, "VP8");
   vp8_raw.packetization = cricket::kPacketizationParamRaw;
   cricket::VideoContentDescription local;
   local.set_codecs({vp8_raw, vp8});
diff --git a/pc/media_session.cc b/pc/media_session.cc
index a7352cc..86b785c 100644
--- a/pc/media_session.cc
+++ b/pc/media_session.cc
@@ -127,9 +127,9 @@
   return absl::EqualsIgnoreCase(codec.name, kComfortNoiseCodecName);
 }
 
-void StripCNCodecs(AudioCodecs* audio_codecs) {
+void StripCNCodecs(Codecs* audio_codecs) {
   audio_codecs->erase(std::remove_if(audio_codecs->begin(), audio_codecs->end(),
-                                     [](const AudioCodec& codec) {
+                                     [](const Codec& codec) {
                                        return IsComfortNoiseCodec(codec);
                                      }),
                       audio_codecs->end());
@@ -1160,7 +1160,7 @@
   return desc;
 }
 
-webrtc::RTCErrorOr<AudioCodecs> GetNegotiatedCodecsForOffer(
+webrtc::RTCErrorOr<Codecs> GetNegotiatedCodecsForOffer(
     const MediaDescriptionOptions& media_description_options,
     const MediaSessionOptions& session_options,
     const ContentInfo* current_content,
@@ -1237,7 +1237,7 @@
   return filtered_codecs;
 }
 
-webrtc::RTCErrorOr<AudioCodecs> GetNegotiatedCodecsForAnswer(
+webrtc::RTCErrorOr<Codecs> GetNegotiatedCodecsForAnswer(
     const MediaDescriptionOptions& media_description_options,
     const MediaSessionOptions& session_options,
     const ContentInfo* current_content,
@@ -1363,43 +1363,41 @@
   ComputeVideoCodecsIntersectionAndUnion();
 }
 
-const AudioCodecs& MediaSessionDescriptionFactory::audio_sendrecv_codecs()
-    const {
+const Codecs& MediaSessionDescriptionFactory::audio_sendrecv_codecs() const {
   return audio_sendrecv_codecs_;
 }
 
-const AudioCodecs& MediaSessionDescriptionFactory::audio_send_codecs() const {
+const Codecs& MediaSessionDescriptionFactory::audio_send_codecs() const {
   return audio_send_codecs_;
 }
 
-const AudioCodecs& MediaSessionDescriptionFactory::audio_recv_codecs() const {
+const Codecs& MediaSessionDescriptionFactory::audio_recv_codecs() const {
   return audio_recv_codecs_;
 }
 
 void MediaSessionDescriptionFactory::set_audio_codecs(
-    const AudioCodecs& send_codecs,
-    const AudioCodecs& recv_codecs) {
+    const Codecs& send_codecs,
+    const Codecs& recv_codecs) {
   audio_send_codecs_ = send_codecs;
   audio_recv_codecs_ = recv_codecs;
   ComputeAudioCodecsIntersectionAndUnion();
 }
 
-const VideoCodecs& MediaSessionDescriptionFactory::video_sendrecv_codecs()
-    const {
+const Codecs& MediaSessionDescriptionFactory::video_sendrecv_codecs() const {
   return video_sendrecv_codecs_;
 }
 
-const VideoCodecs& MediaSessionDescriptionFactory::video_send_codecs() const {
+const Codecs& MediaSessionDescriptionFactory::video_send_codecs() const {
   return video_send_codecs_;
 }
 
-const VideoCodecs& MediaSessionDescriptionFactory::video_recv_codecs() const {
+const Codecs& MediaSessionDescriptionFactory::video_recv_codecs() const {
   return video_recv_codecs_;
 }
 
 void MediaSessionDescriptionFactory::set_video_codecs(
-    const VideoCodecs& send_codecs,
-    const VideoCodecs& recv_codecs) {
+    const Codecs& send_codecs,
+    const Codecs& recv_codecs) {
   video_send_codecs_ = send_codecs;
   video_recv_codecs_ = recv_codecs;
   ComputeVideoCodecsIntersectionAndUnion();
@@ -1445,8 +1443,8 @@
   StreamParamsVec current_streams =
       GetCurrentStreamParams(current_active_contents);
 
-  AudioCodecs offer_audio_codecs;
-  VideoCodecs offer_video_codecs;
+  Codecs offer_audio_codecs;
+  Codecs offer_video_codecs;
   GetCodecsForOffer(current_active_contents, &offer_audio_codecs,
                     &offer_video_codecs);
   AudioVideoRtpHeaderExtensions extensions_with_ids =
@@ -1578,8 +1576,8 @@
   // Note that these lists may be further filtered for each m= section; this
   // step is done just to establish the payload type mappings shared by all
   // sections.
-  AudioCodecs answer_audio_codecs;
-  VideoCodecs answer_video_codecs;
+  Codecs answer_audio_codecs;
+  Codecs answer_video_codecs;
   GetCodecsForAnswer(current_active_contents, *offer, &answer_audio_codecs,
                      &answer_video_codecs);
 
@@ -1742,7 +1740,7 @@
   return answer;
 }
 
-const AudioCodecs& MediaSessionDescriptionFactory::GetAudioCodecsForOffer(
+const Codecs& MediaSessionDescriptionFactory::GetAudioCodecsForOffer(
     const RtpTransceiverDirection& direction) const {
   switch (direction) {
     // If stream is inactive - generate list as if sendrecv.
@@ -1758,7 +1756,7 @@
   RTC_CHECK_NOTREACHED();
 }
 
-const AudioCodecs& MediaSessionDescriptionFactory::GetAudioCodecsForAnswer(
+const Codecs& MediaSessionDescriptionFactory::GetAudioCodecsForAnswer(
     const RtpTransceiverDirection& offer,
     const RtpTransceiverDirection& answer) const {
   switch (answer) {
@@ -1777,7 +1775,7 @@
   RTC_CHECK_NOTREACHED();
 }
 
-const VideoCodecs& MediaSessionDescriptionFactory::GetVideoCodecsForOffer(
+const Codecs& MediaSessionDescriptionFactory::GetVideoCodecsForOffer(
     const RtpTransceiverDirection& direction) const {
   switch (direction) {
     // If stream is inactive - generate list as if sendrecv.
@@ -1793,7 +1791,7 @@
   RTC_CHECK_NOTREACHED();
 }
 
-const VideoCodecs& MediaSessionDescriptionFactory::GetVideoCodecsForAnswer(
+const Codecs& MediaSessionDescriptionFactory::GetVideoCodecsForAnswer(
     const RtpTransceiverDirection& offer,
     const RtpTransceiverDirection& answer) const {
   switch (answer) {
@@ -1814,8 +1812,8 @@
 
 void MergeCodecsFromDescription(
     const std::vector<const ContentInfo*>& current_active_contents,
-    AudioCodecs* audio_codecs,
-    VideoCodecs* video_codecs,
+    Codecs* audio_codecs,
+    Codecs* video_codecs,
     UsedPayloadTypes* used_pltypes) {
   for (const ContentInfo* content : current_active_contents) {
     if (IsMediaContentOfType(content, MEDIA_TYPE_AUDIO)) {
@@ -1836,8 +1834,8 @@
 //    on the directional attribute (happens in another method).
 void MediaSessionDescriptionFactory::GetCodecsForOffer(
     const std::vector<const ContentInfo*>& current_active_contents,
-    AudioCodecs* audio_codecs,
-    VideoCodecs* video_codecs) const {
+    Codecs* audio_codecs,
+    Codecs* video_codecs) const {
   // First - get all codecs from the current description if the media type
   // is used. Add them to `used_pltypes` so the payload type is not reused if a
   // new media type is added.
@@ -1860,8 +1858,8 @@
 void MediaSessionDescriptionFactory::GetCodecsForAnswer(
     const std::vector<const ContentInfo*>& current_active_contents,
     const SessionDescription& remote_offer,
-    AudioCodecs* audio_codecs,
-    VideoCodecs* video_codecs) const {
+    Codecs* audio_codecs,
+    Codecs* video_codecs) const {
   // First - get all codecs from the current description if the media type
   // is used. Add them to `used_pltypes` so the payload type is not reused if a
   // new media type is added.
@@ -1870,8 +1868,8 @@
                              video_codecs, &used_pltypes);
 
   // Second - filter out codecs that we don't support at all and should ignore.
-  AudioCodecs filtered_offered_audio_codecs;
-  VideoCodecs filtered_offered_video_codecs;
+  Codecs filtered_offered_audio_codecs;
+  Codecs filtered_offered_video_codecs;
   for (const ContentInfo& content : remote_offer.contents()) {
     if (IsMediaContentOfType(&content, MEDIA_TYPE_AUDIO)) {
       std::vector<Codec> offered_codecs = content.media_description()->codecs();
diff --git a/pc/media_session.h b/pc/media_session.h
index c9fbc4b..4e7bf67 100644
--- a/pc/media_session.h
+++ b/pc/media_session.h
@@ -148,16 +148,14 @@
                                  rtc::UniqueRandomIdGenerator* ssrc_generator,
                                  const TransportDescriptionFactory* factory);
 
-  const AudioCodecs& audio_sendrecv_codecs() const;
-  const AudioCodecs& audio_send_codecs() const;
-  const AudioCodecs& audio_recv_codecs() const;
-  void set_audio_codecs(const AudioCodecs& send_codecs,
-                        const AudioCodecs& recv_codecs);
-  const VideoCodecs& video_sendrecv_codecs() const;
-  const VideoCodecs& video_send_codecs() const;
-  const VideoCodecs& video_recv_codecs() const;
-  void set_video_codecs(const VideoCodecs& send_codecs,
-                        const VideoCodecs& recv_codecs);
+  const Codecs& audio_sendrecv_codecs() const;
+  const Codecs& audio_send_codecs() const;
+  const Codecs& audio_recv_codecs() const;
+  void set_audio_codecs(const Codecs& send_codecs, const Codecs& recv_codecs);
+  const Codecs& video_sendrecv_codecs() const;
+  const Codecs& video_send_codecs() const;
+  const Codecs& video_recv_codecs() const;
+  void set_video_codecs(const Codecs& send_codecs, const Codecs& recv_codecs);
   RtpHeaderExtensions filtered_rtp_header_extensions(
       RtpHeaderExtensions extensions) const;
 
@@ -183,25 +181,25 @@
     RtpHeaderExtensions video;
   };
 
-  const AudioCodecs& GetAudioCodecsForOffer(
+  const Codecs& GetAudioCodecsForOffer(
       const webrtc::RtpTransceiverDirection& direction) const;
-  const AudioCodecs& GetAudioCodecsForAnswer(
+  const Codecs& GetAudioCodecsForAnswer(
       const webrtc::RtpTransceiverDirection& offer,
       const webrtc::RtpTransceiverDirection& answer) const;
-  const VideoCodecs& GetVideoCodecsForOffer(
+  const Codecs& GetVideoCodecsForOffer(
       const webrtc::RtpTransceiverDirection& direction) const;
-  const VideoCodecs& GetVideoCodecsForAnswer(
+  const Codecs& GetVideoCodecsForAnswer(
       const webrtc::RtpTransceiverDirection& offer,
       const webrtc::RtpTransceiverDirection& answer) const;
   void GetCodecsForOffer(
       const std::vector<const ContentInfo*>& current_active_contents,
-      AudioCodecs* audio_codecs,
-      VideoCodecs* video_codecs) const;
+      Codecs* audio_codecs,
+      Codecs* video_codecs) const;
   void GetCodecsForAnswer(
       const std::vector<const ContentInfo*>& current_active_contents,
       const SessionDescription& remote_offer,
-      AudioCodecs* audio_codecs,
-      VideoCodecs* video_codecs) const;
+      Codecs* audio_codecs,
+      Codecs* video_codecs) const;
   AudioVideoRtpHeaderExtensions GetOfferedRtpHeaderExtensionsWithIds(
       const std::vector<const ContentInfo*>& current_active_contents,
       bool extmap_allow_mixed,
@@ -302,18 +300,18 @@
   }
 
   bool is_unified_plan_ = false;
-  AudioCodecs audio_send_codecs_;
-  AudioCodecs audio_recv_codecs_;
+  Codecs audio_send_codecs_;
+  Codecs audio_recv_codecs_;
   // Intersection of send and recv.
-  AudioCodecs audio_sendrecv_codecs_;
+  Codecs audio_sendrecv_codecs_;
   // Union of send and recv.
-  AudioCodecs all_audio_codecs_;
-  VideoCodecs video_send_codecs_;
-  VideoCodecs video_recv_codecs_;
+  Codecs all_audio_codecs_;
+  Codecs video_send_codecs_;
+  Codecs video_recv_codecs_;
   // Intersection of send and recv.
-  VideoCodecs video_sendrecv_codecs_;
+  Codecs video_sendrecv_codecs_;
   // Union of send and recv.
-  VideoCodecs all_video_codecs_;
+  Codecs all_video_codecs_;
   // This object may or may not be owned by this class.
   webrtc::AlwaysValidPointer<rtc::UniqueRandomIdGenerator> const
       ssrc_generator_;
diff --git a/pc/media_session_unittest.cc b/pc/media_session_unittest.cc
index d00ad1c..19f7898 100644
--- a/pc/media_session_unittest.cc
+++ b/pc/media_session_unittest.cc
@@ -78,42 +78,42 @@
 
 using Candidates = std::vector<Candidate>;
 
-AudioCodec CreateRedAudioCodec(absl::string_view encoding_id) {
-  AudioCodec red = CreateAudioCodec(63, "red", 48000, 2);
+Codec CreateRedAudioCodec(absl::string_view encoding_id) {
+  Codec red = CreateAudioCodec(63, "red", 48000, 2);
   red.SetParam(kCodecParamNotInNameValueFormat,
                std::string(encoding_id) + '/' + std::string(encoding_id));
   return red;
 }
 
-const AudioCodec kAudioCodecs1[] = {CreateAudioCodec(111, "opus", 48000, 2),
-                                    CreateRedAudioCodec("111"),
-                                    CreateAudioCodec(102, "iLBC", 8000, 1),
-                                    CreateAudioCodec(0, "PCMU", 8000, 1),
-                                    CreateAudioCodec(8, "PCMA", 8000, 1),
-                                    CreateAudioCodec(117, "red", 8000, 1),
-                                    CreateAudioCodec(107, "CN", 48000, 1)};
+const Codec kAudioCodecs1[] = {CreateAudioCodec(111, "opus", 48000, 2),
+                               CreateRedAudioCodec("111"),
+                               CreateAudioCodec(102, "iLBC", 8000, 1),
+                               CreateAudioCodec(0, "PCMU", 8000, 1),
+                               CreateAudioCodec(8, "PCMA", 8000, 1),
+                               CreateAudioCodec(117, "red", 8000, 1),
+                               CreateAudioCodec(107, "CN", 48000, 1)};
 
-const AudioCodec kAudioCodecs2[] = {
+const Codec kAudioCodecs2[] = {
     CreateAudioCodec(126, "foo", 16000, 1),
     CreateAudioCodec(0, "PCMU", 8000, 1),
     CreateAudioCodec(127, "iLBC", 8000, 1),
 };
 
-const AudioCodec kAudioCodecsAnswer[] = {
+const Codec kAudioCodecsAnswer[] = {
     CreateAudioCodec(102, "iLBC", 8000, 1),
     CreateAudioCodec(0, "PCMU", 8000, 1),
 };
 
-const VideoCodec kVideoCodecs1[] = {CreateVideoCodec(96, "H264-SVC"),
-                                    CreateVideoCodec(97, "H264")};
+const Codec kVideoCodecs1[] = {CreateVideoCodec(96, "H264-SVC"),
+                               CreateVideoCodec(97, "H264")};
 
-const VideoCodec kVideoCodecs1Reverse[] = {CreateVideoCodec(97, "H264"),
-                                           CreateVideoCodec(96, "H264-SVC")};
+const Codec kVideoCodecs1Reverse[] = {CreateVideoCodec(97, "H264"),
+                                      CreateVideoCodec(96, "H264-SVC")};
 
-const VideoCodec kVideoCodecs2[] = {CreateVideoCodec(126, "H264"),
-                                    CreateVideoCodec(127, "H263")};
+const Codec kVideoCodecs2[] = {CreateVideoCodec(126, "H264"),
+                               CreateVideoCodec(127, "H263")};
 
-const VideoCodec kVideoCodecsAnswer[] = {CreateVideoCodec(97, "H264")};
+const Codec kVideoCodecsAnswer[] = {CreateVideoCodec(97, "H264")};
 
 const RtpExtension kAudioRtpExtension1[] = {
     RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8),
@@ -264,7 +264,7 @@
   return content->media_description()->direction();
 }
 
-void AddRtxCodec(const VideoCodec& rtx_codec, std::vector<VideoCodec>* codecs) {
+void AddRtxCodec(const Codec& rtx_codec, std::vector<Codec>* codecs) {
   ASSERT_FALSE(FindCodecById(*codecs, rtx_codec.id));
   codecs->push_back(rtx_codec);
 }
@@ -744,8 +744,8 @@
 // RTP playlod type. The test verifies that the offer don't contain the
 // duplicate RTP payload types.
 TEST_F(MediaSessionDescriptionFactoryTest, TestBundleOfferWithSameCodecPlType) {
-  const VideoCodec& offered_video_codec = f2_.video_sendrecv_codecs()[0];
-  const AudioCodec& offered_audio_codec = f2_.audio_sendrecv_codecs()[0];
+  const Codec& offered_video_codec = f2_.video_sendrecv_codecs()[0];
+  const Codec& offered_audio_codec = f2_.audio_sendrecv_codecs()[0];
   ASSERT_EQ(offered_video_codec.id, offered_audio_codec.id);
 
   MediaSessionOptions opts;
@@ -2705,7 +2705,7 @@
   // preference order.
   // TODO(wu): `updated_offer` should not include the codec
   // (i.e. `kAudioCodecs2[0]`) the other side doesn't support.
-  const AudioCodec kUpdatedAudioCodecOffer[] = {
+  const Codec kUpdatedAudioCodecOffer[] = {
       kAudioCodecsAnswer[0],
       kAudioCodecsAnswer[1],
       kAudioCodecs2[0],
@@ -2714,7 +2714,7 @@
   // The expected video codecs are the common video codecs from the first
   // offer/answer exchange plus the video codecs only `f2_` offer, sorted in
   // preference order.
-  const VideoCodec kUpdatedVideoCodecOffer[] = {
+  const Codec kUpdatedVideoCodecOffer[] = {
       kVideoCodecsAnswer[0],
       kVideoCodecs2[1],
   };
@@ -2856,12 +2856,12 @@
   AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
                              RtpTransceiverDirection::kRecvOnly, kActive,
                              &opts);
-  std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+  std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates rtx for H264 with the payload type `f1_` uses.
   AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
   f1_.set_video_codecs(f1_codecs, f1_codecs);
 
-  std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+  std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates rtx for H264 with the payload type `f2_` uses.
   AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
   f2_.set_video_codecs(f2_codecs, f2_codecs);
@@ -2875,7 +2875,7 @@
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(answer.get());
 
-  std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
+  std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
   AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs);
 
   EXPECT_EQ(expected_codecs, vcd->codecs());
@@ -2909,22 +2909,21 @@
                              &opts);
   // We specifically choose different preferred payload types for VP8 to
   // trigger the issue.
-  VideoCodec vp8_offerer = CreateVideoCodec(100, "VP8");
-  VideoCodec vp8_offerer_rtx = CreateVideoRtxCodec(101, vp8_offerer.id);
-  VideoCodec vp8_answerer = CreateVideoCodec(110, "VP8");
-  VideoCodec vp8_answerer_rtx = CreateVideoRtxCodec(111, vp8_answerer.id);
-  VideoCodec vp9 = CreateVideoCodec(120, "VP9");
-  VideoCodec vp9_rtx = CreateVideoRtxCodec(121, vp9.id);
+  Codec vp8_offerer = CreateVideoCodec(100, "VP8");
+  Codec vp8_offerer_rtx = CreateVideoRtxCodec(101, vp8_offerer.id);
+  Codec vp8_answerer = CreateVideoCodec(110, "VP8");
+  Codec vp8_answerer_rtx = CreateVideoRtxCodec(111, vp8_answerer.id);
+  Codec vp9 = CreateVideoCodec(120, "VP9");
+  Codec vp9_rtx = CreateVideoRtxCodec(121, vp9.id);
 
-  std::vector<VideoCodec> f1_codecs = {vp8_offerer, vp8_offerer_rtx};
+  std::vector<Codec> f1_codecs = {vp8_offerer, vp8_offerer_rtx};
   // We also specifically cause the answerer to prefer VP9, such that if it
   // *doesn't* honor the existing preferred codec (VP8) we'll notice.
-  std::vector<VideoCodec> f2_codecs = {vp9, vp9_rtx, vp8_answerer,
-                                       vp8_answerer_rtx};
+  std::vector<Codec> f2_codecs = {vp9, vp9_rtx, vp8_answerer, vp8_answerer_rtx};
 
   f1_.set_video_codecs(f1_codecs, f1_codecs);
   f2_.set_video_codecs(f2_codecs, f2_codecs);
-  std::vector<AudioCodec> audio_codecs;
+  std::vector<Codec> audio_codecs;
   f1_.set_audio_codecs(audio_codecs, audio_codecs);
   f2_.set_audio_codecs(audio_codecs, audio_codecs);
 
@@ -2942,7 +2941,7 @@
 
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(updated_offer.get());
-  std::vector<VideoCodec> codecs = vcd->codecs();
+  std::vector<Codec> codecs = vcd->codecs();
   ASSERT_EQ(4u, codecs.size());
   EXPECT_EQ(vp8_offerer, codecs[0]);
   EXPECT_EQ(vp8_offerer_rtx, codecs[1]);
@@ -2956,7 +2955,7 @@
 // use, the added codecs payload types are changed.
 TEST_F(MediaSessionDescriptionFactoryTest,
        RespondentCreatesOfferWithVideoAndRtxAfterCreatingAudioAnswer) {
-  std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+  std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates rtx for H264 with the payload type `f1_` uses.
   AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
   f1_.set_video_codecs(f1_codecs, f1_codecs);
@@ -2981,7 +2980,7 @@
   opts.media_description_options.clear();
   AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
 
-  std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+  std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   int used_pl_type = acd->codecs()[0].id;
   f2_codecs[0].id = used_pl_type;  // Set the payload type for H264.
   AddRtxCodec(CreateVideoRtxCodec(125, used_pl_type), &f2_codecs);
@@ -3005,7 +3004,7 @@
   ASSERT_EQ(kRtxCodecName, updated_vcd->codecs()[1].name);
   int new_h264_pl_type = updated_vcd->codecs()[0].id;
   EXPECT_NE(used_pl_type, new_h264_pl_type);
-  VideoCodec rtx = updated_vcd->codecs()[1];
+  Codec rtx = updated_vcd->codecs()[1];
   int pt_referenced_by_rtx =
       rtc::FromString<int>(rtx.params[kCodecParamAssociatedPayloadType]);
   EXPECT_EQ(new_h264_pl_type, pt_referenced_by_rtx);
@@ -3019,7 +3018,7 @@
   MediaSessionOptions opts;
   AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
 
-  std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+  std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates rtx for H264 with the payload type `f2_` uses.
   AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
   f2_.set_video_codecs(f2_codecs, f2_codecs);
@@ -3033,7 +3032,7 @@
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(answer.get());
 
-  std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
+  std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
   EXPECT_EQ(expected_codecs, vcd->codecs());
 
   // Now, ensure that the RTX codec is created correctly when `f2_` creates an
@@ -3058,12 +3057,12 @@
   AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
                              RtpTransceiverDirection::kRecvOnly, kActive,
                              &opts);
-  std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+  std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates RTX without associated payload type parameter.
   AddRtxCodec(CreateVideoCodec(126, kRtxCodecName), &f1_codecs);
   f1_.set_video_codecs(f1_codecs, f1_codecs);
 
-  std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+  std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates RTX for H264 with the payload type `f2_` uses.
   AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
   f2_.set_video_codecs(f2_codecs, f2_codecs);
@@ -3101,12 +3100,12 @@
   AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
                              RtpTransceiverDirection::kRecvOnly, kActive,
                              &opts);
-  std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+  std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates RTX for H264 in sender.
   AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
   f1_.set_video_codecs(f1_codecs, f1_codecs);
 
-  std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+  std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates RTX for H263 in receiver.
   AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[1].id), &f2_codecs);
   f2_.set_video_codecs(f2_codecs, f2_codecs);
@@ -3132,7 +3131,7 @@
   AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
                              RtpTransceiverDirection::kRecvOnly, kActive,
                              &opts);
-  std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+  std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates RTX for H264-SVC in sender.
   AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[0].id), &f1_codecs);
   f1_.set_video_codecs(f1_codecs, f1_codecs);
@@ -3141,7 +3140,7 @@
   AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
   f1_.set_video_codecs(f1_codecs, f1_codecs);
 
-  std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+  std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates RTX for H264 in receiver.
   AddRtxCodec(CreateVideoRtxCodec(124, kVideoCodecs2[0].id), &f2_codecs);
   f2_.set_video_codecs(f2_codecs, f1_codecs);
@@ -3155,7 +3154,7 @@
       f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(answer.get());
-  std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
+  std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
   AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs);
 
   EXPECT_EQ(expected_codecs, vcd->codecs());
@@ -3168,7 +3167,7 @@
   AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
                              RtpTransceiverDirection::kRecvOnly, kActive,
                              &opts);
-  std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+  std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates RTX for H264 for the offerer.
   AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
   f1_.set_video_codecs(f1_codecs, f1_codecs);
@@ -3179,7 +3178,7 @@
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(offer.get());
 
-  std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecs1);
+  std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecs1);
   AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs);
   EXPECT_EQ(expected_codecs, vcd->codecs());
 
@@ -3208,7 +3207,7 @@
                                         {"stream1label"}, 3, &opts);
 
   // Use a single real codec, and then add RTX for it.
-  std::vector<VideoCodec> f1_codecs;
+  std::vector<Codec> f1_codecs;
   f1_codecs.push_back(CreateVideoCodec(97, "H264"));
   AddRtxCodec(CreateVideoRtxCodec(125, 97), &f1_codecs);
   f1_.set_video_codecs(f1_codecs, f1_codecs);
@@ -3252,7 +3251,7 @@
                                         {"stream1label"}, 1, &opts);
 
   // Use a single real codec, and then add FlexFEC for it.
-  std::vector<VideoCodec> f1_codecs;
+  std::vector<Codec> f1_codecs;
   f1_codecs.push_back(CreateVideoCodec(97, "H264"));
   f1_codecs.push_back(CreateVideoCodec(118, "flexfec-03"));
   f1_.set_video_codecs(f1_codecs, f1_codecs);
@@ -3295,7 +3294,7 @@
                                         {"stream1label"}, 3, &opts);
 
   // Use a single real codec, and then add FlexFEC for it.
-  std::vector<VideoCodec> f1_codecs;
+  std::vector<Codec> f1_codecs;
   f1_codecs.push_back(CreateVideoCodec(97, "H264"));
   f1_codecs.push_back(CreateVideoCodec(118, "flexfec-03"));
   f1_.set_video_codecs(f1_codecs, f1_codecs);
@@ -4276,10 +4275,10 @@
        H264MatchCriteriaIncludesPacketizationMode) {
   // Create two H264 codecs with the same profile level ID and different
   // packetization modes.
-  VideoCodec h264_pm0 = CreateVideoCodec(96, "H264");
+  Codec h264_pm0 = CreateVideoCodec(96, "H264");
   h264_pm0.params[kH264FmtpProfileLevelId] = "42c01f";
   h264_pm0.params[kH264FmtpPacketizationMode] = "0";
-  VideoCodec h264_pm1 = CreateVideoCodec(97, "H264");
+  Codec h264_pm1 = CreateVideoCodec(97, "H264");
   h264_pm1.params[kH264FmtpProfileLevelId] = "42c01f";
   h264_pm1.params[kH264FmtpPacketizationMode] = "1";
 
@@ -4380,17 +4379,16 @@
 
   UniqueRandomIdGenerator ssrc_generator;
   MediaSessionDescriptionFactory sf(nullptr, false, &ssrc_generator, &tdf);
-  std::vector<AudioCodec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
-  std::vector<AudioCodec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
+  std::vector<Codec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
+  std::vector<Codec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
 
   // The merged list of codecs should contain any send codecs that are also
   // nominally in the receive codecs list. Payload types should be picked from
   // the send codecs and a number-of-channels of 0 and 1 should be equivalent
   // (set to 1). This equals what happens when the send codecs are used in an
   // offer and the receive codecs are used in the following answer.
-  const std::vector<AudioCodec> sendrecv_codecs =
-      MAKE_VECTOR(kAudioCodecsAnswer);
-  const std::vector<AudioCodec> no_codecs;
+  const std::vector<Codec> sendrecv_codecs = MAKE_VECTOR(kAudioCodecsAnswer);
+  const std::vector<Codec> no_codecs;
 
   RTC_CHECK_EQ(send_codecs[2].name, "iLBC")
       << "Please don't change shared test data!";
@@ -4452,10 +4450,9 @@
 
   UniqueRandomIdGenerator ssrc_generator;
   MediaSessionDescriptionFactory sf(nullptr, false, &ssrc_generator, &tdf);
-  const std::vector<AudioCodec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
-  const std::vector<AudioCodec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
-  const std::vector<AudioCodec> sendrecv_codecs =
-      MAKE_VECTOR(kAudioCodecsAnswer);
+  const std::vector<Codec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
+  const std::vector<Codec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
+  const std::vector<Codec> sendrecv_codecs = MAKE_VECTOR(kAudioCodecsAnswer);
   sf.set_audio_codecs(send_codecs, recv_codecs);
 
   MediaSessionOptions opts;
@@ -4493,14 +4490,13 @@
   }
 }
 
-const AudioCodec kOfferAnswerCodecs[] = {
-    CreateAudioCodec(0, "codec0", 16000, 1),
-    CreateAudioCodec(1, "codec1", 8000, 1),
-    CreateAudioCodec(2, "codec2", 8000, 1),
-    CreateAudioCodec(3, "codec3", 8000, 1),
-    CreateAudioCodec(4, "codec4", 8000, 2),
-    CreateAudioCodec(5, "codec5", 32000, 1),
-    CreateAudioCodec(6, "codec6", 48000, 1)};
+const Codec kOfferAnswerCodecs[] = {CreateAudioCodec(0, "codec0", 16000, 1),
+                                    CreateAudioCodec(1, "codec1", 8000, 1),
+                                    CreateAudioCodec(2, "codec2", 8000, 1),
+                                    CreateAudioCodec(3, "codec3", 8000, 1),
+                                    CreateAudioCodec(4, "codec4", 8000, 2),
+                                    CreateAudioCodec(5, "codec5", 32000, 1),
+                                    CreateAudioCodec(6, "codec6", 48000, 1)};
 
 /* The codecs groups below are chosen as per the matrix below. The objective
  * is to have different sets of codecs in the inputs, to get unique sets of
@@ -4604,7 +4600,7 @@
     ASSERT_EQ(MEDIA_TYPE_AUDIO, ac->media_description()->type());
     const MediaContentDescription* acd = ac->media_description();
 
-    std::vector<AudioCodec> target_codecs;
+    std::vector<Codec> target_codecs;
     // For offers with sendrecv or inactive, we should never reply with more
     // codecs than offered, with these codec sets.
     switch (offer_direction) {
@@ -4637,7 +4633,7 @@
         RTC_DCHECK_NOTREACHED();
     }
 
-    auto format_codecs = [](const std::vector<AudioCodec>& codecs) {
+    auto format_codecs = [](const std::vector<Codec>& codecs) {
       rtc::StringBuilder os;
       bool first = true;
       os << "{";
diff --git a/pc/peer_connection.cc b/pc/peer_connection.cc
index 444a0bf..44fae13 100644
--- a/pc/peer_connection.cc
+++ b/pc/peer_connection.cc
@@ -1141,7 +1141,7 @@
         "Attempted to set an unimplemented parameter of RtpParameters.");
   }
 
-  std::vector<cricket::VideoCodec> codecs;
+  std::vector<cricket::Codec> codecs;
   // Gather the current codec capabilities to allow checking scalabilityMode and
   // codec selection against supported values.
   if (media_type == cricket::MEDIA_TYPE_VIDEO) {
diff --git a/pc/peer_connection_factory.cc b/pc/peer_connection_factory.cc
index 92fdfc8..e62a680 100644
--- a/pc/peer_connection_factory.cc
+++ b/pc/peer_connection_factory.cc
@@ -134,14 +134,14 @@
   RTC_DCHECK_RUN_ON(signaling_thread());
   switch (kind) {
     case cricket::MEDIA_TYPE_AUDIO: {
-      cricket::AudioCodecs cricket_codecs;
+      cricket::Codecs cricket_codecs;
       cricket_codecs = media_engine()->voice().send_codecs();
       auto extensions =
           GetDefaultEnabledRtpHeaderExtensions(media_engine()->voice());
       return ToRtpCapabilities(cricket_codecs, extensions);
     }
     case cricket::MEDIA_TYPE_VIDEO: {
-      cricket::VideoCodecs cricket_codecs;
+      cricket::Codecs cricket_codecs;
       cricket_codecs = media_engine()->video().send_codecs(context_->use_rtx());
       auto extensions =
           GetDefaultEnabledRtpHeaderExtensions(media_engine()->video());
@@ -161,14 +161,14 @@
   RTC_DCHECK_RUN_ON(signaling_thread());
   switch (kind) {
     case cricket::MEDIA_TYPE_AUDIO: {
-      cricket::AudioCodecs cricket_codecs;
+      cricket::Codecs cricket_codecs;
       cricket_codecs = media_engine()->voice().recv_codecs();
       auto extensions =
           GetDefaultEnabledRtpHeaderExtensions(media_engine()->voice());
       return ToRtpCapabilities(cricket_codecs, extensions);
     }
     case cricket::MEDIA_TYPE_VIDEO: {
-      cricket::VideoCodecs cricket_codecs =
+      cricket::Codecs cricket_codecs =
           media_engine()->video().recv_codecs(context_->use_rtx());
       auto extensions =
           GetDefaultEnabledRtpHeaderExtensions(media_engine()->video());
diff --git a/pc/peer_connection_integrationtest.cc b/pc/peer_connection_integrationtest.cc
index 24ca52f..0e4e52b 100644
--- a/pc/peer_connection_integrationtest.cc
+++ b/pc/peer_connection_integrationtest.cc
@@ -2573,7 +2573,7 @@
     ASSERT_NE(nullptr, audio);
     auto audio_codecs = audio->codecs();
     audio_codecs.erase(std::remove_if(audio_codecs.begin(), audio_codecs.end(),
-                                      [](const cricket::AudioCodec& codec) {
+                                      [](const cricket::Codec& codec) {
                                         return codec.name != "opus";
                                       }),
                        audio_codecs.end());
@@ -2586,7 +2586,7 @@
     ASSERT_NE(nullptr, video);
     auto video_codecs = video->codecs();
     video_codecs.erase(std::remove_if(video_codecs.begin(), video_codecs.end(),
-                                      [](const cricket::VideoCodec& codec) {
+                                      [](const cricket::Codec& codec) {
                                         return codec.name != "VP8";
                                       }),
                        video_codecs.end());
diff --git a/pc/peer_connection_media_unittest.cc b/pc/peer_connection_media_unittest.cc
index e114e5d..97faae5 100644
--- a/pc/peer_connection_media_unittest.cc
+++ b/pc/peer_connection_media_unittest.cc
@@ -599,7 +599,7 @@
 
 // Test that raw packetization is not set in the offer by default.
 TEST_P(PeerConnectionMediaTest, RawPacketizationNotSetInOffer) {
-  std::vector<cricket::VideoCodec> fake_codecs;
+  std::vector<cricket::Codec> fake_codecs;
   fake_codecs.push_back(cricket::CreateVideoCodec(111, cricket::kVp8CodecName));
   fake_codecs.push_back(cricket::CreateVideoRtxCodec(112, 111));
   fake_codecs.push_back(cricket::CreateVideoCodec(113, cricket::kVp9CodecName));
@@ -621,7 +621,7 @@
 // Test that raw packetization is set in the offer and answer for all
 // video payload when raw_packetization_for_video is true.
 TEST_P(PeerConnectionMediaTest, RawPacketizationSetInOfferAndAnswer) {
-  std::vector<cricket::VideoCodec> fake_codecs;
+  std::vector<cricket::Codec> fake_codecs;
   fake_codecs.push_back(cricket::CreateVideoCodec(111, cricket::kVp8CodecName));
   fake_codecs.push_back(cricket::CreateVideoRtxCodec(112, 111));
   fake_codecs.push_back(cricket::CreateVideoCodec(113, cricket::kVp9CodecName));
@@ -664,7 +664,7 @@
 // raw_packetization_for_video is true if it was not set in the offer.
 TEST_P(PeerConnectionMediaTest,
        RawPacketizationNotSetInAnswerWhenNotSetInOffer) {
-  std::vector<cricket::VideoCodec> fake_codecs;
+  std::vector<cricket::Codec> fake_codecs;
   fake_codecs.push_back(cricket::CreateVideoCodec(111, cricket::kVp8CodecName));
   fake_codecs.push_back(cricket::CreateVideoRtxCodec(112, 111));
   fake_codecs.push_back(cricket::CreateVideoCodec(113, cricket::kVp9CodecName));
@@ -906,9 +906,9 @@
 }
 
 void AddComfortNoiseCodecsToSend(cricket::FakeMediaEngine* media_engine) {
-  const cricket::AudioCodec kComfortNoiseCodec8k =
+  const cricket::Codec kComfortNoiseCodec8k =
       cricket::CreateAudioCodec(102, cricket::kCnCodecName, 8000, 1);
-  const cricket::AudioCodec kComfortNoiseCodec16k =
+  const cricket::Codec kComfortNoiseCodec16k =
       cricket::CreateAudioCodec(103, cricket::kCnCodecName, 16000, 1);
 
   auto codecs = media_engine->voice().send_codecs();
@@ -1246,13 +1246,13 @@
 // endpoint selected a different payload type or there was a conflict), the RED
 // fmtp line is modified to refer to the correct payload type.
 TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeReassigned) {
-  std::vector<cricket::AudioCodec> caller_fake_codecs;
+  std::vector<cricket::Codec> caller_fake_codecs;
   caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
   auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
   caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
   auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
 
-  std::vector<cricket::AudioCodec> callee_fake_codecs;
+  std::vector<cricket::Codec> callee_fake_codecs;
   callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
   callee_fake_codecs.push_back(
       cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
@@ -1289,7 +1289,7 @@
 
 // Test that RED without fmtp does match RED without fmtp.
 TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeNoFmtpMatchNoFmtp) {
-  std::vector<cricket::AudioCodec> caller_fake_codecs;
+  std::vector<cricket::Codec> caller_fake_codecs;
   caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
   caller_fake_codecs.push_back(
       cricket::CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
@@ -1297,7 +1297,7 @@
   caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
   auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
 
-  std::vector<cricket::AudioCodec> callee_fake_codecs;
+  std::vector<cricket::Codec> callee_fake_codecs;
   callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
   callee_fake_codecs.push_back(
       cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
@@ -1331,7 +1331,7 @@
 
 // Test that RED without fmtp does not match RED with fmtp.
 TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeNoFmtpNoMatchFmtp) {
-  std::vector<cricket::AudioCodec> caller_fake_codecs;
+  std::vector<cricket::Codec> caller_fake_codecs;
   caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
   caller_fake_codecs.push_back(
       cricket::CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
@@ -1339,7 +1339,7 @@
   caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
   auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
 
-  std::vector<cricket::AudioCodec> callee_fake_codecs;
+  std::vector<cricket::Codec> callee_fake_codecs;
   callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
   callee_fake_codecs.push_back(
       cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
@@ -1378,7 +1378,7 @@
 
 // Test that RED with fmtp must match base codecs.
 TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeMustMatchBaseCodecs) {
-  std::vector<cricket::AudioCodec> caller_fake_codecs;
+  std::vector<cricket::Codec> caller_fake_codecs;
   caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
   caller_fake_codecs.push_back(
       cricket::CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
@@ -1388,7 +1388,7 @@
   caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
   auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
 
-  std::vector<cricket::AudioCodec> callee_fake_codecs;
+  std::vector<cricket::Codec> callee_fake_codecs;
   callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
   callee_fake_codecs.push_back(
       cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
@@ -1412,7 +1412,7 @@
 // Test behaviour when the RED fmtp attempts to specify different codecs
 // which is not supported.
 TEST_P(PeerConnectionMediaTest, RedFmtpPayloadMixed) {
-  std::vector<cricket::AudioCodec> caller_fake_codecs;
+  std::vector<cricket::Codec> caller_fake_codecs;
   caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
   caller_fake_codecs.push_back(cricket::CreateAudioCodec(102, "bar", 0, 1));
   caller_fake_codecs.push_back(
@@ -1423,7 +1423,7 @@
   caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
   auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
 
-  std::vector<cricket::AudioCodec> callee_fake_codecs;
+  std::vector<cricket::Codec> callee_fake_codecs;
   callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
   callee_fake_codecs.push_back(
       cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
@@ -1446,7 +1446,7 @@
 // Test behaviour when the RED fmtp attempts to negotiate different levels of
 // redundancy.
 TEST_P(PeerConnectionMediaTest, RedFmtpPayloadDifferentRedundancy) {
-  std::vector<cricket::AudioCodec> caller_fake_codecs;
+  std::vector<cricket::Codec> caller_fake_codecs;
   caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
   caller_fake_codecs.push_back(
       cricket::CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
@@ -1456,7 +1456,7 @@
   caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
   auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
 
-  std::vector<cricket::AudioCodec> callee_fake_codecs;
+  std::vector<cricket::Codec> callee_fake_codecs;
   callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
   callee_fake_codecs.push_back(
       cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
@@ -2004,12 +2004,12 @@
        SetCodecPreferencesAvoidsPayloadTypeConflictInOffer) {
   auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
 
-  std::vector<cricket::AudioCodec> audio_codecs;
+  std::vector<cricket::Codec> audio_codecs;
   audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
   audio_codecs.emplace_back(cricket::CreateAudioRtxCodec(101, 100));
   fake_engine->SetAudioCodecs(audio_codecs);
 
-  std::vector<cricket::VideoCodec> video_codecs;
+  std::vector<cricket::Codec> video_codecs;
   video_codecs.emplace_back(cricket::CreateVideoCodec(100, "bar"));
   video_codecs.emplace_back(cricket::CreateVideoRtxCodec(101, 100));
   fake_engine->SetVideoCodecs(video_codecs);
@@ -2045,12 +2045,12 @@
        SetCodecPreferencesAvoidsPayloadTypeConflictInAnswer) {
   auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
 
-  std::vector<cricket::AudioCodec> audio_codecs;
+  std::vector<cricket::Codec> audio_codecs;
   audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
   audio_codecs.emplace_back(cricket::CreateAudioRtxCodec(101, 100));
   fake_engine->SetAudioCodecs(audio_codecs);
 
-  std::vector<cricket::VideoCodec> video_codecs;
+  std::vector<cricket::Codec> video_codecs;
   video_codecs.emplace_back(cricket::CreateVideoCodec(100, "bar"));
   video_codecs.emplace_back(cricket::CreateVideoRtxCodec(101, 100));
   fake_engine->SetVideoCodecs(video_codecs);
@@ -2090,12 +2090,12 @@
        SetCodecPreferencesAvoidsPayloadTypeConflictInSubsequentOffer) {
   auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
 
-  std::vector<cricket::AudioCodec> audio_codecs;
+  std::vector<cricket::Codec> audio_codecs;
   audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
   audio_codecs.emplace_back(cricket::CreateAudioRtxCodec(101, 100));
   fake_engine->SetAudioCodecs(audio_codecs);
 
-  std::vector<cricket::VideoCodec> video_codecs;
+  std::vector<cricket::Codec> video_codecs;
   video_codecs.emplace_back(cricket::CreateVideoCodec(100, "bar"));
   video_codecs.emplace_back(cricket::CreateVideoRtxCodec(101, 100));
   fake_engine->SetVideoCodecs(video_codecs);
@@ -2136,7 +2136,7 @@
        SetCodecPreferencesReceiveOnlyWithSendOnlyTransceiverStops) {
   auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
 
-  std::vector<cricket::AudioCodec> audio_codecs;
+  std::vector<cricket::Codec> audio_codecs;
   audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
   fake_engine->SetAudioRecvCodecs(audio_codecs);
 
diff --git a/pc/rtp_parameters_conversion_unittest.cc b/pc/rtp_parameters_conversion_unittest.cc
index 9b48bfa..0c68b0a 100644
--- a/pc/rtp_parameters_conversion_unittest.cc
+++ b/pc/rtp_parameters_conversion_unittest.cc
@@ -397,8 +397,7 @@
 }
 
 TEST(RtpParametersConversionTest, ToAudioRtpCodecCapability) {
-  cricket::AudioCodec cricket_codec =
-      cricket::CreateAudioCodec(50, "foo", 22222, 4);
+  cricket::Codec cricket_codec = cricket::CreateAudioCodec(50, "foo", 22222, 4);
   cricket_codec.params["foo"] = "bar";
   cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc"));
   RtpCodecCapability codec = ToRtpCodecCapability(cricket_codec);
@@ -416,7 +415,7 @@
 }
 
 TEST(RtpParametersConversionTest, ToVideoRtpCodecCapability) {
-  cricket::VideoCodec cricket_codec = cricket::CreateVideoCodec(101, "VID");
+  cricket::Codec cricket_codec = cricket::CreateVideoCodec(101, "VID");
   cricket_codec.clockrate = 80000;
   cricket_codec.params["foo"] = "bar";
   cricket_codec.params["ANOTHER"] = "param";
@@ -464,8 +463,7 @@
 }
 
 TEST(RtpParametersConversionTest, ToAudioRtpCodecParameters) {
-  cricket::AudioCodec cricket_codec =
-      cricket::CreateAudioCodec(50, "foo", 22222, 4);
+  cricket::Codec cricket_codec = cricket::CreateAudioCodec(50, "foo", 22222, 4);
   cricket_codec.params["foo"] = "bar";
   cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc"));
   RtpCodecParameters codec = ToRtpCodecParameters(cricket_codec);
@@ -483,7 +481,7 @@
 }
 
 TEST(RtpParametersConversionTest, ToVideoRtpCodecParameters) {
-  cricket::VideoCodec cricket_codec = cricket::CreateVideoCodec(101, "VID");
+  cricket::Codec cricket_codec = cricket::CreateVideoCodec(101, "VID");
   cricket_codec.clockrate = 80000;
   cricket_codec.params["foo"] = "bar";
   cricket_codec.params["ANOTHER"] = "param";
@@ -509,8 +507,7 @@
 
 // An unknown feedback param should just be ignored.
 TEST(RtpParametersConversionTest, ToRtpCodecCapabilityUnknownFeedbackParam) {
-  cricket::AudioCodec cricket_codec =
-      cricket::CreateAudioCodec(50, "foo", 22222, 4);
+  cricket::Codec cricket_codec = cricket::CreateAudioCodec(50, "foo", 22222, 4);
   cricket_codec.params["foo"] = "bar";
   cricket_codec.feedback_params.Add({"unknown", "param"});
   cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc"));
@@ -525,21 +522,21 @@
 // test that the result of ToRtpCodecCapability ends up in the result, and that
 // the "fec" list is assembled correctly.
 TEST(RtpParametersConversionTest, ToRtpCapabilities) {
-  cricket::VideoCodec vp8 = cricket::CreateVideoCodec(101, "VP8");
+  cricket::Codec vp8 = cricket::CreateVideoCodec(101, "VP8");
   vp8.clockrate = 90000;
 
-  cricket::VideoCodec red = cricket::CreateVideoCodec(102, "red");
+  cricket::Codec red = cricket::CreateVideoCodec(102, "red");
   red.clockrate = 90000;
 
-  cricket::VideoCodec ulpfec = cricket::CreateVideoCodec(103, "ulpfec");
+  cricket::Codec ulpfec = cricket::CreateVideoCodec(103, "ulpfec");
   ulpfec.clockrate = 90000;
 
-  cricket::VideoCodec flexfec = cricket::CreateVideoCodec(102, "flexfec-03");
+  cricket::Codec flexfec = cricket::CreateVideoCodec(102, "flexfec-03");
   flexfec.clockrate = 90000;
 
-  cricket::VideoCodec rtx = cricket::CreateVideoRtxCodec(014, 101);
+  cricket::Codec rtx = cricket::CreateVideoRtxCodec(014, 101);
 
-  cricket::VideoCodec rtx2 = cricket::CreateVideoRtxCodec(105, 109);
+  cricket::Codec rtx2 = cricket::CreateVideoRtxCodec(105, 109);
 
   RtpCapabilities capabilities =
       ToRtpCapabilities({vp8, ulpfec, rtx, rtx2}, {{"uri", 1}, {"uri2", 3}});
@@ -570,13 +567,13 @@
 }
 
 TEST(RtpParametersConversionTest, ToRtpParameters) {
-  cricket::VideoCodec vp8 = cricket::CreateVideoCodec(101, "VP8");
+  cricket::Codec vp8 = cricket::CreateVideoCodec(101, "VP8");
   vp8.clockrate = 90000;
 
-  cricket::VideoCodec red = cricket::CreateVideoCodec(102, "red");
+  cricket::Codec red = cricket::CreateVideoCodec(102, "red");
   red.clockrate = 90000;
 
-  cricket::VideoCodec ulpfec = cricket::CreateVideoCodec(103, "ulpfec");
+  cricket::Codec ulpfec = cricket::CreateVideoCodec(103, "ulpfec");
   ulpfec.clockrate = 90000;
 
   cricket::StreamParamsVec streams;
diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc
index 259b2d2..c6c342e 100644
--- a/pc/rtp_sender_receiver_unittest.cc
+++ b/pc/rtp_sender_receiver_unittest.cc
@@ -174,7 +174,7 @@
   // Needed to use DTMF sender.
   void AddDtmfCodec() {
     cricket::AudioSenderParameter params;
-    const cricket::AudioCodec kTelephoneEventCodec =
+    const cricket::Codec kTelephoneEventCodec =
         cricket::CreateAudioCodec(106, "telephone-event", 8000, 1);
     params.codecs.push_back(kTelephoneEventCodec);
     voice_media_send_channel()->SetSenderParameters(params);
diff --git a/pc/test/mock_rtp_sender_internal.h b/pc/test/mock_rtp_sender_internal.h
index bb7776b..925e9ec 100644
--- a/pc/test/mock_rtp_sender_internal.h
+++ b/pc/test/mock_rtp_sender_internal.h
@@ -68,10 +68,7 @@
               CheckCodecParameters,
               (const RtpParameters&),
               (override));
-  MOCK_METHOD(void,
-              SetSendCodecs,
-              (std::vector<cricket::VideoCodec>),
-              (override));
+  MOCK_METHOD(void, SetSendCodecs, (std::vector<cricket::Codec>), (override));
   MOCK_METHOD(rtc::scoped_refptr<DtmfSenderInterface>,
               GetDtmfSender,
               (),
diff --git a/pc/webrtc_sdp.cc b/pc/webrtc_sdp.cc
index b6cea4d..8def097 100644
--- a/pc/webrtc_sdp.cc
+++ b/pc/webrtc_sdp.cc
@@ -3633,7 +3633,7 @@
   }
 
   if (media_type == cricket::MEDIA_TYPE_VIDEO) {
-    for (const cricket::VideoCodec& existing_codec : media_desc->codecs()) {
+    for (const cricket::Codec& existing_codec : media_desc->codecs()) {
       if (!existing_codec.name.empty() && payload_type == existing_codec.id &&
           (!absl::EqualsIgnoreCase(encoding_name, existing_codec.name) ||
            clock_rate != existing_codec.clockrate)) {
@@ -3664,7 +3664,7 @@
       return ParseFailed(line, "At most 24 channels are supported.", error);
     }
 
-    for (const cricket::AudioCodec& existing_codec : media_desc->codecs()) {
+    for (const cricket::Codec& existing_codec : media_desc->codecs()) {
       // TODO(crbug.com/1338902) re-add checks for clockrate and number of
       // channels.
       if (!existing_codec.name.empty() && payload_type == existing_codec.id &&
diff --git a/pc/webrtc_sdp_unittest.cc b/pc/webrtc_sdp_unittest.cc
index afa2304..f71b303 100644
--- a/pc/webrtc_sdp_unittest.cc
+++ b/pc/webrtc_sdp_unittest.cc
@@ -1880,15 +1880,15 @@
         GetFirstVideoContentDescription(jdesc_output->description());
     ASSERT_TRUE(vcd);
     ASSERT_FALSE(vcd->codecs().empty());
-    cricket::VideoCodec vp8 = vcd->codecs()[0];
+    cricket::Codec vp8 = vcd->codecs()[0];
     EXPECT_EQ("VP8", vp8.name);
     EXPECT_EQ(99, vp8.id);
-    cricket::VideoCodec rtx = vcd->codecs()[1];
+    cricket::Codec rtx = vcd->codecs()[1];
     EXPECT_EQ("RTX", rtx.name);
     EXPECT_EQ(95, rtx.id);
     VerifyCodecParameter(rtx.params, "apt", vp8.id);
     // VP9 is listed last in the m= line so should come after VP8 and RTX.
-    cricket::VideoCodec vp9 = vcd->codecs()[2];
+    cricket::Codec vp9 = vcd->codecs()[2];
     EXPECT_EQ("VP9", vp9.name);
     EXPECT_EQ(96, vp9.id);
   }
@@ -1935,7 +1935,7 @@
         GetFirstVideoContentDescription(jdesc_output->description());
     ASSERT_TRUE(vcd);
     ASSERT_FALSE(vcd->codecs().empty());
-    cricket::VideoCodec vp8 = vcd->codecs()[0];
+    cricket::Codec vp8 = vcd->codecs()[0];
     EXPECT_EQ(vp8.name, "VP8");
     EXPECT_EQ(101, vp8.id);
     EXPECT_TRUE(vp8.HasFeedbackParam(cricket::FeedbackParam(
@@ -2280,7 +2280,7 @@
 }
 
 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithH264) {
-  cricket::VideoCodec h264_codec = cricket::CreateVideoCodec("H264");
+  cricket::Codec h264_codec = cricket::CreateVideoCodec("H264");
   h264_codec.SetParam("profile-level-id", "42e01f");
   h264_codec.SetParam("level-asymmetry-allowed", "1");
   h264_codec.SetParam("packetization-mode", "1");
@@ -2368,7 +2368,7 @@
   EXPECT_TRUE(SdpDeserialize(kSdpNoRtpmapString, &jdesc));
   cricket::AudioContentDescription* audio =
       cricket::GetFirstAudioContentDescription(jdesc.description());
-  cricket::AudioCodecs ref_codecs;
+  cricket::Codecs ref_codecs;
   // The codecs in the AudioContentDescription should be in the same order as
   // the payload types (<fmt>s) on the m= line.
   ref_codecs.push_back(cricket::CreateAudioCodec(0, "PCMU", 8000, 1));
@@ -3232,7 +3232,7 @@
       GetFirstVideoContentDescription(jdesc_output.description());
   ASSERT_TRUE(vcd);
   ASSERT_FALSE(vcd->codecs().empty());
-  cricket::VideoCodec vp8 = vcd->codecs()[0];
+  cricket::Codec vp8 = vcd->codecs()[0];
   EXPECT_EQ("VP8", vp8.name);
   EXPECT_EQ(120, vp8.id);
   webrtc::CodecParameterMap::iterator found =
@@ -3266,7 +3266,7 @@
       GetFirstVideoContentDescription(jdesc_output.description());
   ASSERT_TRUE(vcd);
   ASSERT_FALSE(vcd->codecs().empty());
-  cricket::VideoCodec h264 = vcd->codecs()[0];
+  cricket::Codec h264 = vcd->codecs()[0];
   EXPECT_EQ("H264", h264.name);
   EXPECT_EQ(98, h264.id);
   webrtc::CodecParameterMap::const_iterator found =
@@ -3299,7 +3299,7 @@
       GetFirstVideoContentDescription(jdesc_output.description());
   ASSERT_TRUE(vcd);
   ASSERT_FALSE(vcd->codecs().empty());
-  cricket::VideoCodec vp8 = vcd->codecs()[0];
+  cricket::Codec vp8 = vcd->codecs()[0];
   EXPECT_EQ("VP8", vp8.name);
   EXPECT_EQ(120, vp8.id);
   webrtc::CodecParameterMap::iterator found =
@@ -3345,15 +3345,15 @@
       GetFirstVideoContentDescription(jdesc_output.description());
   ASSERT_TRUE(vcd);
   ASSERT_THAT(vcd->codecs(), testing::SizeIs(3));
-  cricket::VideoCodec vp8 = vcd->codecs()[0];
+  cricket::Codec vp8 = vcd->codecs()[0];
   EXPECT_EQ(vp8.name, "VP8");
   EXPECT_EQ(vp8.id, 120);
   EXPECT_EQ(vp8.packetization, "raw");
-  cricket::VideoCodec vp9 = vcd->codecs()[1];
+  cricket::Codec vp9 = vcd->codecs()[1];
   EXPECT_EQ(vp9.name, "VP9");
   EXPECT_EQ(vp9.id, 121);
   EXPECT_EQ(vp9.packetization, absl::nullopt);
-  cricket::VideoCodec h264 = vcd->codecs()[2];
+  cricket::Codec h264 = vcd->codecs()[2];
   EXPECT_EQ(h264.name, "H264");
   EXPECT_EQ(h264.id, 122);
   EXPECT_EQ(h264.packetization, absl::nullopt);
@@ -3362,7 +3362,7 @@
 TEST_F(WebRtcSdpTest, SerializeAudioFmtpWithUnknownParameter) {
   AudioContentDescription* acd = GetFirstAudioContentDescription(&desc_);
 
-  cricket::AudioCodecs codecs = acd->codecs();
+  cricket::Codecs codecs = acd->codecs();
   codecs[0].params["unknown-future-parameter"] = "SomeFutureValue";
   acd->set_codecs(codecs);
 
@@ -3379,7 +3379,7 @@
 TEST_F(WebRtcSdpTest, SerializeAudioFmtpWithKnownFmtpParameter) {
   AudioContentDescription* acd = GetFirstAudioContentDescription(&desc_);
 
-  cricket::AudioCodecs codecs = acd->codecs();
+  cricket::Codecs codecs = acd->codecs();
   codecs[0].params["stereo"] = "1";
   acd->set_codecs(codecs);
 
@@ -3395,7 +3395,7 @@
 TEST_F(WebRtcSdpTest, SerializeAudioFmtpWithPTimeAndMaxPTime) {
   AudioContentDescription* acd = GetFirstAudioContentDescription(&desc_);
 
-  cricket::AudioCodecs codecs = acd->codecs();
+  cricket::Codecs codecs = acd->codecs();
   codecs[0].params["ptime"] = "20";
   codecs[0].params["maxptime"] = "120";
   acd->set_codecs(codecs);
@@ -3414,7 +3414,7 @@
 TEST_F(WebRtcSdpTest, SerializeAudioFmtpWithTelephoneEvent) {
   AudioContentDescription* acd = GetFirstAudioContentDescription(&desc_);
 
-  cricket::AudioCodecs codecs = acd->codecs();
+  cricket::Codecs codecs = acd->codecs();
   cricket::Codec dtmf =
       cricket::CreateAudioCodec(105, "telephone-event", 8000, 1);
   dtmf.params[""] = "0-15";
@@ -3437,7 +3437,7 @@
 TEST_F(WebRtcSdpTest, SerializeVideoFmtp) {
   VideoContentDescription* vcd = GetFirstVideoContentDescription(&desc_);
 
-  cricket::VideoCodecs codecs = vcd->codecs();
+  cricket::Codecs codecs = vcd->codecs();
   codecs[0].params["x-google-min-bitrate"] = "10";
   vcd->set_codecs(codecs);
 
@@ -3453,7 +3453,7 @@
 TEST_F(WebRtcSdpTest, SerializeVideoPacketizationAttribute) {
   VideoContentDescription* vcd = GetFirstVideoContentDescription(&desc_);
 
-  cricket::VideoCodecs codecs = vcd->codecs();
+  cricket::Codecs codecs = vcd->codecs();
   codecs[0].packetization = "raw";
   vcd->set_codecs(codecs);