BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

28 files changed, 506 insertions, 186 deletions

diff --git a/chromium/third_party/webrtc/media/BUILD.gn b/chromium/third_party/webrtc/media/BUILD.gn
index 28a8755615a..b6c78fdb397 100644
--- a/chromium/third_party/webrtc/media/BUILD.gn
+++ b/chromium/third_party/webrtc/media/BUILD.gn
@@ -36,8 +36,8 @@ rtc_library("rtc_h264_profile_id") {
     "../rtc_base:checks",
     "../rtc_base:rtc_base_approved",
     "../rtc_base/system:rtc_export",
-    "//third_party/abseil-cpp/absl/types:optional",
   ]
+  absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
 }
 
 rtc_source_set("rtc_media_config") {
@@ -57,8 +57,8 @@ rtc_library("rtc_vp9_profile") {
     "../api/video_codecs:video_codecs_api",
     "../rtc_base:rtc_base_approved",
     "../rtc_base/system:rtc_export",
-    "//third_party/abseil-cpp/absl/types:optional",
   ]
+  absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
 }
 
 rtc_library("rtc_sdp_fmtp_utils") {
@@ -71,8 +71,8 @@ rtc_library("rtc_sdp_fmtp_utils") {
   deps = [
     "../api/video_codecs:video_codecs_api",
     "../rtc_base:stringutils",
-    "//third_party/abseil-cpp/absl/types:optional",
   ]
+  absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
 }
 
 rtc_library("rtc_media_base") {
@@ -96,7 +96,6 @@ rtc_library("rtc_media_base") {
     "../api/crypto:frame_encryptor_interface",
     "../api/crypto:options",
     "../api/transport:stun_types",
-    "../api/transport/media:media_transport_interface",
     "../api/transport/rtp:rtp_source",
     "../api/video:video_bitrate_allocation",
     "../api/video:video_bitrate_allocator_factory",
@@ -121,6 +120,8 @@ rtc_library("rtc_media_base") {
     "../rtc_base/system:rtc_export",
     "../rtc_base/third_party/sigslot",
     "../system_wrappers:field_trial",
+  ]
+  absl_deps = [
     "//third_party/abseil-cpp/absl/algorithm:container",
     "//third_party/abseil-cpp/absl/strings",
     "//third_party/abseil-cpp/absl/types:optional",
@@ -197,8 +198,8 @@ rtc_library("rtc_simulcast_encoder_adapter") {
     "../rtc_base/system:rtc_export",
     "../system_wrappers",
     "../system_wrappers:field_trial",
-    "//third_party/abseil-cpp/absl/types:optional",
   ]
+  absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
 }
 
 rtc_library("rtc_encoder_simulcast_proxy") {
@@ -253,8 +254,8 @@ rtc_library("rtc_internal_video_codecs") {
     "../rtc_base:rtc_base_approved",
     "../rtc_base/system:rtc_export",
     "../test:fake_video_codecs",
-    "//third_party/abseil-cpp/absl/strings",
   ]
+  absl_deps = [ "//third_party/abseil-cpp/absl/strings" ]
   sources = [
     "engine/fake_video_codec_factory.cc",
     "engine/fake_video_codec_factory.h",
@@ -290,8 +291,6 @@ rtc_library("rtc_audio_video") {
     "../api/audio_codecs:audio_codecs_api",
     "../api/task_queue",
     "../api/transport:bitrate_settings",
-    "../api/transport:datagram_transport_interface",
-    "../api/transport/media:media_transport_interface",
     "../api/transport/rtp:rtp_source",
     "../api/units:data_rate",
     "../api/video:video_bitrate_allocation",
@@ -318,6 +317,7 @@ rtc_library("rtc_audio_video") {
     "../rtc_base",
     "../rtc_base:audio_format_to_string",
     "../rtc_base:checks",
+    "../rtc_base:ignore_wundef",
     "../rtc_base:rtc_task_queue",
     "../rtc_base:stringutils",
     "../rtc_base/experiments:field_trial_parser",
@@ -329,6 +329,8 @@ rtc_library("rtc_audio_video") {
     "../system_wrappers",
     "../system_wrappers:field_trial",
     "../system_wrappers:metrics",
+  ]
+  absl_deps = [
     "//third_party/abseil-cpp/absl/algorithm:container",
     "//third_party/abseil-cpp/absl/strings",
     "//third_party/abseil-cpp/absl/types:optional",
@@ -358,7 +360,10 @@ rtc_library("rtc_audio_video") {
     deps += [ "../modules/video_capture:video_capture_internal_impl" ]
   }
   if (rtc_enable_protobuf) {
-    deps += [ "../modules/audio_processing/aec_dump:aec_dump_impl" ]
+    deps += [
+      "../modules/audio_coding:ana_config_proto",
+      "../modules/audio_processing/aec_dump:aec_dump_impl",
+    ]
   } else {
     deps += [ "../modules/audio_processing/aec_dump:null_aec_dump_factory" ]
   }
@@ -405,6 +410,8 @@ rtc_library("rtc_data") {
     "../rtc_base:rtc_base_approved",
     "../rtc_base/third_party/sigslot",
     "../system_wrappers",
+  ]
+  absl_deps = [
     "//third_party/abseil-cpp/absl/algorithm:container",
     "//third_party/abseil-cpp/absl/base:core_headers",
     "//third_party/abseil-cpp/absl/types:optional",
@@ -479,6 +486,8 @@ if (rtc_include_tests) {
       "../rtc_base/third_party/sigslot",
       "../test:test_support",
       "//testing/gtest",
+    ]
+    absl_deps = [
       "//third_party/abseil-cpp/absl/algorithm:container",
       "//third_party/abseil-cpp/absl/strings",
     ]
@@ -553,7 +562,6 @@ if (rtc_include_tests) {
       "../api/task_queue:default_task_queue_factory",
       "../api/test/video:function_video_factory",
       "../api/transport:field_trial_based_config",
-      "../api/transport/media:media_transport_interface",
       "../api/units:time_delta",
       "../api/video:builtin_video_bitrate_allocator_factory",
       "../api/video:video_bitrate_allocation",
diff --git a/chromium/third_party/webrtc/media/base/fake_network_interface.h b/chromium/third_party/webrtc/media/base/fake_network_interface.h
index 7d50ca84bcd..24b553fd63f 100644
--- a/chromium/third_party/webrtc/media/base/fake_network_interface.h
+++ b/chromium/third_party/webrtc/media/base/fake_network_interface.h
@@ -28,7 +28,7 @@ namespace cricket {
 
 // Fake NetworkInterface that sends/receives RTP/RTCP packets.
 class FakeNetworkInterface : public MediaChannel::NetworkInterface,
-                             public rtc::MessageHandler {
+                             public rtc::MessageHandlerAutoCleanup {
  public:
   FakeNetworkInterface()
       : thread_(rtc::Thread::Current()),
@@ -43,13 +43,14 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
   // Conference mode is a mode where instead of simply forwarding the packets,
   // the transport will send multiple copies of the packet with the specified
   // SSRCs. This allows us to simulate receiving media from multiple sources.
-  void SetConferenceMode(bool conf, const std::vector<uint32_t>& ssrcs) {
+  void SetConferenceMode(bool conf, const std::vector<uint32_t>& ssrcs)
+      RTC_LOCKS_EXCLUDED(crit_) {
     rtc::CritScope cs(&crit_);
     conf_ = conf;
     conf_sent_ssrcs_ = ssrcs;
   }
 
-  int NumRtpBytes() {
+  int NumRtpBytes() RTC_LOCKS_EXCLUDED(crit_) {
     rtc::CritScope cs(&crit_);
     int bytes = 0;
     for (size_t i = 0; i < rtp_packets_.size(); ++i) {
@@ -58,48 +59,50 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
     return bytes;
   }
 
-  int NumRtpBytes(uint32_t ssrc) {
+  int NumRtpBytes(uint32_t ssrc) RTC_LOCKS_EXCLUDED(crit_) {
     rtc::CritScope cs(&crit_);
     int bytes = 0;
     GetNumRtpBytesAndPackets(ssrc, &bytes, NULL);
     return bytes;
   }
 
-  int NumRtpPackets() {
+  int NumRtpPackets() RTC_LOCKS_EXCLUDED(crit_) {
     rtc::CritScope cs(&crit_);
     return static_cast<int>(rtp_packets_.size());
   }
 
-  int NumRtpPackets(uint32_t ssrc) {
+  int NumRtpPackets(uint32_t ssrc) RTC_LOCKS_EXCLUDED(crit_) {
     rtc::CritScope cs(&crit_);
     int packets = 0;
     GetNumRtpBytesAndPackets(ssrc, NULL, &packets);
     return packets;
   }
 
-  int NumSentSsrcs() {
+  int NumSentSsrcs() RTC_LOCKS_EXCLUDED(crit_) {
     rtc::CritScope cs(&crit_);
     return static_cast<int>(sent_ssrcs_.size());
   }
 
   // Note: callers are responsible for deleting the returned buffer.
-  const rtc::CopyOnWriteBuffer* GetRtpPacket(int index) {
+  const rtc::CopyOnWriteBuffer* GetRtpPacket(int index)
+      RTC_LOCKS_EXCLUDED(crit_) {
     rtc::CritScope cs(&crit_);
-    if (index >= NumRtpPackets()) {
+    if (index >= static_cast<int>(rtp_packets_.size())) {
       return NULL;
     }
     return new rtc::CopyOnWriteBuffer(rtp_packets_[index]);
   }
 
-  int NumRtcpPackets() {
+  int NumRtcpPackets() RTC_LOCKS_EXCLUDED(crit_) {
     rtc::CritScope cs(&crit_);
     return static_cast<int>(rtcp_packets_.size());
   }
 
   // Note: callers are responsible for deleting the returned buffer.
-  const rtc::CopyOnWriteBuffer* GetRtcpPacket(int index) {
+  const rtc::CopyOnWriteBuffer* GetRtcpPacket(int index)
+      RTC_LOCKS_EXCLUDED(crit_) {
     rtc::CritScope cs(&crit_);
-    if (index >= NumRtcpPackets()) {
+    if (index >= static_cast<int>(rtcp_packets_.size())) {
       return NULL;
     }
     return new rtc::CopyOnWriteBuffer(rtcp_packets_[index]);
@@ -112,7 +115,8 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
 
  protected:
   virtual bool SendPacket(rtc::CopyOnWriteBuffer* packet,
-                          const rtc::PacketOptions& options) {
+                          const rtc::PacketOptions& options)
+      RTC_LOCKS_EXCLUDED(crit_) {
     rtc::CritScope cs(&crit_);
 
     uint32_t cur_ssrc = 0;
@@ -137,7 +141,8 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
   }
 
   virtual bool SendRtcp(rtc::CopyOnWriteBuffer* packet,
-                        const rtc::PacketOptions& options) {
+                        const rtc::PacketOptions& options)
+      RTC_LOCKS_EXCLUDED(crit_) {
     rtc::CritScope cs(&crit_);
     rtcp_packets_.push_back(*packet);
     options_ = options;
diff --git a/chromium/third_party/webrtc/media/base/media_channel.cc b/chromium/third_party/webrtc/media/base/media_channel.cc
index 2e9bfc3d318..5b0ed26f8bc 100644
--- a/chromium/third_party/webrtc/media/base/media_channel.cc
+++ b/chromium/third_party/webrtc/media/base/media_channel.cc
@@ -23,12 +23,9 @@ MediaChannel::MediaChannel() : enable_dscp_(false) {}
 
 MediaChannel::~MediaChannel() {}
 
-void MediaChannel::SetInterface(
-    NetworkInterface* iface,
-    const webrtc::MediaTransportConfig& media_transport_config) {
+void MediaChannel::SetInterface(NetworkInterface* iface) {
   rtc::CritScope cs(&network_interface_crit_);
   network_interface_ = iface;
-  media_transport_config_ = media_transport_config;
   UpdateDscp();
 }
 
diff --git a/chromium/third_party/webrtc/media/base/media_channel.h b/chromium/third_party/webrtc/media/base/media_channel.h
index d71ec9158a5..07be28cafab 100644
--- a/chromium/third_party/webrtc/media/base/media_channel.h
+++ b/chromium/third_party/webrtc/media/base/media_channel.h
@@ -26,7 +26,6 @@
 #include "api/media_stream_interface.h"
 #include "api/rtc_error.h"
 #include "api/rtp_parameters.h"
-#include "api/transport/media/media_transport_config.h"
 #include "api/transport/rtp/rtp_source.h"
 #include "api/video/video_content_type.h"
 #include "api/video/video_sink_interface.h"
@@ -195,15 +194,9 @@ class MediaChannel : public sigslot::has_slots<> {
 
   virtual cricket::MediaType media_type() const = 0;
 
-  // Sets the abstract interface class for sending RTP/RTCP data and
-  // interface for media transport (experimental). If media transport is
-  // provided, it should be used instead of RTP/RTCP.
-  // TODO(sukhanov): Currently media transport can co-exist with RTP/RTCP, but
-  // in the future we will refactor code to send all frames with media
-  // transport.
-  virtual void SetInterface(
-      NetworkInterface* iface,
-      const webrtc::MediaTransportConfig& media_transport_config);
+  // Sets the abstract interface class for sending RTP/RTCP data.
+  virtual void SetInterface(NetworkInterface* iface)
+      RTC_LOCKS_EXCLUDED(network_interface_crit_);
   // Called when a RTP packet is received.
   virtual void OnPacketReceived(rtc::CopyOnWriteBuffer packet,
                                 int64_t packet_time_us) = 0;
@@ -264,16 +257,9 @@ class MediaChannel : public sigslot::has_slots<> {
 
   int SetOption(NetworkInterface::SocketType type,
                 rtc::Socket::Option opt,
-                int option) {
+                int option) RTC_LOCKS_EXCLUDED(network_interface_crit_) {
     rtc::CritScope cs(&network_interface_crit_);
-    if (!network_interface_)
-      return -1;
-
-    return network_interface_->SetOption(type, opt, option);
-  }
-
-  const webrtc::MediaTransportConfig& media_transport_config() const {
-    return media_transport_config_;
+    return SetOptionLocked(type, opt, option);
   }
 
   // Corresponds to the SDP attribute extmap-allow-mixed, see RFC8285.
@@ -298,16 +284,27 @@ class MediaChannel : public sigslot::has_slots<> {
       rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer);
 
  protected:
+  int SetOptionLocked(NetworkInterface::SocketType type,
+                      rtc::Socket::Option opt,
+                      int option)
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(network_interface_crit_) {
+    if (!network_interface_)
+      return -1;
+    return network_interface_->SetOption(type, opt, option);
+  }
+
   bool DscpEnabled() const { return enable_dscp_; }
 
   // This is the DSCP value used for both RTP and RTCP channels if DSCP is
   // enabled. It can be changed at any time via |SetPreferredDscp|.
-  rtc::DiffServCodePoint PreferredDscp() const {
+  rtc::DiffServCodePoint PreferredDscp() const
+      RTC_LOCKS_EXCLUDED(network_interface_crit_) {
     rtc::CritScope cs(&network_interface_crit_);
     return preferred_dscp_;
   }
 
-  int SetPreferredDscp(rtc::DiffServCodePoint preferred_dscp) {
+  int SetPreferredDscp(rtc::DiffServCodePoint preferred_dscp)
+      RTC_LOCKS_EXCLUDED(network_interface_crit_) {
     rtc::CritScope cs(&network_interface_crit_);
     if (preferred_dscp == preferred_dscp_) {
       return 0;
@@ -322,16 +319,19 @@ class MediaChannel : public sigslot::has_slots<> {
   int UpdateDscp() RTC_EXCLUSIVE_LOCKS_REQUIRED(network_interface_crit_) {
     rtc::DiffServCodePoint value =
         enable_dscp_ ? preferred_dscp_ : rtc::DSCP_DEFAULT;
-    int ret = SetOption(NetworkInterface::ST_RTP, rtc::Socket::OPT_DSCP, value);
+    int ret =
+        SetOptionLocked(NetworkInterface::ST_RTP, rtc::Socket::OPT_DSCP, value);
     if (ret == 0) {
-      ret = SetOption(NetworkInterface::ST_RTCP, rtc::Socket::OPT_DSCP, value);
+      ret = SetOptionLocked(NetworkInterface::ST_RTCP, rtc::Socket::OPT_DSCP,
+                            value);
     }
     return ret;
   }
 
   bool DoSendPacket(rtc::CopyOnWriteBuffer* packet,
                     bool rtcp,
-                    const rtc::PacketOptions& options) {
+                    const rtc::PacketOptions& options)
+      RTC_LOCKS_EXCLUDED(network_interface_crit_) {
     rtc::CritScope cs(&network_interface_crit_);
     if (!network_interface_)
       return false;
@@ -349,7 +349,6 @@ class MediaChannel : public sigslot::has_slots<> {
       nullptr;
   rtc::DiffServCodePoint preferred_dscp_
       RTC_GUARDED_BY(network_interface_crit_) = rtc::DSCP_DEFAULT;
-  webrtc::MediaTransportConfig media_transport_config_;
   bool extmap_allow_mixed_ = false;
 };
 
diff --git a/chromium/third_party/webrtc/media/base/media_constants.cc b/chromium/third_party/webrtc/media/base/media_constants.cc
index 5144a6ea655..03679d9627d 100644
--- a/chromium/third_party/webrtc/media/base/media_constants.cc
+++ b/chromium/third_party/webrtc/media/base/media_constants.cc
@@ -98,15 +98,13 @@ const char kCodecParamMaxMessageSize[] = "x-google-max-message-size";
 const int kGoogleRtpDataCodecPlType = 109;
 const char kGoogleRtpDataCodecName[] = "google-data";
 
-const int kGoogleSctpDataCodecPlType = 108;
-const char kGoogleSctpDataCodecName[] = "google-sctp-data";
-
 const char kComfortNoiseCodecName[] = "CN";
 
 const char kVp8CodecName[] = "VP8";
 const char kVp9CodecName[] = "VP9";
 const char kAv1CodecName[] = "AV1X";
 const char kH264CodecName[] = "H264";
+const char kHEVCCodecName[] = "H265X";
 
 // RFC 6184 RTP Payload Format for H.264 video
 const char kH264FmtpProfileLevelId[] = "profile-level-id";
diff --git a/chromium/third_party/webrtc/media/base/media_constants.h b/chromium/third_party/webrtc/media/base/media_constants.h
index b9b8a336f7f..d2bfb36ee91 100644
--- a/chromium/third_party/webrtc/media/base/media_constants.h
+++ b/chromium/third_party/webrtc/media/base/media_constants.h
@@ -124,18 +124,13 @@ extern const char kCodecParamMaxMessageSize[];
 extern const int kGoogleRtpDataCodecPlType;
 extern const char kGoogleRtpDataCodecName[];
 
-// TODO(pthatcher): Find an id that won't conflict with anything.  On
-// the other hand, it really shouldn't matter since the id won't be
-// used on the wire.
-extern const int kGoogleSctpDataCodecPlType;
-extern const char kGoogleSctpDataCodecName[];
-
 extern const char kComfortNoiseCodecName[];
 
 RTC_EXPORT extern const char kVp8CodecName[];
 RTC_EXPORT extern const char kVp9CodecName[];
 RTC_EXPORT extern const char kAv1CodecName[];
 RTC_EXPORT extern const char kH264CodecName[];
+RTC_EXPORT extern const char kHEVCCodecName[];
 
 // RFC 6184 RTP Payload Format for H.264 video
 RTC_EXPORT extern const char kH264FmtpProfileLevelId[];
diff --git a/chromium/third_party/webrtc/media/base/media_engine_unittest.cc b/chromium/third_party/webrtc/media/base/media_engine_unittest.cc
index f4c6f5f0454..83f80c4669c 100644
--- a/chromium/third_party/webrtc/media/base/media_engine_unittest.cc
+++ b/chromium/third_party/webrtc/media/base/media_engine_unittest.cc
@@ -26,8 +26,10 @@ namespace {
 class MockRtpHeaderExtensionQueryInterface
     : public RtpHeaderExtensionQueryInterface {
  public:
-  MOCK_CONST_METHOD0(GetRtpHeaderExtensions,
-                     std::vector<RtpHeaderExtensionCapability>());
+  MOCK_METHOD(std::vector<RtpHeaderExtensionCapability>,
+              GetRtpHeaderExtensions,
+              (),
+              (const, override));
 };
 
 }  // namespace
diff --git a/chromium/third_party/webrtc/media/base/rtp_data_engine_unittest.cc b/chromium/third_party/webrtc/media/base/rtp_data_engine_unittest.cc
index dab4058c331..f01c7c60c74 100644
--- a/chromium/third_party/webrtc/media/base/rtp_data_engine_unittest.cc
+++ b/chromium/third_party/webrtc/media/base/rtp_data_engine_unittest.cc
@@ -75,7 +75,7 @@ class RtpDataMediaChannelTest : public ::testing::Test {
     cricket::MediaConfig config;
     cricket::RtpDataMediaChannel* channel =
         static_cast<cricket::RtpDataMediaChannel*>(dme->CreateChannel(config));
-    channel->SetInterface(iface_.get(), webrtc::MediaTransportConfig());
+    channel->SetInterface(iface_.get());
     channel->SignalDataReceived.connect(receiver_.get(),
                                         &FakeDataReceiver::OnDataReceived);
     return channel;
diff --git a/chromium/third_party/webrtc/media/base/rtp_utils.cc b/chromium/third_party/webrtc/media/base/rtp_utils.cc
index 0b45e69410d..4a2b3267ccf 100644
--- a/chromium/third_party/webrtc/media/base/rtp_utils.cc
+++ b/chromium/third_party/webrtc/media/base/rtp_utils.cc
@@ -34,6 +34,7 @@ static const size_t kRtcpPayloadTypeOffset = 1;
 static const size_t kRtpExtensionHeaderLen = 4;
 static const size_t kAbsSendTimeExtensionLen = 3;
 static const size_t kOneByteExtensionHeaderLen = 1;
+static const size_t kTwoByteExtensionHeaderLen = 2;
 
 namespace {
 
@@ -424,10 +425,13 @@ bool UpdateRtpAbsSendTimeExtension(uint8_t* rtp,
 
   rtp += kRtpExtensionHeaderLen;  // Moving past extension header.
 
+  constexpr uint16_t kOneByteExtensionProfileId = 0xBEDE;
+  constexpr uint16_t kTwoByteExtensionProfileId = 0x1000;
+
   bool found = false;
-  // WebRTC is using one byte header extension.
-  // TODO(mallinath) - Handle two byte header extension.
-  if (profile_id == 0xBEDE) {  // OneByte extension header
+  if (profile_id == kOneByteExtensionProfileId ||
+      profile_id == kTwoByteExtensionProfileId) {
+    // OneByte extension header
     //  0
     //  0 1 2 3 4 5 6 7
     // +-+-+-+-+-+-+-+-+
@@ -445,24 +449,53 @@ bool UpdateRtpAbsSendTimeExtension(uint8_t* rtp,
     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     // |                          data                                 |
     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+    // TwoByte extension header
+    //  0
+    //  0 1 2 3 4 5 6 7
+    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    // |      ID       |    length     |
+    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+    //  0                   1                   2                   3
+    //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    // |     0x10      |     0x00      |           length=3            |
+    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    // |      ID       |      L=1      |     data      |      ID       |
+    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    // |      L=2      |             data              |    0 (pad)    |
+    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    // |      ID       |      L=2      |             data              |
+    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+    size_t extension_header_length = profile_id == kOneByteExtensionProfileId
+                                         ? kOneByteExtensionHeaderLen
+                                         : kTwoByteExtensionHeaderLen;
+
     const uint8_t* extension_start = rtp;
     const uint8_t* extension_end = extension_start + extension_length;
 
-    while (rtp < extension_end) {
-      const int id = (*rtp & 0xF0) >> 4;
-      const size_t length = (*rtp & 0x0F) + 1;
-      if (rtp + kOneByteExtensionHeaderLen + length > extension_end) {
+    // rtp + 1 since the minimum size per header extension is two bytes for both
+    // one- and two-byte header extensions.
+    while (rtp + 1 < extension_end) {
+      // See RFC8285 Section 4.2-4.3 for more information about one- and
+      // two-byte header extensions.
+      const int id =
+          profile_id == kOneByteExtensionProfileId ? (*rtp & 0xF0) >> 4 : *rtp;
+      const size_t length = profile_id == kOneByteExtensionProfileId
+                                ? (*rtp & 0x0F) + 1
+                                : *(rtp + 1);
+      if (rtp + extension_header_length + length > extension_end) {
         return false;
       }
-      // The 4-bit length is the number minus one of data bytes of this header
-      // extension element following the one-byte header.
       if (id == extension_id) {
-        UpdateAbsSendTimeExtensionValue(rtp + kOneByteExtensionHeaderLen,
-                                        length, time_us);
+        UpdateAbsSendTimeExtensionValue(rtp + extension_header_length, length,
+                                        time_us);
         found = true;
         break;
       }
-      rtp += kOneByteExtensionHeaderLen + length;
+      rtp += extension_header_length + length;
       // Counting padding bytes.
       while ((rtp < extension_end) && (*rtp == 0)) {
         ++rtp;
diff --git a/chromium/third_party/webrtc/media/base/rtp_utils_unittest.cc b/chromium/third_party/webrtc/media/base/rtp_utils_unittest.cc
index 051508cd01a..a5e8a810f47 100644
--- a/chromium/third_party/webrtc/media/base/rtp_utils_unittest.cc
+++ b/chromium/third_party/webrtc/media/base/rtp_utils_unittest.cc
@@ -71,15 +71,25 @@ static uint8_t kRtpMsgWith2ByteExtnHeader[] = {
     // clang-format on
 };
 
-// RTP packet with single byte extension header of length 4 bytes.
-// Extension id = 3 and length = 3
-static uint8_t kRtpMsgWithAbsSendTimeExtension[] = {
+// RTP packet with two one-byte header extensions. The last 4 bytes consist of
+// abs-send-time with extension id = 3 and length = 3.
+static uint8_t kRtpMsgWithOneByteAbsSendTimeExtension[] = {
     0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0xBE, 0xDE, 0x00, 0x02, 0x22, 0x00, 0x02, 0x1c, 0x32, 0xaa, 0xbb, 0xcc,
 };
 
-// Index of AbsSendTimeExtn data in message |kRtpMsgWithAbsSendTimeExtension|.
-static const int kAstIndexInRtpMsg = 21;
+// RTP packet with two two-byte header extensions. The last 5 bytes consist of
+// abs-send-time with extension id = 3 and length = 3.
+static uint8_t kRtpMsgWithTwoByteAbsSendTimeExtension[] = {
+    0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x02, 0x02, 0x01, 0x02, 0x03, 0x03, 0xaa, 0xbb, 0xcc,
+};
+
+// Index of AbsSendTimeExtn data in message
+// |kRtpMsgWithOneByteAbsSendTimeExtension|.
+static const int kAstIndexInOneByteRtpMsg = 21;
+// and in message |kRtpMsgWithTwoByteAbsSendTimeExtension|.
+static const int kAstIndexInTwoByteRtpMsg = 21;
 
 static const rtc::ArrayView<const char> kPcmuFrameArrayView =
     rtc::MakeArrayView(reinterpret_cast<const char*>(kPcmuFrame),
@@ -213,19 +223,17 @@ TEST(RtpUtilsTest, Valid2ByteExtnHdrRtpMessage) {
 }
 
 // Valid RTP packet which has 1 byte header AbsSendTime extension in it.
-TEST(RtpUtilsTest, ValidRtpPacketWithAbsSendTimeExtension) {
-  EXPECT_TRUE(ValidateRtpHeader(kRtpMsgWithAbsSendTimeExtension,
-                                sizeof(kRtpMsgWithAbsSendTimeExtension),
+TEST(RtpUtilsTest, ValidRtpPacketWithOneByteAbsSendTimeExtension) {
+  EXPECT_TRUE(ValidateRtpHeader(kRtpMsgWithOneByteAbsSendTimeExtension,
+                                sizeof(kRtpMsgWithOneByteAbsSendTimeExtension),
                                 nullptr));
 }
 
-// Verify handling of a 2 byte extension header RTP messsage. Currently these
-// messages are not supported.
-TEST(RtpUtilsTest, UpdateAbsSendTimeExtensionIn2ByteHeaderExtn) {
-  std::vector<uint8_t> data(
-      kRtpMsgWith2ByteExtnHeader,
-      kRtpMsgWith2ByteExtnHeader + sizeof(kRtpMsgWith2ByteExtnHeader));
-  EXPECT_FALSE(UpdateRtpAbsSendTimeExtension(&data[0], data.size(), 3, 0));
+// Valid RTP packet which has 2 byte header AbsSendTime extension in it.
+TEST(RtpUtilsTest, ValidRtpPacketWithTwoByteAbsSendTimeExtension) {
+  EXPECT_TRUE(ValidateRtpHeader(kRtpMsgWithTwoByteAbsSendTimeExtension,
+                                sizeof(kRtpMsgWithTwoByteAbsSendTimeExtension),
+                                nullptr));
 }
 
 // Verify finding an extension ID in the TURN send indication message.
@@ -276,19 +284,21 @@ TEST(RtpUtilsTest, UpdateAbsSendTimeExtensionInTurnSendIndication) {
 // without HMAC value in the packet.
 TEST(RtpUtilsTest, ApplyPacketOptionsWithDefaultValues) {
   rtc::PacketTimeUpdateParams packet_time_params;
-  std::vector<uint8_t> rtp_packet(kRtpMsgWithAbsSendTimeExtension,
-                                  kRtpMsgWithAbsSendTimeExtension +
-                                      sizeof(kRtpMsgWithAbsSendTimeExtension));
+  std::vector<uint8_t> rtp_packet(
+      kRtpMsgWithOneByteAbsSendTimeExtension,
+      kRtpMsgWithOneByteAbsSendTimeExtension +
+          sizeof(kRtpMsgWithOneByteAbsSendTimeExtension));
   rtp_packet.insert(rtp_packet.end(), kFakeTag, kFakeTag + sizeof(kFakeTag));
   EXPECT_TRUE(ApplyPacketOptions(&rtp_packet[0], rtp_packet.size(),
                                  packet_time_params, 0));
 
   // Making sure HMAC wasn't updated..
-  EXPECT_EQ(0, memcmp(&rtp_packet[sizeof(kRtpMsgWithAbsSendTimeExtension)],
-                      kFakeTag, 4));
+  EXPECT_EQ(0,
+            memcmp(&rtp_packet[sizeof(kRtpMsgWithOneByteAbsSendTimeExtension)],
+                   kFakeTag, 4));
 
   // Verify AbsouluteSendTime extension field wasn't modified.
-  EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInRtpMsg], kTestAstValue,
+  EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInOneByteRtpMsg], kTestAstValue,
                       sizeof(kTestAstValue)));
 }
 
@@ -299,34 +309,53 @@ TEST(RtpUtilsTest, ApplyPacketOptionsWithAuthParams) {
                                           kTestKey + sizeof(kTestKey));
   packet_time_params.srtp_auth_tag_len = 4;
 
-  std::vector<uint8_t> rtp_packet(kRtpMsgWithAbsSendTimeExtension,
-                                  kRtpMsgWithAbsSendTimeExtension +
-                                      sizeof(kRtpMsgWithAbsSendTimeExtension));
+  std::vector<uint8_t> rtp_packet(
+      kRtpMsgWithOneByteAbsSendTimeExtension,
+      kRtpMsgWithOneByteAbsSendTimeExtension +
+          sizeof(kRtpMsgWithOneByteAbsSendTimeExtension));
   rtp_packet.insert(rtp_packet.end(), kFakeTag, kFakeTag + sizeof(kFakeTag));
   EXPECT_TRUE(ApplyPacketOptions(&rtp_packet[0], rtp_packet.size(),
                                  packet_time_params, 0));
 
   uint8_t kExpectedTag[] = {0xc1, 0x7a, 0x8c, 0xa0};
-  EXPECT_EQ(0, memcmp(&rtp_packet[sizeof(kRtpMsgWithAbsSendTimeExtension)],
-                      kExpectedTag, sizeof(kExpectedTag)));
+  EXPECT_EQ(0,
+            memcmp(&rtp_packet[sizeof(kRtpMsgWithOneByteAbsSendTimeExtension)],
+                   kExpectedTag, sizeof(kExpectedTag)));
 
   // Verify AbsouluteSendTime extension field is not modified.
-  EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInRtpMsg], kTestAstValue,
+  EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInOneByteRtpMsg], kTestAstValue,
                       sizeof(kTestAstValue)));
 }
 
 // Verify finding an extension ID in a raw rtp message.
-TEST(RtpUtilsTest, UpdateAbsSendTimeExtensionInRtpPacket) {
-  std::vector<uint8_t> rtp_packet(kRtpMsgWithAbsSendTimeExtension,
-                                  kRtpMsgWithAbsSendTimeExtension +
-                                      sizeof(kRtpMsgWithAbsSendTimeExtension));
+TEST(RtpUtilsTest, UpdateOneByteAbsSendTimeExtensionInRtpPacket) {
+  std::vector<uint8_t> rtp_packet(
+      kRtpMsgWithOneByteAbsSendTimeExtension,
+      kRtpMsgWithOneByteAbsSendTimeExtension +
+          sizeof(kRtpMsgWithOneByteAbsSendTimeExtension));
+
+  EXPECT_TRUE(UpdateRtpAbsSendTimeExtension(&rtp_packet[0], rtp_packet.size(),
+                                            3, 51183266));
+
+  // Verify that the timestamp was updated.
+  const uint8_t kExpectedTimestamp[3] = {0xcc, 0xbb, 0xaa};
+  EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInOneByteRtpMsg], kExpectedTimestamp,
+                      sizeof(kExpectedTimestamp)));
+}
+
+// Verify finding an extension ID in a raw rtp message.
+TEST(RtpUtilsTest, UpdateTwoByteAbsSendTimeExtensionInRtpPacket) {
+  std::vector<uint8_t> rtp_packet(
+      kRtpMsgWithTwoByteAbsSendTimeExtension,
+      kRtpMsgWithTwoByteAbsSendTimeExtension +
+          sizeof(kRtpMsgWithTwoByteAbsSendTimeExtension));
 
   EXPECT_TRUE(UpdateRtpAbsSendTimeExtension(&rtp_packet[0], rtp_packet.size(),
                                             3, 51183266));
 
   // Verify that the timestamp was updated.
   const uint8_t kExpectedTimestamp[3] = {0xcc, 0xbb, 0xaa};
-  EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInRtpMsg], kExpectedTimestamp,
+  EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInTwoByteRtpMsg], kExpectedTimestamp,
                       sizeof(kExpectedTimestamp)));
 }
 
@@ -339,20 +368,22 @@ TEST(RtpUtilsTest, ApplyPacketOptionsWithAuthParamsAndAbsSendTime) {
   packet_time_params.rtp_sendtime_extension_id = 3;
   // 3 is also present in the test message.
 
-  std::vector<uint8_t> rtp_packet(kRtpMsgWithAbsSendTimeExtension,
-                                  kRtpMsgWithAbsSendTimeExtension +
-                                      sizeof(kRtpMsgWithAbsSendTimeExtension));
+  std::vector<uint8_t> rtp_packet(
+      kRtpMsgWithOneByteAbsSendTimeExtension,
+      kRtpMsgWithOneByteAbsSendTimeExtension +
+          sizeof(kRtpMsgWithOneByteAbsSendTimeExtension));
   rtp_packet.insert(rtp_packet.end(), kFakeTag, kFakeTag + sizeof(kFakeTag));
   EXPECT_TRUE(ApplyPacketOptions(&rtp_packet[0], rtp_packet.size(),
                                  packet_time_params, 51183266));
 
   const uint8_t kExpectedTag[] = {0x81, 0xd1, 0x2c, 0x0e};
-  EXPECT_EQ(0, memcmp(&rtp_packet[sizeof(kRtpMsgWithAbsSendTimeExtension)],
-                      kExpectedTag, sizeof(kExpectedTag)));
+  EXPECT_EQ(0,
+            memcmp(&rtp_packet[sizeof(kRtpMsgWithOneByteAbsSendTimeExtension)],
+                   kExpectedTag, sizeof(kExpectedTag)));
 
   // Verify that the timestamp was updated.
   const uint8_t kExpectedTimestamp[3] = {0xcc, 0xbb, 0xaa};
-  EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInRtpMsg], kExpectedTimestamp,
+  EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInOneByteRtpMsg], kExpectedTimestamp,
                       sizeof(kExpectedTimestamp)));
 }
 
diff --git a/chromium/third_party/webrtc/media/base/video_adapter.cc b/chromium/third_party/webrtc/media/base/video_adapter.cc
index 27b82646ac1..8ba91d7189f 100644
--- a/chromium/third_party/webrtc/media/base/video_adapter.cc
+++ b/chromium/third_party/webrtc/media/base/video_adapter.cc
@@ -145,8 +145,6 @@ VideoAdapter::VideoAdapter() : VideoAdapter(1) {}
 VideoAdapter::~VideoAdapter() {}
 
 bool VideoAdapter::KeepFrame(int64_t in_timestamp_ns) {
-  rtc::CritScope cs(&critical_section_);
-
   int max_fps = max_framerate_request_;
   if (max_fps_)
     max_fps = std::min(max_fps, *max_fps_);
diff --git a/chromium/third_party/webrtc/media/base/video_adapter.h b/chromium/third_party/webrtc/media/base/video_adapter.h
index 936cf8917ee..b7acf0e67cb 100644
--- a/chromium/third_party/webrtc/media/base/video_adapter.h
+++ b/chromium/third_party/webrtc/media/base/video_adapter.h
@@ -46,7 +46,8 @@ class VideoAdapter {
                             int* cropped_width,
                             int* cropped_height,
                             int* out_width,
-                            int* out_height);
+                            int* out_height)
+      RTC_LOCKS_EXCLUDED(critical_section_);
 
   // DEPRECATED. Please use OnOutputFormatRequest below.
   // TODO(asapersson): Remove this once it is no longer used.
@@ -57,7 +58,8 @@ class VideoAdapter {
   // maintain the input orientation, so it doesn't matter if e.g. 1280x720 or
   // 720x1280 is requested.
   // Note: Should be called from the source only.
-  void OnOutputFormatRequest(const absl::optional<VideoFormat>& format);
+  void OnOutputFormatRequest(const absl::optional<VideoFormat>& format)
+      RTC_LOCKS_EXCLUDED(critical_section_);
 
   // Requests output frame size and frame interval from |AdaptFrameResolution|.
   // |target_aspect_ratio|: The input frame size will be cropped to match the
@@ -70,7 +72,7 @@ class VideoAdapter {
   void OnOutputFormatRequest(
       const absl::optional<std::pair<int, int>>& target_aspect_ratio,
       const absl::optional<int>& max_pixel_count,
-      const absl::optional<int>& max_fps);
+      const absl::optional<int>& max_fps) RTC_LOCKS_EXCLUDED(critical_section_);
 
   // Same as above, but allows setting two different target aspect ratios
   // depending on incoming frame orientation. This gives more fine-grained
@@ -81,7 +83,7 @@ class VideoAdapter {
       const absl::optional<int>& max_landscape_pixel_count,
       const absl::optional<std::pair<int, int>>& target_portrait_aspect_ratio,
       const absl::optional<int>& max_portrait_pixel_count,
-      const absl::optional<int>& max_fps);
+      const absl::optional<int>& max_fps) RTC_LOCKS_EXCLUDED(critical_section_);
 
   // Requests the output frame size from |AdaptFrameResolution| to have as close
   // as possible to |sink_wants.target_pixel_count| pixels (if set)
@@ -93,18 +95,25 @@ class VideoAdapter {
   // The sink resolution alignment requirement is given by
   // |sink_wants.resolution_alignment|.
   // Note: Should be called from the sink only.
-  void OnSinkWants(const rtc::VideoSinkWants& sink_wants);
+  void OnSinkWants(const rtc::VideoSinkWants& sink_wants)
+      RTC_LOCKS_EXCLUDED(critical_section_);
 
  private:
   // Determine if frame should be dropped based on input fps and requested fps.
-  bool KeepFrame(int64_t in_timestamp_ns);
-
-  int frames_in_;         // Number of input frames.
-  int frames_out_;        // Number of output frames.
-  int frames_scaled_;     // Number of frames scaled.
-  int adaption_changes_;  // Number of changes in scale factor.
-  int previous_width_;    // Previous adapter output width.
-  int previous_height_;   // Previous adapter output height.
+  bool KeepFrame(int64_t in_timestamp_ns)
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(critical_section_);
+
+  int frames_in_ RTC_GUARDED_BY(critical_section_);  // Number of input frames.
+  int frames_out_
+      RTC_GUARDED_BY(critical_section_);  // Number of output frames.
+  int frames_scaled_
+      RTC_GUARDED_BY(critical_section_);  // Number of frames scaled.
+  int adaption_changes_
+      RTC_GUARDED_BY(critical_section_);  // Number of changes in scale factor.
+  int previous_width_
+      RTC_GUARDED_BY(critical_section_);  // Previous adapter output width.
+  int previous_height_
+      RTC_GUARDED_BY(critical_section_);  // Previous adapter output height.
   const bool variable_start_scale_factor_;
 
   // The fixed source resolution alignment requirement.
diff --git a/chromium/third_party/webrtc/media/base/vp9_profile.cc b/chromium/third_party/webrtc/media/base/vp9_profile.cc
index cfecc5e5450..abf2502fc80 100644
--- a/chromium/third_party/webrtc/media/base/vp9_profile.cc
+++ b/chromium/third_party/webrtc/media/base/vp9_profile.cc
@@ -24,6 +24,8 @@ std::string VP9ProfileToString(VP9Profile profile) {
   switch (profile) {
     case VP9Profile::kProfile0:
       return "0";
+    case VP9Profile::kProfile1:
+      return "1";
     case VP9Profile::kProfile2:
       return "2";
   }
@@ -38,6 +40,8 @@ absl::optional<VP9Profile> StringToVP9Profile(const std::string& str) {
   switch (i.value()) {
     case 0:
       return VP9Profile::kProfile0;
+    case 1:
+      return VP9Profile::kProfile1;
     case 2:
       return VP9Profile::kProfile2;
     default:
diff --git a/chromium/third_party/webrtc/media/base/vp9_profile.h b/chromium/third_party/webrtc/media/base/vp9_profile.h
index e2bbf190055..e47204fede4 100644
--- a/chromium/third_party/webrtc/media/base/vp9_profile.h
+++ b/chromium/third_party/webrtc/media/base/vp9_profile.h
@@ -24,6 +24,7 @@ extern RTC_EXPORT const char kVP9FmtpProfileId[];
 
 enum class VP9Profile {
   kProfile0,
+  kProfile1,
   kProfile2,
 };
 
diff --git a/chromium/third_party/webrtc/media/engine/fake_webrtc_call.cc b/chromium/third_party/webrtc/media/engine/fake_webrtc_call.cc
index 78d4ba41e03..cb62d9fc0a5 100644
--- a/chromium/third_party/webrtc/media/engine/fake_webrtc_call.cc
+++ b/chromium/third_party/webrtc/media/engine/fake_webrtc_call.cc
@@ -279,6 +279,14 @@ void FakeVideoSendStream::Stop() {
   sending_ = false;
 }
 
+void FakeVideoSendStream::AddAdaptationResource(
+    rtc::scoped_refptr<webrtc::Resource> resource) {}
+
+std::vector<rtc::scoped_refptr<webrtc::Resource>>
+FakeVideoSendStream::GetAdaptationResources() {
+  return {};
+}
+
 void FakeVideoSendStream::SetSource(
     rtc::VideoSourceInterface<webrtc::VideoFrame>* source,
     const webrtc::DegradationPreference& degradation_preference) {
@@ -570,6 +578,9 @@ void FakeCall::DestroyFlexfecReceiveStream(
   }
 }
 
+void FakeCall::AddAdaptationResource(
+    rtc::scoped_refptr<webrtc::Resource> resource) {}
+
 webrtc::PacketReceiver* FakeCall::Receiver() {
   return this;
 }
diff --git a/chromium/third_party/webrtc/media/engine/fake_webrtc_call.h b/chromium/third_party/webrtc/media/engine/fake_webrtc_call.h
index 4404dec5dfc..97eb49c897b 100644
--- a/chromium/third_party/webrtc/media/engine/fake_webrtc_call.h
+++ b/chromium/third_party/webrtc/media/engine/fake_webrtc_call.h
@@ -173,6 +173,10 @@ class FakeVideoSendStream final
       const std::vector<bool> active_layers) override;
   void Start() override;
   void Stop() override;
+  void AddAdaptationResource(
+      rtc::scoped_refptr<webrtc::Resource> resource) override;
+  std::vector<rtc::scoped_refptr<webrtc::Resource>> GetAdaptationResources()
+      override;
   void SetSource(
       rtc::VideoSourceInterface<webrtc::VideoFrame>* source,
       const webrtc::DegradationPreference& degradation_preference) override;
@@ -341,6 +345,9 @@ class FakeCall final : public webrtc::Call, public webrtc::PacketReceiver {
   void DestroyFlexfecReceiveStream(
       webrtc::FlexfecReceiveStream* receive_stream) override;
 
+  void AddAdaptationResource(
+      rtc::scoped_refptr<webrtc::Resource> resource) override;
+
   webrtc::PacketReceiver* Receiver() override;
 
   DeliveryStatus DeliverPacket(webrtc::MediaType media_type,
diff --git a/chromium/third_party/webrtc/media/engine/internal_decoder_factory.cc b/chromium/third_party/webrtc/media/engine/internal_decoder_factory.cc
index e68bb369b55..d512b731af4 100644
--- a/chromium/third_party/webrtc/media/engine/internal_decoder_factory.cc
+++ b/chromium/third_party/webrtc/media/engine/internal_decoder_factory.cc
@@ -44,7 +44,7 @@ std::vector<SdpVideoFormat> InternalDecoderFactory::GetSupportedFormats()
     const {
   std::vector<SdpVideoFormat> formats;
   formats.push_back(SdpVideoFormat(cricket::kVp8CodecName));
-  for (const SdpVideoFormat& format : SupportedVP9Codecs())
+  for (const SdpVideoFormat& format : SupportedVP9DecoderCodecs())
     formats.push_back(format);
   for (const SdpVideoFormat& h264_format : SupportedH264Codecs())
     formats.push_back(h264_format);
diff --git a/chromium/third_party/webrtc/media/engine/internal_decoder_factory_unittest.cc b/chromium/third_party/webrtc/media/engine/internal_decoder_factory_unittest.cc
index 705933d4395..61be5e72dfd 100644
--- a/chromium/third_party/webrtc/media/engine/internal_decoder_factory_unittest.cc
+++ b/chromium/third_party/webrtc/media/engine/internal_decoder_factory_unittest.cc
@@ -13,6 +13,7 @@
 #include "api/video_codecs/sdp_video_format.h"
 #include "api/video_codecs/video_decoder.h"
 #include "media/base/media_constants.h"
+#include "media/base/vp9_profile.h"
 #include "modules/video_coding/codecs/av1/libaom_av1_decoder.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
@@ -30,6 +31,26 @@ TEST(InternalDecoderFactory, TestVP8) {
   EXPECT_TRUE(decoder);
 }
 
+#ifdef RTC_ENABLE_VP9
+TEST(InternalDecoderFactory, TestVP9Profile0) {
+  InternalDecoderFactory factory;
+  std::unique_ptr<VideoDecoder> decoder =
+      factory.CreateVideoDecoder(SdpVideoFormat(
+          cricket::kVp9CodecName,
+          {{kVP9FmtpProfileId, VP9ProfileToString(VP9Profile::kProfile0)}}));
+  EXPECT_TRUE(decoder);
+}
+
+TEST(InternalDecoderFactory, TestVP9Profile1) {
+  InternalDecoderFactory factory;
+  std::unique_ptr<VideoDecoder> decoder =
+      factory.CreateVideoDecoder(SdpVideoFormat(
+          cricket::kVp9CodecName,
+          {{kVP9FmtpProfileId, VP9ProfileToString(VP9Profile::kProfile1)}}));
+  EXPECT_TRUE(decoder);
+}
+#endif  // RTC_ENABLE_VP9
+
 TEST(InternalDecoderFactory, Av1) {
   InternalDecoderFactory factory;
   if (kIsLibaomAv1DecoderSupported) {
diff --git a/chromium/third_party/webrtc/media/engine/payload_type_mapper.cc b/chromium/third_party/webrtc/media/engine/payload_type_mapper.cc
index fcacd448839..e9f863ca638 100644
--- a/chromium/third_party/webrtc/media/engine/payload_type_mapper.cc
+++ b/chromium/third_party/webrtc/media/engine/payload_type_mapper.cc
@@ -67,7 +67,6 @@ PayloadTypeMapper::PayloadTypeMapper()
            {{kIsacCodecName, 32000, 1}, 104},
            {{kCnCodecName, 16000, 1}, 105},
            {{kCnCodecName, 32000, 1}, 106},
-           {{kGoogleSctpDataCodecName, 0, 0}, kGoogleSctpDataCodecPlType},
            {{kOpusCodecName,
              48000,
              2,
diff --git a/chromium/third_party/webrtc/media/engine/payload_type_mapper_unittest.cc b/chromium/third_party/webrtc/media/engine/payload_type_mapper_unittest.cc
index c8b2234c25e..fa6864b48aa 100644
--- a/chromium/third_party/webrtc/media/engine/payload_type_mapper_unittest.cc
+++ b/chromium/third_party/webrtc/media/engine/payload_type_mapper_unittest.cc
@@ -52,7 +52,6 @@ TEST_F(PayloadTypeMapperTest, WebRTCPayloadTypes) {
     return mapper_.FindMappingFor({name, 0, 0});
   };
   EXPECT_EQ(kGoogleRtpDataCodecPlType, data_mapping(kGoogleRtpDataCodecName));
-  EXPECT_EQ(kGoogleSctpDataCodecPlType, data_mapping(kGoogleSctpDataCodecName));
 
   EXPECT_EQ(102, mapper_.FindMappingFor({kIlbcCodecName, 8000, 1}));
   EXPECT_EQ(103, mapper_.FindMappingFor({kIsacCodecName, 16000, 1}));
diff --git a/chromium/third_party/webrtc/media/engine/simulcast_encoder_adapter_unittest.cc b/chromium/third_party/webrtc/media/engine/simulcast_encoder_adapter_unittest.cc
index b467c49166c..075cb83ee93 100644
--- a/chromium/third_party/webrtc/media/engine/simulcast_encoder_adapter_unittest.cc
+++ b/chromium/third_party/webrtc/media/engine/simulcast_encoder_adapter_unittest.cc
@@ -199,8 +199,10 @@ class MockVideoEncoder : public VideoEncoder {
         video_format_("unknown"),
         callback_(nullptr) {}
 
-  MOCK_METHOD1(SetFecControllerOverride,
-               void(FecControllerOverride* fec_controller_override));
+  MOCK_METHOD(void,
+              SetFecControllerOverride,
+              (FecControllerOverride * fec_controller_override),
+              (override));
 
   // TODO(nisse): Valid overrides commented out, because the gmock
   // methods don't use any override declarations, and we want to avoid
@@ -212,10 +214,11 @@ class MockVideoEncoder : public VideoEncoder {
     return init_encode_return_value_;
   }
 
-  MOCK_METHOD2(
-      Encode,
-      int32_t(const VideoFrame& inputImage,
-              const std::vector<VideoFrameType>* frame_types) /* override */);
+  MOCK_METHOD(int32_t,
+              Encode,
+              (const VideoFrame& inputImage,
+               const std::vector<VideoFrameType>* frame_types),
+              (override));
 
   int32_t RegisterEncodeCompleteCallback(
       EncodedImageCallback* callback) override {
@@ -223,7 +226,7 @@ class MockVideoEncoder : public VideoEncoder {
     return 0;
   }
 
-  MOCK_METHOD0(Release, int32_t() /* override */);
+  MOCK_METHOD(int32_t, Release, (), (override));
 
   void SetRates(const RateControlParameters& parameters) {
     last_set_rates_ = parameters;
@@ -334,8 +337,7 @@ std::vector<SdpVideoFormat> MockVideoEncoderFactory::GetSupportedFormats()
 
 std::unique_ptr<VideoEncoder> MockVideoEncoderFactory::CreateVideoEncoder(
     const SdpVideoFormat& format) {
-  std::unique_ptr<MockVideoEncoder> encoder(
-      new ::testing::NiceMock<MockVideoEncoder>(this));
+  auto encoder = std::make_unique<::testing::NiceMock<MockVideoEncoder>>(this);
   encoder->set_init_encode_return_value(init_encode_return_value_);
   const char* encoder_name = encoder_names_.empty()
                                  ? "codec_implementation_name"
diff --git a/chromium/third_party/webrtc/media/engine/webrtc_video_engine.cc b/chromium/third_party/webrtc/media/engine/webrtc_video_engine.cc
index 3976a6a1c50..a7eff62b16c 100644
--- a/chromium/third_party/webrtc/media/engine/webrtc_video_engine.cc
+++ b/chromium/third_party/webrtc/media/engine/webrtc_video_engine.cc
@@ -20,7 +20,6 @@
 #include "absl/algorithm/container.h"
 #include "absl/strings/match.h"
 #include "api/media_stream_interface.h"
-#include "api/transport/datagram_transport_interface.h"
 #include "api/units/data_rate.h"
 #include "api/video/video_codec_constants.h"
 #include "api/video/video_codec_type.h"
@@ -609,7 +608,6 @@ WebRtcVideoEngine::GetRtpHeaderExtensions() const {
         webrtc::RtpExtension::kPlayoutDelayUri,
         webrtc::RtpExtension::kVideoContentTypeUri,
         webrtc::RtpExtension::kVideoTimingUri,
-        webrtc::RtpExtension::kFrameMarkingUri,
         webrtc::RtpExtension::kColorSpaceUri, webrtc::RtpExtension::kMidUri,
         webrtc::RtpExtension::kRidUri, webrtc::RtpExtension::kRepairedRidUri}) {
     result.emplace_back(uri, id++, webrtc::RtpTransceiverDirection::kSendRecv);
@@ -1299,13 +1297,6 @@ bool WebRtcVideoChannel::AddSendStream(const StreamParams& sp) {
   config.rtp.extmap_allow_mixed = ExtmapAllowMixed();
   config.rtcp_report_interval_ms = video_config_.rtcp_report_interval_ms;
 
-  // If sending through Datagram Transport, limit packet size to maximum
-  // packet size supported by datagram_transport.
-  if (media_transport_config().rtp_max_packet_size) {
-    config.rtp.max_packet_size =
-        media_transport_config().rtp_max_packet_size.value();
-  }
-
   WebRtcVideoSendStream* stream = new WebRtcVideoSendStream(
       call_, sp, std::move(config), default_send_options_,
       video_config_.enable_cpu_adaptation, bitrate_config_.max_bitrate_bps,
@@ -1759,11 +1750,9 @@ void WebRtcVideoChannel::OnNetworkRouteChanged(
       network_route.packet_overhead);
 }
 
-void WebRtcVideoChannel::SetInterface(
-    NetworkInterface* iface,
-    const webrtc::MediaTransportConfig& media_transport_config) {
+void WebRtcVideoChannel::SetInterface(NetworkInterface* iface) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
-  MediaChannel::SetInterface(iface, media_transport_config);
+  MediaChannel::SetInterface(iface);
   // Set the RTP recv/send buffer to a bigger size.
 
   // The group should be a positive integer with an explicit size, in
diff --git a/chromium/third_party/webrtc/media/engine/webrtc_video_engine.h b/chromium/third_party/webrtc/media/engine/webrtc_video_engine.h
index 00d249541a3..126abfd2905 100644
--- a/chromium/third_party/webrtc/media/engine/webrtc_video_engine.h
+++ b/chromium/third_party/webrtc/media/engine/webrtc_video_engine.h
@@ -169,9 +169,7 @@ class WebRtcVideoChannel : public VideoMediaChannel,
   void OnReadyToSend(bool ready) override;
   void OnNetworkRouteChanged(const std::string& transport_name,
                              const rtc::NetworkRoute& network_route) override;
-  void SetInterface(
-      NetworkInterface* iface,
-      const webrtc::MediaTransportConfig& media_transport_config) override;
+  void SetInterface(NetworkInterface* iface) override;
 
   // E2E Encrypted Video Frame API
   // Set a frame decryptor to a particular ssrc that will intercept all
diff --git a/chromium/third_party/webrtc/media/engine/webrtc_video_engine_unittest.cc b/chromium/third_party/webrtc/media/engine/webrtc_video_engine_unittest.cc
index ae6f15d8af4..eae83938d4f 100644
--- a/chromium/third_party/webrtc/media/engine/webrtc_video_engine_unittest.cc
+++ b/chromium/third_party/webrtc/media/engine/webrtc_video_engine_unittest.cc
@@ -28,7 +28,6 @@
 #include "api/test/mock_video_encoder_factory.h"
 #include "api/test/video/function_video_decoder_factory.h"
 #include "api/transport/field_trial_based_config.h"
-#include "api/transport/media/media_transport_config.h"
 #include "api/units/time_delta.h"
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
 #include "api/video/i420_buffer.h"
@@ -209,11 +208,15 @@ int GetMaxDefaultBitrateBps(size_t width, size_t height) {
 
 class MockVideoSource : public rtc::VideoSourceInterface<webrtc::VideoFrame> {
  public:
-  MOCK_METHOD2(AddOrUpdateSink,
-               void(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
-                    const rtc::VideoSinkWants& wants));
-  MOCK_METHOD1(RemoveSink,
-               void(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink));
+  MOCK_METHOD(void,
+              AddOrUpdateSink,
+              (rtc::VideoSinkInterface<webrtc::VideoFrame> * sink,
+               const rtc::VideoSinkWants& wants),
+              (override));
+  MOCK_METHOD(void,
+              RemoveSink,
+              (rtc::VideoSinkInterface<webrtc::VideoFrame> * sink),
+              (override));
 };
 
 }  // namespace
@@ -343,10 +346,6 @@ TEST_F(WebRtcVideoEngineTest, SupportsVideoTimingHeaderExtension) {
   ExpectRtpCapabilitySupport(RtpExtension::kVideoTimingUri, true);
 }
 
-TEST_F(WebRtcVideoEngineTest, SupportsFrameMarkingHeaderExtension) {
-  ExpectRtpCapabilitySupport(RtpExtension::kFrameMarkingUri, true);
-}
-
 TEST_F(WebRtcVideoEngineTest, SupportsColorSpaceHeaderExtension) {
   ExpectRtpCapabilitySupport(RtpExtension::kColorSpaceUri, true);
 }
@@ -1335,7 +1334,7 @@ class WebRtcVideoChannelEncodedFrameCallbackTest : public ::testing::Test {
                 webrtc::CryptoOptions(),
                 video_bitrate_allocator_factory_.get())))) {
     network_interface_.SetDestination(channel_.get());
-    channel_->SetInterface(&network_interface_, webrtc::MediaTransportConfig());
+    channel_->SetInterface(&network_interface_);
     cricket::VideoRecvParameters parameters;
     parameters.codecs = engine_.recv_codecs();
     channel_->SetRecvParameters(parameters);
@@ -1481,7 +1480,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
     channel_->OnReadyToSend(true);
     EXPECT_TRUE(channel_.get() != NULL);
     network_interface_.SetDestination(channel_.get());
-    channel_->SetInterface(&network_interface_, webrtc::MediaTransportConfig());
+    channel_->SetInterface(&network_interface_);
     cricket::VideoRecvParameters parameters;
     parameters.codecs = engine_.send_codecs();
     channel_->SetRecvParameters(parameters);
@@ -5064,8 +5063,7 @@ TEST_F(WebRtcVideoChannelTest, TestSetDscpOptions) {
       static_cast<cricket::WebRtcVideoChannel*>(engine_.CreateMediaChannel(
           call_.get(), config, VideoOptions(), webrtc::CryptoOptions(),
           video_bitrate_allocator_factory_.get())));
-  channel->SetInterface(network_interface.get(),
-                        webrtc::MediaTransportConfig());
+  channel->SetInterface(network_interface.get());
   // Default value when DSCP is disabled should be DSCP_DEFAULT.
   EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
 
@@ -5076,8 +5074,7 @@ TEST_F(WebRtcVideoChannelTest, TestSetDscpOptions) {
       static_cast<cricket::WebRtcVideoChannel*>(engine_.CreateMediaChannel(
           call_.get(), config, VideoOptions(), webrtc::CryptoOptions(),
           video_bitrate_allocator_factory_.get())));
-  channel->SetInterface(network_interface.get(),
-                        webrtc::MediaTransportConfig());
+  channel->SetInterface(network_interface.get());
   EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
 
   // Create a send stream to configure
@@ -5106,8 +5103,7 @@ TEST_F(WebRtcVideoChannelTest, TestSetDscpOptions) {
       static_cast<cricket::WebRtcVideoChannel*>(engine_.CreateMediaChannel(
           call_.get(), config, VideoOptions(), webrtc::CryptoOptions(),
           video_bitrate_allocator_factory_.get())));
-  channel->SetInterface(network_interface.get(),
-                        webrtc::MediaTransportConfig());
+  channel->SetInterface(network_interface.get());
   EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
 }
 
diff --git a/chromium/third_party/webrtc/media/engine/webrtc_voice_engine.cc b/chromium/third_party/webrtc/media/engine/webrtc_voice_engine.cc
index 85c72804c15..38dc3462ace 100644
--- a/chromium/third_party/webrtc/media/engine/webrtc_voice_engine.cc
+++ b/chromium/third_party/webrtc/media/engine/webrtc_voice_engine.cc
@@ -36,7 +36,9 @@
 #include "rtc_base/constructor_magic.h"
 #include "rtc_base/experiments/field_trial_parser.h"
 #include "rtc_base/experiments/field_trial_units.h"
+#include "rtc_base/experiments/struct_parameters_parser.h"
 #include "rtc_base/helpers.h"
+#include "rtc_base/ignore_wundef.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/race_checker.h"
 #include "rtc_base/strings/audio_format_to_string.h"
@@ -46,6 +48,16 @@
 #include "system_wrappers/include/field_trial.h"
 #include "system_wrappers/include/metrics.h"
 
+#if WEBRTC_ENABLE_PROTOBUF
+RTC_PUSH_IGNORING_WUNDEF()
+#ifdef WEBRTC_ANDROID_PLATFORM_BUILD
+#include "external/webrtc/webrtc/modules/audio_coding/audio_network_adaptor/config.pb.h"
+#else
+#include "modules/audio_coding/audio_network_adaptor/config.pb.h"
+#endif
+RTC_POP_IGNORING_WUNDEF()
+#endif
+
 namespace cricket {
 namespace {
 
@@ -99,6 +111,12 @@ std::string ToString(const AudioCodec& codec) {
   return ss.Release();
 }
 
+// If this field trial is enabled, we will negotiate and use RFC 2198
+// redundancy for opus audio.
+bool IsAudioRedForOpusFieldTrialEnabled() {
+  return webrtc::field_trial::IsEnabled("WebRTC-Audio-Red-For-Opus");
+}
+
 bool IsCodec(const AudioCodec& codec, const char* ref_name) {
   return absl::EqualsIgnoreCase(codec.name, ref_name);
 }
@@ -185,6 +203,38 @@ absl::optional<int> ComputeSendBitrate(int max_send_bitrate_bps,
   }
 }
 
+struct AdaptivePtimeConfig {
+  bool enabled = false;
+  webrtc::DataRate min_payload_bitrate = webrtc::DataRate::KilobitsPerSec(16);
+  webrtc::DataRate min_encoder_bitrate = webrtc::DataRate::KilobitsPerSec(12);
+  bool use_slow_adaptation = true;
+
+  absl::optional<std::string> audio_network_adaptor_config;
+
+  std::unique_ptr<webrtc::StructParametersParser> Parser() {
+    return webrtc::StructParametersParser::Create(    //
+        "enabled", &enabled,                          //
+        "min_payload_bitrate", &min_payload_bitrate,  //
+        "min_encoder_bitrate", &min_encoder_bitrate,  //
+        "use_slow_adaptation", &use_slow_adaptation);
+  }
+
+  AdaptivePtimeConfig() {
+    Parser()->Parse(
+        webrtc::field_trial::FindFullName("WebRTC-Audio-AdaptivePtime"));
+#if WEBRTC_ENABLE_PROTOBUF
+    webrtc::audio_network_adaptor::config::ControllerManager config;
+    auto* frame_length_controller =
+        config.add_controllers()->mutable_frame_length_controller_v2();
+    frame_length_controller->set_min_payload_bitrate_bps(
+        min_payload_bitrate.bps());
+    frame_length_controller->set_use_slow_adaptation(use_slow_adaptation);
+    config.add_controllers()->mutable_bitrate_controller();
+    audio_network_adaptor_config = config.SerializeAsString();
+#endif
+  }
+};
+
 }  // namespace
 
 WebRtcVoiceEngine::WebRtcVoiceEngine(
@@ -682,6 +732,11 @@ std::vector<AudioCodec> WebRtcVoiceEngine::CollectCodecs(
     }
   }
 
+  // Add red codec.
+  if (IsAudioRedForOpusFieldTrialEnabled()) {
+    map_format({kRedCodecName, 48000, 2}, &out);
+  }
+
   // Add telephone-event codecs last.
   for (const auto& dtmf : generate_dtmf) {
     if (dtmf.second) {
@@ -726,7 +781,6 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     config_.rtp.extensions = extensions;
     config_.has_dscp =
         rtp_parameters_.encodings[0].network_priority != webrtc::Priority::kLow;
-    config_.audio_network_adaptor_config = audio_network_adaptor_config;
     config_.encoder_factory = encoder_factory;
     config_.codec_pair_id = codec_pair_id;
     config_.track_id = track_id;
@@ -737,6 +791,9 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     rtp_parameters_.rtcp.cname = c_name;
     rtp_parameters_.header_extensions = extensions;
 
+    audio_network_adaptor_config_from_options_ = audio_network_adaptor_config;
+    UpdateAudioNetworkAdaptorConfig();
+
     if (send_codec_spec) {
       UpdateSendCodecSpec(*send_codec_spec);
     }
@@ -787,10 +844,12 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
   void SetAudioNetworkAdaptorConfig(
       const absl::optional<std::string>& audio_network_adaptor_config) {
     RTC_DCHECK(worker_thread_checker_.IsCurrent());
-    if (config_.audio_network_adaptor_config == audio_network_adaptor_config) {
+    if (audio_network_adaptor_config_from_options_ ==
+        audio_network_adaptor_config) {
       return;
     }
-    config_.audio_network_adaptor_config = audio_network_adaptor_config;
+    audio_network_adaptor_config_from_options_ = audio_network_adaptor_config;
+    UpdateAudioNetworkAdaptorConfig();
     UpdateAllowedBitrateRange();
     ReconfigureAudioSendStream();
   }
@@ -937,6 +996,7 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
         rtp_parameters_.encodings[0].max_bitrate_bps;
     double old_priority = rtp_parameters_.encodings[0].bitrate_priority;
     webrtc::Priority old_dscp = rtp_parameters_.encodings[0].network_priority;
+    bool old_adaptive_ptime = rtp_parameters_.encodings[0].adaptive_ptime;
     rtp_parameters_ = parameters;
     config_.bitrate_priority = rtp_parameters_.encodings[0].bitrate_priority;
     config_.has_dscp = (rtp_parameters_.encodings[0].network_priority !=
@@ -945,15 +1005,19 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     bool reconfigure_send_stream =
         (rtp_parameters_.encodings[0].max_bitrate_bps != old_rtp_max_bitrate) ||
         (rtp_parameters_.encodings[0].bitrate_priority != old_priority) ||
-        (rtp_parameters_.encodings[0].network_priority != old_dscp);
+        (rtp_parameters_.encodings[0].network_priority != old_dscp) ||
+        (rtp_parameters_.encodings[0].adaptive_ptime != old_adaptive_ptime);
     if (rtp_parameters_.encodings[0].max_bitrate_bps != old_rtp_max_bitrate) {
       // Update the bitrate range.
       if (send_rate) {
         config_.send_codec_spec->target_bitrate_bps = send_rate;
       }
-      UpdateAllowedBitrateRange();
     }
     if (reconfigure_send_stream) {
+      // Changing adaptive_ptime may update the audio network adaptor config
+      // used.
+      UpdateAudioNetworkAdaptorConfig();
+      UpdateAllowedBitrateRange();
       ReconfigureAudioSendStream();
     }
 
@@ -989,6 +1053,7 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     // The order of precedence, from lowest to highest is:
     // - a reasonable default of 32kbps min/max
     // - fixed target bitrate from codec spec
+    // - lower min bitrate if adaptive ptime is enabled
     // - bitrate configured in the rtp_parameter encodings settings
     const int kDefaultBitrateBps = 32000;
     config_.min_bitrate_bps = kDefaultBitrateBps;
@@ -1000,6 +1065,12 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
       config_.max_bitrate_bps = *config_.send_codec_spec->target_bitrate_bps;
     }
 
+    if (rtp_parameters_.encodings[0].adaptive_ptime) {
+      config_.min_bitrate_bps = std::min(
+          config_.min_bitrate_bps,
+          static_cast<int>(adaptive_ptime_config_.min_encoder_bitrate.bps()));
+    }
+
     if (rtp_parameters_.encodings[0].min_bitrate_bps) {
       config_.min_bitrate_bps = *rtp_parameters_.encodings[0].min_bitrate_bps;
     }
@@ -1033,12 +1104,24 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     UpdateAllowedBitrateRange();
   }
 
+  void UpdateAudioNetworkAdaptorConfig() {
+    if (adaptive_ptime_config_.enabled ||
+        rtp_parameters_.encodings[0].adaptive_ptime) {
+      config_.audio_network_adaptor_config =
+          adaptive_ptime_config_.audio_network_adaptor_config;
+      return;
+    }
+    config_.audio_network_adaptor_config =
+        audio_network_adaptor_config_from_options_;
+  }
+
   void ReconfigureAudioSendStream() {
     RTC_DCHECK(worker_thread_checker_.IsCurrent());
     RTC_DCHECK(stream_);
     stream_->Reconfigure(config_);
   }
 
+  const AdaptivePtimeConfig adaptive_ptime_config_;
   rtc::ThreadChecker worker_thread_checker_;
   rtc::RaceChecker audio_capture_race_checker_;
   webrtc::Call* call_ = nullptr;
@@ -1056,6 +1139,9 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
   int max_send_bitrate_bps_;
   webrtc::RtpParameters rtp_parameters_;
   absl::optional<webrtc::AudioCodecSpec> audio_codec_spec_;
+  // TODO(webrtc:11717): Remove this once audio_network_adaptor in AudioOptions
+  // has been removed.
+  absl::optional<std::string> audio_network_adaptor_config_from_options_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcAudioSendStream);
 };
@@ -1541,7 +1627,9 @@ bool WebRtcVoiceMediaChannel::SetRecvCodecs(
                           << old_codec.id << ")";
     }
     auto format = AudioCodecToSdpAudioFormat(codec);
-    if (!IsCodec(codec, "cn") && !IsCodec(codec, "telephone-event") &&
+    if (!IsCodec(codec, kCnCodecName) && !IsCodec(codec, kDtmfCodecName) &&
+        (!IsAudioRedForOpusFieldTrialEnabled() ||
+         !IsCodec(codec, kRedCodecName)) &&
         !engine()->decoder_factory_->IsSupportedDecoder(format)) {
       RTC_LOG(LS_ERROR) << "Unsupported codec: " << rtc::ToString(format);
       return false;
@@ -1692,6 +1780,19 @@ bool WebRtcVoiceMediaChannel::SetSendCodecs(
     }
   }
 
+  if (IsAudioRedForOpusFieldTrialEnabled()) {
+    // Loop through the codecs to find the RED codec that matches opus
+    // with respect to clockrate and number of channels.
+    for (const AudioCodec& red_codec : codecs) {
+      if (IsCodec(red_codec, kRedCodecName) &&
+          red_codec.clockrate == send_codec_spec->format.clockrate_hz &&
+          red_codec.channels == send_codec_spec->format.num_channels) {
+        send_codec_spec->red_payload_type = red_codec.id;
+        break;
+      }
+    }
+  }
+
   if (send_codec_spec_ != send_codec_spec) {
     send_codec_spec_ = std::move(send_codec_spec);
     // Apply new settings to all streams.
diff --git a/chromium/third_party/webrtc/media/engine/webrtc_voice_engine_unittest.cc b/chromium/third_party/webrtc/media/engine/webrtc_voice_engine_unittest.cc
index e7ebf8940f8..d70019e9f34 100644
--- a/chromium/third_party/webrtc/media/engine/webrtc_voice_engine_unittest.cc
+++ b/chromium/third_party/webrtc/media/engine/webrtc_voice_engine_unittest.cc
@@ -59,6 +59,7 @@ const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1);
 const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1);
 const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1);
 const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1);
+const cricket::AudioCodec kRed48000Codec(112, "RED", 48000, 32000, 2);
 const cricket::AudioCodec kTelephoneEventCodec1(106,
                                                 "telephone-event",
                                                 8000,
@@ -1031,6 +1032,30 @@ TEST_P(WebRtcVoiceEngineTestFake, ChangeRecvCodecPayloadType) {
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 }
 
+// Test that we set Opus/Red under the field trial.
+TEST_P(WebRtcVoiceEngineTestFake, RecvRed) {
+  webrtc::test::ScopedFieldTrials override_field_trials(
+      "WebRTC-Audio-Red-For-Opus/Enabled/");
+
+  EXPECT_TRUE(SetupRecvStream());
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs.push_back(kRed48000Codec);
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
+  EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map,
+              (ContainerEq<std::map<int, webrtc::SdpAudioFormat>>(
+                  {{111, {"opus", 48000, 2}}, {112, {"red", 48000, 2}}})));
+}
+
+// Test that we do not allow setting Opus/Red by default.
+TEST_P(WebRtcVoiceEngineTestFake, RecvRedDefault) {
+  EXPECT_TRUE(SetupRecvStream());
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs.push_back(kRed48000Codec);
+  EXPECT_FALSE(channel_->SetRecvParameters(parameters));
+}
+
 TEST_P(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) {
   EXPECT_TRUE(SetupSendStream());
 
@@ -1194,6 +1219,46 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRtpParametersEncodingsActive) {
   EXPECT_TRUE(GetSendStream(kSsrcX).IsSending());
 }
 
+TEST_P(WebRtcVoiceEngineTestFake, SetRtpParametersAdaptivePtime) {
+  EXPECT_TRUE(SetupSendStream());
+  // Get current parameters and change "adaptive_ptime" to true.
+  webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrcX);
+  ASSERT_EQ(1u, parameters.encodings.size());
+  ASSERT_FALSE(parameters.encodings[0].adaptive_ptime);
+  parameters.encodings[0].adaptive_ptime = true;
+  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrcX, parameters).ok());
+  EXPECT_TRUE(GetAudioNetworkAdaptorConfig(kSsrcX));
+  EXPECT_EQ(12000, GetSendStreamConfig(kSsrcX).min_bitrate_bps);
+
+  parameters.encodings[0].adaptive_ptime = false;
+  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrcX, parameters).ok());
+  EXPECT_FALSE(GetAudioNetworkAdaptorConfig(kSsrcX));
+  EXPECT_EQ(32000, GetSendStreamConfig(kSsrcX).min_bitrate_bps);
+}
+
+TEST_P(WebRtcVoiceEngineTestFake,
+       DisablingAdaptivePtimeDoesNotRemoveAudioNetworkAdaptorFromOptions) {
+  EXPECT_TRUE(SetupSendStream());
+  send_parameters_.options.audio_network_adaptor = true;
+  send_parameters_.options.audio_network_adaptor_config = {"1234"};
+  SetSendParameters(send_parameters_);
+  EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
+            GetAudioNetworkAdaptorConfig(kSsrcX));
+
+  webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrcX);
+  parameters.encodings[0].adaptive_ptime = false;
+  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrcX, parameters).ok());
+  EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
+            GetAudioNetworkAdaptorConfig(kSsrcX));
+}
+
+TEST_P(WebRtcVoiceEngineTestFake, AdaptivePtimeFieldTrial) {
+  webrtc::test::ScopedFieldTrials override_field_trials(
+      "WebRTC-Audio-AdaptivePtime/enabled:true/");
+  EXPECT_TRUE(SetupSendStream());
+  EXPECT_TRUE(GetAudioNetworkAdaptorConfig(kSsrcX));
+}
+
 // Test that SetRtpSendParameters configures the correct encoding channel for
 // each SSRC.
 TEST_P(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) {
@@ -1442,6 +1507,37 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecs) {
   EXPECT_FALSE(channel_->CanInsertDtmf());
 }
 
+// Test that we set Opus/Red under the field trial.
+TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRed) {
+  webrtc::test::ScopedFieldTrials override_field_trials(
+      "WebRTC-Audio-Red-For-Opus/Enabled/");
+
+  EXPECT_TRUE(SetupSendStream());
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs.push_back(kRed48000Codec);
+  parameters.codecs[0].id = 96;
+  SetSendParameters(parameters);
+  const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
+  EXPECT_EQ(96, send_codec_spec.payload_type);
+  EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str());
+  EXPECT_EQ(112, send_codec_spec.red_payload_type);
+}
+
+// Test that we set do not interpret Opus/Red by default.
+TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedDefault) {
+  EXPECT_TRUE(SetupSendStream());
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs.push_back(kRed48000Codec);
+  parameters.codecs[0].id = 96;
+  SetSendParameters(parameters);
+  const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
+  EXPECT_EQ(96, send_codec_spec.payload_type);
+  EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str());
+  EXPECT_EQ(absl::nullopt, send_codec_spec.red_payload_type);
+}
+
 // Test that WebRtcVoiceEngine reconfigures, rather than recreates its
 // AudioSendStream.
 TEST_P(WebRtcVoiceEngineTestFake, DontRecreateSendStream) {
@@ -2046,6 +2142,10 @@ class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake {
       : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {}
 };
 
+INSTANTIATE_TEST_SUITE_P(UnusedParameter,
+                         WebRtcVoiceEngineWithSendSideBweTest,
+                         ::testing::Values(true));
+
 TEST_P(WebRtcVoiceEngineWithSendSideBweTest,
        SupportsTransportSequenceNumberHeaderExtension) {
   const std::vector<webrtc::RtpExtension> header_extensions =
@@ -3098,7 +3198,7 @@ TEST_P(WebRtcVoiceEngineTestFake, TestSetDscpOptions) {
   channel.reset(static_cast<cricket::WebRtcVoiceMediaChannel*>(
       engine_->CreateMediaChannel(&call_, config, cricket::AudioOptions(),
                                   webrtc::CryptoOptions())));
-  channel->SetInterface(&network_interface, webrtc::MediaTransportConfig());
+  channel->SetInterface(&network_interface);
   // Default value when DSCP is disabled should be DSCP_DEFAULT.
   EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp());
 
@@ -3106,7 +3206,7 @@ TEST_P(WebRtcVoiceEngineTestFake, TestSetDscpOptions) {
   channel.reset(static_cast<cricket::WebRtcVoiceMediaChannel*>(
       engine_->CreateMediaChannel(&call_, config, cricket::AudioOptions(),
                                   webrtc::CryptoOptions())));
-  channel->SetInterface(&network_interface, webrtc::MediaTransportConfig());
+  channel->SetInterface(&network_interface);
   EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp());
 
   // Create a send stream to configure
@@ -3134,11 +3234,11 @@ TEST_P(WebRtcVoiceEngineTestFake, TestSetDscpOptions) {
   channel.reset(static_cast<cricket::WebRtcVoiceMediaChannel*>(
       engine_->CreateMediaChannel(&call_, config, cricket::AudioOptions(),
                                   webrtc::CryptoOptions())));
-  channel->SetInterface(&network_interface, webrtc::MediaTransportConfig());
+  channel->SetInterface(&network_interface);
   // Default value when DSCP is disabled should be DSCP_DEFAULT.
   EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp());
 
-  channel->SetInterface(nullptr, webrtc::MediaTransportConfig());
+  channel->SetInterface(nullptr);
 }
 
 TEST_P(WebRtcVoiceEngineTestFake, SetOutputVolume) {
diff --git a/chromium/third_party/webrtc/media/sctp/sctp_transport.cc b/chromium/third_party/webrtc/media/sctp/sctp_transport.cc
index ad68c37ac97..5b434109eec 100644
--- a/chromium/third_party/webrtc/media/sctp/sctp_transport.cc
+++ b/chromium/third_party/webrtc/media/sctp/sctp_transport.cc
@@ -269,6 +269,11 @@ class SctpTransport::UsrSctpWrapper {
     // TODO(ldixon): Consider turning this on/off.
     usrsctp_sysctl_set_sctp_ecn_enable(0);
 
+    // WebRTC doesn't use these features, so disable them to reduce the
+    // potential attack surface.
+    usrsctp_sysctl_set_sctp_asconf_enable(0);
+    usrsctp_sysctl_set_sctp_auth_enable(0);
+
     // This is harmless, but we should find out when the library default
     // changes.
     int send_size = usrsctp_sysctl_get_sctp_sendspace();
@@ -1263,6 +1268,9 @@ void SctpTransport::OnNotificationAssocChange(const sctp_assoc_change& change) {
       max_outbound_streams_ = change.sac_outbound_streams;
       max_inbound_streams_ = change.sac_inbound_streams;
       SignalAssociationChangeCommunicationUp();
+      // In case someone tried to close a stream before communication
+      // came up, send any queued resets.
+      SendQueuedStreamResets();
       break;
     case SCTP_COMM_LOST:
       RTC_LOG(LS_INFO) << "Association change SCTP_COMM_LOST";
diff --git a/chromium/third_party/webrtc/media/sctp/sctp_transport_unittest.cc b/chromium/third_party/webrtc/media/sctp/sctp_transport_unittest.cc
index ff3f2d70a98..da6c6290fd3 100644
--- a/chromium/third_party/webrtc/media/sctp/sctp_transport_unittest.cc
+++ b/chromium/third_party/webrtc/media/sctp/sctp_transport_unittest.cc
@@ -605,6 +605,15 @@ TEST_F(SctpTransportTest, ClosesRemoteStream) {
   transport1()->ResetStream(1);
   EXPECT_TRUE_WAIT(transport2_observer.WasStreamClosed(1), kDefaultTimeout);
 }
+TEST_F(SctpTransportTest, ClosesRemoteStreamWithNoData) {
+  SetupConnectedTransportsWithTwoStreams();
+  SctpTransportObserver transport1_observer(transport1());
+  SctpTransportObserver transport2_observer(transport2());
+
+  // Close stream 1 on transport 1. Transport 2 should notify us.
+  transport1()->ResetStream(1);
+  EXPECT_TRUE_WAIT(transport2_observer.WasStreamClosed(1), kDefaultTimeout);
+}
 
 TEST_F(SctpTransportTest, ClosesTwoRemoteStreams) {
   SetupConnectedTransportsWithTwoStreams();