diff --git a/modules/rtp_rtcp/include/rtp_header_extension_map.h b/modules/rtp_rtcp/include/rtp_header_extension_map.h
index b8f27a1312..8ee97eff90 100644
--- a/modules/rtp_rtcp/include/rtp_header_extension_map.h
+++ b/modules/rtp_rtcp/include/rtp_header_extension_map.h
@@ -26,6 +26,7 @@ class RtpHeaderExtensionMap {
   static constexpr int kInvalidId = 0;
 
   RtpHeaderExtensionMap();
+  explicit RtpHeaderExtensionMap(bool extmap_allow_mixed);
   explicit RtpHeaderExtensionMap(rtc::ArrayView<const RtpExtension> extensions);
 
   template <typename Extension>
@@ -53,18 +54,16 @@ class RtpHeaderExtensionMap {
   }
   int32_t Deregister(RTPExtensionType type);
 
-  bool IsMixedOneTwoByteHeaderSupported() const {
-    return mixed_one_two_byte_header_supported_;
-  }
-  void SetMixedOneTwoByteHeaderSupported(bool supported) {
-    mixed_one_two_byte_header_supported_ = supported;
-  }
+  // Corresponds to the SDP attribute extmap-allow-mixed, see RFC8285.
+  // Set to true if it's allowed to mix one- and two-byte RTP header extensions
+  // in the same stream.
+  bool ExtmapAllowMixed() const { return extmap_allow_mixed_; }
 
  private:
   bool Register(int id, RTPExtensionType type, const char* uri);
 
   uint8_t ids_[kRtpExtensionNumberOfExtensions];
-  bool mixed_one_two_byte_header_supported_;
+  bool extmap_allow_mixed_;
 };
 
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_header_extension_map.cc b/modules/rtp_rtcp/source/rtp_header_extension_map.cc
index 168665afc4..dde25e324e 100644
--- a/modules/rtp_rtcp/source/rtp_header_extension_map.cc
+++ b/modules/rtp_rtcp/source/rtp_header_extension_map.cc
@@ -56,15 +56,17 @@ static_assert(arraysize(kExtensions) ==
 constexpr RTPExtensionType RtpHeaderExtensionMap::kInvalidType;
 constexpr int RtpHeaderExtensionMap::kInvalidId;
 
-RtpHeaderExtensionMap::RtpHeaderExtensionMap()
-    : mixed_one_two_byte_header_supported_(false) {
+RtpHeaderExtensionMap::RtpHeaderExtensionMap() : RtpHeaderExtensionMap(false) {}
+
+RtpHeaderExtensionMap::RtpHeaderExtensionMap(bool extmap_allow_mixed)
+    : extmap_allow_mixed_(extmap_allow_mixed) {
   for (auto& id : ids_)
     id = kInvalidId;
 }
 
 RtpHeaderExtensionMap::RtpHeaderExtensionMap(
     rtc::ArrayView<const RtpExtension> extensions)
-    : RtpHeaderExtensionMap() {
+    : RtpHeaderExtensionMap(false) {
   for (const RtpExtension& extension : extensions)
     RegisterByUri(extension.id, extension.uri);
 }
diff --git a/modules/rtp_rtcp/source/rtp_packet.cc b/modules/rtp_rtcp/source/rtp_packet.cc
index 8cb8fd8cee..2c29ccae66 100644
--- a/modules/rtp_rtcp/source/rtp_packet.cc
+++ b/modules/rtp_rtcp/source/rtp_packet.cc
@@ -211,8 +211,7 @@ rtc::ArrayView<uint8_t> RtpPacket::AllocateRawExtension(int id, size_t length) {
   const bool two_byte_header_required =
       id > RtpExtension::kOneByteHeaderExtensionMaxId ||
       length > RtpExtension::kOneByteHeaderExtensionMaxValueSize || length == 0;
-  RTC_CHECK(!two_byte_header_required ||
-            extensions_.IsMixedOneTwoByteHeaderSupported());
+  RTC_CHECK(!two_byte_header_required || extensions_.ExtmapAllowMixed());
 
   uint16_t profile_id;
   if (extensions_size_ > 0) {
@@ -553,7 +552,7 @@ rtc::ArrayView<uint8_t> RtpPacket::AllocateExtension(ExtensionType type,
                                                      size_t length) {
   // TODO(webrtc:7990): Add support for empty extensions (length==0).
   if (length == 0 || length > RtpExtension::kMaxValueSize ||
-      (!extensions_.IsMixedOneTwoByteHeaderSupported() &&
+      (!extensions_.ExtmapAllowMixed() &&
        length > RtpExtension::kOneByteHeaderExtensionMaxValueSize)) {
     return nullptr;
   }
@@ -563,7 +562,7 @@ rtc::ArrayView<uint8_t> RtpPacket::AllocateExtension(ExtensionType type,
     // Extension not registered.
     return nullptr;
   }
-  if (!extensions_.IsMixedOneTwoByteHeaderSupported() &&
+  if (!extensions_.ExtmapAllowMixed() &&
       id > RtpExtension::kOneByteHeaderExtensionMaxId) {
     return nullptr;
   }
diff --git a/modules/rtp_rtcp/source/rtp_packet_unittest.cc b/modules/rtp_rtcp/source/rtp_packet_unittest.cc
index 648ddc33c6..431bf5e3d0 100644
--- a/modules/rtp_rtcp/source/rtp_packet_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_packet_unittest.cc
@@ -226,8 +226,7 @@ TEST(RtpPacketTest, CreateWith2Extensions) {
 }
 
 TEST(RtpPacketTest, CreateWithTwoByteHeaderExtensionFirst) {
-  RtpPacketToSend::ExtensionManager extensions;
-  extensions.SetMixedOneTwoByteHeaderSupported(true);
+  RtpPacketToSend::ExtensionManager extensions(true);
   extensions.Register(kRtpExtensionTransmissionTimeOffset,
                       kTransmissionOffsetExtensionId);
   extensions.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId);
@@ -248,8 +247,7 @@ TEST(RtpPacketTest, CreateWithTwoByteHeaderExtensionFirst) {
 
 TEST(RtpPacketTest, CreateWithTwoByteHeaderExtensionLast) {
   // This test will trigger RtpPacket::PromoteToTwoByteHeaderExtension().
-  RtpPacketToSend::ExtensionManager extensions;
-  extensions.SetMixedOneTwoByteHeaderSupported(true);
+  RtpPacketToSend::ExtensionManager extensions(true);
   extensions.Register(kRtpExtensionTransmissionTimeOffset,
                       kTransmissionOffsetExtensionId);
   extensions.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId);
diff --git a/pc/mediasession.cc b/pc/mediasession.cc
index d84166278a..024bf1ebc2 100644
--- a/pc/mediasession.cc
+++ b/pc/mediasession.cc
@@ -1072,7 +1072,7 @@ static bool CreateMediaContentAnswer(
   answer->AddCodecs(negotiated_codecs);
   answer->set_protocol(offer->protocol());
 
-  answer->set_extmap_allow_mixed_headers(offer->extmap_allow_mixed_headers());
+  answer->set_extmap_allow_mixed_enum(offer->extmap_allow_mixed_enum());
   RtpHeaderExtensions negotiated_rtp_extensions;
   NegotiateRtpHeaderExtensions(
       local_rtp_extenstions, offer->rtp_header_extensions(),
@@ -1406,7 +1406,7 @@ SessionDescription* MediaSessionDescriptionFactory::CreateAnswer(
   // Transport info shared by the bundle group.
   std::unique_ptr<TransportInfo> bundle_transport;
 
-  answer->set_extmap_allow_mixed_headers(offer->extmap_allow_mixed_headers());
+  answer->set_extmap_allow_mixed(offer->extmap_allow_mixed());
 
   // Get list of all possible codecs that respects existing payload type
   // mappings and uses a single payload type space.
diff --git a/pc/mediasession_unittest.cc b/pc/mediasession_unittest.cc
index 0d92147027..3af86eaa8a 100644
--- a/pc/mediasession_unittest.cc
+++ b/pc/mediasession_unittest.cc
@@ -1586,18 +1586,18 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   MediaSessionOptions opts;
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   // Offer without request of mixed one- and two-byte header extensions.
-  offer->set_extmap_allow_mixed_headers(false);
+  offer->set_extmap_allow_mixed(false);
   ASSERT_TRUE(offer.get() != NULL);
   std::unique_ptr<SessionDescription> answer_no_support(
       f2_.CreateAnswer(offer.get(), opts, NULL));
-  EXPECT_FALSE(answer_no_support->extmap_allow_mixed_headers());
+  EXPECT_FALSE(answer_no_support->extmap_allow_mixed());
 
   // Offer with request of mixed one- and two-byte header extensions.
-  offer->set_extmap_allow_mixed_headers(true);
+  offer->set_extmap_allow_mixed(true);
   ASSERT_TRUE(offer.get() != NULL);
   std::unique_ptr<SessionDescription> answer_support(
       f2_.CreateAnswer(offer.get(), opts, NULL));
-  EXPECT_TRUE(answer_support->extmap_allow_mixed_headers());
+  EXPECT_TRUE(answer_support->extmap_allow_mixed());
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest,
@@ -1613,8 +1613,8 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   ASSERT_TRUE(audio_offer);
 
   // Explicit disable of mixed one-two byte header support in offer.
-  video_offer->set_extmap_allow_mixed_headers(MediaContentDescription::kNo);
-  audio_offer->set_extmap_allow_mixed_headers(MediaContentDescription::kNo);
+  video_offer->set_extmap_allow_mixed_enum(MediaContentDescription::kNo);
+  audio_offer->set_extmap_allow_mixed_enum(MediaContentDescription::kNo);
 
   ASSERT_TRUE(offer.get() != NULL);
   std::unique_ptr<SessionDescription> answer_no_support(
@@ -1624,22 +1624,22 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   MediaContentDescription* audio_answer =
       answer_no_support->GetContentDescriptionByName("audio");
   EXPECT_EQ(MediaContentDescription::kNo,
-            video_answer->extmap_allow_mixed_headers());
+            video_answer->extmap_allow_mixed_enum());
   EXPECT_EQ(MediaContentDescription::kNo,
-            audio_answer->extmap_allow_mixed_headers());
+            audio_answer->extmap_allow_mixed_enum());
 
   // Enable mixed one-two byte header support in offer.
-  video_offer->set_extmap_allow_mixed_headers(MediaContentDescription::kMedia);
-  audio_offer->set_extmap_allow_mixed_headers(MediaContentDescription::kMedia);
+  video_offer->set_extmap_allow_mixed_enum(MediaContentDescription::kMedia);
+  audio_offer->set_extmap_allow_mixed_enum(MediaContentDescription::kMedia);
   ASSERT_TRUE(offer.get() != NULL);
   std::unique_ptr<SessionDescription> answer_support(
       f2_.CreateAnswer(offer.get(), opts, NULL));
   video_answer = answer_support->GetContentDescriptionByName("video");
   audio_answer = answer_support->GetContentDescriptionByName("audio");
   EXPECT_EQ(MediaContentDescription::kMedia,
-            video_answer->extmap_allow_mixed_headers());
+            video_answer->extmap_allow_mixed_enum());
   EXPECT_EQ(MediaContentDescription::kMedia,
-            audio_answer->extmap_allow_mixed_headers());
+            audio_answer->extmap_allow_mixed_enum());
 }
 
 // Create an audio and video offer with:
diff --git a/pc/sessiondescription.cc b/pc/sessiondescription.cc
index ce2a406e21..3a9b18ee69 100644
--- a/pc/sessiondescription.cc
+++ b/pc/sessiondescription.cc
@@ -175,9 +175,9 @@ void SessionDescription::AddContent(const std::string& name,
 }
 
 void SessionDescription::AddContent(ContentInfo* content) {
-  if (extmap_allow_mixed_headers()) {
+  if (extmap_allow_mixed()) {
     // Mixed support on session level overrides setting on media level.
-    content->description->set_extmap_allow_mixed_headers(
+    content->description->set_extmap_allow_mixed_enum(
         MediaContentDescription::kSession);
   }
   contents_.push_back(std::move(*content));
diff --git a/pc/sessiondescription.h b/pc/sessiondescription.h
index 4980dbff5e..b887b187f5 100644
--- a/pc/sessiondescription.h
+++ b/pc/sessiondescription.h
@@ -185,22 +185,19 @@ class MediaContentDescription {
 
   // Determines if it's allowed to mix one- and two-byte rtp header extensions
   // within the same rtp stream.
-  enum ExtmapAllowMixedHeaders { kNo, kSession, kMedia };
-  void set_extmap_allow_mixed_headers(
-      ExtmapAllowMixedHeaders new_extmap_allow_mixed) {
+  enum ExtmapAllowMixed { kNo, kSession, kMedia };
+  void set_extmap_allow_mixed_enum(ExtmapAllowMixed new_extmap_allow_mixed) {
     if (new_extmap_allow_mixed == kMedia &&
-        extmap_allow_mixed_headers_ == kSession) {
+        extmap_allow_mixed_enum_ == kSession) {
       // Do not downgrade from session level to media level.
       return;
     }
-    extmap_allow_mixed_headers_ = new_extmap_allow_mixed;
+    extmap_allow_mixed_enum_ = new_extmap_allow_mixed;
   }
-  ExtmapAllowMixedHeaders extmap_allow_mixed_headers() const {
-    return extmap_allow_mixed_headers_;
-  }
-  bool mixed_one_two_byte_header_extensions_supported() const {
-    return extmap_allow_mixed_headers_ != kNo;
+  ExtmapAllowMixed extmap_allow_mixed_enum() const {
+    return extmap_allow_mixed_enum_;
   }
+  bool extmap_allow_mixed() const { return extmap_allow_mixed_enum_ != kNo; }
 
  protected:
   bool rtcp_mux_ = false;
@@ -218,7 +215,7 @@ class MediaContentDescription {
   // Mixed one- and two-byte header not included in offer on media level or
   // session level, but we will respond that we support it. The plan is to add
   // it to our offer on session level. See todo in SessionDescription.
-  ExtmapAllowMixedHeaders extmap_allow_mixed_headers_ = kNo;
+  ExtmapAllowMixed extmap_allow_mixed_enum_ = kNo;
 };
 
 // TODO(bugs.webrtc.org/8620): Remove this alias once downstream projects have
@@ -477,24 +474,21 @@ class SessionDescription {
 
   // Determines if it's allowed to mix one- and two-byte rtp header extensions
   // within the same rtp stream.
-  void set_extmap_allow_mixed_headers(bool supported) {
-    extmap_allow_mixed_headers_ = supported;
-    MediaContentDescription::ExtmapAllowMixedHeaders media_level_setting =
+  void set_extmap_allow_mixed(bool supported) {
+    extmap_allow_mixed_ = supported;
+    MediaContentDescription::ExtmapAllowMixed media_level_setting =
         supported ? MediaContentDescription::kSession
                   : MediaContentDescription::kNo;
     for (auto& content : contents_) {
       // Do not set to kNo if the current setting is kMedia.
-      if (supported ||
-          content.media_description()->extmap_allow_mixed_headers() !=
-              MediaContentDescription::kMedia) {
-        content.media_description()->set_extmap_allow_mixed_headers(
+      if (supported || content.media_description()->extmap_allow_mixed_enum() !=
+                           MediaContentDescription::kMedia) {
+        content.media_description()->set_extmap_allow_mixed_enum(
             media_level_setting);
       }
     }
   }
-  bool extmap_allow_mixed_headers() const {
-    return extmap_allow_mixed_headers_;
-  }
+  bool extmap_allow_mixed() const { return extmap_allow_mixed_; }
 
  private:
   SessionDescription(const SessionDescription&);
@@ -510,7 +504,7 @@ class SessionDescription {
   // session level. It's currently not included in offer by default because
   // clients prior to https://bugs.webrtc.org/9712 cannot parse this correctly.
   // If it's included in offer to us we will respond that we support it.
-  bool extmap_allow_mixed_headers_ = false;
+  bool extmap_allow_mixed_ = false;
 };
 
 // Indicates whether a session description was sent by the local client or
diff --git a/pc/sessiondescription_unittest.cc b/pc/sessiondescription_unittest.cc
index b539524bc3..dcacf587f5 100644
--- a/pc/sessiondescription_unittest.cc
+++ b/pc/sessiondescription_unittest.cc
@@ -14,55 +14,51 @@ namespace cricket {
 
 TEST(MediaContentDescriptionTest, ExtmapAllowMixedDefaultValue) {
   VideoContentDescription video_desc;
-  EXPECT_EQ(MediaContentDescription::kNo,
-            video_desc.extmap_allow_mixed_headers());
+  EXPECT_EQ(MediaContentDescription::kNo, video_desc.extmap_allow_mixed_enum());
 }
 
 TEST(MediaContentDescriptionTest, SetExtmapAllowMixed) {
   VideoContentDescription video_desc;
-  video_desc.set_extmap_allow_mixed_headers(MediaContentDescription::kNo);
-  EXPECT_EQ(MediaContentDescription::kNo,
-            video_desc.extmap_allow_mixed_headers());
-  video_desc.set_extmap_allow_mixed_headers(MediaContentDescription::kMedia);
+  video_desc.set_extmap_allow_mixed_enum(MediaContentDescription::kNo);
+  EXPECT_EQ(MediaContentDescription::kNo, video_desc.extmap_allow_mixed_enum());
+  video_desc.set_extmap_allow_mixed_enum(MediaContentDescription::kMedia);
   EXPECT_EQ(MediaContentDescription::kMedia,
-            video_desc.extmap_allow_mixed_headers());
-  video_desc.set_extmap_allow_mixed_headers(MediaContentDescription::kSession);
+            video_desc.extmap_allow_mixed_enum());
+  video_desc.set_extmap_allow_mixed_enum(MediaContentDescription::kSession);
   EXPECT_EQ(MediaContentDescription::kSession,
-            video_desc.extmap_allow_mixed_headers());
+            video_desc.extmap_allow_mixed_enum());
 
   // Not allowed to downgrade from kSession to kMedia.
-  video_desc.set_extmap_allow_mixed_headers(MediaContentDescription::kMedia);
+  video_desc.set_extmap_allow_mixed_enum(MediaContentDescription::kMedia);
   EXPECT_EQ(MediaContentDescription::kSession,
-            video_desc.extmap_allow_mixed_headers());
+            video_desc.extmap_allow_mixed_enum());
 
   // Always okay to set not supported.
-  video_desc.set_extmap_allow_mixed_headers(MediaContentDescription::kNo);
-  EXPECT_EQ(MediaContentDescription::kNo,
-            video_desc.extmap_allow_mixed_headers());
-  video_desc.set_extmap_allow_mixed_headers(MediaContentDescription::kMedia);
+  video_desc.set_extmap_allow_mixed_enum(MediaContentDescription::kNo);
+  EXPECT_EQ(MediaContentDescription::kNo, video_desc.extmap_allow_mixed_enum());
+  video_desc.set_extmap_allow_mixed_enum(MediaContentDescription::kMedia);
   EXPECT_EQ(MediaContentDescription::kMedia,
-            video_desc.extmap_allow_mixed_headers());
-  video_desc.set_extmap_allow_mixed_headers(MediaContentDescription::kNo);
-  EXPECT_EQ(MediaContentDescription::kNo,
-            video_desc.extmap_allow_mixed_headers());
+            video_desc.extmap_allow_mixed_enum());
+  video_desc.set_extmap_allow_mixed_enum(MediaContentDescription::kNo);
+  EXPECT_EQ(MediaContentDescription::kNo, video_desc.extmap_allow_mixed_enum());
 }
 
 TEST(MediaContentDescriptionTest, MixedOneTwoByteHeaderSupported) {
   VideoContentDescription video_desc;
-  video_desc.set_extmap_allow_mixed_headers(MediaContentDescription::kNo);
-  EXPECT_FALSE(video_desc.mixed_one_two_byte_header_extensions_supported());
-  video_desc.set_extmap_allow_mixed_headers(MediaContentDescription::kMedia);
-  EXPECT_TRUE(video_desc.mixed_one_two_byte_header_extensions_supported());
-  video_desc.set_extmap_allow_mixed_headers(MediaContentDescription::kSession);
-  EXPECT_TRUE(video_desc.mixed_one_two_byte_header_extensions_supported());
+  video_desc.set_extmap_allow_mixed_enum(MediaContentDescription::kNo);
+  EXPECT_FALSE(video_desc.extmap_allow_mixed());
+  video_desc.set_extmap_allow_mixed_enum(MediaContentDescription::kMedia);
+  EXPECT_TRUE(video_desc.extmap_allow_mixed());
+  video_desc.set_extmap_allow_mixed_enum(MediaContentDescription::kSession);
+  EXPECT_TRUE(video_desc.extmap_allow_mixed());
 }
 
 TEST(SessionDescriptionTest, SetExtmapAllowMixed) {
   SessionDescription session_desc;
-  session_desc.set_extmap_allow_mixed_headers(true);
-  EXPECT_TRUE(session_desc.extmap_allow_mixed_headers());
-  session_desc.set_extmap_allow_mixed_headers(false);
-  EXPECT_FALSE(session_desc.extmap_allow_mixed_headers());
+  session_desc.set_extmap_allow_mixed(true);
+  EXPECT_TRUE(session_desc.extmap_allow_mixed());
+  session_desc.set_extmap_allow_mixed(false);
+  EXPECT_FALSE(session_desc.extmap_allow_mixed());
 }
 
 TEST(SessionDescriptionTest, SetExtmapAllowMixedPropagatesToMediaLevel) {
@@ -71,64 +67,64 @@ TEST(SessionDescriptionTest, SetExtmapAllowMixedPropagatesToMediaLevel) {
   session_desc.AddContent("video", MediaProtocolType::kRtp, video_desc);
 
   // Setting true on session level propagates to media level.
-  session_desc.set_extmap_allow_mixed_headers(true);
+  session_desc.set_extmap_allow_mixed(true);
   EXPECT_EQ(MediaContentDescription::kSession,
-            video_desc->extmap_allow_mixed_headers());
+            video_desc->extmap_allow_mixed_enum());
 
   // Don't downgrade from session level to media level
-  video_desc->set_extmap_allow_mixed_headers(MediaContentDescription::kMedia);
+  video_desc->set_extmap_allow_mixed_enum(MediaContentDescription::kMedia);
   EXPECT_EQ(MediaContentDescription::kSession,
-            video_desc->extmap_allow_mixed_headers());
+            video_desc->extmap_allow_mixed_enum());
 
   // Setting false on session level propagates to media level if the current
   // state is kSession.
-  session_desc.set_extmap_allow_mixed_headers(false);
+  session_desc.set_extmap_allow_mixed(false);
   EXPECT_EQ(MediaContentDescription::kNo,
-            video_desc->extmap_allow_mixed_headers());
+            video_desc->extmap_allow_mixed_enum());
 
   // Now possible to set at media level.
-  video_desc->set_extmap_allow_mixed_headers(MediaContentDescription::kMedia);
+  video_desc->set_extmap_allow_mixed_enum(MediaContentDescription::kMedia);
   EXPECT_EQ(MediaContentDescription::kMedia,
-            video_desc->extmap_allow_mixed_headers());
+            video_desc->extmap_allow_mixed_enum());
 
   // Setting false on session level does not override on media level if current
   // state is kMedia.
-  session_desc.set_extmap_allow_mixed_headers(false);
+  session_desc.set_extmap_allow_mixed(false);
   EXPECT_EQ(MediaContentDescription::kMedia,
-            video_desc->extmap_allow_mixed_headers());
+            video_desc->extmap_allow_mixed_enum());
 
   // Setting true on session level overrides setting on media level.
-  session_desc.set_extmap_allow_mixed_headers(true);
+  session_desc.set_extmap_allow_mixed(true);
   EXPECT_EQ(MediaContentDescription::kSession,
-            video_desc->extmap_allow_mixed_headers());
+            video_desc->extmap_allow_mixed_enum());
 }
 
 TEST(SessionDescriptionTest, AddContentTransfersExtmapAllowMixedSetting) {
   SessionDescription session_desc;
-  session_desc.set_extmap_allow_mixed_headers(false);
+  session_desc.set_extmap_allow_mixed(false);
   MediaContentDescription* audio_desc = new AudioContentDescription();
-  audio_desc->set_extmap_allow_mixed_headers(MediaContentDescription::kMedia);
+  audio_desc->set_extmap_allow_mixed_enum(MediaContentDescription::kMedia);
 
   // If session setting is false, media level setting is preserved when new
   // content is added.
   session_desc.AddContent("audio", MediaProtocolType::kRtp, audio_desc);
   EXPECT_EQ(MediaContentDescription::kMedia,
-            audio_desc->extmap_allow_mixed_headers());
+            audio_desc->extmap_allow_mixed_enum());
 
   // If session setting is true, it's transferred to media level when new
   // content is added.
-  session_desc.set_extmap_allow_mixed_headers(true);
+  session_desc.set_extmap_allow_mixed(true);
   MediaContentDescription* video_desc = new VideoContentDescription();
   session_desc.AddContent("video", MediaProtocolType::kRtp, video_desc);
   EXPECT_EQ(MediaContentDescription::kSession,
-            video_desc->extmap_allow_mixed_headers());
+            video_desc->extmap_allow_mixed_enum());
 
   // Session level setting overrides media level when new content is added.
   MediaContentDescription* data_desc = new DataContentDescription;
-  data_desc->set_extmap_allow_mixed_headers(MediaContentDescription::kMedia);
+  data_desc->set_extmap_allow_mixed_enum(MediaContentDescription::kMedia);
   session_desc.AddContent("data", MediaProtocolType::kRtp, data_desc);
   EXPECT_EQ(MediaContentDescription::kSession,
-            data_desc->extmap_allow_mixed_headers());
+            data_desc->extmap_allow_mixed_enum());
 }
 
 }  // namespace cricket
diff --git a/pc/webrtcsdp.cc b/pc/webrtcsdp.cc
index 2ea24c00c5..40f78747cf 100644
--- a/pc/webrtcsdp.cc
+++ b/pc/webrtcsdp.cc
@@ -856,7 +856,7 @@ std::string SdpSerialize(const JsepSessionDescription& jdesc) {
   }
 
   // Mixed one- and two-byte header extension.
-  if (desc->extmap_allow_mixed_headers()) {
+  if (desc->extmap_allow_mixed()) {
     InitAttrLine(kAttributeExtmapAllowMixed, &os);
     AddLine(os.str(), &message);
   }
@@ -1496,7 +1496,7 @@ void BuildRtpContentAttributes(const MediaContentDescription* media_desc,
   // The attribute MUST be either on session level or media level. We support
   // responding on both levels, however, we don't respond on media level if it's
   // set on session level.
-  if (media_desc->extmap_allow_mixed_headers() ==
+  if (media_desc->extmap_allow_mixed_enum() ==
       MediaContentDescription::kMedia) {
     InitAttrLine(kAttributeExtmapAllowMixed, &os);
     AddLine(os.str(), message);
@@ -2020,7 +2020,7 @@ bool ParseSessionDescription(const std::string& message,
   std::string line;
 
   desc->set_msid_supported(false);
-  desc->set_extmap_allow_mixed_headers(false);
+  desc->set_extmap_allow_mixed(false);
   // RFC 4566
   // v=  (protocol version)
   if (!GetLineWithType(message, pos, &line, kLineTypeVersion)) {
@@ -2158,7 +2158,7 @@ bool ParseSessionDescription(const std::string& message,
       desc->set_msid_supported(
           CaseInsensitiveFind(semantics, kMediaStreamSemantic));
     } else if (HasAttribute(line, kAttributeExtmapAllowMixed)) {
-      desc->set_extmap_allow_mixed_headers(true);
+      desc->set_extmap_allow_mixed(true);
     } else if (HasAttribute(line, kAttributeExtmap)) {
       RtpExtension extmap;
       if (!ParseExtmap(line, &extmap, error)) {
@@ -2930,7 +2930,7 @@ bool ParseContent(const std::string& message,
       } else if (HasAttribute(line, kAttributeSendRecv)) {
         media_desc->set_direction(RtpTransceiverDirection::kSendRecv);
       } else if (HasAttribute(line, kAttributeExtmapAllowMixed)) {
-        media_desc->set_extmap_allow_mixed_headers(
+        media_desc->set_extmap_allow_mixed_enum(
             MediaContentDescription::kMedia);
       } else if (HasAttribute(line, kAttributeExtmap)) {
         RtpExtension extmap;
diff --git a/pc/webrtcsdp_unittest.cc b/pc/webrtcsdp_unittest.cc
index bba10f2054..e7c5c77bb6 100644
--- a/pc/webrtcsdp_unittest.cc
+++ b/pc/webrtcsdp_unittest.cc
@@ -1286,8 +1286,7 @@ class WebRtcSdpTest : public testing::Test {
     EXPECT_EQ(cd1->streams(), cd2->streams());
 
     // extmap-allow-mixed
-    EXPECT_EQ(cd1->extmap_allow_mixed_headers(),
-              cd2->extmap_allow_mixed_headers());
+    EXPECT_EQ(cd1->extmap_allow_mixed_enum(), cd2->extmap_allow_mixed_enum());
 
     // extmap
     ASSERT_EQ(cd1->rtp_header_extensions().size(),
@@ -1405,8 +1404,7 @@ class WebRtcSdpTest : public testing::Test {
 
     // global attributes
     EXPECT_EQ(desc1.msid_supported(), desc2.msid_supported());
-    EXPECT_EQ(desc1.extmap_allow_mixed_headers(),
-              desc2.extmap_allow_mixed_headers());
+    EXPECT_EQ(desc1.extmap_allow_mixed(), desc2.extmap_allow_mixed());
   }
 
   bool CompareSessionDescription(const JsepSessionDescription& desc1,
@@ -2123,7 +2121,7 @@ TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithDataChannelAndBandwidth) {
 }
 
 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithExtmapAllowMixed) {
-  jdesc_.description()->set_extmap_allow_mixed_headers(true);
+  jdesc_.description()->set_extmap_allow_mixed(true);
   TestSerialize(jdesc_);
 }
 
@@ -2134,9 +2132,9 @@ TEST_F(WebRtcSdpTest, SerializeMediaContentDescriptionWithExtmapAllowMixed) {
   cricket::MediaContentDescription* audio_desc =
       jdesc_.description()->GetContentDescriptionByName(kAudioContentName);
   ASSERT_TRUE(audio_desc);
-  video_desc->set_extmap_allow_mixed_headers(
+  video_desc->set_extmap_allow_mixed_enum(
       cricket::MediaContentDescription::kMedia);
-  audio_desc->set_extmap_allow_mixed_headers(
+  audio_desc->set_extmap_allow_mixed_enum(
       cricket::MediaContentDescription::kMedia);
   TestSerialize(jdesc_);
 }
@@ -2479,7 +2477,7 @@ TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithoutMsid) {
 }
 
 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithExtmapAllowMixed) {
-  jdesc_.description()->set_extmap_allow_mixed_headers(true);
+  jdesc_.description()->set_extmap_allow_mixed(true);
   std::string sdp_with_extmap_allow_mixed = kSdpFullString;
   InjectAfter("t=0 0\r\n", kExtmapAllowMixed, &sdp_with_extmap_allow_mixed);
   // Deserialize
@@ -2490,7 +2488,7 @@ TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithExtmapAllowMixed) {
 }
 
 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithoutExtmapAllowMixed) {
-  jdesc_.description()->set_extmap_allow_mixed_headers(false);
+  jdesc_.description()->set_extmap_allow_mixed(false);
   std::string sdp_without_extmap_allow_mixed = kSdpFullString;
   // Deserialize
   JsepSessionDescription jdesc_deserialized(kDummyType);
@@ -2507,9 +2505,9 @@ TEST_F(WebRtcSdpTest, DeserializeMediaContentDescriptionWithExtmapAllowMixed) {
   cricket::MediaContentDescription* audio_desc =
       jdesc_.description()->GetContentDescriptionByName(kAudioContentName);
   ASSERT_TRUE(audio_desc);
-  video_desc->set_extmap_allow_mixed_headers(
+  video_desc->set_extmap_allow_mixed_enum(
       cricket::MediaContentDescription::kMedia);
-  audio_desc->set_extmap_allow_mixed_headers(
+  audio_desc->set_extmap_allow_mixed_enum(
       cricket::MediaContentDescription::kMedia);
 
   std::string sdp_with_extmap_allow_mixed = kSdpFullString;